Line data Source code
1 : /*-------------------------------------------------------------------------
2 : *
3 : * functions.c
4 : * Execution of SQL-language functions
5 : *
6 : * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
7 : * Portions Copyright (c) 1994, Regents of the University of California
8 : *
9 : *
10 : * IDENTIFICATION
11 : * src/backend/executor/functions.c
12 : *
13 : *-------------------------------------------------------------------------
14 : */
15 : #include "postgres.h"
16 :
17 : #include "access/htup_details.h"
18 : #include "access/xact.h"
19 : #include "catalog/pg_proc.h"
20 : #include "catalog/pg_type.h"
21 : #include "executor/functions.h"
22 : #include "funcapi.h"
23 : #include "miscadmin.h"
24 : #include "nodes/makefuncs.h"
25 : #include "nodes/nodeFuncs.h"
26 : #include "parser/parse_coerce.h"
27 : #include "parser/parse_collate.h"
28 : #include "parser/parse_func.h"
29 : #include "rewrite/rewriteHandler.h"
30 : #include "storage/proc.h"
31 : #include "tcop/utility.h"
32 : #include "utils/builtins.h"
33 : #include "utils/datum.h"
34 : #include "utils/lsyscache.h"
35 : #include "utils/memutils.h"
36 : #include "utils/snapmgr.h"
37 : #include "utils/syscache.h"
38 :
39 :
40 : /*
41 : * Specialized DestReceiver for collecting query output in a SQL function
42 : */
43 : typedef struct
44 : {
45 : DestReceiver pub; /* publicly-known function pointers */
46 : Tuplestorestate *tstore; /* where to put result tuples */
47 : MemoryContext cxt; /* context containing tstore */
48 : JunkFilter *filter; /* filter to convert tuple type */
49 : } DR_sqlfunction;
50 :
51 : /*
52 : * We have an execution_state record for each query in a function. Each
53 : * record contains a plantree for its query. If the query is currently in
54 : * F_EXEC_RUN state then there's a QueryDesc too.
55 : *
56 : * The "next" fields chain together all the execution_state records generated
57 : * from a single original parsetree. (There will only be more than one in
58 : * case of rule expansion of the original parsetree.)
59 : */
60 : typedef enum
61 : {
62 : F_EXEC_START, F_EXEC_RUN, F_EXEC_DONE,
63 : } ExecStatus;
64 :
65 : typedef struct execution_state
66 : {
67 : struct execution_state *next;
68 : ExecStatus status;
69 : bool setsResult; /* true if this query produces func's result */
70 : bool lazyEval; /* true if should fetch one row at a time */
71 : PlannedStmt *stmt; /* plan for this query */
72 : QueryDesc *qd; /* null unless status == RUN */
73 : } execution_state;
74 :
75 :
76 : /*
77 : * An SQLFunctionCache record is built during the first call,
78 : * and linked to from the fn_extra field of the FmgrInfo struct.
79 : *
80 : * Note that currently this has only the lifespan of the calling query.
81 : * Someday we should rewrite this code to use plancache.c to save parse/plan
82 : * results for longer than that.
83 : *
84 : * Physically, though, the data has the lifespan of the FmgrInfo that's used
85 : * to call the function, and there are cases (particularly with indexes)
86 : * where the FmgrInfo might survive across transactions. We cannot assume
87 : * that the parse/plan trees are good for longer than the (sub)transaction in
88 : * which parsing was done, so we must mark the record with the LXID/subxid of
89 : * its creation time, and regenerate everything if that's obsolete. To avoid
90 : * memory leakage when we do have to regenerate things, all the data is kept
91 : * in a sub-context of the FmgrInfo's fn_mcxt.
92 : */
93 : typedef struct
94 : {
95 : char *fname; /* function name (for error msgs) */
96 : char *src; /* function body text (for error msgs) */
97 :
98 : SQLFunctionParseInfoPtr pinfo; /* data for parser callback hooks */
99 :
100 : Oid rettype; /* actual return type */
101 : int16 typlen; /* length of the return type */
102 : bool typbyval; /* true if return type is pass by value */
103 : bool returnsSet; /* true if returning multiple rows */
104 : bool returnsTuple; /* true if returning whole tuple result */
105 : bool shutdown_reg; /* true if registered shutdown callback */
106 : bool readonly_func; /* true to run in "read only" mode */
107 : bool lazyEval; /* true if using lazyEval for result query */
108 :
109 : ParamListInfo paramLI; /* Param list representing current args */
110 :
111 : Tuplestorestate *tstore; /* where we accumulate result tuples */
112 :
113 : JunkFilter *junkFilter; /* will be NULL if function returns VOID */
114 :
115 : /*
116 : * func_state is a List of execution_state records, each of which is the
117 : * first for its original parsetree, with any additional records chained
118 : * to it via the "next" fields. This sublist structure is needed to keep
119 : * track of where the original query boundaries are.
120 : */
121 : List *func_state;
122 :
123 : MemoryContext fcontext; /* memory context holding this struct and all
124 : * subsidiary data */
125 :
126 : LocalTransactionId lxid; /* lxid in which cache was made */
127 : SubTransactionId subxid; /* subxid in which cache was made */
128 : } SQLFunctionCache;
129 :
130 : typedef SQLFunctionCache *SQLFunctionCachePtr;
131 :
132 :
133 : /* non-export function prototypes */
134 : static Node *sql_fn_param_ref(ParseState *pstate, ParamRef *pref);
135 : static Node *sql_fn_post_column_ref(ParseState *pstate,
136 : ColumnRef *cref, Node *var);
137 : static Node *sql_fn_make_param(SQLFunctionParseInfoPtr pinfo,
138 : int paramno, int location);
139 : static Node *sql_fn_resolve_param_name(SQLFunctionParseInfoPtr pinfo,
140 : const char *paramname, int location);
141 : static List *init_execution_state(List *queryTree_list,
142 : SQLFunctionCachePtr fcache,
143 : bool lazyEvalOK);
144 : static void init_sql_fcache(FunctionCallInfo fcinfo, Oid collation, bool lazyEvalOK);
145 : static void postquel_start(execution_state *es, SQLFunctionCachePtr fcache);
146 : static bool postquel_getnext(execution_state *es, SQLFunctionCachePtr fcache);
147 : static void postquel_end(execution_state *es);
148 : static void postquel_sub_params(SQLFunctionCachePtr fcache,
149 : FunctionCallInfo fcinfo);
150 : static Datum postquel_get_single_result(TupleTableSlot *slot,
151 : FunctionCallInfo fcinfo,
152 : SQLFunctionCachePtr fcache,
153 : MemoryContext resultcontext);
154 : static void sql_exec_error_callback(void *arg);
155 : static void ShutdownSQLFunction(Datum arg);
156 : static bool coerce_fn_result_column(TargetEntry *src_tle,
157 : Oid res_type, int32 res_typmod,
158 : bool tlist_is_modifiable,
159 : List **upper_tlist,
160 : bool *upper_tlist_nontrivial);
161 : static void sqlfunction_startup(DestReceiver *self, int operation, TupleDesc typeinfo);
162 : static bool sqlfunction_receive(TupleTableSlot *slot, DestReceiver *self);
163 : static void sqlfunction_shutdown(DestReceiver *self);
164 : static void sqlfunction_destroy(DestReceiver *self);
165 :
166 :
167 : /*
168 : * Prepare the SQLFunctionParseInfo struct for parsing a SQL function body
169 : *
170 : * This includes resolving actual types of polymorphic arguments.
171 : *
172 : * call_expr can be passed as NULL, but then we will fail if there are any
173 : * polymorphic arguments.
174 : */
175 : SQLFunctionParseInfoPtr
176 60776 : prepare_sql_fn_parse_info(HeapTuple procedureTuple,
177 : Node *call_expr,
178 : Oid inputCollation)
179 : {
180 : SQLFunctionParseInfoPtr pinfo;
181 60776 : Form_pg_proc procedureStruct = (Form_pg_proc) GETSTRUCT(procedureTuple);
182 : int nargs;
183 :
184 60776 : pinfo = (SQLFunctionParseInfoPtr) palloc0(sizeof(SQLFunctionParseInfo));
185 :
186 : /* Function's name (only) can be used to qualify argument names */
187 60776 : pinfo->fname = pstrdup(NameStr(procedureStruct->proname));
188 :
189 : /* Save the function's input collation */
190 60776 : pinfo->collation = inputCollation;
191 :
192 : /*
193 : * Copy input argument types from the pg_proc entry, then resolve any
194 : * polymorphic types.
195 : */
196 60776 : pinfo->nargs = nargs = procedureStruct->pronargs;
197 60776 : if (nargs > 0)
198 : {
199 : Oid *argOidVect;
200 : int argnum;
201 :
202 40870 : argOidVect = (Oid *) palloc(nargs * sizeof(Oid));
203 40870 : memcpy(argOidVect,
204 40870 : procedureStruct->proargtypes.values,
205 : nargs * sizeof(Oid));
206 :
207 120046 : for (argnum = 0; argnum < nargs; argnum++)
208 : {
209 79176 : Oid argtype = argOidVect[argnum];
210 :
211 79176 : if (IsPolymorphicType(argtype))
212 : {
213 2930 : argtype = get_call_expr_argtype(call_expr, argnum);
214 2930 : if (argtype == InvalidOid)
215 0 : ereport(ERROR,
216 : (errcode(ERRCODE_DATATYPE_MISMATCH),
217 : errmsg("could not determine actual type of argument declared %s",
218 : format_type_be(argOidVect[argnum]))));
219 2930 : argOidVect[argnum] = argtype;
220 : }
221 : }
222 :
223 40870 : pinfo->argtypes = argOidVect;
224 : }
225 :
226 : /*
227 : * Collect names of arguments, too, if any
228 : */
229 60776 : if (nargs > 0)
230 : {
231 : Datum proargnames;
232 : Datum proargmodes;
233 : int n_arg_names;
234 : bool isNull;
235 :
236 40870 : proargnames = SysCacheGetAttr(PROCNAMEARGSNSP, procedureTuple,
237 : Anum_pg_proc_proargnames,
238 : &isNull);
239 40870 : if (isNull)
240 31988 : proargnames = PointerGetDatum(NULL); /* just to be sure */
241 :
242 40870 : proargmodes = SysCacheGetAttr(PROCNAMEARGSNSP, procedureTuple,
243 : Anum_pg_proc_proargmodes,
244 : &isNull);
245 40870 : if (isNull)
246 39974 : proargmodes = PointerGetDatum(NULL); /* just to be sure */
247 :
248 40870 : n_arg_names = get_func_input_arg_names(proargnames, proargmodes,
249 : &pinfo->argnames);
250 :
251 : /* Paranoia: ignore the result if too few array entries */
252 40870 : if (n_arg_names < nargs)
253 31988 : pinfo->argnames = NULL;
254 : }
255 : else
256 19906 : pinfo->argnames = NULL;
257 :
258 60776 : return pinfo;
259 : }
260 :
261 : /*
262 : * Parser setup hook for parsing a SQL function body.
263 : */
264 : void
265 63378 : sql_fn_parser_setup(struct ParseState *pstate, SQLFunctionParseInfoPtr pinfo)
266 : {
267 63378 : pstate->p_pre_columnref_hook = NULL;
268 63378 : pstate->p_post_columnref_hook = sql_fn_post_column_ref;
269 63378 : pstate->p_paramref_hook = sql_fn_param_ref;
270 : /* no need to use p_coerce_param_hook */
271 63378 : pstate->p_ref_hook_state = (void *) pinfo;
272 63378 : }
273 :
274 : /*
275 : * sql_fn_post_column_ref parser callback for ColumnRefs
276 : */
277 : static Node *
278 12272 : sql_fn_post_column_ref(ParseState *pstate, ColumnRef *cref, Node *var)
279 : {
280 12272 : SQLFunctionParseInfoPtr pinfo = (SQLFunctionParseInfoPtr) pstate->p_ref_hook_state;
281 : int nnames;
282 : Node *field1;
283 12272 : Node *subfield = NULL;
284 : const char *name1;
285 12272 : const char *name2 = NULL;
286 : Node *param;
287 :
288 : /*
289 : * Never override a table-column reference. This corresponds to
290 : * considering the parameter names to appear in a scope outside the
291 : * individual SQL commands, which is what we want.
292 : */
293 12272 : if (var != NULL)
294 9550 : return NULL;
295 :
296 : /*----------
297 : * The allowed syntaxes are:
298 : *
299 : * A A = parameter name
300 : * A.B A = function name, B = parameter name
301 : * OR: A = record-typed parameter name, B = field name
302 : * (the first possibility takes precedence)
303 : * A.B.C A = function name, B = record-typed parameter name,
304 : * C = field name
305 : * A.* Whole-row reference to composite parameter A.
306 : * A.B.* Same, with A = function name, B = parameter name
307 : *
308 : * Here, it's sufficient to ignore the "*" in the last two cases --- the
309 : * main parser will take care of expanding the whole-row reference.
310 : *----------
311 : */
312 2722 : nnames = list_length(cref->fields);
313 :
314 2722 : if (nnames > 3)
315 0 : return NULL;
316 :
317 2722 : if (IsA(llast(cref->fields), A_Star))
318 54 : nnames--;
319 :
320 2722 : field1 = (Node *) linitial(cref->fields);
321 2722 : name1 = strVal(field1);
322 2722 : if (nnames > 1)
323 : {
324 156 : subfield = (Node *) lsecond(cref->fields);
325 156 : name2 = strVal(subfield);
326 : }
327 :
328 2722 : if (nnames == 3)
329 : {
330 : /*
331 : * Three-part name: if the first part doesn't match the function name,
332 : * we can fail immediately. Otherwise, look up the second part, and
333 : * take the third part to be a field reference.
334 : */
335 24 : if (strcmp(name1, pinfo->fname) != 0)
336 0 : return NULL;
337 :
338 24 : param = sql_fn_resolve_param_name(pinfo, name2, cref->location);
339 :
340 24 : subfield = (Node *) lthird(cref->fields);
341 : Assert(IsA(subfield, String));
342 : }
343 2698 : else if (nnames == 2 && strcmp(name1, pinfo->fname) == 0)
344 : {
345 : /*
346 : * Two-part name with first part matching function name: first see if
347 : * second part matches any parameter name.
348 : */
349 24 : param = sql_fn_resolve_param_name(pinfo, name2, cref->location);
350 :
351 24 : if (param)
352 : {
353 : /* Yes, so this is a parameter reference, no subfield */
354 24 : subfield = NULL;
355 : }
356 : else
357 : {
358 : /* No, so try to match as parameter name and subfield */
359 0 : param = sql_fn_resolve_param_name(pinfo, name1, cref->location);
360 : }
361 : }
362 : else
363 : {
364 : /* Single name, or parameter name followed by subfield */
365 2674 : param = sql_fn_resolve_param_name(pinfo, name1, cref->location);
366 : }
367 :
368 2722 : if (!param)
369 0 : return NULL; /* No match */
370 :
371 2722 : if (subfield)
372 : {
373 : /*
374 : * Must be a reference to a field of a composite parameter; otherwise
375 : * ParseFuncOrColumn will return NULL, and we'll fail back at the
376 : * caller.
377 : */
378 132 : param = ParseFuncOrColumn(pstate,
379 132 : list_make1(subfield),
380 132 : list_make1(param),
381 : pstate->p_last_srf,
382 : NULL,
383 : false,
384 : cref->location);
385 : }
386 :
387 2722 : return param;
388 : }
389 :
390 : /*
391 : * sql_fn_param_ref parser callback for ParamRefs ($n symbols)
392 : */
393 : static Node *
394 145390 : sql_fn_param_ref(ParseState *pstate, ParamRef *pref)
395 : {
396 145390 : SQLFunctionParseInfoPtr pinfo = (SQLFunctionParseInfoPtr) pstate->p_ref_hook_state;
397 145390 : int paramno = pref->number;
398 :
399 : /* Check parameter number is valid */
400 145390 : if (paramno <= 0 || paramno > pinfo->nargs)
401 6 : return NULL; /* unknown parameter number */
402 :
403 145384 : return sql_fn_make_param(pinfo, paramno, pref->location);
404 : }
405 :
406 : /*
407 : * sql_fn_make_param construct a Param node for the given paramno
408 : */
409 : static Node *
410 148106 : sql_fn_make_param(SQLFunctionParseInfoPtr pinfo,
411 : int paramno, int location)
412 : {
413 : Param *param;
414 :
415 148106 : param = makeNode(Param);
416 148106 : param->paramkind = PARAM_EXTERN;
417 148106 : param->paramid = paramno;
418 148106 : param->paramtype = pinfo->argtypes[paramno - 1];
419 148106 : param->paramtypmod = -1;
420 148106 : param->paramcollid = get_typcollation(param->paramtype);
421 148106 : param->location = location;
422 :
423 : /*
424 : * If we have a function input collation, allow it to override the
425 : * type-derived collation for parameter symbols. (XXX perhaps this should
426 : * not happen if the type collation is not default?)
427 : */
428 148106 : if (OidIsValid(pinfo->collation) && OidIsValid(param->paramcollid))
429 2912 : param->paramcollid = pinfo->collation;
430 :
431 148106 : return (Node *) param;
432 : }
433 :
434 : /*
435 : * Search for a function parameter of the given name; if there is one,
436 : * construct and return a Param node for it. If not, return NULL.
437 : * Helper function for sql_fn_post_column_ref.
438 : */
439 : static Node *
440 2722 : sql_fn_resolve_param_name(SQLFunctionParseInfoPtr pinfo,
441 : const char *paramname, int location)
442 : {
443 : int i;
444 :
445 2722 : if (pinfo->argnames == NULL)
446 0 : return NULL;
447 :
448 3884 : for (i = 0; i < pinfo->nargs; i++)
449 : {
450 3884 : if (pinfo->argnames[i] && strcmp(pinfo->argnames[i], paramname) == 0)
451 2722 : return sql_fn_make_param(pinfo, i + 1, location);
452 : }
453 :
454 0 : return NULL;
455 : }
456 :
457 : /*
458 : * Set up the per-query execution_state records for a SQL function.
459 : *
460 : * The input is a List of Lists of parsed and rewritten, but not planned,
461 : * querytrees. The sublist structure denotes the original query boundaries.
462 : */
463 : static List *
464 39616 : init_execution_state(List *queryTree_list,
465 : SQLFunctionCachePtr fcache,
466 : bool lazyEvalOK)
467 : {
468 39616 : List *eslist = NIL;
469 39616 : execution_state *lasttages = NULL;
470 : ListCell *lc1;
471 :
472 79356 : foreach(lc1, queryTree_list)
473 : {
474 39746 : List *qtlist = lfirst_node(List, lc1);
475 39746 : execution_state *firstes = NULL;
476 39746 : execution_state *preves = NULL;
477 : ListCell *lc2;
478 :
479 79492 : foreach(lc2, qtlist)
480 : {
481 39752 : Query *queryTree = lfirst_node(Query, lc2);
482 : PlannedStmt *stmt;
483 : execution_state *newes;
484 :
485 : /* Plan the query if needed */
486 39752 : if (queryTree->commandType == CMD_UTILITY)
487 : {
488 : /* Utility commands require no planning. */
489 168 : stmt = makeNode(PlannedStmt);
490 168 : stmt->commandType = CMD_UTILITY;
491 168 : stmt->canSetTag = queryTree->canSetTag;
492 168 : stmt->utilityStmt = queryTree->utilityStmt;
493 168 : stmt->stmt_location = queryTree->stmt_location;
494 168 : stmt->stmt_len = queryTree->stmt_len;
495 168 : stmt->queryId = queryTree->queryId;
496 : }
497 : else
498 39584 : stmt = pg_plan_query(queryTree,
499 39584 : fcache->src,
500 : CURSOR_OPT_PARALLEL_OK,
501 : NULL);
502 :
503 : /*
504 : * Precheck all commands for validity in a function. This should
505 : * generally match the restrictions spi.c applies.
506 : */
507 39746 : if (stmt->commandType == CMD_UTILITY)
508 : {
509 168 : if (IsA(stmt->utilityStmt, CopyStmt) &&
510 0 : ((CopyStmt *) stmt->utilityStmt)->filename == NULL)
511 0 : ereport(ERROR,
512 : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
513 : errmsg("cannot COPY to/from client in an SQL function")));
514 :
515 168 : if (IsA(stmt->utilityStmt, TransactionStmt))
516 0 : ereport(ERROR,
517 : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
518 : /* translator: %s is a SQL statement name */
519 : errmsg("%s is not allowed in an SQL function",
520 : CreateCommandName(stmt->utilityStmt))));
521 : }
522 :
523 39746 : if (fcache->readonly_func && !CommandIsReadOnly(stmt))
524 0 : ereport(ERROR,
525 : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
526 : /* translator: %s is a SQL statement name */
527 : errmsg("%s is not allowed in a non-volatile function",
528 : CreateCommandName((Node *) stmt))));
529 :
530 : /* OK, build the execution_state for this query */
531 39746 : newes = (execution_state *) palloc(sizeof(execution_state));
532 39746 : if (preves)
533 6 : preves->next = newes;
534 : else
535 39740 : firstes = newes;
536 :
537 39746 : newes->next = NULL;
538 39746 : newes->status = F_EXEC_START;
539 39746 : newes->setsResult = false; /* might change below */
540 39746 : newes->lazyEval = false; /* might change below */
541 39746 : newes->stmt = stmt;
542 39746 : newes->qd = NULL;
543 :
544 39746 : if (queryTree->canSetTag)
545 39740 : lasttages = newes;
546 :
547 39746 : preves = newes;
548 : }
549 :
550 39740 : eslist = lappend(eslist, firstes);
551 : }
552 :
553 : /*
554 : * Mark the last canSetTag query as delivering the function result; then,
555 : * if it is a plain SELECT, mark it for lazy evaluation. If it's not a
556 : * SELECT we must always run it to completion.
557 : *
558 : * Note: at some point we might add additional criteria for whether to use
559 : * lazy eval. However, we should prefer to use it whenever the function
560 : * doesn't return set, since fetching more than one row is useless in that
561 : * case.
562 : *
563 : * Note: don't set setsResult if the function returns VOID, as evidenced
564 : * by not having made a junkfilter. This ensures we'll throw away any
565 : * output from the last statement in such a function.
566 : */
567 39610 : if (lasttages && fcache->junkFilter)
568 : {
569 39322 : lasttages->setsResult = true;
570 39322 : if (lazyEvalOK &&
571 38674 : lasttages->stmt->commandType == CMD_SELECT &&
572 38608 : !lasttages->stmt->hasModifyingCTE)
573 38608 : fcache->lazyEval = lasttages->lazyEval = true;
574 : }
575 :
576 39610 : return eslist;
577 : }
578 :
579 : /*
580 : * Initialize the SQLFunctionCache for a SQL function
581 : */
582 : static void
583 39624 : init_sql_fcache(FunctionCallInfo fcinfo, Oid collation, bool lazyEvalOK)
584 : {
585 39624 : FmgrInfo *finfo = fcinfo->flinfo;
586 39624 : Oid foid = finfo->fn_oid;
587 : MemoryContext fcontext;
588 : MemoryContext oldcontext;
589 : Oid rettype;
590 : TupleDesc rettupdesc;
591 : HeapTuple procedureTuple;
592 : Form_pg_proc procedureStruct;
593 : SQLFunctionCachePtr fcache;
594 : List *queryTree_list;
595 : List *resulttlist;
596 : ListCell *lc;
597 : Datum tmp;
598 : bool isNull;
599 :
600 : /*
601 : * Create memory context that holds all the SQLFunctionCache data. It
602 : * must be a child of whatever context holds the FmgrInfo.
603 : */
604 39624 : fcontext = AllocSetContextCreate(finfo->fn_mcxt,
605 : "SQL function",
606 : ALLOCSET_DEFAULT_SIZES);
607 :
608 39624 : oldcontext = MemoryContextSwitchTo(fcontext);
609 :
610 : /*
611 : * Create the struct proper, link it to fcontext and fn_extra. Once this
612 : * is done, we'll be able to recover the memory after failure, even if the
613 : * FmgrInfo is long-lived.
614 : */
615 39624 : fcache = (SQLFunctionCachePtr) palloc0(sizeof(SQLFunctionCache));
616 39624 : fcache->fcontext = fcontext;
617 39624 : finfo->fn_extra = (void *) fcache;
618 :
619 : /*
620 : * get the procedure tuple corresponding to the given function Oid
621 : */
622 39624 : procedureTuple = SearchSysCache1(PROCOID, ObjectIdGetDatum(foid));
623 39624 : if (!HeapTupleIsValid(procedureTuple))
624 0 : elog(ERROR, "cache lookup failed for function %u", foid);
625 39624 : procedureStruct = (Form_pg_proc) GETSTRUCT(procedureTuple);
626 :
627 : /*
628 : * copy function name immediately for use by error reporting callback, and
629 : * for use as memory context identifier
630 : */
631 39624 : fcache->fname = pstrdup(NameStr(procedureStruct->proname));
632 39624 : MemoryContextSetIdentifier(fcontext, fcache->fname);
633 :
634 : /*
635 : * Resolve any polymorphism, obtaining the actual result type, and the
636 : * corresponding tupdesc if it's a rowtype.
637 : */
638 39624 : (void) get_call_result_type(fcinfo, &rettype, &rettupdesc);
639 :
640 39624 : fcache->rettype = rettype;
641 :
642 : /* Fetch the typlen and byval info for the result type */
643 39624 : get_typlenbyval(rettype, &fcache->typlen, &fcache->typbyval);
644 :
645 : /* Remember whether we're returning setof something */
646 39624 : fcache->returnsSet = procedureStruct->proretset;
647 :
648 : /* Remember if function is STABLE/IMMUTABLE */
649 39624 : fcache->readonly_func =
650 39624 : (procedureStruct->provolatile != PROVOLATILE_VOLATILE);
651 :
652 : /*
653 : * We need the actual argument types to pass to the parser. Also make
654 : * sure that parameter symbols are considered to have the function's
655 : * resolved input collation.
656 : */
657 79248 : fcache->pinfo = prepare_sql_fn_parse_info(procedureTuple,
658 39624 : finfo->fn_expr,
659 : collation);
660 :
661 : /*
662 : * And of course we need the function body text.
663 : */
664 39624 : tmp = SysCacheGetAttrNotNull(PROCOID, procedureTuple, Anum_pg_proc_prosrc);
665 39624 : fcache->src = TextDatumGetCString(tmp);
666 :
667 : /* If we have prosqlbody, pay attention to that not prosrc. */
668 39624 : tmp = SysCacheGetAttr(PROCOID,
669 : procedureTuple,
670 : Anum_pg_proc_prosqlbody,
671 : &isNull);
672 :
673 : /*
674 : * Parse and rewrite the queries in the function text. Use sublists to
675 : * keep track of the original query boundaries.
676 : *
677 : * Note: since parsing and planning is done in fcontext, we will generate
678 : * a lot of cruft that lives as long as the fcache does. This is annoying
679 : * but we'll not worry about it until the module is rewritten to use
680 : * plancache.c.
681 : */
682 39624 : queryTree_list = NIL;
683 39624 : if (!isNull)
684 : {
685 : Node *n;
686 : List *stored_query_list;
687 :
688 2568 : n = stringToNode(TextDatumGetCString(tmp));
689 2568 : if (IsA(n, List))
690 2118 : stored_query_list = linitial_node(List, castNode(List, n));
691 : else
692 450 : stored_query_list = list_make1(n);
693 :
694 5136 : foreach(lc, stored_query_list)
695 : {
696 2568 : Query *parsetree = lfirst_node(Query, lc);
697 : List *queryTree_sublist;
698 :
699 2568 : AcquireRewriteLocks(parsetree, true, false);
700 2568 : queryTree_sublist = pg_rewrite_query(parsetree);
701 2568 : queryTree_list = lappend(queryTree_list, queryTree_sublist);
702 : }
703 : }
704 : else
705 : {
706 : List *raw_parsetree_list;
707 :
708 37056 : raw_parsetree_list = pg_parse_query(fcache->src);
709 :
710 74240 : foreach(lc, raw_parsetree_list)
711 : {
712 37186 : RawStmt *parsetree = lfirst_node(RawStmt, lc);
713 : List *queryTree_sublist;
714 :
715 37186 : queryTree_sublist = pg_analyze_and_rewrite_withcb(parsetree,
716 37186 : fcache->src,
717 : (ParserSetupHook) sql_fn_parser_setup,
718 37186 : fcache->pinfo,
719 : NULL);
720 37184 : queryTree_list = lappend(queryTree_list, queryTree_sublist);
721 : }
722 : }
723 :
724 : /*
725 : * Check that there are no statements we don't want to allow.
726 : */
727 39622 : check_sql_fn_statements(queryTree_list);
728 :
729 : /*
730 : * Check that the function returns the type it claims to. Although in
731 : * simple cases this was already done when the function was defined, we
732 : * have to recheck because database objects used in the function's queries
733 : * might have changed type. We'd have to recheck anyway if the function
734 : * had any polymorphic arguments. Moreover, check_sql_fn_retval takes
735 : * care of injecting any required column type coercions. (But we don't
736 : * ask it to insert nulls for dropped columns; the junkfilter handles
737 : * that.)
738 : *
739 : * Note: we set fcache->returnsTuple according to whether we are returning
740 : * the whole tuple result or just a single column. In the latter case we
741 : * clear returnsTuple because we need not act different from the scalar
742 : * result case, even if it's a rowtype column. (However, we have to force
743 : * lazy eval mode in that case; otherwise we'd need extra code to expand
744 : * the rowtype column into multiple columns, since we have no way to
745 : * notify the caller that it should do that.)
746 : */
747 79238 : fcache->returnsTuple = check_sql_fn_retval(queryTree_list,
748 : rettype,
749 : rettupdesc,
750 39622 : procedureStruct->prokind,
751 : false,
752 : &resulttlist);
753 :
754 : /*
755 : * Construct a JunkFilter we can use to coerce the returned rowtype to the
756 : * desired form, unless the result type is VOID, in which case there's
757 : * nothing to coerce to. (XXX Frequently, the JunkFilter isn't doing
758 : * anything very interesting, but much of this module expects it to be
759 : * there anyway.)
760 : */
761 39616 : if (rettype != VOIDOID)
762 : {
763 39328 : TupleTableSlot *slot = MakeSingleTupleTableSlot(NULL,
764 : &TTSOpsMinimalTuple);
765 :
766 : /*
767 : * If the result is composite, *and* we are returning the whole tuple
768 : * result, we need to insert nulls for any dropped columns. In the
769 : * single-column-result case, there might be dropped columns within
770 : * the composite column value, but it's not our problem here. There
771 : * should be no resjunk entries in resulttlist, so in the second case
772 : * the JunkFilter is certainly a no-op.
773 : */
774 39328 : if (rettupdesc && fcache->returnsTuple)
775 1272 : fcache->junkFilter = ExecInitJunkFilterConversion(resulttlist,
776 : rettupdesc,
777 : slot);
778 : else
779 38056 : fcache->junkFilter = ExecInitJunkFilter(resulttlist, slot);
780 : }
781 :
782 39616 : if (fcache->returnsTuple)
783 : {
784 : /* Make sure output rowtype is properly blessed */
785 1296 : BlessTupleDesc(fcache->junkFilter->jf_resultSlot->tts_tupleDescriptor);
786 : }
787 38320 : else if (fcache->returnsSet && type_is_rowtype(fcache->rettype))
788 : {
789 : /*
790 : * Returning rowtype as if it were scalar --- materialize won't work.
791 : * Right now it's sufficient to override any caller preference for
792 : * materialize mode, but to add more smarts in init_execution_state
793 : * about this, we'd probably need a three-way flag instead of bool.
794 : */
795 0 : lazyEvalOK = true;
796 : }
797 :
798 : /* Finally, plan the queries */
799 39616 : fcache->func_state = init_execution_state(queryTree_list,
800 : fcache,
801 : lazyEvalOK);
802 :
803 : /* Mark fcache with time of creation to show it's valid */
804 39610 : fcache->lxid = MyProc->vxid.lxid;
805 39610 : fcache->subxid = GetCurrentSubTransactionId();
806 :
807 39610 : ReleaseSysCache(procedureTuple);
808 :
809 39610 : MemoryContextSwitchTo(oldcontext);
810 39610 : }
811 :
812 : /* Start up execution of one execution_state node */
813 : static void
814 175632 : postquel_start(execution_state *es, SQLFunctionCachePtr fcache)
815 : {
816 : DestReceiver *dest;
817 :
818 : Assert(es->qd == NULL);
819 :
820 : /* Caller should have ensured a suitable snapshot is active */
821 : Assert(ActiveSnapshotSet());
822 :
823 : /*
824 : * If this query produces the function result, send its output to the
825 : * tuplestore; else discard any output.
826 : */
827 175632 : if (es->setsResult)
828 : {
829 : DR_sqlfunction *myState;
830 :
831 135218 : dest = CreateDestReceiver(DestSQLFunction);
832 : /* pass down the needed info to the dest receiver routines */
833 135218 : myState = (DR_sqlfunction *) dest;
834 : Assert(myState->pub.mydest == DestSQLFunction);
835 135218 : myState->tstore = fcache->tstore;
836 135218 : myState->cxt = CurrentMemoryContext;
837 135218 : myState->filter = fcache->junkFilter;
838 : }
839 : else
840 40414 : dest = None_Receiver;
841 :
842 175632 : es->qd = CreateQueryDesc(es->stmt,
843 175632 : fcache->src,
844 : GetActiveSnapshot(),
845 : InvalidSnapshot,
846 : dest,
847 : fcache->paramLI,
848 175632 : es->qd ? es->qd->queryEnv : NULL,
849 : 0);
850 :
851 : /* Utility commands don't need Executor. */
852 175632 : if (es->qd->operation != CMD_UTILITY)
853 : {
854 : /*
855 : * In lazyEval mode, do not let the executor set up an AfterTrigger
856 : * context. This is necessary not just an optimization, because we
857 : * mustn't exit from the function execution with a stacked
858 : * AfterTrigger level still active. We are careful not to select
859 : * lazyEval mode for any statement that could possibly queue triggers.
860 : */
861 : int eflags;
862 :
863 175464 : if (es->lazyEval)
864 134306 : eflags = EXEC_FLAG_SKIP_TRIGGERS;
865 : else
866 41158 : eflags = 0; /* default run-to-completion flags */
867 175464 : ExecutorStart(es->qd, eflags);
868 : }
869 :
870 175632 : es->status = F_EXEC_RUN;
871 175632 : }
872 :
873 : /* Run one execution_state; either to completion or to first result row */
874 : /* Returns true if we ran to completion */
875 : static bool
876 176596 : postquel_getnext(execution_state *es, SQLFunctionCachePtr fcache)
877 : {
878 : bool result;
879 :
880 176596 : if (es->qd->operation == CMD_UTILITY)
881 : {
882 168 : ProcessUtility(es->qd->plannedstmt,
883 168 : fcache->src,
884 : true, /* protect function cache's parsetree */
885 : PROCESS_UTILITY_QUERY,
886 168 : es->qd->params,
887 168 : es->qd->queryEnv,
888 168 : es->qd->dest,
889 : NULL);
890 78 : result = true; /* never stops early */
891 : }
892 : else
893 : {
894 : /* Run regular commands to completion unless lazyEval */
895 176428 : uint64 count = (es->lazyEval) ? 1 : 0;
896 :
897 176428 : ExecutorRun(es->qd, ForwardScanDirection, count, !fcache->returnsSet || !es->lazyEval);
898 :
899 : /*
900 : * If we requested run to completion OR there was no tuple returned,
901 : * command must be complete.
902 : */
903 168120 : result = (count == 0 || es->qd->estate->es_processed == 0);
904 : }
905 :
906 168198 : return result;
907 : }
908 :
909 : /* Shut down execution of one execution_state node */
910 : static void
911 167234 : postquel_end(execution_state *es)
912 : {
913 : /* mark status done to ensure we don't do ExecutorEnd twice */
914 167234 : es->status = F_EXEC_DONE;
915 :
916 : /* Utility commands don't need Executor. */
917 167234 : if (es->qd->operation != CMD_UTILITY)
918 : {
919 167156 : ExecutorFinish(es->qd);
920 167138 : ExecutorEnd(es->qd);
921 : }
922 :
923 167216 : es->qd->dest->rDestroy(es->qd->dest);
924 :
925 167216 : FreeQueryDesc(es->qd);
926 167216 : es->qd = NULL;
927 167216 : }
928 :
929 : /* Build ParamListInfo array representing current arguments */
930 : static void
931 135530 : postquel_sub_params(SQLFunctionCachePtr fcache,
932 : FunctionCallInfo fcinfo)
933 : {
934 135530 : int nargs = fcinfo->nargs;
935 :
936 135530 : if (nargs > 0)
937 : {
938 : ParamListInfo paramLI;
939 124672 : Oid *argtypes = fcache->pinfo->argtypes;
940 :
941 124672 : if (fcache->paramLI == NULL)
942 : {
943 28782 : paramLI = makeParamList(nargs);
944 28782 : fcache->paramLI = paramLI;
945 : }
946 : else
947 : {
948 95890 : paramLI = fcache->paramLI;
949 : Assert(paramLI->numParams == nargs);
950 : }
951 :
952 370008 : for (int i = 0; i < nargs; i++)
953 : {
954 245336 : ParamExternData *prm = ¶mLI->params[i];
955 :
956 : /*
957 : * If an incoming parameter value is a R/W expanded datum, we
958 : * force it to R/O. We'd be perfectly entitled to scribble on it,
959 : * but the problem is that if the parameter is referenced more
960 : * than once in the function, earlier references might mutate the
961 : * value seen by later references, which won't do at all. We
962 : * could do better if we could be sure of the number of Param
963 : * nodes in the function's plans; but we might not have planned
964 : * all the statements yet, nor do we have plan tree walker
965 : * infrastructure. (Examining the parse trees is not good enough,
966 : * because of possible function inlining during planning.)
967 : */
968 245336 : prm->isnull = fcinfo->args[i].isnull;
969 245336 : prm->value = MakeExpandedObjectReadOnly(fcinfo->args[i].value,
970 : prm->isnull,
971 : get_typlen(argtypes[i]));
972 245336 : prm->pflags = 0;
973 245336 : prm->ptype = argtypes[i];
974 : }
975 : }
976 : else
977 10858 : fcache->paramLI = NULL;
978 135530 : }
979 :
980 : /*
981 : * Extract the SQL function's value from a single result row. This is used
982 : * both for scalar (non-set) functions and for each row of a lazy-eval set
983 : * result.
984 : */
985 : static Datum
986 119586 : postquel_get_single_result(TupleTableSlot *slot,
987 : FunctionCallInfo fcinfo,
988 : SQLFunctionCachePtr fcache,
989 : MemoryContext resultcontext)
990 : {
991 : Datum value;
992 : MemoryContext oldcontext;
993 :
994 : /*
995 : * Set up to return the function value. For pass-by-reference datatypes,
996 : * be sure to allocate the result in resultcontext, not the current memory
997 : * context (which has query lifespan). We can't leave the data in the
998 : * TupleTableSlot because we intend to clear the slot before returning.
999 : */
1000 119586 : oldcontext = MemoryContextSwitchTo(resultcontext);
1001 :
1002 119586 : if (fcache->returnsTuple)
1003 : {
1004 : /* We must return the whole tuple as a Datum. */
1005 1470 : fcinfo->isnull = false;
1006 1470 : value = ExecFetchSlotHeapTupleDatum(slot);
1007 : }
1008 : else
1009 : {
1010 : /*
1011 : * Returning a scalar, which we have to extract from the first column
1012 : * of the SELECT result, and then copy into result context if needed.
1013 : */
1014 118116 : value = slot_getattr(slot, 1, &(fcinfo->isnull));
1015 :
1016 118116 : if (!fcinfo->isnull)
1017 117774 : value = datumCopy(value, fcache->typbyval, fcache->typlen);
1018 : }
1019 :
1020 119586 : MemoryContextSwitchTo(oldcontext);
1021 :
1022 119586 : return value;
1023 : }
1024 :
1025 : /*
1026 : * fmgr_sql: function call manager for SQL functions
1027 : */
1028 : Datum
1029 136514 : fmgr_sql(PG_FUNCTION_ARGS)
1030 : {
1031 : SQLFunctionCachePtr fcache;
1032 : ErrorContextCallback sqlerrcontext;
1033 : MemoryContext oldcontext;
1034 : bool randomAccess;
1035 : bool lazyEvalOK;
1036 : bool is_first;
1037 : bool pushed_snapshot;
1038 : execution_state *es;
1039 : TupleTableSlot *slot;
1040 : Datum result;
1041 : List *eslist;
1042 : ListCell *eslc;
1043 :
1044 : /*
1045 : * Setup error traceback support for ereport()
1046 : */
1047 136514 : sqlerrcontext.callback = sql_exec_error_callback;
1048 136514 : sqlerrcontext.arg = fcinfo->flinfo;
1049 136514 : sqlerrcontext.previous = error_context_stack;
1050 136514 : error_context_stack = &sqlerrcontext;
1051 :
1052 : /* Check call context */
1053 136514 : if (fcinfo->flinfo->fn_retset)
1054 : {
1055 5010 : ReturnSetInfo *rsi = (ReturnSetInfo *) fcinfo->resultinfo;
1056 :
1057 : /*
1058 : * For simplicity, we require callers to support both set eval modes.
1059 : * There are cases where we must use one or must use the other, and
1060 : * it's not really worthwhile to postpone the check till we know. But
1061 : * note we do not require caller to provide an expectedDesc.
1062 : */
1063 5010 : if (!rsi || !IsA(rsi, ReturnSetInfo) ||
1064 5010 : (rsi->allowedModes & SFRM_ValuePerCall) == 0 ||
1065 5010 : (rsi->allowedModes & SFRM_Materialize) == 0)
1066 0 : ereport(ERROR,
1067 : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1068 : errmsg("set-valued function called in context that cannot accept a set")));
1069 5010 : randomAccess = rsi->allowedModes & SFRM_Materialize_Random;
1070 5010 : lazyEvalOK = !(rsi->allowedModes & SFRM_Materialize_Preferred);
1071 : }
1072 : else
1073 : {
1074 131504 : randomAccess = false;
1075 131504 : lazyEvalOK = true;
1076 : }
1077 :
1078 : /*
1079 : * Initialize fcache (build plans) if first time through; or re-initialize
1080 : * if the cache is stale.
1081 : */
1082 136514 : fcache = (SQLFunctionCachePtr) fcinfo->flinfo->fn_extra;
1083 :
1084 136514 : if (fcache != NULL)
1085 : {
1086 96932 : if (fcache->lxid != MyProc->vxid.lxid ||
1087 96890 : !SubTransactionIsActive(fcache->subxid))
1088 : {
1089 : /* It's stale; unlink and delete */
1090 42 : fcinfo->flinfo->fn_extra = NULL;
1091 42 : MemoryContextDelete(fcache->fcontext);
1092 42 : fcache = NULL;
1093 : }
1094 : }
1095 :
1096 136514 : if (fcache == NULL)
1097 : {
1098 39624 : init_sql_fcache(fcinfo, PG_GET_COLLATION(), lazyEvalOK);
1099 39610 : fcache = (SQLFunctionCachePtr) fcinfo->flinfo->fn_extra;
1100 : }
1101 :
1102 : /*
1103 : * Switch to context in which the fcache lives. This ensures that our
1104 : * tuplestore etc will have sufficient lifetime. The sub-executor is
1105 : * responsible for deleting per-tuple information. (XXX in the case of a
1106 : * long-lived FmgrInfo, this policy represents more memory leakage, but
1107 : * it's not entirely clear where to keep stuff instead.)
1108 : */
1109 136500 : oldcontext = MemoryContextSwitchTo(fcache->fcontext);
1110 :
1111 : /*
1112 : * Find first unfinished query in function, and note whether it's the
1113 : * first query.
1114 : */
1115 136500 : eslist = fcache->func_state;
1116 136500 : es = NULL;
1117 136500 : is_first = true;
1118 136500 : foreach(eslc, eslist)
1119 : {
1120 136494 : es = (execution_state *) lfirst(eslc);
1121 :
1122 136494 : while (es && es->status == F_EXEC_DONE)
1123 : {
1124 0 : is_first = false;
1125 0 : es = es->next;
1126 : }
1127 :
1128 136494 : if (es)
1129 136494 : break;
1130 : }
1131 :
1132 : /*
1133 : * Convert params to appropriate format if starting a fresh execution. (If
1134 : * continuing execution, we can re-use prior params.)
1135 : */
1136 136500 : if (is_first && es && es->status == F_EXEC_START)
1137 135530 : postquel_sub_params(fcache, fcinfo);
1138 :
1139 : /*
1140 : * Build tuplestore to hold results, if we don't have one already. Note
1141 : * it's in the query-lifespan context.
1142 : */
1143 136500 : if (!fcache->tstore)
1144 39796 : fcache->tstore = tuplestore_begin_heap(randomAccess, false, work_mem);
1145 :
1146 : /*
1147 : * Execute each command in the function one after another until we either
1148 : * run out of commands or get a result row from a lazily-evaluated SELECT.
1149 : *
1150 : * Notes about snapshot management:
1151 : *
1152 : * In a read-only function, we just use the surrounding query's snapshot.
1153 : *
1154 : * In a non-read-only function, we rely on the fact that we'll never
1155 : * suspend execution between queries of the function: the only reason to
1156 : * suspend execution before completion is if we are returning a row from a
1157 : * lazily-evaluated SELECT. So, when first entering this loop, we'll
1158 : * either start a new query (and push a fresh snapshot) or re-establish
1159 : * the active snapshot from the existing query descriptor. If we need to
1160 : * start a new query in a subsequent execution of the loop, either we need
1161 : * a fresh snapshot (and pushed_snapshot is false) or the existing
1162 : * snapshot is on the active stack and we can just bump its command ID.
1163 : */
1164 136500 : pushed_snapshot = false;
1165 303716 : while (es)
1166 : {
1167 : bool completed;
1168 :
1169 176596 : if (es->status == F_EXEC_START)
1170 : {
1171 : /*
1172 : * If not read-only, be sure to advance the command counter for
1173 : * each command, so that all work to date in this transaction is
1174 : * visible. Take a new snapshot if we don't have one yet,
1175 : * otherwise just bump the command ID in the existing snapshot.
1176 : */
1177 175632 : if (!fcache->readonly_func)
1178 : {
1179 161822 : CommandCounterIncrement();
1180 161822 : if (!pushed_snapshot)
1181 : {
1182 161816 : PushActiveSnapshot(GetTransactionSnapshot());
1183 161816 : pushed_snapshot = true;
1184 : }
1185 : else
1186 6 : UpdateActiveSnapshotCommandId();
1187 : }
1188 :
1189 175632 : postquel_start(es, fcache);
1190 : }
1191 964 : else if (!fcache->readonly_func && !pushed_snapshot)
1192 : {
1193 : /* Re-establish active snapshot when re-entering function */
1194 616 : PushActiveSnapshot(es->qd->snapshot);
1195 616 : pushed_snapshot = true;
1196 : }
1197 :
1198 176596 : completed = postquel_getnext(es, fcache);
1199 :
1200 : /*
1201 : * If we ran the command to completion, we can shut it down now. Any
1202 : * row(s) we need to return are safely stashed in the tuplestore, and
1203 : * we want to be sure that, for example, AFTER triggers get fired
1204 : * before we return anything. Also, if the function doesn't return
1205 : * set, we can shut it down anyway because it must be a SELECT and we
1206 : * don't care about fetching any more result rows.
1207 : */
1208 168198 : if (completed || !fcache->returnsSet)
1209 167234 : postquel_end(es);
1210 :
1211 : /*
1212 : * Break from loop if we didn't shut down (implying we got a
1213 : * lazily-evaluated row). Otherwise we'll press on till the whole
1214 : * function is done, relying on the tuplestore to keep hold of the
1215 : * data to eventually be returned. This is necessary since an
1216 : * INSERT/UPDATE/DELETE RETURNING that sets the result might be
1217 : * followed by additional rule-inserted commands, and we want to
1218 : * finish doing all those commands before we return anything.
1219 : */
1220 168180 : if (es->status != F_EXEC_DONE)
1221 964 : break;
1222 :
1223 : /*
1224 : * Advance to next execution_state, which might be in the next list.
1225 : */
1226 167216 : es = es->next;
1227 207312 : while (!es)
1228 : {
1229 167210 : eslc = lnext(eslist, eslc);
1230 167210 : if (!eslc)
1231 127114 : break; /* end of function */
1232 :
1233 40096 : es = (execution_state *) lfirst(eslc);
1234 :
1235 : /*
1236 : * Flush the current snapshot so that we will take a new one for
1237 : * the new query list. This ensures that new snaps are taken at
1238 : * original-query boundaries, matching the behavior of interactive
1239 : * execution.
1240 : */
1241 40096 : if (pushed_snapshot)
1242 : {
1243 40096 : PopActiveSnapshot();
1244 40096 : pushed_snapshot = false;
1245 : }
1246 : }
1247 : }
1248 :
1249 : /*
1250 : * The tuplestore now contains whatever row(s) we are supposed to return.
1251 : */
1252 128084 : if (fcache->returnsSet)
1253 : {
1254 5004 : ReturnSetInfo *rsi = (ReturnSetInfo *) fcinfo->resultinfo;
1255 :
1256 5004 : if (es)
1257 : {
1258 : /*
1259 : * If we stopped short of being done, we must have a lazy-eval
1260 : * row.
1261 : */
1262 : Assert(es->lazyEval);
1263 : /* Re-use the junkfilter's output slot to fetch back the tuple */
1264 : Assert(fcache->junkFilter);
1265 964 : slot = fcache->junkFilter->jf_resultSlot;
1266 964 : if (!tuplestore_gettupleslot(fcache->tstore, true, false, slot))
1267 0 : elog(ERROR, "failed to fetch lazy-eval tuple");
1268 : /* Extract the result as a datum, and copy out from the slot */
1269 964 : result = postquel_get_single_result(slot, fcinfo,
1270 : fcache, oldcontext);
1271 : /* Clear the tuplestore, but keep it for next time */
1272 : /* NB: this might delete the slot's content, but we don't care */
1273 964 : tuplestore_clear(fcache->tstore);
1274 :
1275 : /*
1276 : * Let caller know we're not finished.
1277 : */
1278 964 : rsi->isDone = ExprMultipleResult;
1279 :
1280 : /*
1281 : * Ensure we will get shut down cleanly if the exprcontext is not
1282 : * run to completion.
1283 : */
1284 964 : if (!fcache->shutdown_reg)
1285 : {
1286 720 : RegisterExprContextCallback(rsi->econtext,
1287 : ShutdownSQLFunction,
1288 : PointerGetDatum(fcache));
1289 720 : fcache->shutdown_reg = true;
1290 : }
1291 : }
1292 4040 : else if (fcache->lazyEval)
1293 : {
1294 : /*
1295 : * We are done with a lazy evaluation. Clean up.
1296 : */
1297 3170 : tuplestore_clear(fcache->tstore);
1298 :
1299 : /*
1300 : * Let caller know we're finished.
1301 : */
1302 3170 : rsi->isDone = ExprEndResult;
1303 :
1304 3170 : fcinfo->isnull = true;
1305 3170 : result = (Datum) 0;
1306 :
1307 : /* Deregister shutdown callback, if we made one */
1308 3170 : if (fcache->shutdown_reg)
1309 : {
1310 720 : UnregisterExprContextCallback(rsi->econtext,
1311 : ShutdownSQLFunction,
1312 : PointerGetDatum(fcache));
1313 720 : fcache->shutdown_reg = false;
1314 : }
1315 : }
1316 : else
1317 : {
1318 : /*
1319 : * We are done with a non-lazy evaluation. Return whatever is in
1320 : * the tuplestore. (It is now caller's responsibility to free the
1321 : * tuplestore when done.)
1322 : */
1323 870 : rsi->returnMode = SFRM_Materialize;
1324 870 : rsi->setResult = fcache->tstore;
1325 870 : fcache->tstore = NULL;
1326 : /* must copy desc because execSRF.c will free it */
1327 870 : if (fcache->junkFilter)
1328 864 : rsi->setDesc = CreateTupleDescCopy(fcache->junkFilter->jf_cleanTupType);
1329 :
1330 870 : fcinfo->isnull = true;
1331 870 : result = (Datum) 0;
1332 :
1333 : /* Deregister shutdown callback, if we made one */
1334 870 : if (fcache->shutdown_reg)
1335 : {
1336 0 : UnregisterExprContextCallback(rsi->econtext,
1337 : ShutdownSQLFunction,
1338 : PointerGetDatum(fcache));
1339 0 : fcache->shutdown_reg = false;
1340 : }
1341 : }
1342 : }
1343 : else
1344 : {
1345 : /*
1346 : * Non-set function. If we got a row, return it; else return NULL.
1347 : */
1348 123080 : if (fcache->junkFilter)
1349 : {
1350 : /* Re-use the junkfilter's output slot to fetch back the tuple */
1351 122878 : slot = fcache->junkFilter->jf_resultSlot;
1352 122878 : if (tuplestore_gettupleslot(fcache->tstore, true, false, slot))
1353 118622 : result = postquel_get_single_result(slot, fcinfo,
1354 : fcache, oldcontext);
1355 : else
1356 : {
1357 4256 : fcinfo->isnull = true;
1358 4256 : result = (Datum) 0;
1359 : }
1360 : }
1361 : else
1362 : {
1363 : /* Should only get here for VOID functions and procedures */
1364 : Assert(fcache->rettype == VOIDOID);
1365 202 : fcinfo->isnull = true;
1366 202 : result = (Datum) 0;
1367 : }
1368 :
1369 : /* Clear the tuplestore, but keep it for next time */
1370 123080 : tuplestore_clear(fcache->tstore);
1371 : }
1372 :
1373 : /* Pop snapshot if we have pushed one */
1374 128084 : if (pushed_snapshot)
1375 113976 : PopActiveSnapshot();
1376 :
1377 : /*
1378 : * If we've gone through every command in the function, we are done. Reset
1379 : * the execution states to start over again on next call.
1380 : */
1381 128084 : if (es == NULL)
1382 : {
1383 294330 : foreach(eslc, fcache->func_state)
1384 : {
1385 167210 : es = (execution_state *) lfirst(eslc);
1386 334426 : while (es)
1387 : {
1388 167216 : es->status = F_EXEC_START;
1389 167216 : es = es->next;
1390 : }
1391 : }
1392 : }
1393 :
1394 128084 : error_context_stack = sqlerrcontext.previous;
1395 :
1396 128084 : MemoryContextSwitchTo(oldcontext);
1397 :
1398 128084 : return result;
1399 : }
1400 :
1401 :
1402 : /*
1403 : * error context callback to let us supply a call-stack traceback
1404 : */
1405 : static void
1406 8478 : sql_exec_error_callback(void *arg)
1407 : {
1408 8478 : FmgrInfo *flinfo = (FmgrInfo *) arg;
1409 8478 : SQLFunctionCachePtr fcache = (SQLFunctionCachePtr) flinfo->fn_extra;
1410 : int syntaxerrposition;
1411 :
1412 : /*
1413 : * We can do nothing useful if init_sql_fcache() didn't get as far as
1414 : * saving the function name
1415 : */
1416 8478 : if (fcache == NULL || fcache->fname == NULL)
1417 0 : return;
1418 :
1419 : /*
1420 : * If there is a syntax error position, convert to internal syntax error
1421 : */
1422 8478 : syntaxerrposition = geterrposition();
1423 8478 : if (syntaxerrposition > 0 && fcache->src != NULL)
1424 : {
1425 2 : errposition(0);
1426 2 : internalerrposition(syntaxerrposition);
1427 2 : internalerrquery(fcache->src);
1428 : }
1429 :
1430 : /*
1431 : * Try to determine where in the function we failed. If there is a query
1432 : * with non-null QueryDesc, finger it. (We check this rather than looking
1433 : * for F_EXEC_RUN state, so that errors during ExecutorStart or
1434 : * ExecutorEnd are blamed on the appropriate query; see postquel_start and
1435 : * postquel_end.)
1436 : */
1437 8478 : if (fcache->func_state)
1438 : {
1439 : execution_state *es;
1440 : int query_num;
1441 : ListCell *lc;
1442 :
1443 8464 : es = NULL;
1444 8464 : query_num = 1;
1445 8464 : foreach(lc, fcache->func_state)
1446 : {
1447 8464 : es = (execution_state *) lfirst(lc);
1448 8464 : while (es)
1449 : {
1450 8464 : if (es->qd)
1451 : {
1452 8464 : errcontext("SQL function \"%s\" statement %d",
1453 : fcache->fname, query_num);
1454 8464 : break;
1455 : }
1456 0 : es = es->next;
1457 : }
1458 8464 : if (es)
1459 8464 : break;
1460 0 : query_num++;
1461 : }
1462 8464 : if (es == NULL)
1463 : {
1464 : /*
1465 : * couldn't identify a running query; might be function entry,
1466 : * function exit, or between queries.
1467 : */
1468 0 : errcontext("SQL function \"%s\"", fcache->fname);
1469 : }
1470 : }
1471 : else
1472 : {
1473 : /*
1474 : * Assume we failed during init_sql_fcache(). (It's possible that the
1475 : * function actually has an empty body, but in that case we may as
1476 : * well report all errors as being "during startup".)
1477 : */
1478 14 : errcontext("SQL function \"%s\" during startup", fcache->fname);
1479 : }
1480 : }
1481 :
1482 :
1483 : /*
1484 : * callback function in case a function-returning-set needs to be shut down
1485 : * before it has been run to completion
1486 : */
1487 : static void
1488 0 : ShutdownSQLFunction(Datum arg)
1489 : {
1490 0 : SQLFunctionCachePtr fcache = (SQLFunctionCachePtr) DatumGetPointer(arg);
1491 : execution_state *es;
1492 : ListCell *lc;
1493 :
1494 0 : foreach(lc, fcache->func_state)
1495 : {
1496 0 : es = (execution_state *) lfirst(lc);
1497 0 : while (es)
1498 : {
1499 : /* Shut down anything still running */
1500 0 : if (es->status == F_EXEC_RUN)
1501 : {
1502 : /* Re-establish active snapshot for any called functions */
1503 0 : if (!fcache->readonly_func)
1504 0 : PushActiveSnapshot(es->qd->snapshot);
1505 :
1506 0 : postquel_end(es);
1507 :
1508 0 : if (!fcache->readonly_func)
1509 0 : PopActiveSnapshot();
1510 : }
1511 :
1512 : /* Reset states to START in case we're called again */
1513 0 : es->status = F_EXEC_START;
1514 0 : es = es->next;
1515 : }
1516 : }
1517 :
1518 : /* Release tuplestore if we have one */
1519 0 : if (fcache->tstore)
1520 0 : tuplestore_end(fcache->tstore);
1521 0 : fcache->tstore = NULL;
1522 :
1523 : /* execUtils will deregister the callback... */
1524 0 : fcache->shutdown_reg = false;
1525 0 : }
1526 :
1527 : /*
1528 : * check_sql_fn_statements
1529 : *
1530 : * Check statements in an SQL function. Error out if there is anything that
1531 : * is not acceptable.
1532 : */
1533 : void
1534 46260 : check_sql_fn_statements(List *queryTreeLists)
1535 : {
1536 : ListCell *lc;
1537 :
1538 : /* We are given a list of sublists of Queries */
1539 92770 : foreach(lc, queryTreeLists)
1540 : {
1541 46516 : List *sublist = lfirst_node(List, lc);
1542 : ListCell *lc2;
1543 :
1544 93032 : foreach(lc2, sublist)
1545 : {
1546 46522 : Query *query = lfirst_node(Query, lc2);
1547 :
1548 : /*
1549 : * Disallow calling procedures with output arguments. The current
1550 : * implementation would just throw the output values away, unless
1551 : * the statement is the last one. Per SQL standard, we should
1552 : * assign the output values by name. By disallowing this here, we
1553 : * preserve an opportunity for future improvement.
1554 : */
1555 46522 : if (query->commandType == CMD_UTILITY &&
1556 236 : IsA(query->utilityStmt, CallStmt))
1557 : {
1558 30 : CallStmt *stmt = (CallStmt *) query->utilityStmt;
1559 :
1560 30 : if (stmt->outargs != NIL)
1561 6 : ereport(ERROR,
1562 : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1563 : errmsg("calling procedures with output arguments is not supported in SQL functions")));
1564 : }
1565 : }
1566 : }
1567 46254 : }
1568 :
1569 : /*
1570 : * check_sql_fn_retval()
1571 : * Check return value of a list of lists of sql parse trees.
1572 : *
1573 : * The return value of a sql function is the value returned by the last
1574 : * canSetTag query in the function. We do some ad-hoc type checking and
1575 : * coercion here to ensure that the function returns what it's supposed to.
1576 : * Note that we may actually modify the last query to make it match!
1577 : *
1578 : * This function returns true if the sql function returns the entire tuple
1579 : * result of its final statement, or false if it returns just the first column
1580 : * result of that statement. It throws an error if the final statement doesn't
1581 : * return the right type at all.
1582 : *
1583 : * Note that because we allow "SELECT rowtype_expression", the result can be
1584 : * false even when the declared function return type is a rowtype.
1585 : *
1586 : * For a polymorphic function the passed rettype must be the actual resolved
1587 : * output type of the function. (This means we can't check the type during
1588 : * function definition of a polymorphic function.) If we do see a polymorphic
1589 : * rettype we'll throw an error, saying it is not a supported rettype.
1590 : *
1591 : * If the function returns composite, the passed rettupdesc should describe
1592 : * the expected output. If rettupdesc is NULL, we can't verify that the
1593 : * output matches; that should only happen in fmgr_sql_validator(), or when
1594 : * the function returns RECORD and the caller doesn't actually care which
1595 : * composite type it is.
1596 : *
1597 : * (Typically, rettype and rettupdesc are computed by get_call_result_type
1598 : * or a sibling function.)
1599 : *
1600 : * In addition to coercing individual output columns, we can modify the
1601 : * output to include dummy NULL columns for any dropped columns appearing
1602 : * in rettupdesc. This is done only if the caller asks for it.
1603 : *
1604 : * If resultTargetList isn't NULL, then *resultTargetList is set to the
1605 : * targetlist that defines the final statement's result. Exception: if the
1606 : * function is defined to return VOID then *resultTargetList is set to NIL.
1607 : */
1608 : bool
1609 66042 : check_sql_fn_retval(List *queryTreeLists,
1610 : Oid rettype, TupleDesc rettupdesc,
1611 : char prokind,
1612 : bool insertDroppedCols,
1613 : List **resultTargetList)
1614 : {
1615 66042 : bool is_tuple_result = false;
1616 : Query *parse;
1617 : ListCell *parse_cell;
1618 : List *tlist;
1619 : int tlistlen;
1620 : bool tlist_is_modifiable;
1621 : char fn_typtype;
1622 66042 : List *upper_tlist = NIL;
1623 66042 : bool upper_tlist_nontrivial = false;
1624 : ListCell *lc;
1625 :
1626 66042 : if (resultTargetList)
1627 39622 : *resultTargetList = NIL; /* initialize in case of VOID result */
1628 :
1629 : /*
1630 : * If it's declared to return VOID, we don't care what's in the function.
1631 : * (This takes care of procedures with no output parameters, as well.)
1632 : */
1633 66042 : if (rettype == VOIDOID)
1634 718 : return false;
1635 :
1636 : /*
1637 : * Find the last canSetTag query in the function body (which is presented
1638 : * to us as a list of sublists of Query nodes). This isn't necessarily
1639 : * the last parsetree, because rule rewriting can insert queries after
1640 : * what the user wrote. Note that it might not even be in the last
1641 : * sublist, for example if the last query rewrites to DO INSTEAD NOTHING.
1642 : * (It might not be unreasonable to throw an error in such a case, but
1643 : * this is the historical behavior and it doesn't seem worth changing.)
1644 : */
1645 65324 : parse = NULL;
1646 65324 : parse_cell = NULL;
1647 130874 : foreach(lc, queryTreeLists)
1648 : {
1649 65550 : List *sublist = lfirst_node(List, lc);
1650 : ListCell *lc2;
1651 :
1652 131106 : foreach(lc2, sublist)
1653 : {
1654 65556 : Query *q = lfirst_node(Query, lc2);
1655 :
1656 65556 : if (q->canSetTag)
1657 : {
1658 65550 : parse = q;
1659 65550 : parse_cell = lc2;
1660 : }
1661 : }
1662 : }
1663 :
1664 : /*
1665 : * If it's a plain SELECT, it returns whatever the targetlist says.
1666 : * Otherwise, if it's INSERT/UPDATE/DELETE/MERGE with RETURNING, it
1667 : * returns that. Otherwise, the function return type must be VOID.
1668 : *
1669 : * Note: eventually replace this test with QueryReturnsTuples? We'd need
1670 : * a more general method of determining the output type, though. Also, it
1671 : * seems too dangerous to consider FETCH or EXECUTE as returning a
1672 : * determinable rowtype, since they depend on relatively short-lived
1673 : * entities.
1674 : */
1675 65324 : if (parse &&
1676 65324 : parse->commandType == CMD_SELECT)
1677 : {
1678 65192 : tlist = parse->targetList;
1679 : /* tlist is modifiable unless it's a dummy in a setop query */
1680 65192 : tlist_is_modifiable = (parse->setOperations == NULL);
1681 : }
1682 132 : else if (parse &&
1683 132 : (parse->commandType == CMD_INSERT ||
1684 30 : parse->commandType == CMD_UPDATE ||
1685 30 : parse->commandType == CMD_DELETE ||
1686 30 : parse->commandType == CMD_MERGE) &&
1687 132 : parse->returningList)
1688 : {
1689 132 : tlist = parse->returningList;
1690 : /* returningList can always be modified */
1691 132 : tlist_is_modifiable = true;
1692 : }
1693 : else
1694 : {
1695 : /* Empty function body, or last statement is a utility command */
1696 0 : ereport(ERROR,
1697 : (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
1698 : errmsg("return type mismatch in function declared to return %s",
1699 : format_type_be(rettype)),
1700 : errdetail("Function's final statement must be SELECT or INSERT/UPDATE/DELETE/MERGE RETURNING.")));
1701 : return false; /* keep compiler quiet */
1702 : }
1703 :
1704 : /*
1705 : * OK, check that the targetlist returns something matching the declared
1706 : * type, and modify it if necessary. If possible, we insert any coercion
1707 : * steps right into the final statement's targetlist. However, that might
1708 : * risk changes in the statement's semantics --- we can't safely change
1709 : * the output type of a grouping column, for instance. In such cases we
1710 : * handle coercions by inserting an extra level of Query that effectively
1711 : * just does a projection.
1712 : */
1713 :
1714 : /*
1715 : * Count the non-junk entries in the result targetlist.
1716 : */
1717 65324 : tlistlen = ExecCleanTargetListLength(tlist);
1718 :
1719 65324 : fn_typtype = get_typtype(rettype);
1720 :
1721 65324 : if (fn_typtype == TYPTYPE_BASE ||
1722 2100 : fn_typtype == TYPTYPE_DOMAIN ||
1723 2094 : fn_typtype == TYPTYPE_ENUM ||
1724 2058 : fn_typtype == TYPTYPE_RANGE ||
1725 : fn_typtype == TYPTYPE_MULTIRANGE)
1726 63290 : {
1727 : /*
1728 : * For scalar-type returns, the target list must have exactly one
1729 : * non-junk entry, and its type must be coercible to rettype.
1730 : */
1731 : TargetEntry *tle;
1732 :
1733 63302 : if (tlistlen != 1)
1734 6 : ereport(ERROR,
1735 : (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
1736 : errmsg("return type mismatch in function declared to return %s",
1737 : format_type_be(rettype)),
1738 : errdetail("Final statement must return exactly one column.")));
1739 :
1740 : /* We assume here that non-junk TLEs must come first in tlists */
1741 63296 : tle = (TargetEntry *) linitial(tlist);
1742 : Assert(!tle->resjunk);
1743 :
1744 63296 : if (!coerce_fn_result_column(tle, rettype, -1,
1745 : tlist_is_modifiable,
1746 : &upper_tlist,
1747 : &upper_tlist_nontrivial))
1748 6 : ereport(ERROR,
1749 : (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
1750 : errmsg("return type mismatch in function declared to return %s",
1751 : format_type_be(rettype)),
1752 : errdetail("Actual return type is %s.",
1753 : format_type_be(exprType((Node *) tle->expr)))));
1754 : }
1755 2022 : else if (fn_typtype == TYPTYPE_COMPOSITE || rettype == RECORDOID)
1756 1884 : {
1757 : /*
1758 : * Returns a rowtype.
1759 : *
1760 : * Note that we will not consider a domain over composite to be a
1761 : * "rowtype" return type; it goes through the scalar case above. This
1762 : * is because we only provide column-by-column implicit casting, and
1763 : * will not cast the complete record result. So the only way to
1764 : * produce a domain-over-composite result is to compute it as an
1765 : * explicit single-column result. The single-composite-column code
1766 : * path just below could handle such cases, but it won't be reached.
1767 : */
1768 : int tupnatts; /* physical number of columns in tuple */
1769 : int tuplogcols; /* # of nondeleted columns in tuple */
1770 : int colindex; /* physical column index */
1771 :
1772 : /*
1773 : * If the target list has one non-junk entry, and that expression has
1774 : * or can be coerced to the declared return type, take it as the
1775 : * result. This allows, for example, 'SELECT func2()', where func2
1776 : * has the same composite return type as the function that's calling
1777 : * it. This provision creates some ambiguity --- maybe the expression
1778 : * was meant to be the lone field of the composite result --- but it
1779 : * works well enough as long as we don't get too enthusiastic about
1780 : * inventing coercions from scalar to composite types.
1781 : *
1782 : * XXX Note that if rettype is RECORD and the expression is of a named
1783 : * composite type, or vice versa, this coercion will succeed, whether
1784 : * or not the record type really matches. For the moment we rely on
1785 : * runtime type checking to catch any discrepancy, but it'd be nice to
1786 : * do better at parse time.
1787 : *
1788 : * We must *not* do this for a procedure, however. Procedures with
1789 : * output parameter(s) have rettype RECORD, and the CALL code expects
1790 : * to get results corresponding to the list of output parameters, even
1791 : * when there's just one parameter that's composite.
1792 : */
1793 2016 : if (tlistlen == 1 && prokind != PROKIND_PROCEDURE)
1794 : {
1795 216 : TargetEntry *tle = (TargetEntry *) linitial(tlist);
1796 :
1797 : Assert(!tle->resjunk);
1798 216 : if (coerce_fn_result_column(tle, rettype, -1,
1799 : tlist_is_modifiable,
1800 : &upper_tlist,
1801 : &upper_tlist_nontrivial))
1802 : {
1803 : /* Note that we're NOT setting is_tuple_result */
1804 72 : goto tlist_coercion_finished;
1805 : }
1806 : }
1807 :
1808 : /*
1809 : * If the caller didn't provide an expected tupdesc, we can't do any
1810 : * further checking. Assume we're returning the whole tuple.
1811 : */
1812 1944 : if (rettupdesc == NULL)
1813 : {
1814 : /* Return tlist if requested */
1815 48 : if (resultTargetList)
1816 24 : *resultTargetList = tlist;
1817 48 : return true;
1818 : }
1819 :
1820 : /*
1821 : * Verify that the targetlist matches the return tuple type. We scan
1822 : * the non-resjunk columns, and coerce them if necessary to match the
1823 : * datatypes of the non-deleted attributes. For deleted attributes,
1824 : * insert NULL result columns if the caller asked for that.
1825 : */
1826 1896 : tupnatts = rettupdesc->natts;
1827 1896 : tuplogcols = 0; /* we'll count nondeleted cols as we go */
1828 1896 : colindex = 0;
1829 :
1830 7068 : foreach(lc, tlist)
1831 : {
1832 5184 : TargetEntry *tle = (TargetEntry *) lfirst(lc);
1833 : Form_pg_attribute attr;
1834 :
1835 : /* resjunk columns can simply be ignored */
1836 5184 : if (tle->resjunk)
1837 0 : continue;
1838 :
1839 : do
1840 : {
1841 5268 : colindex++;
1842 5268 : if (colindex > tupnatts)
1843 0 : ereport(ERROR,
1844 : (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
1845 : errmsg("return type mismatch in function declared to return %s",
1846 : format_type_be(rettype)),
1847 : errdetail("Final statement returns too many columns.")));
1848 5268 : attr = TupleDescAttr(rettupdesc, colindex - 1);
1849 5268 : if (attr->attisdropped && insertDroppedCols)
1850 : {
1851 : Expr *null_expr;
1852 :
1853 : /* The type of the null we insert isn't important */
1854 6 : null_expr = (Expr *) makeConst(INT4OID,
1855 : -1,
1856 : InvalidOid,
1857 : sizeof(int32),
1858 : (Datum) 0,
1859 : true, /* isnull */
1860 : true /* byval */ );
1861 6 : upper_tlist = lappend(upper_tlist,
1862 6 : makeTargetEntry(null_expr,
1863 6 : list_length(upper_tlist) + 1,
1864 : NULL,
1865 : false));
1866 6 : upper_tlist_nontrivial = true;
1867 : }
1868 5268 : } while (attr->attisdropped);
1869 5184 : tuplogcols++;
1870 :
1871 5184 : if (!coerce_fn_result_column(tle,
1872 : attr->atttypid, attr->atttypmod,
1873 : tlist_is_modifiable,
1874 : &upper_tlist,
1875 : &upper_tlist_nontrivial))
1876 12 : ereport(ERROR,
1877 : (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
1878 : errmsg("return type mismatch in function declared to return %s",
1879 : format_type_be(rettype)),
1880 : errdetail("Final statement returns %s instead of %s at column %d.",
1881 : format_type_be(exprType((Node *) tle->expr)),
1882 : format_type_be(attr->atttypid),
1883 : tuplogcols)));
1884 : }
1885 :
1886 : /* remaining columns in rettupdesc had better all be dropped */
1887 1884 : for (colindex++; colindex <= tupnatts; colindex++)
1888 : {
1889 0 : if (!TupleDescAttr(rettupdesc, colindex - 1)->attisdropped)
1890 0 : ereport(ERROR,
1891 : (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
1892 : errmsg("return type mismatch in function declared to return %s",
1893 : format_type_be(rettype)),
1894 : errdetail("Final statement returns too few columns.")));
1895 0 : if (insertDroppedCols)
1896 : {
1897 : Expr *null_expr;
1898 :
1899 : /* The type of the null we insert isn't important */
1900 0 : null_expr = (Expr *) makeConst(INT4OID,
1901 : -1,
1902 : InvalidOid,
1903 : sizeof(int32),
1904 : (Datum) 0,
1905 : true, /* isnull */
1906 : true /* byval */ );
1907 0 : upper_tlist = lappend(upper_tlist,
1908 0 : makeTargetEntry(null_expr,
1909 0 : list_length(upper_tlist) + 1,
1910 : NULL,
1911 : false));
1912 0 : upper_tlist_nontrivial = true;
1913 : }
1914 : }
1915 :
1916 : /* Report that we are returning entire tuple result */
1917 1884 : is_tuple_result = true;
1918 : }
1919 : else
1920 6 : ereport(ERROR,
1921 : (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
1922 : errmsg("return type %s is not supported for SQL functions",
1923 : format_type_be(rettype))));
1924 :
1925 65246 : tlist_coercion_finished:
1926 :
1927 : /*
1928 : * If necessary, modify the final Query by injecting an extra Query level
1929 : * that just performs a projection. (It'd be dubious to do this to a
1930 : * non-SELECT query, but we never have to; RETURNING lists can always be
1931 : * modified in-place.)
1932 : */
1933 65246 : if (upper_tlist_nontrivial)
1934 : {
1935 : Query *newquery;
1936 : List *colnames;
1937 : RangeTblEntry *rte;
1938 : RangeTblRef *rtr;
1939 :
1940 : Assert(parse->commandType == CMD_SELECT);
1941 :
1942 : /* Most of the upper Query struct can be left as zeroes/nulls */
1943 84 : newquery = makeNode(Query);
1944 84 : newquery->commandType = CMD_SELECT;
1945 84 : newquery->querySource = parse->querySource;
1946 84 : newquery->canSetTag = true;
1947 84 : newquery->targetList = upper_tlist;
1948 :
1949 : /* We need a moderately realistic colnames list for the subquery RTE */
1950 84 : colnames = NIL;
1951 216 : foreach(lc, parse->targetList)
1952 : {
1953 132 : TargetEntry *tle = (TargetEntry *) lfirst(lc);
1954 :
1955 132 : if (tle->resjunk)
1956 0 : continue;
1957 132 : colnames = lappend(colnames,
1958 132 : makeString(tle->resname ? tle->resname : ""));
1959 : }
1960 :
1961 : /* Build a suitable RTE for the subquery */
1962 84 : rte = makeNode(RangeTblEntry);
1963 84 : rte->rtekind = RTE_SUBQUERY;
1964 84 : rte->subquery = parse;
1965 84 : rte->eref = rte->alias = makeAlias("*SELECT*", colnames);
1966 84 : rte->lateral = false;
1967 84 : rte->inh = false;
1968 84 : rte->inFromCl = true;
1969 84 : newquery->rtable = list_make1(rte);
1970 :
1971 84 : rtr = makeNode(RangeTblRef);
1972 84 : rtr->rtindex = 1;
1973 84 : newquery->jointree = makeFromExpr(list_make1(rtr), NULL);
1974 :
1975 : /*
1976 : * Make sure the new query is marked as having row security if the
1977 : * original one does.
1978 : */
1979 84 : newquery->hasRowSecurity = parse->hasRowSecurity;
1980 :
1981 : /* Replace original query in the correct element of the query list */
1982 84 : lfirst(parse_cell) = newquery;
1983 : }
1984 :
1985 : /* Return tlist (possibly modified) if requested */
1986 65246 : if (resultTargetList)
1987 39304 : *resultTargetList = upper_tlist;
1988 :
1989 65246 : return is_tuple_result;
1990 : }
1991 :
1992 : /*
1993 : * Process one function result column for check_sql_fn_retval
1994 : *
1995 : * Coerce the output value to the required type/typmod, and add a column
1996 : * to *upper_tlist for it. Set *upper_tlist_nontrivial to true if we
1997 : * add an upper tlist item that's not just a Var.
1998 : *
1999 : * Returns true if OK, false if could not coerce to required type
2000 : * (in which case, no changes have been made)
2001 : */
2002 : static bool
2003 68696 : coerce_fn_result_column(TargetEntry *src_tle,
2004 : Oid res_type,
2005 : int32 res_typmod,
2006 : bool tlist_is_modifiable,
2007 : List **upper_tlist,
2008 : bool *upper_tlist_nontrivial)
2009 : {
2010 : TargetEntry *new_tle;
2011 : Expr *new_tle_expr;
2012 : Node *cast_result;
2013 :
2014 : /*
2015 : * If the TLE has a sortgroupref marking, don't change it, as it probably
2016 : * is referenced by ORDER BY, DISTINCT, etc, and changing its type would
2017 : * break query semantics. Otherwise, it's safe to modify in-place unless
2018 : * the query as a whole has issues with that.
2019 : */
2020 68696 : if (tlist_is_modifiable && src_tle->ressortgroupref == 0)
2021 : {
2022 : /* OK to modify src_tle in place, if necessary */
2023 136440 : cast_result = coerce_to_target_type(NULL,
2024 68220 : (Node *) src_tle->expr,
2025 68220 : exprType((Node *) src_tle->expr),
2026 : res_type, res_typmod,
2027 : COERCION_ASSIGNMENT,
2028 : COERCE_IMPLICIT_CAST,
2029 : -1);
2030 68220 : if (cast_result == NULL)
2031 144 : return false;
2032 68076 : assign_expr_collations(NULL, cast_result);
2033 68076 : src_tle->expr = (Expr *) cast_result;
2034 : /* Make a Var referencing the possibly-modified TLE */
2035 68076 : new_tle_expr = (Expr *) makeVarFromTargetEntry(1, src_tle);
2036 : }
2037 : else
2038 : {
2039 : /* Any casting must happen in the upper tlist */
2040 476 : Var *var = makeVarFromTargetEntry(1, src_tle);
2041 :
2042 476 : cast_result = coerce_to_target_type(NULL,
2043 : (Node *) var,
2044 : var->vartype,
2045 : res_type, res_typmod,
2046 : COERCION_ASSIGNMENT,
2047 : COERCE_IMPLICIT_CAST,
2048 : -1);
2049 476 : if (cast_result == NULL)
2050 18 : return false;
2051 458 : assign_expr_collations(NULL, cast_result);
2052 : /* Did the coercion actually do anything? */
2053 458 : if (cast_result != (Node *) var)
2054 102 : *upper_tlist_nontrivial = true;
2055 458 : new_tle_expr = (Expr *) cast_result;
2056 : }
2057 137068 : new_tle = makeTargetEntry(new_tle_expr,
2058 68534 : list_length(*upper_tlist) + 1,
2059 : src_tle->resname, false);
2060 68534 : *upper_tlist = lappend(*upper_tlist, new_tle);
2061 68534 : return true;
2062 : }
2063 :
2064 :
2065 : /*
2066 : * CreateSQLFunctionDestReceiver -- create a suitable DestReceiver object
2067 : */
2068 : DestReceiver *
2069 135218 : CreateSQLFunctionDestReceiver(void)
2070 : {
2071 135218 : DR_sqlfunction *self = (DR_sqlfunction *) palloc0(sizeof(DR_sqlfunction));
2072 :
2073 135218 : self->pub.receiveSlot = sqlfunction_receive;
2074 135218 : self->pub.rStartup = sqlfunction_startup;
2075 135218 : self->pub.rShutdown = sqlfunction_shutdown;
2076 135218 : self->pub.rDestroy = sqlfunction_destroy;
2077 135218 : self->pub.mydest = DestSQLFunction;
2078 :
2079 : /* private fields will be set by postquel_start */
2080 :
2081 135218 : return (DestReceiver *) self;
2082 : }
2083 :
2084 : /*
2085 : * sqlfunction_startup --- executor startup
2086 : */
2087 : static void
2088 136182 : sqlfunction_startup(DestReceiver *self, int operation, TupleDesc typeinfo)
2089 : {
2090 : /* no-op */
2091 136182 : }
2092 :
2093 : /*
2094 : * sqlfunction_receive --- receive one tuple
2095 : */
2096 : static bool
2097 241936 : sqlfunction_receive(TupleTableSlot *slot, DestReceiver *self)
2098 : {
2099 241936 : DR_sqlfunction *myState = (DR_sqlfunction *) self;
2100 :
2101 : /* Filter tuple as needed */
2102 241936 : slot = ExecFilterJunk(myState->filter, slot);
2103 :
2104 : /* Store the filtered tuple into the tuplestore */
2105 241936 : tuplestore_puttupleslot(myState->tstore, slot);
2106 :
2107 241936 : return true;
2108 : }
2109 :
2110 : /*
2111 : * sqlfunction_shutdown --- executor end
2112 : */
2113 : static void
2114 127876 : sqlfunction_shutdown(DestReceiver *self)
2115 : {
2116 : /* no-op */
2117 127876 : }
2118 :
2119 : /*
2120 : * sqlfunction_destroy --- release DestReceiver object
2121 : */
2122 : static void
2123 126912 : sqlfunction_destroy(DestReceiver *self)
2124 : {
2125 126912 : pfree(self);
2126 126912 : }
|
