execSRF.c

Go to the documentation of this file.

/*-------------------------------------------------------------------------
 *
 * execSRF.c
 *    Routines implementing the API for set-returning functions
 *
 * This file serves nodeFunctionscan.c and nodeProjectSet.c, providing
 * common code for calling set-returning functions according to the
 * ReturnSetInfo API.
 *
 * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 *
 * IDENTIFICATION
 *    src/backend/executor/execSRF.c
 *
 *-------------------------------------------------------------------------
 */
#include "postgres.h"
 
#include "access/htup_details.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_proc.h"
#include "executor/execdebug.h"
#include "funcapi.h"
#include "miscadmin.h"
#include "nodes/nodeFuncs.h"
#include "parser/parse_coerce.h"
#include "pgstat.h"
#include "utils/acl.h"
#include "utils/builtins.h"
#include "utils/lsyscache.h"
#include "utils/memutils.h"
#include "utils/typcache.h"
 
 
/* static function decls */
static void init_sexpr(Oid foid, Oid input_collation, Expr *node,
                       SetExprState *sexpr, PlanState *parent,
                       MemoryContext sexprCxt, bool allowSRF, bool needDescForSRF);
static void ShutdownSetExpr(Datum arg);
static void ExecEvalFuncArgs(FunctionCallInfo fcinfo,
                             List *argList, ExprContext *econtext);
static void ExecPrepareTuplestoreResult(SetExprState *sexpr,
                                        ExprContext *econtext,
                                        Tuplestorestate *resultStore,
                                        TupleDesc resultDesc);
static void tupledesc_match(TupleDesc dst_tupdesc, TupleDesc src_tupdesc);
 
 
/*
 * Prepare function call in FROM (ROWS FROM) for execution.
 *
 * This is used by nodeFunctionscan.c.
 */
SetExprState *
ExecInitTableFunctionResult(Expr *expr,
                            ExprContext *econtext, PlanState *parent)
{
    SetExprState *state = makeNode(SetExprState);
 
    state->funcReturnsSet = false;
    state->expr = expr;
    state->func.fn_oid = InvalidOid;
 
    /*
     * Normally the passed expression tree will be a FuncExpr, since the
     * grammar only allows a function call at the top level of a table
     * function reference.  However, if the function doesn't return set then
     * the planner might have replaced the function call via constant-folding
     * or inlining.  So if we see any other kind of expression node, execute
     * it via the general ExecEvalExpr() code.  That code path will not
     * support set-returning functions buried in the expression, though.
     */
    if (IsA(expr, FuncExpr))
    {
        FuncExpr   *func = (FuncExpr *) expr;
 
        state->funcReturnsSet = func->funcretset;
        state->args = ExecInitExprList(func->args, parent);
 
        init_sexpr(func->funcid, func->inputcollid, expr, state, parent,
                   econtext->ecxt_per_query_memory, func->funcretset, false);
    }
    else
    {
        state->elidedFuncState = ExecInitExpr(expr, parent);
    }
 
    return state;
}
 
/*
 *      ExecMakeTableFunctionResult
 *
 * Evaluate a table function, producing a materialized result in a Tuplestore
 * object.
 *
 * This is used by nodeFunctionscan.c.
 */
Tuplestorestate *
ExecMakeTableFunctionResult(SetExprState *setexpr,
                            ExprContext *econtext,
                            MemoryContext argContext,
                            TupleDesc expectedDesc,
                            bool randomAccess)
{
    Tuplestorestate *tupstore = NULL;
    TupleDesc   tupdesc = NULL;
    Oid         funcrettype;
    bool        returnsTuple;
    bool        returnsSet = false;
    FunctionCallInfo fcinfo;
    PgStat_FunctionCallUsage fcusage;
    ReturnSetInfo rsinfo;
    HeapTupleData tmptup;
    MemoryContext callerContext;
    bool        first_time = true;
 
    /*
     * Execute per-tablefunc actions in appropriate context.
     *
     * The FunctionCallInfo needs to live across all the calls to a
     * ValuePerCall function, so it can't be allocated in the per-tuple
     * context. Similarly, the function arguments need to be evaluated in a
     * context that is longer lived than the per-tuple context: The argument
     * values would otherwise disappear when we reset that context in the
     * inner loop.  As the caller's CurrentMemoryContext is typically a
     * query-lifespan context, we don't want to leak memory there.  We require
     * the caller to pass a separate memory context that can be used for this,
     * and can be reset each time through to avoid bloat.
     */
    MemoryContextReset(argContext);
    callerContext = MemoryContextSwitchTo(argContext);
 
    funcrettype = exprType((Node *) setexpr->expr);
 
    returnsTuple = type_is_rowtype(funcrettype);
 
    /*
     * Prepare a resultinfo node for communication.  We always do this even if
     * not expecting a set result, so that we can pass expectedDesc.  In the
     * generic-expression case, the expression doesn't actually get to see the
     * resultinfo, but set it up anyway because we use some of the fields as
     * our own state variables.
     */
    rsinfo.type = T_ReturnSetInfo;
    rsinfo.econtext = econtext;
    rsinfo.expectedDesc = expectedDesc;
    rsinfo.allowedModes = (int) (SFRM_ValuePerCall | SFRM_Materialize | SFRM_Materialize_Preferred);
    if (randomAccess)
        rsinfo.allowedModes |= (int) SFRM_Materialize_Random;
    rsinfo.returnMode = SFRM_ValuePerCall;
    /* isDone is filled below */
    rsinfo.setResult = NULL;
    rsinfo.setDesc = NULL;
 
    fcinfo = palloc(SizeForFunctionCallInfo(list_length(setexpr->args)));
 
    /*
     * Normally the passed expression tree will be a SetExprState, since the
     * grammar only allows a function call at the top level of a table
     * function reference.  However, if the function doesn't return set then
     * the planner might have replaced the function call via constant-folding
     * or inlining.  So if we see any other kind of expression node, execute
     * it via the general ExecEvalExpr() code; the only difference is that we
     * don't get a chance to pass a special ReturnSetInfo to any functions
     * buried in the expression.
     */
    if (!setexpr->elidedFuncState)
    {
        /*
         * This path is similar to ExecMakeFunctionResultSet.
         */
        returnsSet = setexpr->funcReturnsSet;
        InitFunctionCallInfoData(*fcinfo, &(setexpr->func),
                                 list_length(setexpr->args),
                                 setexpr->fcinfo->fncollation,
                                 NULL, (Node *) &rsinfo);
        /* evaluate the function's argument list */
        Assert(CurrentMemoryContext == argContext);
        ExecEvalFuncArgs(fcinfo, setexpr->args, econtext);
 
        /*
         * If function is strict, and there are any NULL arguments, skip
         * calling the function and act like it returned NULL (or an empty
         * set, in the returns-set case).
         */
        if (setexpr->func.fn_strict)
        {
            int         i;
 
            for (i = 0; i < fcinfo->nargs; i++)
            {
                if (fcinfo->args[i].isnull)
                    goto no_function_result;
            }
        }
    }
    else
    {
        /* Treat setexpr as a generic expression */
        InitFunctionCallInfoData(*fcinfo, NULL, 0, InvalidOid, NULL, NULL);
    }
 
    /*
     * Switch to short-lived context for calling the function or expression.
     */
    MemoryContextSwitchTo(econtext->ecxt_per_tuple_memory);
 
    /*
     * Loop to handle the ValuePerCall protocol (which is also the same
     * behavior needed in the generic ExecEvalExpr path).
     */
    for (;;)
    {
        Datum       result;
 
        CHECK_FOR_INTERRUPTS();
 
        /*
         * Reset per-tuple memory context before each call of the function or
         * expression. This cleans up any local memory the function may leak
         * when called.
         */
        ResetExprContext(econtext);
 
        /* Call the function or expression one time */
        if (!setexpr->elidedFuncState)
        {
            pgstat_init_function_usage(fcinfo, &fcusage);
 
            fcinfo->isnull = false;
            rsinfo.isDone = ExprSingleResult;
            result = FunctionCallInvoke(fcinfo);
 
            pgstat_end_function_usage(&fcusage,
                                      rsinfo.isDone != ExprMultipleResult);
        }
        else
        {
            result =
                ExecEvalExpr(setexpr->elidedFuncState, econtext, &fcinfo->isnull);
            rsinfo.isDone = ExprSingleResult;
        }
 
        /* Which protocol does function want to use? */
        if (rsinfo.returnMode == SFRM_ValuePerCall)
        {
            /*
             * Check for end of result set.
             */
            if (rsinfo.isDone == ExprEndResult)
                break;
 
            /*
             * If first time through, build tuplestore for result.  For a
             * scalar function result type, also make a suitable tupdesc.
             */
            if (first_time)
            {
                MemoryContext oldcontext =
                MemoryContextSwitchTo(econtext->ecxt_per_query_memory);
 
                tupstore = tuplestore_begin_heap(randomAccess, false, work_mem);
                rsinfo.setResult = tupstore;
                if (!returnsTuple)
                {
                    tupdesc = CreateTemplateTupleDesc(1);
                    TupleDescInitEntry(tupdesc,
                                       (AttrNumber) 1,
                                       "column",
                                       funcrettype,
                                       -1,
                                       0);
                    rsinfo.setDesc = tupdesc;
                }
                MemoryContextSwitchTo(oldcontext);
            }
 
            /*
             * Store current resultset item.
             */
            if (returnsTuple)
            {
                if (!fcinfo->isnull)
                {
                    HeapTupleHeader td = DatumGetHeapTupleHeader(result);
 
                    if (tupdesc == NULL)
                    {
                        MemoryContext oldcontext =
                        MemoryContextSwitchTo(econtext->ecxt_per_query_memory);
 
                        /*
                         * This is the first non-NULL result from the
                         * function.  Use the type info embedded in the
                         * rowtype Datum to look up the needed tupdesc.  Make
                         * a copy for the query.
                         */
                        tupdesc = lookup_rowtype_tupdesc_copy(HeapTupleHeaderGetTypeId(td),
                                                              HeapTupleHeaderGetTypMod(td));
                        rsinfo.setDesc = tupdesc;
                        MemoryContextSwitchTo(oldcontext);
                    }
                    else
                    {
                        /*
                         * Verify all later returned rows have same subtype;
                         * necessary in case the type is RECORD.
                         */
                        if (HeapTupleHeaderGetTypeId(td) != tupdesc->tdtypeid ||
                            HeapTupleHeaderGetTypMod(td) != tupdesc->tdtypmod)
                            ereport(ERROR,
                                    (errcode(ERRCODE_DATATYPE_MISMATCH),
                                     errmsg("rows returned by function are not all of the same row type")));
                    }
 
                    /*
                     * tuplestore_puttuple needs a HeapTuple not a bare
                     * HeapTupleHeader, but it doesn't need all the fields.
                     */
                    tmptup.t_len = HeapTupleHeaderGetDatumLength(td);
                    tmptup.t_data = td;
 
                    tuplestore_puttuple(tupstore, &tmptup);
                }
                else
                {
                    /*
                     * NULL result from a tuple-returning function; expand it
                     * to a row of all nulls.  We rely on the expectedDesc to
                     * form such rows.  (Note: this would be problematic if
                     * tuplestore_putvalues saved the tdtypeid/tdtypmod from
                     * the provided descriptor, since that might not match
                     * what we get from the function itself.  But it doesn't.)
                     */
                    int         natts = expectedDesc->natts;
                    bool       *nullflags;
 
                    nullflags = (bool *) palloc(natts * sizeof(bool));
                    memset(nullflags, true, natts * sizeof(bool));
                    tuplestore_putvalues(tupstore, expectedDesc, NULL, nullflags);
                }
            }
            else
            {
                /* Scalar-type case: just store the function result */
                tuplestore_putvalues(tupstore, tupdesc, &result, &fcinfo->isnull);
            }
 
            /*
             * Are we done?
             */
            if (rsinfo.isDone != ExprMultipleResult)
                break;
 
            /*
             * Check that set-returning functions were properly declared.
             * (Note: for historical reasons, we don't complain if a non-SRF
             * returns ExprEndResult; that's treated as returning NULL.)
             */
            if (!returnsSet)
                ereport(ERROR,
                        (errcode(ERRCODE_E_R_I_E_SRF_PROTOCOL_VIOLATED),
                         errmsg("table-function protocol for value-per-call mode was not followed")));
        }
        else if (rsinfo.returnMode == SFRM_Materialize)
        {
            /* check we're on the same page as the function author */
            if (!first_time || rsinfo.isDone != ExprSingleResult || !returnsSet)
                ereport(ERROR,
                        (errcode(ERRCODE_E_R_I_E_SRF_PROTOCOL_VIOLATED),
                         errmsg("table-function protocol for materialize mode was not followed")));
            /* Done evaluating the set result */
            break;
        }
        else
            ereport(ERROR,
                    (errcode(ERRCODE_E_R_I_E_SRF_PROTOCOL_VIOLATED),
                     errmsg("unrecognized table-function returnMode: %d",
                            (int) rsinfo.returnMode)));
 
        first_time = false;
    }
 
no_function_result:
 
    /*
     * If we got nothing from the function (ie, an empty-set or NULL result),
     * we have to create the tuplestore to return, and if it's a
     * non-set-returning function then insert a single all-nulls row.  As
     * above, we depend on the expectedDesc to manufacture the dummy row.
     */
    if (rsinfo.setResult == NULL)
    {
        MemoryContext oldcontext =
        MemoryContextSwitchTo(econtext->ecxt_per_query_memory);
 
        tupstore = tuplestore_begin_heap(randomAccess, false, work_mem);
        rsinfo.setResult = tupstore;
        MemoryContextSwitchTo(oldcontext);
 
        if (!returnsSet)
        {
            int         natts = expectedDesc->natts;
            bool       *nullflags;
 
            nullflags = (bool *) palloc(natts * sizeof(bool));
            memset(nullflags, true, natts * sizeof(bool));
            tuplestore_putvalues(tupstore, expectedDesc, NULL, nullflags);
        }
    }
 
    /*
     * If function provided a tupdesc, cross-check it.  We only really need to
     * do this for functions returning RECORD, but might as well do it always.
     */
    if (rsinfo.setDesc)
    {
        tupledesc_match(expectedDesc, rsinfo.setDesc);
 
        /*
         * If it is a dynamically-allocated TupleDesc, free it: it is
         * typically allocated in a per-query context, so we must avoid
         * leaking it across multiple usages.
         */
        if (rsinfo.setDesc->tdrefcount == -1)
            FreeTupleDesc(rsinfo.setDesc);
    }
 
    MemoryContextSwitchTo(callerContext);
 
    /* All done, pass back the tuplestore */
    return rsinfo.setResult;
}
 
 
/*
 * Prepare targetlist SRF function call for execution.
 *
 * This is used by nodeProjectSet.c.
 */
SetExprState *
ExecInitFunctionResultSet(Expr *expr,
                          ExprContext *econtext, PlanState *parent)
{
    SetExprState *state = makeNode(SetExprState);
 
    state->funcReturnsSet = true;
    state->expr = expr;
    state->func.fn_oid = InvalidOid;
 
    /*
     * Initialize metadata.  The expression node could be either a FuncExpr or
     * an OpExpr.
     */
    if (IsA(expr, FuncExpr))
    {
        FuncExpr   *func = (FuncExpr *) expr;
 
        state->args = ExecInitExprList(func->args, parent);
        init_sexpr(func->funcid, func->inputcollid, expr, state, parent,
                   econtext->ecxt_per_query_memory, true, true);
    }
    else if (IsA(expr, OpExpr))
    {
        OpExpr     *op = (OpExpr *) expr;
 
        state->args = ExecInitExprList(op->args, parent);
        init_sexpr(op->opfuncid, op->inputcollid, expr, state, parent,
                   econtext->ecxt_per_query_memory, true, true);
    }
    else
        elog(ERROR, "unrecognized node type: %d",
             (int) nodeTag(expr));
 
    /* shouldn't get here unless the selected function returns set */
    Assert(state->func.fn_retset);
 
    return state;
}
 
/*
 *      ExecMakeFunctionResultSet
 *
 * Evaluate the arguments to a set-returning function and then call the
 * function itself.  The argument expressions may not contain set-returning
 * functions (the planner is supposed to have separated evaluation for those).
 *
 * This should be called in a short-lived (per-tuple) context, argContext
 * needs to live until all rows have been returned (i.e. *isDone set to
 * ExprEndResult or ExprSingleResult).
 *
 * This is used by nodeProjectSet.c.
 */
Datum
ExecMakeFunctionResultSet(SetExprState *fcache,
                          ExprContext *econtext,
                          MemoryContext argContext,
                          bool *isNull,
                          ExprDoneCond *isDone)
{
    List       *arguments;
    Datum       result;
    FunctionCallInfo fcinfo;
    PgStat_FunctionCallUsage fcusage;
    ReturnSetInfo rsinfo;
    bool        callit;
    int         i;
 
restart:
 
    /* Guard against stack overflow due to overly complex expressions */
    check_stack_depth();
 
    /*
     * If a previous call of the function returned a set result in the form of
     * a tuplestore, continue reading rows from the tuplestore until it's
     * empty.
     */
    if (fcache->funcResultStore)
    {
        TupleTableSlot *slot = fcache->funcResultSlot;
        MemoryContext oldContext;
        bool        foundTup;
 
        /*
         * Have to make sure tuple in slot lives long enough, otherwise
         * clearing the slot could end up trying to free something already
         * freed.
         */
        oldContext = MemoryContextSwitchTo(slot->tts_mcxt);
        foundTup = tuplestore_gettupleslot(fcache->funcResultStore, true, false,
                                           fcache->funcResultSlot);
        MemoryContextSwitchTo(oldContext);
 
        if (foundTup)
        {
            *isDone = ExprMultipleResult;
            if (fcache->funcReturnsTuple)
            {
                /* We must return the whole tuple as a Datum. */
                *isNull = false;
                return ExecFetchSlotHeapTupleDatum(fcache->funcResultSlot);
            }
            else
            {
                /* Extract the first column and return it as a scalar. */
                return slot_getattr(fcache->funcResultSlot, 1, isNull);
            }
        }
        /* Exhausted the tuplestore, so clean up */
        tuplestore_end(fcache->funcResultStore);
        fcache->funcResultStore = NULL;
        *isDone = ExprEndResult;
        *isNull = true;
        return (Datum) 0;
    }
 
    /*
     * arguments is a list of expressions to evaluate before passing to the
     * function manager.  We skip the evaluation if it was already done in the
     * previous call (ie, we are continuing the evaluation of a set-valued
     * function).  Otherwise, collect the current argument values into fcinfo.
     *
     * The arguments have to live in a context that lives at least until all
     * rows from this SRF have been returned, otherwise ValuePerCall SRFs
     * would reference freed memory after the first returned row.
     */
    fcinfo = fcache->fcinfo;
    arguments = fcache->args;
    if (!fcache->setArgsValid)
    {
        MemoryContext oldContext = MemoryContextSwitchTo(argContext);
 
        ExecEvalFuncArgs(fcinfo, arguments, econtext);
        MemoryContextSwitchTo(oldContext);
    }
    else
    {
        /* Reset flag (we may set it again below) */
        fcache->setArgsValid = false;
    }
 
    /*
     * Now call the function, passing the evaluated parameter values.
     */
 
    /* Prepare a resultinfo node for communication. */
    fcinfo->resultinfo = (Node *) &rsinfo;
    rsinfo.type = T_ReturnSetInfo;
    rsinfo.econtext = econtext;
    rsinfo.expectedDesc = fcache->funcResultDesc;
    rsinfo.allowedModes = (int) (SFRM_ValuePerCall | SFRM_Materialize);
    /* note we do not set SFRM_Materialize_Random or _Preferred */
    rsinfo.returnMode = SFRM_ValuePerCall;
    /* isDone is filled below */
    rsinfo.setResult = NULL;
    rsinfo.setDesc = NULL;
 
    /*
     * If function is strict, and there are any NULL arguments, skip calling
     * the function.
     */
    callit = true;
    if (fcache->func.fn_strict)
    {
        for (i = 0; i < fcinfo->nargs; i++)
        {
            if (fcinfo->args[i].isnull)
            {
                callit = false;
                break;
            }
        }
    }
 
    if (callit)
    {
        pgstat_init_function_usage(fcinfo, &fcusage);
 
        fcinfo->isnull = false;
        rsinfo.isDone = ExprSingleResult;
        result = FunctionCallInvoke(fcinfo);
        *isNull = fcinfo->isnull;
        *isDone = rsinfo.isDone;
 
        pgstat_end_function_usage(&fcusage,
                                  rsinfo.isDone != ExprMultipleResult);
    }
    else
    {
        /* for a strict SRF, result for NULL is an empty set */
        result = (Datum) 0;
        *isNull = true;
        *isDone = ExprEndResult;
    }
 
    /* Which protocol does function want to use? */
    if (rsinfo.returnMode == SFRM_ValuePerCall)
    {
        if (*isDone != ExprEndResult)
        {
            /*
             * Save the current argument values to re-use on the next call.
             */
            if (*isDone == ExprMultipleResult)
            {
                fcache->setArgsValid = true;
                /* Register cleanup callback if we didn't already */
                if (!fcache->shutdown_reg)
                {
                    RegisterExprContextCallback(econtext,
                                                ShutdownSetExpr,
                                                PointerGetDatum(fcache));
                    fcache->shutdown_reg = true;
                }
            }
        }
    }
    else if (rsinfo.returnMode == SFRM_Materialize)
    {
        /* check we're on the same page as the function author */
        if (rsinfo.isDone != ExprSingleResult)
            ereport(ERROR,
                    (errcode(ERRCODE_E_R_I_E_SRF_PROTOCOL_VIOLATED),
                     errmsg("table-function protocol for materialize mode was not followed")));
        if (rsinfo.setResult != NULL)
        {
            /* prepare to return values from the tuplestore */
            ExecPrepareTuplestoreResult(fcache, econtext,
                                        rsinfo.setResult,
                                        rsinfo.setDesc);
            /* loop back to top to start returning from tuplestore */
            goto restart;
        }
        /* if setResult was left null, treat it as empty set */
        *isDone = ExprEndResult;
        *isNull = true;
        result = (Datum) 0;
    }
    else
        ereport(ERROR,
                (errcode(ERRCODE_E_R_I_E_SRF_PROTOCOL_VIOLATED),
                 errmsg("unrecognized table-function returnMode: %d",
                        (int) rsinfo.returnMode)));
 
    return result;
}
 
 
/*
 * init_sexpr - initialize a SetExprState node during first use
 */
static void
init_sexpr(Oid foid, Oid input_collation, Expr *node,
           SetExprState *sexpr, PlanState *parent,
           MemoryContext sexprCxt, bool allowSRF, bool needDescForSRF)
{
    AclResult   aclresult;
    size_t      numargs = list_length(sexpr->args);
 
    /* Check permission to call function */
    aclresult = object_aclcheck(ProcedureRelationId, foid, GetUserId(), ACL_EXECUTE);
    if (aclresult != ACLCHECK_OK)
        aclcheck_error(aclresult, OBJECT_FUNCTION, get_func_name(foid));
    InvokeFunctionExecuteHook(foid);
 
    /*
     * Safety check on nargs.  Under normal circumstances this should never
     * fail, as parser should check sooner.  But possibly it might fail if
     * server has been compiled with FUNC_MAX_ARGS smaller than some functions
     * declared in pg_proc?
     */
    if (list_length(sexpr->args) > FUNC_MAX_ARGS)
        ereport(ERROR,
                (errcode(ERRCODE_TOO_MANY_ARGUMENTS),
                 errmsg_plural("cannot pass more than %d argument to a function",
                               "cannot pass more than %d arguments to a function",
                               FUNC_MAX_ARGS,
                               FUNC_MAX_ARGS)));
 
    /* Set up the primary fmgr lookup information */
    fmgr_info_cxt(foid, &(sexpr->func), sexprCxt);
    fmgr_info_set_expr((Node *) sexpr->expr, &(sexpr->func));
 
    /* Initialize the function call parameter struct as well */
    sexpr->fcinfo =
        (FunctionCallInfo) palloc(SizeForFunctionCallInfo(numargs));
    InitFunctionCallInfoData(*sexpr->fcinfo, &(sexpr->func),
                             numargs,
                             input_collation, NULL, NULL);
 
    /* If function returns set, check if that's allowed by caller */
    if (sexpr->func.fn_retset && !allowSRF)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("set-valued function called in context that cannot accept a set"),
                 parent ? executor_errposition(parent->state,
                                               exprLocation((Node *) node)) : 0));
 
    /* Otherwise, caller should have marked the sexpr correctly */
    Assert(sexpr->func.fn_retset == sexpr->funcReturnsSet);
 
    /* If function returns set, prepare expected tuple descriptor */
    if (sexpr->func.fn_retset && needDescForSRF)
    {
        TypeFuncClass functypclass;
        Oid         funcrettype;
        TupleDesc   tupdesc;
        MemoryContext oldcontext;
 
        functypclass = get_expr_result_type(sexpr->func.fn_expr,
                                            &funcrettype,
                                            &tupdesc);
 
        /* Must save tupdesc in sexpr's context */
        oldcontext = MemoryContextSwitchTo(sexprCxt);
 
        if (functypclass == TYPEFUNC_COMPOSITE ||
            functypclass == TYPEFUNC_COMPOSITE_DOMAIN)
        {
            /* Composite data type, e.g. a table's row type */
            Assert(tupdesc);
            /* Must copy it out of typcache for safety */
            sexpr->funcResultDesc = CreateTupleDescCopy(tupdesc);
            sexpr->funcReturnsTuple = true;
        }
        else if (functypclass == TYPEFUNC_SCALAR)
        {
            /* Base data type, i.e. scalar */
            tupdesc = CreateTemplateTupleDesc(1);
            TupleDescInitEntry(tupdesc,
                               (AttrNumber) 1,
                               NULL,
                               funcrettype,
                               -1,
                               0);
            sexpr->funcResultDesc = tupdesc;
            sexpr->funcReturnsTuple = false;
        }
        else if (functypclass == TYPEFUNC_RECORD)
        {
            /* This will work if function doesn't need an expectedDesc */
            sexpr->funcResultDesc = NULL;
            sexpr->funcReturnsTuple = true;
        }
        else
        {
            /* Else, we will fail if function needs an expectedDesc */
            sexpr->funcResultDesc = NULL;
        }
 
        MemoryContextSwitchTo(oldcontext);
    }
    else
        sexpr->funcResultDesc = NULL;
 
    /* Initialize additional state */
    sexpr->funcResultStore = NULL;
    sexpr->funcResultSlot = NULL;
    sexpr->shutdown_reg = false;
}
 
/*
 * callback function in case a SetExprState needs to be shut down before it
 * has been run to completion
 */
static void
ShutdownSetExpr(Datum arg)
{
    SetExprState *sexpr = castNode(SetExprState, DatumGetPointer(arg));
 
    /* If we have a slot, make sure it's let go of any tuplestore pointer */
    if (sexpr->funcResultSlot)
        ExecClearTuple(sexpr->funcResultSlot);
 
    /* Release any open tuplestore */
    if (sexpr->funcResultStore)
        tuplestore_end(sexpr->funcResultStore);
    sexpr->funcResultStore = NULL;
 
    /* Clear any active set-argument state */
    sexpr->setArgsValid = false;
 
    /* execUtils will deregister the callback... */
    sexpr->shutdown_reg = false;
}
 
/*
 * Evaluate arguments for a function.
 */
static void
ExecEvalFuncArgs(FunctionCallInfo fcinfo,
                 List *argList,
                 ExprContext *econtext)
{
    int         i;
    ListCell   *arg;
 
    i = 0;
    foreach(arg, argList)
    {
        ExprState  *argstate = (ExprState *) lfirst(arg);
 
        fcinfo->args[i].value = ExecEvalExpr(argstate,
                                             econtext,
                                             &fcinfo->args[i].isnull);
        i++;
    }
 
    Assert(i == fcinfo->nargs);
}
 
/*
 *      ExecPrepareTuplestoreResult
 *
 * Subroutine for ExecMakeFunctionResultSet: prepare to extract rows from a
 * tuplestore function result.  We must set up a funcResultSlot (unless
 * already done in a previous call cycle) and verify that the function
 * returned the expected tuple descriptor.
 */
static void
ExecPrepareTuplestoreResult(SetExprState *sexpr,
                            ExprContext *econtext,
                            Tuplestorestate *resultStore,
                            TupleDesc resultDesc)
{
    sexpr->funcResultStore = resultStore;
 
    if (sexpr->funcResultSlot == NULL)
    {
        /* Create a slot so we can read data out of the tuplestore */
        TupleDesc   slotDesc;
        MemoryContext oldcontext;
 
        oldcontext = MemoryContextSwitchTo(sexpr->func.fn_mcxt);
 
        /*
         * If we were not able to determine the result rowtype from context,
         * and the function didn't return a tupdesc, we have to fail.
         */
        if (sexpr->funcResultDesc)
            slotDesc = sexpr->funcResultDesc;
        else if (resultDesc)
        {
            /* don't assume resultDesc is long-lived */
            slotDesc = CreateTupleDescCopy(resultDesc);
        }
        else
        {
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("function returning setof record called in "
                            "context that cannot accept type record")));
            slotDesc = NULL;    /* keep compiler quiet */
        }
 
        sexpr->funcResultSlot = MakeSingleTupleTableSlot(slotDesc,
                                                         &TTSOpsMinimalTuple);
        MemoryContextSwitchTo(oldcontext);
    }
 
    /*
     * If function provided a tupdesc, cross-check it.  We only really need to
     * do this for functions returning RECORD, but might as well do it always.
     */
    if (resultDesc)
    {
        if (sexpr->funcResultDesc)
            tupledesc_match(sexpr->funcResultDesc, resultDesc);
 
        /*
         * If it is a dynamically-allocated TupleDesc, free it: it is
         * typically allocated in a per-query context, so we must avoid
         * leaking it across multiple usages.
         */
        if (resultDesc->tdrefcount == -1)
            FreeTupleDesc(resultDesc);
    }
 
    /* Register cleanup callback if we didn't already */
    if (!sexpr->shutdown_reg)
    {
        RegisterExprContextCallback(econtext,
                                    ShutdownSetExpr,
                                    PointerGetDatum(sexpr));
        sexpr->shutdown_reg = true;
    }
}
 
/*
 * Check that function result tuple type (src_tupdesc) matches or can
 * be considered to match what the query expects (dst_tupdesc). If
 * they don't match, ereport.
 *
 * We really only care about number of attributes and data type.
 * Also, we can ignore type mismatch on columns that are dropped in the
 * destination type, so long as the physical storage matches.  This is
 * helpful in some cases involving out-of-date cached plans.
 */
static void
tupledesc_match(TupleDesc dst_tupdesc, TupleDesc src_tupdesc)
{
    int         i;
 
    if (dst_tupdesc->natts != src_tupdesc->natts)
        ereport(ERROR,
                (errcode(ERRCODE_DATATYPE_MISMATCH),
                 errmsg("function return row and query-specified return row do not match"),
                 errdetail_plural("Returned row contains %d attribute, but query expects %d.",
                                  "Returned row contains %d attributes, but query expects %d.",
                                  src_tupdesc->natts,
                                  src_tupdesc->natts, dst_tupdesc->natts)));
 
    for (i = 0; i < dst_tupdesc->natts; i++)
    {
        Form_pg_attribute dattr = TupleDescAttr(dst_tupdesc, i);
        Form_pg_attribute sattr = TupleDescAttr(src_tupdesc, i);
 
        if (IsBinaryCoercible(sattr->atttypid, dattr->atttypid))
            continue;           /* no worries */
        if (!dattr->attisdropped)
            ereport(ERROR,
                    (errcode(ERRCODE_DATATYPE_MISMATCH),
                     errmsg("function return row and query-specified return row do not match"),
                     errdetail("Returned type %s at ordinal position %d, but query expects %s.",
                               format_type_be(sattr->atttypid),
                               i + 1,
                               format_type_be(dattr->atttypid))));
 
        if (dattr->attlen != sattr->attlen ||
            dattr->attalign != sattr->attalign)
            ereport(ERROR,
                    (errcode(ERRCODE_DATATYPE_MISMATCH),
                     errmsg("function return row and query-specified return row do not match"),
                     errdetail("Physical storage mismatch on dropped attribute at ordinal position %d.",
                               i + 1)));
    }
}