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)
JoinExpr *	convert_ANY_sublink_to_join (PlannerInfo *root, SubLink *sublink, 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_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,
		Relids	available_rels
	)

Definition at line 1212 of file subselect.c.

References addRangeTableEntryForSubquery(), JoinExpr::alias, ANY_SUBLINK, Assert, bms_is_empty(), bms_is_subset(), contain_vars_of_level(), contain_volatile_functions(), convert_testexpr(), generate_subquery_vars(), JoinExpr::isNatural, JOIN_SEMI, JoinExpr::jointype, lappend(), JoinExpr::larg, list_length(), make_parsestate(), makeAlias(), makeNode, NIL, parse(), PlannerInfo::parse, pull_varnos(), JoinExpr::quals, JoinExpr::rarg, Query::rtable, JoinExpr::rtindex, SubLink::subLinkType, SubLink::subselect, SubLink::testexpr, and JoinExpr::usingClause.

Referenced by pull_up_sublinks_qual_recurse().

{
    JoinExpr   *result;
    Query      *parse = root->parse;
    Query      *subselect = (Query *) sublink->subselect;
    Relids      upper_varnos;
    int         rtindex;
    RangeTblEntry *rte;
    RangeTblRef *rtr;
    List       *subquery_vars;
    Node       *quals;
    ParseState *pstate;

    Assert(sublink->subLinkType == ANY_SUBLINK);

    /*
     * 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;

    /*
     * 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(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.
     */
    rte = addRangeTableEntryForSubquery(pstate,
                                        subselect,
                                        makeAlias("ANY_subquery", NIL),
                                        false,
                                        false);
    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 = JOIN_SEMI;
    result->isNatural = false;
    result->larg = NULL;        /* caller must fill this in */
    result->rarg = (Node *) rtr;
    result->usingClause = NIL;
    result->quals = quals;
    result->alias = NULL;
    result->rtindex = 0;        /* we don't need an RTE for it */

    return result;
}

convert_EXISTS_sublink_to_join()

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

Definition at line 1317 of file subselect.c.

References JoinExpr::alias, Assert, bms_add_member(), bms_first_member(), bms_free(), bms_is_empty(), bms_is_subset(), contain_vars_of_level(), contain_volatile_functions(), copyObject, Query::cteList, EXISTS_SUBLINK, IncrementVarSublevelsUp(), JoinExpr::isNatural, JOIN_ANTI, JOIN_SEMI, Query::jointree, JoinExpr::jointype, JoinExpr::larg, linitial, list_concat(), list_length(), makeNode, NIL, OffsetVarNodes(), parse(), PlannerInfo::parse, pull_varnos(), JoinExpr::quals, FromExpr::quals, JoinExpr::rarg, replace_empty_jointree(), Query::rtable, JoinExpr::rtindex, simplify_EXISTS_query(), SubLink::subLinkType, SubLink::subselect, and JoinExpr::usingClause.

Referenced by pull_up_sublinks_qual_recurse().

{
    JoinExpr   *result;
    Query      *parse = root->parse;
    Query      *subselect = (Query *) sublink->subselect;
    Node       *whereClause;
    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;

    /*
     * 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(whereClause);
    upper_varnos = NULL;
    while ((varno = bms_first_member(clause_varnos)) >= 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 */
    parse->rtable = list_concat(parse->rtable, subselect->rtable);

    /*
     * 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->quals = whereClause;
    result->alias = NULL;
    result->rtindex = 0;        /* we don't need an RTE for it */

    return result;
}

SS_attach_initplans()

void SS_attach_initplans	(	PlannerInfo *	root,
		Plan *	plan
	)

Definition at line 2118 of file subselect.c.

References PlannerInfo::init_plans, and Plan::initPlan.

Referenced by create_plan().

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

SS_charge_for_initplans()

void SS_charge_for_initplans	(	PlannerInfo *	root,
		RelOptInfo *	final_rel
	)

Definition at line 2061 of file subselect.c.

References RelOptInfo::consider_parallel, PlannerInfo::init_plans, lfirst, NIL, Path::parallel_safe, RelOptInfo::partial_pathlist, RelOptInfo::pathlist, SubPlan::per_call_cost, SubPlan::startup_cost, Path::startup_cost, and Path::total_cost.

Referenced by build_minmax_path(), and subquery_planner().

{
    Cost        initplan_cost;
    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.  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;
    foreach(lc, root->init_plans)
    {
        SubPlan    *initsubplan = (SubPlan *) lfirst(lc);

        initplan_cost += initsubplan->startup_cost + initsubplan->per_call_cost;
    }

    /*
     * 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;
        path->parallel_safe = false;
    }

    /*
     * Forget about any partial paths and clear consider_parallel, too;
     * they're not usable if we attached an initPlan.
     */
    final_rel->partial_pathlist = NIL;
    final_rel->consider_parallel = false;

    /* We needn't do set_cheapest() here, caller will do it */
}

SS_finalize_plan()

void SS_finalize_plan	(	PlannerInfo *	root,
		Plan *	plan
	)

Definition at line 2133 of file subselect.c.

References finalize_plan(), and PlannerInfo::outer_params.

Referenced by standard_planner().

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

SS_identify_outer_params()

void SS_identify_outer_params

(

PlannerInfo *

root

)

Definition at line 1999 of file subselect.c.

References bms_add_member(), PlannerInfo::glob, PlannerInfo::init_plans, lfirst, lfirst_int, NIL, PlannerInfo::outer_params, PlannerGlobal::paramExecTypes, PlannerParamItem::paramId, PlannerInfo::parent_root, PlannerInfo::plan_params, SubPlan::setParam, and PlannerInfo::wt_param_id.

Referenced by build_minmax_path(), and subquery_planner().

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

SS_make_initplan_from_plan()

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

Definition at line 2889 of file subselect.c.

References cost_subplan(), EXPR_SUBLINK, SubPlan::firstColCollation, SubPlan::firstColType, SubPlan::firstColTypmod, get_first_col_type(), PlannerInfo::glob, PlannerInfo::init_plans, lappend(), list_length(), list_make1_int, makeNode, Param::paramid, SubPlan::plan_id, SubPlan::plan_name, psprintf(), SubPlan::setParam, SubPlan::subLinkType, PlannerGlobal::subplans, and PlannerGlobal::subroots.

Referenced by create_minmaxagg_plan().

{
    SubPlan    *node;

    /*
     * Add the subplan and its PlannerInfo to the global lists.
     */
    root->glob->subplans = lappend(root->glob->subplans, plan);
    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 = psprintf("InitPlan %d (returns $%d)",
                               node->plan_id, prm->paramid);
    get_first_col_type(plan, &node->firstColType, &node->firstColTypmod,
                       &node->firstColCollation);
    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);
}

SS_make_initplan_output_param()

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

Definition at line 2873 of file subselect.c.

References generate_new_exec_param().

Referenced by preprocess_minmax_aggregates().

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

SS_process_ctes()

void SS_process_ctes

(

PlannerInfo *

root

)

Definition at line 830 of file subselect.c.

References SubPlan::args, Assert, assign_special_exec_param(), RelOptInfo::cheapest_total_path, CMD_SELECT, contain_dml(), contain_outer_selfref(), contain_volatile_functions(), copyObject, cost_subplan(), create_plan(), PlannerInfo::cte_plan_ids, CTE_SUBLINK, Query::cteList, CommonTableExpr::ctematerialized, CTEMaterializeDefault, CTEMaterializeNever, CommonTableExpr::ctename, CommonTableExpr::ctequery, CommonTableExpr::cterecursive, CommonTableExpr::cterefcount, elog, ERROR, fetch_upper_rel(), SubPlan::firstColCollation, SubPlan::firstColType, SubPlan::firstColTypmod, get_first_col_type(), PlannerInfo::glob, PlannerInfo::init_plans, inline_cte(), lappend(), lappend_int(), lfirst, list_length(), list_make1_int, makeNode, NIL, SubPlan::parallel_safe, SubPlan::paramIds, SubPlan::parParam, PlannerInfo::parse, SubPlan::plan_id, SubPlan::plan_name, PlannerInfo::plan_params, psprintf(), SubPlan::setParam, splan, SubPlan::subLinkType, PlannerGlobal::subplans, subquery_planner(), PlannerGlobal::subroots, SubPlan::testexpr, SubPlan::unknownEqFalse, UPPERREL_FINAL, and SubPlan::useHashTable.

Referenced by subquery_planner().

{
    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,
                                   root,
                                   cte->cterecursive, 0.0);

        /*
         * 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, plan_name, and cost fields are set further down.
         */
        splan = makeNode(SubPlan);
        splan->subLinkType = CTE_SUBLINK;
        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), and even if they were, initPlans aren't
         * parallel-safe.
         */
        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 and its PlannerInfo to the global lists.
         */
        root->glob->subplans = lappend(root->glob->subplans, plan);
        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);

        /* Label the subplan for EXPLAIN purposes */
        splan->plan_name = psprintf("CTE %s", cte->ctename);

        /* Lastly, fill in the cost estimates for use later */
        cost_subplan(root, splan, plan);
    }
}

SS_process_sublinks()

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

Definition at line 1852 of file subselect.c.

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

Referenced by build_subplan(), and preprocess_expression().

{
    process_sublinks_context context;

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

SS_replace_correlation_vars()

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

Definition at line 1807 of file subselect.c.

References replace_correlation_vars_mutator().

Referenced by preprocess_expression().

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