/*-------------------------------------------------------------------------
 *
 * nodeProjectSet.c
 *   support for evaluating targetlists containing set-returning functions
 *
 * DESCRIPTION
 *
 *  ProjectSet nodes are inserted by the planner to evaluate set-returning
 *  functions in the targetlist.  It's guaranteed that all set-returning
 *  functions are directly at the top level of the targetlist, i.e. they
 *  can't be inside more-complex expressions.  If that'd otherwise be
 *  the case, the planner adds additional ProjectSet nodes.
 *
 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 * IDENTIFICATION
 *   src/backend/executor/nodeProjectSet.c
 *
 *-------------------------------------------------------------------------
 */

#include "postgres.h"

#include "executor/executor.h"
#include "executor/nodeProjectSet.h"
#include "miscadmin.h"
#include "nodes/nodeFuncs.h"


static TupleTableSlot *ExecProjectSRF(ProjectSetState *node, bool continuing);


/* ----------------------------------------------------------------
 *  ExecProjectSet(node)
 *
 *  Return tuples after evaluating the targetlist (which contains set
 *  returning functions).
 * ----------------------------------------------------------------
 */
static TupleTableSlot *
ExecProjectSet(PlanState *pstate)
{
 ProjectSetState *node = castNode(ProjectSetState, pstate);
 TupleTableSlot *outerTupleSlot;
 TupleTableSlot *resultSlot;
 PlanState  *outerPlan;
 ExprContext *econtext;

 CHECK_FOR_INTERRUPTS();

 econtext = node->ps.ps_ExprContext;

 /*
  * Reset per-tuple context to free expression-evaluation storage allocated
  * for a potentially previously returned tuple. Note that the SRF argument
  * context has a different lifetime and is reset below.
 */
 ResetExprContext(econtext);

 /*
  * Check to see if we're still projecting out tuples from a previous scan
  * tuple (because there is a function-returning-set in the projection
  * expressions).  If so, try to project another one.
 */
 if (node->pending_srf_tuples)
 {
  resultSlot = ExecProjectSRF(node, true);

  if (resultSlot != NULL)
   return resultSlot;
 }

 /*
  * Get another input tuple and project SRFs from it.
 */
 for (;;)
 {
  /*
   * Reset argument context to free any expression evaluation storage
   * allocated in the previous tuple cycle.  Note this can't happen
   * until we're done projecting out tuples from a scan tuple, as
   * ValuePerCall functions are allowed to reference the arguments for
   * each returned tuple.  However, if we loop around after finding that
   * no rows are produced from a scan tuple, we should reset, to avoid
   * leaking memory when many successive scan tuples produce no rows.
 */
  MemoryContextReset(node->argcontext);

  /*
   * Retrieve tuples from the outer plan until there are no more.
 */
  outerPlan = outerPlanState(node);
  outerTupleSlot = ExecProcNode(outerPlan);

  if (TupIsNull(outerTupleSlot))
   return NULL;

  /*
   * Prepare to compute projection expressions, which will expect to
   * access the input tuples as varno OUTER.
 */
  econtext->ecxt_outertuple = outerTupleSlot;

  /* Evaluate the expressions */
  resultSlot = ExecProjectSRF(node, false);

  /*
   * Return the tuple unless the projection produced no rows (due to an
   * empty set), in which case we must loop back to see if there are
   * more outerPlan tuples.
 */
  if (resultSlot)
   return resultSlot;

  /*
   * When we do loop back, we'd better reset the econtext again, just in
   * case the SRF leaked some memory there.
 */
  ResetExprContext(econtext);
 }

 return NULL;
}

/* ----------------------------------------------------------------
 *  ExecProjectSRF
 *
 *  Project a targetlist containing one or more set-returning functions.
 *
 *  'continuing' indicates whether to continue projecting rows for the
 *  same input tuple; or whether a new input tuple is being projected.
 *
 *  Returns NULL if no output tuple has been produced.
 *
 * ----------------------------------------------------------------
 */
static TupleTableSlot *
ExecProjectSRF(ProjectSetState *node, bool continuing)
{
 TupleTableSlot *resultSlot = node->ps.ps_ResultTupleSlot;
 ExprContext *econtext = node->ps.ps_ExprContext;
 MemoryContext oldcontext;
 bool  hassrf PG_USED_FOR_ASSERTS_ONLY;
 bool  hasresult;
 int   argno;

 ExecClearTuple(resultSlot);

 /* Call SRFs, as well as plain expressions, in per-tuple context */
 oldcontext = MemoryContextSwitchTo(econtext->ecxt_per_tuple_memory);

 /*
  * Assume no further tuples are produced unless an ExprMultipleResult is
  * encountered from a set returning function.
 */
 node->pending_srf_tuples = false;

 hassrf = hasresult = false;
 for (argno = 0; argno < node->nelems; argno++)
 {
  Node    *elem = node->elems[argno];
  ExprDoneCond *isdone = &node->elemdone[argno];
  Datum    *result = &resultSlot->tts_values[argno];
  bool    *isnull = &resultSlot->tts_isnull[argno];

  if (continuing && *isdone == ExprEndResult)
  {
   /*
    * If we're continuing to project output rows from a source tuple,
    * return NULLs once the SRF has been exhausted.
 */
   *result = (Datum) 0;
   *isnull = true;
   hassrf = true;
  }
  else if (IsA(elem, SetExprState))
  {
   /*
    * Evaluate SRF - possibly continuing previously started output.
 */
   *result = ExecMakeFunctionResultSet((SetExprState *) elem,
            econtext, node->argcontext,
            isnull, isdone);

   if (*isdone != ExprEndResult)
    hasresult = true;
   if (*isdone == ExprMultipleResult)
    node->pending_srf_tuples = true;
   hassrf = true;
  }
  else
  {
   /* Non-SRF tlist expression, just evaluate normally. */
   *result = ExecEvalExpr((ExprState *) elem, econtext, isnull);
   *isdone = ExprSingleResult;
  }
 }

 MemoryContextSwitchTo(oldcontext);

 /* ProjectSet should not be used if there's no SRFs */
 Assert(hassrf);

 /*
  * If all the SRFs returned ExprEndResult, we consider that as no row
  * being produced.
 */
 if (hasresult)
 {
  ExecStoreVirtualTuple(resultSlot);
  return resultSlot;
 }

 return NULL;
}

/* ----------------------------------------------------------------
 *  ExecInitProjectSet
 *
 *  Creates the run-time state information for the ProjectSet node
 *  produced by the planner and initializes outer relations
 *  (child nodes).
 * ----------------------------------------------------------------
 */
ProjectSetState *
ExecInitProjectSet(ProjectSet *node, EState *estate, int eflags)
{
 ProjectSetState *state;
 ListCell   *lc;
 int   off;

 /* check for unsupported flags */
 Assert(!(eflags & (EXEC_FLAG_MARK | EXEC_FLAG_BACKWARD)));

 /*
  * create state structure
 */
 state = makeNode(ProjectSetState);
 state->ps.plan = (Plan *) node;
 state->ps.state = estate;
 state->ps.ExecProcNode = ExecProjectSet;

 state->pending_srf_tuples = false;

 /*
  * Miscellaneous initialization
  *
  * create expression context for node
 */
 ExecAssignExprContext(estate, &state->ps);

 /*
  * initialize child nodes
 */
 outerPlanState(state) = ExecInitNode(outerPlan(node), estate, eflags);

 /*
  * we don't use inner plan
 */
 Assert(innerPlan(node) == NULL);

 /*
  * tuple table and result type initialization
 */
 ExecInitResultTupleSlotTL(&state->ps, &TTSOpsVirtual);

 /* Create workspace for per-tlist-entry expr state & SRF-is-done state */
 state->nelems = list_length(node->plan.targetlist);
 state->elems = (Node **)
  palloc(sizeof(Node *) * state->nelems);
 state->elemdone = (ExprDoneCond *)
  palloc(sizeof(ExprDoneCond) * state->nelems);

 /*
  * Build expressions to evaluate targetlist.  We can't use
  * ExecBuildProjectionInfo here, since that doesn't deal with SRFs.
  * Instead compile each expression separately, using
  * ExecInitFunctionResultSet where applicable.
 */
 off = 0;
 foreach(lc, node->plan.targetlist)
 {
  TargetEntry *te = (TargetEntry *) lfirst(lc);
  Expr    *expr = te->expr;

  if ((IsA(expr, FuncExpr) && ((FuncExpr *) expr)->funcretset) ||
   (IsA(expr, OpExpr) && ((OpExpr *) expr)->opretset))
  {
   state->elems[off] = (Node *)
    ExecInitFunctionResultSet(expr, state->ps.ps_ExprContext,
            &state->ps);
  }
  else
  {
   Assert(!expression_returns_set((Node *) expr));
   state->elems[off] = (Node *) ExecInitExpr(expr, &state->ps);
  }

  off++;
 }

 /* We don't support any qual on ProjectSet nodes */
 Assert(node->plan.qual == NIL);

 /*
  * Create a memory context that ExecMakeFunctionResultSet can use to
  * evaluate function arguments in.  We can't use the per-tuple context for
  * this because it gets reset too often; but we don't want to leak
  * evaluation results into the query-lifespan context either.  We use one
  * context for the arguments of all tSRFs, as they have roughly equivalent
  * lifetimes.
 */
 state->argcontext = AllocSetContextCreate(CurrentMemoryContext,
             "tSRF function arguments",
             ALLOCSET_DEFAULT_SIZES);

 return state;
}

/* ----------------------------------------------------------------
 *  ExecEndProjectSet
 *
 *  frees up storage allocated through C routines
 * ----------------------------------------------------------------
 */
void
ExecEndProjectSet(ProjectSetState *node)
{
 /*
  * shut down subplans
 */
 ExecEndNode(outerPlanState(node));
}

void
ExecReScanProjectSet(ProjectSetState *node)
{
 PlanState  *outerPlan = outerPlanState(node);

 /* Forget any incompletely-evaluated SRFs */
 node->pending_srf_tuples = false;

 /*
  * If chgParam of subnode is not null then plan will be re-scanned by
  * first ExecProcNode.
 */
 if (outerPlan->chgParam == NULL)
  ExecReScan(outerPlan);
}