LCOV - code coverage report
Current view: top level - src/backend/executor - functions.c (source / functions) Hit Total Coverage
Test: PostgreSQL 18devel Lines: 541 595 90.9 %
Date: 2024-10-10 03:14:42 Functions: 23 24 95.8 %
Legend: Lines: hit not hit

          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       54910 : prepare_sql_fn_parse_info(HeapTuple procedureTuple,
     177             :                           Node *call_expr,
     178             :                           Oid inputCollation)
     179             : {
     180             :     SQLFunctionParseInfoPtr pinfo;
     181       54910 :     Form_pg_proc procedureStruct = (Form_pg_proc) GETSTRUCT(procedureTuple);
     182             :     int         nargs;
     183             : 
     184       54910 :     pinfo = (SQLFunctionParseInfoPtr) palloc0(sizeof(SQLFunctionParseInfo));
     185             : 
     186             :     /* Function's name (only) can be used to qualify argument names */
     187       54910 :     pinfo->fname = pstrdup(NameStr(procedureStruct->proname));
     188             : 
     189             :     /* Save the function's input collation */
     190       54910 :     pinfo->collation = inputCollation;
     191             : 
     192             :     /*
     193             :      * Copy input argument types from the pg_proc entry, then resolve any
     194             :      * polymorphic types.
     195             :      */
     196       54910 :     pinfo->nargs = nargs = procedureStruct->pronargs;
     197       54910 :     if (nargs > 0)
     198             :     {
     199             :         Oid        *argOidVect;
     200             :         int         argnum;
     201             : 
     202       35094 :         argOidVect = (Oid *) palloc(nargs * sizeof(Oid));
     203       35094 :         memcpy(argOidVect,
     204       35094 :                procedureStruct->proargtypes.values,
     205             :                nargs * sizeof(Oid));
     206             : 
     207      102718 :         for (argnum = 0; argnum < nargs; argnum++)
     208             :         {
     209       67624 :             Oid         argtype = argOidVect[argnum];
     210             : 
     211       67624 :             if (IsPolymorphicType(argtype))
     212             :             {
     213        2950 :                 argtype = get_call_expr_argtype(call_expr, argnum);
     214        2950 :                 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        2950 :                 argOidVect[argnum] = argtype;
     220             :             }
     221             :         }
     222             : 
     223       35094 :         pinfo->argtypes = argOidVect;
     224             :     }
     225             : 
     226             :     /*
     227             :      * Collect names of arguments, too, if any
     228             :      */
     229       54910 :     if (nargs > 0)
     230             :     {
     231             :         Datum       proargnames;
     232             :         Datum       proargmodes;
     233             :         int         n_arg_names;
     234             :         bool        isNull;
     235             : 
     236       35094 :         proargnames = SysCacheGetAttr(PROCNAMEARGSNSP, procedureTuple,
     237             :                                       Anum_pg_proc_proargnames,
     238             :                                       &isNull);
     239       35094 :         if (isNull)
     240       28216 :             proargnames = PointerGetDatum(NULL);    /* just to be sure */
     241             : 
     242       35094 :         proargmodes = SysCacheGetAttr(PROCNAMEARGSNSP, procedureTuple,
     243             :                                       Anum_pg_proc_proargmodes,
     244             :                                       &isNull);
     245       35094 :         if (isNull)
     246       34198 :             proargmodes = PointerGetDatum(NULL);    /* just to be sure */
     247             : 
     248       35094 :         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       35094 :         if (n_arg_names < nargs)
     253       28216 :             pinfo->argnames = NULL;
     254             :     }
     255             :     else
     256       19816 :         pinfo->argnames = NULL;
     257             : 
     258       54910 :     return pinfo;
     259             : }
     260             : 
     261             : /*
     262             :  * Parser setup hook for parsing a SQL function body.
     263             :  */
     264             : void
     265       57450 : sql_fn_parser_setup(struct ParseState *pstate, SQLFunctionParseInfoPtr pinfo)
     266             : {
     267       57450 :     pstate->p_pre_columnref_hook = NULL;
     268       57450 :     pstate->p_post_columnref_hook = sql_fn_post_column_ref;
     269       57450 :     pstate->p_paramref_hook = sql_fn_param_ref;
     270             :     /* no need to use p_coerce_param_hook */
     271       57450 :     pstate->p_ref_hook_state = (void *) pinfo;
     272       57450 : }
     273             : 
     274             : /*
     275             :  * sql_fn_post_column_ref       parser callback for ColumnRefs
     276             :  */
     277             : static Node *
     278        9948 : sql_fn_post_column_ref(ParseState *pstate, ColumnRef *cref, Node *var)
     279             : {
     280        9948 :     SQLFunctionParseInfoPtr pinfo = (SQLFunctionParseInfoPtr) pstate->p_ref_hook_state;
     281             :     int         nnames;
     282             :     Node       *field1;
     283        9948 :     Node       *subfield = NULL;
     284             :     const char *name1;
     285        9948 :     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        9948 :     if (var != NULL)
     294        7226 :         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      120138 : sql_fn_param_ref(ParseState *pstate, ParamRef *pref)
     395             : {
     396      120138 :     SQLFunctionParseInfoPtr pinfo = (SQLFunctionParseInfoPtr) pstate->p_ref_hook_state;
     397      120138 :     int         paramno = pref->number;
     398             : 
     399             :     /* Check parameter number is valid */
     400      120138 :     if (paramno <= 0 || paramno > pinfo->nargs)
     401           6 :         return NULL;            /* unknown parameter number */
     402             : 
     403      120132 :     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      122854 : sql_fn_make_param(SQLFunctionParseInfoPtr pinfo,
     411             :                   int paramno, int location)
     412             : {
     413             :     Param      *param;
     414             : 
     415      122854 :     param = makeNode(Param);
     416      122854 :     param->paramkind = PARAM_EXTERN;
     417      122854 :     param->paramid = paramno;
     418      122854 :     param->paramtype = pinfo->argtypes[paramno - 1];
     419      122854 :     param->paramtypmod = -1;
     420      122854 :     param->paramcollid = get_typcollation(param->paramtype);
     421      122854 :     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      122854 :     if (OidIsValid(pinfo->collation) && OidIsValid(param->paramcollid))
     429        2906 :         param->paramcollid = pinfo->collation;
     430             : 
     431      122854 :     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       33836 : init_execution_state(List *queryTree_list,
     465             :                      SQLFunctionCachePtr fcache,
     466             :                      bool lazyEvalOK)
     467             : {
     468       33836 :     List       *eslist = NIL;
     469       33836 :     execution_state *lasttages = NULL;
     470             :     ListCell   *lc1;
     471             : 
     472       67796 :     foreach(lc1, queryTree_list)
     473             :     {
     474       33966 :         List       *qtlist = lfirst_node(List, lc1);
     475       33966 :         execution_state *firstes = NULL;
     476       33966 :         execution_state *preves = NULL;
     477             :         ListCell   *lc2;
     478             : 
     479       67932 :         foreach(lc2, qtlist)
     480             :         {
     481       33972 :             Query      *queryTree = lfirst_node(Query, lc2);
     482             :             PlannedStmt *stmt;
     483             :             execution_state *newes;
     484             : 
     485             :             /* Plan the query if needed */
     486       33972 :             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       33804 :                 stmt = pg_plan_query(queryTree,
     499       33804 :                                      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       33966 :             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       33966 :             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       33966 :             newes = (execution_state *) palloc(sizeof(execution_state));
     532       33966 :             if (preves)
     533           6 :                 preves->next = newes;
     534             :             else
     535       33960 :                 firstes = newes;
     536             : 
     537       33966 :             newes->next = NULL;
     538       33966 :             newes->status = F_EXEC_START;
     539       33966 :             newes->setsResult = false;   /* might change below */
     540       33966 :             newes->lazyEval = false; /* might change below */
     541       33966 :             newes->stmt = stmt;
     542       33966 :             newes->qd = NULL;
     543             : 
     544       33966 :             if (queryTree->canSetTag)
     545       33960 :                 lasttages = newes;
     546             : 
     547       33966 :             preves = newes;
     548             :         }
     549             : 
     550       33960 :         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       33830 :     if (lasttages && fcache->junkFilter)
     568             :     {
     569       33542 :         lasttages->setsResult = true;
     570       33542 :         if (lazyEvalOK &&
     571       32894 :             lasttages->stmt->commandType == CMD_SELECT &&
     572       32828 :             !lasttages->stmt->hasModifyingCTE)
     573       32828 :             fcache->lazyEval = lasttages->lazyEval = true;
     574             :     }
     575             : 
     576       33830 :     return eslist;
     577             : }
     578             : 
     579             : /*
     580             :  * Initialize the SQLFunctionCache for a SQL function
     581             :  */
     582             : static void
     583       33844 : init_sql_fcache(FunctionCallInfo fcinfo, Oid collation, bool lazyEvalOK)
     584             : {
     585       33844 :     FmgrInfo   *finfo = fcinfo->flinfo;
     586       33844 :     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       33844 :     fcontext = AllocSetContextCreate(finfo->fn_mcxt,
     605             :                                      "SQL function",
     606             :                                      ALLOCSET_DEFAULT_SIZES);
     607             : 
     608       33844 :     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       33844 :     fcache = (SQLFunctionCachePtr) palloc0(sizeof(SQLFunctionCache));
     616       33844 :     fcache->fcontext = fcontext;
     617       33844 :     finfo->fn_extra = (void *) fcache;
     618             : 
     619             :     /*
     620             :      * get the procedure tuple corresponding to the given function Oid
     621             :      */
     622       33844 :     procedureTuple = SearchSysCache1(PROCOID, ObjectIdGetDatum(foid));
     623       33844 :     if (!HeapTupleIsValid(procedureTuple))
     624           0 :         elog(ERROR, "cache lookup failed for function %u", foid);
     625       33844 :     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       33844 :     fcache->fname = pstrdup(NameStr(procedureStruct->proname));
     632       33844 :     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       33844 :     (void) get_call_result_type(fcinfo, &rettype, &rettupdesc);
     639             : 
     640       33844 :     fcache->rettype = rettype;
     641             : 
     642             :     /* Fetch the typlen and byval info for the result type */
     643       33844 :     get_typlenbyval(rettype, &fcache->typlen, &fcache->typbyval);
     644             : 
     645             :     /* Remember whether we're returning setof something */
     646       33844 :     fcache->returnsSet = procedureStruct->proretset;
     647             : 
     648             :     /* Remember if function is STABLE/IMMUTABLE */
     649       33844 :     fcache->readonly_func =
     650       33844 :         (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       67688 :     fcache->pinfo = prepare_sql_fn_parse_info(procedureTuple,
     658       33844 :                                               finfo->fn_expr,
     659             :                                               collation);
     660             : 
     661             :     /*
     662             :      * And of course we need the function body text.
     663             :      */
     664       33844 :     tmp = SysCacheGetAttrNotNull(PROCOID, procedureTuple, Anum_pg_proc_prosrc);
     665       33844 :     fcache->src = TextDatumGetCString(tmp);
     666             : 
     667             :     /* If we have prosqlbody, pay attention to that not prosrc. */
     668       33844 :     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       33844 :     queryTree_list = NIL;
     683       33844 :     if (!isNull)
     684             :     {
     685             :         Node       *n;
     686             :         List       *stored_query_list;
     687             : 
     688        2182 :         n = stringToNode(TextDatumGetCString(tmp));
     689        2182 :         if (IsA(n, List))
     690        1734 :             stored_query_list = linitial_node(List, castNode(List, n));
     691             :         else
     692         448 :             stored_query_list = list_make1(n);
     693             : 
     694        4364 :         foreach(lc, stored_query_list)
     695             :         {
     696        2182 :             Query      *parsetree = lfirst_node(Query, lc);
     697             :             List       *queryTree_sublist;
     698             : 
     699        2182 :             AcquireRewriteLocks(parsetree, true, false);
     700        2182 :             queryTree_sublist = pg_rewrite_query(parsetree);
     701        2182 :             queryTree_list = lappend(queryTree_list, queryTree_sublist);
     702             :         }
     703             :     }
     704             :     else
     705             :     {
     706             :         List       *raw_parsetree_list;
     707             : 
     708       31662 :         raw_parsetree_list = pg_parse_query(fcache->src);
     709             : 
     710       63452 :         foreach(lc, raw_parsetree_list)
     711             :         {
     712       31792 :             RawStmt    *parsetree = lfirst_node(RawStmt, lc);
     713             :             List       *queryTree_sublist;
     714             : 
     715       31792 :             queryTree_sublist = pg_analyze_and_rewrite_withcb(parsetree,
     716       31792 :                                                               fcache->src,
     717             :                                                               (ParserSetupHook) sql_fn_parser_setup,
     718       31792 :                                                               fcache->pinfo,
     719             :                                                               NULL);
     720       31790 :             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       33842 :     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       67678 :     fcache->returnsTuple = check_sql_fn_retval(queryTree_list,
     748             :                                                rettype,
     749             :                                                rettupdesc,
     750       33842 :                                                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       33836 :     if (rettype != VOIDOID)
     762             :     {
     763       33548 :         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       33548 :         if (rettupdesc && fcache->returnsTuple)
     775        1272 :             fcache->junkFilter = ExecInitJunkFilterConversion(resulttlist,
     776             :                                                               rettupdesc,
     777             :                                                               slot);
     778             :         else
     779       32276 :             fcache->junkFilter = ExecInitJunkFilter(resulttlist, slot);
     780             :     }
     781             : 
     782       33836 :     if (fcache->returnsTuple)
     783             :     {
     784             :         /* Make sure output rowtype is properly blessed */
     785        1296 :         BlessTupleDesc(fcache->junkFilter->jf_resultSlot->tts_tupleDescriptor);
     786             :     }
     787       32540 :     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       33836 :     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       33830 :     fcache->lxid = MyProc->vxid.lxid;
     805       33830 :     fcache->subxid = GetCurrentSubTransactionId();
     806             : 
     807       33830 :     ReleaseSysCache(procedureTuple);
     808             : 
     809       33830 :     MemoryContextSwitchTo(oldcontext);
     810       33830 : }
     811             : 
     812             : /* Start up execution of one execution_state node */
     813             : static void
     814      165054 : 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      165054 :     if (es->setsResult)
     828             :     {
     829             :         DR_sqlfunction *myState;
     830             : 
     831      124640 :         dest = CreateDestReceiver(DestSQLFunction);
     832             :         /* pass down the needed info to the dest receiver routines */
     833      124640 :         myState = (DR_sqlfunction *) dest;
     834             :         Assert(myState->pub.mydest == DestSQLFunction);
     835      124640 :         myState->tstore = fcache->tstore;
     836      124640 :         myState->cxt = CurrentMemoryContext;
     837      124640 :         myState->filter = fcache->junkFilter;
     838             :     }
     839             :     else
     840       40414 :         dest = None_Receiver;
     841             : 
     842      165054 :     es->qd = CreateQueryDesc(es->stmt,
     843      165054 :                              fcache->src,
     844             :                              GetActiveSnapshot(),
     845             :                              InvalidSnapshot,
     846             :                              dest,
     847             :                              fcache->paramLI,
     848      165054 :                              es->qd ? es->qd->queryEnv : NULL,
     849             :                              0);
     850             : 
     851             :     /* Utility commands don't need Executor. */
     852      165054 :     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      164886 :         if (es->lazyEval)
     864      123728 :             eflags = EXEC_FLAG_SKIP_TRIGGERS;
     865             :         else
     866       41158 :             eflags = 0;         /* default run-to-completion flags */
     867      164886 :         ExecutorStart(es->qd, eflags);
     868             :     }
     869             : 
     870      165054 :     es->status = F_EXEC_RUN;
     871      165054 : }
     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      166018 : postquel_getnext(execution_state *es, SQLFunctionCachePtr fcache)
     877             : {
     878             :     bool        result;
     879             : 
     880      166018 :     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      165850 :         uint64      count = (es->lazyEval) ? 1 : 0;
     896             : 
     897      165850 :         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      157542 :         result = (count == 0 || es->qd->estate->es_processed == 0);
     904             :     }
     905             : 
     906      157620 :     return result;
     907             : }
     908             : 
     909             : /* Shut down execution of one execution_state node */
     910             : static void
     911      156656 : postquel_end(execution_state *es)
     912             : {
     913             :     /* mark status done to ensure we don't do ExecutorEnd twice */
     914      156656 :     es->status = F_EXEC_DONE;
     915             : 
     916             :     /* Utility commands don't need Executor. */
     917      156656 :     if (es->qd->operation != CMD_UTILITY)
     918             :     {
     919      156578 :         ExecutorFinish(es->qd);
     920      156560 :         ExecutorEnd(es->qd);
     921             :     }
     922             : 
     923      156638 :     es->qd->dest->rDestroy(es->qd->dest);
     924             : 
     925      156638 :     FreeQueryDesc(es->qd);
     926      156638 :     es->qd = NULL;
     927      156638 : }
     928             : 
     929             : /* Build ParamListInfo array representing current arguments */
     930             : static void
     931      124952 : postquel_sub_params(SQLFunctionCachePtr fcache,
     932             :                     FunctionCallInfo fcinfo)
     933             : {
     934      124952 :     int         nargs = fcinfo->nargs;
     935             : 
     936      124952 :     if (nargs > 0)
     937             :     {
     938             :         ParamListInfo paramLI;
     939      114094 :         Oid        *argtypes = fcache->pinfo->argtypes;
     940             : 
     941      114094 :         if (fcache->paramLI == NULL)
     942             :         {
     943       23002 :             paramLI = makeParamList(nargs);
     944       23002 :             fcache->paramLI = paramLI;
     945             :         }
     946             :         else
     947             :         {
     948       91092 :             paramLI = fcache->paramLI;
     949             :             Assert(paramLI->numParams == nargs);
     950             :         }
     951             : 
     952      338276 :         for (int i = 0; i < nargs; i++)
     953             :         {
     954      224182 :             ParamExternData *prm = &paramLI->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      224182 :             prm->isnull = fcinfo->args[i].isnull;
     969      224182 :             prm->value = MakeExpandedObjectReadOnly(fcinfo->args[i].value,
     970             :                                                     prm->isnull,
     971             :                                                     get_typlen(argtypes[i]));
     972      224182 :             prm->pflags = 0;
     973      224182 :             prm->ptype = argtypes[i];
     974             :         }
     975             :     }
     976             :     else
     977       10858 :         fcache->paramLI = NULL;
     978      124952 : }
     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      109716 : 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      109716 :     oldcontext = MemoryContextSwitchTo(resultcontext);
    1001             : 
    1002      109716 :     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      108246 :         value = slot_getattr(slot, 1, &(fcinfo->isnull));
    1015             : 
    1016      108246 :         if (!fcinfo->isnull)
    1017      107890 :             value = datumCopy(value, fcache->typbyval, fcache->typlen);
    1018             :     }
    1019             : 
    1020      109716 :     MemoryContextSwitchTo(oldcontext);
    1021             : 
    1022      109716 :     return value;
    1023             : }
    1024             : 
    1025             : /*
    1026             :  * fmgr_sql: function call manager for SQL functions
    1027             :  */
    1028             : Datum
    1029      125936 : 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      125936 :     sqlerrcontext.callback = sql_exec_error_callback;
    1048      125936 :     sqlerrcontext.arg = fcinfo->flinfo;
    1049      125936 :     sqlerrcontext.previous = error_context_stack;
    1050      125936 :     error_context_stack = &sqlerrcontext;
    1051             : 
    1052             :     /* Check call context */
    1053      125936 :     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      120926 :         randomAccess = false;
    1075      120926 :         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      125936 :     fcache = (SQLFunctionCachePtr) fcinfo->flinfo->fn_extra;
    1083             : 
    1084      125936 :     if (fcache != NULL)
    1085             :     {
    1086       92134 :         if (fcache->lxid != MyProc->vxid.lxid ||
    1087       92092 :             !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      125936 :     if (fcache == NULL)
    1097             :     {
    1098       33844 :         init_sql_fcache(fcinfo, PG_GET_COLLATION(), lazyEvalOK);
    1099       33830 :         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      125922 :     oldcontext = MemoryContextSwitchTo(fcache->fcontext);
    1110             : 
    1111             :     /*
    1112             :      * Find first unfinished query in function, and note whether it's the
    1113             :      * first query.
    1114             :      */
    1115      125922 :     eslist = fcache->func_state;
    1116      125922 :     es = NULL;
    1117      125922 :     is_first = true;
    1118      125922 :     foreach(eslc, eslist)
    1119             :     {
    1120      125916 :         es = (execution_state *) lfirst(eslc);
    1121             : 
    1122      125916 :         while (es && es->status == F_EXEC_DONE)
    1123             :         {
    1124           0 :             is_first = false;
    1125           0 :             es = es->next;
    1126             :         }
    1127             : 
    1128      125916 :         if (es)
    1129      125916 :             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      125922 :     if (is_first && es && es->status == F_EXEC_START)
    1137      124952 :         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      125922 :     if (!fcache->tstore)
    1144       34016 :         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      125922 :     pushed_snapshot = false;
    1165      282560 :     while (es)
    1166             :     {
    1167             :         bool        completed;
    1168             : 
    1169      166018 :         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      165054 :             if (!fcache->readonly_func)
    1178             :             {
    1179      153818 :                 CommandCounterIncrement();
    1180      153818 :                 if (!pushed_snapshot)
    1181             :                 {
    1182      153812 :                     PushActiveSnapshot(GetTransactionSnapshot());
    1183      153812 :                     pushed_snapshot = true;
    1184             :                 }
    1185             :                 else
    1186           6 :                     UpdateActiveSnapshotCommandId();
    1187             :             }
    1188             : 
    1189      165054 :             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      166018 :         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      157620 :         if (completed || !fcache->returnsSet)
    1209      156656 :             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      157602 :         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      156638 :         es = es->next;
    1227      196734 :         while (!es)
    1228             :         {
    1229      156632 :             eslc = lnext(eslist, eslc);
    1230      156632 :             if (!eslc)
    1231      116536 :                 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      117506 :     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      112502 :         if (fcache->junkFilter)
    1349             :         {
    1350             :             /* Re-use the junkfilter's output slot to fetch back the tuple */
    1351      112300 :             slot = fcache->junkFilter->jf_resultSlot;
    1352      112300 :             if (tuplestore_gettupleslot(fcache->tstore, true, false, slot))
    1353      108752 :                 result = postquel_get_single_result(slot, fcinfo,
    1354             :                                                     fcache, oldcontext);
    1355             :             else
    1356             :             {
    1357        3548 :                 fcinfo->isnull = true;
    1358        3548 :                 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      112502 :         tuplestore_clear(fcache->tstore);
    1371             :     }
    1372             : 
    1373             :     /* Pop snapshot if we have pushed one */
    1374      117506 :     if (pushed_snapshot)
    1375      105972 :         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      117506 :     if (es == NULL)
    1382             :     {
    1383      273174 :         foreach(eslc, fcache->func_state)
    1384             :         {
    1385      156632 :             es = (execution_state *) lfirst(eslc);
    1386      313270 :             while (es)
    1387             :             {
    1388      156638 :                 es->status = F_EXEC_START;
    1389      156638 :                 es = es->next;
    1390             :             }
    1391             :         }
    1392             :     }
    1393             : 
    1394      117506 :     error_context_stack = sqlerrcontext.previous;
    1395             : 
    1396      117506 :     MemoryContextSwitchTo(oldcontext);
    1397             : 
    1398      117506 :     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       40000 : check_sql_fn_statements(List *queryTreeLists)
    1535             : {
    1536             :     ListCell   *lc;
    1537             : 
    1538             :     /* We are given a list of sublists of Queries */
    1539       80250 :     foreach(lc, queryTreeLists)
    1540             :     {
    1541       40256 :         List       *sublist = lfirst_node(List, lc);
    1542             :         ListCell   *lc2;
    1543             : 
    1544       80512 :         foreach(lc2, sublist)
    1545             :         {
    1546       40262 :             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       40262 :             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       39994 : }
    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       59718 : check_sql_fn_retval(List *queryTreeLists,
    1610             :                     Oid rettype, TupleDesc rettupdesc,
    1611             :                     char prokind,
    1612             :                     bool insertDroppedCols,
    1613             :                     List **resultTargetList)
    1614             : {
    1615       59718 :     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       59718 :     List       *upper_tlist = NIL;
    1623       59718 :     bool        upper_tlist_nontrivial = false;
    1624             :     ListCell   *lc;
    1625             : 
    1626       59718 :     if (resultTargetList)
    1627       33842 :         *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       59718 :     if (rettype == VOIDOID)
    1634         702 :         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       59016 :     parse = NULL;
    1646       59016 :     parse_cell = NULL;
    1647      118258 :     foreach(lc, queryTreeLists)
    1648             :     {
    1649       59242 :         List       *sublist = lfirst_node(List, lc);
    1650             :         ListCell   *lc2;
    1651             : 
    1652      118490 :         foreach(lc2, sublist)
    1653             :         {
    1654       59248 :             Query      *q = lfirst_node(Query, lc2);
    1655             : 
    1656       59248 :             if (q->canSetTag)
    1657             :             {
    1658       59242 :                 parse = q;
    1659       59242 :                 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       59016 :     if (parse &&
    1676       59016 :         parse->commandType == CMD_SELECT)
    1677             :     {
    1678       58884 :         tlist = parse->targetList;
    1679             :         /* tlist is modifiable unless it's a dummy in a setop query */
    1680       58884 :         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       59016 :     tlistlen = ExecCleanTargetListLength(tlist);
    1718             : 
    1719       59016 :     fn_typtype = get_typtype(rettype);
    1720             : 
    1721       59016 :     if (fn_typtype == TYPTYPE_BASE ||
    1722        1994 :         fn_typtype == TYPTYPE_DOMAIN ||
    1723        1988 :         fn_typtype == TYPTYPE_ENUM ||
    1724        1952 :         fn_typtype == TYPTYPE_RANGE ||
    1725             :         fn_typtype == TYPTYPE_MULTIRANGE)
    1726       57088 :     {
    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       57100 :         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       57094 :         tle = (TargetEntry *) linitial(tlist);
    1742             :         Assert(!tle->resjunk);
    1743             : 
    1744       57094 :         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        1916 :     else if (fn_typtype == TYPTYPE_COMPOSITE || rettype == RECORDOID)
    1756        1778 :     {
    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        1910 :         if (tlistlen == 1 && prokind != PROKIND_PROCEDURE)
    1794             :         {
    1795         126 :             TargetEntry *tle = (TargetEntry *) linitial(tlist);
    1796             : 
    1797             :             Assert(!tle->resjunk);
    1798         126 :             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        1838 :         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        1790 :         tupnatts = rettupdesc->natts;
    1827        1790 :         tuplogcols = 0;         /* we'll count nondeleted cols as we go */
    1828        1790 :         colindex = 0;
    1829             : 
    1830        6776 :         foreach(lc, tlist)
    1831             :         {
    1832        4998 :             TargetEntry *tle = (TargetEntry *) lfirst(lc);
    1833             :             Form_pg_attribute attr;
    1834             : 
    1835             :             /* resjunk columns can simply be ignored */
    1836        4998 :             if (tle->resjunk)
    1837           0 :                 continue;
    1838             : 
    1839             :             do
    1840             :             {
    1841        5082 :                 colindex++;
    1842        5082 :                 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        5082 :                 attr = TupleDescAttr(rettupdesc, colindex - 1);
    1849        5082 :                 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        5082 :             } while (attr->attisdropped);
    1869        4998 :             tuplogcols++;
    1870             : 
    1871        4998 :             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        1778 :         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        1778 :         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       58938 : 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       58938 :     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          66 :         newquery = makeNode(Query);
    1944          66 :         newquery->commandType = CMD_SELECT;
    1945          66 :         newquery->querySource = parse->querySource;
    1946          66 :         newquery->canSetTag = true;
    1947          66 :         newquery->targetList = upper_tlist;
    1948             : 
    1949             :         /* We need a moderately realistic colnames list for the subquery RTE */
    1950          66 :         colnames = NIL;
    1951         180 :         foreach(lc, parse->targetList)
    1952             :         {
    1953         114 :             TargetEntry *tle = (TargetEntry *) lfirst(lc);
    1954             : 
    1955         114 :             if (tle->resjunk)
    1956           0 :                 continue;
    1957         114 :             colnames = lappend(colnames,
    1958         114 :                                makeString(tle->resname ? tle->resname : ""));
    1959             :         }
    1960             : 
    1961             :         /* Build a suitable RTE for the subquery */
    1962          66 :         rte = makeNode(RangeTblEntry);
    1963          66 :         rte->rtekind = RTE_SUBQUERY;
    1964          66 :         rte->subquery = parse;
    1965          66 :         rte->eref = rte->alias = makeAlias("*SELECT*", colnames);
    1966          66 :         rte->lateral = false;
    1967          66 :         rte->inh = false;
    1968          66 :         rte->inFromCl = true;
    1969          66 :         newquery->rtable = list_make1(rte);
    1970             : 
    1971          66 :         rtr = makeNode(RangeTblRef);
    1972          66 :         rtr->rtindex = 1;
    1973          66 :         newquery->jointree = makeFromExpr(list_make1(rtr), NULL);
    1974             : 
    1975             :         /* Replace original query in the correct element of the query list */
    1976          66 :         lfirst(parse_cell) = newquery;
    1977             :     }
    1978             : 
    1979             :     /* Return tlist (possibly modified) if requested */
    1980       58938 :     if (resultTargetList)
    1981       33524 :         *resultTargetList = upper_tlist;
    1982             : 
    1983       58938 :     return is_tuple_result;
    1984             : }
    1985             : 
    1986             : /*
    1987             :  * Process one function result column for check_sql_fn_retval
    1988             :  *
    1989             :  * Coerce the output value to the required type/typmod, and add a column
    1990             :  * to *upper_tlist for it.  Set *upper_tlist_nontrivial to true if we
    1991             :  * add an upper tlist item that's not just a Var.
    1992             :  *
    1993             :  * Returns true if OK, false if could not coerce to required type
    1994             :  * (in which case, no changes have been made)
    1995             :  */
    1996             : static bool
    1997       62218 : coerce_fn_result_column(TargetEntry *src_tle,
    1998             :                         Oid res_type,
    1999             :                         int32 res_typmod,
    2000             :                         bool tlist_is_modifiable,
    2001             :                         List **upper_tlist,
    2002             :                         bool *upper_tlist_nontrivial)
    2003             : {
    2004             :     TargetEntry *new_tle;
    2005             :     Expr       *new_tle_expr;
    2006             :     Node       *cast_result;
    2007             : 
    2008             :     /*
    2009             :      * If the TLE has a sortgroupref marking, don't change it, as it probably
    2010             :      * is referenced by ORDER BY, DISTINCT, etc, and changing its type would
    2011             :      * break query semantics.  Otherwise, it's safe to modify in-place unless
    2012             :      * the query as a whole has issues with that.
    2013             :      */
    2014       62218 :     if (tlist_is_modifiable && src_tle->ressortgroupref == 0)
    2015             :     {
    2016             :         /* OK to modify src_tle in place, if necessary */
    2017      123556 :         cast_result = coerce_to_target_type(NULL,
    2018       61778 :                                             (Node *) src_tle->expr,
    2019       61778 :                                             exprType((Node *) src_tle->expr),
    2020             :                                             res_type, res_typmod,
    2021             :                                             COERCION_ASSIGNMENT,
    2022             :                                             COERCE_IMPLICIT_CAST,
    2023             :                                             -1);
    2024       61778 :         if (cast_result == NULL)
    2025          72 :             return false;
    2026       61706 :         assign_expr_collations(NULL, cast_result);
    2027       61706 :         src_tle->expr = (Expr *) cast_result;
    2028             :         /* Make a Var referencing the possibly-modified TLE */
    2029       61706 :         new_tle_expr = (Expr *) makeVarFromTargetEntry(1, src_tle);
    2030             :     }
    2031             :     else
    2032             :     {
    2033             :         /* Any casting must happen in the upper tlist */
    2034         440 :         Var        *var = makeVarFromTargetEntry(1, src_tle);
    2035             : 
    2036         440 :         cast_result = coerce_to_target_type(NULL,
    2037             :                                             (Node *) var,
    2038             :                                             var->vartype,
    2039             :                                             res_type, res_typmod,
    2040             :                                             COERCION_ASSIGNMENT,
    2041             :                                             COERCE_IMPLICIT_CAST,
    2042             :                                             -1);
    2043         440 :         if (cast_result == NULL)
    2044           0 :             return false;
    2045         440 :         assign_expr_collations(NULL, cast_result);
    2046             :         /* Did the coercion actually do anything? */
    2047         440 :         if (cast_result != (Node *) var)
    2048          84 :             *upper_tlist_nontrivial = true;
    2049         440 :         new_tle_expr = (Expr *) cast_result;
    2050             :     }
    2051      124292 :     new_tle = makeTargetEntry(new_tle_expr,
    2052       62146 :                               list_length(*upper_tlist) + 1,
    2053             :                               src_tle->resname, false);
    2054       62146 :     *upper_tlist = lappend(*upper_tlist, new_tle);
    2055       62146 :     return true;
    2056             : }
    2057             : 
    2058             : 
    2059             : /*
    2060             :  * CreateSQLFunctionDestReceiver -- create a suitable DestReceiver object
    2061             :  */
    2062             : DestReceiver *
    2063      124640 : CreateSQLFunctionDestReceiver(void)
    2064             : {
    2065      124640 :     DR_sqlfunction *self = (DR_sqlfunction *) palloc0(sizeof(DR_sqlfunction));
    2066             : 
    2067      124640 :     self->pub.receiveSlot = sqlfunction_receive;
    2068      124640 :     self->pub.rStartup = sqlfunction_startup;
    2069      124640 :     self->pub.rShutdown = sqlfunction_shutdown;
    2070      124640 :     self->pub.rDestroy = sqlfunction_destroy;
    2071      124640 :     self->pub.mydest = DestSQLFunction;
    2072             : 
    2073             :     /* private fields will be set by postquel_start */
    2074             : 
    2075      124640 :     return (DestReceiver *) self;
    2076             : }
    2077             : 
    2078             : /*
    2079             :  * sqlfunction_startup --- executor startup
    2080             :  */
    2081             : static void
    2082      125604 : sqlfunction_startup(DestReceiver *self, int operation, TupleDesc typeinfo)
    2083             : {
    2084             :     /* no-op */
    2085      125604 : }
    2086             : 
    2087             : /*
    2088             :  * sqlfunction_receive --- receive one tuple
    2089             :  */
    2090             : static bool
    2091      232066 : sqlfunction_receive(TupleTableSlot *slot, DestReceiver *self)
    2092             : {
    2093      232066 :     DR_sqlfunction *myState = (DR_sqlfunction *) self;
    2094             : 
    2095             :     /* Filter tuple as needed */
    2096      232066 :     slot = ExecFilterJunk(myState->filter, slot);
    2097             : 
    2098             :     /* Store the filtered tuple into the tuplestore */
    2099      232066 :     tuplestore_puttupleslot(myState->tstore, slot);
    2100             : 
    2101      232066 :     return true;
    2102             : }
    2103             : 
    2104             : /*
    2105             :  * sqlfunction_shutdown --- executor end
    2106             :  */
    2107             : static void
    2108      117298 : sqlfunction_shutdown(DestReceiver *self)
    2109             : {
    2110             :     /* no-op */
    2111      117298 : }
    2112             : 
    2113             : /*
    2114             :  * sqlfunction_destroy --- release DestReceiver object
    2115             :  */
    2116             : static void
    2117      116334 : sqlfunction_destroy(DestReceiver *self)
    2118             : {
    2119      116334 :     pfree(self);
    2120      116334 : }

Generated by: LCOV version 1.14