/*-------------------------------------------------------------------------
 *
 * paramassign.c
 *  Functions for assigning PARAM_EXEC slots during planning.
 *
 * This module is responsible for managing three planner data structures:
 *
 * root->glob->paramExecTypes: records actual assignments of PARAM_EXEC slots.
 * The i'th list element holds the data type OID of the i'th parameter slot.
 * (Elements can be InvalidOid if they represent slots that are needed for
 * chgParam signaling, but will never hold a value at runtime.)  This list is
 * global to the whole plan since the executor has only one PARAM_EXEC array.
 * Assignments are permanent for the plan: we never remove entries once added.
 *
 * root->plan_params: a list of PlannerParamItem nodes, recording Vars and
 * PlaceHolderVars that the root's query level needs to supply to lower-level
 * subqueries, along with the PARAM_EXEC number to use for each such value.
 * Elements are added to this list while planning a subquery, and the list
 * is reset to empty after completion of each subquery.
 *
 * root->curOuterParams: a list of NestLoopParam nodes, recording Vars and
 * PlaceHolderVars that some outer level of nestloop needs to pass down to
 * a lower-level plan node in its righthand side.  Elements are added to this
 * list as createplan.c creates lower Plan nodes that need such Params, and
 * are removed when it creates a NestLoop Plan node that will supply those
 * values.
 *
 * The latter two data structures are used to prevent creating multiple
 * PARAM_EXEC slots (each requiring work to fill) when the same upper
 * SubPlan or NestLoop supplies a value that is referenced in more than
 * one place in its child plan nodes.  However, when the same Var has to
 * be supplied to different subplan trees by different SubPlan or NestLoop
 * parent nodes, we don't recognize any commonality; a fresh plan_params or
 * curOuterParams entry will be made (since the old one has been removed
 * when we finished processing the earlier SubPlan or NestLoop) and a fresh
 * PARAM_EXEC number will be assigned.  At one time we tried to avoid
 * allocating duplicate PARAM_EXEC numbers in such cases, but it's harder
 * than it seems to avoid bugs due to overlapping Param lifetimes, so we
 * don't risk that anymore.  Minimizing the number of PARAM_EXEC slots
 * doesn't really save much executor work anyway.
 *
 *
 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 * IDENTIFICATION
 *   src/backend/optimizer/util/paramassign.c
 *
 *-------------------------------------------------------------------------
 */
#include "postgres.h"

#include "nodes/nodeFuncs.h"
#include "nodes/plannodes.h"
#include "optimizer/paramassign.h"
#include "optimizer/placeholder.h"
#include "rewrite/rewriteManip.h"


/*
 * Select a PARAM_EXEC number to identify the given Var as a parameter for
 * the current subquery.  (It might already have one.)
 * Record the need for the Var in the proper upper-level root->plan_params.
 */
static int
assign_param_for_var(PlannerInfo *root, Var *var)
{
 ListCell   *ppl;
 PlannerParamItem *pitem;
 Index  levelsup;

 /* Find the query level the Var belongs to */
 for (levelsup = var->varlevelsup; levelsup > 0; levelsup--)
  root = root->parent_root;

 /* If there's already a matching PlannerParamItem there, just use it */
 foreach(ppl, root->plan_params)
 {
  pitem = (PlannerParamItem *) lfirst(ppl);
  if (IsA(pitem->item, Var))
  {
   Var     *pvar = (Var *) pitem->item;

   /*
    * This comparison must match _equalVar(), except for ignoring
    * varlevelsup.  Note that _equalVar() ignores varnosyn,
    * varattnosyn, and location, so this does too.
 */
   if (pvar->varno == var->varno &&
    pvar->varattno == var->varattno &&
    pvar->vartype == var->vartype &&
    pvar->vartypmod == var->vartypmod &&
    pvar->varcollid == var->varcollid &&
    pvar->varreturningtype == var->varreturningtype &&
    bms_equal(pvar->varnullingrels, var->varnullingrels))
    return pitem->paramId;
  }
 }

 /* Nope, so make a new one */
 var = copyObject(var);
 var->varlevelsup = 0;

 pitem = makeNode(PlannerParamItem);
 pitem->item = (Node *) var;
 pitem->paramId = list_length(root->glob->paramExecTypes);
 root->glob->paramExecTypes = lappend_oid(root->glob->paramExecTypes,
            var->vartype);

 root->plan_params = lappend(root->plan_params, pitem);

 return pitem->paramId;
}

/*
 * Generate a Param node to replace the given Var,
 * which is expected to have varlevelsup > 0 (ie, it is not local).
 * Record the need for the Var in the proper upper-level root->plan_params.
 */
Param *
replace_outer_var(PlannerInfo *root, Var *var)
{
 Param    *retval;
 int   i;

 Assert(var->varlevelsup > 0 && var->varlevelsup < root->query_level);

 /* Find the Var in the appropriate plan_params, or add it if not present */
 i = assign_param_for_var(root, var);

 retval = makeNode(Param);
 retval->paramkind = PARAM_EXEC;
 retval->paramid = i;
 retval->paramtype = var->vartype;
 retval->paramtypmod = var->vartypmod;
 retval->paramcollid = var->varcollid;
 retval->location = var->location;

 return retval;
}

/*
 * Select a PARAM_EXEC number to identify the given PlaceHolderVar as a
 * parameter for the current subquery.  (It might already have one.)
 * Record the need for the PHV in the proper upper-level root->plan_params.
 *
 * This is just like assign_param_for_var, except for PlaceHolderVars.
 */
static int
assign_param_for_placeholdervar(PlannerInfo *root, PlaceHolderVar *phv)
{
 ListCell   *ppl;
 PlannerParamItem *pitem;
 Index  levelsup;

 /* Find the query level the PHV belongs to */
 for (levelsup = phv->phlevelsup; levelsup > 0; levelsup--)
  root = root->parent_root;

 /* If there's already a matching PlannerParamItem there, just use it */
 foreach(ppl, root->plan_params)
 {
  pitem = (PlannerParamItem *) lfirst(ppl);
  if (IsA(pitem->item, PlaceHolderVar))
  {
   PlaceHolderVar *pphv = (PlaceHolderVar *) pitem->item;

   /* We assume comparing the PHIDs is sufficient */
   if (pphv->phid == phv->phid)
    return pitem->paramId;
  }
 }

 /* Nope, so make a new one */
 phv = copyObject(phv);
 IncrementVarSublevelsUp((Node *) phv, -((int) phv->phlevelsup), 0);
 Assert(phv->phlevelsup == 0);

 pitem = makeNode(PlannerParamItem);
 pitem->item = (Node *) phv;
 pitem->paramId = list_length(root->glob->paramExecTypes);
 root->glob->paramExecTypes = lappend_oid(root->glob->paramExecTypes,
            exprType((Node *) phv->phexpr));

 root->plan_params = lappend(root->plan_params, pitem);

 return pitem->paramId;
}

/*
 * Generate a Param node to replace the given PlaceHolderVar,
 * which is expected to have phlevelsup > 0 (ie, it is not local).
 * Record the need for the PHV in the proper upper-level root->plan_params.
 *
 * This is just like replace_outer_var, except for PlaceHolderVars.
 */
Param *
replace_outer_placeholdervar(PlannerInfo *root, PlaceHolderVar *phv)
{
 Param    *retval;
 int   i;

 Assert(phv->phlevelsup > 0 && phv->phlevelsup < root->query_level);

 /* Find the PHV in the appropriate plan_params, or add it if not present */
 i = assign_param_for_placeholdervar(root, phv);

 retval = makeNode(Param);
 retval->paramkind = PARAM_EXEC;
 retval->paramid = i;
 retval->paramtype = exprType((Node *) phv->phexpr);
 retval->paramtypmod = exprTypmod((Node *) phv->phexpr);
 retval->paramcollid = exprCollation((Node *) phv->phexpr);
 retval->location = -1;

 return retval;
}

/*
 * Generate a Param node to replace the given Aggref
 * which is expected to have agglevelsup > 0 (ie, it is not local).
 * Record the need for the Aggref in the proper upper-level root->plan_params.
 */
Param *
replace_outer_agg(PlannerInfo *root, Aggref *agg)
{
 Param    *retval;
 PlannerParamItem *pitem;
 Index  levelsup;

 Assert(agg->agglevelsup > 0 && agg->agglevelsup < root->query_level);

 /* Find the query level the Aggref belongs to */
 for (levelsup = agg->agglevelsup; levelsup > 0; levelsup--)
  root = root->parent_root;

 /*
  * It does not seem worthwhile to try to de-duplicate references to outer
  * aggs.  Just make a new slot every time.
 */
 agg = copyObject(agg);
 IncrementVarSublevelsUp((Node *) agg, -((int) agg->agglevelsup), 0);
 Assert(agg->agglevelsup == 0);

 pitem = makeNode(PlannerParamItem);
 pitem->item = (Node *) agg;
 pitem->paramId = list_length(root->glob->paramExecTypes);
 root->glob->paramExecTypes = lappend_oid(root->glob->paramExecTypes,
            agg->aggtype);

 root->plan_params = lappend(root->plan_params, pitem);

 retval = makeNode(Param);
 retval->paramkind = PARAM_EXEC;
 retval->paramid = pitem->paramId;
 retval->paramtype = agg->aggtype;
 retval->paramtypmod = -1;
 retval->paramcollid = agg->aggcollid;
 retval->location = agg->location;

 return retval;
}

/*
 * Generate a Param node to replace the given GroupingFunc expression which is
 * expected to have agglevelsup > 0 (ie, it is not local).
 * Record the need for the GroupingFunc in the proper upper-level
 * root->plan_params.
 */
Param *
replace_outer_grouping(PlannerInfo *root, GroupingFunc *grp)
{
 Param    *retval;
 PlannerParamItem *pitem;
 Index  levelsup;
 Oid   ptype = exprType((Node *) grp);

 Assert(grp->agglevelsup > 0 && grp->agglevelsup < root->query_level);

 /* Find the query level the GroupingFunc belongs to */
 for (levelsup = grp->agglevelsup; levelsup > 0; levelsup--)
  root = root->parent_root;

 /*
  * It does not seem worthwhile to try to de-duplicate references to outer
  * aggs.  Just make a new slot every time.
 */
 grp = copyObject(grp);
 IncrementVarSublevelsUp((Node *) grp, -((int) grp->agglevelsup), 0);
 Assert(grp->agglevelsup == 0);

 pitem = makeNode(PlannerParamItem);
 pitem->item = (Node *) grp;
 pitem->paramId = list_length(root->glob->paramExecTypes);
 root->glob->paramExecTypes = lappend_oid(root->glob->paramExecTypes,
            ptype);

 root->plan_params = lappend(root->plan_params, pitem);

 retval = makeNode(Param);
 retval->paramkind = PARAM_EXEC;
 retval->paramid = pitem->paramId;
 retval->paramtype = ptype;
 retval->paramtypmod = -1;
 retval->paramcollid = InvalidOid;
 retval->location = grp->location;

 return retval;
}

/*
 * Generate a Param node to replace the given MergeSupportFunc expression
 * which is expected to be in the RETURNING list of an upper-level MERGE
 * query.  Record the need for the MergeSupportFunc in the proper upper-level
 * root->plan_params.
 */
Param *
replace_outer_merge_support(PlannerInfo *root, MergeSupportFunc *msf)
{
 Param    *retval;
 PlannerParamItem *pitem;
 Oid   ptype = exprType((Node *) msf);

 Assert(root->parse->commandType != CMD_MERGE);

 /*
  * The parser should have ensured that the MergeSupportFunc is in the
  * RETURNING list of an upper-level MERGE query, so find that query.
 */
 do
 {
  root = root->parent_root;
  if (root == NULL)
   elog(ERROR, "MergeSupportFunc found outside MERGE");
 } while (root->parse->commandType != CMD_MERGE);

 /*
  * It does not seem worthwhile to try to de-duplicate references to outer
  * MergeSupportFunc expressions.  Just make a new slot every time.
 */
 msf = copyObject(msf);

 pitem = makeNode(PlannerParamItem);
 pitem->item = (Node *) msf;
 pitem->paramId = list_length(root->glob->paramExecTypes);
 root->glob->paramExecTypes = lappend_oid(root->glob->paramExecTypes,
            ptype);

 root->plan_params = lappend(root->plan_params, pitem);

 retval = makeNode(Param);
 retval->paramkind = PARAM_EXEC;
 retval->paramid = pitem->paramId;
 retval->paramtype = ptype;
 retval->paramtypmod = -1;
 retval->paramcollid = InvalidOid;
 retval->location = msf->location;

 return retval;
}

/*
 * Generate a Param node to replace the given ReturningExpr expression which
 * is expected to have retlevelsup > 0 (ie, it is not local).  Record the need
 * for the ReturningExpr in the proper upper-level root->plan_params.
 */
Param *
replace_outer_returning(PlannerInfo *root, ReturningExpr *rexpr)
{
 Param    *retval;
 PlannerParamItem *pitem;
 Index  levelsup;
 Oid   ptype = exprType((Node *) rexpr->retexpr);

 Assert(rexpr->retlevelsup > 0 && rexpr->retlevelsup < root->query_level);

 /* Find the query level the ReturningExpr belongs to */
 for (levelsup = rexpr->retlevelsup; levelsup > 0; levelsup--)
  root = root->parent_root;

 /*
  * It does not seem worthwhile to try to de-duplicate references to outer
  * ReturningExprs.  Just make a new slot every time.
 */
 rexpr = copyObject(rexpr);
 IncrementVarSublevelsUp((Node *) rexpr, -((int) rexpr->retlevelsup), 0);
 Assert(rexpr->retlevelsup == 0);

 pitem = makeNode(PlannerParamItem);
 pitem->item = (Node *) rexpr;
 pitem->paramId = list_length(root->glob->paramExecTypes);
 root->glob->paramExecTypes = lappend_oid(root->glob->paramExecTypes,
            ptype);

 root->plan_params = lappend(root->plan_params, pitem);

 retval = makeNode(Param);
 retval->paramkind = PARAM_EXEC;
 retval->paramid = pitem->paramId;
 retval->paramtype = ptype;
 retval->paramtypmod = exprTypmod((Node *) rexpr->retexpr);
 retval->paramcollid = exprCollation((Node *) rexpr->retexpr);
 retval->location = exprLocation((Node *) rexpr->retexpr);

 return retval;
}

/*
 * Generate a Param node to replace the given Var,
 * which is expected to come from some upper NestLoop plan node.
 * Record the need for the Var in root->curOuterParams.
 */
Param *
replace_nestloop_param_var(PlannerInfo *root, Var *var)
{
 Param    *param;
 NestLoopParam *nlp;
 ListCell   *lc;

 /* Is this Var already listed in root->curOuterParams? */
 foreach(lc, root->curOuterParams)
 {
  nlp = (NestLoopParam *) lfirst(lc);
  if (equal(var, nlp->paramval))
  {
   /* Yes, so just make a Param referencing this NLP's slot */
   param = makeNode(Param);
   param->paramkind = PARAM_EXEC;
   param->paramid = nlp->paramno;
   param->paramtype = var->vartype;
   param->paramtypmod = var->vartypmod;
   param->paramcollid = var->varcollid;
   param->location = var->location;
   return param;
  }
 }

 /* No, so assign a PARAM_EXEC slot for a new NLP */
 param = generate_new_exec_param(root,
         var->vartype,
         var->vartypmod,
         var->varcollid);
 param->location = var->location;

 /* Add it to the list of required NLPs */
 nlp = makeNode(NestLoopParam);
 nlp->paramno = param->paramid;
 nlp->paramval = copyObject(var);
 root->curOuterParams = lappend(root->curOuterParams, nlp);

 /* And return the replacement Param */
 return param;
}

/*
 * Generate a Param node to replace the given PlaceHolderVar,
 * which is expected to come from some upper NestLoop plan node.
 * Record the need for the PHV in root->curOuterParams.
 *
 * This is just like replace_nestloop_param_var, except for PlaceHolderVars.
 */
Param *
replace_nestloop_param_placeholdervar(PlannerInfo *root, PlaceHolderVar *phv)
{
 Param    *param;
 NestLoopParam *nlp;
 ListCell   *lc;

 /* Is this PHV already listed in root->curOuterParams? */
 foreach(lc, root->curOuterParams)
 {
  nlp = (NestLoopParam *) lfirst(lc);
  if (equal(phv, nlp->paramval))
  {
   /* Yes, so just make a Param referencing this NLP's slot */
   param = makeNode(Param);
   param->paramkind = PARAM_EXEC;
   param->paramid = nlp->paramno;
   param->paramtype = exprType((Node *) phv->phexpr);
   param->paramtypmod = exprTypmod((Node *) phv->phexpr);
   param->paramcollid = exprCollation((Node *) phv->phexpr);
   param->location = -1;
   return param;
  }
 }

 /* No, so assign a PARAM_EXEC slot for a new NLP */
 param = generate_new_exec_param(root,
         exprType((Node *) phv->phexpr),
         exprTypmod((Node *) phv->phexpr),
         exprCollation((Node *) phv->phexpr));

 /* Add it to the list of required NLPs */
 nlp = makeNode(NestLoopParam);
 nlp->paramno = param->paramid;
 nlp->paramval = (Var *) copyObject(phv);
 root->curOuterParams = lappend(root->curOuterParams, nlp);

 /* And return the replacement Param */
 return param;
}

/*
 * process_subquery_nestloop_params
 *   Handle params of a parameterized subquery that need to be fed
 *   from an outer nestloop.
 *
 * Currently, that would be *all* params that a subquery in FROM has demanded
 * from the current query level, since they must be LATERAL references.
 *
 * subplan_params is a list of PlannerParamItems that we intend to pass to
 * a subquery-in-FROM.  (This was constructed in root->plan_params while
 * planning the subquery, but isn't there anymore when this is called.)
 *
 * The subplan's references to the outer variables are already represented
 * as PARAM_EXEC Params, since that conversion was done by the routines above
 * while planning the subquery.  So we need not modify the subplan or the
 * PlannerParamItems here.  What we do need to do is add entries to
 * root->curOuterParams to signal the parent nestloop plan node that it must
 * provide these values.  This differs from replace_nestloop_param_var in
 * that the PARAM_EXEC slots to use have already been determined.
 *
 * Note that we also use root->curOuterRels as an implicit parameter for
 * sanity checks.
 */
void
process_subquery_nestloop_params(PlannerInfo *root, List *subplan_params)
{
 ListCell   *lc;

 foreach(lc, subplan_params)
 {
  PlannerParamItem *pitem = lfirst_node(PlannerParamItem, lc);

  if (IsA(pitem->item, Var))
  {
   Var     *var = (Var *) pitem->item;
   NestLoopParam *nlp;
   ListCell   *lc2;

   /* If not from a nestloop outer rel, complain */
   if (!bms_is_member(var->varno, root->curOuterRels))
    elog(ERROR, "non-LATERAL parameter required by subquery");

   /* Is this param already listed in root->curOuterParams? */
   foreach(lc2, root->curOuterParams)
   {
    nlp = (NestLoopParam *) lfirst(lc2);
    if (nlp->paramno == pitem->paramId)
    {
     Assert(equal(var, nlp->paramval));
     /* Present, so nothing to do */
     break;
    }
   }
   if (lc2 == NULL)
   {
    /* No, so add it */
    nlp = makeNode(NestLoopParam);
    nlp->paramno = pitem->paramId;
    nlp->paramval = copyObject(var);
    root->curOuterParams = lappend(root->curOuterParams, nlp);
   }
  }
  else if (IsA(pitem->item, PlaceHolderVar))
  {
   PlaceHolderVar *phv = (PlaceHolderVar *) pitem->item;
   NestLoopParam *nlp;
   ListCell   *lc2;

   /* If not from a nestloop outer rel, complain */
   if (!bms_is_subset(find_placeholder_info(root, phv)->ph_eval_at,
          root->curOuterRels))
    elog(ERROR, "non-LATERAL parameter required by subquery");

   /* Is this param already listed in root->curOuterParams? */
   foreach(lc2, root->curOuterParams)
   {
    nlp = (NestLoopParam *) lfirst(lc2);
    if (nlp->paramno == pitem->paramId)
    {
     Assert(equal(phv, nlp->paramval));
     /* Present, so nothing to do */
     break;
    }
   }
   if (lc2 == NULL)
   {
    /* No, so add it */
    nlp = makeNode(NestLoopParam);
    nlp->paramno = pitem->paramId;
    nlp->paramval = (Var *) copyObject(phv);
    root->curOuterParams = lappend(root->curOuterParams, nlp);
   }
  }
  else
   elog(ERROR, "unexpected type of subquery parameter");
 }
}

/*
 * Identify any NestLoopParams that should be supplied by a NestLoop
 * plan node with the specified lefthand rels and required-outer rels.
 * Remove them from the active root->curOuterParams list and return
 * them as the result list.
 *
 * Vars and PHVs appearing in the result list must have nullingrel sets
 * that could validly appear in the lefthand rel's output.  Ordinarily that
 * would be true already, but if we have applied outer join identity 3,
 * there could be more or fewer nullingrel bits in the nodes appearing in
 * curOuterParams than are in the nominal leftrelids.  We deal with that by
 * forcing their nullingrel sets to include exactly the outer-join relids
 * that appear in leftrelids and can null the respective Var or PHV.
 * This fix is a bit ad-hoc and intellectually unsatisfactory, because it's
 * essentially jumping to the conclusion that we've placed evaluation of
 * the nestloop parameters correctly, and thus it defeats the intent of the
 * subsequent nullingrel cross-checks in setrefs.c.  But the alternative
 * seems to be to generate multiple versions of each laterally-parameterized
 * subquery, which'd be unduly expensive.
 */
List *
identify_current_nestloop_params(PlannerInfo *root,
         Relids leftrelids,
         Relids outerrelids)
{
 List    *result;
 Relids  allleftrelids;
 ListCell   *cell;

 /*
  * We'll be able to evaluate a PHV in the lefthand path if it uses the
  * lefthand rels plus any available required-outer rels.  But don't do so
  * if it uses *only* required-outer rels; in that case it should be
  * evaluated higher in the tree.  For Vars, no such hair-splitting is
  * necessary since they depend on only one relid.
 */
 if (outerrelids)
  allleftrelids = bms_union(leftrelids, outerrelids);
 else
  allleftrelids = leftrelids;

 result = NIL;
 foreach(cell, root->curOuterParams)
 {
  NestLoopParam *nlp = (NestLoopParam *) lfirst(cell);

  /*
   * We are looking for Vars and PHVs that can be supplied by the
   * lefthand rels.  When we find one, it's okay to modify it in-place
   * because all the routines above make a fresh copy to put into
   * curOuterParams.
 */
  if (IsA(nlp->paramval, Var) &&
   bms_is_member(nlp->paramval->varno, leftrelids))
  {
   Var     *var = (Var *) nlp->paramval;
   RelOptInfo *rel = root->simple_rel_array[var->varno];

   root->curOuterParams = foreach_delete_current(root->curOuterParams,
                cell);
   var->varnullingrels = bms_intersect(rel->nulling_relids,
            leftrelids);
   result = lappend(result, nlp);
  }
  else if (IsA(nlp->paramval, PlaceHolderVar))
  {
   PlaceHolderVar *phv = (PlaceHolderVar *) nlp->paramval;
   PlaceHolderInfo *phinfo = find_placeholder_info(root, phv);
   Relids  eval_at = phinfo->ph_eval_at;

   if (bms_is_subset(eval_at, allleftrelids) &&
    bms_overlap(eval_at, leftrelids))
   {
    root->curOuterParams = foreach_delete_current(root->curOuterParams,
                 cell);

    /*
     * Deal with an edge case: if the PHV was pulled up out of a
     * subquery and it contains a subquery that was originally
     * pushed down from this query level, then that will still be
     * represented as a SubLink, because SS_process_sublinks won't
     * recurse into outer PHVs, so it didn't get transformed
     * during expression preprocessing in the subquery.  We need a
     * version of the PHV that has a SubPlan, which we can get
     * from the current query level's placeholder_list.  This is
     * quite grotty of course, but dealing with it earlier in the
     * handling of subplan params would be just as grotty, and it
     * might end up being a waste of cycles if we don't decide to
     * treat the PHV as a NestLoopParam.  (Perhaps that whole
     * mechanism should be redesigned someday, but today is not
     * that day.)
 */
    if (root->parse->hasSubLinks)
    {
     phv = copyObject(phinfo->ph_var);

     /*
      * The ph_var will have empty nullingrels, but that
      * doesn't matter since we're about to overwrite
      * phv->phnullingrels.  Other fields should be OK already.
 */
     nlp->paramval = (Var *) phv;
    }

    phv->phnullingrels =
     bms_intersect(get_placeholder_nulling_relids(root, phinfo),
          leftrelids);

    result = lappend(result, nlp);
   }
  }
 }
 return result;
}

/*
 * Generate a new Param node that will not conflict with any other.
 *
 * This is used to create Params representing subplan outputs or
 * NestLoop parameters.
 *
 * We don't need to build a PlannerParamItem for such a Param, but we do
 * need to make sure we record the type in paramExecTypes (otherwise,
 * there won't be a slot allocated for it).
 */
Param *
generate_new_exec_param(PlannerInfo *root, Oid paramtype, int32 paramtypmod,
      Oid paramcollation)
{
 Param    *retval;

 retval = makeNode(Param);
 retval->paramkind = PARAM_EXEC;
 retval->paramid = list_length(root->glob->paramExecTypes);
 root->glob->paramExecTypes = lappend_oid(root->glob->paramExecTypes,
            paramtype);
 retval->paramtype = paramtype;
 retval->paramtypmod = paramtypmod;
 retval->paramcollid = paramcollation;
 retval->location = -1;

 return retval;
}

/*
 * Assign a (nonnegative) PARAM_EXEC ID for a special parameter (one that
 * is not actually used to carry a value at runtime).  Such parameters are
 * used for special runtime signaling purposes, such as connecting a
 * recursive union node to its worktable scan node or forcing plan
 * re-evaluation within the EvalPlanQual mechanism.  No actual Param node
 * exists with this ID, however.
 */
int
assign_special_exec_param(PlannerInfo *root)
{
 int   paramId = list_length(root->glob->paramExecTypes);

 root->glob->paramExecTypes = lappend_oid(root->glob->paramExecTypes,
            InvalidOid);
 return paramId;
}