/*-------------------------------------------------------------------------

 *

 * 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-2026, 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 "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/tuplestore.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 ExecReleaseTuplestoreResult(SetExprState *sexpr);

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);

          TupleDescFinalize(tupdesc);

          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")));

          }

          if (tupdesc->tdtypeid != RECORDOID)

          {

            /*

             * If it's not a record type, check that the datum and

             * the tupledesc are still compatible.

             *

             * We do that here because after tuplestore_puttuple()

             * we don't have the necessary information anymore.

             * Right now tuplestore_puttuple() doesn't have the

             * tupledesc and thus can't perform this check.

             *

             * Note that this would not protect against problems

             * if the tupledesc could change across rows (we'd

             * leave differently shaped tuples in the tuplestore,

             * causing problems on retrieval), but the descriptor

             * luckily can't change.

             *

             * Because of the version normalization in

             * DatumGetHeapTupleHeader(), the tuple has to be

             * marked as a datum, and because this is the !=

             * RECORDOID branch, it should be versioned. For now

             * just Assert() that that is the case.

             */

            Assert(HeapTupleHeaderIsVersionedDatum(td));

            if (HeapTupleHeaderIsVersionedDatum(td))

              heap_datum_check(td, tupdesc);

          }

          /*

           * 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 = palloc_array(bool, natts);

          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 = palloc_array(bool, natts);

      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 */

    ExecReleaseTuplestoreResult(fcache);

    *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);

      TupleDescFinalize(tupdesc);

      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));

  /* Release any open tuplestore */

  ExecReleaseTuplestoreResult(sexpr);

  /*

   * If each invocation of the function can return a different row type,

   * ExecReleaseTuplestoreResult will have already dropped the slot.  If

   * not, we must clear it here.

   */

  if (sexpr->funcResultSlot)

    ExecClearTuple(sexpr->funcResultSlot);

  /* 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)

{

  /*

   * Any previous result must have been released.  In particular, a slot not

   * built from funcResultDesc must not survive to be reused here.

   */

  Assert(sexpr->funcResultStore == NULL);

  Assert(sexpr->funcResultDesc != NULL || sexpr->funcResultSlot == NULL);

  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 */

    }