Function-call-style type coercions should be treated as explicit

tglsfdc · tglsfdc · commit c3086c8f530e · 2002-10-24T22:09:00.000Z
coercions, not implicit ones.  For example, 'select abstime(1035497293)'
should succeed because there is an explicit binary coercion from int4
to abstime.
diff --git a/src/backend/parser/parse_coerce.c b/src/backend/parser/parse_coerce.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/parser/parse_coerce.c,v 2.84 2002/09/18 21:35:22 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/parser/parse_coerce.c,v 2.85 2002/10/24 22:09:00 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -32,9 +32,6 @@ 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,
-								  CoercionContext ccontext,
-								  Oid *funcid);
 static Node *build_func_call(Oid funcid, Oid rettype, List *args,
 							 CoercionForm fformat);
 
@@ -910,7 +907,7 @@ IsBinaryCoercible(Oid srctype, Oid targettype)
  * to the castfunc value (which may be InvalidOid for a binary-compatible
  * coercion).
  */
-static bool
+bool
 find_coercion_pathway(Oid targetTypeId, Oid sourceTypeId,
 					  CoercionContext ccontext,
 					  Oid *funcid)
diff --git a/src/backend/parser/parse_func.c b/src/backend/parser/parse_func.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/parser/parse_func.c,v 1.138 2002/10/19 21:23:20 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/parser/parse_func.c,v 1.139 2002/10/24 22:09:00 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -770,6 +770,11 @@ func_get_detail(List *funcname,
 		 * and ones that are coercing a previously-unknown-type literal
 		 * constant to a specific type.
 		 *
+		 * The reason we can restrict our check to binary-compatible
+		 * coercions here is that we expect non-binary-compatible coercions
+		 * to have an implementation function named after the target type.
+		 * That function will be found by normal lookup if appropriate.
+		 *
 		 * NB: it's important that this code stays in sync with what
 		 * coerce_type can do, because the caller will try to apply
 		 * coerce_type if we return FUNCDETAIL_COERCION.  If we return
@@ -791,7 +796,9 @@ func_get_detail(List *funcname,
 				Node	   *arg1 = lfirst(fargs);
 
 				if ((sourceType == UNKNOWNOID && IsA(arg1, Const)) ||
-					IsBinaryCoercible(sourceType, targetType))
+					(find_coercion_pathway(targetType, sourceType,
+										   COERCION_EXPLICIT, funcid) &&
+					 *funcid == InvalidOid))
 				{
 					/* Yup, it's a type coercion */
 					*funcid = InvalidOid;
diff --git a/src/include/parser/parse_coerce.h b/src/include/parser/parse_coerce.h
@@ -7,7 +7,7 @@
  * Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $Id: parse_coerce.h,v 1.47 2002/09/18 21:35:24 tgl Exp $
+ * $Id: parse_coerce.h,v 1.48 2002/10/24 22:09:00 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -54,6 +54,9 @@ extern Oid	select_common_type(List *typeids, const char *context);
 extern Node *coerce_to_common_type(Node *node, Oid targetTypeId,
 					  const char *context);
 
+extern bool find_coercion_pathway(Oid targetTypeId, Oid sourceTypeId,
+								  CoercionContext ccontext,
+								  Oid *funcid);
 extern Oid	find_typmod_coercion_function(Oid typeId, int *nargs);
 
 #endif   /* PARSE_COERCE_H */

Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@`
`8`	`8`	`*`
`9`	`9`	`*`
`10`	`10`	`* IDENTIFICATION`
`11`		`- * $Header: /cvsroot/pgsql/src/backend/parser/parse_func.c,v 1.138 2002/10/19 21:23:20 tgl Exp $`
	`11`	`+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_func.c,v 1.139 2002/10/24 22:09:00 tgl Exp $`
`12`	`12`	`*`
`13`	`13`	`*-------------------------------------------------------------------------`
`14`	`14`	`*/`
`@@ -770,6 +770,11 @@ func_get_detail(List *funcname,`
`770`	`770`	`* and ones that are coercing a previously-unknown-type literal`
`771`	`771`	`* constant to a specific type.`
`772`	`772`	`*`
	`773`	`+ * The reason we can restrict our check to binary-compatible`
	`774`	`+ * coercions here is that we expect non-binary-compatible coercions`
	`775`	`+ * to have an implementation function named after the target type.`
	`776`	`+ * That function will be found by normal lookup if appropriate.`
	`777`	`+ *`
`773`	`778`	`* NB: it's important that this code stays in sync with what`
`774`	`779`	`* coerce_type can do, because the caller will try to apply`
`775`	`780`	`* coerce_type if we return FUNCDETAIL_COERCION. If we return`
`@@ -791,7 +796,9 @@ func_get_detail(List *funcname,`
`791`	`796`	`Node *arg1 = lfirst(fargs);`
`792`	`797`
`793`	`798`	`if ((sourceType == UNKNOWNOID && IsA(arg1, Const)) \|\|`
`794`		`- IsBinaryCoercible(sourceType, targetType))`
	`799`	`+ (find_coercion_pathway(targetType, sourceType,`
	`800`	`+ COERCION_EXPLICIT, funcid) &&`
	`801`	`+ *funcid == InvalidOid))`
`795`	`802`	`{`
`796`	`803`	`/* Yup, it's a type coercion */`
`797`	`804`	`*funcid = InvalidOid;`