/* ------------------------------------------------------------------------- * * functions.cpp * Execution of SQL-language functions * * Portions Copyright (c) 2020 Huawei Technologies Co.,Ltd. * Portions Copyright (c) 1996-2012, PostgreSQL Global Development Group * Portions Copyright (c) 1994, Regents of the University of California * * * IDENTIFICATION * src/gausskernel/runtime/executor/functions.cpp * * ------------------------------------------------------------------------- */ #include "postgres.h" #include "knl/knl_variable.h" #include "access/transam.h" #include "access/tableam.h" #include "access/xact.h" #include "auditfuncs.h" #include "catalog/pg_proc.h" #include "catalog/pg_type.h" #include "executor/functions.h" #include "funcapi.h" #include "miscadmin.h" #include "nodes/makefuncs.h" #include "nodes/nodeFuncs.h" #include "parser/parse_coerce.h" #include "parser/parse_func.h" #include "storage/proc.h" #include "tcop/utility.h" #include "utils/builtins.h" #include "utils/datum.h" #include "utils/lsyscache.h" #include "utils/memutils.h" #include "utils/snapmgr.h" #include "utils/syscache.h" #ifdef STREAMPLAN #include "optimizer/streamplan.h" #endif #ifdef PGXC #include "pgxc/pgxc.h" #include "commands/prepare.h" #endif #include "securec.h" /* * Specialized DestReceiver for collecting query output in a SQL function */ typedef struct { DestReceiver pub; /* publicly-known function pointers */ Tuplestorestate* tstore; /* where to put result tuples */ MemoryContext cxt; /* context containing tstore */ JunkFilter* filter; /* filter to convert tuple type */ } DR_sqlfunction; /* * We have an execution_state record for each query in a function. Each * record contains a plantree for its query. If the query is currently in * F_EXEC_RUN state then there's a QueryDesc too. * * The "next" fields chain together all the execution_state records generated * from a single original parsetree. (There will only be more than one in * case of rule expansion of the original parsetree.) */ typedef enum { F_EXEC_START, F_EXEC_RUN, F_EXEC_DONE } ExecStatus; typedef struct execution_state { struct execution_state* next; ExecStatus status; bool setsResult; /* true if this query produces func's result */ bool lazyEval; /* true if should fetch one row at a time */ Node* stmt; /* PlannedStmt or utility statement */ QueryDesc* qd; /* null unless status == RUN */ } execution_state; /* * An SQLFunctionCache record is built during the first call, * and linked to from the fn_extra field of the FmgrInfo struct. * * Note that currently this has only the lifespan of the calling query. * Someday we should rewrite this code to use plancache.c to save parse/plan * results for longer than that. * * Physically, though, the data has the lifespan of the FmgrInfo that's used * to call the function, and there are cases (particularly with indexes) * where the FmgrInfo might survive across transactions. We cannot assume * that the parse/plan trees are good for longer than the (sub)transaction in * which parsing was done, so we must mark the record with the LXID/subxid of * its creation time, and regenerate everything if that's obsolete. To avoid * memory leakage when we do have to regenerate things, all the data is kept * in a sub-context of the FmgrInfo's fn_mcxt. */ typedef struct { char* fname; /* function name (for error msgs) */ char* src; /* function body text (for error msgs) */ SQLFunctionParseInfoPtr pinfo; /* data for parser callback hooks */ Oid rettype; /* actual return type */ int16 typlen; /* length of the return type */ bool typbyval; /* true if return type is pass by value */ bool returnsSet; /* true if returning multiple rows */ bool returnsTuple; /* true if returning whole tuple result */ bool shutdown_reg; /* true if registered shutdown callback */ bool readonly_func; /* true to run in "read only" mode */ bool lazyEval; /* true if using lazyEval for result query */ ParamListInfo paramLI; /* Param list representing current args */ Tuplestorestate* tstore; /* where we accumulate result tuples */ JunkFilter* junkFilter; /* will be NULL if function returns VOID */ /* * func_state is a List of execution_state records, each of which is the * first for its original parsetree, with any additional records chained * to it via the "next" fields. This sublist structure is needed to keep * track of where the original query boundaries are. */ List* func_state; MemoryContext fcontext; /* memory context holding this struct and all subsidiary data */ LocalTransactionId lxid; /* lxid in which cache was made */ SubTransactionId subxid; /* subxid in which cache was made */ } SQLFunctionCache; typedef SQLFunctionCache* SQLFunctionCachePtr; /* * Data structure needed by the parser callback hooks to resolve parameter * references during parsing of a SQL function's body. This is separate from * SQLFunctionCache since we sometimes do parsing separately from execution. */ typedef struct SQLFunctionParseInfo { char* fname; /* function's name */ int nargs; /* number of input arguments */ Oid* argtypes; /* resolved types of input arguments */ char** argnames; /* names of input arguments; NULL if none */ /* Note that argnames[i] can be NULL, if some args are unnamed */ Oid collation; /* function's input collation, if known */ } SQLFunctionParseInfo; /* non-export function prototypes */ static Node* sql_fn_param_ref(ParseState* p_state, ParamRef* p_ref); static Node* sql_fn_post_column_ref(ParseState* p_state, ColumnRef* c_ref, Node* var); static Node* sql_fn_make_param(SQLFunctionParseInfoPtr p_info, int param_no, int location); static Node* sql_fn_resolve_param_name(SQLFunctionParseInfoPtr p_info, const char* param_name, int location); static List* init_execution_state(List* query_tree_list, SQLFunctionCachePtr fcache, bool lazy_eval_ok); static void init_sql_fcache(FmgrInfo* finfo, Oid collation, bool lazy_eval_ok); static void postquel_start(execution_state* es, SQLFunctionCachePtr fcache); static bool postquel_getnext(execution_state* es, SQLFunctionCachePtr fcache); static void postquel_end(execution_state* es); static void postquel_sub_params(SQLFunctionCachePtr fcache, FunctionCallInfo fcinfo); static Datum postquel_get_single_result( TupleTableSlot* slot, FunctionCallInfo fcinfo, SQLFunctionCachePtr fcache, MemoryContext result_context); static void sql_exec_error_callback(void* arg); static void ShutdownSQLFunction(Datum arg); static void sqlfunction_startup(DestReceiver* self, int operation, TupleDesc type_info); static void sqlfunction_receive(TupleTableSlot* slot, DestReceiver* self); static void sqlfunction_shutdown(DestReceiver* self); static void sqlfunction_destroy(DestReceiver* self); /* * Prepare the SQLFunctionParseInfo struct for parsing a SQL function body * * This includes resolving actual types of polymorphic arguments. * * call_expr can be passed as NULL, but then we will fail if there are any * polymorphic arguments. */ SQLFunctionParseInfoPtr prepare_sql_fn_parse_info(HeapTuple procedure_tuple, Node* call_expr, Oid input_collation) { SQLFunctionParseInfoPtr p_info; Form_pg_proc procedure_struct = (Form_pg_proc)GETSTRUCT(procedure_tuple); int nargs; p_info = (SQLFunctionParseInfoPtr)palloc0(sizeof(SQLFunctionParseInfo)); /* Function's name (only) can be used to qualify argument names */ p_info->fname = pstrdup(NameStr(procedure_struct->proname)); /* Save the function's input collation */ p_info->collation = input_collation; /* * Copy input argument types from the pg_proc entry, then resolve any * polymorphic types. */ p_info->nargs = nargs = procedure_struct->pronargs; if (nargs <= 0) { p_info->argnames = NULL; return p_info; } Oid* arg_oid_vect = NULL; int arg_num; errno_t rc = EOK; arg_oid_vect = (Oid*)palloc(nargs * sizeof(Oid)); rc = memcpy_s(arg_oid_vect, nargs * sizeof(Oid), procedure_struct->proargtypes.values, nargs * sizeof(Oid)); securec_check(rc, "\0", "\0"); for (arg_num = 0; arg_num < nargs; arg_num++) { Oid arg_type = arg_oid_vect[arg_num]; if (IsPolymorphicType(arg_type)) { arg_type = get_call_expr_argtype(call_expr, arg_num); if (arg_type == InvalidOid) { ereport(ERROR, (errcode(ERRCODE_DATATYPE_MISMATCH), errmsg("could not determine actual type of argument declared %s", format_type_be(arg_oid_vect[arg_num])))); } arg_oid_vect[arg_num] = arg_type; } } p_info->argtypes = arg_oid_vect; /* * Collect names of arguments, too, if any */ Datum pro_arg_names; Datum pro_arg_modes; int n_arg_names; bool is_null = false; pro_arg_names = SysCacheGetAttr(PROCNAMEARGSNSP, procedure_tuple, Anum_pg_proc_proargnames, &is_null); if (is_null) { pro_arg_names = PointerGetDatum(NULL); /* just to be sure */ } pro_arg_modes = SysCacheGetAttr(PROCNAMEARGSNSP, procedure_tuple, Anum_pg_proc_proargmodes, &is_null); if (is_null) { pro_arg_modes = PointerGetDatum(NULL); /* just to be sure */ } n_arg_names = get_func_input_arg_names(pro_arg_names, pro_arg_modes, &p_info->argnames); /* Paranoia: ignore the result if too few array entries */ if (n_arg_names < nargs) { p_info->argnames = NULL; } return p_info; } /* * Parser setup hook for parsing a SQL function body. */ void sql_fn_parser_setup(struct ParseState* p_state, SQLFunctionParseInfoPtr p_info) { p_state->p_pre_columnref_hook = NULL; p_state->p_post_columnref_hook = sql_fn_post_column_ref; p_state->p_paramref_hook = sql_fn_param_ref; /* no need to use p_coerce_param_hook */ p_state->p_ref_hook_state = (void*)p_info; } /* * sql_fn_post_column_ref parser callback for ColumnRefs */ static Node* sql_fn_post_column_ref(ParseState* p_state, ColumnRef* c_ref, Node* var) { SQLFunctionParseInfoPtr p_info = (SQLFunctionParseInfoPtr)p_state->p_ref_hook_state; int n_names; Node* field1 = NULL; Node* sub_field = NULL; const char* name1 = NULL; const char* name2 = NULL; Node* param = NULL; /* * Never override a table-column reference. This corresponds to * considering the parameter names to appear in a scope outside the * individual SQL commands, which is what we want. */ if (var != NULL) return NULL; /* ---------- * The allowed syntaxes are: * * A A = parameter name * A.B A = function name, B = parameter name * OR: A = record-typed parameter name, B = field name * (the first possibility takes precedence) * A.B.C A = function name, B = record-typed parameter name, * C = field name * A.* Whole-row reference to composite parameter A. * A.B.* Same, with A = function name, B = parameter name * * Here, it's sufficient to ignore the "*" in the last two cases --- the * main parser will take care of expanding the whole-row reference. * ---------- */ n_names = list_length(c_ref->fields); if (n_names > 3) return NULL; if (IsA(llast(c_ref->fields), A_Star)) n_names--; field1 = (Node*)linitial(c_ref->fields); Assert(IsA(field1, String)); name1 = strVal(field1); if (n_names > 1) { sub_field = (Node*)lsecond(c_ref->fields); Assert(IsA(sub_field, String)); name2 = strVal(sub_field); } if (n_names == 3) { /* * Three-part name: if the first part doesn't match the function name, * we can fail immediately. Otherwise, look up the second part, and * take the third part to be a field reference. */ if (strcmp(name1, p_info->fname) != 0) return NULL; param = sql_fn_resolve_param_name(p_info, name2, c_ref->location); sub_field = (Node*)lthird(c_ref->fields); Assert(IsA(sub_field, String)); } else if (n_names == 2 && strcmp(name1, p_info->fname) == 0) { /* * Two-part name with first part matching function name: first see if * second part matches any parameter name. */ param = sql_fn_resolve_param_name(p_info, name2, c_ref->location); if (param != NULL) { /* Yes, so this is a parameter reference, no subfield */ sub_field = NULL; } else { /* No, so try to match as parameter name and subfield */ param = sql_fn_resolve_param_name(p_info, name1, c_ref->location); } } else { /* Single name, or parameter name followed by subfield */ param = sql_fn_resolve_param_name(p_info, name1, c_ref->location); } if (param == NULL) return NULL; /* No match */ if (sub_field != NULL) { /* * Must be a reference to a field of a composite parameter; otherwise * ParseFuncOrColumn will return NULL, and we'll fail back at the * caller. */ param = ParseFuncOrColumn(p_state, list_make1(sub_field), list_make1(param), NULL, c_ref->location); } return param; } /* * sql_fn_param_ref parser callback for ParamRefs ($n symbols) */ static Node* sql_fn_param_ref(ParseState* p_state, ParamRef* p_ref) { SQLFunctionParseInfoPtr p_info = (SQLFunctionParseInfoPtr)p_state->p_ref_hook_state; int param_no = p_ref->number; /* Check parameter number is valid */ if (param_no <= 0 || param_no > p_info->nargs) return NULL; /* unknown parameter number */ return sql_fn_make_param(p_info, param_no, p_ref->location); } /* * sql_fn_make_param construct a Param node for the given paramno */ static Node* sql_fn_make_param(SQLFunctionParseInfoPtr p_info, int param_no, int location) { Param* param = NULL; param = makeNode(Param); param->paramkind = PARAM_EXTERN; param->paramid = param_no; param->paramtype = p_info->argtypes[param_no - 1]; param->paramtypmod = -1; param->paramcollid = get_typcollation(param->paramtype); param->location = location; /* * If we have a function input collation, allow it to override the * type-derived collation for parameter symbols. (XXX perhaps this should * not happen if the type collation is not default?) */ if (OidIsValid(p_info->collation) && OidIsValid(param->paramcollid)) param->paramcollid = p_info->collation; return (Node*)param; } /* * Search for a function parameter of the given name; if there is one, * construct and return a Param node for it. If not, return NULL. * Helper function for sql_fn_post_column_ref. */ static Node* sql_fn_resolve_param_name(SQLFunctionParseInfoPtr p_info, const char* param_name, int location) { int i; if (p_info->argnames == NULL) return NULL; if (param_name == NULL) { ereport(ERROR, (errcode(ERRCODE_UNEXPECTED_NULL_VALUE), errmsg("paramname should not be NULL"))); } for (i = 0; i < p_info->nargs; i++) { if (p_info->argnames[i] && strcmp(p_info->argnames[i], param_name) == 0) return sql_fn_make_param(p_info, i + 1, location); } return NULL; } /* * Set up the per-query execution_state records for a SQL function. * * The input is a List of Lists of parsed and rewritten, but not planned, * querytrees. The sublist structure denotes the original query boundaries. */ static List* init_execution_state(List* query_tree_list, SQLFunctionCachePtr fcache, bool lazy_eval_ok) { List* es_list = NIL; execution_state* last_tages = NULL; ListCell* lc1 = NULL; foreach (lc1, query_tree_list) { List* qt_list = (List*)lfirst(lc1); execution_state* first_es = NULL; execution_state* prev_es = NULL; ListCell* lc2 = NULL; foreach (lc2, qt_list) { Query* query_tree = (Query*)lfirst(lc2); Node* stmt = NULL; execution_state* new_es = NULL; Assert(IsA(query_tree, Query)); /* Plan the query if needed */ if (query_tree->commandType == CMD_UTILITY) stmt = query_tree->utilityStmt; else stmt = (Node*)pg_plan_query(query_tree, 0, NULL); /* Precheck all commands for validity in a function */ if (IsA(stmt, TransactionStmt)) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), /* translator: %s is a SQL statement name */ errmsg("%s is not allowed in a SQL function", CreateCommandTag(stmt)))); if (fcache->readonly_func && !CommandIsReadOnly(stmt)) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), /* translator: %s is a SQL statement name */ errmsg("%s is not allowed in a non-volatile function", CreateCommandTag(stmt)))); /* OK, build the execution_state for this query */ new_es = (execution_state*)palloc(sizeof(execution_state)); if (prev_es != NULL) prev_es->next = new_es; else first_es = new_es; new_es->next = NULL; new_es->status = F_EXEC_START; new_es->setsResult = false; /* might change below */ new_es->lazyEval = false; /* might change below */ new_es->stmt = stmt; new_es->qd = NULL; if (query_tree->canSetTag) last_tages = new_es; prev_es = new_es; } es_list = lappend(es_list, first_es); } /* * Mark the last canSetTag query as delivering the function result; then, * if it is a plain SELECT, mark it for lazy evaluation. If it's not a * SELECT we must always run it to completion. * * Note: at some point we might add additional criteria for whether to use * lazy eval. However, we should prefer to use it whenever the function * doesn't return set, since fetching more than one row is useless in that * case. * * Note: don't set setsResult if the function returns VOID, as evidenced * by not having made a junkfilter. This ensures we'll throw away any * output from a utility statement that check_sql_fn_retval deemed to not * have output. */ if (last_tages != NULL && fcache->junkFilter) { last_tages->setsResult = true; if (lazy_eval_ok && IsA(last_tages->stmt, PlannedStmt)) { PlannedStmt* ps = (PlannedStmt*)last_tages->stmt; if (ps->commandType == CMD_SELECT && ps->utilityStmt == NULL && !ps->hasModifyingCTE) fcache->lazyEval = last_tages->lazyEval = true; } } return es_list; } /* * Initialize the SQLFunctionCache for a SQL function */ static void init_sql_fcache(FmgrInfo* finfo, Oid collation, bool lazy_eval_ok) { Oid f_oid = finfo->fn_oid; MemoryContext f_context; MemoryContext old_context; Oid ret_type; HeapTuple procedure_tuple; Form_pg_proc procedure_struct; SQLFunctionCachePtr fcache; List* raw_parsetree_list = NIL; List* query_tree_list = NIL; List* flat_query_list = NIL; ListCell* lc = NULL; Datum tmp; bool is_null = false; /* * Create memory context that holds all the SQLFunctionCache data. It * must be a child of whatever context holds the FmgrInfo. */ f_context = AllocSetContextCreate(finfo->fn_mcxt, "SQL function data", ALLOCSET_DEFAULT_MINSIZE, ALLOCSET_DEFAULT_INITSIZE, ALLOCSET_DEFAULT_MAXSIZE); old_context = MemoryContextSwitchTo(f_context); /* * Create the struct proper, link it to fcontext and fn_extra. Once this * is done, we'll be able to recover the memory after failure, even if the * FmgrInfo is long-lived. */ fcache = (SQLFunctionCachePtr)palloc0(sizeof(SQLFunctionCache)); fcache->fcontext = f_context; finfo->fn_extra = (void*)fcache; /* * get the procedure tuple corresponding to the given function Oid */ procedure_tuple = SearchSysCache1(PROCOID, ObjectIdGetDatum(f_oid)); if (!HeapTupleIsValid(procedure_tuple)) ereport(ERROR, (errcode(ERRCODE_CACHE_LOOKUP_FAILED), errmodule(MOD_EXECUTOR), errmsg("cache lookup failed for function %u when initialize function cache.", f_oid))); procedure_struct = (Form_pg_proc)GETSTRUCT(procedure_tuple); /* * copy function name immediately for use by error reporting callback */ fcache->fname = pstrdup(NameStr(procedure_struct->proname)); /* * get the result type from the procedure tuple, and check for polymorphic * result type; if so, find out the actual result type. */ ret_type = procedure_struct->prorettype; if (IsPolymorphicType(ret_type)) { ret_type = get_fn_expr_rettype(finfo); if (ret_type == InvalidOid) /* this probably should not happen */ ereport(ERROR, (errcode(ERRCODE_DATATYPE_MISMATCH), errmsg("could not determine actual result type for function declared to return type %s", format_type_be(procedure_struct->prorettype)))); } fcache->rettype = ret_type; /* Fetch the typlen and byval info for the result type */ get_typlenbyval(ret_type, &fcache->typlen, &fcache->typbyval); /* Remember whether we're returning setof something */ fcache->returnsSet = procedure_struct->proretset; /* Remember if function is STABLE/IMMUTABLE */ fcache->readonly_func = (procedure_struct->provolatile != PROVOLATILE_VOLATILE); /* * We need the actual argument types to pass to the parser. Also make * sure that parameter symbols are considered to have the function's * resolved input collation. */ fcache->pinfo = prepare_sql_fn_parse_info(procedure_tuple, finfo->fn_expr, collation); /* * And of course we need the function body text. */ tmp = SysCacheGetAttr(PROCOID, procedure_tuple, Anum_pg_proc_prosrc, &is_null); if (is_null) ereport(ERROR, (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION), errmsg("null prosrc for function %u when we need the function body text", f_oid))); fcache->src = TextDatumGetCString(tmp); /* * Parse and rewrite the queries in the function text. Use sublists to * keep track of the original query boundaries. But we also build a * "flat" list of the rewritten queries to pass to check_sql_fn_retval. * This is because the last canSetTag query determines the result type * independently of query boundaries --- and it might not be in the last * sublist, for example if the last query rewrites to DO INSTEAD NOTHING. * (It might not be unreasonable to throw an error in such a case, but * this is the historical behavior and it doesn't seem worth changing.) * * Note: since parsing and planning is done in fcontext, we will generate * a lot of cruft that lives as long as the fcache does. This is annoying * but we'll not worry about it until the module is rewritten to use * plancache.c. */ raw_parsetree_list = pg_parse_query(fcache->src); query_tree_list = NIL; flat_query_list = NIL; foreach (lc, raw_parsetree_list) { Node* parsetree = (Node*)lfirst(lc); List* queryTree_sublist = NIL; queryTree_sublist = pg_analyze_and_rewrite_params(parsetree, fcache->src, (ParserSetupHook)sql_fn_parser_setup, fcache->pinfo); query_tree_list = lappend(query_tree_list, queryTree_sublist); flat_query_list = list_concat(flat_query_list, list_copy(queryTree_sublist)); } /* * Check that the function returns the type it claims to. Although in * simple cases this was already done when the function was defined, we * have to recheck because database objects used in the function's queries * might have changed type. We'd have to do it anyway if the function had * any polymorphic arguments. * * Note: we set fcache->returnsTuple according to whether we are returning * the whole tuple result or just a single column. In the latter case we * clear returnsTuple because we need not act different from the scalar * result case, even if it's a rowtype column. (However, we have to force * lazy eval mode in that case; otherwise we'd need extra code to expand * the rowtype column into multiple columns, since we have no way to * notify the caller that it should do that.) * * check_sql_fn_retval will also construct a JunkFilter we can use to * coerce the returned rowtype to the desired form (unless the result type * is VOID, in which case there's nothing to coerce to). */ fcache->returnsTuple = check_sql_fn_retval(f_oid, ret_type, flat_query_list, NULL, &fcache->junkFilter); if (fcache->returnsTuple) { /* Make sure output rowtype is properly blessed */ BlessTupleDesc(fcache->junkFilter->jf_resultSlot->tts_tupleDescriptor); } else if (fcache->returnsSet && type_is_rowtype(fcache->rettype)) { /* * Returning rowtype as if it were scalar --- materialize won't work. * Right now it's sufficient to override any caller preference for * materialize mode, but to add more smarts in init_execution_state * about this, we'd probably need a three-way flag instead of bool. */ lazy_eval_ok = true; } /* Finally, plan the queries */ fcache->func_state = init_execution_state(query_tree_list, fcache, lazy_eval_ok); /* Mark fcache with time of creation to show it's valid */ fcache->lxid = t_thrd.proc->lxid; fcache->subxid = GetCurrentSubTransactionId(); ReleaseSysCache(procedure_tuple); MemoryContextSwitchTo(old_context); } /* Start up execution of one execution_state node */ static void postquel_start(execution_state* es, SQLFunctionCachePtr fcache) { DestReceiver* dest = NULL; Assert(es->qd == NULL); /* Caller should have ensured a suitable snapshot is active */ Assert(ActiveSnapshotSet()); /* * If this query produces the function result, send its output to the * tuplestore; else discard any output. */ if (es->setsResult) { DR_sqlfunction* my_state = NULL; dest = CreateDestReceiver(DestSQLFunction); /* pass down the needed info to the dest receiver routines */ my_state = (DR_sqlfunction*)dest; Assert(my_state->pub.mydest == DestSQLFunction); my_state->tstore = fcache->tstore; my_state->cxt = CurrentMemoryContext; my_state->filter = fcache->junkFilter; } else { dest = None_Receiver; } if (IsA(es->stmt, PlannedStmt)) { es->qd = CreateQueryDesc( (PlannedStmt*)es->stmt, fcache->src, GetActiveSnapshot(), InvalidSnapshot, dest, fcache->paramLI, 0); } else { es->qd = CreateUtilityQueryDesc(es->stmt, fcache->src, GetActiveSnapshot(), dest, fcache->paramLI); } /* Utility commands don't need Executor. */ if (es->qd->utilitystmt == NULL) { /* * In lazyEval mode, do not let the executor set up an AfterTrigger * context. This is necessary not just an optimization, because we * mustn't exit from the function execution with a stacked * AfterTrigger level still active. We are careful not to select * lazyEval mode for any statement that could possibly queue triggers. */ int eflags; if (es->lazyEval) { eflags = EXEC_FLAG_SKIP_TRIGGERS; } else { eflags = 0; /* default run-to-completion flags */ } ExecutorStart(es->qd, eflags); } es->status = F_EXEC_RUN; } /* Run one execution_state; either to completion or to first result row */ /* Returns true if we ran to completion */ static bool postquel_getnext(execution_state* es, SQLFunctionCachePtr fcache) { bool result = false; /* initialize the parameters of the main statement */ Qid stroed_proc_qid = {0, 0, 0}; unsigned char stroed_proc_parctl_state_except = 0; WLMStatusTag stroed_proc_g_collect_info_status = WLM_STATUS_RESERVE; bool stroed_proc_is_active_statements_reset = false; errno_t rc = EOK; if (es->qd->utilitystmt) { /* ProcessUtility needs the PlannedStmt for DECLARE CURSOR */ ProcessUtility((es->qd->plannedstmt ? (Node*)es->qd->plannedstmt : es->qd->utilitystmt), fcache->src, es->qd->params, false, /* not top level */ es->qd->dest, #ifdef PGXC false, #endif /* PGXC */ NULL); result = true; /* never stops early */ } else { /* Run regular commands to completion unless lazyEval */ long count = (es->lazyEval) ? 1L : 0L; bool forced_control = (t_thrd.wlm_cxt.parctl_state.simple == 1 || u_sess->wlm_cxt->is_active_statements_reset); if (ENABLE_WORKLOAD_CONTROL && IS_PGXC_COORDINATOR && forced_control) { if (!u_sess->wlm_cxt->is_active_statements_reset && !u_sess->attr.attr_resource.enable_transaction_parctl) { u_sess->wlm_cxt->stroedproc_rp_reserve = t_thrd.wlm_cxt.parctl_state.rp_reserve; u_sess->wlm_cxt->stroedproc_rp_release = t_thrd.wlm_cxt.parctl_state.rp_release; u_sess->wlm_cxt->stroedproc_release = t_thrd.wlm_cxt.parctl_state.release; } /* Retain the parameters of the main statement */ if (!IsQidInvalid(&u_sess->wlm_cxt->wlm_params.qid)) { rc = memcpy_s(&stroed_proc_qid, sizeof(Qid), &u_sess->wlm_cxt->wlm_params.qid, sizeof(Qid)); securec_check(rc, "\0", "\0"); } stroed_proc_parctl_state_except = t_thrd.wlm_cxt.parctl_state.except; stroed_proc_g_collect_info_status = t_thrd.wlm_cxt.collect_info->status; stroed_proc_is_active_statements_reset = u_sess->wlm_cxt->is_active_statements_reset; t_thrd.wlm_cxt.parctl_state.subquery = 1; WLMInitQueryPlan(es->qd); dywlm_client_manager(es->qd); } ExecutorRun(es->qd, ForwardScanDirection, count); if (ENABLE_WORKLOAD_CONTROL && IS_PGXC_COORDINATOR && forced_control) { t_thrd.wlm_cxt.parctl_state.except = 0; if (g_instance.wlm_cxt->dynamic_workload_inited && (t_thrd.wlm_cxt.parctl_state.simple == 0)) { dywlm_client_release(&t_thrd.wlm_cxt.parctl_state); } else { // only release resource pool count if (IS_PGXC_COORDINATOR && !IsConnFromCoord() && (u_sess->wlm_cxt->parctl_state_exit || IsQueuedSubquery())) { WLMReleaseGroupActiveStatement(); } } WLMSetCollectInfoStatus(WLM_STATUS_FINISHED); t_thrd.wlm_cxt.parctl_state.subquery = 0; t_thrd.wlm_cxt.parctl_state.except = stroed_proc_parctl_state_except; t_thrd.wlm_cxt.collect_info->status = stroed_proc_g_collect_info_status; u_sess->wlm_cxt->is_active_statements_reset = stroed_proc_is_active_statements_reset; if (!IsQidInvalid(&stroed_proc_qid)) { rc = memcpy_s(&u_sess->wlm_cxt->wlm_params.qid, sizeof(Qid), &stroed_proc_qid, sizeof(Qid)); securec_check(rc, "\0", "\0"); } /* restore state condition if guc para is off since it contains unreleased count */ if (!u_sess->attr.attr_resource.enable_transaction_parctl && (u_sess->wlm_cxt->reserved_in_active_statements || u_sess->wlm_cxt->reserved_in_group_statements || u_sess->wlm_cxt->reserved_in_group_statements_simple)) { t_thrd.wlm_cxt.parctl_state.rp_reserve = u_sess->wlm_cxt->stroedproc_rp_reserve; t_thrd.wlm_cxt.parctl_state.rp_release = u_sess->wlm_cxt->stroedproc_rp_release; t_thrd.wlm_cxt.parctl_state.release = u_sess->wlm_cxt->stroedproc_release; } } /* * If we requested run to completion OR there was no tuple returned, * command must be complete. */ result = (count == 0L || es->qd->estate->es_processed == 0); } return result; } /* Shut down execution of one execution_state node */ static void postquel_end(execution_state* es) { /* mark status done to ensure we don't do ExecutorEnd twice */ es->status = F_EXEC_DONE; /* Utility commands don't need Executor. */ if (es->qd->utilitystmt == NULL) { ExecutorFinish(es->qd); ExecutorEnd(es->qd); } (*es->qd->dest->rDestroy)(es->qd->dest); FreeQueryDesc(es->qd); es->qd = NULL; } /* Build ParamListInfo array representing current arguments */ static void postquel_sub_params(SQLFunctionCachePtr fcache, FunctionCallInfo fcinfo) { int nargs = fcinfo->nargs; if (nargs > 0) { ParamListInfo param_li; int i; if (fcache->paramLI == NULL) { param_li = (ParamListInfo)palloc(offsetof(ParamListInfoData, params) + nargs * sizeof(ParamExternData)); /* we have static list of params, so no hooks needed */ param_li->paramFetch = NULL; param_li->paramFetchArg = NULL; param_li->parserSetup = NULL; param_li->parserSetupArg = NULL; param_li->params_need_process = false; param_li->numParams = nargs; fcache->paramLI = param_li; } else { param_li = fcache->paramLI; Assert(param_li->numParams == nargs); } for (i = 0; i < nargs; i++) { ParamExternData* prm = ¶m_li->params[i]; prm->value = fcinfo->arg[i]; prm->isnull = fcinfo->argnull[i]; prm->pflags = 0; prm->ptype = fcache->pinfo->argtypes[i]; } } else { fcache->paramLI = NULL; } } /* * Extract the SQL function's value from a single result row. This is used * both for scalar (non-set) functions and for each row of a lazy-eval set * result. */ static Datum postquel_get_single_result( TupleTableSlot* slot, FunctionCallInfo fcinfo, SQLFunctionCachePtr fcache, MemoryContext result_context) { Assert(slot != NULL); Datum value; MemoryContext old_context; /* * Set up to return the function value. For pass-by-reference datatypes, * be sure to allocate the result in resultcontext, not the current memory * context (which has query lifespan). We can't leave the data in the * TupleTableSlot because we intend to clear the slot before returning. */ old_context = MemoryContextSwitchTo(result_context); if (fcache->returnsTuple) { /* We must return the whole tuple as a Datum. */ fcinfo->isnull = false; value = ExecFetchSlotTupleDatum(slot); value = datumCopy(value, fcache->typbyval, fcache->typlen); } else { /* * Returning a scalar, which we have to extract from the first column * of the SELECT result, and then copy into result context if needed. */ /* Get the Table Accessor Method*/ Assert(slot->tts_tupleDescriptor != NULL); value = tableam_tslot_getattr(slot, 1, &(fcinfo->isnull)); if (!fcinfo->isnull) value = datumCopy(value, fcache->typbyval, fcache->typlen); } MemoryContextSwitchTo(old_context); return value; } static void auditExecSQLFunction(Oid fn_oid, SQLFunctionCache* func, AuditResult result) { char details[PGAUDIT_MAXLENGTH]; Assert(func != NULL); if (fn_oid < FirstNormalObjectId) return; int ret = snprintf_s(details, sizeof(details), sizeof(details) - 1, "Execute SQL function(%s). ", func->fname); securec_check_ss(ret, "", ""); audit_report(AUDIT_FUNCTION_EXEC, result, func->fname, details); } /* * fmgr_sql: function call manager for SQL functions */ Datum fmgr_sql(PG_FUNCTION_ARGS) { SQLFunctionCachePtr fcache = NULL; ErrorContextCallback sql_err_context; MemoryContext old_context; bool random_access = false; bool lazy_eval_ok = false; bool is_first = false; bool pushed_snapshot = false; execution_state* es = NULL; TupleTableSlot* slot = NULL; Datum result; List* es_list = NIL; ListCell* eslc = NULL; bool old_running_in_fmgr = t_thrd.codegen_cxt.g_runningInFmgr; t_thrd.codegen_cxt.g_runningInFmgr = true; bool need_snapshot = !ActiveSnapshotSet(); #ifdef STREAMPLAN bool outer_is_stream = false; bool outer_is_stream_support = false; if (IS_PGXC_COORDINATOR) { outer_is_stream = u_sess->opt_cxt.is_stream; outer_is_stream_support = u_sess->opt_cxt.is_stream_support; u_sess->opt_cxt.is_stream = true; u_sess->opt_cxt.is_stream_support = true; } #endif /* * Setup error traceback support for ereport() */ sql_err_context.callback = sql_exec_error_callback; sql_err_context.arg = fcinfo->flinfo; sql_err_context.previous = t_thrd.log_cxt.error_context_stack; t_thrd.log_cxt.error_context_stack = &sql_err_context; /* Check call context */ if (fcinfo->flinfo->fn_retset) { ReturnSetInfo* rsi = (ReturnSetInfo*)fcinfo->resultinfo; /* * For simplicity, we require callers to support both set eval modes. * There are cases where we must use one or must use the other, and * it's not really worthwhile to postpone the check till we know. But * note we do not require caller to provide an expectedDesc. */ if (rsi == NULL || !IsA(rsi, ReturnSetInfo) || (rsi->allowedModes & SFRM_ValuePerCall) == 0 || (rsi->allowedModes & SFRM_Materialize) == 0) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("set-valued function called in context that cannot accept a set"))); random_access = rsi->allowedModes & SFRM_Materialize_Random; lazy_eval_ok = !(rsi->allowedModes & SFRM_Materialize_Preferred); } else { random_access = false; lazy_eval_ok = true; } if (need_snapshot) { PushActiveSnapshot(GetTransactionSnapshot()); } /* * Initialize fcache (build plans) if first time through; or re-initialize * if the cache is stale. */ fcache = (SQLFunctionCachePtr)fcinfo->flinfo->fn_extra; if (fcache != NULL) { if (fcache->lxid != t_thrd.proc->lxid || !SubTransactionIsActive(fcache->subxid)) { /* It's stale; unlink and delete */ fcinfo->flinfo->fn_extra = NULL; MemoryContextDelete(fcache->fcontext); fcache = NULL; } } if (fcache == NULL) { init_sql_fcache(fcinfo->flinfo, PG_GET_COLLATION(), lazy_eval_ok); fcache = (SQLFunctionCachePtr)fcinfo->flinfo->fn_extra; } /* * Switch to context in which the fcache lives. This ensures that our * tuplestore etc will have sufficient lifetime. The sub-executor is * responsible for deleting per-tuple information. (XXX in the case of a * long-lived FmgrInfo, this policy represents more memory leakage, but * it's not entirely clear where to keep stuff instead.) */ old_context = MemoryContextSwitchTo(fcache->fcontext); /* * Find first unfinished query in function, and note whether it's the * first query. */ es_list = fcache->func_state; es = NULL; is_first = true; foreach (eslc, es_list) { es = (execution_state*)lfirst(eslc); while (es != NULL && es->status == F_EXEC_DONE) { is_first = false; es = es->next; } if (es != NULL) break; } /* * Convert params to appropriate format if starting a fresh execution. (If * continuing execution, we can re-use prior params.) */ if (is_first && es != NULL && es->status == F_EXEC_START) postquel_sub_params(fcache, fcinfo); /* * Build tuplestore to hold results, if we don't have one already. Note * it's in the query-lifespan context. */ if (fcache->tstore == NULL) fcache->tstore = tuplestore_begin_heap(random_access, false, u_sess->attr.attr_memory.work_mem); /* * Execute each command in the function one after another until we either * run out of commands or get a result row from a lazily-evaluated SELECT. * * Notes about snapshot management: * * In a read-only function, we just use the surrounding query's snapshot. * * In a non-read-only function, we rely on the fact that we'll never * suspend execution between queries of the function: the only reason to * suspend execution before completion is if we are returning a row from a * lazily-evaluated SELECT. So, when first entering this loop, we'll * either start a new query (and push a fresh snapshot) or re-establish * the active snapshot from the existing query descriptor. If we need to * start a new query in a subsequent execution of the loop, either we need * a fresh snapshot (and pushed_snapshot is false) or the existing * snapshot is on the active stack and we can just bump its command ID. */ pushed_snapshot = false; while (es != NULL) { bool completed = false; if (es->status == F_EXEC_START) { /* * If not read-only, be sure to advance the command counter for * each command, so that all work to date in this transaction is * visible. Take a new snapshot if we don't have one yet, * otherwise just bump the command ID in the existing snapshot. */ if (!fcache->readonly_func) { CommandCounterIncrement(); if (!pushed_snapshot) { PushActiveSnapshot(GetTransactionSnapshot()); pushed_snapshot = true; } else UpdateActiveSnapshotCommandId(); } postquel_start(es, fcache); } else if (!fcache->readonly_func && !pushed_snapshot) { /* Re-establish active snapshot when re-entering function */ PushActiveSnapshot(es->qd->snapshot); pushed_snapshot = true; } completed = postquel_getnext(es, fcache); /* * If we ran the command to completion, we can shut it down now. Any * row(s) we need to return are safely stashed in the tuplestore, and * we want to be sure that, for example, AFTER triggers get fired * before we return anything. Also, if the function doesn't return * set, we can shut it down anyway because it must be a SELECT and we * don't care about fetching any more result rows. */ if (completed || !fcache->returnsSet) postquel_end(es); /* * Break from loop if we didn't shut down (implying we got a * lazily-evaluated row). Otherwise we'll press on till the whole * function is done, relying on the tuplestore to keep hold of the * data to eventually be returned. This is necessary since an * INSERT/UPDATE/DELETE RETURNING that sets the result might be * followed by additional rule-inserted commands, and we want to * finish doing all those commands before we return anything. */ if (es->status != F_EXEC_DONE) break; /* * Advance to next execution_state, which might be in the next list. */ es = es->next; while (es == NULL) { eslc = lnext(eslc); if (eslc == NULL) break; /* end of function */ es = (execution_state*)lfirst(eslc); /* * Flush the current snapshot so that we will take a new one for * the new query list. This ensures that new snaps are taken at * original-query boundaries, matching the behavior of interactive * execution. */ if (pushed_snapshot) { PopActiveSnapshot(); pushed_snapshot = false; } } } if (AUDIT_EXEC_ENABLED) { auditExecSQLFunction(fcinfo->flinfo->fn_oid, fcache, AUDIT_OK); } /* * The tuplestore now contains whatever row(s) we are supposed to return. */ if (fcache->returnsSet) { ReturnSetInfo* rsi = (ReturnSetInfo*)fcinfo->resultinfo; if (es != NULL) { /* * If we stopped short of being done, we must have a lazy-eval * row. */ Assert(es->lazyEval); /* Re-use the junkfilter's output slot to fetch back the tuple */ Assert(fcache->junkFilter); if (fcache->junkFilter == NULL) { ereport(ERROR, (errcode(ERRCODE_FETCH_DATA_FAILED), errmsg("function returns VOID, failed to get junk filter's slot"))); } slot = fcache->junkFilter->jf_resultSlot; if (!tuplestore_gettupleslot(fcache->tstore, true, false, slot)) ereport(ERROR, (errcode(ERRCODE_FETCH_DATA_FAILED), errmsg("failed to fetch lazy-eval tuple"))); /* Extract the result as a datum, and copy out from the slot */ result = postquel_get_single_result(slot, fcinfo, fcache, old_context); /* Clear the tuplestore, but keep it for next time */ /* NB: this might delete the slot's content, but we don't care */ tuplestore_clear(fcache->tstore); /* * Let caller know we're not finished. */ rsi->isDone = ExprMultipleResult; /* * Ensure we will get shut down cleanly if the exprcontext is not * run to completion. */ if (!fcache->shutdown_reg) { RegisterExprContextCallback(rsi->econtext, ShutdownSQLFunction, PointerGetDatum(fcache)); fcache->shutdown_reg = true; } } else if (fcache->lazyEval) { /* * We are done with a lazy evaluation. Clean up. */ tuplestore_clear(fcache->tstore); /* * Let caller know we're finished. */ rsi->isDone = ExprEndResult; fcinfo->isnull = true; result = (Datum)0; /* Deregister shutdown callback, if we made one */ if (fcache->shutdown_reg) { UnregisterExprContextCallback(rsi->econtext, ShutdownSQLFunction, PointerGetDatum(fcache)); fcache->shutdown_reg = false; } } else { /* * We are done with a non-lazy evaluation. Return whatever is in * the tuplestore. (It is now caller's responsibility to free the * tuplestore when done.) */ rsi->returnMode = SFRM_Materialize; rsi->setResult = fcache->tstore; fcache->tstore = NULL; /* must copy desc because execQual will free it */ if (fcache->junkFilter != NULL) rsi->setDesc = CreateTupleDescCopy(fcache->junkFilter->jf_cleanTupType); fcinfo->isnull = true; result = (Datum)0; /* Deregister shutdown callback, if we made one */ if (fcache->shutdown_reg) { UnregisterExprContextCallback(rsi->econtext, ShutdownSQLFunction, PointerGetDatum(fcache)); fcache->shutdown_reg = false; } } } else { /* * Non-set function. If we got a row, return it; else return NULL. */ if (fcache->junkFilter != NULL) { /* Re-use the junkfilter's output slot to fetch back the tuple */ slot = fcache->junkFilter->jf_resultSlot; if (tuplestore_gettupleslot(fcache->tstore, true, false, slot)) result = postquel_get_single_result(slot, fcinfo, fcache, old_context); else { fcinfo->isnull = true; result = (Datum)0; } } else { /* Should only get here for VOID functions */ Assert(fcache->rettype == VOIDOID); fcinfo->isnull = true; result = (Datum)0; } /* Clear the tuplestore, but keep it for next time */ tuplestore_clear(fcache->tstore); } /* Pop snapshot if we have pushed one */ if (pushed_snapshot) PopActiveSnapshot(); if (need_snapshot) PopActiveSnapshot(); /* * If we've gone through every command in the function, we are done. Reset * the execution states to start over again on next call. */ if (es == NULL) { foreach (eslc, fcache->func_state) { es = (execution_state*)lfirst(eslc); while (es != NULL) { es->status = F_EXEC_START; es = es->next; } } } t_thrd.log_cxt.error_context_stack = sql_err_context.previous; MemoryContextSwitchTo(old_context); #ifdef STREAMPLAN if (IS_PGXC_COORDINATOR) { u_sess->opt_cxt.is_stream = outer_is_stream; u_sess->opt_cxt.is_stream_support = outer_is_stream_support; } #endif t_thrd.codegen_cxt.g_runningInFmgr = old_running_in_fmgr; return result; } /* * error context callback to let us supply a call-stack traceback */ static void sql_exec_error_callback(void* arg) { FmgrInfo* flinfo = (FmgrInfo*)arg; SQLFunctionCachePtr fcache = (SQLFunctionCachePtr)flinfo->fn_extra; int syntax_err_position; /* * We can do nothing useful if init_sql_fcache() didn't get as far as * saving the function name */ if (fcache == NULL || fcache->fname == NULL) return; /* * If there is a syntax error position, convert to internal syntax error */ syntax_err_position = geterrposition(); if (syntax_err_position > 0 && fcache->src != NULL) { errposition(0); internalerrposition(syntax_err_position); internalerrquery(fcache->src); } if (AUDIT_EXEC_ENABLED) { int e_level; int sql_state; getElevelAndSqlstate(&e_level, &sql_state); if (e_level >= ERROR) auditExecSQLFunction(flinfo->fn_oid, fcache, AUDIT_FAILED); } /* * Try to determine where in the function we failed. If there is a query * with non-null QueryDesc, finger it. (We check this rather than looking * for F_EXEC_RUN state, so that errors during ExecutorStart or * ExecutorEnd are blamed on the appropriate query; see postquel_start and * postquel_end.) */ if (fcache->func_state != NULL) { execution_state* es = NULL; int query_num; ListCell* lc = NULL; es = NULL; query_num = 1; foreach (lc, fcache->func_state) { es = (execution_state*)lfirst(lc); while (es != NULL) { if (es->qd != NULL) { errcontext("SQL function \"%s\" statement %d", fcache->fname, query_num); break; } es = es->next; } if (es != NULL) break; query_num++; } if (es == NULL) { /* * couldn't identify a running query; might be function entry, * function exit, or between queries. */ errcontext("SQL function \"%s\"", fcache->fname); } } else { /* * Assume we failed during init_sql_fcache(). (It's possible that the * function actually has an empty body, but in that case we may as * well report all errors as being "during startup".) */ errcontext("SQL function \"%s\" during startup", fcache->fname); } } /* * callback function in case a function-returning-set needs to be shut down * before it has been run to completion */ static void ShutdownSQLFunction(Datum arg) { SQLFunctionCachePtr fcache = (SQLFunctionCachePtr)DatumGetPointer(arg); execution_state* es = NULL; ListCell* lc = NULL; foreach (lc, fcache->func_state) { es = (execution_state*)lfirst(lc); while (es != NULL) { /* Shut down anything still running */ if (es->status == F_EXEC_RUN) { /* Re-establish active snapshot for any called functions */ if (!fcache->readonly_func) PushActiveSnapshot(es->qd->snapshot); postquel_end(es); if (!fcache->readonly_func) PopActiveSnapshot(); } /* Reset states to START in case we're called again */ es->status = F_EXEC_START; es = es->next; } } /* Release tuplestore if we have one */ if (fcache->tstore != NULL) tuplestore_end(fcache->tstore); fcache->tstore = NULL; /* execUtils will deregister the callback... */ fcache->shutdown_reg = false; } /* * 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 last * canSetTag query in the function. We do some ad-hoc type checking here * to be sure that the user is returning the type he claims. There are * also a couple of strange-looking features to assist callers in dealing * with allowed special cases, such as binary-compatible result types. * * For a polymorphic function the passed rettype must be the actual resolved * output type of the function; we should never see a polymorphic pseudotype * such as ANYELEMENT as rettype. (This means we can't check the type during * function definition of a polymorphic function.) * * This function returns true if the sql function returns the entire tuple * result of its final statement, or false if it returns just the first column * result of that statement. It throws an error if the final statement doesn't * return the right type at all. * * Note that because we allow "SELECT rowtype_expression", the result can be * false even when the declared function return type is a rowtype. * * If modifyTargetList isn't NULL, the function will modify the final * statement's targetlist in two cases: * (1) if the tlist returns values that are binary-coercible to the expected * type rather than being exactly the expected type. RelabelType nodes will * be inserted to make the result types match exactly. * (2) if there are dropped columns in the declared result rowtype. NULL * output columns will be inserted in the tlist to match them. * (Obviously the caller must pass a parsetree that is okay to modify when * using this flag.) Note that this flag does not affect whether the tlist is * considered to be a legal match to the result type, only how we react to * allowed not-exact-match cases. *modifyTargetList will be set true iff * we had to make any "dangerous" changes that could modify the semantics of * the statement. If it is set true, the caller should not use the modified * statement, but for simplicity we apply the changes anyway. * * If junkFilter isn't NULL, then *junkFilter is set to a JunkFilter defined * to convert the function's tuple result to the correct output tuple type. * Exception: if the function is defined to return VOID then *junkFilter is * set to NULL. */ bool check_sql_fn_retval(Oid func_id, Oid ret_type, List* query_tree_list, bool* modify_target_list, JunkFilter** junk_filter) { Query* parse = NULL; List** tlist_ptr; List* tlist = NIL; int tlist_len; char fn_type; Oid res_type; ListCell* lc = NULL; AssertArg(!IsPolymorphicType(ret_type)); if (modify_target_list != NULL) *modify_target_list = false; /* initialize for no change */ if (junk_filter != NULL) *junk_filter = NULL; /* initialize in case of VOID result */ /* * Find the last canSetTag query in the list. This isn't necessarily the * last parsetree, because rule rewriting can insert queries after what * the user wrote. */ parse = NULL; foreach (lc, query_tree_list) { Query* q = (Query*)lfirst(lc); if (q->canSetTag) parse = q; } /* * If it's a plain SELECT, it returns whatever the targetlist says. * Otherwise, if it's INSERT/UPDATE/DELETE with RETURNING, it returns * that. Otherwise, the function return type must be VOID. * * Note: eventually replace this test with QueryReturnsTuples? We'd need * a more general method of determining the output type, though. Also, it * seems too dangerous to consider FETCH or EXECUTE as returning a * determinable rowtype, since they depend on relatively short-lived * entities. */ if (parse != NULL && parse->commandType == CMD_SELECT && parse->utilityStmt == NULL) { tlist_ptr = &parse->targetList; tlist = parse->targetList; } else if (parse != NULL && (parse->commandType == CMD_INSERT || parse->commandType == CMD_UPDATE || parse->commandType == CMD_DELETE) && parse->returningList) { tlist_ptr = &parse->returningList; tlist = parse->returningList; } else { /* Empty function body, or last statement is a utility command */ if (ret_type != VOIDOID) ereport(ERROR, (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION), errmsg("return type mismatch in function declared to return %s", format_type_be(ret_type)), errdetail("Function's final statement must be SELECT or INSERT/UPDATE/DELETE RETURNING."))); return false; } /* * OK, check that the targetlist returns something matching the declared * type. (We used to insist that the declared type not be VOID in this * case, but that makes it hard to write a void function that exits after * calling another void function. Instead, we insist that the tlist * return void ... so void is treated as if it were a scalar type below.) */ /* * Count the non-junk entries in the result targetlist. */ tlist_len = ExecCleanTargetListLength(tlist); fn_type = get_typtype(ret_type); if (fn_type == TYPTYPE_BASE || fn_type == TYPTYPE_DOMAIN || fn_type == TYPTYPE_ENUM || fn_type == TYPTYPE_RANGE || ret_type == VOIDOID) { /* * For scalar-type returns, the target list must have exactly one * non-junk entry, and its type must agree with what the user * declared; except we allow binary-compatible types too. */ TargetEntry* tle = NULL; if (tlist_len != 1) ereport(ERROR, (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION), errmsg("return type mismatch in function declared to return %s", format_type_be(ret_type)), errdetail("Final statement must return exactly one column."))); /* We assume here that non-junk TLEs must come first in tlists */ tle = (TargetEntry*)linitial(tlist); Assert(!tle->resjunk); res_type = exprType((Node*)tle->expr); if (!IsBinaryCoercible(res_type, ret_type)) ereport(ERROR, (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION), errmsg("return type mismatch in function declared to return %s", format_type_be(ret_type)), errdetail("Actual return type is %s.", format_type_be(res_type)))); if (modify_target_list != NULL && res_type != ret_type) { tle->expr = (Expr*)makeRelabelType(tle->expr, ret_type, -1, get_typcollation(ret_type), COERCE_DONTCARE); /* Relabel is dangerous if TLE is a sort/group or setop column */ if (tle->ressortgroupref != 0 || parse->setOperations) *modify_target_list = true; } /* Set up junk filter if needed */ if (junk_filter != NULL) *junk_filter = ExecInitJunkFilter(tlist, false, NULL); } else if (fn_type == TYPTYPE_COMPOSITE || ret_type == RECORDOID) { /* Returns a rowtype */ TupleDesc tup_desc; int tup_natts; /* physical number of columns in tuple */ int tup_log_cols; /* # of nondeleted columns in tuple */ int col_index; /* physical column index */ List* new_tlist = NIL; /* new non-junk tlist entries */ List* junk_attrs = NIL; /* new junk tlist entries */ /* * If the target list is of length 1, and the type of the varnode in * the target list matches the declared return type, this is okay. * This can happen, for example, where the body of the function is * 'SELECT func2()', where func2 has the same composite return type as * the function that's calling it. * * XXX Note that if rettype is RECORD, the IsBinaryCoercible check * will succeed for any composite restype. For the moment we rely on * runtime type checking to catch any discrepancy, but it'd be nice to * do better at parse time. */ if (tlist_len == 1) { TargetEntry* tle = (TargetEntry*)linitial(tlist); Assert(!tle->resjunk); res_type = exprType((Node*)tle->expr); if (IsBinaryCoercible(res_type, ret_type)) { if (modify_target_list != NULL && res_type != ret_type) { tle->expr = (Expr*)makeRelabelType(tle->expr, ret_type, -1, get_typcollation(ret_type), COERCE_DONTCARE); /* Relabel is dangerous if sort/group or setop column */ if (tle->ressortgroupref != 0 || parse->setOperations) *modify_target_list = true; } /* Set up junk filter if needed */ if (junk_filter != NULL) *junk_filter = ExecInitJunkFilter(tlist, false, NULL); return false; /* NOT returning whole tuple */ } } /* Is the rowtype fixed, or determined only at runtime? */ if (get_func_result_type(func_id, NULL, &tup_desc) != TYPEFUNC_COMPOSITE) { /* * Assume we are returning the whole tuple. Crosschecking against * what the caller expects will happen at runtime. */ if (junk_filter != NULL) *junk_filter = ExecInitJunkFilter(tlist, false, NULL); return true; } Assert(tup_desc); /* * Verify that the targetlist matches the return tuple type. We scan * the non-deleted attributes to ensure that they match the datatypes * of the non-resjunk columns. For deleted attributes, insert NULL * result columns if the caller asked for that. */ tup_natts = tup_desc->natts; tup_log_cols = 0; /* we'll count nondeleted cols as we go */ col_index = 0; new_tlist = NIL; /* these are only used if modifyTargetList */ junk_attrs = NIL; foreach (lc, tlist) { TargetEntry* tle = (TargetEntry*)lfirst(lc); Form_pg_attribute attr; Oid tle_type; Oid att_type; if (tle->resjunk) { if (modify_target_list != NULL) junk_attrs = lappend(junk_attrs, tle); continue; } do { col_index++; if (col_index > tup_natts) ereport(ERROR, (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION), errmsg("return type mismatch in function declared to return %s", format_type_be(ret_type)), errdetail("Final statement returns too many columns."))); attr = tup_desc->attrs[col_index - 1]; if (attr->attisdropped && modify_target_list) { Expr* null_expr = NULL; /* The type of the null we insert isn't important */ null_expr = (Expr*)makeConst(INT4OID, -1, InvalidOid, sizeof(int32), (Datum)0, true, /* isnull */ true /* byval */); new_tlist = lappend(new_tlist, makeTargetEntry(null_expr, col_index, NULL, false)); /* NULL insertion is dangerous in a setop */ if (parse->setOperations) *modify_target_list = true; } } while (attr->attisdropped); tup_log_cols++; tle_type = exprType((Node*)tle->expr); att_type = attr->atttypid; if (!IsBinaryCoercible(tle_type, att_type)) ereport(ERROR, (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION), errmsg("return type mismatch in function declared to return %s", format_type_be(ret_type)), errdetail("Final statement returns %s instead of %s at column %d.", format_type_be(tle_type), format_type_be(att_type), tup_log_cols))); if (modify_target_list != NULL) { if (tle_type != att_type) { tle->expr = (Expr*)makeRelabelType(tle->expr, att_type, -1, get_typcollation(att_type), COERCE_DONTCARE); /* Relabel is dangerous if sort/group or setop column */ if (tle->ressortgroupref != 0 || parse->setOperations) *modify_target_list = true; } tle->resno = col_index; new_tlist = lappend(new_tlist, tle); } } /* remaining columns in tupdesc had better all be dropped */ for (col_index++; col_index <= tup_natts; col_index++) { if (!tup_desc->attrs[col_index - 1]->attisdropped) ereport(ERROR, (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION), errmsg("return type mismatch in function declared to return %s", format_type_be(ret_type)), errdetail("Final statement returns too few columns."))); if (modify_target_list != NULL) { Expr* null_expr = NULL; /* The type of the null we insert isn't important */ null_expr = (Expr*)makeConst(INT4OID, -1, InvalidOid, sizeof(int32), (Datum)0, true, /* isnull */ true /* byval */); new_tlist = lappend(new_tlist, makeTargetEntry(null_expr, col_index, NULL, false)); /* NULL insertion is dangerous in a setop */ if (parse->setOperations) *modify_target_list = true; } } if (modify_target_list != NULL) { /* ensure resjunk columns are numbered correctly */ foreach (lc, junk_attrs) { TargetEntry* tle = (TargetEntry*)lfirst(lc); tle->resno = col_index++; } /* replace the tlist with the modified one */ *tlist_ptr = list_concat(new_tlist, junk_attrs); } /* Set up junk filter if needed */ if (junk_filter != NULL) *junk_filter = ExecInitJunkFilterConversion(tlist, CreateTupleDescCopy(tup_desc), NULL); /* Report that we are returning entire tuple result */ return true; } else ereport(ERROR, (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION), errmsg("return type %s is not supported for SQL functions with ID %u.", format_type_be(ret_type), func_id))); return false; } /* * CreateSQLFunctionDestReceiver -- create a suitable DestReceiver object */ DestReceiver* CreateSQLFunctionDestReceiver(void) { DR_sqlfunction* self = (DR_sqlfunction*)palloc0(sizeof(DR_sqlfunction)); self->pub.receiveSlot = sqlfunction_receive; self->pub.rStartup = sqlfunction_startup; self->pub.rShutdown = sqlfunction_shutdown; self->pub.rDestroy = sqlfunction_destroy; self->pub.mydest = DestSQLFunction; self->pub.tmpContext = NULL; /* private fields will be set by postquel_start */ return (DestReceiver*)self; } /* * sqlfunction_startup --- executor startup */ static void sqlfunction_startup(DestReceiver* self, int operation, TupleDesc type_info) { /* no-op */ } /* * sqlfunction_receive --- receive one tuple */ static void sqlfunction_receive(TupleTableSlot* slot, DestReceiver* self) { DR_sqlfunction* my_state = (DR_sqlfunction*)self; /* Filter tuple as needed */ slot = ExecFilterJunk(my_state->filter, slot); /* Store the filtered tuple into the tuplestore */ tuplestore_puttupleslot(my_state->tstore, slot); } /* * sqlfunction_shutdown --- executor end */ static void sqlfunction_shutdown(DestReceiver* self) { /* no-op */ } /* * sqlfunction_destroy --- release DestReceiver object */ static void sqlfunction_destroy(DestReceiver* self) { pfree_ext(self); }