subselect.h File Reference

#include "nodes/pathnodes.h"
#include "nodes/plannodes.h"

Include dependency graph for subselect.h:

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

Go to the source code of this file.

Functions
void	SS_process_ctes (PlannerInfo *root)
ScalarArrayOpExpr *	convert_VALUES_to_ANY (PlannerInfo *root, Node *testexpr, Query *values)
JoinExpr *	convert_ANY_sublink_to_join (PlannerInfo *root, SubLink *sublink, bool under_not, Relids available_rels)
JoinExpr *	convert_EXISTS_sublink_to_join (PlannerInfo *root, SubLink *sublink, bool under_not, Relids available_rels)
Node *	SS_replace_correlation_vars (PlannerInfo *root, Node *expr)
Node *	SS_process_sublinks (PlannerInfo *root, Node *expr, bool isQual)
void	SS_identify_outer_params (PlannerInfo *root)
void	SS_charge_for_initplans (PlannerInfo *root, RelOptInfo *final_rel)
void	SS_compute_initplan_cost (List *init_plans, Cost *initplan_cost_p, bool *unsafe_initplans_p)
void	SS_attach_initplans (PlannerInfo *root, Plan *plan)
void	SS_finalize_plan (PlannerInfo *root, Plan *plan)
Param *	SS_make_initplan_output_param (PlannerInfo *root, Oid resulttype, int32 resulttypmod, Oid resultcollation)
void	SS_make_initplan_from_plan (PlannerInfo *root, PlannerInfo *subroot, Plan *plan, Param *prm)

Function Documentation

convert_ANY_sublink_to_join()

JoinExpr * convert_ANY_sublink_to_join ( PlannerInfo *  root, SubLink *  sublink, bool  under_not, Relids  available_rels  )

extern

Definition at line 1341 of file subselect.c.

{
    JoinExpr   *result;
    Query      *parse = root->parse;
    Query      *subselect = (Query *) sublink->subselect;
    Relids      upper_varnos;
    int         rtindex;
    ParseNamespaceItem *nsitem;
    RangeTblEntry *rte;
    RangeTblRef *rtr;
    List       *subquery_vars;
    Node       *quals;
    ParseState *pstate;
    Relids      sub_ref_outer_relids;
    bool        use_lateral;
 
    Assert(sublink->subLinkType == ANY_SUBLINK);
 
    /*
     * Per SQL spec, NOT IN is not ordinarily equivalent to an anti-join, so
     * that by default we have to fail when under_not.  However, if we can
     * prove that neither the outer query's expressions nor the sub-select's
     * output columns can be NULL, and further that the operator itself cannot
     * return NULL for non-null inputs, then the logic is identical and it's
     * safe to convert NOT IN to an anti-join.
     */
    if (under_not &&
        (!sublink_testexpr_is_not_nullable(root, sublink) ||
         !query_outputs_are_not_nullable(subselect)))
        return NULL;
 
    /*
     * If the sub-select contains any Vars of the parent query, we treat it as
     * LATERAL.  (Vars from higher levels don't matter here.)
     */
    sub_ref_outer_relids = pull_varnos_of_level(NULL, (Node *) subselect, 1);
    use_lateral = !bms_is_empty(sub_ref_outer_relids);
 
    /*
     * Can't convert if the sub-select contains parent-level Vars of relations
     * not in available_rels.
     */
    if (!bms_is_subset(sub_ref_outer_relids, available_rels))
        return NULL;
 
    /*
     * The test expression must contain some Vars of the parent query, else
     * it's not gonna be a join.  (Note that it won't have Vars referring to
     * the subquery, rather Params.)
     */
    upper_varnos = pull_varnos(root, sublink->testexpr);
    if (bms_is_empty(upper_varnos))
        return NULL;
 
    /*
     * However, it can't refer to anything outside available_rels.
     */
    if (!bms_is_subset(upper_varnos, available_rels))
        return NULL;
 
    /*
     * The combining operators and left-hand expressions mustn't be volatile.
     */
    if (contain_volatile_functions(sublink->testexpr))
        return NULL;
 
    /* Create a dummy ParseState for addRangeTableEntryForSubquery */
    pstate = make_parsestate(NULL);
 
    /*
     * Okay, pull up the sub-select into upper range table.
     *
     * We rely here on the assumption that the outer query has no references
     * to the inner (necessarily true, other than the Vars that we build
     * below). Therefore this is a lot easier than what pull_up_subqueries has
     * to go through.
     */
    nsitem = addRangeTableEntryForSubquery(pstate,
                                           subselect,
                                           NULL,
                                           use_lateral,
                                           false);
    rte = nsitem->p_rte;
    parse->rtable = lappend(parse->rtable, rte);
    rtindex = list_length(parse->rtable);
 
    /*
     * Form a RangeTblRef for the pulled-up sub-select.
     */
    rtr = makeNode(RangeTblRef);
    rtr->rtindex = rtindex;
 
    /*
     * Build a list of Vars representing the subselect outputs.
     */
    subquery_vars = generate_subquery_vars(root,
                                           subselect->targetList,
                                           rtindex);
 
    /*
     * Build the new join's qual expression, replacing Params with these Vars.
     */
    quals = convert_testexpr(root, sublink->testexpr, subquery_vars);
 
    /*
     * And finally, build the JoinExpr node.
     */
    result = makeNode(JoinExpr);
    result->jointype = under_not ? JOIN_ANTI : JOIN_SEMI;
    result->isNatural = false;
    result->larg = NULL;        /* caller must fill this in */
    result->rarg = (Node *) rtr;
    result->usingClause = NIL;
    result->join_using_alias = NULL;
    result->quals = quals;
    result->alias = NULL;
    result->rtindex = 0;        /* we don't need an RTE for it */
 
    return result;
}

References addRangeTableEntryForSubquery(), ANY_SUBLINK, Assert, bms_is_empty, bms_is_subset(), contain_volatile_functions(), convert_testexpr(), fb(), generate_subquery_vars(), JOIN_ANTI, JOIN_SEMI, lappend(), list_length(), make_parsestate(), makeNode, NIL, parse(), pull_varnos(), pull_varnos_of_level(), query_outputs_are_not_nullable(), result, root, sublink_testexpr_is_not_nullable(), and Query::targetList.

Referenced by pull_up_sublinks_qual_recurse().

convert_EXISTS_sublink_to_join()

JoinExpr * convert_EXISTS_sublink_to_join ( PlannerInfo *  root, SubLink *  sublink, bool  under_not, Relids  available_rels  )

extern

Definition at line 1593 of file subselect.c.

{
    JoinExpr   *result;
    Query      *parse = root->parse;
    Query      *subselect = (Query *) sublink->subselect;
    Node       *whereClause;
    PlannerInfo subroot;
    int         rtoffset;
    int         varno;
    Relids      clause_varnos;
    Relids      upper_varnos;
 
    Assert(sublink->subLinkType == EXISTS_SUBLINK);
 
    /*
     * Can't flatten if it contains WITH.  (We could arrange to pull up the
     * WITH into the parent query's cteList, but that risks changing the
     * semantics, since a WITH ought to be executed once per associated query
     * call.)  Note that convert_ANY_sublink_to_join doesn't have to reject
     * this case, since it just produces a subquery RTE that doesn't have to
     * get flattened into the parent query.
     */
    if (subselect->cteList)
        return NULL;
 
    /*
     * Copy the subquery so we can modify it safely (see comments in
     * make_subplan).
     */
    subselect = copyObject(subselect);
 
    /*
     * See if the subquery can be simplified based on the knowledge that it's
     * being used in EXISTS().  If we aren't able to get rid of its
     * targetlist, we have to fail, because the pullup operation leaves us
     * with noplace to evaluate the targetlist.
     */
    if (!simplify_EXISTS_query(root, subselect))
        return NULL;
 
    /*
     * Separate out the WHERE clause.  (We could theoretically also remove
     * top-level plain JOIN/ON clauses, but it's probably not worth the
     * trouble.)
     */
    whereClause = subselect->jointree->quals;
    subselect->jointree->quals = NULL;
 
    /*
     * The rest of the sub-select must not refer to any Vars of the parent
     * query.  (Vars of higher levels should be okay, though.)
     */
    if (contain_vars_of_level((Node *) subselect, 1))
        return NULL;
 
    /*
     * On the other hand, the WHERE clause must contain some Vars of the
     * parent query, else it's not gonna be a join.
     */
    if (!contain_vars_of_level(whereClause, 1))
        return NULL;
 
    /*
     * We don't risk optimizing if the WHERE clause is volatile, either.
     */
    if (contain_volatile_functions(whereClause))
        return NULL;
 
    /*
     * Scan the rangetable for relation RTEs and retrieve the necessary
     * catalog information for each relation.  Using this information, clear
     * the inh flag for any relation that has no children, collect not-null
     * attribute numbers for any relation that has column not-null
     * constraints, and expand virtual generated columns for any relation that
     * contains them.
     *
     * Note: we construct up an entirely dummy PlannerInfo for use here.  This
     * is fine because only the "glob" and "parse" links will be used in this
     * case.
     *
     * Note: we temporarily assign back the WHERE clause so that any virtual
     * generated column references within it can be expanded.  It should be
     * separated out again afterward.
     */
    MemSet(&subroot, 0, sizeof(subroot));
    subroot.type = T_PlannerInfo;
    subroot.glob = root->glob;
    subroot.parse = subselect;
    subselect->jointree->quals = whereClause;
    subselect = preprocess_relation_rtes(&subroot);
 
    /*
     * Now separate out the WHERE clause again.
     */
    whereClause = subselect->jointree->quals;
    subselect->jointree->quals = NULL;
 
    /*
     * The subquery must have a nonempty jointree, but we can make it so.
     */
    replace_empty_jointree(subselect);
 
    /*
     * Prepare to pull up the sub-select into top range table.
     *
     * We rely here on the assumption that the outer query has no references
     * to the inner (necessarily true). Therefore this is a lot easier than
     * what pull_up_subqueries has to go through.
     *
     * In fact, it's even easier than what convert_ANY_sublink_to_join has to
     * do.  The machinations of simplify_EXISTS_query ensured that there is
     * nothing interesting in the subquery except an rtable and jointree, and
     * even the jointree FromExpr no longer has quals.  So we can just append
     * the rtable to our own and use the FromExpr in our jointree. But first,
     * adjust all level-zero varnos in the subquery to account for the rtable
     * merger.
     */
    rtoffset = list_length(parse->rtable);
    OffsetVarNodes((Node *) subselect, rtoffset, 0);
    OffsetVarNodes(whereClause, rtoffset, 0);
 
    /*
     * Upper-level vars in subquery will now be one level closer to their
     * parent than before; in particular, anything that had been level 1
     * becomes level zero.
     */
    IncrementVarSublevelsUp((Node *) subselect, -1, 1);
    IncrementVarSublevelsUp(whereClause, -1, 1);
 
    /*
     * Now that the WHERE clause is adjusted to match the parent query
     * environment, we can easily identify all the level-zero rels it uses.
     * The ones <= rtoffset belong to the upper query; the ones > rtoffset do
     * not.
     */
    clause_varnos = pull_varnos(root, whereClause);
    upper_varnos = NULL;
    varno = -1;
    while ((varno = bms_next_member(clause_varnos, varno)) >= 0)
    {
        if (varno <= rtoffset)
            upper_varnos = bms_add_member(upper_varnos, varno);
    }
    bms_free(clause_varnos);
    Assert(!bms_is_empty(upper_varnos));
 
    /*
     * Now that we've got the set of upper-level varnos, we can make the last
     * check: only available_rels can be referenced.
     */
    if (!bms_is_subset(upper_varnos, available_rels))
        return NULL;
 
    /*
     * Now we can attach the modified subquery rtable to the parent. This also
     * adds subquery's RTEPermissionInfos into the upper query.
     */
    CombineRangeTables(&parse->rtable, &parse->rteperminfos,
                       subselect->rtable, subselect->rteperminfos);
 
    /*
     * And finally, build the JoinExpr node.
     */
    result = makeNode(JoinExpr);
    result->jointype = under_not ? JOIN_ANTI : JOIN_SEMI;
    result->isNatural = false;
    result->larg = NULL;        /* caller must fill this in */
    /* flatten out the FromExpr node if it's useless */
    if (list_length(subselect->jointree->fromlist) == 1)
        result->rarg = (Node *) linitial(subselect->jointree->fromlist);
    else
        result->rarg = (Node *) subselect->jointree;
    result->usingClause = NIL;
    result->join_using_alias = NULL;
    result->quals = whereClause;
    result->alias = NULL;
    result->rtindex = 0;        /* we don't need an RTE for it */
 
    return result;
}

References Assert, bms_add_member(), bms_free(), bms_is_empty, bms_is_subset(), bms_next_member(), CombineRangeTables(), contain_vars_of_level(), contain_volatile_functions(), copyObject, Query::cteList, EXISTS_SUBLINK, fb(), FromExpr::fromlist, PlannerInfo::glob, IncrementVarSublevelsUp(), JOIN_ANTI, JOIN_SEMI, Query::jointree, linitial, list_length(), makeNode, MemSet, NIL, OffsetVarNodes(), PlannerInfo::parse, parse(), preprocess_relation_rtes(), pull_varnos(), FromExpr::quals, replace_empty_jointree(), result, root, Query::rtable, and simplify_EXISTS_query().

Referenced by pull_up_sublinks_qual_recurse().

convert_VALUES_to_ANY()

ScalarArrayOpExpr * convert_VALUES_to_ANY ( PlannerInfo *  root, Node *  testexpr, Query *  values  )

extern

Definition at line 1232 of file subselect.c.

{
    RangeTblEntry *rte;
    Node       *leftop;
    Node       *rightop;
    Oid         opno;
    ListCell   *lc;
    Oid         inputcollid;
    List       *exprs = NIL;
 
    /*
     * Check we have a binary operator over a single-column subquery with no
     * joins and no LIMIT/OFFSET/ORDER BY clauses.
     */
    if (!IsA(testexpr, OpExpr) ||
        list_length(((OpExpr *) testexpr)->args) != 2 ||
        list_length(values->targetList) > 1 ||
        values->limitCount != NULL ||
        values->limitOffset != NULL ||
        values->sortClause != NIL ||
        list_length(values->rtable) != 1)
        return NULL;
 
    rte = linitial_node(RangeTblEntry, values->rtable);
    leftop = linitial(((OpExpr *) testexpr)->args);
    rightop = lsecond(((OpExpr *) testexpr)->args);
    opno = ((OpExpr *) testexpr)->opno;
    inputcollid = ((OpExpr *) testexpr)->inputcollid;
 
    /*
     * Also, check that only RTE corresponds to VALUES; the list of values has
     * at least two items and no volatile functions.
     */
    if (rte->rtekind != RTE_VALUES ||
        list_length(rte->values_lists) < 2 ||
        contain_volatile_functions((Node *) rte->values_lists))
        return NULL;
 
    foreach(lc, rte->values_lists)
    {
        List       *elem = lfirst(lc);
        Node       *value = linitial(elem);
 
        /*
         * Prepare an evaluation of the right side of the operator with
         * substitution of the given value.
         */
        value = convert_testexpr(root, rightop, list_make1(value));
 
        /*
         * Try to evaluate constant expressions.  We could get Const as a
         * result.
         */
        value = eval_const_expressions(root, value);
 
        /*
         * As we only support constant output arrays, all the items must also
         * be constant.
         */
        if (!IsA(value, Const))
            return NULL;
 
        exprs = lappend(exprs, value);
    }
 
    /* Finally, build ScalarArrayOpExpr at the top of the 'exprs' list. */
    return make_SAOP_expr(opno, leftop, exprType(rightop),
                          linitial_oid(rte->colcollations), inputcollid,
                          exprs, false);
}

References contain_volatile_functions(), convert_testexpr(), eval_const_expressions(), exprType(), fb(), IsA, lappend(), lfirst, linitial, linitial_node, linitial_oid, list_length(), list_make1, lsecond, make_SAOP_expr(), NIL, root, RTE_VALUES, value, and values.

Referenced by pull_up_sublinks_qual_recurse().

SS_attach_initplans()

void SS_attach_initplans ( PlannerInfo *  root, Plan *  plan  )

extern

Definition at line 2536 of file subselect.c.

{
    plan->initPlan = root->init_plans;
}

References plan, and root.

Referenced by create_plan().

SS_charge_for_initplans()

void SS_charge_for_initplans ( PlannerInfo *  root, RelOptInfo *  final_rel  )

extern

Definition at line 2431 of file subselect.c.

{
    Cost        initplan_cost;
    bool        unsafe_initplans;
    ListCell   *lc;
 
    /* Nothing to do if no initPlans */
    if (root->init_plans == NIL)
        return;
 
    /*
     * Compute the cost increment just once, since it will be the same for all
     * Paths.  Also check for parallel-unsafe initPlans.
     */
    SS_compute_initplan_cost(root->init_plans,
                             &initplan_cost, &unsafe_initplans);
 
    /*
     * Now adjust the costs and parallel_safe flags.
     */
    foreach(lc, final_rel->pathlist)
    {
        Path       *path = (Path *) lfirst(lc);
 
        path->startup_cost += initplan_cost;
        path->total_cost += initplan_cost;
        if (unsafe_initplans)
            path->parallel_safe = false;
    }
 
    /*
     * Adjust partial paths' costs too, or forget them entirely if we must
     * consider the rel parallel-unsafe.
     */
    if (unsafe_initplans)
    {
        final_rel->partial_pathlist = NIL;
        final_rel->consider_parallel = false;
    }
    else
    {
        foreach(lc, final_rel->partial_pathlist)
        {
            Path       *path = (Path *) lfirst(lc);
 
            path->startup_cost += initplan_cost;
            path->total_cost += initplan_cost;
        }
    }
 
    /* We needn't do set_cheapest() here, caller will do it */
}

References fb(), lfirst, NIL, Path::parallel_safe, root, SS_compute_initplan_cost(), Path::startup_cost, and Path::total_cost.

Referenced by build_minmax_path(), and subquery_planner().

SS_compute_initplan_cost()

void SS_compute_initplan_cost ( List *  init_plans, Cost *  initplan_cost_p, bool *  unsafe_initplans_p  )

extern

Definition at line 2495 of file subselect.c.

{
    Cost        initplan_cost;
    bool        unsafe_initplans;
    ListCell   *lc;
 
    /*
     * We assume each initPlan gets run once during top plan startup.  This is
     * a conservative overestimate, since in fact an initPlan might be
     * executed later than plan startup, or even not at all.
     */
    initplan_cost = 0;
    unsafe_initplans = false;
    foreach(lc, init_plans)
    {
        SubPlan    *initsubplan = lfirst_node(SubPlan, lc);
 
        initplan_cost += initsubplan->startup_cost + initsubplan->per_call_cost;
        if (!initsubplan->parallel_safe)
            unsafe_initplans = true;
    }
    *initplan_cost_p = initplan_cost;
    *unsafe_initplans_p = unsafe_initplans;
}

References fb(), and lfirst_node.

Referenced by clean_up_removed_plan_level(), materialize_finished_plan(), SS_charge_for_initplans(), and standard_planner().

SS_finalize_plan()

void SS_finalize_plan ( PlannerInfo *  root, Plan *  plan  )

extern

Definition at line 2551 of file subselect.c.

{
    /* No setup needed, just recurse through plan tree. */
    (void) finalize_plan(root, plan, -1, root->outer_params, NULL);
}

References fb(), finalize_plan(), plan, and root.

Referenced by standard_planner().

SS_identify_outer_params()

void SS_identify_outer_params ( PlannerInfo *  root )

extern

Definition at line 2367 of file subselect.c.

{
    Bitmapset  *outer_params;
    PlannerInfo *proot;
    ListCell   *l;
 
    /*
     * If no parameters have been assigned anywhere in the tree, we certainly
     * don't need to do anything here.
     */
    if (root->glob->paramExecTypes == NIL)
        return;
 
    /*
     * Scan all query levels above this one to see which parameters are due to
     * be available from them, either because lower query levels have
     * requested them (via plan_params) or because they will be available from
     * initPlans of those levels.
     */
    outer_params = NULL;
    for (proot = root->parent_root; proot != NULL; proot = proot->parent_root)
    {
        /*
         * Include ordinary Var/PHV/Aggref/GroupingFunc/ReturningExpr params.
         */
        foreach(l, proot->plan_params)
        {
            PlannerParamItem *pitem = (PlannerParamItem *) lfirst(l);
 
            outer_params = bms_add_member(outer_params, pitem->paramId);
        }
        /* Include any outputs of outer-level initPlans */
        foreach(l, proot->init_plans)
        {
            SubPlan    *initsubplan = (SubPlan *) lfirst(l);
            ListCell   *l2;
 
            foreach(l2, initsubplan->setParam)
            {
                outer_params = bms_add_member(outer_params, lfirst_int(l2));
            }
        }
        /* Include worktable ID, if a recursive query is being planned */
        if (proot->wt_param_id >= 0)
            outer_params = bms_add_member(outer_params, proot->wt_param_id);
    }
    root->outer_params = outer_params;
}

References bms_add_member(), fb(), lfirst, lfirst_int, NIL, and root.

Referenced by build_minmax_path(), and subquery_planner().

SS_make_initplan_from_plan()

void SS_make_initplan_from_plan ( PlannerInfo *  root, PlannerInfo *  subroot, Plan *  plan, Param *  prm  )

extern

Definition at line 3312 of file subselect.c.

{
    SubPlan    *node;
 
    /*
     * Add the subplan and its PlannerInfo, as well as a dummy path entry, to
     * the global lists.  Ideally we'd save a real path, but right now our
     * sole caller doesn't build a path that exactly matches the plan.  Since
     * we're not currently going to need the path for an initplan, it's not
     * worth requiring construction of such a path.
     */
    root->glob->subplans = lappend(root->glob->subplans, plan);
    root->glob->subpaths = lappend(root->glob->subpaths, NULL);
    root->glob->subroots = lappend(root->glob->subroots, subroot);
 
    /*
     * Create a SubPlan node and add it to the outer list of InitPlans. Note
     * it has to appear after any other InitPlans it might depend on (see
     * comments in ExecReScan).
     */
    node = makeNode(SubPlan);
    node->subLinkType = EXPR_SUBLINK;
    node->plan_id = list_length(root->glob->subplans);
    node->plan_name = subroot->plan_name;
    node->isInitPlan = true;
    get_first_col_type(plan, &node->firstColType, &node->firstColTypmod,
                       &node->firstColCollation);
    node->parallel_safe = plan->parallel_safe;
    node->setParam = list_make1_int(prm->paramid);
 
    root->init_plans = lappend(root->init_plans, node);
 
    /*
     * The node can't have any inputs (since it's an initplan), so the
     * parParam and args lists remain empty.
     */
 
    /* Set costs of SubPlan using info from the plan tree */
    cost_subplan(subroot, node, plan);
}

References cost_subplan(), EXPR_SUBLINK, fb(), SubPlan::firstColCollation, SubPlan::firstColType, SubPlan::firstColTypmod, get_first_col_type(), SubPlan::isInitPlan, lappend(), list_length(), list_make1_int, makeNode, SubPlan::parallel_safe, plan, SubPlan::plan_id, PlannerInfo::plan_name, SubPlan::plan_name, root, SubPlan::setParam, and SubPlan::subLinkType.

Referenced by create_minmaxagg_plan().

SS_make_initplan_output_param()

Param * SS_make_initplan_output_param ( PlannerInfo *  root, Oid  resulttype, int32  resulttypmod, Oid  resultcollation  )

extern

Definition at line 3296 of file subselect.c.

{
    return generate_new_exec_param(root, resulttype,
                                   resulttypmod, resultcollation);
}

References fb(), generate_new_exec_param(), and root.

Referenced by preprocess_minmax_aggregates().

SS_process_ctes()

void SS_process_ctes ( PlannerInfo *  root )

extern

Definition at line 886 of file subselect.c.

{
    ListCell   *lc;
 
    Assert(root->cte_plan_ids == NIL);
 
    foreach(lc, root->parse->cteList)
    {
        CommonTableExpr *cte = (CommonTableExpr *) lfirst(lc);
        CmdType     cmdType = ((Query *) cte->ctequery)->commandType;
        Query      *subquery;
        PlannerInfo *subroot;
        RelOptInfo *final_rel;
        Path       *best_path;
        Plan       *plan;
        SubPlan    *splan;
        int         paramid;
 
        /*
         * Ignore SELECT CTEs that are not actually referenced anywhere.
         */
        if (cte->cterefcount == 0 && cmdType == CMD_SELECT)
        {
            /* Make a dummy entry in cte_plan_ids */
            root->cte_plan_ids = lappend_int(root->cte_plan_ids, -1);
            continue;
        }
 
        /*
         * Consider inlining the CTE (creating RTE_SUBQUERY RTE(s)) instead of
         * implementing it as a separately-planned CTE.
         *
         * We cannot inline if any of these conditions hold:
         *
         * 1. The user said not to (the CTEMaterializeAlways option).
         *
         * 2. The CTE is recursive.
         *
         * 3. The CTE has side-effects; this includes either not being a plain
         * SELECT, or containing volatile functions.  Inlining might change
         * the side-effects, which would be bad.
         *
         * 4. The CTE is multiply-referenced and contains a self-reference to
         * a recursive CTE outside itself.  Inlining would result in multiple
         * recursive self-references, which we don't support.
         *
         * Otherwise, we have an option whether to inline or not.  That should
         * always be a win if there's just a single reference, but if the CTE
         * is multiply-referenced then it's unclear: inlining adds duplicate
         * computations, but the ability to absorb restrictions from the outer
         * query level could outweigh that.  We do not have nearly enough
         * information at this point to tell whether that's true, so we let
         * the user express a preference.  Our default behavior is to inline
         * only singly-referenced CTEs, but a CTE marked CTEMaterializeNever
         * will be inlined even if multiply referenced.
         *
         * Note: we check for volatile functions last, because that's more
         * expensive than the other tests needed.
         */
        if ((cte->ctematerialized == CTEMaterializeNever ||
             (cte->ctematerialized == CTEMaterializeDefault &&
              cte->cterefcount == 1)) &&
            !cte->cterecursive &&
            cmdType == CMD_SELECT &&
            !contain_dml(cte->ctequery) &&
            (cte->cterefcount <= 1 ||
             !contain_outer_selfref(cte->ctequery)) &&
            !contain_volatile_functions(cte->ctequery))
        {
            inline_cte(root, cte);
            /* Make a dummy entry in cte_plan_ids */
            root->cte_plan_ids = lappend_int(root->cte_plan_ids, -1);
            continue;
        }
 
        /*
         * Copy the source Query node.  Probably not necessary, but let's keep
         * this similar to make_subplan.
         */
        subquery = (Query *) copyObject(cte->ctequery);
 
        /* plan_params should not be in use in current query level */
        Assert(root->plan_params == NIL);
 
        /*
         * Generate Paths for the CTE query.  Always plan for full retrieval
         * --- we don't have enough info to predict otherwise.
         */
        subroot = subquery_planner(root->glob, subquery,
                                   choose_plan_name(root->glob, cte->ctename, false),
                                   root, NULL, cte->cterecursive, 0.0, NULL);
 
        /*
         * Since the current query level doesn't yet contain any RTEs, it
         * should not be possible for the CTE to have requested parameters of
         * this level.
         */
        if (root->plan_params)
            elog(ERROR, "unexpected outer reference in CTE query");
 
        /*
         * Select best Path and turn it into a Plan.  At least for now, there
         * seems no reason to postpone doing that.
         */
        final_rel = fetch_upper_rel(subroot, UPPERREL_FINAL, NULL);
        best_path = final_rel->cheapest_total_path;
 
        plan = create_plan(subroot, best_path);
 
        /*
         * Make a SubPlan node for it.  This is just enough unlike
         * build_subplan that we can't share code.
         *
         * Note: plan_id and cost fields are set further down.
         */
        splan = makeNode(SubPlan);
        splan->subLinkType = CTE_SUBLINK;
        splan->plan_name = subroot->plan_name;
        splan->testexpr = NULL;
        splan->paramIds = NIL;
        get_first_col_type(plan, &splan->firstColType, &splan->firstColTypmod,
                           &splan->firstColCollation);
        splan->useHashTable = false;
        splan->unknownEqFalse = false;
 
        /*
         * CTE scans are not considered for parallelism (cf
         * set_rel_consider_parallel).
         */
        splan->parallel_safe = false;
        splan->setParam = NIL;
        splan->parParam = NIL;
        splan->args = NIL;
 
        /*
         * The node can't have any inputs (since it's an initplan), so the
         * parParam and args lists remain empty.  (It could contain references
         * to earlier CTEs' output param IDs, but CTE outputs are not
         * propagated via the args list.)
         */
 
        /*
         * Assign a param ID to represent the CTE's output.  No ordinary
         * "evaluation" of this param slot ever happens, but we use the param
         * ID for setParam/chgParam signaling just as if the CTE plan were
         * returning a simple scalar output.  (Also, the executor abuses the
         * ParamExecData slot for this param ID for communication among
         * multiple CteScan nodes that might be scanning this CTE.)
         */
        paramid = assign_special_exec_param(root);
        splan->setParam = list_make1_int(paramid);
 
        /*
         * Add the subplan, its path, and its PlannerInfo to the global lists.
         */
        root->glob->subplans = lappend(root->glob->subplans, plan);
        root->glob->subpaths = lappend(root->glob->subpaths, best_path);
        root->glob->subroots = lappend(root->glob->subroots, subroot);
        splan->plan_id = list_length(root->glob->subplans);
 
        root->init_plans = lappend(root->init_plans, splan);
 
        root->cte_plan_ids = lappend_int(root->cte_plan_ids, splan->plan_id);
 
        /* Lastly, fill in the cost estimates for use later */
        cost_subplan(root, splan, plan);
    }
}

References Assert, assign_special_exec_param(), choose_plan_name(), CMD_SELECT, contain_dml(), contain_outer_selfref(), contain_volatile_functions(), copyObject, cost_subplan(), create_plan(), CTE_SUBLINK, CommonTableExpr::ctematerialized, CTEMaterializeDefault, CTEMaterializeNever, CommonTableExpr::ctename, CommonTableExpr::ctequery, elog, ERROR, fb(), fetch_upper_rel(), get_first_col_type(), inline_cte(), lappend(), lappend_int(), lfirst, list_length(), list_make1_int, makeNode, NIL, plan, PlannerInfo::plan_name, root, subquery_planner(), and UPPERREL_FINAL.

Referenced by subquery_planner().

SS_process_sublinks()

Node * SS_process_sublinks ( PlannerInfo *  root, Node *  expr, bool  isQual  )

extern

Definition at line 2209 of file subselect.c.

{
    process_sublinks_context context;
 
    context.root = root;
    context.isTopQual = isQual;
    return process_sublinks_mutator(expr, &context);
}

References fb(), process_sublinks_context::isTopQual, process_sublinks_mutator(), process_sublinks_context::root, and root.

Referenced by build_subplan(), and preprocess_expression().

SS_replace_correlation_vars()

Node * SS_replace_correlation_vars ( PlannerInfo *  root, Node *  expr  )

extern

Definition at line 2154 of file subselect.c.

{
    /* No setup needed for tree walk, so away we go */
    return replace_correlation_vars_mutator(expr, root);
}

References replace_correlation_vars_mutator(), and root.

Referenced by preprocess_expression().