*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/catalog/pg_proc.c,v 1.97 2003/06/15 17:59:10 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/catalog/pg_proc.c,v 1.98 2003/07/01 00:04:37 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "utils/syscache.h"
-static void checkretval(Oid rettype, char fn_typtype, List *queryTreeList);
Datum fmgr_internal_validator(PG_FUNCTION_ARGS);
Datum fmgr_c_validator(PG_FUNCTION_ARGS);
Datum fmgr_sql_validator(PG_FUNCTION_ARGS);
}
/*
- * checkretval() -- check return value of a list of sql parse trees.
+ * check_sql_fn_retval() -- check return value of a list of sql parse trees.
*
* The return value of a sql function is the value returned by
- * the final query in the function. We do some ad-hoc define-time
- * type checking here to be sure that the user is returning the
- * type he claims.
+ * the final query in the function. We do some ad-hoc type checking here
+ * to be sure that the user is returning the type he claims.
+ *
+ * This is normally applied during function definition, but in the case
+ * of a function with polymorphic arguments, we instead apply it during
+ * function execution startup. The rettype is then the actual resolved
+ * output type of the function, rather than the declared type. (Therefore,
+ * we should never see ANYARRAY or ANYELEMENT as rettype.)
*/
-static void
-checkretval(Oid rettype, char fn_typtype, List *queryTreeList)
+void
+check_sql_fn_retval(Oid rettype, char fn_typtype, List *queryTreeList)
{
Query *parse;
int cmd;
relation_close(reln, AccessShareLock);
}
- else if (fn_typtype == 'p' && rettype == RECORDOID)
+ else if (rettype == RECORDOID)
{
/* Shouldn't have a typerelid */
Assert(typerelid == InvalidOid);
* tuple.
*/
}
+ else if (rettype == ANYARRAYOID || rettype == ANYELEMENTOID)
+ {
+ /*
+ * This should already have been caught ...
+ */
+ elog(ERROR, "functions returning ANYARRAY or ANYELEMENT must " \
+ "have at least one argument of either type");
+ }
else
elog(ERROR, "return type %s is not supported for SQL functions",
format_type_be(rettype));
Datum tmp;
char *prosrc;
- tuple = SearchSysCache(PROCOID, funcoid, 0, 0, 0);
+ tuple = SearchSysCache(PROCOID,
+ ObjectIdGetDatum(funcoid),
+ 0, 0, 0);
if (!HeapTupleIsValid(tuple))
elog(ERROR, "cache lookup of function %u failed", funcoid);
proc = (Form_pg_proc) GETSTRUCT(tuple);
char *prosrc;
char *probin;
- tuple = SearchSysCache(PROCOID, funcoid, 0, 0, 0);
+ tuple = SearchSysCache(PROCOID,
+ ObjectIdGetDatum(funcoid),
+ 0, 0, 0);
if (!HeapTupleIsValid(tuple))
elog(ERROR, "cache lookup of function %u failed", funcoid);
proc = (Form_pg_proc) GETSTRUCT(tuple);
Datum tmp;
char *prosrc;
char functyptype;
+ bool haspolyarg;
int i;
- tuple = SearchSysCache(PROCOID, funcoid, 0, 0, 0);
+ tuple = SearchSysCache(PROCOID,
+ ObjectIdGetDatum(funcoid),
+ 0, 0, 0);
if (!HeapTupleIsValid(tuple))
elog(ERROR, "cache lookup of function %u failed", funcoid);
proc = (Form_pg_proc) GETSTRUCT(tuple);
functyptype = get_typtype(proc->prorettype);
- /* Disallow pseudotypes in arguments and result */
- /* except that return type can be RECORD or VOID */
+ /* Disallow pseudotype result */
+ /* except for RECORD, VOID, ANYARRAY, or ANYELEMENT */
if (functyptype == 'p' &&
proc->prorettype != RECORDOID &&
- proc->prorettype != VOIDOID)
+ proc->prorettype != VOIDOID &&
+ proc->prorettype != ANYARRAYOID &&
+ proc->prorettype != ANYELEMENTOID)
elog(ERROR, "SQL functions cannot return type %s",
format_type_be(proc->prorettype));
+ /* Disallow pseudotypes in arguments */
+ /* except for ANYARRAY or ANYELEMENT */
+ haspolyarg = false;
for (i = 0; i < proc->pronargs; i++)
{
if (get_typtype(proc->proargtypes[i]) == 'p')
- elog(ERROR, "SQL functions cannot have arguments of type %s",
- format_type_be(proc->proargtypes[i]));
+ {
+ if (proc->proargtypes[i] == ANYARRAYOID ||
+ proc->proargtypes[i] == ANYELEMENTOID)
+ haspolyarg = true;
+ else
+ elog(ERROR, "SQL functions cannot have arguments of type %s",
+ format_type_be(proc->proargtypes[i]));
+ }
}
- tmp = SysCacheGetAttr(PROCOID, tuple, Anum_pg_proc_prosrc, &isnull);
- if (isnull)
- elog(ERROR, "null prosrc");
+ /*
+ * We can't precheck the function definition if there are any polymorphic
+ * input types, because actual datatypes of expression results will be
+ * unresolvable. The check will be done at runtime instead.
+ */
+ if (!haspolyarg)
+ {
+ tmp = SysCacheGetAttr(PROCOID, tuple, Anum_pg_proc_prosrc, &isnull);
+ if (isnull)
+ elog(ERROR, "null prosrc");
- prosrc = DatumGetCString(DirectFunctionCall1(textout, tmp));
+ prosrc = DatumGetCString(DirectFunctionCall1(textout, tmp));
- querytree_list = pg_parse_and_rewrite(prosrc, proc->proargtypes, proc->pronargs);
- checkretval(proc->prorettype, functyptype, querytree_list);
+ querytree_list = pg_parse_and_rewrite(prosrc,
+ proc->proargtypes,
+ proc->pronargs);
+ check_sql_fn_retval(proc->prorettype, functyptype, querytree_list);
+ }
ReleaseSysCache(tuple);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/functions.c,v 1.66 2003/06/12 17:29:26 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/functions.c,v 1.67 2003/07/01 00:04:37 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "tcop/tcopprot.h"
#include "tcop/utility.h"
#include "utils/builtins.h"
+#include "utils/lsyscache.h"
#include "utils/syscache.h"
/* non-export function prototypes */
static execution_state *init_execution_state(char *src,
- Oid *argOidVect, int nargs);
+ Oid *argOidVect, int nargs,
+ Oid rettype, bool haspolyarg);
static void init_sql_fcache(FmgrInfo *finfo);
static void postquel_start(execution_state *es, SQLFunctionCachePtr fcache);
static TupleTableSlot *postquel_getnext(execution_state *es);
static execution_state *
-init_execution_state(char *src, Oid *argOidVect, int nargs)
+init_execution_state(char *src, Oid *argOidVect, int nargs,
+ Oid rettype, bool haspolyarg)
{
execution_state *firstes;
execution_state *preves;
queryTree_list = pg_parse_and_rewrite(src, argOidVect, nargs);
+ /*
+ * If the function has any arguments declared as polymorphic types,
+ * then it wasn't type-checked at definition time; must do so now.
+ */
+ if (haspolyarg)
+ check_sql_fn_retval(rettype, get_typtype(rettype), queryTree_list);
+
firstes = NULL;
preves = NULL;
init_sql_fcache(FmgrInfo *finfo)
{
Oid foid = finfo->fn_oid;
+ Oid rettype;
HeapTuple procedureTuple;
HeapTuple typeTuple;
Form_pg_proc procedureStruct;
Form_pg_type typeStruct;
SQLFunctionCachePtr fcache;
Oid *argOidVect;
+ bool haspolyarg;
char *src;
int nargs;
Datum tmp;
bool isNull;
+ fcache = (SQLFunctionCachePtr) palloc0(sizeof(SQLFunctionCache));
+
/*
* get the procedure tuple corresponding to the given function Oid
*/
if (!HeapTupleIsValid(procedureTuple))
elog(ERROR, "init_sql_fcache: Cache lookup failed for procedure %u",
foid);
-
procedureStruct = (Form_pg_proc) GETSTRUCT(procedureTuple);
/*
- * get the return type from the procedure tuple
+ * get the result type from the procedure tuple, and check for
+ * polymorphic result type; if so, find out the actual result type.
*/
+ rettype = procedureStruct->prorettype;
+
+ if (rettype == ANYARRAYOID || rettype == ANYELEMENTOID)
+ {
+ rettype = get_fn_expr_rettype(finfo);
+ if (rettype == InvalidOid)
+ elog(ERROR, "could not determine actual result type for function declared %s",
+ format_type_be(procedureStruct->prorettype));
+ }
+
+ /* Now look up the actual result type */
typeTuple = SearchSysCache(TYPEOID,
- ObjectIdGetDatum(procedureStruct->prorettype),
+ ObjectIdGetDatum(rettype),
0, 0, 0);
if (!HeapTupleIsValid(typeTuple))
elog(ERROR, "init_sql_fcache: Cache lookup failed for type %u",
- procedureStruct->prorettype);
-
+ rettype);
typeStruct = (Form_pg_type) GETSTRUCT(typeTuple);
- fcache = (SQLFunctionCachePtr) palloc0(sizeof(SQLFunctionCache));
-
/*
* get the type length and by-value flag from the type tuple
*/
fcache->typlen = typeStruct->typlen;
- if (typeStruct->typtype != 'c' &&
- procedureStruct->prorettype != RECORDOID)
+ if (typeStruct->typtype != 'c' && rettype != RECORDOID)
{
/* The return type is not a composite type, so just use byval */
fcache->typbyval = typeStruct->typbyval;
fcache->funcSlot = NULL;
/*
- * Parse and plan the queries. We need the argument info to pass
+ * Parse and plan the queries. We need the argument type info to pass
* to the parser.
*/
nargs = procedureStruct->pronargs;
+ haspolyarg = false;
if (nargs > 0)
{
+ int argnum;
+
argOidVect = (Oid *) palloc(nargs * sizeof(Oid));
memcpy(argOidVect,
procedureStruct->proargtypes,
nargs * sizeof(Oid));
+ /* Resolve any polymorphic argument types */
+ for (argnum = 0; argnum < nargs; argnum++)
+ {
+ Oid argtype = argOidVect[argnum];
+
+ if (argtype == ANYARRAYOID || argtype == ANYELEMENTOID)
+ {
+ argtype = get_fn_expr_argtype(finfo, argnum);
+ if (argtype == InvalidOid)
+ elog(ERROR, "could not determine actual type of argument declared %s",
+ format_type_be(argOidVect[argnum]));
+ argOidVect[argnum] = argtype;
+ haspolyarg = true;
+ }
+ }
}
else
argOidVect = (Oid *) NULL;
foid);
src = DatumGetCString(DirectFunctionCall1(textout, tmp));
- fcache->func_state = init_execution_state(src, argOidVect, nargs);
+ fcache->func_state = init_execution_state(src, argOidVect, nargs,
+ rettype, haspolyarg);
pfree(src);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/util/clauses.c,v 1.142 2003/06/29 00:33:43 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/util/clauses.c,v 1.143 2003/07/01 00:04:37 tgl Exp $
*
* HISTORY
* AUTHOR DATE MAJOR EVENT
int *usecounts;
List *arg;
int i;
+ int j;
/*
* Forget it if the function is not SQL-language or has other
funcform->pronargs != length(args))
return NULL;
- /* Forget it if declared return type is tuple or void */
+ /* Forget it if declared return type is not base or domain */
result_typtype = get_typtype(funcform->prorettype);
if (result_typtype != 'b' &&
result_typtype != 'd')
return NULL;
+ /* Forget it if any declared argument type is polymorphic */
+ for (j = 0; j < funcform->pronargs; j++)
+ {
+ if (funcform->proargtypes[j] == ANYARRAYOID ||
+ funcform->proargtypes[j] == ANYELEMENTOID)
+ return NULL;
+ }
+
/* Check for recursive function, and give up trying to expand if so */
if (oidMember(funcid, active_fns))
return NULL;
* Copyright (c) 2003, PostgreSQL Global Development Group
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/array_userfuncs.c,v 1.4 2003/06/27 00:33:25 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/array_userfuncs.c,v 1.5 2003/07/01 00:04:38 tgl Exp $
*
*-------------------------------------------------------------------------
*/
int16 typlen;
bool typbyval;
char typalign;
- Oid arg0_typeid = get_fn_expr_argtype(fcinfo, 0);
- Oid arg1_typeid = get_fn_expr_argtype(fcinfo, 1);
+ Oid arg0_typeid = get_fn_expr_argtype(fcinfo->flinfo, 0);
+ Oid arg1_typeid = get_fn_expr_argtype(fcinfo->flinfo, 1);
Oid arg0_elemid;
Oid arg1_elemid;
ArrayMetaState *my_extra;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/arrayfuncs.c,v 1.92 2003/06/27 00:33:25 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/arrayfuncs.c,v 1.93 2003/07/01 00:04:38 tgl Exp $
*
*-------------------------------------------------------------------------
*/
if (my_extra->srctype != src_elem_type)
{
- Oid tgt_type = get_fn_expr_rettype(fcinfo);
+ Oid tgt_type = get_fn_expr_rettype(fmgr_info);
Oid tgt_elem_type;
Oid funcId;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/fmgr/fmgr.c,v 1.71 2003/06/29 00:33:44 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/fmgr/fmgr.c,v 1.72 2003/07/01 00:04:38 tgl Exp $
*
*-------------------------------------------------------------------------
*/
/*-------------------------------------------------------------------------
* Support routines for extracting info from fn_expr parse tree
+ *
+ * These are needed by polymorphic functions, which accept multiple possible
+ * input types and need help from the parser to know what they've got.
*-------------------------------------------------------------------------
*/
/*
- * Get the OID of the function return type
+ * Get the actual type OID of the function return type
*
* Returns InvalidOid if information is not available
*/
Oid
-get_fn_expr_rettype(FunctionCallInfo fcinfo)
+get_fn_expr_rettype(FmgrInfo *flinfo)
{
Node *expr;
* can't return anything useful if we have no FmgrInfo or if
* its fn_expr node has not been initialized
*/
- if (!fcinfo || !fcinfo->flinfo || !fcinfo->flinfo->fn_expr)
+ if (!flinfo || !flinfo->fn_expr)
return InvalidOid;
- expr = fcinfo->flinfo->fn_expr;
+ expr = flinfo->fn_expr;
return exprType(expr);
}
/*
- * Get the type OID of a specific function argument (counting from 0)
+ * Get the actual type OID of a specific function argument (counting from 0)
*
* Returns InvalidOid if information is not available
*/
Oid
-get_fn_expr_argtype(FunctionCallInfo fcinfo, int argnum)
+get_fn_expr_argtype(FmgrInfo *flinfo, int argnum)
{
Node *expr;
List *args;
* can't return anything useful if we have no FmgrInfo or if
* its fn_expr node has not been initialized
*/
- if (!fcinfo || !fcinfo->flinfo || !fcinfo->flinfo->fn_expr)
+ if (!flinfo || !flinfo->fn_expr)
return InvalidOid;
- expr = fcinfo->flinfo->fn_expr;
+ expr = flinfo->fn_expr;
if (IsA(expr, FuncExpr))
args = ((FuncExpr *) expr)->args;
* Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: pg_proc.h,v 1.308 2003/06/27 00:33:25 tgl Exp $
+ * $Id: pg_proc.h,v 1.309 2003/07/01 00:04:38 tgl Exp $
*
* NOTES
* The script catalog/genbki.sh reads this file and generates .bki
int parameterCount,
const Oid *parameterTypes);
+extern void check_sql_fn_retval(Oid rettype, char fn_typtype,
+ List *queryTreeList);
+
#endif /* PG_PROC_H */
* Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: fmgr.h,v 1.29 2003/06/25 21:30:32 momjian Exp $
+ * $Id: fmgr.h,v 1.30 2003/07/01 00:04:39 tgl Exp $
*
*-------------------------------------------------------------------------
*/
*/
extern Pg_finfo_record *fetch_finfo_record(void *filehandle, char *funcname);
extern Oid fmgr_internal_function(const char *proname);
-extern Oid get_fn_expr_rettype(FunctionCallInfo fcinfo);
-extern Oid get_fn_expr_argtype(FunctionCallInfo fcinfo, int argnum);
+extern Oid get_fn_expr_rettype(FmgrInfo *flinfo);
+extern Oid get_fn_expr_argtype(FmgrInfo *flinfo, int argnum);
/*
* Routines in dfmgr.c
projects / postgresql.git / commitdiff