paramassign.h File Reference

#include "nodes/pathnodes.h"

Include dependency graph for paramassign.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
Param *	replace_outer_var (PlannerInfo *root, Var *var)
Param *	replace_outer_placeholdervar (PlannerInfo *root, PlaceHolderVar *phv)
Param *	replace_outer_agg (PlannerInfo *root, Aggref *agg)
Param *	replace_outer_grouping (PlannerInfo *root, GroupingFunc *grp)
Param *	replace_outer_merge_support (PlannerInfo *root, MergeSupportFunc *msf)
Param *	replace_outer_returning (PlannerInfo *root, ReturningExpr *rexpr)
Param *	replace_nestloop_param_var (PlannerInfo *root, Var *var)
Param *	replace_nestloop_param_placeholdervar (PlannerInfo *root, PlaceHolderVar *phv)
void	process_subquery_nestloop_params (PlannerInfo *root, List *subplan_params)
List *	identify_current_nestloop_params (PlannerInfo *root, Relids leftrelids, Relids outerrelids)
Param *	generate_new_exec_param (PlannerInfo *root, Oid paramtype, int32 paramtypmod, Oid paramcollation)
int	assign_special_exec_param (PlannerInfo *root)

Function Documentation

assign_special_exec_param()

int assign_special_exec_param

(

PlannerInfo *

root

)

Definition at line 754 of file paramassign.c.

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

References InvalidOid, lappend_oid(), list_length(), and root.

Referenced by create_gather_merge_plan(), create_gather_plan(), grouping_planner(), SS_process_ctes(), and subquery_planner().

generate_new_exec_param()

Param * generate_new_exec_param	(	PlannerInfo *	root,
		Oid	paramtype,
		int32	paramtypmod,
		Oid	paramcollation
	)

Definition at line 727 of file paramassign.c.

{
    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;
}

References lappend_oid(), list_length(), Param::location, makeNode, PARAM_EXEC, Param::paramcollid, Param::paramid, Param::paramkind, Param::paramtype, Param::paramtypmod, and root.

Referenced by build_subplan(), convert_EXISTS_to_ANY(), generate_subquery_params(), replace_nestloop_param_placeholdervar(), replace_nestloop_param_var(), and SS_make_initplan_output_param().

identify_current_nestloop_params()

List * identify_current_nestloop_params	(	PlannerInfo *	root,
		Relids	leftrelids,
		Relids	outerrelids
	)

Definition at line 622 of file paramassign.c.

{
    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;
}

References bms_intersect(), bms_is_member(), bms_is_subset(), bms_overlap(), bms_union(), copyObject, find_placeholder_info(), foreach_delete_current, get_placeholder_nulling_relids(), IsA, lappend(), lfirst, NIL, NestLoopParam::paramval, PlaceHolderVar::phnullingrels, root, and Var::varno.

Referenced by create_nestloop_plan().

process_subquery_nestloop_params()

void process_subquery_nestloop_params	(	PlannerInfo *	root,
		List *	subplan_params
	)

Definition at line 527 of file paramassign.c.

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

References Assert(), bms_is_member(), bms_is_subset(), copyObject, elog, equal(), ERROR, find_placeholder_info(), if(), IsA, PlannerParamItem::item, lappend(), lfirst, lfirst_node, makeNode, PlannerParamItem::paramId, root, and Var::varno.

Referenced by create_subqueryscan_plan().

replace_nestloop_param_placeholdervar()

Param * replace_nestloop_param_placeholdervar	(	PlannerInfo *	root,
		PlaceHolderVar *	phv
	)

Definition at line 463 of file paramassign.c.

{
    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;
}

References copyObject, equal(), exprCollation(), exprType(), exprTypmod(), generate_new_exec_param(), lappend(), lfirst, Param::location, makeNode, PARAM_EXEC, Param::paramcollid, Param::paramid, Param::paramkind, NestLoopParam::paramno, Param::paramtype, Param::paramtypmod, NestLoopParam::paramval, and root.

Referenced by replace_nestloop_params_mutator().

replace_nestloop_param_var()

Param * replace_nestloop_param_var	(	PlannerInfo *	root,
		Var *	var
	)

Definition at line 414 of file paramassign.c.

{
    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;
}

References copyObject, equal(), generate_new_exec_param(), lappend(), lfirst, Var::location, Param::location, makeNode, PARAM_EXEC, Param::paramcollid, Param::paramid, Param::paramkind, NestLoopParam::paramno, Param::paramtype, Param::paramtypmod, NestLoopParam::paramval, and root.

Referenced by replace_nestloop_params_mutator().

replace_outer_agg()

Param * replace_outer_agg	(	PlannerInfo *	root,
		Aggref *	agg
	)

Definition at line 225 of file paramassign.c.

{
    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;
}

References Assert(), copyObject, IncrementVarSublevelsUp(), PlannerParamItem::item, lappend(), lappend_oid(), list_length(), Param::location, Aggref::location, makeNode, PARAM_EXEC, Param::paramcollid, PlannerParamItem::paramId, Param::paramid, Param::paramkind, Param::paramtype, Param::paramtypmod, and root.

Referenced by replace_correlation_vars_mutator().

replace_outer_grouping()

Param * replace_outer_grouping	(	PlannerInfo *	root,
		GroupingFunc *	grp
	)

Definition at line 271 of file paramassign.c.

{
    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;
}

References GroupingFunc::agglevelsup, Assert(), copyObject, exprType(), IncrementVarSublevelsUp(), InvalidOid, PlannerParamItem::item, lappend(), lappend_oid(), list_length(), Param::location, GroupingFunc::location, makeNode, PARAM_EXEC, Param::paramcollid, PlannerParamItem::paramId, Param::paramid, Param::paramkind, Param::paramtype, Param::paramtypmod, and root.

Referenced by replace_correlation_vars_mutator().

replace_outer_merge_support()

Param * replace_outer_merge_support	(	PlannerInfo *	root,
		MergeSupportFunc *	msf
	)

Definition at line 318 of file paramassign.c.

{
    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;
}

References Assert(), CMD_MERGE, copyObject, elog, ERROR, exprType(), InvalidOid, PlannerParamItem::item, lappend(), lappend_oid(), list_length(), Param::location, MergeSupportFunc::location, makeNode, PARAM_EXEC, Param::paramcollid, PlannerParamItem::paramId, Param::paramid, Param::paramkind, Param::paramtype, Param::paramtypmod, and root.

Referenced by replace_correlation_vars_mutator().

replace_outer_placeholdervar()

Param * replace_outer_placeholdervar	(	PlannerInfo *	root,
		PlaceHolderVar *	phv
	)

Definition at line 198 of file paramassign.c.

{
    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;
}

References Assert(), assign_param_for_placeholdervar(), exprCollation(), exprType(), exprTypmod(), i, Param::location, makeNode, PARAM_EXEC, Param::paramcollid, Param::paramid, Param::paramkind, Param::paramtype, Param::paramtypmod, PlaceHolderVar::phlevelsup, and root.

Referenced by replace_correlation_vars_mutator().

replace_outer_returning()

Param * replace_outer_returning	(	PlannerInfo *	root,
		ReturningExpr *	rexpr
	)

Definition at line 368 of file paramassign.c.

{
    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;
}

References Assert(), copyObject, exprCollation(), exprLocation(), exprType(), exprTypmod(), IncrementVarSublevelsUp(), PlannerParamItem::item, lappend(), lappend_oid(), list_length(), Param::location, makeNode, PARAM_EXEC, Param::paramcollid, PlannerParamItem::paramId, Param::paramid, Param::paramkind, Param::paramtype, Param::paramtypmod, ReturningExpr::retexpr, ReturningExpr::retlevelsup, and root.

Referenced by replace_correlation_vars_mutator().

replace_outer_var()

Param * replace_outer_var	(	PlannerInfo *	root,
		Var *	var
	)

Definition at line 121 of file paramassign.c.

{
    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;
}

References Assert(), assign_param_for_var(), i, Var::location, Param::location, makeNode, PARAM_EXEC, Param::paramcollid, Param::paramid, Param::paramkind, Param::paramtype, Param::paramtypmod, root, and Var::varlevelsup.

Referenced by replace_correlation_vars_mutator().