placeholder.c File Reference

#include "postgres.h"
#include "nodes/nodeFuncs.h"
#include "optimizer/cost.h"
#include "optimizer/optimizer.h"
#include "optimizer/pathnode.h"
#include "optimizer/placeholder.h"
#include "optimizer/planmain.h"
#include "utils/lsyscache.h"

Include dependency graph for placeholder.c:

Go to the source code of this file.

Data Structures
struct	contain_placeholder_references_context

Typedefs
typedef struct contain_placeholder_references_context	contain_placeholder_references_context

Functions
static void	find_placeholders_recurse (PlannerInfo *root, Node *jtnode)
static void	find_placeholders_in_expr (PlannerInfo *root, Node *expr)
static bool	contain_placeholder_references_walker (Node *node, contain_placeholder_references_context *context)
static bool	contain_noop_phv_walker (Node *node, void *context)
static Node *	strip_noop_phvs_mutator (Node *node, void *context)
PlaceHolderVar *	make_placeholder_expr (PlannerInfo *root, Expr *expr, Relids phrels)
PlaceHolderInfo *	find_placeholder_info (PlannerInfo *root, PlaceHolderVar *phv)
void	find_placeholders_in_jointree (PlannerInfo *root)
void	fix_placeholder_input_needed_levels (PlannerInfo *root)
void	rebuild_placeholder_attr_needed (PlannerInfo *root)
void	add_placeholders_to_base_rels (PlannerInfo *root)
void	add_placeholders_to_joinrel (PlannerInfo *root, RelOptInfo *joinrel, RelOptInfo *outer_rel, RelOptInfo *inner_rel, SpecialJoinInfo *sjinfo)
bool	contain_placeholder_references_to (PlannerInfo *root, Node *clause, int relid)
Relids	get_placeholder_nulling_relids (PlannerInfo *root, PlaceHolderInfo *phinfo)
Node *	strip_noop_phvs (Node *node)

Typedef Documentation

contain_placeholder_references_context

typedef struct contain_placeholder_references_context contain_placeholder_references_context

Function Documentation

add_placeholders_to_base_rels()

void add_placeholders_to_base_rels

(

PlannerInfo *

root

)

Definition at line 358 of file placeholder.c.

{
    ListCell   *lc;
 
    foreach(lc, root->placeholder_list)
    {
        PlaceHolderInfo *phinfo = (PlaceHolderInfo *) lfirst(lc);
        Relids      eval_at = phinfo->ph_eval_at;
        int         varno;
 
        if (bms_get_singleton_member(eval_at, &varno) &&
            bms_nonempty_difference(phinfo->ph_needed, eval_at))
        {
            RelOptInfo *rel = find_base_rel(root, varno);
 
            /*
             * As in add_vars_to_targetlist(), a value computed at scan level
             * has not yet been nulled by any outer join, so its phnullingrels
             * should be empty.
             */
            Assert(phinfo->ph_var->phnullingrels == NULL);
 
            /* Copying the PHV might be unnecessary here, but be safe */
            rel->reltarget->exprs = lappend(rel->reltarget->exprs,
                                            copyObject(phinfo->ph_var));
            /* reltarget's cost and width fields will be updated later */
        }
    }
}

References Assert, bms_get_singleton_member(), bms_nonempty_difference(), copyObject, PathTarget::exprs, fb(), find_base_rel(), lappend(), lfirst, RelOptInfo::reltarget, and root.

Referenced by query_planner().

add_placeholders_to_joinrel()

void add_placeholders_to_joinrel	(	PlannerInfo *	root,
		RelOptInfo *	joinrel,
		RelOptInfo *	outer_rel,
		RelOptInfo *	inner_rel,
		SpecialJoinInfo *	sjinfo
	)

Definition at line 402 of file placeholder.c.

{
    Relids      relids = joinrel->relids;
    int64       tuple_width = joinrel->reltarget->width;
    ListCell   *lc;
 
    foreach(lc, root->placeholder_list)
    {
        PlaceHolderInfo *phinfo = (PlaceHolderInfo *) lfirst(lc);
 
        /* Is it computable here? */
        if (bms_is_subset(phinfo->ph_eval_at, relids))
        {
            /* Is it still needed above this joinrel? */
            if (bms_nonempty_difference(phinfo->ph_needed, relids))
            {
                /*
                 * Yes, but only add to tlist if it wasn't computed in either
                 * input; otherwise it should be there already.  Also, we
                 * charge the cost of evaluating the contained expression if
                 * the PHV can be computed here but not in either input.  This
                 * is a bit bogus because we make the decision based on the
                 * first pair of possible input relations considered for the
                 * joinrel.  With other pairs, it might be possible to compute
                 * the PHV in one input or the other, and then we'd be double
                 * charging the PHV's cost for some join paths.  For now, live
                 * with that; but we might want to improve it later by
                 * refiguring the reltarget costs for each pair of inputs.
                 */
                if (!bms_is_subset(phinfo->ph_eval_at, outer_rel->relids) &&
                    !bms_is_subset(phinfo->ph_eval_at, inner_rel->relids))
                {
                    /* Copying might be unnecessary here, but be safe */
                    PlaceHolderVar *phv = copyObject(phinfo->ph_var);
                    QualCost    cost;
 
                    /*
                     * It'll start out not nulled by anything.  Joins above
                     * this one might add to its phnullingrels later, in much
                     * the same way as for Vars.
                     */
                    Assert(phv->phnullingrels == NULL);
 
                    joinrel->reltarget->exprs = lappend(joinrel->reltarget->exprs,
                                                        phv);
                    cost_qual_eval_node(&cost, (Node *) phv->phexpr, root);
                    joinrel->reltarget->cost.startup += cost.startup;
                    joinrel->reltarget->cost.per_tuple += cost.per_tuple;
                    tuple_width += phinfo->ph_width;
                }
            }
 
            /*
             * Also adjust joinrel's direct_lateral_relids to include the
             * PHV's source rel(s).  We must do this even if we're not
             * actually going to emit the PHV, otherwise join_is_legal() will
             * reject valid join orderings.  (In principle maybe we could
             * instead remove the joinrel's lateral_relids dependency; but
             * that's complicated to get right, and cases where we're not
             * going to emit the PHV are too rare to justify the work.)
             *
             * In principle we should only do this if the join doesn't yet
             * include the PHV's source rel(s).  But our caller
             * build_join_rel() will clean things up by removing the join's
             * own relids from its direct_lateral_relids, so we needn't
             * account for that here.
             */
            joinrel->direct_lateral_relids =
                bms_add_members(joinrel->direct_lateral_relids,
                                phinfo->ph_lateral);
        }
    }
 
    joinrel->reltarget->width = clamp_width_est(tuple_width);
}

References Assert, bms_add_members(), bms_is_subset(), bms_nonempty_difference(), clamp_width_est(), copyObject, PathTarget::cost, cost_qual_eval_node(), RelOptInfo::direct_lateral_relids, PathTarget::exprs, fb(), lappend(), lfirst, QualCost::per_tuple, RelOptInfo::relids, RelOptInfo::reltarget, root, QualCost::startup, and PathTarget::width.

Referenced by build_join_rel().

contain_noop_phv_walker()

static bool contain_noop_phv_walker ( Node *  node, void *  context  )

static

Definition at line 632 of file placeholder.c.

{
    if (node == NULL)
        return false;
 
    if (IsA(node, PlaceHolderVar))
    {
        PlaceHolderVar *phv = (PlaceHolderVar *) node;
 
        if (bms_is_empty(phv->phnullingrels))
            return true;
    }
 
    return expression_tree_walker(node, contain_noop_phv_walker,
                                  context);
}

References bms_is_empty, contain_noop_phv_walker(), expression_tree_walker, fb(), and IsA.

Referenced by contain_noop_phv_walker(), and strip_noop_phvs().

contain_placeholder_references_to()

bool contain_placeholder_references_to	(	PlannerInfo *	root,
		Node *	clause,
		int	relid
	)

Definition at line 493 of file placeholder.c.

{
    contain_placeholder_references_context context;
 
    /* We can answer quickly in the common case that there's no PHVs at all */
    if (root->glob->lastPHId == 0)
        return false;
    /* Else run the recursive search */
    context.relid = relid;
    context.sublevels_up = 0;
    return contain_placeholder_references_walker(clause, &context);
}

References contain_placeholder_references_walker(), contain_placeholder_references_context::relid, root, and contain_placeholder_references_context::sublevels_up.

Referenced by make_outerjoininfo().

contain_placeholder_references_walker()

static bool contain_placeholder_references_walker ( Node *  node, contain_placeholder_references_context *  context  )

static

Definition at line 508 of file placeholder.c.

{
    if (node == NULL)
        return false;
    if (IsA(node, PlaceHolderVar))
    {
        PlaceHolderVar *phv = (PlaceHolderVar *) node;
 
        /* We should just look through PHVs of other query levels */
        if (phv->phlevelsup == context->sublevels_up)
        {
            /* If phrels matches, we found what we came for */
            if (bms_is_member(context->relid, phv->phrels))
                return true;
 
            /*
             * We should not examine phnullingrels: what we are looking for is
             * references in the contained expression, not OJs that might null
             * the result afterwards.  Also, we don't need to recurse into the
             * contained expression, because phrels should adequately
             * summarize what's in there.  So we're done here.
             */
            return false;
        }
    }
    else if (IsA(node, Query))
    {
        /* Recurse into RTE subquery or not-yet-planned sublink subquery */
        bool        result;
 
        context->sublevels_up++;
        result = query_tree_walker((Query *) node,
                                   contain_placeholder_references_walker,
                                   context,
                                   0);
        context->sublevels_up--;
        return result;
    }
    return expression_tree_walker(node, contain_placeholder_references_walker,
                                  context);
}

References bms_is_member(), contain_placeholder_references_walker(), expression_tree_walker, fb(), IsA, query_tree_walker, contain_placeholder_references_context::relid, result, and contain_placeholder_references_context::sublevels_up.

Referenced by contain_placeholder_references_to(), and contain_placeholder_references_walker().

find_placeholder_info()

PlaceHolderInfo * find_placeholder_info	(	PlannerInfo *	root,
		PlaceHolderVar *	phv
	)

Definition at line 85 of file placeholder.c.

{
    PlaceHolderInfo *phinfo;
    Relids      rels_used;
 
    /* if this ever isn't true, we'd need to be able to look in parent lists */
    Assert(phv->phlevelsup == 0);
 
    /* Use placeholder_array to look up existing PlaceHolderInfo quickly */
    if (phv->phid < root->placeholder_array_size)
        phinfo = root->placeholder_array[phv->phid];
    else
        phinfo = NULL;
    if (phinfo != NULL)
    {
        Assert(phinfo->phid == phv->phid);
        return phinfo;
    }
 
    /* Not found, so create it */
    if (root->placeholdersFrozen)
        elog(ERROR, "too late to create a new PlaceHolderInfo");
 
    phinfo = makeNode(PlaceHolderInfo);
 
    phinfo->phid = phv->phid;
    phinfo->ph_var = copyObject(phv);
 
    /*
     * By convention, phinfo->ph_var->phnullingrels is always empty, since the
     * PlaceHolderInfo represents the initially-calculated state of the
     * PlaceHolderVar.  PlaceHolderVars appearing in the query tree might have
     * varying values of phnullingrels, reflecting outer joins applied above
     * the calculation level.
     */
    phinfo->ph_var->phnullingrels = NULL;
 
    /*
     * Any referenced rels that are outside the PHV's syntactic scope are
     * LATERAL references, which should be included in ph_lateral but not in
     * ph_eval_at.  If no referenced rels are within the syntactic scope,
     * force evaluation at the syntactic location.
     */
    rels_used = pull_varnos(root, (Node *) phv->phexpr);
    phinfo->ph_lateral = bms_difference(rels_used, phv->phrels);
    phinfo->ph_eval_at = bms_int_members(rels_used, phv->phrels);
    /* If no contained vars, force evaluation at syntactic location */
    if (bms_is_empty(phinfo->ph_eval_at))
    {
        phinfo->ph_eval_at = bms_copy(phv->phrels);
        Assert(!bms_is_empty(phinfo->ph_eval_at));
    }
    phinfo->ph_needed = NULL;   /* initially it's unused */
    /* for the moment, estimate width using just the datatype info */
    phinfo->ph_width = get_typavgwidth(exprType((Node *) phv->phexpr),
                                       exprTypmod((Node *) phv->phexpr));
 
    /*
     * Add to both placeholder_list and placeholder_array.  Note: because we
     * store pointers to the PlaceHolderInfos in two data structures, it'd be
     * unsafe to pass the whole placeholder_list structure through
     * expression_tree_mutator or the like --- or at least, you'd have to
     * rebuild the placeholder_array afterwards.
     */
    root->placeholder_list = lappend(root->placeholder_list, phinfo);
 
    if (phinfo->phid >= root->placeholder_array_size)
    {
        /* Must allocate or enlarge placeholder_array */
        int         new_size;
 
        new_size = root->placeholder_array_size ? root->placeholder_array_size * 2 : 8;
        while (phinfo->phid >= new_size)
            new_size *= 2;
        if (root->placeholder_array)
            root->placeholder_array =
                repalloc0_array(root->placeholder_array, PlaceHolderInfo *, root->placeholder_array_size, new_size);
        else
            root->placeholder_array =
                palloc0_array(PlaceHolderInfo *, new_size);
        root->placeholder_array_size = new_size;
    }
    root->placeholder_array[phinfo->phid] = phinfo;
 
    /*
     * The PHV's contained expression may contain other, lower-level PHVs.  We
     * now know we need to get those into the PlaceHolderInfo list, too, so we
     * may as well do that immediately.
     */
    find_placeholders_in_expr(root, (Node *) phinfo->ph_var->phexpr);
 
    return phinfo;
}

References Assert, bms_copy(), bms_difference(), bms_int_members(), bms_is_empty, copyObject, elog, ERROR, exprType(), exprTypmod(), fb(), find_placeholders_in_expr(), get_typavgwidth(), lappend(), makeNode, palloc0_array, pull_varnos(), repalloc0_array, and root.

Referenced by add_vars_to_attr_needed(), add_vars_to_targetlist(), build_joinrel_tlist(), create_lateral_join_info(), extract_lateral_vars_from_PHVs(), find_placeholders_in_expr(), identify_current_nestloop_params(), process_subquery_nestloop_params(), replace_nestloop_params_mutator(), and set_rel_width().

find_placeholders_in_expr()

static void find_placeholders_in_expr ( PlannerInfo *  root, Node *  expr  )

static

Definition at line 259 of file placeholder.c.

{
    List       *vars;
    ListCell   *vl;
 
    /*
     * pull_var_clause does more than we need here, but it'll do and it's
     * convenient to use.
     */
    vars = pull_var_clause(expr,
                           PVC_RECURSE_AGGREGATES |
                           PVC_RECURSE_WINDOWFUNCS |
                           PVC_INCLUDE_PLACEHOLDERS);
    foreach(vl, vars)
    {
        PlaceHolderVar *phv = (PlaceHolderVar *) lfirst(vl);
 
        /* Ignore any plain Vars */
        if (!IsA(phv, PlaceHolderVar))
            continue;
 
        /* Create a PlaceHolderInfo entry if there's not one already */
        (void) find_placeholder_info(root, phv);
    }
    list_free(vars);
}

References fb(), find_placeholder_info(), IsA, lfirst, list_free(), pull_var_clause(), PVC_INCLUDE_PLACEHOLDERS, PVC_RECURSE_AGGREGATES, PVC_RECURSE_WINDOWFUNCS, and root.

Referenced by find_placeholder_info(), and find_placeholders_recurse().

find_placeholders_in_jointree()

void find_placeholders_in_jointree

(

PlannerInfo *

root

)

Definition at line 187 of file placeholder.c.

{
    /* This must be done before freezing the set of PHIs */
    Assert(!root->placeholdersFrozen);
 
    /* We need do nothing if the query contains no PlaceHolderVars */
    if (root->glob->lastPHId != 0)
    {
        /* Start recursion at top of jointree */
        Assert(root->parse->jointree != NULL &&
               IsA(root->parse->jointree, FromExpr));
        find_placeholders_recurse(root, (Node *) root->parse->jointree);
    }
}

References Assert, fb(), find_placeholders_recurse(), IsA, and root.

Referenced by query_planner().

find_placeholders_recurse()

static void find_placeholders_recurse ( PlannerInfo *  root, Node *  jtnode  )

static

Definition at line 209 of file placeholder.c.

{
    if (jtnode == NULL)
        return;
    if (IsA(jtnode, RangeTblRef))
    {
        /* No quals to deal with here */
    }
    else if (IsA(jtnode, FromExpr))
    {
        FromExpr   *f = (FromExpr *) jtnode;
        ListCell   *l;
 
        /*
         * First, recurse to handle child joins.
         */
        foreach(l, f->fromlist)
        {
            find_placeholders_recurse(root, lfirst(l));
        }
 
        /*
         * Now process the top-level quals.
         */
        find_placeholders_in_expr(root, f->quals);
    }
    else if (IsA(jtnode, JoinExpr))
    {
        JoinExpr   *j = (JoinExpr *) jtnode;
 
        /*
         * First, recurse to handle child joins.
         */
        find_placeholders_recurse(root, j->larg);
        find_placeholders_recurse(root, j->rarg);
 
        /* Process the qual clauses */
        find_placeholders_in_expr(root, j->quals);
    }
    else
        elog(ERROR, "unrecognized node type: %d",
             (int) nodeTag(jtnode));
}

References elog, ERROR, fb(), find_placeholders_in_expr(), find_placeholders_recurse(), FromExpr::fromlist, IsA, j, lfirst, nodeTag, FromExpr::quals, and root.

Referenced by find_placeholders_in_jointree(), and find_placeholders_recurse().

fix_placeholder_input_needed_levels()

void fix_placeholder_input_needed_levels

(

PlannerInfo *

root

)

Definition at line 302 of file placeholder.c.

{
    ListCell   *lc;
 
    foreach(lc, root->placeholder_list)
    {
        PlaceHolderInfo *phinfo = (PlaceHolderInfo *) lfirst(lc);
        List       *vars = pull_var_clause((Node *) phinfo->ph_var->phexpr,
                                           PVC_RECURSE_AGGREGATES |
                                           PVC_RECURSE_WINDOWFUNCS |
                                           PVC_INCLUDE_PLACEHOLDERS);
 
        add_vars_to_targetlist(root, vars, phinfo->ph_eval_at);
        list_free(vars);
    }
}

References add_vars_to_targetlist(), fb(), lfirst, list_free(), pull_var_clause(), PVC_INCLUDE_PLACEHOLDERS, PVC_RECURSE_AGGREGATES, PVC_RECURSE_WINDOWFUNCS, and root.

Referenced by query_planner().

get_placeholder_nulling_relids()

Relids get_placeholder_nulling_relids	(	PlannerInfo *	root,
		PlaceHolderInfo *	phinfo
	)

Definition at line 561 of file placeholder.c.

{
    Relids      result = NULL;
    int         relid = -1;
 
    /*
     * Form the union of all potential nulling OJs for each baserel included
     * in ph_eval_at.
     */
    while ((relid = bms_next_member(phinfo->ph_eval_at, relid)) > 0)
    {
        RelOptInfo *rel = root->simple_rel_array[relid];
 
        /* ignore the RTE_GROUP RTE */
        if (relid == root->group_rtindex)
            continue;
 
        if (rel == NULL)        /* must be an outer join */
        {
            Assert(bms_is_member(relid, root->outer_join_rels));
            continue;
        }
        result = bms_add_members(result, rel->nulling_relids);
    }
 
    /* Now remove any OJs already included in ph_eval_at, and we're done. */
    result = bms_del_members(result, phinfo->ph_eval_at);
    return result;
}

References Assert, bms_add_members(), bms_del_members(), bms_is_member(), bms_next_member(), fb(), RelOptInfo::nulling_relids, result, and root.

Referenced by identify_current_nestloop_params().

make_placeholder_expr()

PlaceHolderVar * make_placeholder_expr	(	PlannerInfo *	root,
		Expr *	expr,
		Relids	phrels
	)

Definition at line 56 of file placeholder.c.

{
    PlaceHolderVar *phv = makeNode(PlaceHolderVar);
 
    phv->phexpr = expr;
    phv->phrels = phrels;
    phv->phnullingrels = NULL;  /* caller may change this later */
    phv->phid = ++(root->glob->lastPHId);
    phv->phlevelsup = 0;        /* caller may change this later */
 
    return phv;
}

References fb(), makeNode, and root.

Referenced by add_nullingrels_if_needed(), mark_nullable_by_grouping(), and pullup_replace_vars_callback().

rebuild_placeholder_attr_needed()

void rebuild_placeholder_attr_needed

(

PlannerInfo *

root

)

Definition at line 329 of file placeholder.c.

{
    ListCell   *lc;
 
    foreach(lc, root->placeholder_list)
    {
        PlaceHolderInfo *phinfo = (PlaceHolderInfo *) lfirst(lc);
        List       *vars = pull_var_clause((Node *) phinfo->ph_var->phexpr,
                                           PVC_RECURSE_AGGREGATES |
                                           PVC_RECURSE_WINDOWFUNCS |
                                           PVC_INCLUDE_PLACEHOLDERS);
 
        add_vars_to_attr_needed(root, vars, phinfo->ph_eval_at);
        list_free(vars);
    }
}

References add_vars_to_attr_needed(), fb(), lfirst, list_free(), pull_var_clause(), PVC_INCLUDE_PLACEHOLDERS, PVC_RECURSE_AGGREGATES, PVC_RECURSE_WINDOWFUNCS, and root.

Referenced by remove_leftjoinrel_from_query(), and remove_self_join_rel().

strip_noop_phvs()

Node * strip_noop_phvs

(

Node *

node

)

Definition at line 614 of file placeholder.c.

{
    /* Don't mutate/copy if no target PHVs exist */
    if (!contain_noop_phv_walker(node, NULL))
        return node;
 
    return strip_noop_phvs_mutator(node, NULL);
}

References contain_noop_phv_walker(), fb(), and strip_noop_phvs_mutator().

Referenced by fix_indexqual_operand(), match_boolean_partition_clause(), match_clause_to_partition_key(), and match_index_to_operand().

strip_noop_phvs_mutator()

static Node * strip_noop_phvs_mutator ( Node *  node, void *  context  )

static

Definition at line 657 of file placeholder.c.

{
    if (node == NULL)
        return NULL;
 
    if (IsA(node, PlaceHolderVar))
    {
        PlaceHolderVar *phv = (PlaceHolderVar *) node;
 
        if (bms_is_empty(phv->phnullingrels))
        {
            /* Recurse on its contained expression */
            return strip_noop_phvs_mutator((Node *) phv->phexpr,
                                           context);
        }
 
        /* Otherwise, keep this PHV but check its contained expression */
    }
 
    return expression_tree_mutator(node, strip_noop_phvs_mutator,
                                   context);
}

References bms_is_empty, expression_tree_mutator, fb(), IsA, and strip_noop_phvs_mutator().

Referenced by strip_noop_phvs(), and strip_noop_phvs_mutator().