Extend pg_cast castimplicit column to a three-way value; this allows us

to be flexible about assignment casts without introducing ambiguity in
operator/function resolution.  Introduce a well-defined promotion hierarchy
for numeric datatypes (int2->int4->int8->numeric->float4->float8).
Change make_const to initially label numeric literals as int4, int8, or
numeric (never float8 anymore).
Explicitly mark Func and RelabelType nodes to indicate whether they came
from a function call, explicit cast, or implicit cast; use this to do
reverse-listing more accurately and without so many heuristics.
Explicit casts to char, varchar, bit, varbit will truncate or pad without
raising an error (the pre-7.2 behavior), while assigning to a column without
any explicit cast will still raise an error for wrong-length data like 7.3.
This more nearly follows the SQL spec than 7.2 behavior (we should be
reporting a 'completion condition' in the explicit-cast cases, but we have
no mechanism for that, so just do silent truncation).
Fix some problems with enforcement of typmod for array elements;
it didn't work at all in 'UPDATE ... SET array[n] = foo', for example.
Provide a generalized array_length_coerce() function to replace the
specialized per-array-type functions that used to be needed (and were
missing for NUMERIC as well as all the datetime types).
Add missing conversions int8<->float4, text<->numeric, oid<->int8.
initdb forced.

src/backend/catalog/heap.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/catalog/heap.c,v 1.226 2002/09/14 22:14:49 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/catalog/heap.c,v 1.227 2002/09/18 21:35:20 tgl Exp $
  *
  *
  * INTERFACE ROUTINES
@@ -51,7 +51,6 @@
 #include "parser/parse_coerce.h"
 #include "parser/parse_expr.h"
 #include "parser/parse_relation.h"
-#include "parser/parse_target.h"
 #include "rewrite/rewriteRemove.h"
 #include "storage/smgr.h"
 #include "utils/builtins.h"
@@ -1705,17 +1704,16 @@ cookDefault(ParseState *pstate,
 	{
 		Oid			type_id = exprType(expr);
 
-		if (type_id != atttypid)
-		{
-			if (CoerceTargetExpr(pstate, expr, type_id,
-								 atttypid, atttypmod, false) == NULL)
-				elog(ERROR, "Column \"%s\" is of type %s"
-					 " but default expression is of type %s"
-				   "\n\tYou will need to rewrite or cast the expression",
-					 attname,
-					 format_type_be(atttypid),
-					 format_type_be(type_id));
-		}
+		if (coerce_to_target_type(expr, type_id,
+								  atttypid, atttypmod,
+								  COERCION_ASSIGNMENT,
+								  COERCE_IMPLICIT_CAST) == NULL)
+			elog(ERROR, "Column \"%s\" is of type %s"
+				 " but default expression is of type %s"
+				 "\n\tYou will need to rewrite or cast the expression",
+				 attname,
+				 format_type_be(atttypid),
+				 format_type_be(type_id));
 	}
 
 	/*

src/backend/catalog/pg_aggregate.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/catalog/pg_aggregate.c,v 1.55 2002/09/04 20:31:14 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/catalog/pg_aggregate.c,v 1.56 2002/09/18 21:35:20 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -95,7 +95,7 @@ AggregateCreate(const char *aggName,
 	 */
 	if (proc->proisstrict && agginitval == NULL)
 	{
-		if (!IsBinaryCompatible(aggBaseType, aggTransType))
+		if (!IsBinaryCoercible(aggBaseType, aggTransType))
 			elog(ERROR, "must not omit initval when transfn is strict and transtype is not compatible with input type");
 	}
 	ReleaseSysCache(tup);

src/backend/catalog/pg_proc.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/catalog/pg_proc.c,v 1.93 2002/09/04 20:31:14 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/catalog/pg_proc.c,v 1.94 2002/09/18 21:35:20 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -369,7 +369,7 @@ checkretval(Oid rettype, char fn_typtype, List *queryTreeList)
 				 format_type_be(rettype));
 
 		restype = ((TargetEntry *) lfirst(tlist))->resdom->restype;
-		if (!IsBinaryCompatible(restype, rettype))
+		if (!IsBinaryCoercible(restype, rettype))
 			elog(ERROR, "return type mismatch in function: declared to return %s, returns %s",
 				 format_type_be(rettype), format_type_be(restype));
 	}
@@ -388,7 +388,7 @@ checkretval(Oid rettype, char fn_typtype, List *queryTreeList)
 		if (tlistlen == 1)
 		{
 			restype = ((TargetEntry *) lfirst(tlist))->resdom->restype;
-			if (IsBinaryCompatible(restype, rettype))
+			if (IsBinaryCoercible(restype, rettype))
 				return;
 		}
 
@@ -426,7 +426,7 @@ checkretval(Oid rettype, char fn_typtype, List *queryTreeList)
 
 			tletype = exprType(tle->expr);
 			atttype = attr->atttypid;
-			if (!IsBinaryCompatible(tletype, atttype))
+			if (!IsBinaryCoercible(tletype, atttype))
 				elog(ERROR, "function declared to return %s returns %s instead of %s at column %d",
 					 format_type_be(rettype),
 					 format_type_be(tletype),

src/backend/commands/functioncmds.c

@@ -9,7 +9,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/commands/functioncmds.c,v 1.20 2002/09/15 13:04:16 petere Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/commands/functioncmds.c,v 1.21 2002/09/18 21:35:20 tgl Exp $
  *
  * DESCRIPTION
  *	  These routines take the parse tree and pick out the
@@ -601,14 +601,11 @@ CreateCast(CreateCastStmt *stmt)
 	Oid			sourcetypeid;
 	Oid			targettypeid;
 	Oid			funcid;
-	HeapTuple	tuple;
+	char		castcontext;
 	Relation	relation;
-	Form_pg_proc procstruct;
-
-	Datum		values[Natts_pg_proc];
-	char		nulls[Natts_pg_proc];
-	int			i;
-
+	HeapTuple	tuple;
+	Datum		values[Natts_pg_cast];
+	char		nulls[Natts_pg_cast];
 	ObjectAddress myself,
 				referenced;
 
@@ -648,24 +645,17 @@ CreateCast(CreateCastStmt *stmt)
 			 TypeNameToString(stmt->sourcetype),
 			 TypeNameToString(stmt->targettype));
 
-	relation = heap_openr(CastRelationName, RowExclusiveLock);
-
-	tuple = SearchSysCache(CASTSOURCETARGET,
-						   ObjectIdGetDatum(sourcetypeid),
-						   ObjectIdGetDatum(targettypeid),
-						   0, 0);
-	if (HeapTupleIsValid(tuple))
-		elog(ERROR, "cast from data type %s to data type %s already exists",
-			 TypeNameToString(stmt->sourcetype),
-			 TypeNameToString(stmt->targettype));
-
 	if (stmt->func != NULL)
 	{
+		Form_pg_proc procstruct;
+
 		funcid = LookupFuncNameTypeNames(stmt->func->funcname,
 										 stmt->func->funcargs,
 										 "CreateCast");
 
-		tuple = SearchSysCache(PROCOID, ObjectIdGetDatum(funcid), 0, 0, 0);
+		tuple = SearchSysCache(PROCOID,
+							   ObjectIdGetDatum(funcid),
+							   0, 0, 0);
 		if (!HeapTupleIsValid(tuple))
 			elog(ERROR, "cache lookup of function %u failed", funcid);
 
@@ -687,18 +677,51 @@ CreateCast(CreateCastStmt *stmt)
 	}
 	else
 	{
-		/* indicates binary compatibility */
+		/* indicates binary coercibility */
 		funcid = InvalidOid;
 	}
 
+	/* convert CoercionContext enum to char value for castcontext */
+	switch (stmt->context)
+	{
+		case COERCION_IMPLICIT:
+			castcontext = COERCION_CODE_IMPLICIT;
+			break;
+		case COERCION_ASSIGNMENT:
+			castcontext = COERCION_CODE_ASSIGNMENT;
+			break;
+		case COERCION_EXPLICIT:
+			castcontext = COERCION_CODE_EXPLICIT;
+			break;
+		default:
+			elog(ERROR, "CreateCast: bogus CoercionContext %c", stmt->context);
+			castcontext = 0;	/* keep compiler quiet */
+			break;
+	}
+
+	relation = heap_openr(CastRelationName, RowExclusiveLock);
+
+	/*
+	 * Check for duplicate.  This is just to give a friendly error message,
+	 * the unique index would catch it anyway (so no need to sweat about
+	 * race conditions).
+	 */
+	tuple = SearchSysCache(CASTSOURCETARGET,
+						   ObjectIdGetDatum(sourcetypeid),
+						   ObjectIdGetDatum(targettypeid),
+						   0, 0);
+	if (HeapTupleIsValid(tuple))
+		elog(ERROR, "cast from data type %s to data type %s already exists",
+			 TypeNameToString(stmt->sourcetype),
+			 TypeNameToString(stmt->targettype));
+
 	/* ready to go */
 	values[Anum_pg_cast_castsource - 1] = ObjectIdGetDatum(sourcetypeid);
 	values[Anum_pg_cast_casttarget - 1] = ObjectIdGetDatum(targettypeid);
 	values[Anum_pg_cast_castfunc - 1] = ObjectIdGetDatum(funcid);
-	values[Anum_pg_cast_castimplicit - 1] = BoolGetDatum(stmt->implicit);
+	values[Anum_pg_cast_castcontext - 1] = CharGetDatum(castcontext);
 
-	for (i = 0; i < Natts_pg_cast; ++i)
-		nulls[i] = ' ';
+	MemSet(nulls, ' ', Natts_pg_cast);
 
 	tuple = heap_formtuple(RelationGetDescr(relation), values, nulls);
 
@@ -706,6 +729,7 @@ CreateCast(CreateCastStmt *stmt)
 
 	CatalogUpdateIndexes(relation, tuple);
 
+	/* make dependency entries */
 	myself.classId = RelationGetRelid(relation);
 	myself.objectId = HeapTupleGetOid(tuple);
 	myself.objectSubId = 0;
@@ -732,6 +756,7 @@ CreateCast(CreateCastStmt *stmt)
 	}
 
 	heap_freetuple(tuple);
+
 	heap_close(relation, RowExclusiveLock);
 }
 

src/backend/commands/indexcmds.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/commands/indexcmds.c,v 1.87 2002/09/04 20:31:15 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/commands/indexcmds.c,v 1.88 2002/09/18 21:35:20 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -335,8 +335,8 @@ FuncIndexArgs(IndexInfo *indexInfo,
 
 	for (i = 0; i < nargs; i++)
 	{
-		if (!IsBinaryCompatible(argTypes[i], true_typeids[i]))
-			func_error("DefineIndex", funcIndex->funcname, nargs, argTypes,
+		if (!IsBinaryCoercible(argTypes[i], true_typeids[i]))
+			func_error("DefineIndex", funcIndex->funcname, nargs, true_typeids,
 					   "Index function must be binary-compatible with table datatype");
 	}
 
@@ -464,7 +464,7 @@ GetAttrOpClass(IndexElem *attribute, Oid attrType,
 	opClassId = HeapTupleGetOid(tuple);
 	opInputType = ((Form_pg_opclass) GETSTRUCT(tuple))->opcintype;
 
-	if (!IsBinaryCompatible(attrType, opInputType))
+	if (!IsBinaryCoercible(attrType, opInputType))
 		elog(ERROR, "operator class \"%s\" does not accept data type %s",
 		 NameListToString(attribute->opclass), format_type_be(attrType));
 
@@ -508,7 +508,7 @@ GetDefaultOpClass(Oid attrType, Oid accessMethodId)
 				nexact++;
 				exactOid = opclass->oid;
 			}
-			else if (IsBinaryCompatible(opclass->opcintype, attrType))
+			else if (IsBinaryCoercible(attrType, opclass->opcintype))
 			{
 				ncompatible++;
 				compatibleOid = opclass->oid;

src/backend/executor/nodeAgg.c

@@ -46,7 +46,7 @@
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/executor/nodeAgg.c,v 1.86 2002/09/04 20:31:18 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/executor/nodeAgg.c,v 1.87 2002/09/18 21:35:20 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -913,7 +913,7 @@ ExecInitAgg(Agg *node, EState *estate, Plan *parent)
 			 */
 			Oid			inputType = exprType(aggref->target);
 
-			if (!IsBinaryCompatible(inputType, aggform->aggtranstype))
+			if (!IsBinaryCoercible(inputType, aggform->aggtranstype))
 				elog(ERROR, "Aggregate %u needs to have compatible input type and transition type",
 					 aggref->aggfnoid);
 		}

src/backend/nodes/copyfuncs.c

@@ -15,7 +15,7 @@
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/nodes/copyfuncs.c,v 1.211 2002/09/04 20:31:19 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/nodes/copyfuncs.c,v 1.212 2002/09/18 21:35:20 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -850,6 +850,7 @@ _copyFunc(Func *from)
 	newnode->funcid = from->funcid;
 	newnode->funcresulttype = from->funcresulttype;
 	newnode->funcretset = from->funcretset;
+	newnode->funcformat = from->funcformat;
 	/* Do not copy the run-time state, if any */
 	newnode->func_fcache = NULL;
 
@@ -931,6 +932,7 @@ _copyRelabelType(RelabelType *from)
 	Node_Copy(from, newnode, arg);
 	newnode->resulttype = from->resulttype;
 	newnode->resulttypmod = from->resulttypmod;
+	newnode->relabelformat = from->relabelformat;
 
 	return newnode;
 }
@@ -2634,7 +2636,7 @@ _copyCreateCastStmt(CreateCastStmt *from)
 	Node_Copy(from, newnode, sourcetype);
 	Node_Copy(from, newnode, targettype);
 	Node_Copy(from, newnode, func);
-	newnode->implicit = from->implicit;
+	newnode->context = from->context;
 
 	return newnode;
 }

src/backend/nodes/equalfuncs.c

@@ -20,7 +20,7 @@
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/nodes/equalfuncs.c,v 1.158 2002/09/02 02:13:01 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/nodes/equalfuncs.c,v 1.159 2002/09/18 21:35:20 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -217,6 +217,15 @@ _equalFunc(Func *a, Func *b)
 		return false;
 	if (a->funcretset != b->funcretset)
 		return false;
+	/*
+	 * Special-case COERCE_DONTCARE, so that pathkeys can build coercion
+	 * nodes that are equal() to both explicit and implicit coercions.
+	 */
+	if (a->funcformat != b->funcformat &&
+		a->funcformat != COERCE_DONTCARE &&
+		b->funcformat != COERCE_DONTCARE)
+		return false;
+
 	/* Note we do not look at func_fcache; see notes for _equalOper */
 
 	return true;
@@ -302,6 +311,14 @@ _equalRelabelType(RelabelType *a, RelabelType *b)
 		return false;
 	if (a->resulttypmod != b->resulttypmod)
 		return false;
+	/*
+	 * Special-case COERCE_DONTCARE, so that pathkeys can build coercion
+	 * nodes that are equal() to both explicit and implicit coercions.
+	 */
+	if (a->relabelformat != b->relabelformat &&
+		a->relabelformat != COERCE_DONTCARE &&
+		b->relabelformat != COERCE_DONTCARE)
+		return false;
 	return true;
 }
 
@@ -1475,7 +1492,7 @@ _equalCreateCastStmt(CreateCastStmt *a, CreateCastStmt *b)
 		return false;
 	if (!equal(a->func, b->func))
 		return false;
-	if (a->implicit != b->implicit)
+	if (a->context != b->context)
 		return false;
 
 	return true;

src/backend/nodes/makefuncs.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/nodes/makefuncs.c,v 1.34 2002/09/04 20:31:19 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/nodes/makefuncs.c,v 1.35 2002/09/18 21:35:21 tgl Exp $
  */
 #include "postgres.h"
 
@@ -215,13 +215,14 @@ makeAlias(const char *aliasname, List *colnames)
  *	  creates a RelabelType node
  */
 RelabelType *
-makeRelabelType(Node *arg, Oid rtype, int32 rtypmod)
+makeRelabelType(Node *arg, Oid rtype, int32 rtypmod, CoercionForm rformat)
 {
 	RelabelType *r = makeNode(RelabelType);
 
 	r->arg = arg;
 	r->resulttype = rtype;
 	r->resulttypmod = rtypmod;
+	r->relabelformat = rformat;
 
 	return r;
 }

src/backend/nodes/outfuncs.c

@@ -5,7 +5,7 @@
  * Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- *	$Header: /cvsroot/pgsql/src/backend/nodes/outfuncs.c,v 1.173 2002/09/04 20:31:19 momjian Exp $
+ *	$Header: /cvsroot/pgsql/src/backend/nodes/outfuncs.c,v 1.174 2002/09/18 21:35:21 tgl Exp $
  *
  * NOTES
  *	  Every (plan) node in POSTGRES has an associated "out" routine which
@@ -860,10 +860,11 @@ static void
 _outFunc(StringInfo str, Func *node)
 {
 	appendStringInfo(str,
-				   " FUNC :funcid %u :funcresulttype %u :funcretset %s ",
+		" FUNC :funcid %u :funcresulttype %u :funcretset %s :funcformat %d ",
 					 node->funcid,
 					 node->funcresulttype,
-					 booltostr(node->funcretset));
+					 booltostr(node->funcretset),
+					 (int) node->funcformat);
 }
 
 /*
@@ -914,9 +915,11 @@ _outRelabelType(StringInfo str, RelabelType *node)
 {
 	appendStringInfo(str, " RELABELTYPE :arg ");
 	_outNode(str, node->arg);
-
-	appendStringInfo(str, " :resulttype %u :resulttypmod %d ",
-					 node->resulttype, node->resulttypmod);
+	appendStringInfo(str,
+					 " :resulttype %u :resulttypmod %d :relabelformat %d ",
+					 node->resulttype,
+					 node->resulttypmod,
+					 (int) node->relabelformat);
 }
 
 /*

src/backend/nodes/readfuncs.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/nodes/readfuncs.c,v 1.132 2002/09/04 20:31:20 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/nodes/readfuncs.c,v 1.133 2002/09/18 21:35:21 tgl Exp $
  *
  * NOTES
  *	  Most of the read functions for plan nodes are tested. (In fact, they
@@ -1129,6 +1129,10 @@ _readFunc(void)
 	token = pg_strtok(&length); /* now read it */
 	local_node->funcretset = strtobool(token);
 
+	token = pg_strtok(&length); /* get :funcformat */
+	token = pg_strtok(&length); /* now read it */
+	local_node->funcformat = (CoercionForm) atoi(token);
+
 	local_node->func_fcache = NULL;
 
 	return local_node;
@@ -1335,6 +1339,10 @@ _readRelabelType(void)
 	token = pg_strtok(&length); /* get resulttypmod */
 	local_node->resulttypmod = atoi(token);
 
+	token = pg_strtok(&length); /* eat :relabelformat */
+	token = pg_strtok(&length); /* get relabelformat */
+	local_node->relabelformat = (CoercionForm) atoi(token);
+
 	return local_node;
 }
 

src/backend/optimizer/path/indxpath.c

@@ -9,7 +9,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/optimizer/path/indxpath.c,v 1.122 2002/09/04 20:31:20 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/optimizer/path/indxpath.c,v 1.123 2002/09/18 21:35:21 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -825,32 +825,15 @@ match_clause_to_indexkey(RelOptInfo *rel,
  * is whether the operator has a commutator operator that matches
  * the index's opclass.
  *
- * We try both the straightforward match and matches that rely on
- * recognizing binary-compatible datatypes.  For example, if we have
- * an expression like "oid = 123", the operator will be oideqint4,
- * which we need to replace with oideq in order to recognize it as
- * matching an oid_ops index on the oid field.	A variant case is where
- * the expression is like "oid::int4 = 123", where the given operator
- * will be int4eq and again we need to intuit that we want to use oideq.
- *
  * Returns the OID of the matching operator, or InvalidOid if no match.
- * Note that the returned OID will be different from the one in the given
- * expression if we used a binary-compatible substitution.	Also note that
- * if indexkey_on_left is FALSE (meaning we need to commute), the returned
- * OID is *not* commuted; it can be plugged directly into the given clause.
+ * (Formerly, this routine might return a binary-compatible operator
+ * rather than the original one, but that kluge is history.)
  */
 Oid
 indexable_operator(Expr *clause, Oid opclass, bool indexkey_on_left)
 {
 	Oid			expr_op = ((Oper *) clause->oper)->opno;
-	Oid			commuted_op,
-				new_op;
-	Operator	oldoptup;
-	Form_pg_operator oldopform;
-	char	   *opname;
-	Oid			ltype,
-				rtype,
-				indexkeytype;
+	Oid			commuted_op;
 
 	/* Get the commuted operator if necessary */
 	if (indexkey_on_left)
@@ -860,83 +843,10 @@ indexable_operator(Expr *clause, Oid opclass, bool indexkey_on_left)
 	if (commuted_op == InvalidOid)
 		return InvalidOid;
 
-	/* Done if the (commuted) operator is a member of the index's opclass */
+	/* OK if the (commuted) operator is a member of the index's opclass */
 	if (op_in_opclass(commuted_op, opclass))
 		return expr_op;
 
-	/*
-	 * Maybe the index uses a binary-compatible operator set.
-	 *
-	 * Get the nominal input types of the given operator and the actual type
-	 * (before binary-compatible relabeling) of the index key.
-	 */
-	oldoptup = SearchSysCache(OPEROID,
-							  ObjectIdGetDatum(expr_op),
-							  0, 0, 0);
-	if (!HeapTupleIsValid(oldoptup))
-		return InvalidOid;		/* probably can't happen */
-	oldopform = (Form_pg_operator) GETSTRUCT(oldoptup);
-	opname = pstrdup(NameStr(oldopform->oprname));
-	ltype = oldopform->oprleft;
-	rtype = oldopform->oprright;
-	ReleaseSysCache(oldoptup);
-
-	if (indexkey_on_left)
-	{
-		Node	   *leftop = (Node *) get_leftop(clause);
-
-		if (leftop && IsA(leftop, RelabelType))
-			leftop = ((RelabelType *) leftop)->arg;
-		indexkeytype = exprType(leftop);
-	}
-	else
-	{
-		Node	   *rightop = (Node *) get_rightop(clause);
-
-		if (rightop && IsA(rightop, RelabelType))
-			rightop = ((RelabelType *) rightop)->arg;
-		indexkeytype = exprType(rightop);
-	}
-
-	/*
-	 * Make sure we have different but binary-compatible types.
-	 */
-	if (ltype == indexkeytype && rtype == indexkeytype)
-		return InvalidOid;		/* no chance for a different operator */
-	if (!IsBinaryCompatible(ltype, indexkeytype))
-		return InvalidOid;
-	if (!IsBinaryCompatible(rtype, indexkeytype))
-		return InvalidOid;
-
-	/*
-	 * OK, look for operator of the same name with the indexkey's data
-	 * type. (In theory this might find a non-semantically-comparable
-	 * operator, but in practice that seems pretty unlikely for
-	 * binary-compatible types.)
-	 */
-	new_op = compatible_oper_opid(makeList1(makeString(opname)),
-								  indexkeytype, indexkeytype, true);
-
-	if (OidIsValid(new_op))
-	{
-		if (new_op != expr_op)
-		{
-			/*
-			 * OK, we found a binary-compatible operator of the same name;
-			 * now does it match the index?
-			 */
-			if (indexkey_on_left)
-				commuted_op = new_op;
-			else
-				commuted_op = get_commutator(new_op);
-			if (commuted_op == InvalidOid)
-				return InvalidOid;
-
-			if (op_in_opclass(commuted_op, opclass))
-				return new_op;
-		}
-	}
-
 	return InvalidOid;
 }
 

src/backend/optimizer/path/pathkeys.c

@@ -11,7 +11,7 @@
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/optimizer/path/pathkeys.c,v 1.40 2002/09/04 20:31:20 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/optimizer/path/pathkeys.c,v 1.41 2002/09/18 21:35:21 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -520,6 +520,7 @@ build_index_pathkeys(Query *root,
 		funcnode->funcid = index->indproc;
 		funcnode->funcresulttype = get_func_rettype(index->indproc);
 		funcnode->funcretset = false;	/* can never be a set */
+		funcnode->funcformat = COERCE_DONTCARE;	/* to match any user expr */
 		funcnode->func_fcache = NULL;
 
 		while (*indexkeys != 0)

src/backend/optimizer/plan/createplan.c

@@ -10,7 +10,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/optimizer/plan/createplan.c,v 1.118 2002/09/04 20:31:21 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/optimizer/plan/createplan.c,v 1.119 2002/09/18 21:35:21 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -1027,8 +1027,7 @@ fix_indxqual_sublist(List *indexqual, int baserelid, IndexOptInfo *index,
 		Expr	   *clause = (Expr *) lfirst(i);
 		Expr	   *newclause;
 		List	   *leftvarnos;
-		Oid			opclass,
-					newopno;
+		Oid			opclass;
 
 		if (!is_opclause((Node *) clause) || length(clause->args) != 2)
 			elog(ERROR, "fix_indxqual_sublist: indexqual clause is not binary opclause");
@@ -1061,23 +1060,13 @@ fix_indxqual_sublist(List *indexqual, int baserelid, IndexOptInfo *index,
 													   index,
 													   &opclass);
 
-		/*
-		 * Substitute the appropriate operator if the expression operator
-		 * is merely binary-compatible with the index.	This shouldn't
-		 * fail, since indxpath.c found it before...
-		 */
-		newopno = indexable_operator(newclause, opclass, true);
-		if (newopno == InvalidOid)
-			elog(ERROR, "fix_indxqual_sublist: failed to find substitute op");
-		((Oper *) newclause->oper)->opno = newopno;
-
 		fixed_qual = lappend(fixed_qual, newclause);
 
 		/*
 		 * Finally, check to see if index is lossy for this operator. If
 		 * so, add (a copy of) original form of clause to recheck list.
 		 */
-		if (op_requires_recheck(newopno, opclass))
+		if (op_requires_recheck(((Oper *) newclause->oper)->opno, opclass))
 			recheck_qual = lappend(recheck_qual,
 								   copyObject((Node *) clause));
 	}

src/backend/optimizer/prep/preptlist.c

@@ -15,7 +15,7 @@
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/optimizer/prep/preptlist.c,v 1.56 2002/09/04 20:31:22 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/optimizer/prep/preptlist.c,v 1.57 2002/09/18 21:35:21 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -187,8 +187,9 @@ expand_targetlist(List *tlist, int command_type,
 												  false,		/* not a set */
 												  false);
 					if (!att_tup->attisdropped)
-						new_expr = coerce_type_constraints(NULL, new_expr,
-														 atttype, false);
+						new_expr = coerce_type_constraints(new_expr,
+														   atttype,
+														   COERCE_IMPLICIT_CAST);
 					break;
 				case CMD_UPDATE:
 					/* Insert NULLs for dropped columns */

src/backend/optimizer/prep/prepunion.c

@@ -14,7 +14,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/optimizer/prep/prepunion.c,v 1.79 2002/09/11 14:48:55 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/optimizer/prep/prepunion.c,v 1.80 2002/09/18 21:35:21 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -420,8 +420,7 @@ generate_setop_tlist(List *colTypes, int flag,
 		}
 		else
 		{
-			expr = coerce_to_common_type(NULL,
-										 expr,
+			expr = coerce_to_common_type(expr,
 										 colType,
 										 "UNION/INTERSECT/EXCEPT");
 			colTypmod = -1;

src/backend/parser/analyze.c

@@ -6,7 +6,7 @@
  * Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- *	$Header: /cvsroot/pgsql/src/backend/parser/analyze.c,v 1.248 2002/09/04 20:31:22 momjian Exp $
+ *	$Header: /cvsroot/pgsql/src/backend/parser/analyze.c,v 1.249 2002/09/18 21:35:21 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -2565,24 +2565,20 @@ transformExecuteStmt(ParseState *pstate, ExecuteStmt *stmt)
 			given_type_id = exprType(expr);
 			expected_type_id = (Oid) lfirsti(paramtypes);
 
-			if (given_type_id != expected_type_id)
-			{
-				expr = CoerceTargetExpr(pstate,
-										expr,
-										given_type_id,
-										expected_type_id,
-										-1,
-										false);
+			expr = coerce_to_target_type(expr, given_type_id,
+										 expected_type_id, -1,
+										 COERCION_ASSIGNMENT,
+										 COERCE_IMPLICIT_CAST);
 
-				if (!expr)
-					elog(ERROR, "Parameter $%d of type %s cannot be coerced into the expected type %s"
-					"\n\tYou will need to rewrite or cast the expression",
-						 i,
-						 format_type_be(given_type_id),
-						 format_type_be(expected_type_id));
-			}
+			if (expr == NULL)
+				elog(ERROR, "Parameter $%d of type %s cannot be coerced into the expected type %s"
+					 "\n\tYou will need to rewrite or cast the expression",
+					 i,
+					 format_type_be(given_type_id),
+					 format_type_be(expected_type_id));
 
 			fix_opids(expr);
+
 			lfirst(l) = expr;
 
 			paramtypes = lnext(paramtypes);

src/backend/parser/gram.y

@@ -11,7 +11,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/parser/gram.y,v 2.366 2002/09/05 22:52:48 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/parser/gram.y,v 2.367 2002/09/18 21:35:21 tgl Exp $
  *
  * HISTORY
  *	  AUTHOR			DATE			MAJOR EVENT
@@ -161,8 +161,8 @@ static void doNegateFloat(Value *v);
 %type <list>	createdb_opt_list, copy_opt_list
 %type <defelt>	createdb_opt_item, copy_opt_item
 
-%type <ival>	opt_lock, lock_type
-%type <boolean>	opt_force, opt_or_replace, opt_assignment
+%type <ival>	opt_lock, lock_type, cast_context
+%type <boolean>	opt_force, opt_or_replace
 
 %type <list>	user_list
 
@@ -349,7 +349,7 @@ static void doNegateFloat(Value *v);
 
 	HANDLER, HAVING, HOUR_P,
 
-	ILIKE, IMMEDIATE, IMMUTABLE, IN_P, INCREMENT,
+	ILIKE, IMMEDIATE, IMMUTABLE, IMPLICIT_P, IN_P, INCREMENT,
 	INDEX, INHERITS, INITIALLY, INNER_P, INOUT, INPUT,
 	INSENSITIVE, INSERT, INSTEAD, INT, INTEGER, INTERSECT,
 	INTERVAL, INTO, INVOKER, IS, ISNULL, ISOLATION,
@@ -3230,29 +3230,30 @@ any_operator:
  *****************************************************************************/
 
 CreateCastStmt: CREATE CAST '(' ConstTypename AS ConstTypename ')'
-					WITH FUNCTION function_with_argtypes opt_assignment
+					WITH FUNCTION function_with_argtypes cast_context
 				{
 					CreateCastStmt *n = makeNode(CreateCastStmt);
 					n->sourcetype = $4;
 					n->targettype = $6;
 					n->func = (FuncWithArgs *) $10;
-					n->implicit = $11;
+					n->context = (CoercionContext) $11;
 					$$ = (Node *)n;
 				}
 			| CREATE CAST '(' ConstTypename AS ConstTypename ')'
-					WITHOUT FUNCTION opt_assignment
+					WITHOUT FUNCTION cast_context
 				{
 					CreateCastStmt *n = makeNode(CreateCastStmt);
 					n->sourcetype = $4;
 					n->targettype = $6;
 					n->func = NULL;
-					n->implicit = $10;
+					n->context = (CoercionContext) $10;
 					$$ = (Node *)n;
 				}
 		;
 
-opt_assignment:  AS ASSIGNMENT					{ $$ = TRUE; }
-		| /*EMPTY*/								{ $$ = FALSE; }
+cast_context:  AS IMPLICIT_P					{ $$ = COERCION_IMPLICIT; }
+		| AS ASSIGNMENT							{ $$ = COERCION_ASSIGNMENT; }
+		| /*EMPTY*/								{ $$ = COERCION_EXPLICIT; }
 		;
 
 
@@ -7061,6 +7062,7 @@ unreserved_keyword:
 			| HOUR_P
 			| IMMEDIATE
 			| IMMUTABLE
+			| IMPLICIT_P
 			| INCREMENT
 			| INDEX
 			| INHERITS

src/backend/parser/keywords.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/parser/keywords.c,v 1.126 2002/08/27 04:55:09 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/parser/keywords.c,v 1.127 2002/09/18 21:35:22 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -147,6 +147,7 @@ static const ScanKeyword ScanKeywords[] = {
 	{"ilike", ILIKE},
 	{"immediate", IMMEDIATE},
 	{"immutable", IMMUTABLE},
+	{"implicit", IMPLICIT_P},
 	{"in", IN_P},
 	{"increment", INCREMENT},
 	{"index", INDEX},

src/backend/parser/parse_clause.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/parser/parse_clause.c,v 1.97 2002/09/04 20:31:23 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/parser/parse_clause.c,v 1.98 2002/09/18 21:35:22 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -872,20 +872,24 @@ buildMergedJoinVar(JoinType jointype, Var *l_colvar, Var *r_colvar)
 	 * typmod is not same as input.
 	 */
 	if (l_colvar->vartype != outcoltype)
-		l_node = coerce_type(NULL, (Node *) l_colvar, l_colvar->vartype,
-							 outcoltype, outcoltypmod, false);
+		l_node = coerce_type((Node *) l_colvar, l_colvar->vartype,
+							 outcoltype,
+							 COERCION_IMPLICIT, COERCE_IMPLICIT_CAST);
 	else if (l_colvar->vartypmod != outcoltypmod)
 		l_node = (Node *) makeRelabelType((Node *) l_colvar,
-										  outcoltype, outcoltypmod);
+										  outcoltype, outcoltypmod,
+										  COERCE_IMPLICIT_CAST);
 	else
 		l_node = (Node *) l_colvar;
 
 	if (r_colvar->vartype != outcoltype)
-		r_node = coerce_type(NULL, (Node *) r_colvar, r_colvar->vartype,
-							 outcoltype, outcoltypmod, false);
+		r_node = coerce_type((Node *) r_colvar, r_colvar->vartype,
+							 outcoltype,
+							 COERCION_IMPLICIT, COERCE_IMPLICIT_CAST);
 	else if (r_colvar->vartypmod != outcoltypmod)
 		r_node = (Node *) makeRelabelType((Node *) r_colvar,
-										  outcoltype, outcoltypmod);
+										  outcoltype, outcoltypmod,
+										  COERCE_IMPLICIT_CAST);
 	else
 		r_node = (Node *) r_colvar;
 

src/backend/parser/parse_coerce.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/parser/parse_coerce.c,v 2.83 2002/09/04 20:31:23 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/parser/parse_coerce.c,v 2.84 2002/09/18 21:35:22 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -23,28 +23,104 @@
 #include "parser/parse_func.h"
 #include "parser/parse_type.h"
 #include "utils/builtins.h"
+#include "utils/fmgroids.h"
 #include "utils/lsyscache.h"
 #include "utils/syscache.h"
 
 
+static Node *coerce_type_typmod(Node *node,
+								Oid targetTypeId, int32 targetTypMod,
+								CoercionForm cformat);
 static Oid	PreferredType(CATEGORY category, Oid type);
 static bool find_coercion_pathway(Oid targetTypeId, Oid sourceTypeId,
-					  bool isExplicit,
-					  Oid *funcid);
-static Oid	find_typmod_coercion_function(Oid typeId);
-static Node *build_func_call(Oid funcid, Oid rettype, List *args);
+								  CoercionContext ccontext,
+								  Oid *funcid);
+static Node *build_func_call(Oid funcid, Oid rettype, List *args,
+							 CoercionForm fformat);
+
+
+/*
+ * coerce_to_target_type()
+ *		Convert an expression to a target type and typmod.
+ *
+ * This is the general-purpose entry point for arbitrary type coercion
+ * operations.  Direct use of the component operations can_coerce_type,
+ * coerce_type, and coerce_type_typmod should be restricted to special
+ * cases (eg, when the conversion is expected to succeed).
+ *
+ * Returns the possibly-transformed expression tree, or NULL if the type
+ * conversion is not possible.  (We do this, rather than elog'ing directly,
+ * so that callers can generate custom error messages indicating context.)
+ *
+ * expr - input expression tree (already transformed by transformExpr)
+ * exprtype - result type of expr
+ * targettype - desired result type
+ * targettypmod - desired result typmod
+ * ccontext, cformat - context indicators to control coercions
+ */
+Node *
+coerce_to_target_type(Node *expr, Oid exprtype,
+					  Oid targettype, int32 targettypmod,
+					  CoercionContext ccontext,
+					  CoercionForm cformat)
+{
+	if (can_coerce_type(1, &exprtype, &targettype, ccontext))
+		expr = coerce_type(expr, exprtype, targettype,
+						   ccontext, cformat);
+	/*
+	 * String hacks to get transparent conversions for char and varchar:
+	 * if a coercion to text is available, use it for forced coercions to
+	 * char(n) or varchar(n).
+	 *
+	 * This is pretty grotty, but seems easier to maintain than providing
+	 * entries in pg_cast that parallel all the ones for text.
+	 */
+	else if (ccontext >= COERCION_ASSIGNMENT &&
+			 (targettype == BPCHAROID || targettype == VARCHAROID))
+	{
+		Oid			text_id = TEXTOID;
+
+		if (can_coerce_type(1, &exprtype, &text_id, ccontext))
+		{
+			expr = coerce_type(expr, exprtype, text_id,
+							   ccontext, cformat);
+			/* Need a RelabelType if no typmod coercion is performed */
+			if (targettypmod < 0)
+				expr = (Node *) makeRelabelType(expr, targettype, -1,
+												cformat);
+		}
+		else
+			expr = NULL;
+	}
+	else
+		expr = NULL;
+
+	/*
+	 * If the target is a fixed-length type, it may need a length coercion
+	 * as well as a type coercion.
+	 */
+	if (expr != NULL)
+		expr = coerce_type_typmod(expr, targettype, targettypmod, cformat);
+
+	return expr;
+}
 
 
 /*
  * coerce_type()
- *		Convert a function argument to a different type.
+ *		Convert an expression to a different type.
  *
  * The caller should already have determined that the coercion is possible;
  * see can_coerce_type.
+ *
+ * No coercion to a typmod (length) is performed here.  The caller must
+ * call coerce_type_typmod as well, if a typmod constraint is wanted.
+ * (But if the target type is a domain, it may internally contain a
+ * typmod constraint, which will be applied inside coerce_type_constraints.)
  */
 Node *
-coerce_type(ParseState *pstate, Node *node, Oid inputTypeId,
-			Oid targetTypeId, int32 atttypmod, bool isExplicit)
+coerce_type(Node *node, Oid inputTypeId, Oid targetTypeId,
+			CoercionContext ccontext, CoercionForm cformat)
 {
 	Node	   *result;
 	Oid			funcId;
@@ -68,7 +144,7 @@ coerce_type(ParseState *pstate, Node *node, Oid inputTypeId,
 		 * example, int4's typinput function will reject "1.2", whereas
 		 * float-to-int type conversion will round to integer.
 		 *
-		 * XXX if the typinput function is not cachable, we really ought to
+		 * XXX if the typinput function is not immutable, we really ought to
 		 * postpone evaluation of the function call until runtime. But
 		 * there is no way to represent a typinput function call as an
 		 * expression tree, because C-string values are not Datums. (XXX
@@ -91,28 +167,31 @@ coerce_type(ParseState *pstate, Node *node, Oid inputTypeId,
 													   con->constvalue));
 
 			/*
-			 * If target is a domain, use the typmod it applies to the
-			 * base type.  Note that we call stringTypeDatum using the
-			 * domain's pg_type row, though.  This works because the
-			 * domain row has the same typinput and typelem as the base
-			 * type --- ugly...
+			 * We pass typmod -1 to the input routine, primarily because
+			 * existing input routines follow implicit-coercion semantics
+			 * for length checks, which is not always what we want here.
+			 * Any length constraint will be applied later by our caller.
+			 *
+			 * Note that we call stringTypeDatum using the domain's pg_type
+			 * row, if it's a domain.  This works because the domain row has
+			 * the same typinput and typelem as the base type --- ugly...
 			 */
-			if (targetTyptype == 'd')
-				atttypmod = getBaseTypeMod(targetTypeId, atttypmod);
-
-			newcon->constvalue = stringTypeDatum(targetType, val, atttypmod);
+			newcon->constvalue = stringTypeDatum(targetType, val, -1);
 			pfree(val);
 		}
 
 		result = (Node *) newcon;
 
-		/*
-		 * If target is a domain, apply constraints (except for typmod,
-		 * which we assume the input routine took care of).
-		 */
+		/* If target is a domain, apply constraints. */
 		if (targetTyptype == 'd')
-			result = coerce_type_constraints(pstate, result, targetTypeId,
-											 false);
+		{
+			result = coerce_type_constraints(result, targetTypeId,
+											 cformat);
+			/* We might now need a RelabelType. */
+			if (exprType(result) != targetTypeId)
+				result = (Node *) makeRelabelType(result, targetTypeId, -1,
+												  cformat);
+		}
 
 		ReleaseSysCache(targetType);
 	}
@@ -120,9 +199,10 @@ coerce_type(ParseState *pstate, Node *node, Oid inputTypeId,
 			 targetTypeId == ANYARRAYOID)
 	{
 		/* assume can_coerce_type verified that implicit coercion is okay */
+		/* NB: we do NOT want a RelabelType here */
 		result = node;
 	}
-	else if (find_coercion_pathway(targetTypeId, inputTypeId, isExplicit,
+	else if (find_coercion_pathway(targetTypeId, inputTypeId, ccontext,
 								   &funcId))
 	{
 		if (OidIsValid(funcId))
@@ -135,7 +215,8 @@ coerce_type(ParseState *pstate, Node *node, Oid inputTypeId,
 			 */
 			Oid			baseTypeId = getBaseType(targetTypeId);
 
-			result = build_func_call(funcId, baseTypeId, makeList1(node));
+			result = build_func_call(funcId, baseTypeId, makeList1(node),
+									 cformat);
 
 			/*
 			 * If domain, test against domain constraints and relabel with
@@ -143,9 +224,10 @@ coerce_type(ParseState *pstate, Node *node, Oid inputTypeId,
 			 */
 			if (targetTypeId != baseTypeId)
 			{
-				result = coerce_type_constraints(pstate, result,
-												 targetTypeId, true);
-				result = (Node *) makeRelabelType(result, targetTypeId, -1);
+				result = coerce_type_constraints(result, targetTypeId,
+												 cformat);
+				result = (Node *) makeRelabelType(result, targetTypeId, -1,
+												  cformat);
 			}
 
 			/*
@@ -179,8 +261,8 @@ coerce_type(ParseState *pstate, Node *node, Oid inputTypeId,
 			 * Also, domains may have value restrictions beyond the base type
 			 * that must be accounted for.
 			 */
-			result = coerce_type_constraints(pstate, node,
-											 targetTypeId, true);
+			result = coerce_type_constraints(node, targetTypeId,
+											 cformat);
 
 			/*
 			 * XXX could we label result with exprTypmod(node) instead of
@@ -189,7 +271,8 @@ coerce_type(ParseState *pstate, Node *node, Oid inputTypeId,
 			 * typmod, which is likely but not certain (wrong if target is
 			 * a domain, in any case).
 			 */
-			result = (Node *) makeRelabelType(result, targetTypeId, -1);
+			result = (Node *) makeRelabelType(result, targetTypeId, -1,
+											  cformat);
 		}
 	}
 	else if (typeInheritsFrom(inputTypeId, targetTypeId))
@@ -199,7 +282,8 @@ coerce_type(ParseState *pstate, Node *node, Oid inputTypeId,
 		 * except relabel the type.  This is binary compatibility for
 		 * complex types.
 		 */
-		result = (Node *) makeRelabelType(node, targetTypeId, -1);
+		result = (Node *) makeRelabelType(node, targetTypeId, -1,
+										  cformat);
 	}
 	else
 	{
@@ -215,15 +299,14 @@ coerce_type(ParseState *pstate, Node *node, Oid inputTypeId,
 
 /*
  * can_coerce_type()
- *		Can input_typeids be coerced to func_typeids?
+ *		Can input_typeids be coerced to target_typeids?
  *
- * We must be told whether this is an implicit or explicit coercion
- * (explicit being a CAST construct, explicit function call, etc).
- * We will accept a wider set of coercion cases for an explicit coercion.
+ * We must be told the context (CAST construct, assignment, implicit coercion)
+ * as this determines the set of available casts.
  */
 bool
-can_coerce_type(int nargs, Oid *input_typeids, Oid *func_typeids,
-				bool isExplicit)
+can_coerce_type(int nargs, Oid *input_typeids, Oid *target_typeids,
+				CoercionContext ccontext)
 {
 	int			i;
 
@@ -231,7 +314,7 @@ can_coerce_type(int nargs, Oid *input_typeids, Oid *func_typeids,
 	for (i = 0; i < nargs; i++)
 	{
 		Oid			inputTypeId = input_typeids[i];
-		Oid			targetTypeId = func_typeids[i];
+		Oid			targetTypeId = target_typeids[i];
 		Oid			funcId;
 
 		/* no problem if same type */
@@ -278,7 +361,7 @@ can_coerce_type(int nargs, Oid *input_typeids, Oid *func_typeids,
 
 			/*
 			 * Otherwise reject; this assumes there are no explicit
-			 * coercions to ANYARRAY.  If we don't reject then
+			 * coercion paths to ANYARRAY.  If we don't reject then
 			 * parse_coerce would have to repeat the above test.
 			 */
 			return false;
@@ -288,7 +371,7 @@ can_coerce_type(int nargs, Oid *input_typeids, Oid *func_typeids,
 		 * If pg_cast shows that we can coerce, accept.  This test now
 		 * covers both binary-compatible and coercion-function cases.
 		 */
-		if (find_coercion_pathway(targetTypeId, inputTypeId, isExplicit,
+		if (find_coercion_pathway(targetTypeId, inputTypeId, ccontext,
 								  &funcId))
 			continue;
 
@@ -312,10 +395,12 @@ can_coerce_type(int nargs, Oid *input_typeids, Oid *func_typeids,
  * Create an expression tree to enforce the constraints (if any)
  * that should be applied by the type.	Currently this is only
  * interesting for domain types.
+ *
+ * NOTE: result tree is not guaranteed to show the correct exprType() for
+ * the domain; it may show the base type.  Caller must relabel if needed.
  */
 Node *
-coerce_type_constraints(ParseState *pstate, Node *arg,
-						Oid typeId, bool applyTypmod)
+coerce_type_constraints(Node *arg, Oid typeId, CoercionForm cformat)
 {
 	char	   *notNull = NULL;
 	int32		typmod = -1;
@@ -356,8 +441,8 @@ coerce_type_constraints(ParseState *pstate, Node *arg,
 	/*
 	 * If domain applies a typmod to its base type, do length coercion.
 	 */
-	if (applyTypmod && typmod >= 0)
-		arg = coerce_type_typmod(pstate, arg, typeId, typmod);
+	if (typmod >= 0)
+		arg = coerce_type_typmod(arg, typeId, typmod, cformat);
 
 	/*
 	 * Only need to add one NOT NULL check regardless of how many domains
@@ -380,8 +465,9 @@ coerce_type_constraints(ParseState *pstate, Node *arg,
 }
 
 
-/* coerce_type_typmod()
- * Force a value to a particular typmod, if meaningful and possible.
+/*
+ * coerce_type_typmod()
+ *		Force a value to a particular typmod, if meaningful and possible.
  *
  * This is applied to values that are going to be stored in a relation
  * (where we have an atttypmod for the column) as well as values being
@@ -394,33 +480,65 @@ coerce_type_constraints(ParseState *pstate, Node *arg,
  * coercion for a domain is considered to be part of the type coercion
  * needed to produce the domain value in the first place.  So, no getBaseType.
  */
-Node *
-coerce_type_typmod(ParseState *pstate, Node *node,
-				   Oid targetTypeId, int32 atttypmod)
+static Node *
+coerce_type_typmod(Node *node, Oid targetTypeId, int32 targetTypMod,
+				   CoercionForm cformat)
 {
 	Oid			funcId;
+	int			nargs;
 
 	/*
 	 * A negative typmod is assumed to mean that no coercion is wanted.
 	 */
-	if (atttypmod < 0 || atttypmod == exprTypmod(node))
+	if (targetTypMod < 0 || targetTypMod == exprTypmod(node))
 		return node;
 
-	funcId = find_typmod_coercion_function(targetTypeId);
+	funcId = find_typmod_coercion_function(targetTypeId, &nargs);
 
 	if (OidIsValid(funcId))
 	{
+		List	   *args;
 		Const	   *cons;
+		Node	   *fcall;
 
+		/* Pass given value, plus target typmod as an int4 constant */
 		cons = makeConst(INT4OID,
 						 sizeof(int32),
-						 Int32GetDatum(atttypmod),
+						 Int32GetDatum(targetTypMod),
 						 false,
 						 true,
 						 false,
 						 false);
 
-		node = build_func_call(funcId, targetTypeId, makeList2(node, cons));
+		args = makeList2(node, cons);
+
+		if (nargs == 3)
+		{
+			/* Pass it a boolean isExplicit parameter, too */
+			cons = makeConst(BOOLOID,
+							 sizeof(bool),
+							 BoolGetDatum(cformat != COERCE_IMPLICIT_CAST),
+							 false,
+							 true,
+							 false,
+							 false);
+
+			args = lappend(args, cons);
+		}
+
+		fcall = build_func_call(funcId, targetTypeId, args, cformat);
+
+		/*
+		 * If the input is a constant, apply the length coercion
+		 * function now instead of delaying to runtime.
+		 *
+		 * See the comments for the similar case in coerce_type.
+		 */
+		if (node && IsA(node, Const) &&
+			!((Const *) node)->constisnull)
+			node = eval_const_expressions(fcall);
+		else
+			node = fcall;
 	}
 
 	return node;
@@ -437,19 +555,19 @@ Node *
 coerce_to_boolean(Node *node, const char *constructName)
 {
 	Oid			inputTypeId = exprType(node);
-	Oid			targetTypeId;
 
 	if (inputTypeId != BOOLOID)
 	{
-		targetTypeId = BOOLOID;
-		if (!can_coerce_type(1, &inputTypeId, &targetTypeId, false))
+		node = coerce_to_target_type(node, inputTypeId,
+									 BOOLOID, -1,
+									 COERCION_ASSIGNMENT,
+									 COERCE_IMPLICIT_CAST);
+		if (node == NULL)
 		{
 			/* translator: first %s is name of a SQL construct, eg WHERE */
 			elog(ERROR, "Argument of %s must be type boolean, not type %s",
 				 constructName, format_type_be(inputTypeId));
 		}
-		node = coerce_type(NULL, node, inputTypeId, targetTypeId, -1,
-						   false);
 	}
 
 	if (expression_returns_set(node))
@@ -472,12 +590,6 @@ coerce_to_boolean(Node *node, const char *constructName)
  * in the list will be preferred if there is doubt.
  * 'context' is a phrase to use in the error message if we fail to select
  * a usable type.
- *
- * XXX this code is WRONG, since (for example) given the input (int4,int8)
- * it will select int4, whereas according to SQL92 clause 9.3 the correct
- * answer is clearly int8.	To fix this we need a notion of a promotion
- * hierarchy within type categories --- something more complete than
- * just a single preferred type.
  */
 Oid
 select_common_type(List *typeids, const char *context)
@@ -511,12 +623,13 @@ select_common_type(List *typeids, const char *context)
 				elog(ERROR, "%s types '%s' and '%s' not matched",
 				  context, format_type_be(ptype), format_type_be(ntype));
 			}
-			else if (IsPreferredType(pcategory, ntype)
-					 && !IsPreferredType(pcategory, ptype)
-					 && can_coerce_type(1, &ptype, &ntype, false))
+			else if (!IsPreferredType(pcategory, ptype) &&
+					 can_coerce_type(1, &ptype, &ntype, COERCION_IMPLICIT) &&
+					 !can_coerce_type(1, &ntype, &ptype, COERCION_IMPLICIT))
 			{
 				/*
-				 * new one is preferred and can convert? then take it...
+				 * take new type if can coerce to it implicitly but not the
+				 * other way; but if we have a preferred type, stay on it.
 				 */
 				ptype = ntype;
 				pcategory = TypeCategory(ptype);
@@ -547,26 +660,20 @@ select_common_type(List *typeids, const char *context)
  * This is used following select_common_type() to coerce the individual
  * expressions to the desired type.  'context' is a phrase to use in the
  * error message if we fail to coerce.
- *
- * NOTE: pstate may be NULL.
  */
 Node *
-coerce_to_common_type(ParseState *pstate, Node *node,
-					  Oid targetTypeId,
-					  const char *context)
+coerce_to_common_type(Node *node, Oid targetTypeId, const char *context)
 {
 	Oid			inputTypeId = exprType(node);
 
 	if (inputTypeId == targetTypeId)
 		return node;			/* no work */
-	if (can_coerce_type(1, &inputTypeId, &targetTypeId, false))
-		node = coerce_type(pstate, node, inputTypeId, targetTypeId, -1,
-						   false);
+	if (can_coerce_type(1, &inputTypeId, &targetTypeId, COERCION_IMPLICIT))
+		node = coerce_type(node, inputTypeId, targetTypeId,
+						   COERCION_IMPLICIT, COERCE_IMPLICIT_CAST);
 	else
-	{
 		elog(ERROR, "%s unable to convert to type %s",
 			 context, format_type_be(targetTypeId));
-	}
 	return node;
 }
 
@@ -708,8 +815,6 @@ PreferredType(CATEGORY category, Oid type)
 				type == REGCLASSOID ||
 				type == REGTYPEOID)
 				result = OIDOID;
-			else if (type == NUMERICOID)
-				result = NUMERICOID;
 			else
 				result = FLOAT8OID;
 			break;
@@ -742,49 +847,52 @@ PreferredType(CATEGORY category, Oid type)
 }	/* PreferredType() */
 
 
-/* IsBinaryCompatible()
- *		Check if two types are binary-compatible.
+/* IsBinaryCoercible()
+ *		Check if srctype is binary-coercible to targettype.
  *
  * This notion allows us to cheat and directly exchange values without
  * going through the trouble of calling a conversion function.
  *
- * As of 7.3, binary compatibility isn't hardwired into the code anymore.
- * We consider two types binary-compatible if there is an implicit,
- * no-function-needed pg_cast entry.  NOTE that we assume that such
- * entries are symmetric, ie, it doesn't matter which type we consider
- * source and which target.  (cf. checks in opr_sanity regression test)
+ * As of 7.3, binary coercibility isn't hardwired into the code anymore.
+ * We consider two types binary-coercible if there is an implicitly
+ * invokable, no-function-needed pg_cast entry.
+ *
+ * This function replaces IsBinaryCompatible(), which was an inherently
+ * symmetric test.  Since the pg_cast entries aren't necessarily symmetric,
+ * the order of the operands is now significant.
  */
 bool
-IsBinaryCompatible(Oid type1, Oid type2)
+IsBinaryCoercible(Oid srctype, Oid targettype)
 {
 	HeapTuple	tuple;
 	Form_pg_cast castForm;
 	bool		result;
 
 	/* Fast path if same type */
-	if (type1 == type2)
+	if (srctype == targettype)
 		return true;
 
 	/* Perhaps the types are domains; if so, look at their base types */
-	if (OidIsValid(type1))
-		type1 = getBaseType(type1);
-	if (OidIsValid(type2))
-		type2 = getBaseType(type2);
+	if (OidIsValid(srctype))
+		srctype = getBaseType(srctype);
+	if (OidIsValid(targettype))
+		targettype = getBaseType(targettype);
 
 	/* Somewhat-fast path if same base type */
-	if (type1 == type2)
+	if (srctype == targettype)
 		return true;
 
 	/* Else look in pg_cast */
 	tuple = SearchSysCache(CASTSOURCETARGET,
-						   ObjectIdGetDatum(type1),
-						   ObjectIdGetDatum(type2),
+						   ObjectIdGetDatum(srctype),
+						   ObjectIdGetDatum(targettype),
 						   0, 0);
 	if (!HeapTupleIsValid(tuple))
 		return false;			/* no cast */
 	castForm = (Form_pg_cast) GETSTRUCT(tuple);
 
-	result = (castForm->castfunc == InvalidOid) && castForm->castimplicit;
+	result = (castForm->castfunc == InvalidOid &&
+			  castForm->castcontext == COERCION_CODE_IMPLICIT);
 
 	ReleaseSysCache(tuple);
 
@@ -796,12 +904,15 @@ IsBinaryCompatible(Oid type1, Oid type2)
  * find_coercion_pathway
  *		Look for a coercion pathway between two types.
  *
- * If we find a matching entry in pg_cast, return TRUE, and set *funcid
+ * ccontext determines the set of available casts.
+ *
+ * If we find a suitable entry in pg_cast, return TRUE, and set *funcid
  * to the castfunc value (which may be InvalidOid for a binary-compatible
  * coercion).
  */
 static bool
-find_coercion_pathway(Oid targetTypeId, Oid sourceTypeId, bool isExplicit,
+find_coercion_pathway(Oid targetTypeId, Oid sourceTypeId,
+					  CoercionContext ccontext,
 					  Oid *funcid)
 {
 	bool		result = false;
@@ -828,8 +939,29 @@ find_coercion_pathway(Oid targetTypeId, Oid sourceTypeId, bool isExplicit,
 	if (HeapTupleIsValid(tuple))
 	{
 		Form_pg_cast castForm = (Form_pg_cast) GETSTRUCT(tuple);
+		CoercionContext castcontext;
 
-		if (isExplicit || castForm->castimplicit)
+		/* convert char value for castcontext to CoercionContext enum */
+		switch (castForm->castcontext)
+		{
+			case COERCION_CODE_IMPLICIT:
+				castcontext = COERCION_IMPLICIT;
+				break;
+			case COERCION_CODE_ASSIGNMENT:
+				castcontext = COERCION_ASSIGNMENT;
+				break;
+			case COERCION_CODE_EXPLICIT:
+				castcontext = COERCION_EXPLICIT;
+				break;
+			default:
+				elog(ERROR, "find_coercion_pathway: bogus castcontext %c",
+					 castForm->castcontext);
+				castcontext = 0;	/* keep compiler quiet */
+				break;
+		}
+
+		/* Rely on ordering of enum for correct behavior here */
+		if (ccontext >= castcontext)
 		{
 			*funcid = castForm->castfunc;
 			result = true;
@@ -850,30 +982,59 @@ find_coercion_pathway(Oid targetTypeId, Oid sourceTypeId, bool isExplicit,
  * the type requires coercion to its own length and that the said
  * function should be invoked to do that.
  *
+ * Alternatively, the length-coercing function may have the signature
+ * (targettype, int4, bool).  On success, *nargs is set to report which
+ * signature we found.
+ *
  * "bpchar" (ie, char(N)) and "numeric" are examples of such types.
  *
+ * If the given type is a varlena array type, we do not look for a coercion
+ * function associated directly with the array type, but instead look for
+ * one associated with the element type.  If one exists, we report
+ * array_length_coerce() as the coercion function to use.
+ *
  * This mechanism may seem pretty grotty and in need of replacement by
  * something in pg_cast, but since typmod is only interesting for datatypes
  * that have special handling in the grammar, there's not really much
  * percentage in making it any easier to apply such coercions ...
  */
-static Oid
-find_typmod_coercion_function(Oid typeId)
+Oid
+find_typmod_coercion_function(Oid typeId, int *nargs)
 {
 	Oid			funcid = InvalidOid;
+	bool		isArray = false;
 	Type		targetType;
+	Form_pg_type typeForm;
 	char	   *typname;
 	Oid			typnamespace;
 	Oid			oid_array[FUNC_MAX_ARGS];
 	HeapTuple	ftup;
 
 	targetType = typeidType(typeId);
-	typname = NameStr(((Form_pg_type) GETSTRUCT(targetType))->typname);
-	typnamespace = ((Form_pg_type) GETSTRUCT(targetType))->typnamespace;
+	typeForm = (Form_pg_type) GETSTRUCT(targetType);
 
+	/* Check for a varlena array type (and not a domain) */
+	if (typeForm->typelem != InvalidOid &&
+		typeForm->typlen == -1 &&
+		typeForm->typtype != 'd')
+	{
+		/* Yes, switch our attention to the element type */
+		typeId = typeForm->typelem;
+		ReleaseSysCache(targetType);
+		targetType = typeidType(typeId);
+		typeForm = (Form_pg_type) GETSTRUCT(targetType);
+		isArray = true;
+	}
+
+	/* Function name is same as type internal name, and in same namespace */
+	typname = NameStr(typeForm->typname);
+	typnamespace = typeForm->typnamespace;
+
+	/* First look for parameters (type, int4) */
 	MemSet(oid_array, 0, FUNC_MAX_ARGS * sizeof(Oid));
 	oid_array[0] = typeId;
 	oid_array[1] = INT4OID;
+	*nargs = 2;
 
 	ftup = SearchSysCache(PROCNAMENSP,
 						  CStringGetDatum(typname),
@@ -894,8 +1055,45 @@ find_typmod_coercion_function(Oid typeId)
 		ReleaseSysCache(ftup);
 	}
 
+	if (!OidIsValid(funcid))
+	{
+		/* Didn't find a function, so now try (type, int4, bool) */
+		oid_array[2] = BOOLOID;
+		*nargs = 3;
+
+		ftup = SearchSysCache(PROCNAMENSP,
+							  CStringGetDatum(typname),
+							  Int16GetDatum(3),
+							  PointerGetDatum(oid_array),
+							  ObjectIdGetDatum(typnamespace));
+		if (HeapTupleIsValid(ftup))
+		{
+			Form_pg_proc pform = (Form_pg_proc) GETSTRUCT(ftup);
+
+			/* Make sure the function's result type is as expected */
+			if (pform->prorettype == typeId && !pform->proretset &&
+				!pform->proisagg)
+			{
+				/* Okay to use it */
+				funcid = HeapTupleGetOid(ftup);
+			}
+			ReleaseSysCache(ftup);
+		}
+	}
+
 	ReleaseSysCache(targetType);
 
+	/*
+	 * Now, if we did find a coercion function for an array element type,
+	 * report array_length_coerce() as the function to use.  We know it
+	 * takes three arguments always.
+	 */
+	if (isArray && OidIsValid(funcid))
+	{
+		funcid = F_ARRAY_LENGTH_COERCE;
+		*nargs = 3;
+	}
+
 	return funcid;
 }
 
@@ -905,7 +1103,7 @@ find_typmod_coercion_function(Oid typeId)
  * The argument expressions must have been transformed already.
  */
 static Node *
-build_func_call(Oid funcid, Oid rettype, List *args)
+build_func_call(Oid funcid, Oid rettype, List *args, CoercionForm fformat)
 {
 	Func	   *funcnode;
 	Expr	   *expr;
@@ -914,6 +1112,7 @@ build_func_call(Oid funcid, Oid rettype, List *args)
 	funcnode->funcid = funcid;
 	funcnode->funcresulttype = rettype;
 	funcnode->funcretset = false;		/* only possible case here */
+	funcnode->funcformat = fformat;
 	funcnode->func_fcache = NULL;
 
 	expr = makeNode(Expr);

src/backend/parser/parse_expr.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/parser/parse_expr.c,v 1.128 2002/09/04 20:31:23 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/parser/parse_expr.c,v 1.129 2002/09/18 21:35:22 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -28,7 +28,6 @@
 #include "parser/parse_func.h"
 #include "parser/parse_oper.h"
 #include "parser/parse_relation.h"
-#include "parser/parse_target.h"
 #include "parser/parse_type.h"
 #include "utils/builtins.h"
 #include "utils/lsyscache.h"
@@ -40,9 +39,7 @@ static int	expr_depth_counter = 0;
 
 bool		Transform_null_equals = false;
 
-static Node *parser_typecast_constant(Value *expr, TypeName *typename);
-static Node *parser_typecast_expression(ParseState *pstate,
-						   Node *expr, TypeName *typename);
+static Node *typecast_expression(Node *expr, TypeName *typename);
 static Node *transformColumnRef(ParseState *pstate, ColumnRef *cref);
 static Node *transformIndirection(ParseState *pstate, Node *basenode,
 					 List *indirection);
@@ -145,10 +142,9 @@ transformExpr(ParseState *pstate, Node *expr)
 				A_Const    *con = (A_Const *) expr;
 				Value	   *val = &con->val;
 
+				result = (Node *) make_const(val);
 				if (con->typename != NULL)
-					result = parser_typecast_constant(val, con->typename);
-				else
-					result = (Node *) make_const(val);
+					result = typecast_expression(result, con->typename);
 				break;
 			}
 		case T_ExprFieldSelect:
@@ -175,7 +171,7 @@ transformExpr(ParseState *pstate, Node *expr)
 				TypeCast   *tc = (TypeCast *) expr;
 				Node	   *arg = transformExpr(pstate, tc->arg);
 
-				result = parser_typecast_expression(pstate, arg, tc->typename);
+				result = typecast_expression(arg, tc->typename);
 				break;
 			}
 		case T_A_Expr:
@@ -562,8 +558,7 @@ transformExpr(ParseState *pstate, Node *expr)
 				newc->casetype = ptype;
 
 				/* Convert default result clause, if necessary */
-				newc->defresult = coerce_to_common_type(pstate,
-														newc->defresult,
+				newc->defresult = coerce_to_common_type(newc->defresult,
 														ptype,
 														"CASE/ELSE");
 
@@ -572,8 +567,7 @@ transformExpr(ParseState *pstate, Node *expr)
 				{
 					CaseWhen   *w = (CaseWhen *) lfirst(args);
 
-					w->result = coerce_to_common_type(pstate,
-													  w->result,
+					w->result = coerce_to_common_type(w->result,
 													  ptype,
 													  "CASE/WHEN");
 				}
@@ -671,8 +665,12 @@ transformIndirection(ParseState *pstate, Node *basenode, List *indirection)
 	if (indirection == NIL)
 		return basenode;
 	return (Node *) transformArraySubscripts(pstate,
-											 basenode, exprType(basenode),
-											 indirection, false, NULL);
+											 basenode,
+											 exprType(basenode),
+											 exprTypmod(basenode),
+											 indirection,
+											 false,
+											 NULL);
 }
 
 static Node *
@@ -1037,23 +1035,13 @@ exprTypmod(Node *expr)
  *
  * If coercedTypmod is not NULL, the typmod is stored there if the expression
  * is a length-coercion function, else -1 is stored there.
- *
- * We assume that a two-argument function named for a datatype, whose
- * output and first argument types are that datatype, and whose second
- * input is an int32 constant, represents a forced length coercion.
- *
- * XXX It'd be better if the parsetree retained some explicit indication
- * of the coercion, so we didn't need these heuristics.
  */
 bool
 exprIsLengthCoercion(Node *expr, int32 *coercedTypmod)
 {
 	Func	   *func;
+	int			nargs;
 	Const	   *second_arg;
-	HeapTuple	procTuple;
-	HeapTuple	typeTuple;
-	Form_pg_proc procStruct;
-	Form_pg_type typeStruct;
 
 	if (coercedTypmod != NULL)
 		*coercedTypmod = -1;	/* default result on failure */
@@ -1067,142 +1055,44 @@ exprIsLengthCoercion(Node *expr, int32 *coercedTypmod)
 	Assert(IsA(func, Func));
 
 	/*
-	 * If it's not a two-argument function with the second argument being
-	 * an int4 constant, it can't have been created from a length
-	 * coercion.
+	 * If it didn't come from a coercion context, reject.
 	 */
-	if (length(((Expr *) expr)->args) != 2)
+	if (func->funcformat != COERCE_EXPLICIT_CAST &&
+		func->funcformat != COERCE_IMPLICIT_CAST)
 		return false;
+
+	/*
+	 * If it's not a two-argument or three-argument function with the second
+	 * argument being an int4 constant, it can't have been created from a
+	 * length coercion (it must be a type coercion, instead).
+	 */
+	nargs = length(((Expr *) expr)->args);
+	if (nargs < 2 || nargs > 3)
+		return false;
+
 	second_arg = (Const *) lsecond(((Expr *) expr)->args);
 	if (!IsA(second_arg, Const) ||
 		second_arg->consttype != INT4OID ||
 		second_arg->constisnull)
 		return false;
 
-	/*
-	 * Lookup the function in pg_proc
-	 */
-	procTuple = SearchSysCache(PROCOID,
-							   ObjectIdGetDatum(func->funcid),
-							   0, 0, 0);
-	if (!HeapTupleIsValid(procTuple))
-		elog(ERROR, "cache lookup for proc %u failed", func->funcid);
-	procStruct = (Form_pg_proc) GETSTRUCT(procTuple);
-
-	/*
-	 * It must be a function with two arguments where the first is of the
-	 * same type as the return value and the second is an int4. Also, just
-	 * to be sure, check return type agrees with expr node.
-	 */
-	if (procStruct->pronargs != 2 ||
-		procStruct->prorettype != procStruct->proargtypes[0] ||
-		procStruct->proargtypes[1] != INT4OID ||
-		procStruct->prorettype != ((Expr *) expr)->typeOid)
-	{
-		ReleaseSysCache(procTuple);
-		return false;
-	}
-
-	/*
-	 * Furthermore, the name and namespace of the function must be the
-	 * same as its result type's name/namespace (cf.
-	 * find_coercion_function).
-	 */
-	typeTuple = SearchSysCache(TYPEOID,
-							   ObjectIdGetDatum(procStruct->prorettype),
-							   0, 0, 0);
-	if (!HeapTupleIsValid(typeTuple))
-		elog(ERROR, "cache lookup for type %u failed",
-			 procStruct->prorettype);
-	typeStruct = (Form_pg_type) GETSTRUCT(typeTuple);
-	if (strcmp(NameStr(procStruct->proname),
-			   NameStr(typeStruct->typname)) != 0 ||
-		procStruct->pronamespace != typeStruct->typnamespace)
-	{
-		ReleaseSysCache(procTuple);
-		ReleaseSysCache(typeTuple);
-		return false;
-	}
-
 	/*
 	 * OK, it is indeed a length-coercion function.
 	 */
 	if (coercedTypmod != NULL)
 		*coercedTypmod = DatumGetInt32(second_arg->constvalue);
 
-	ReleaseSysCache(procTuple);
-	ReleaseSysCache(typeTuple);
 	return true;
 }
 
 /*
- * Produce an appropriate Const node from a constant value produced
- * by the parser and an explicit type name to cast to.
- */
-static Node *
-parser_typecast_constant(Value *expr, TypeName *typename)
-{
-	Type		tp;
-	Datum		datum;
-	Const	   *con;
-	char	   *const_string = NULL;
-	bool		string_palloced = false;
-	bool		isNull = false;
-
-	tp = typenameType(typename);
-
-	switch (nodeTag(expr))
-	{
-		case T_Integer:
-			const_string = DatumGetCString(DirectFunctionCall1(int4out,
-										 Int32GetDatum(expr->val.ival)));
-			string_palloced = true;
-			break;
-		case T_Float:
-		case T_String:
-		case T_BitString:
-			const_string = expr->val.str;
-			break;
-		case T_Null:
-			isNull = true;
-			break;
-		default:
-			elog(ERROR, "Cannot cast this expression to type '%s'",
-				 typeTypeName(tp));
-	}
-
-	if (isNull)
-		datum = (Datum) NULL;
-	else
-		datum = stringTypeDatum(tp, const_string, typename->typmod);
-
-	con = makeConst(typeTypeId(tp),
-					typeLen(tp),
-					datum,
-					isNull,
-					typeByVal(tp),
-					false,		/* not a set */
-					true /* is cast */ );
-
-	if (string_palloced)
-		pfree(const_string);
-
-	ReleaseSysCache(tp);
-
-	return (Node *) con;
-}
-
-/*
- * Handle an explicit CAST applied to a non-constant expression.
- * (Actually, this works for constants too, but gram.y won't generate
- * a TypeCast node if the argument is just a constant.)
+ * Handle an explicit CAST construct.
  *
  * The given expr has already been transformed, but we need to lookup
  * the type name and then apply any necessary coercion function(s).
  */
 static Node *
-parser_typecast_expression(ParseState *pstate,
-						   Node *expr, TypeName *typename)
+typecast_expression(Node *expr, TypeName *typename)
 {
 	Oid			inputType = exprType(expr);
 	Oid			targetType;
@@ -1212,23 +1102,14 @@ parser_typecast_expression(ParseState *pstate,
 	if (inputType == InvalidOid)
 		return expr;			/* do nothing if NULL input */
 
-	if (inputType != targetType)
-	{
-		expr = CoerceTargetExpr(pstate, expr, inputType,
-								targetType, typename->typmod,
-								true);	/* explicit coercion */
-		if (expr == NULL)
-			elog(ERROR, "Cannot cast type '%s' to '%s'",
-				 format_type_be(inputType),
-				 format_type_be(targetType));
-	}
-
-	/*
-	 * If the target is a fixed-length type, it may need a length coercion
-	 * as well as a type coercion.
-	 */
-	expr = coerce_type_typmod(pstate, expr,
-							  targetType, typename->typmod);
+	expr = coerce_to_target_type(expr, inputType,
+								 targetType, typename->typmod,
+								 COERCION_EXPLICIT,
+								 COERCE_EXPLICIT_CAST);
+	if (expr == NULL)
+		elog(ERROR, "Cannot cast type %s to %s",
+			 format_type_be(inputType),
+			 format_type_be(targetType));
 
 	return expr;
 }

src/backend/parser/parse_func.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/parser/parse_func.c,v 1.136 2002/09/04 20:31:23 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/parser/parse_func.c,v 1.137 2002/09/18 21:35:22 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -32,15 +32,12 @@
 #include "utils/syscache.h"
 
 
-static Node *ParseComplexProjection(ParseState *pstate,
-					   char *funcname,
-					   Node *first_arg);
+static Node *ParseComplexProjection(char *funcname, Node *first_arg);
 static Oid **argtype_inherit(int nargs, Oid *argtypes);
 
 static int	find_inheritors(Oid relid, Oid **supervec);
 static Oid **gen_cross_product(InhPaths *arginh, int nargs);
-static void make_arguments(ParseState *pstate,
-			   int nargs,
+static void make_arguments(int nargs,
 			   List *fargs,
 			   Oid *input_typeids,
 			   Oid *function_typeids);
@@ -137,7 +134,7 @@ ParseFuncOrColumn(ParseState *pstate, List *funcname, List *fargs,
 			 * ParseComplexProjection can't handle the projection, we have
 			 * to keep going.
 			 */
-			retval = ParseComplexProjection(pstate, cname, first_arg);
+			retval = ParseComplexProjection(cname, first_arg);
 			if (retval)
 				return retval;
 		}
@@ -243,8 +240,8 @@ ParseFuncOrColumn(ParseState *pstate, List *funcname, List *fargs,
 		 * We can do it as a trivial coercion. coerce_type can handle
 		 * these cases, so why duplicate code...
 		 */
-		return coerce_type(pstate, lfirst(fargs),
-						   oid_array[0], rettype, -1, true);
+		return coerce_type(lfirst(fargs), oid_array[0], rettype,
+						   COERCION_EXPLICIT, COERCE_EXPLICIT_CALL);
 	}
 	else if (fdresult == FUNCDETAIL_NORMAL)
 	{
@@ -296,7 +293,7 @@ ParseFuncOrColumn(ParseState *pstate, List *funcname, List *fargs,
 	}
 
 	/* perform the necessary typecasting of arguments */
-	make_arguments(pstate, nargs, fargs, oid_array, true_oid_array);
+	make_arguments(nargs, fargs, oid_array, true_oid_array);
 
 	/* build the appropriate output structure */
 	if (fdresult == FUNCDETAIL_NORMAL)
@@ -307,6 +304,7 @@ ParseFuncOrColumn(ParseState *pstate, List *funcname, List *fargs,
 		funcnode->funcid = funcid;
 		funcnode->funcresulttype = rettype;
 		funcnode->funcretset = retset;
+		funcnode->funcformat = COERCE_EXPLICIT_CALL;
 		funcnode->func_fcache = NULL;
 
 		expr->typeOid = rettype;
@@ -367,7 +365,7 @@ match_argtypes(int nargs,
 	{
 		next_candidate = current_candidate->next;
 		if (can_coerce_type(nargs, input_typeids, current_candidate->args,
-							false))
+							COERCION_IMPLICIT))
 		{
 			current_candidate->next = *candidates;
 			*candidates = current_candidate;
@@ -470,7 +468,7 @@ func_select_candidate(int nargs,
 		{
 			if (input_typeids[i] != UNKNOWNOID)
 			{
-				if (IsBinaryCompatible(current_typeids[i], input_typeids[i]))
+				if (IsBinaryCoercible(input_typeids[i], current_typeids[i]))
 					nmatch++;
 			}
 		}
@@ -776,7 +774,7 @@ func_get_detail(List *funcname,
 				Node	   *arg1 = lfirst(fargs);
 
 				if ((sourceType == UNKNOWNOID && IsA(arg1, Const)) ||
-					IsBinaryCompatible(sourceType, targetType))
+					IsBinaryCoercible(sourceType, targetType))
 				{
 					/* Yup, it's a type coercion */
 					*funcid = InvalidOid;
@@ -1120,8 +1118,7 @@ typeInheritsFrom(Oid subclassTypeId, Oid superclassTypeId)
  *	actual arguments and argument types, do the necessary typecasting.
  */
 static void
-make_arguments(ParseState *pstate,
-			   int nargs,
+make_arguments(int nargs,
 			   List *fargs,
 			   Oid *input_typeids,
 			   Oid *function_typeids)
@@ -1136,11 +1133,11 @@ make_arguments(ParseState *pstate,
 		/* types don't match? then force coercion using a function call... */
 		if (input_typeids[i] != function_typeids[i])
 		{
-			lfirst(current_fargs) = coerce_type(pstate,
-												lfirst(current_fargs),
+			lfirst(current_fargs) = coerce_type(lfirst(current_fargs),
 												input_typeids[i],
-												function_typeids[i], -1,
-												false);
+												function_typeids[i],
+												COERCION_IMPLICIT,
+												COERCE_IMPLICIT_CAST);
 		}
 	}
 }
@@ -1179,9 +1176,7 @@ setup_field_select(Node *input, char *attname, Oid relid)
  * NB: argument is expected to be transformed already, ie, not a RangeVar.
  */
 static Node *
-ParseComplexProjection(ParseState *pstate,
-					   char *funcname,
-					   Node *first_arg)
+ParseComplexProjection(char *funcname, Node *first_arg)
 {
 	Oid			argtype = exprType(first_arg);
 	Oid			argrelid;

src/backend/parser/parse_node.c

@@ -1,27 +1,22 @@
 /*-------------------------------------------------------------------------
  *
  * parse_node.c
- *	  various routines that make nodes for query plans
+ *	  various routines that make nodes for querytrees
  *
  * Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/parser/parse_node.c,v 1.68 2002/09/04 20:31:24 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/parser/parse_node.c,v 1.69 2002/09/18 21:35:22 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
 #include "postgres.h"
 
-#include <ctype.h>
-#include <errno.h>
-#include <float.h>
-
 #include "access/heapam.h"
 #include "catalog/pg_operator.h"
 #include "catalog/pg_type.h"
-#include "fmgr.h"
 #include "nodes/makefuncs.h"
 #include "parser/parsetree.h"
 #include "parser/parse_coerce.h"
@@ -29,14 +24,11 @@
 #include "parser/parse_node.h"
 #include "parser/parse_oper.h"
 #include "parser/parse_relation.h"
-#include "parser/parse_target.h"
-#include "parser/parse_type.h"
 #include "utils/builtins.h"
-#include "utils/varbit.h"
+#include "utils/int8.h"
 #include "utils/lsyscache.h"
 #include "utils/syscache.h"
-
-static bool fitsInFloat(Value *value);
+#include "utils/varbit.h"
 
 
 /* make_parsestate()
@@ -70,8 +62,8 @@ make_operand(Node *tree, Oid orig_typeId, Oid target_typeId)
 	{
 		/* must coerce? */
 		if (target_typeId != orig_typeId)
-			result = coerce_type(NULL, tree, orig_typeId, target_typeId, -1,
-								 false);
+			result = coerce_type(tree, orig_typeId, target_typeId,
+								 COERCION_IMPLICIT, COERCE_IMPLICIT_CAST);
 		else
 			result = tree;
 	}
@@ -191,6 +183,7 @@ make_var(ParseState *pstate, RangeTblEntry *rte, int attrno)
  * arrayBase	Already-transformed expression for the array as a whole
  *				(may be NULL if we are handling an INSERT)
  * arrayType	OID of array's datatype
+ * arrayTypMod	typmod to be applied to array elements
  * indirection	Untransformed list of subscripts (must not be NIL)
  * forceSlice	If true, treat subscript as array slice in all cases
  * assignFrom	NULL for array fetch, else transformed expression for source.
@@ -199,6 +192,7 @@ ArrayRef *
 transformArraySubscripts(ParseState *pstate,
 						 Node *arrayBase,
 						 Oid arrayType,
+						 int32 arrayTypMod,
 						 List *indirection,
 						 bool forceSlice,
 						 Node *assignFrom)
@@ -286,8 +280,10 @@ transformArraySubscripts(ParseState *pstate,
 			{
 				subexpr = transformExpr(pstate, ai->lidx);
 				/* If it's not int4 already, try to coerce */
-				subexpr = CoerceTargetExpr(pstate, subexpr, exprType(subexpr),
-										   INT4OID, -1, false);
+				subexpr = coerce_to_target_type(subexpr, exprType(subexpr),
+												INT4OID, -1,
+												COERCION_ASSIGNMENT,
+												COERCE_IMPLICIT_CAST);
 				if (subexpr == NULL)
 					elog(ERROR, "array index expressions must be integers");
 			}
@@ -306,8 +302,10 @@ transformArraySubscripts(ParseState *pstate,
 		}
 		subexpr = transformExpr(pstate, ai->uidx);
 		/* If it's not int4 already, try to coerce */
-		subexpr = CoerceTargetExpr(pstate, subexpr, exprType(subexpr),
-								   INT4OID, -1, false);
+		subexpr = coerce_to_target_type(subexpr, exprType(subexpr),
+										INT4OID, -1,
+										COERCION_ASSIGNMENT,
+										COERCE_IMPLICIT_CAST);
 		if (subexpr == NULL)
 			elog(ERROR, "array index expressions must be integers");
 		upperIndexpr = lappend(upperIndexpr, subexpr);
@@ -323,19 +321,16 @@ transformArraySubscripts(ParseState *pstate,
 
 		if (typesource != InvalidOid)
 		{
-			if (typesource != typeneeded)
-			{
-				/* XXX fixme: need to get the array's atttypmod? */
-				assignFrom = CoerceTargetExpr(pstate, assignFrom,
-											  typesource, typeneeded,
-											  -1, false);
-				if (assignFrom == NULL)
-					elog(ERROR, "Array assignment requires type '%s'"
-						 " but expression is of type '%s'"
-					"\n\tYou will need to rewrite or cast the expression",
-						 format_type_be(typeneeded),
-						 format_type_be(typesource));
-			}
+			assignFrom = coerce_to_target_type(assignFrom, typesource,
+											   typeneeded, arrayTypMod,
+											   COERCION_ASSIGNMENT,
+											   COERCE_IMPLICIT_CAST);
+			if (assignFrom == NULL)
+				elog(ERROR, "Array assignment requires type %s"
+					 " but expression is of type %s"
+					 "\n\tYou will need to rewrite or cast the expression",
+					 format_type_be(typeneeded),
+					 format_type_be(typesource));
 		}
 	}
 
@@ -344,7 +339,7 @@ transformArraySubscripts(ParseState *pstate,
 	 */
 	aref = makeNode(ArrayRef);
 	aref->refrestype = resultType;		/* XXX should save element type
-										 * too */
+										 * OID too */
 	aref->refattrlength = type_struct_array->typlen;
 	aref->refelemlength = type_struct_element->typlen;
 	aref->refelembyval = type_struct_element->typbyval;
@@ -373,21 +368,16 @@ transformArraySubscripts(ParseState *pstate,
  *	resolution that we're not sure that it should be considered text.
  *	Explicit "NULL" constants are also typed as UNKNOWN.
  *
- *	For integers and floats we produce int4, float8, or numeric depending
- *	on the value of the number.  XXX In some cases it would be nice to take
- *	context into account when determining the type to convert to, but in
- *	other cases we can't delay the type choice.  One possibility is to invent
- *	a dummy type "UNKNOWNNUMERIC" that's treated similarly to UNKNOWN;
- *	that would allow us to do the right thing in examples like a simple
- *	INSERT INTO table (numericcolumn) VALUES (1.234), since we wouldn't
- *	have to resolve the unknown type until we knew the destination column
- *	type.  On the other hand UNKNOWN has considerable problems of its own.
- *	We would not like "SELECT 1.2 + 3.4" to claim it can't choose a type.
+ *	For integers and floats we produce int4, int8, or numeric depending
+ *	on the value of the number.  XXX This should include int2 as well,
+ *	but additional cleanup is needed before we can do that; else cases
+ *	like "WHERE int4var = 42" will fail to be indexable.
  */
 Const *
 make_const(Value *value)
 {
 	Datum		val;
+	int64		val64;
 	Oid			typeid;
 	int			typelen;
 	bool		typebyval;
@@ -404,12 +394,13 @@ make_const(Value *value)
 			break;
 
 		case T_Float:
-			if (fitsInFloat(value))
+			/* could be an oversize integer as well as a float ... */
+			if (scanint8(strVal(value), true, &val64))
 			{
-				val = Float8GetDatum(floatVal(value));
+				val = Int64GetDatum(val64);
 
-				typeid = FLOAT8OID;
-				typelen = sizeof(float8);
+				typeid = INT8OID;
+				typelen = sizeof(int64);
 				typebyval = false;		/* XXX might change someday */
 			}
 			else
@@ -470,46 +461,3 @@ make_const(Value *value)
 
 	return con;
 }
-
-/*
- * Decide whether a T_Float value fits in float8, or must be treated as
- * type "numeric".	We check the number of digits and check for overflow/
- * underflow.  (With standard compilation options, Postgres' NUMERIC type
- * can handle decimal exponents up to 1000, considerably more than most
- * implementations of float8, so this is a sensible test.)
- */
-static bool
-fitsInFloat(Value *value)
-{
-	const char *ptr;
-	int			ndigits;
-	char	   *endptr;
-
-	/*
-	 * Count digits, ignoring leading zeroes (but not trailing zeroes).
-	 * DBL_DIG is the maximum safe number of digits for "double".
-	 */
-	ptr = strVal(value);
-	while (*ptr == '+' || *ptr == '-' || *ptr == '0' || *ptr == '.')
-		ptr++;
-	ndigits = 0;
-	for (; *ptr; ptr++)
-	{
-		if (isdigit((unsigned char) *ptr))
-			ndigits++;
-		else if (*ptr == 'e' || *ptr == 'E')
-			break;				/* don't count digits in exponent */
-	}
-	if (ndigits > DBL_DIG)
-		return false;
-
-	/*
-	 * Use strtod() to check for overflow/underflow.
-	 */
-	errno = 0;
-	(void) strtod(strVal(value), &endptr);
-	if (*endptr != '\0' || errno != 0)
-		return false;
-
-	return true;
-}

src/backend/parser/parse_oper.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/parser/parse_oper.c,v 1.59 2002/09/04 20:31:24 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/parser/parse_oper.c,v 1.60 2002/09/18 21:35:22 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -273,7 +273,7 @@ oper_select_candidate(int nargs,
 		 current_candidate = current_candidate->next)
 	{
 		if (can_coerce_type(nargs, input_typeids, current_candidate->args,
-							false))
+							COERCION_IMPLICIT))
 		{
 			if (last_candidate == NULL)
 			{
@@ -362,7 +362,7 @@ oper_select_candidate(int nargs,
 		{
 			if (input_typeids[i] != UNKNOWNOID)
 			{
-				if (IsBinaryCompatible(current_typeids[i], input_typeids[i]))
+				if (IsBinaryCoercible(input_typeids[i], current_typeids[i]))
 					nmatch++;
 			}
 		}
@@ -696,8 +696,8 @@ compatible_oper(List *op, Oid arg1, Oid arg2, bool noError)
 
 	/* but is it good enough? */
 	opform = (Form_pg_operator) GETSTRUCT(optup);
-	if (IsBinaryCompatible(opform->oprleft, arg1) &&
-		IsBinaryCompatible(opform->oprright, arg2))
+	if (IsBinaryCoercible(arg1, opform->oprleft) &&
+		IsBinaryCoercible(arg2, opform->oprright))
 		return optup;
 
 	/* nope... */

src/backend/parser/parse_target.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/parser/parse_target.c,v 1.89 2002/09/04 20:31:24 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/parser/parse_target.c,v 1.90 2002/09/18 21:35:22 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -274,6 +274,7 @@ updateTargetListEntry(ParseState *pstate,
 		aref = transformArraySubscripts(pstate,
 										arrayBase,
 										attrtype,
+										attrtypmod,
 										indirection,
 										pstate->p_is_insert,
 										tle->expr);
@@ -284,30 +285,21 @@ updateTargetListEntry(ParseState *pstate,
 		/*
 		 * For normal non-subscripted target column, do type checking and
 		 * coercion.  But accept InvalidOid, which indicates the source is
-		 * a NULL constant.
+		 * a NULL constant.  (XXX is that still true?)
 		 */
 		if (type_id != InvalidOid)
 		{
-			if (type_id != attrtype)
-			{
-				tle->expr = CoerceTargetExpr(pstate, tle->expr, type_id,
-											 attrtype, attrtypmod,
-											 false);
-				if (tle->expr == NULL)
-					elog(ERROR, "column \"%s\" is of type '%s'"
-						 " but expression is of type '%s'"
-					"\n\tYou will need to rewrite or cast the expression",
-						 colname,
-						 format_type_be(attrtype),
-						 format_type_be(type_id));
-			}
-
-			/*
-			 * If the target is a fixed-length type, it may need a length
-			 * coercion as well as a type coercion.
-			 */
-			tle->expr = coerce_type_typmod(pstate, tle->expr,
-										   attrtype, attrtypmod);
+			tle->expr = coerce_to_target_type(tle->expr, type_id,
+											  attrtype, attrtypmod,
+											  COERCION_ASSIGNMENT,
+											  COERCE_IMPLICIT_CAST);
+			if (tle->expr == NULL)
+				elog(ERROR, "column \"%s\" is of type %s"
+					 " but expression is of type %s"
+					 "\n\tYou will need to rewrite or cast the expression",
+					 colname,
+					 format_type_be(attrtype),
+					 format_type_be(type_id));
 		}
 	}
 
@@ -324,46 +316,6 @@ updateTargetListEntry(ParseState *pstate,
 }
 
 
-Node *
-CoerceTargetExpr(ParseState *pstate,
-				 Node *expr,
-				 Oid type_id,
-				 Oid attrtype,
-				 int32 attrtypmod,
-				 bool isExplicit)
-{
-	if (can_coerce_type(1, &type_id, &attrtype, isExplicit))
-		expr = coerce_type(pstate, expr, type_id, attrtype, attrtypmod,
-						   isExplicit);
-
-#ifndef DISABLE_STRING_HACKS
-
-	/*
-	 * string hacks to get transparent conversions w/o explicit
-	 * conversions
-	 */
-	else if ((attrtype == BPCHAROID) || (attrtype == VARCHAROID))
-	{
-		Oid			text_id = TEXTOID;
-
-		if (type_id == TEXTOID)
-		{
-		}
-		else if (can_coerce_type(1, &type_id, &text_id, isExplicit))
-			expr = coerce_type(pstate, expr, type_id, text_id, attrtypmod,
-							   isExplicit);
-		else
-			expr = NULL;
-	}
-#endif
-
-	else
-		expr = NULL;
-
-	return expr;
-}
-
-
 /*
  * checkInsertTargets -
  *	  generate a list of INSERT column targets if not supplied, or

src/backend/rewrite/rewriteHandler.c

@@ -7,7 +7,7 @@
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteHandler.c,v 1.109 2002/09/11 14:48:54 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteHandler.c,v 1.110 2002/09/18 21:35:22 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -25,7 +25,6 @@
 #include "parser/parse_coerce.h"
 #include "parser/parse_expr.h"
 #include "parser/parse_oper.h"
-#include "parser/parse_target.h"
 #include "parser/parse_type.h"
 #include "parser/parsetree.h"
 #include "rewrite/rewriteHandler.h"
@@ -474,29 +473,21 @@ build_column_default(Relation rel, int attrno)
 	 */
 	exprtype = exprType(expr);
 
-	if (exprtype != atttype)
-	{
-		expr = CoerceTargetExpr(NULL, expr, exprtype,
-								atttype, atttypmod, false);
-
-		/*
-		 * This really shouldn't fail; should have checked the default's
-		 * type when it was created ...
-		 */
-		if (expr == NULL)
-			elog(ERROR, "Column \"%s\" is of type %s"
-				 " but default expression is of type %s"
-				 "\n\tYou will need to rewrite or cast the expression",
-				 NameStr(att_tup->attname),
-				 format_type_be(atttype),
-				 format_type_be(exprtype));
-	}
-
+	expr = coerce_to_target_type(expr, exprtype,
+								 atttype, atttypmod,
+								 COERCION_ASSIGNMENT,
+								 COERCE_IMPLICIT_CAST);
 	/*
-	 * If the column is a fixed-length type, it may need a length coercion
-	 * as well as a type coercion.
+	 * This really shouldn't fail; should have checked the default's
+	 * type when it was created ...
 	 */
-	expr = coerce_type_typmod(NULL, expr, atttype, atttypmod);
+	if (expr == NULL)
+		elog(ERROR, "Column \"%s\" is of type %s"
+			 " but default expression is of type %s"
+			 "\n\tYou will need to rewrite or cast the expression",
+			 NameStr(att_tup->attname),
+			 format_type_be(atttype),
+			 format_type_be(exprtype));
 
 	return expr;
 }

src/backend/utils/adt/arrayfuncs.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/arrayfuncs.c,v 1.80 2002/09/04 20:31:27 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/arrayfuncs.c,v 1.81 2002/09/18 21:35:22 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -19,6 +19,7 @@
 #include "access/tupmacs.h"
 #include "catalog/catalog.h"
 #include "catalog/pg_type.h"
+#include "parser/parse_coerce.h"
 #include "utils/array.h"
 #include "utils/memutils.h"
 #include "utils/syscache.h"
@@ -755,6 +756,72 @@ array_out(PG_FUNCTION_ARGS)
 	PG_RETURN_CSTRING(retval);
 }
 
+/*-------------------------------------------------------------------------
+ * array_length_coerce :
+ *		  Apply the element type's length-coercion routine to each element
+ *		  of the given array.
+ *-------------------------------------------------------------------------
+ */
+Datum
+array_length_coerce(PG_FUNCTION_ARGS)
+{
+	ArrayType  *v = PG_GETARG_ARRAYTYPE_P(0);
+	int32		len = PG_GETARG_INT32(1);
+	bool		isExplicit = PG_GETARG_BOOL(2);
+	FmgrInfo   *fmgr_info = fcinfo->flinfo;
+	FmgrInfo   *element_finfo;
+	FunctionCallInfoData locfcinfo;
+
+	/* If no typmod is provided, shortcircuit the whole thing */
+	if (len < 0)
+		PG_RETURN_ARRAYTYPE_P(v);
+
+	/*
+	 * We arrange to look up the element type's coercion function only
+	 * once per series of calls.
+	 */
+	if (fmgr_info->fn_extra == NULL)
+	{
+		Oid			funcId;
+		int			nargs;
+
+		fmgr_info->fn_extra = MemoryContextAlloc(fmgr_info->fn_mcxt,
+												 sizeof(FmgrInfo));
+		element_finfo = (FmgrInfo *) fmgr_info->fn_extra;
+
+		funcId = find_typmod_coercion_function(ARR_ELEMTYPE(v), &nargs);
+
+		if (OidIsValid(funcId))
+			fmgr_info_cxt(funcId, element_finfo, fmgr_info->fn_mcxt);
+		else
+			element_finfo->fn_oid = InvalidOid;
+	}
+	else
+		element_finfo = (FmgrInfo *) fmgr_info->fn_extra;
+
+	/*
+	 * If we didn't find a coercion function, return the array unmodified
+	 * (this should not happen in the normal course of things, but might
+	 * happen if this function is called manually).
+	 */
+	if (element_finfo->fn_oid == InvalidOid)
+		PG_RETURN_ARRAYTYPE_P(v);
+
+	/*
+	 * Use array_map to apply the function to each array element.
+	 *
+	 * Note: we pass isExplicit whether or not the function wants it ...
+	 */
+	MemSet(&locfcinfo, 0, sizeof(locfcinfo));
+	locfcinfo.flinfo = element_finfo;
+	locfcinfo.nargs = 3;
+	locfcinfo.arg[0] = PointerGetDatum(v);
+	locfcinfo.arg[1] = Int32GetDatum(len);
+	locfcinfo.arg[2] = BoolGetDatum(isExplicit);
+
+	return array_map(&locfcinfo, ARR_ELEMTYPE(v), ARR_ELEMTYPE(v));
+}
+
 /*-----------------------------------------------------------------------------
  * array_dims :
  *		  returns the dimensions of the array pointed to by "v", as a "text"

src/backend/utils/adt/int8.c

@@ -7,7 +7,7 @@
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/int8.c,v 1.41 2002/09/04 20:31:28 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/int8.c,v 1.42 2002/09/18 21:35:22 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -48,14 +48,16 @@
  * Formatting and conversion routines.
  *---------------------------------------------------------*/
 
-/* int8in()
+/*
+ * scanint8 --- try to parse a string into an int8.
+ *
+ * If errorOK is false, elog a useful error message if the string is bad.
+ * If errorOK is true, just return "false" for bad input.
  */
-Datum
-int8in(PG_FUNCTION_ARGS)
+bool
+scanint8(const char *str, bool errorOK, int64 *result)
 {
-	char	   *str = PG_GETARG_CSTRING(0);
-	int64		result;
-	char	   *ptr = str;
+	const char *ptr = str;
 	int64		tmp = 0;
 	int			sign = 1;
 
@@ -63,8 +65,11 @@ int8in(PG_FUNCTION_ARGS)
 	 * Do our own scan, rather than relying on sscanf which might be
 	 * broken for long long.
 	 */
-	while (*ptr && isspace((unsigned char) *ptr))		/* skip leading spaces */
+
+	/* skip leading spaces */
+	while (*ptr && isspace((unsigned char) *ptr))
 		ptr++;
+
 	/* handle sign */
 	if (*ptr == '-')
 	{
@@ -79,28 +84,61 @@ int8in(PG_FUNCTION_ARGS)
 #ifndef INT64_IS_BUSTED
 		if (strcmp(ptr, "9223372036854775808") == 0)
 		{
-			result = -INT64CONST(0x7fffffffffffffff) - 1;
-			PG_RETURN_INT64(result);
+			*result = -INT64CONST(0x7fffffffffffffff) - 1;
+			return true;
 		}
 #endif
 	}
 	else if (*ptr == '+')
 		ptr++;
-	if (!isdigit((unsigned char) *ptr)) /* require at least one digit */
-		elog(ERROR, "Bad int8 external representation \"%s\"", str);
-	while (*ptr && isdigit((unsigned char) *ptr))		/* process digits */
+
+	/* require at least one digit */
+	if (!isdigit((unsigned char) *ptr))
+	{
+		if (errorOK)
+			return false;
+		else
+			elog(ERROR, "Bad int8 external representation \"%s\"", str);
+	}
+
+	/* process digits */
+	while (*ptr && isdigit((unsigned char) *ptr))
 	{
 		int64		newtmp = tmp * 10 + (*ptr++ - '0');
 
 		if ((newtmp / 10) != tmp)		/* overflow? */
-			elog(ERROR, "int8 value out of range: \"%s\"", str);
+		{
+			if (errorOK)
+				return false;
+			else
+				elog(ERROR, "int8 value out of range: \"%s\"", str);
+		}
 		tmp = newtmp;
 	}
-	if (*ptr)					/* trailing junk? */
-		elog(ERROR, "Bad int8 external representation \"%s\"", str);
 
-	result = (sign < 0) ? -tmp : tmp;
+	/* trailing junk? */
+	if (*ptr)
+	{
+		if (errorOK)
+			return false;
+		else
+			elog(ERROR, "Bad int8 external representation \"%s\"", str);
+	}
 
+	*result = (sign < 0) ? -tmp : tmp;
+
+	return true;
+}
+
+/* int8in()
+ */
+Datum
+int8in(PG_FUNCTION_ARGS)
+{
+	char	   *str = PG_GETARG_CSTRING(0);
+	int64		result;
+
+	(void) scanint8(str, false, &result);
 	PG_RETURN_INT64(result);
 }
 
@@ -747,7 +785,7 @@ i8tod(PG_FUNCTION_ARGS)
 }
 
 /* dtoi8()
- * Convert double float to 8-byte integer.
+ * Convert float8 to 8-byte integer.
  */
 Datum
 dtoi8(PG_FUNCTION_ARGS)
@@ -771,8 +809,66 @@ dtoi8(PG_FUNCTION_ARGS)
 	PG_RETURN_INT64(result);
 }
 
-/* text_int8()
+Datum
+i8tof(PG_FUNCTION_ARGS)
+{
+	int64		val = PG_GETARG_INT64(0);
+	float4		result;
+
+	result = val;
+
+	PG_RETURN_FLOAT4(result);
+}
+
+/* ftoi8()
+ * Convert float4 to 8-byte integer.
  */
+Datum
+ftoi8(PG_FUNCTION_ARGS)
+{
+	float4		val = PG_GETARG_FLOAT4(0);
+	int64		result;
+	float8		dval;
+
+	/* Round val to nearest integer (but it's still in float form) */
+	dval = rint(val);
+
+	/*
+	 * Does it fit in an int64?  Avoid assuming that we have handy
+	 * constants defined for the range boundaries, instead test for
+	 * overflow by reverse-conversion.
+	 */
+	result = (int64) dval;
+
+	if ((float8) result != dval)
+		elog(ERROR, "Floating point conversion to int8 is out of range");
+
+	PG_RETURN_INT64(result);
+}
+
+Datum
+i8tooid(PG_FUNCTION_ARGS)
+{
+	int64		val = PG_GETARG_INT64(0);
+	Oid			result;
+
+	result = (Oid) val;
+
+	/* Test for overflow by reverse-conversion. */
+	if ((int64) result != val)
+		elog(ERROR, "int8 conversion to OID is out of range");
+
+	PG_RETURN_OID(result);
+}
+
+Datum
+oidtoi8(PG_FUNCTION_ARGS)
+{
+	Oid			val = PG_GETARG_OID(0);
+
+	PG_RETURN_INT64((int64) val);
+}
+
 Datum
 text_int8(PG_FUNCTION_ARGS)
 {
@@ -793,9 +889,6 @@ text_int8(PG_FUNCTION_ARGS)
 	return result;
 }
 
-
-/* int8_text()
- */
 Datum
 int8_text(PG_FUNCTION_ARGS)
 {

src/backend/utils/adt/numeric.c

@@ -5,7 +5,7 @@
  *
  *	1998 Jan Wieck
  *
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/numeric.c,v 1.53 2002/09/04 20:31:28 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/numeric.c,v 1.54 2002/09/18 21:35:22 tgl Exp $
  *
  * ----------
  */
@@ -1709,6 +1709,50 @@ numeric_float4(PG_FUNCTION_ARGS)
 }
 
 
+Datum
+text_numeric(PG_FUNCTION_ARGS)
+{
+	text	   *str = PG_GETARG_TEXT_P(0);
+	int			len;
+	char	   *s;
+	Datum		result;
+
+	len = (VARSIZE(str) - VARHDRSZ);
+	s = palloc(len + 1);
+	memcpy(s, VARDATA(str), len);
+	*(s + len) = '\0';
+
+	result = DirectFunctionCall3(numeric_in, CStringGetDatum(s),
+								 ObjectIdGetDatum(0), Int32GetDatum(-1));
+
+	pfree(s);
+
+	return result;
+}
+
+Datum
+numeric_text(PG_FUNCTION_ARGS)
+{
+	/* val is numeric, but easier to leave it as Datum */
+	Datum		val = PG_GETARG_DATUM(0);
+	char	   *s;
+	int			len;
+	text	   *result;
+
+	s = DatumGetCString(DirectFunctionCall1(numeric_out, val));
+	len = strlen(s);
+
+	result = (text *) palloc(VARHDRSZ + len);
+
+	VARATT_SIZEP(result) = len + VARHDRSZ;
+	memcpy(VARDATA(result), s, len);
+
+	pfree(s);
+
+	PG_RETURN_TEXT_P(result);
+}
+
+
 /* ----------------------------------------------------------------------
  *
  * Aggregate functions

src/backend/utils/adt/regproc.c

@@ -13,7 +13,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/regproc.c,v 1.75 2002/09/04 20:31:28 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/regproc.c,v 1.76 2002/09/18 21:35:23 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -49,7 +49,7 @@ static void parseNameAndArgTypes(const char *string, const char *caller,
 /*
  * regprocin		- converts "proname" to proc OID
  *
- * We also accept a numeric OID, mostly for historical reasons.
+ * We also accept a numeric OID, for symmetry with the output routine.
  *
  * '-' signifies unknown (OID 0).  In all other cases, the input must
  * match an existing pg_proc entry.
@@ -71,15 +71,8 @@ regprocin(PG_FUNCTION_ARGS)
 		pro_name_or_oid[0] <= '9' &&
 		strspn(pro_name_or_oid, "0123456789") == strlen(pro_name_or_oid))
 	{
-		Oid			searchOid;
-
-		searchOid = DatumGetObjectId(DirectFunctionCall1(oidin,
+		result = DatumGetObjectId(DirectFunctionCall1(oidin,
 									  CStringGetDatum(pro_name_or_oid)));
-		result = (RegProcedure) GetSysCacheOid(PROCOID,
-											 ObjectIdGetDatum(searchOid),
-											   0, 0, 0);
-		if (!RegProcedureIsValid(result))
-			elog(ERROR, "No procedure with oid %s", pro_name_or_oid);
 		PG_RETURN_OID(result);
 	}
 
@@ -211,7 +204,7 @@ regprocout(PG_FUNCTION_ARGS)
 /*
  * regprocedurein		- converts "proname(args)" to proc OID
  *
- * We also accept a numeric OID, mostly for historical reasons.
+ * We also accept a numeric OID, for symmetry with the output routine.
  *
  * '-' signifies unknown (OID 0).  In all other cases, the input must
  * match an existing pg_proc entry.
@@ -235,15 +228,8 @@ regprocedurein(PG_FUNCTION_ARGS)
 		pro_name_or_oid[0] <= '9' &&
 		strspn(pro_name_or_oid, "0123456789") == strlen(pro_name_or_oid))
 	{
-		Oid			searchOid;
-
-		searchOid = DatumGetObjectId(DirectFunctionCall1(oidin,
+		result = DatumGetObjectId(DirectFunctionCall1(oidin,
 									  CStringGetDatum(pro_name_or_oid)));
-		result = (RegProcedure) GetSysCacheOid(PROCOID,
-											 ObjectIdGetDatum(searchOid),
-											   0, 0, 0);
-		if (!RegProcedureIsValid(result))
-			elog(ERROR, "No procedure with oid %s", pro_name_or_oid);
 		PG_RETURN_OID(result);
 	}
 
@@ -361,7 +347,7 @@ regprocedureout(PG_FUNCTION_ARGS)
 /*
  * regoperin		- converts "oprname" to operator OID
  *
- * We also accept a numeric OID, mostly for historical reasons.
+ * We also accept a numeric OID, for symmetry with the output routine.
  *
  * '0' signifies unknown (OID 0).  In all other cases, the input must
  * match an existing pg_operator entry.
@@ -383,15 +369,8 @@ regoperin(PG_FUNCTION_ARGS)
 		opr_name_or_oid[0] <= '9' &&
 		strspn(opr_name_or_oid, "0123456789") == strlen(opr_name_or_oid))
 	{
-		Oid			searchOid;
-
-		searchOid = DatumGetObjectId(DirectFunctionCall1(oidin,
+		result = DatumGetObjectId(DirectFunctionCall1(oidin,
 									  CStringGetDatum(opr_name_or_oid)));
-		result = GetSysCacheOid(OPEROID,
-								ObjectIdGetDatum(searchOid),
-								0, 0, 0);
-		if (!OidIsValid(result))
-			elog(ERROR, "No operator with oid %s", opr_name_or_oid);
 		PG_RETURN_OID(result);
 	}
 
@@ -531,7 +510,7 @@ regoperout(PG_FUNCTION_ARGS)
 /*
  * regoperatorin		- converts "oprname(args)" to operator OID
  *
- * We also accept a numeric OID, mostly for historical reasons.
+ * We also accept a numeric OID, for symmetry with the output routine.
  *
  * '0' signifies unknown (OID 0).  In all other cases, the input must
  * match an existing pg_operator entry.
@@ -556,15 +535,8 @@ regoperatorin(PG_FUNCTION_ARGS)
 		opr_name_or_oid[0] <= '9' &&
 		strspn(opr_name_or_oid, "0123456789") == strlen(opr_name_or_oid))
 	{
-		Oid			searchOid;
-
-		searchOid = DatumGetObjectId(DirectFunctionCall1(oidin,
+		result = DatumGetObjectId(DirectFunctionCall1(oidin,
 									  CStringGetDatum(opr_name_or_oid)));
-		result = GetSysCacheOid(OPEROID,
-								ObjectIdGetDatum(searchOid),
-								0, 0, 0);
-		if (!OidIsValid(result))
-			elog(ERROR, "No operator with oid %s", opr_name_or_oid);
 		PG_RETURN_OID(result);
 	}
 
@@ -698,7 +670,7 @@ regoperatorout(PG_FUNCTION_ARGS)
 /*
  * regclassin		- converts "classname" to class OID
  *
- * We also accept a numeric OID, mostly for historical reasons.
+ * We also accept a numeric OID, for symmetry with the output routine.
  *
  * '-' signifies unknown (OID 0).  In all other cases, the input must
  * match an existing pg_class entry.
@@ -719,15 +691,8 @@ regclassin(PG_FUNCTION_ARGS)
 		class_name_or_oid[0] <= '9' &&
 	strspn(class_name_or_oid, "0123456789") == strlen(class_name_or_oid))
 	{
-		Oid			searchOid;
-
-		searchOid = DatumGetObjectId(DirectFunctionCall1(oidin,
+		result = DatumGetObjectId(DirectFunctionCall1(oidin,
 									CStringGetDatum(class_name_or_oid)));
-		result = GetSysCacheOid(RELOID,
-								ObjectIdGetDatum(searchOid),
-								0, 0, 0);
-		if (!OidIsValid(result))
-			elog(ERROR, "No class with oid %s", class_name_or_oid);
 		PG_RETURN_OID(result);
 	}
 
@@ -843,7 +808,7 @@ regclassout(PG_FUNCTION_ARGS)
 /*
  * regtypein		- converts "typename" to type OID
  *
- * We also accept a numeric OID, mostly for historical reasons.
+ * We also accept a numeric OID, for symmetry with the output routine.
  *
  * '-' signifies unknown (OID 0).  In all other cases, the input must
  * match an existing pg_type entry.
@@ -870,15 +835,8 @@ regtypein(PG_FUNCTION_ARGS)
 		typ_name_or_oid[0] <= '9' &&
 		strspn(typ_name_or_oid, "0123456789") == strlen(typ_name_or_oid))
 	{
-		Oid			searchOid;
-
-		searchOid = DatumGetObjectId(DirectFunctionCall1(oidin,
+		result = DatumGetObjectId(DirectFunctionCall1(oidin,
 									  CStringGetDatum(typ_name_or_oid)));
-		result = GetSysCacheOid(TYPEOID,
-								ObjectIdGetDatum(searchOid),
-								0, 0, 0);
-		if (!OidIsValid(result))
-			elog(ERROR, "No type with oid %s", typ_name_or_oid);
 		PG_RETURN_OID(result);
 	}
 

src/backend/utils/adt/ruleutils.c

@@ -3,7 +3,7 @@
  *				back to source text
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/ruleutils.c,v 1.121 2002/09/04 20:31:28 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/ruleutils.c,v 1.122 2002/09/18 21:35:23 tgl Exp $
  *
  *	  This software is copyrighted by Jan Wieck - Hamburg.
  *
@@ -152,7 +152,6 @@ static void get_oper_expr(Expr *expr, deparse_context *context);
 static void get_func_expr(Expr *expr, deparse_context *context);
 static void get_agg_expr(Aggref *aggref, deparse_context *context);
 static Node *strip_type_coercion(Node *expr, Oid resultType);
-static void get_tle_expr(TargetEntry *tle, deparse_context *context);
 static void get_const_expr(Const *constval, deparse_context *context);
 static void get_sublink_expr(Node *node, deparse_context *context);
 static void get_from_clause(Query *query, deparse_context *context);
@@ -1430,7 +1429,6 @@ get_basic_select_query(Query *query, deparse_context *context,
 		sep = ", ";
 		colno++;
 
-		/* Do NOT use get_tle_expr here; see its comments! */
 		get_rule_expr(tle->expr, context);
 
 		/*
@@ -1644,7 +1642,7 @@ get_insert_query_def(Query *query, deparse_context *context)
 
 			appendStringInfo(buf, sep);
 			sep = ", ";
-			get_tle_expr(tle, context);
+			get_rule_expr(tle->expr, context);
 		}
 		appendStringInfoChar(buf, ')');
 	}
@@ -1694,7 +1692,7 @@ get_update_query_def(Query *query, deparse_context *context)
 		if (!tleIsArrayAssign(tle))
 			appendStringInfo(buf, "%s = ",
 							 quote_identifier(tle->resdom->resname));
-		get_tle_expr(tle, context);
+		get_rule_expr(tle->expr, context);
 	}
 
 	/* Add the FROM clause if needed */
@@ -2106,12 +2104,29 @@ get_rule_expr(Node *node, deparse_context *context)
 		case T_RelabelType:
 			{
 				RelabelType *relabel = (RelabelType *) node;
+				Node   *arg = relabel->arg;
 
-				appendStringInfoChar(buf, '(');
-				get_rule_expr(relabel->arg, context);
-				appendStringInfo(buf, ")::%s",
+				if (relabel->relabelformat == COERCE_IMPLICIT_CAST)
+				{
+					/* don't show an implicit cast */
+					get_rule_expr(arg, context);
+				}
+				else
+				{
+					/*
+					 * Strip off any type coercions on the input, so we don't
+					 * print redundancies like x::bpchar::character(8).
+					 *
+					 * XXX Are there any cases where this is a bad idea?
+					 */
+					arg = strip_type_coercion(arg, relabel->resulttype);
+
+					appendStringInfoChar(buf, '(');
+					get_rule_expr(arg, context);
+					appendStringInfo(buf, ")::%s",
 							format_type_with_typemod(relabel->resulttype,
-												 relabel->resulttypmod));
+													 relabel->resulttypmod));
+				}
 			}
 			break;
 
@@ -2305,21 +2320,33 @@ get_func_expr(Expr *expr, deparse_context *context)
 	StringInfo	buf = context->buf;
 	Func	   *func = (Func *) (expr->oper);
 	Oid			funcoid = func->funcid;
-	int32		coercedTypmod;
 	Oid			argtypes[FUNC_MAX_ARGS];
 	int			nargs;
 	List	   *l;
 	char	   *sep;
 
 	/*
-	 * Check to see if function is a length-coercion function for some
-	 * datatype.  If so, display the operation as a type cast.
+	 * If the function call came from an implicit coercion, then just show
+	 * the first argument.
 	 */
-	if (exprIsLengthCoercion((Node *) expr, &coercedTypmod))
+	if (func->funcformat == COERCE_IMPLICIT_CAST)
+	{
+		get_rule_expr((Node *) lfirst(expr->args), context);
+		return;
+	}
+
+	/*
+	 * If the function call came from an explicit cast, then show
+	 * the first argument plus an explicit cast operation.
+	 */
+	if (func->funcformat == COERCE_EXPLICIT_CAST)
 	{
 		Node	   *arg = lfirst(expr->args);
-		Oid			rettype = get_func_rettype(funcoid);
-		char	   *typdesc;
+		Oid			rettype = expr->typeOid;
+		int32		coercedTypmod;
+
+		/* Get the typmod if this is a length-coercion function */
+		(void) exprIsLengthCoercion((Node *) expr, &coercedTypmod);
 
 		/*
 		 * Strip off any type coercions on the input, so we don't print
@@ -2331,17 +2358,8 @@ get_func_expr(Expr *expr, deparse_context *context)
 
 		appendStringInfoChar(buf, '(');
 		get_rule_expr(arg, context);
-
-		/*
-		 * Show typename with appropriate length decoration. Note that
-		 * since exprIsLengthCoercion succeeded, the function's output
-		 * type is the right thing to report.  Also note we don't need to
-		 * quote the result of format_type_with_typemod: it takes care of
-		 * double-quoting any identifier that needs it.
-		 */
-		typdesc = format_type_with_typemod(rettype, coercedTypmod);
-		appendStringInfo(buf, ")::%s", typdesc);
-		pfree(typdesc);
+		appendStringInfo(buf, ")::%s",
+						 format_type_with_typemod(rettype, coercedTypmod));
 
 		return;
 	}
@@ -2393,15 +2411,14 @@ get_agg_expr(Aggref *aggref, deparse_context *context)
 
 /*
  * strip_type_coercion
- *		Strip any type coercions at the top of the given expression tree,
- *		as long as they are coercions to the given datatype.
+ *		Strip any type coercion at the top of the given expression tree,
+ *		if it is a coercion to the given datatype.
  *
- * A RelabelType node is always a type coercion.  A function call is
- * also considered a type coercion if it has one argument and there is
- * a cast declared that uses it.
+ * We use this to avoid printing two levels of coercion in situations where
+ * the expression tree has a length-coercion node atop a type-coercion node.
  *
- * XXX It'd be better if the parsetree retained some explicit indication
- * of the coercion, so we didn't need these heuristics.
+ * Note: avoid stripping a length-coercion node, since two successive
+ * coercions to different lengths aren't a no-op.
  */
 static Node *
 strip_type_coercion(Node *expr, Oid resultType)
@@ -2409,101 +2426,30 @@ strip_type_coercion(Node *expr, Oid resultType)
 	if (expr == NULL || exprType(expr) != resultType)
 		return expr;
 
-	if (IsA(expr, RelabelType))
-		return strip_type_coercion(((RelabelType *) expr)->arg, resultType);
+	if (IsA(expr, RelabelType) &&
+		((RelabelType *) expr)->resulttypmod == -1)
+		return ((RelabelType *) expr)->arg;
 
 	if (IsA(expr, Expr) &&
 		((Expr *) expr)->opType == FUNC_EXPR)
 	{
-		Func	   *func;
-		HeapTuple	procTuple;
-		HeapTuple	castTuple;
-		Form_pg_proc procStruct;
-		Form_pg_cast castStruct;
+		Func	   *func = (Func *) (((Expr *) expr)->oper);
 
-		func = (Func *) (((Expr *) expr)->oper);
 		Assert(IsA(func, Func));
-		if (length(((Expr *) expr)->args) != 1)
+		if (func->funcformat != COERCE_EXPLICIT_CAST &&
+			func->funcformat != COERCE_IMPLICIT_CAST)
+			return expr;		/* don't absorb into upper coercion */
+
+		if (exprIsLengthCoercion(expr, NULL))
 			return expr;
-		/* Lookup the function in pg_proc */
-		procTuple = SearchSysCache(PROCOID,
-								   ObjectIdGetDatum(func->funcid),
-								   0, 0, 0);
-		if (!HeapTupleIsValid(procTuple))
-			elog(ERROR, "cache lookup for proc %u failed", func->funcid);
-		procStruct = (Form_pg_proc) GETSTRUCT(procTuple);
-		/* Double-check func has one arg and correct result type */
-		if (procStruct->pronargs != 1 ||
-			procStruct->prorettype != resultType)
-		{
-			ReleaseSysCache(procTuple);
-			return expr;
-		}
-		/* See if function has is actually declared as a cast */
-		castTuple = SearchSysCache(CASTSOURCETARGET,
-							ObjectIdGetDatum(procStruct->proargtypes[0]),
-								ObjectIdGetDatum(procStruct->prorettype),
-								   0, 0);
-		if (!HeapTupleIsValid(castTuple))
-		{
-			ReleaseSysCache(procTuple);
-			return expr;
-		}
-		/* It must also be an implicit cast. */
-		castStruct = (Form_pg_cast) GETSTRUCT(castTuple);
-		if (!castStruct->castimplicit)
-		{
-			ReleaseSysCache(procTuple);
-			ReleaseSysCache(castTuple);
-			return expr;
-		}
-		/* Okay, it is indeed a type-coercion function */
-		ReleaseSysCache(procTuple);
-		ReleaseSysCache(castTuple);
-		return strip_type_coercion(lfirst(((Expr *) expr)->args), resultType);
+
+		return (Node *) lfirst(((Expr *) expr)->args);
 	}
 
 	return expr;
 }
 
 
-/* ----------
- * get_tle_expr
- *
- *		In an INSERT or UPDATE targetlist item, the parser may have inserted
- *		a length-coercion function call to coerce the value to the right
- *		length for the target column.  We want to suppress the output of
- *		that function call, otherwise dump/reload/dump... would blow up the
- *		expression by adding more and more layers of length-coercion calls.
- *
- * As of 7.0, this hack is no longer absolutely essential, because the parser
- * is now smart enough not to add a redundant length coercion function call.
- * But we still suppress the function call just for neatness of displayed
- * rules.
- *
- * Note that this hack must NOT be applied to SELECT targetlist items;
- * any length coercion appearing there is something the user actually wrote.
- * ----------
- */
-static void
-get_tle_expr(TargetEntry *tle, deparse_context *context)
-{
-	Expr	   *expr = (Expr *) (tle->expr);
-	int32		coercedTypmod;
-
-	/*
-	 * If top level is a length coercion to the correct length, suppress
-	 * it; else dump the expression normally.
-	 */
-	if (tle->resdom->restypmod >= 0 &&
-		exprIsLengthCoercion((Node *) expr, &coercedTypmod) &&
-		coercedTypmod == tle->resdom->restypmod)
-		get_rule_expr((Node *) lfirst(expr->args), context);
-	else
-		get_rule_expr(tle->expr, context);
-}
-
-
 /* ----------
  * get_const_expr
  *
@@ -2518,6 +2464,8 @@ get_const_expr(Const *constval, deparse_context *context)
 	Form_pg_type typeStruct;
 	char	   *extval;
 	char	   *valptr;
+	bool		isfloat = false;
+	bool		needlabel;
 
 	if (constval->constisnull)
 	{
@@ -2563,8 +2511,12 @@ get_const_expr(Const *constval, deparse_context *context)
 				 * NaN, so we need not get too crazy about pattern
 				 * matching here.
 				 */
-				if (strspn(extval, "0123456789 +-eE.") == strlen(extval))
+				if (strspn(extval, "0123456789+-eE.") == strlen(extval))
+				{
 					appendStringInfo(buf, extval);
+					if (strcspn(extval, "eE.") != strlen(extval))
+						isfloat = true;	/* it looks like a float */
+				}
 				else
 					appendStringInfo(buf, "'%s'", extval);
 			}
@@ -2609,20 +2561,30 @@ get_const_expr(Const *constval, deparse_context *context)
 
 	pfree(extval);
 
+	/*
+	 * Append ::typename unless the constant will be implicitly typed as
+	 * the right type when it is read in.  XXX this code has to be kept
+	 * in sync with the behavior of the parser, especially make_const.
+	 */
 	switch (constval->consttype)
 	{
 		case BOOLOID:
 		case INT4OID:
-		case FLOAT8OID:
 		case UNKNOWNOID:
 			/* These types can be left unlabeled */
+			needlabel = false;
+			break;
+		case NUMERICOID:
+			/* Float-looking constants will be typed as numeric */
+			needlabel = !isfloat;
 			break;
 		default:
-			appendStringInfo(buf, "::%s",
-							 format_type_with_typemod(constval->consttype,
-													  -1));
+			needlabel = true;
 			break;
 	}
+	if (needlabel)
+		appendStringInfo(buf, "::%s",
+						 format_type_with_typemod(constval->consttype, -1));
 
 	ReleaseSysCache(typetup);
 }

src/backend/utils/adt/varbit.c

@@ -9,7 +9,7 @@
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/varbit.c,v 1.25 2002/09/04 20:31:29 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/varbit.c,v 1.26 2002/09/18 21:35:23 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -35,6 +35,11 @@
  *	  data section -- private data section for the bits data structures
  *		bitlength -- length of the bit string in bits
  *		bitdata   -- bit string, most significant byte first
+ *
+ *	The length of the bitdata vector should always be exactly as many
+ *	bytes as are needed for the given bitlength.  If the bitlength is
+ *	not a multiple of 8, the extra low-order padding bits of the last
+ *	byte must be zeroes.
  *----------
  */
 
@@ -104,7 +109,7 @@ bit_in(PG_FUNCTION_ARGS)
 	len = VARBITTOTALLEN(atttypmod);
 	result = (VarBit *) palloc(len);
 	/* set to 0 so that *r is always initialised and string is zero-padded */
-	memset(result, 0, len);
+	MemSet(result, 0, len);
 	VARATT_SIZEP(result) = len;
 	VARBITLEN(result) = atttypmod;
 
@@ -203,50 +208,52 @@ bit_out(PG_FUNCTION_ARGS)
 /* bit()
  * Converts a bit() type to a specific internal length.
  * len is the bitlength specified in the column definition.
+ *
+ * If doing implicit cast, raise error when source data is wrong length.
+ * If doing explicit cast, silently truncate or zero-pad to specified length.
  */
 Datum
 bit(PG_FUNCTION_ARGS)
 {
 	VarBit	   *arg = PG_GETARG_VARBIT_P(0);
 	int32		len = PG_GETARG_INT32(1);
+	bool		isExplicit = PG_GETARG_BOOL(2);
+	VarBit	   *result;
+	int			rlen;
+	int			ipad;
+	bits8		mask;
 
 	/* No work if typmod is invalid or supplied data matches it already */
 	if (len <= 0 || len == VARBITLEN(arg))
 		PG_RETURN_VARBIT_P(arg);
-	else
+
+	if (!isExplicit)
 		elog(ERROR, "Bit string length %d does not match type BIT(%d)",
 			 VARBITLEN(arg), len);
-	return 0;					/* quiet compiler */
-}
 
-/* _bit()
- * Converts an array of bit() elements to a specific internal length.
- * len is the bitlength specified in the column definition.
- */
-Datum
-_bit(PG_FUNCTION_ARGS)
-{
-	ArrayType  *v = PG_GETARG_ARRAYTYPE_P(0);
-	int32		len = PG_GETARG_INT32(1);
-	FunctionCallInfoData locfcinfo;
+	rlen = VARBITTOTALLEN(len);
+	result = (VarBit *) palloc(rlen);
+	/* set to 0 so that string is zero-padded */
+	MemSet(result, 0, rlen);
+	VARATT_SIZEP(result) = rlen;
+	VARBITLEN(result) = len;
+
+	memcpy(VARBITS(result), VARBITS(arg),
+		   Min(VARBITBYTES(result), VARBITBYTES(arg)));
 
 	/*
-	 * Since bit() is a built-in function, we should only need to look it
-	 * up once per run.
+	 * Make sure last byte is zero-padded if needed.  This is useless but
+	 * safe if source data was shorter than target length (we assume the
+	 * last byte of the source data was itself correctly zero-padded).
 	 */
-	static FmgrInfo bit_finfo;
+	ipad = VARBITPAD(result);
+	if (ipad > 0)
+	{
+		mask = BITMASK << ipad;
+		*(VARBITS(result) + VARBITBYTES(result) - 1) &= mask;
+	}
 
-	if (bit_finfo.fn_oid == InvalidOid)
-		fmgr_info_cxt(F_BIT, &bit_finfo, TopMemoryContext);
-
-	MemSet(&locfcinfo, 0, sizeof(locfcinfo));
-	locfcinfo.flinfo = &bit_finfo;
-	locfcinfo.nargs = 2;
-	/* We assume we are "strict" and need not worry about null inputs */
-	locfcinfo.arg[0] = PointerGetDatum(v);
-	locfcinfo.arg[1] = Int32GetDatum(len);
-
-	return array_map(&locfcinfo, BITOID, BITOID);
+	PG_RETURN_VARBIT_P(result);
 }
 
 /*
@@ -311,7 +318,7 @@ varbit_in(PG_FUNCTION_ARGS)
 	len = VARBITTOTALLEN(bitlen);
 	result = (VarBit *) palloc(len);
 	/* set to 0 so that *r is always initialised and string is zero-padded */
-	memset(result, 0, len);
+	MemSet(result, 0, len);
 	VARATT_SIZEP(result) = len;
 	VARBITLEN(result) = Min(bitlen, atttypmod);
 
@@ -406,20 +413,26 @@ varbit_out(PG_FUNCTION_ARGS)
 /* varbit()
  * Converts a varbit() type to a specific internal length.
  * len is the maximum bitlength specified in the column definition.
+ *
+ * If doing implicit cast, raise error when source data is too long.
+ * If doing explicit cast, silently truncate to max length.
  */
 Datum
 varbit(PG_FUNCTION_ARGS)
 {
 	VarBit	   *arg = PG_GETARG_VARBIT_P(0);
 	int32		len = PG_GETARG_INT32(1);
+	bool		isExplicit = PG_GETARG_BOOL(2);
 	VarBit	   *result;
 	int			rlen;
+	int			ipad;
+	bits8		mask;
 
 	/* No work if typmod is invalid or supplied data matches it already */
 	if (len <= 0 || len >= VARBITLEN(arg))
 		PG_RETURN_VARBIT_P(arg);
 
-	if (len < VARBITLEN(arg))
+	if (!isExplicit)
 		elog(ERROR, "Bit string too long for type BIT VARYING(%d)", len);
 
 	rlen = VARBITTOTALLEN(len);
@@ -429,39 +442,17 @@ varbit(PG_FUNCTION_ARGS)
 
 	memcpy(VARBITS(result), VARBITS(arg), VARBITBYTES(result));
 
+	/* Make sure last byte is zero-padded if needed */
+	ipad = VARBITPAD(result);
+	if (ipad > 0)
+	{
+		mask = BITMASK << ipad;
+		*(VARBITS(result) + VARBITBYTES(result) - 1) &= mask;
+	}
+
 	PG_RETURN_VARBIT_P(result);
 }
 
-/* _varbit()
- * Converts an array of bit() elements to a specific internal length.
- * len is the maximum bitlength specified in the column definition.
- */
-Datum
-_varbit(PG_FUNCTION_ARGS)
-{
-	ArrayType  *v = PG_GETARG_ARRAYTYPE_P(0);
-	int32		len = PG_GETARG_INT32(1);
-	FunctionCallInfoData locfcinfo;
-
-	/*
-	 * Since varbit() is a built-in function, we should only need to look
-	 * it up once per run.
-	 */
-	static FmgrInfo varbit_finfo;
-
-	if (varbit_finfo.fn_oid == InvalidOid)
-		fmgr_info_cxt(F_VARBIT, &varbit_finfo, TopMemoryContext);
-
-	MemSet(&locfcinfo, 0, sizeof(locfcinfo));
-	locfcinfo.flinfo = &varbit_finfo;
-	locfcinfo.nargs = 2;
-	/* We assume we are "strict" and need not worry about null inputs */
-	locfcinfo.arg[0] = PointerGetDatum(v);
-	locfcinfo.arg[1] = Int32GetDatum(len);
-
-	return array_map(&locfcinfo, VARBITOID, VARBITOID);
-}
-
 
 /*
  * Comparison operators
@@ -978,7 +969,7 @@ bitshiftleft(PG_FUNCTION_ARGS)
 	/* If we shifted all the bits out, return an all-zero string */
 	if (shft >= VARBITLEN(arg))
 	{
-		memset(r, 0, VARBITBYTES(arg));
+		MemSet(r, 0, VARBITBYTES(arg));
 		PG_RETURN_VARBIT_P(result);
 	}
 
@@ -991,7 +982,7 @@ bitshiftleft(PG_FUNCTION_ARGS)
 		/* Special case: we can do a memcpy */
 		len = VARBITBYTES(arg) - byte_shift;
 		memcpy(r, p, len);
-		memset(r + len, 0, byte_shift);
+		MemSet(r + len, 0, byte_shift);
 	}
 	else
 	{
@@ -1037,7 +1028,7 @@ bitshiftright(PG_FUNCTION_ARGS)
 	/* If we shifted all the bits out, return an all-zero string */
 	if (shft >= VARBITLEN(arg))
 	{
-		memset(r, 0, VARBITBYTES(arg));
+		MemSet(r, 0, VARBITBYTES(arg));
 		PG_RETURN_VARBIT_P(result);
 	}
 
@@ -1046,7 +1037,7 @@ bitshiftright(PG_FUNCTION_ARGS)
 	p = VARBITS(arg);
 
 	/* Set the first part of the result to 0 */
-	memset(r, 0, byte_shift);
+	MemSet(r, 0, byte_shift);
 	r += byte_shift;
 
 	if (ishift == 0)

src/backend/utils/adt/varchar.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/varchar.c,v 1.94 2002/09/04 20:31:29 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/varchar.c,v 1.95 2002/09/18 21:35:23 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -165,21 +165,28 @@ bpcharout(PG_FUNCTION_ARGS)
 
 
 /*
- * Converts a CHARACTER type to the specified size.  maxlen is the new
- * declared length plus VARHDRSZ bytes.  Truncation
- * rules see bpcharin() above.
+ * Converts a CHARACTER type to the specified size.
+ *
+ * maxlen is the typmod, ie, declared length plus VARHDRSZ bytes.
+ * isExplicit is true if this is for an explicit cast to char(N).
+ *
+ * Truncation rules: for an explicit cast, silently truncate to the given
+ * length; for an implicit cast, raise error unless extra characters are
+ * all spaces.  (This is sort-of per SQL: the spec would actually have us
+ * raise a "completion condition" for the explicit cast case, but Postgres
+ * hasn't got such a concept.)
  */
 Datum
 bpchar(PG_FUNCTION_ARGS)
 {
 	BpChar	   *source = PG_GETARG_BPCHAR_P(0);
 	int32		maxlen = PG_GETARG_INT32(1);
+	bool		isExplicit = PG_GETARG_BOOL(2);
 	BpChar	   *result;
 	int32		len;
 	char	   *r;
 	char	   *s;
 	int			i;
-
 	int			charlen;		/* number of charcters in the input string
 								 * + VARHDRSZ */
 
@@ -188,7 +195,7 @@ bpchar(PG_FUNCTION_ARGS)
 	charlen = pg_mbstrlen_with_len(VARDATA(source), len - VARHDRSZ) + VARHDRSZ;
 
 	/* No work if typmod is invalid or supplied data matches it already */
-	if (maxlen < (int32) VARHDRSZ || len == maxlen)
+	if (maxlen < (int32) VARHDRSZ || charlen == maxlen)
 		PG_RETURN_BPCHAR_P(source);
 
 	if (charlen > maxlen)
@@ -199,10 +206,13 @@ bpchar(PG_FUNCTION_ARGS)
 		maxmblen = pg_mbcharcliplen(VARDATA(source), len - VARHDRSZ,
 									maxlen - VARHDRSZ) + VARHDRSZ;
 
-		for (i = maxmblen - VARHDRSZ; i < len - VARHDRSZ; i++)
-			if (*(VARDATA(source) + i) != ' ')
-				elog(ERROR, "value too long for type character(%d)",
-					 maxlen - VARHDRSZ);
+		if (!isExplicit)
+		{
+			for (i = maxmblen - VARHDRSZ; i < len - VARHDRSZ; i++)
+				if (*(VARDATA(source) + i) != ' ')
+					elog(ERROR, "value too long for type character(%d)",
+						 maxlen - VARHDRSZ);
+		}
 
 		len = maxmblen;
 
@@ -238,37 +248,6 @@ bpchar(PG_FUNCTION_ARGS)
 }
 
 
-/* _bpchar()
- * Converts an array of char() elements to a specific internal length.
- * len is the length specified in () plus VARHDRSZ bytes.
- */
-Datum
-_bpchar(PG_FUNCTION_ARGS)
-{
-	ArrayType  *v = PG_GETARG_ARRAYTYPE_P(0);
-	int32		len = PG_GETARG_INT32(1);
-	FunctionCallInfoData locfcinfo;
-
-	/*
-	 * Since bpchar() is a built-in function, we should only need to look
-	 * it up once per run.
-	 */
-	static FmgrInfo bpchar_finfo;
-
-	if (bpchar_finfo.fn_oid == InvalidOid)
-		fmgr_info_cxt(F_BPCHAR, &bpchar_finfo, TopMemoryContext);
-
-	MemSet(&locfcinfo, 0, sizeof(locfcinfo));
-	locfcinfo.flinfo = &bpchar_finfo;
-	locfcinfo.nargs = 2;
-	/* We assume we are "strict" and need not worry about null inputs */
-	locfcinfo.arg[0] = PointerGetDatum(v);
-	locfcinfo.arg[1] = Int32GetDatum(len);
-
-	return array_map(&locfcinfo, BPCHAROID, BPCHAROID);
-}
-
-
 /* char_bpchar()
  * Convert char to bpchar(1).
  */
@@ -354,9 +333,9 @@ name_bpchar(PG_FUNCTION_ARGS)
  * Note that atttypmod is regarded as the number of characters, which
  * is not necessarily the same as the number of bytes.
  *
- * If the C string is too long,
- * raise an error, unless the extra characters are spaces, in which
- * case they're truncated.  (per SQL) */
+ * If the C string is too long, raise an error, unless the extra characters
+ * are spaces, in which case they're truncated.  (per SQL)
+ */
 Datum
 varcharin(PG_FUNCTION_ARGS)
 {
@@ -428,17 +407,26 @@ varcharout(PG_FUNCTION_ARGS)
 
 
 /*
- * Converts a VARCHAR type to the specified size.  maxlen is the new
- * declared length plus VARHDRSZ bytes.  Truncation
- * rules see varcharin() above.
+ * Converts a VARCHAR type to the specified size.
+ *
+ * maxlen is the typmod, ie, declared length plus VARHDRSZ bytes.
+ * isExplicit is true if this is for an explicit cast to varchar(N).
+ *
+ * Truncation rules: for an explicit cast, silently truncate to the given
+ * length; for an implicit cast, raise error unless extra characters are
+ * all spaces.  (This is sort-of per SQL: the spec would actually have us
+ * raise a "completion condition" for the explicit cast case, but Postgres
+ * hasn't got such a concept.)
  */
 Datum
 varchar(PG_FUNCTION_ARGS)
 {
 	VarChar    *source = PG_GETARG_VARCHAR_P(0);
 	int32		maxlen = PG_GETARG_INT32(1);
+	bool		isExplicit = PG_GETARG_BOOL(2);
 	VarChar    *result;
 	int32		len;
+	size_t		maxmblen;
 	int			i;
 
 	len = VARSIZE(source);
@@ -448,21 +436,19 @@ varchar(PG_FUNCTION_ARGS)
 
 	/* only reach here if string is too long... */
 
+	/* truncate multibyte string preserving multibyte boundary */
+	maxmblen = pg_mbcharcliplen(VARDATA(source), len - VARHDRSZ,
+								maxlen - VARHDRSZ);
+
+	if (!isExplicit)
 	{
-		size_t		maxmblen;
-
-		/* truncate multibyte string preserving multibyte boundary */
-		maxmblen = pg_mbcharcliplen(VARDATA(source), len - VARHDRSZ,
-									maxlen - VARHDRSZ) + VARHDRSZ;
-
-		for (i = maxmblen - VARHDRSZ; i < len - VARHDRSZ; i++)
+		for (i = maxmblen; i < len - VARHDRSZ; i++)
 			if (*(VARDATA(source) + i) != ' ')
 				elog(ERROR, "value too long for type character varying(%d)",
 					 maxlen - VARHDRSZ);
-
-		len = maxmblen;
 	}
 
+	len = maxmblen + VARHDRSZ;
 	result = palloc(len);
 	VARATT_SIZEP(result) = len;
 	memcpy(VARDATA(result), VARDATA(source), len - VARHDRSZ);
@@ -471,38 +457,6 @@ varchar(PG_FUNCTION_ARGS)
 }
 
 
-/* _varchar()
- * Converts an array of varchar() elements to the specified size.
- * len is the length specified in () plus VARHDRSZ bytes.
- */
-Datum
-_varchar(PG_FUNCTION_ARGS)
-{
-	ArrayType  *v = PG_GETARG_ARRAYTYPE_P(0);
-	int32		len = PG_GETARG_INT32(1);
-	FunctionCallInfoData locfcinfo;
-
-	/*
-	 * Since varchar() is a built-in function, we should only need to look
-	 * it up once per run.
-	 */
-	static FmgrInfo varchar_finfo;
-
-	if (varchar_finfo.fn_oid == InvalidOid)
-		fmgr_info_cxt(F_VARCHAR, &varchar_finfo, TopMemoryContext);
-
-	MemSet(&locfcinfo, 0, sizeof(locfcinfo));
-	locfcinfo.flinfo = &varchar_finfo;
-	locfcinfo.nargs = 2;
-	/* We assume we are "strict" and need not worry about null inputs */
-	locfcinfo.arg[0] = PointerGetDatum(v);
-	locfcinfo.arg[1] = Int32GetDatum(len);
-
-	return array_map(&locfcinfo, VARCHAROID, VARCHAROID);
-}
-
-
-
 /*****************************************************************************
  * Exported functions
  *****************************************************************************/

src/backend/utils/cache/lsyscache.c

@@ -7,7 +7,7 @@
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/utils/cache/lsyscache.c,v 1.83 2002/09/04 20:31:30 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/utils/cache/lsyscache.c,v 1.84 2002/09/18 21:35:23 tgl Exp $
  *
  * NOTES
  *	  Eventually, the index information should go through here, too.
@@ -1073,51 +1073,6 @@ getBaseType(Oid typid)
 	return typid;
 }
 
-/*
- * getBaseTypeMod
- *		If the given type is a domain, return the typmod it applies to
- *		its base type; otherwise return the specified original typmod.
- */
-int32
-getBaseTypeMod(Oid typid, int32 typmod)
-{
-	/*
-	 * We loop to find the bottom base type in a stack of domains.
-	 */
-	for (;;)
-	{
-		HeapTuple	tup;
-		Form_pg_type typTup;
-
-		tup = SearchSysCache(TYPEOID,
-							 ObjectIdGetDatum(typid),
-							 0, 0, 0);
-		if (!HeapTupleIsValid(tup))
-			elog(ERROR, "getBaseTypeMod: failed to lookup type %u", typid);
-		typTup = (Form_pg_type) GETSTRUCT(tup);
-		if (typTup->typtype != 'd')
-		{
-			/* Not a domain, so done */
-			ReleaseSysCache(tup);
-			break;
-		}
-
-		/*
-		 * The typmod applied to a domain should always be -1.
-		 *
-		 * We substitute the domain's typmod as we switch attention to the
-		 * base type.
-		 */
-		Assert(typmod < 0);
-
-		typid = typTup->typbasetype;
-		typmod = typTup->typtypmod;
-		ReleaseSysCache(tup);
-	}
-
-	return typmod;
-}
-
 /*
  * get_typavgwidth
  *