planmain.h File Reference

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

Include dependency graph for planmain.h:

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

Go to the source code of this file.

Macros
#define	DEFAULT_CURSOR_TUPLE_FRACTION   0.1

Typedefs
typedef void(*	query_pathkeys_callback) (PlannerInfo *root, void *extra)

Functions
RelOptInfo *	query_planner (PlannerInfo *root, query_pathkeys_callback qp_callback, void *qp_extra)
void	preprocess_minmax_aggregates (PlannerInfo *root)
Plan *	create_plan (PlannerInfo *root, Path *best_path)
ForeignScan *	make_foreignscan (List *qptlist, List *qpqual, Index scanrelid, List *fdw_exprs, List *fdw_private, List *fdw_scan_tlist, List *fdw_recheck_quals, Plan *outer_plan)
Plan *	change_plan_targetlist (Plan *subplan, List *tlist, bool tlist_parallel_safe)
Plan *	materialize_finished_plan (Plan *subplan)
bool	is_projection_capable_path (Path *path)
bool	is_projection_capable_plan (Plan *plan)
Sort *	make_sort_from_sortclauses (List *sortcls, Plan *lefttree)
Agg *	make_agg (List *tlist, List *qual, AggStrategy aggstrategy, AggSplit aggsplit, int numGroupCols, AttrNumber *grpColIdx, Oid *grpOperators, Oid *grpCollations, List *groupingSets, List *chain, double dNumGroups, Size transitionSpace, Plan *lefttree)
Limit *	make_limit (Plan *lefttree, Node *limitOffset, Node *limitCount, LimitOption limitOption, int uniqNumCols, AttrNumber *uniqColIdx, Oid *uniqOperators, Oid *uniqCollations)
void	add_base_rels_to_query (PlannerInfo *root, Node *jtnode)
void	add_other_rels_to_query (PlannerInfo *root)
void	build_base_rel_tlists (PlannerInfo *root, List *final_tlist)
void	add_vars_to_targetlist (PlannerInfo *root, List *vars, Relids where_needed, bool create_new_ph)
void	find_lateral_references (PlannerInfo *root)
void	create_lateral_join_info (PlannerInfo *root)
List *	deconstruct_jointree (PlannerInfo *root)
void	distribute_restrictinfo_to_rels (PlannerInfo *root, RestrictInfo *restrictinfo)
RestrictInfo *	process_implied_equality (PlannerInfo *root, Oid opno, Oid collation, Expr *item1, Expr *item2, Relids qualscope, Relids nullable_relids, Index security_level, bool below_outer_join, bool both_const)
RestrictInfo *	build_implied_join_equality (PlannerInfo *root, Oid opno, Oid collation, Expr *item1, Expr *item2, Relids qualscope, Relids nullable_relids, Index security_level)
void	match_foreign_keys_to_quals (PlannerInfo *root)
List *	remove_useless_joins (PlannerInfo *root, List *joinlist)
void	reduce_unique_semijoins (PlannerInfo *root)
bool	query_supports_distinctness (Query *query)
bool	query_is_distinct_for (Query *query, List *colnos, List *opids)
bool	innerrel_is_unique (PlannerInfo *root, Relids joinrelids, Relids outerrelids, RelOptInfo *innerrel, JoinType jointype, List *restrictlist, bool force_cache)
Plan *	set_plan_references (PlannerInfo *root, Plan *plan)
void	record_plan_function_dependency (PlannerInfo *root, Oid funcid)
void	record_plan_type_dependency (PlannerInfo *root, Oid typid)
bool	extract_query_dependencies_walker (Node *node, PlannerInfo *root)

Variables
double	cursor_tuple_fraction
int	from_collapse_limit
int	join_collapse_limit

Macro Definition Documentation

DEFAULT_CURSOR_TUPLE_FRACTION

#define DEFAULT_CURSOR_TUPLE_FRACTION   0.1

Definition at line 21 of file planmain.h.

Typedef Documentation

query_pathkeys_callback

typedef void(* query_pathkeys_callback) (PlannerInfo *root, void *extra)

Definition at line 25 of file planmain.h.

Function Documentation

add_base_rels_to_query()

void add_base_rels_to_query	(	PlannerInfo *	root,
		Node *	jtnode
	)

Definition at line 106 of file initsplan.c.

References add_base_rels_to_query(), build_simple_rel(), elog, ERROR, FromExpr::fromlist, IsA, JoinExpr::larg, lfirst, nodeTag, and JoinExpr::rarg.

Referenced by add_base_rels_to_query(), and query_planner().

{
    if (jtnode == NULL)
        return;
    if (IsA(jtnode, RangeTblRef))
    {
        int         varno = ((RangeTblRef *) jtnode)->rtindex;

        (void) build_simple_rel(root, varno, NULL);
    }
    else if (IsA(jtnode, FromExpr))
    {
        FromExpr   *f = (FromExpr *) jtnode;
        ListCell   *l;

        foreach(l, f->fromlist)
            add_base_rels_to_query(root, lfirst(l));
    }
    else if (IsA(jtnode, JoinExpr))
    {
        JoinExpr   *j = (JoinExpr *) jtnode;

        add_base_rels_to_query(root, j->larg);
        add_base_rels_to_query(root, j->rarg);
    }
    else
        elog(ERROR, "unrecognized node type: %d",
             (int) nodeTag(jtnode));
}

add_other_rels_to_query()

void add_other_rels_to_query

(

PlannerInfo *

root

)

Definition at line 144 of file initsplan.c.

References expand_inherited_rtentry(), RangeTblEntry::inh, RELOPT_BASEREL, RelOptInfo::reloptkind, PlannerInfo::simple_rel_array, PlannerInfo::simple_rel_array_size, and PlannerInfo::simple_rte_array.

Referenced by query_planner().

{
    int         rti;

    for (rti = 1; rti < root->simple_rel_array_size; rti++)
    {
        RelOptInfo *rel = root->simple_rel_array[rti];
        RangeTblEntry *rte = root->simple_rte_array[rti];

        /* there may be empty slots corresponding to non-baserel RTEs */
        if (rel == NULL)
            continue;

        /* Ignore any "otherrels" that were already added. */
        if (rel->reloptkind != RELOPT_BASEREL)
            continue;

        /* If it's marked as inheritable, look for children. */
        if (rte->inh)
            expand_inherited_rtentry(root, rel, rte, rti);
    }
}

add_vars_to_targetlist()

void add_vars_to_targetlist	(	PlannerInfo *	root,
		List *	vars,
		Relids	where_needed,
		bool	create_new_ph
	)

Definition at line 230 of file initsplan.c.

References Assert, RelOptInfo::attr_needed, bms_add_members(), bms_is_empty(), bms_is_subset(), copyObject, elog, ERROR, PathTarget::exprs, find_base_rel(), find_placeholder_info(), IsA, lappend(), lfirst, RelOptInfo::min_attr, nodeTag, PlaceHolderInfo::ph_needed, RelOptInfo::relids, RelOptInfo::reltarget, Var::varattno, and Var::varno.

Referenced by build_base_rel_tlists(), distribute_qual_to_rels(), expand_inherited_rtentry(), extract_lateral_references(), fix_placeholder_input_needed_levels(), generate_base_implied_equalities_no_const(), and process_implied_equality().

{
    ListCell   *temp;

    Assert(!bms_is_empty(where_needed));

    foreach(temp, vars)
    {
        Node       *node = (Node *) lfirst(temp);

        if (IsA(node, Var))
        {
            Var        *var = (Var *) node;
            RelOptInfo *rel = find_base_rel(root, var->varno);
            int         attno = var->varattno;

            if (bms_is_subset(where_needed, rel->relids))
                continue;
            Assert(attno >= rel->min_attr && attno <= rel->max_attr);
            attno -= rel->min_attr;
            if (rel->attr_needed[attno] == NULL)
            {
                /* Variable not yet requested, so add to rel's targetlist */
                /* XXX is copyObject necessary here? */
                rel->reltarget->exprs = lappend(rel->reltarget->exprs,
                                                copyObject(var));
                /* reltarget cost and width will be computed later */
            }
            rel->attr_needed[attno] = bms_add_members(rel->attr_needed[attno],
                                                      where_needed);
        }
        else if (IsA(node, PlaceHolderVar))
        {
            PlaceHolderVar *phv = (PlaceHolderVar *) node;
            PlaceHolderInfo *phinfo = find_placeholder_info(root, phv,
                                                            create_new_ph);

            phinfo->ph_needed = bms_add_members(phinfo->ph_needed,
                                                where_needed);
        }
        else
            elog(ERROR, "unrecognized node type: %d", (int) nodeTag(node));
    }
}

build_base_rel_tlists()

void build_base_rel_tlists	(	PlannerInfo *	root,
		List *	final_tlist
	)

Definition at line 183 of file initsplan.c.

References add_vars_to_targetlist(), bms_make_singleton(), Query::havingQual, list_free(), NIL, PlannerInfo::parse, pull_var_clause(), PVC_INCLUDE_PLACEHOLDERS, PVC_RECURSE_AGGREGATES, and PVC_RECURSE_WINDOWFUNCS.

Referenced by query_planner().

{
    List       *tlist_vars = pull_var_clause((Node *) final_tlist,
                                             PVC_RECURSE_AGGREGATES |
                                             PVC_RECURSE_WINDOWFUNCS |
                                             PVC_INCLUDE_PLACEHOLDERS);

    if (tlist_vars != NIL)
    {
        add_vars_to_targetlist(root, tlist_vars, bms_make_singleton(0), true);
        list_free(tlist_vars);
    }

    /*
     * If there's a HAVING clause, we'll need the Vars it uses, too.  Note
     * that HAVING can contain Aggrefs but not WindowFuncs.
     */
    if (root->parse->havingQual)
    {
        List       *having_vars = pull_var_clause(root->parse->havingQual,
                                                  PVC_RECURSE_AGGREGATES |
                                                  PVC_INCLUDE_PLACEHOLDERS);

        if (having_vars != NIL)
        {
            add_vars_to_targetlist(root, having_vars,
                                   bms_make_singleton(0), true);
            list_free(having_vars);
        }
    }
}

build_implied_join_equality()

RestrictInfo* build_implied_join_equality	(	PlannerInfo *	root,
		Oid	opno,
		Oid	collation,
		Expr *	item1,
		Expr *	item2,
		Relids	qualscope,
		Relids	nullable_relids,
		Index	security_level
	)

Definition at line 2422 of file initsplan.c.

References check_hashjoinable(), check_memoizable(), check_mergejoinable(), copyObject, InvalidOid, make_opclause(), and make_restrictinfo().

Referenced by create_join_clause(), reconsider_full_join_clause(), and reconsider_outer_join_clause().

{
    RestrictInfo *restrictinfo;
    Expr       *clause;

    /*
     * Build the new clause.  Copy to ensure it shares no substructure with
     * original (this is necessary in case there are subselects in there...)
     */
    clause = make_opclause(opno,
                           BOOLOID, /* opresulttype */
                           false,   /* opretset */
                           copyObject(item1),
                           copyObject(item2),
                           InvalidOid,
                           collation);

    /*
     * Build the RestrictInfo node itself.
     */
    restrictinfo = make_restrictinfo(root,
                                     clause,
                                     true,  /* is_pushed_down */
                                     false, /* outerjoin_delayed */
                                     false, /* pseudoconstant */
                                     security_level,    /* security_level */
                                     qualscope, /* required_relids */
                                     NULL,  /* outer_relids */
                                     nullable_relids);  /* nullable_relids */

    /* Set mergejoinability/hashjoinability flags */
    check_mergejoinable(restrictinfo);
    check_hashjoinable(restrictinfo);
    check_memoizable(restrictinfo);

    return restrictinfo;
}

change_plan_targetlist()

Plan* change_plan_targetlist	(	Plan *	subplan,
		List *	tlist,
		bool	tlist_parallel_safe
	)

Definition at line 2067 of file createplan.c.

References inject_projection_plan(), is_projection_capable_plan(), Plan::parallel_safe, Plan::targetlist, and tlist_same_exprs().

Referenced by create_unique_plan(), and postgresGetForeignPlan().

{
    /*
     * If the top plan node can't do projections and its existing target list
     * isn't already what we need, we need to add a Result node to help it
     * along.
     */
    if (!is_projection_capable_plan(subplan) &&
        !tlist_same_exprs(tlist, subplan->targetlist))
        subplan = inject_projection_plan(subplan, tlist,
                                         subplan->parallel_safe &&
                                         tlist_parallel_safe);
    else
    {
        /* Else we can just replace the plan node's tlist */
        subplan->targetlist = tlist;
        subplan->parallel_safe &= tlist_parallel_safe;
    }
    return subplan;
}

create_lateral_join_info()

void create_lateral_join_info

(

PlannerInfo *

root

)

Definition at line 450 of file initsplan.c.

References Assert, bms_add_member(), bms_add_members(), bms_copy(), bms_get_singleton_member(), bms_is_empty(), bms_is_member(), bms_next_member(), RelOptInfo::direct_lateral_relids, find_base_rel(), find_placeholder_info(), PlannerInfo::hasLateralRTEs, IsA, RelOptInfo::lateral_referencers, RelOptInfo::lateral_relids, RelOptInfo::lateral_vars, lfirst, PlaceHolderInfo::ph_eval_at, PlaceHolderInfo::ph_lateral, PlannerInfo::placeholder_list, RelOptInfo::relid, RELOPT_BASEREL, RelOptInfo::reloptkind, PlannerInfo::simple_rel_array, PlannerInfo::simple_rel_array_size, and Var::varno.

Referenced by query_planner().

{
    bool        found_laterals = false;
    Index       rti;
    ListCell   *lc;

    /* We need do nothing if the query contains no LATERAL RTEs */
    if (!root->hasLateralRTEs)
        return;

    /*
     * Examine all baserels (the rel array has been set up by now).
     */
    for (rti = 1; rti < root->simple_rel_array_size; rti++)
    {
        RelOptInfo *brel = root->simple_rel_array[rti];
        Relids      lateral_relids;

        /* there may be empty slots corresponding to non-baserel RTEs */
        if (brel == NULL)
            continue;

        Assert(brel->relid == rti); /* sanity check on array */

        /* ignore RTEs that are "other rels" */
        if (brel->reloptkind != RELOPT_BASEREL)
            continue;

        lateral_relids = NULL;

        /* consider each laterally-referenced Var or PHV */
        foreach(lc, brel->lateral_vars)
        {
            Node       *node = (Node *) lfirst(lc);

            if (IsA(node, Var))
            {
                Var        *var = (Var *) node;

                found_laterals = true;
                lateral_relids = bms_add_member(lateral_relids,
                                                var->varno);
            }
            else if (IsA(node, PlaceHolderVar))
            {
                PlaceHolderVar *phv = (PlaceHolderVar *) node;
                PlaceHolderInfo *phinfo = find_placeholder_info(root, phv,
                                                                false);

                found_laterals = true;
                lateral_relids = bms_add_members(lateral_relids,
                                                 phinfo->ph_eval_at);
            }
            else
                Assert(false);
        }

        /* We now have all the simple lateral refs from this rel */
        brel->direct_lateral_relids = lateral_relids;
        brel->lateral_relids = bms_copy(lateral_relids);
    }

    /*
     * Now check for lateral references within PlaceHolderVars, and mark their
     * eval_at rels as having lateral references to the source rels.
     *
     * For a PHV that is due to be evaluated at a baserel, mark its source(s)
     * as direct lateral dependencies of the baserel (adding onto the ones
     * recorded above).  If it's due to be evaluated at a join, mark its
     * source(s) as indirect lateral dependencies of each baserel in the join,
     * ie put them into lateral_relids but not direct_lateral_relids.  This is
     * appropriate because we can't put any such baserel on the outside of a
     * join to one of the PHV's lateral dependencies, but on the other hand we
     * also can't yet join it directly to the dependency.
     */
    foreach(lc, root->placeholder_list)
    {
        PlaceHolderInfo *phinfo = (PlaceHolderInfo *) lfirst(lc);
        Relids      eval_at = phinfo->ph_eval_at;
        int         varno;

        if (phinfo->ph_lateral == NULL)
            continue;           /* PHV is uninteresting if no lateral refs */

        found_laterals = true;

        if (bms_get_singleton_member(eval_at, &varno))
        {
            /* Evaluation site is a baserel */
            RelOptInfo *brel = find_base_rel(root, varno);

            brel->direct_lateral_relids =
                bms_add_members(brel->direct_lateral_relids,
                                phinfo->ph_lateral);
            brel->lateral_relids =
                bms_add_members(brel->lateral_relids,
                                phinfo->ph_lateral);
        }
        else
        {
            /* Evaluation site is a join */
            varno = -1;
            while ((varno = bms_next_member(eval_at, varno)) >= 0)
            {
                RelOptInfo *brel = find_base_rel(root, varno);

                brel->lateral_relids = bms_add_members(brel->lateral_relids,
                                                       phinfo->ph_lateral);
            }
        }
    }

    /*
     * If we found no actual lateral references, we're done; but reset the
     * hasLateralRTEs flag to avoid useless work later.
     */
    if (!found_laterals)
    {
        root->hasLateralRTEs = false;
        return;
    }

    /*
     * Calculate the transitive closure of the lateral_relids sets, so that
     * they describe both direct and indirect lateral references.  If relation
     * X references Y laterally, and Y references Z laterally, then we will
     * have to scan X on the inside of a nestloop with Z, so for all intents
     * and purposes X is laterally dependent on Z too.
     *
     * This code is essentially Warshall's algorithm for transitive closure.
     * The outer loop considers each baserel, and propagates its lateral
     * dependencies to those baserels that have a lateral dependency on it.
     */
    for (rti = 1; rti < root->simple_rel_array_size; rti++)
    {
        RelOptInfo *brel = root->simple_rel_array[rti];
        Relids      outer_lateral_relids;
        Index       rti2;

        if (brel == NULL || brel->reloptkind != RELOPT_BASEREL)
            continue;

        /* need not consider baserel further if it has no lateral refs */
        outer_lateral_relids = brel->lateral_relids;
        if (outer_lateral_relids == NULL)
            continue;

        /* else scan all baserels */
        for (rti2 = 1; rti2 < root->simple_rel_array_size; rti2++)
        {
            RelOptInfo *brel2 = root->simple_rel_array[rti2];

            if (brel2 == NULL || brel2->reloptkind != RELOPT_BASEREL)
                continue;

            /* if brel2 has lateral ref to brel, propagate brel's refs */
            if (bms_is_member(rti, brel2->lateral_relids))
                brel2->lateral_relids = bms_add_members(brel2->lateral_relids,
                                                        outer_lateral_relids);
        }
    }

    /*
     * Now that we've identified all lateral references, mark each baserel
     * with the set of relids of rels that reference it laterally (possibly
     * indirectly) --- that is, the inverse mapping of lateral_relids.
     */
    for (rti = 1; rti < root->simple_rel_array_size; rti++)
    {
        RelOptInfo *brel = root->simple_rel_array[rti];
        Relids      lateral_relids;
        int         rti2;

        if (brel == NULL || brel->reloptkind != RELOPT_BASEREL)
            continue;

        /* Nothing to do at rels with no lateral refs */
        lateral_relids = brel->lateral_relids;
        if (lateral_relids == NULL)
            continue;

        /*
         * We should not have broken the invariant that lateral_relids is
         * exactly NULL if empty.
         */
        Assert(!bms_is_empty(lateral_relids));

        /* Also, no rel should have a lateral dependency on itself */
        Assert(!bms_is_member(rti, lateral_relids));

        /* Mark this rel's referencees */
        rti2 = -1;
        while ((rti2 = bms_next_member(lateral_relids, rti2)) >= 0)
        {
            RelOptInfo *brel2 = root->simple_rel_array[rti2];

            Assert(brel2 != NULL && brel2->reloptkind == RELOPT_BASEREL);
            brel2->lateral_referencers =
                bms_add_member(brel2->lateral_referencers, rti);
        }
    }
}

create_plan()

Plan* create_plan	(	PlannerInfo *	root,
		Path *	best_path
	)

Definition at line 332 of file createplan.c.

References apply_tlist_labeling(), Assert, CP_EXACT_TLIST, create_plan_recurse(), PlannerInfo::curOuterParams, PlannerInfo::curOuterRels, elog, ERROR, IsA, NIL, PlannerInfo::plan_params, PlannerInfo::processed_tlist, SS_attach_initplans(), and Plan::targetlist.

Referenced by create_minmaxagg_plan(), create_subqueryscan_plan(), make_subplan(), SS_process_ctes(), and standard_planner().

{
    Plan       *plan;

    /* plan_params should not be in use in current query level */
    Assert(root->plan_params == NIL);

    /* Initialize this module's workspace in PlannerInfo */
    root->curOuterRels = NULL;
    root->curOuterParams = NIL;

    /* Recursively process the path tree, demanding the correct tlist result */
    plan = create_plan_recurse(root, best_path, CP_EXACT_TLIST);

    /*
     * Make sure the topmost plan node's targetlist exposes the original
     * column names and other decorative info.  Targetlists generated within
     * the planner don't bother with that stuff, but we must have it on the
     * top-level tlist seen at execution time.  However, ModifyTable plan
     * nodes don't have a tlist matching the querytree targetlist.
     */
    if (!IsA(plan, ModifyTable))
        apply_tlist_labeling(plan->targetlist, root->processed_tlist);

    /*
     * Attach any initPlans created in this query level to the topmost plan
     * node.  (In principle the initplans could go in any plan node at or
     * above where they're referenced, but there seems no reason to put them
     * any lower than the topmost node for the query level.  Also, see
     * comments for SS_finalize_plan before you try to change this.)
     */
    SS_attach_initplans(root, plan);

    /* Check we successfully assigned all NestLoopParams to plan nodes */
    if (root->curOuterParams != NIL)
        elog(ERROR, "failed to assign all NestLoopParams to plan nodes");

    /*
     * Reset plan_params to ensure param IDs used for nestloop params are not
     * re-used later
     */
    root->plan_params = NIL;

    return plan;
}

deconstruct_jointree()

List* deconstruct_jointree

(

PlannerInfo *

root

)

Definition at line 687 of file initsplan.c.

References Assert, deconstruct_recurse(), IsA, Query::jointree, NIL, PlannerInfo::nullable_baserels, and PlannerInfo::parse.

Referenced by query_planner().

{
    List       *result;
    Relids      qualscope;
    Relids      inner_join_rels;
    List       *postponed_qual_list = NIL;

    /* Start recursion at top of jointree */
    Assert(root->parse->jointree != NULL &&
           IsA(root->parse->jointree, FromExpr));

    /* this is filled as we scan the jointree */
    root->nullable_baserels = NULL;

    result = deconstruct_recurse(root, (Node *) root->parse->jointree, false,
                                 &qualscope, &inner_join_rels,
                                 &postponed_qual_list);

    /* Shouldn't be any leftover quals */
    Assert(postponed_qual_list == NIL);

    return result;
}

distribute_restrictinfo_to_rels()

void distribute_restrictinfo_to_rels	(	PlannerInfo *	root,
		RestrictInfo *	restrictinfo
	)

Definition at line 2177 of file initsplan.c.

References add_join_clause_to_rels(), RelOptInfo::baserestrict_min_security, RelOptInfo::baserestrictinfo, bms_membership(), BMS_MULTIPLE, BMS_SINGLETON, bms_singleton_member(), check_hashjoinable(), check_memoizable(), elog, ERROR, find_base_rel(), lappend(), Min, PostponedQual::relids, RestrictInfo::required_relids, and RestrictInfo::security_level.

Referenced by distribute_qual_to_rels(), generate_base_implied_equalities_broken(), generate_base_implied_equalities_const(), process_implied_equality(), reconsider_outer_join_clauses(), and remove_rel_from_query().

{
    Relids      relids = restrictinfo->required_relids;
    RelOptInfo *rel;

    switch (bms_membership(relids))
    {
        case BMS_SINGLETON:

            /*
             * There is only one relation participating in the clause, so it
             * is a restriction clause for that relation.
             */
            rel = find_base_rel(root, bms_singleton_member(relids));

            /* Add clause to rel's restriction list */
            rel->baserestrictinfo = lappend(rel->baserestrictinfo,
                                            restrictinfo);
            /* Update security level info */
            rel->baserestrict_min_security = Min(rel->baserestrict_min_security,
                                                 restrictinfo->security_level);
            break;
        case BMS_MULTIPLE:

            /*
             * The clause is a join clause, since there is more than one rel
             * in its relid set.
             */

            /*
             * Check for hashjoinable operators.  (We don't bother setting the
             * hashjoin info except in true join clauses.)
             */
            check_hashjoinable(restrictinfo);

            /*
             * Likewise, check if the clause is suitable to be used with a
             * Memoize node to cache inner tuples during a parameterized
             * nested loop.
             */
            check_memoizable(restrictinfo);

            /*
             * Add clause to the join lists of all the relevant relations.
             */
            add_join_clause_to_rels(root, restrictinfo, relids);
            break;
        default:

            /*
             * clause references no rels, and therefore we have no place to
             * attach it.  Shouldn't get here if callers are working properly.
             */
            elog(ERROR, "cannot cope with variable-free clause");
            break;
    }
}

extract_query_dependencies_walker()

bool extract_query_dependencies_walker	(	Node *	node,
		PlannerInfo *	root
	)

Definition at line 3069 of file setrefs.c.

References Assert, CMD_UTILITY, Query::commandType, PlannerGlobal::dependsOnRole, expression_tree_walker(), extract_query_dependencies_walker(), fix_expr_common(), PlannerInfo::glob, Query::hasRowSecurity, IsA, lappend_oid(), lfirst, OidIsValid, query_tree_walker(), PlannerGlobal::relationOids, RangeTblEntry::relid, Query::rtable, RTE_NAMEDTUPLESTORE, RTE_RELATION, RangeTblEntry::rtekind, UtilityContainsQuery(), and Query::utilityStmt.

Referenced by expression_planner_with_deps(), extract_query_dependencies(), and extract_query_dependencies_walker().

{
    if (node == NULL)
        return false;
    Assert(!IsA(node, PlaceHolderVar));
    if (IsA(node, Query))
    {
        Query      *query = (Query *) node;
        ListCell   *lc;

        if (query->commandType == CMD_UTILITY)
        {
            /*
             * Ignore utility statements, except those (such as EXPLAIN) that
             * contain a parsed-but-not-planned query.
             */
            query = UtilityContainsQuery(query->utilityStmt);
            if (query == NULL)
                return false;
        }

        /* Remember if any Query has RLS quals applied by rewriter */
        if (query->hasRowSecurity)
            context->glob->dependsOnRole = true;

        /* Collect relation OIDs in this Query's rtable */
        foreach(lc, query->rtable)
        {
            RangeTblEntry *rte = (RangeTblEntry *) lfirst(lc);

            if (rte->rtekind == RTE_RELATION)
                context->glob->relationOids =
                    lappend_oid(context->glob->relationOids, rte->relid);
            else if (rte->rtekind == RTE_NAMEDTUPLESTORE &&
                     OidIsValid(rte->relid))
                context->glob->relationOids =
                    lappend_oid(context->glob->relationOids,
                                rte->relid);
        }

        /* And recurse into the query's subexpressions */
        return query_tree_walker(query, extract_query_dependencies_walker,
                                 (void *) context, 0);
    }
    /* Extract function dependencies and check for regclass Consts */
    fix_expr_common(context, node);
    return expression_tree_walker(node, extract_query_dependencies_walker,
                                  (void *) context);
}

find_lateral_references()

void find_lateral_references

(

PlannerInfo *

root

)

Definition at line 304 of file initsplan.c.

References Assert, extract_lateral_references(), PlannerInfo::hasLateralRTEs, RelOptInfo::relid, RELOPT_BASEREL, RelOptInfo::reloptkind, PlannerInfo::simple_rel_array, and PlannerInfo::simple_rel_array_size.

Referenced by query_planner().

{
    Index       rti;

    /* We need do nothing if the query contains no LATERAL RTEs */
    if (!root->hasLateralRTEs)
        return;

    /*
     * Examine all baserels (the rel array has been set up by now).
     */
    for (rti = 1; rti < root->simple_rel_array_size; rti++)
    {
        RelOptInfo *brel = root->simple_rel_array[rti];

        /* there may be empty slots corresponding to non-baserel RTEs */
        if (brel == NULL)
            continue;

        Assert(brel->relid == rti); /* sanity check on array */

        /*
         * This bit is less obvious than it might look.  We ignore appendrel
         * otherrels and consider only their parent baserels.  In a case where
         * a LATERAL-containing UNION ALL subquery was pulled up, it is the
         * otherrel that is actually going to be in the plan.  However, we
         * want to mark all its lateral references as needed by the parent,
         * because it is the parent's relid that will be used for join
         * planning purposes.  And the parent's RTE will contain all the
         * lateral references we need to know, since the pulled-up member is
         * nothing but a copy of parts of the original RTE's subquery.  We
         * could visit the parent's children instead and transform their
         * references back to the parent's relid, but it would be much more
         * complicated for no real gain.  (Important here is that the child
         * members have not yet received any processing beyond being pulled
         * up.)  Similarly, in appendrels created by inheritance expansion,
         * it's sufficient to look at the parent relation.
         */

        /* ignore RTEs that are "other rels" */
        if (brel->reloptkind != RELOPT_BASEREL)
            continue;

        extract_lateral_references(root, brel, rti);
    }
}

innerrel_is_unique()

bool innerrel_is_unique	(	PlannerInfo *	root,
		Relids	joinrelids,
		Relids	outerrelids,
		RelOptInfo *	innerrel,
		JoinType	jointype,
		List *	restrictlist,
		bool	force_cache
	)

Definition at line 964 of file analyzejoins.c.

References bms_copy(), bms_is_subset(), is_innerrel_unique_for(), PlannerInfo::join_search_private, lappend(), lfirst, MemoryContextSwitchTo(), NIL, RelOptInfo::non_unique_for_rels, PlannerInfo::planner_cxt, rel_supports_distinctness(), and RelOptInfo::unique_for_rels.

Referenced by add_paths_to_joinrel(), and reduce_unique_semijoins().

{
    MemoryContext old_context;
    ListCell   *lc;

    /* Certainly can't prove uniqueness when there are no joinclauses */
    if (restrictlist == NIL)
        return false;

    /*
     * Make a quick check to eliminate cases in which we will surely be unable
     * to prove uniqueness of the innerrel.
     */
    if (!rel_supports_distinctness(root, innerrel))
        return false;

    /*
     * Query the cache to see if we've managed to prove that innerrel is
     * unique for any subset of this outerrel.  We don't need an exact match,
     * as extra outerrels can't make the innerrel any less unique (or more
     * formally, the restrictlist for a join to a superset outerrel must be a
     * superset of the conditions we successfully used before).
     */
    foreach(lc, innerrel->unique_for_rels)
    {
        Relids      unique_for_rels = (Relids) lfirst(lc);

        if (bms_is_subset(unique_for_rels, outerrelids))
            return true;        /* Success! */
    }

    /*
     * Conversely, we may have already determined that this outerrel, or some
     * superset thereof, cannot prove this innerrel to be unique.
     */
    foreach(lc, innerrel->non_unique_for_rels)
    {
        Relids      unique_for_rels = (Relids) lfirst(lc);

        if (bms_is_subset(outerrelids, unique_for_rels))
            return false;
    }

    /* No cached information, so try to make the proof. */
    if (is_innerrel_unique_for(root, joinrelids, outerrelids, innerrel,
                               jointype, restrictlist))
    {
        /*
         * Cache the positive result for future probes, being sure to keep it
         * in the planner_cxt even if we are working in GEQO.
         *
         * Note: one might consider trying to isolate the minimal subset of
         * the outerrels that proved the innerrel unique.  But it's not worth
         * the trouble, because the planner builds up joinrels incrementally
         * and so we'll see the minimally sufficient outerrels before any
         * supersets of them anyway.
         */
        old_context = MemoryContextSwitchTo(root->planner_cxt);
        innerrel->unique_for_rels = lappend(innerrel->unique_for_rels,
                                            bms_copy(outerrelids));
        MemoryContextSwitchTo(old_context);

        return true;            /* Success! */
    }
    else
    {
        /*
         * None of the join conditions for outerrel proved innerrel unique, so
         * we can safely reject this outerrel or any subset of it in future
         * checks.
         *
         * However, in normal planning mode, caching this knowledge is totally
         * pointless; it won't be queried again, because we build up joinrels
         * from smaller to larger.  It is useful in GEQO mode, where the
         * knowledge can be carried across successive planning attempts; and
         * it's likely to be useful when using join-search plugins, too. Hence
         * cache when join_search_private is non-NULL.  (Yeah, that's a hack,
         * but it seems reasonable.)
         *
         * Also, allow callers to override that heuristic and force caching;
         * that's useful for reduce_unique_semijoins, which calls here before
         * the normal join search starts.
         */
        if (force_cache || root->join_search_private)
        {
            old_context = MemoryContextSwitchTo(root->planner_cxt);
            innerrel->non_unique_for_rels =
                lappend(innerrel->non_unique_for_rels,
                        bms_copy(outerrelids));
            MemoryContextSwitchTo(old_context);
        }

        return false;
    }
}

is_projection_capable_path()

bool is_projection_capable_path

(

Path *

path

)

Definition at line 7028 of file createplan.c.

References castNode, CUSTOMPATH_SUPPORT_PROJECTION, IS_DUMMY_APPEND, Path::pathtype, T_Append, T_CustomScan, T_Hash, T_IncrementalSort, T_Limit, T_LockRows, T_Material, T_Memoize, T_MergeAppend, T_ModifyTable, T_ProjectSet, T_RecursiveUnion, T_SetOp, T_Sort, and T_Unique.

Referenced by apply_projection_to_path(), create_projection_path(), and create_projection_plan().

{
    /* Most plan types can project, so just list the ones that can't */
    switch (path->pathtype)
    {
        case T_Hash:
        case T_Material:
        case T_Memoize:
        case T_Sort:
        case T_IncrementalSort:
        case T_Unique:
        case T_SetOp:
        case T_LockRows:
        case T_Limit:
        case T_ModifyTable:
        case T_MergeAppend:
        case T_RecursiveUnion:
            return false;
        case T_CustomScan:
            if (castNode(CustomPath, path)->flags & CUSTOMPATH_SUPPORT_PROJECTION)
                return true;
            return false;
        case T_Append:

            /*
             * Append can't project, but if an AppendPath is being used to
             * represent a dummy path, what will actually be generated is a
             * Result which can project.
             */
            return IS_DUMMY_APPEND(path);
        case T_ProjectSet:

            /*
             * Although ProjectSet certainly projects, say "no" because we
             * don't want the planner to randomly replace its tlist with
             * something else; the SRFs have to stay at top level.  This might
             * get relaxed later.
             */
            return false;
        default:
            break;
    }
    return true;
}

is_projection_capable_plan()

bool is_projection_capable_plan

(

Plan *

plan

)

Definition at line 7078 of file createplan.c.

References CUSTOMPATH_SUPPORT_PROJECTION, nodeTag, T_Append, T_CustomScan, T_Hash, T_Limit, T_LockRows, T_Material, T_Memoize, T_MergeAppend, T_ModifyTable, T_ProjectSet, T_RecursiveUnion, T_SetOp, T_Sort, and T_Unique.

Referenced by change_plan_targetlist(), create_projection_plan(), and prepare_sort_from_pathkeys().

{
    /* Most plan types can project, so just list the ones that can't */
    switch (nodeTag(plan))
    {
        case T_Hash:
        case T_Material:
        case T_Memoize:
        case T_Sort:
        case T_Unique:
        case T_SetOp:
        case T_LockRows:
        case T_Limit:
        case T_ModifyTable:
        case T_Append:
        case T_MergeAppend:
        case T_RecursiveUnion:
            return false;
        case T_CustomScan:
            if (((CustomScan *) plan)->flags & CUSTOMPATH_SUPPORT_PROJECTION)
                return true;
            return false;
        case T_ProjectSet:

            /*
             * Although ProjectSet certainly projects, say "no" because we
             * don't want the planner to randomly replace its tlist with
             * something else; the SRFs have to stay at top level.  This might
             * get relaxed later.
             */
            return false;
        default:
            break;
    }
    return true;
}

make_agg()

Agg* make_agg	(	List *	tlist,
		List *	qual,
		AggStrategy	aggstrategy,
		AggSplit	aggsplit,
		int	numGroupCols,
		AttrNumber *	grpColIdx,
		Oid *	grpOperators,
		Oid *	grpCollations,
		List *	groupingSets,
		List *	chain,
		double	dNumGroups,
		Size	transitionSpace,
		Plan *	lefttree
	)

Definition at line 6440 of file createplan.c.

References Agg::aggParams, Agg::aggsplit, Agg::aggstrategy, Agg::chain, Agg::groupingSets, Agg::grpColIdx, Agg::grpCollations, Agg::grpOperators, Plan::lefttree, makeNode, Min, Agg::numCols, Agg::numGroups, Agg::plan, Plan::qual, Plan::righttree, Plan::targetlist, and Agg::transitionSpace.

Referenced by create_agg_plan(), create_groupingsets_plan(), and create_unique_plan().

{
    Agg        *node = makeNode(Agg);
    Plan       *plan = &node->plan;
    long        numGroups;

    /* Reduce to long, but 'ware overflow! */
    numGroups = (long) Min(dNumGroups, (double) LONG_MAX);

    node->aggstrategy = aggstrategy;
    node->aggsplit = aggsplit;
    node->numCols = numGroupCols;
    node->grpColIdx = grpColIdx;
    node->grpOperators = grpOperators;
    node->grpCollations = grpCollations;
    node->numGroups = numGroups;
    node->transitionSpace = transitionSpace;
    node->aggParams = NULL;     /* SS_finalize_plan() will fill this */
    node->groupingSets = groupingSets;
    node->chain = chain;

    plan->qual = qual;
    plan->targetlist = tlist;
    plan->lefttree = lefttree;
    plan->righttree = NULL;

    return node;
}

make_foreignscan()

ForeignScan* make_foreignscan	(	List *	qptlist,
		List *	qpqual,
		Index	scanrelid,
		List *	fdw_exprs,
		List *	fdw_private,
		List *	fdw_scan_tlist,
		List *	fdw_recheck_quals,
		Plan *	outer_plan
	)

Definition at line 5678 of file createplan.c.

References CMD_SELECT, ForeignScan::fdw_exprs, ForeignScan::fdw_private, ForeignScan::fdw_recheck_quals, ForeignScan::fdw_scan_tlist, ForeignScan::fs_relids, ForeignScan::fs_server, ForeignScan::fsSystemCol, InvalidOid, Plan::lefttree, makeNode, ForeignScan::operation, Scan::plan, Plan::qual, ForeignScan::resultRelation, Plan::righttree, ForeignScan::scan, Scan::scanrelid, and Plan::targetlist.

Referenced by fileGetForeignPlan(), and postgresGetForeignPlan().

{
    ForeignScan *node = makeNode(ForeignScan);
    Plan       *plan = &node->scan.plan;

    /* cost will be filled in by create_foreignscan_plan */
    plan->targetlist = qptlist;
    plan->qual = qpqual;
    plan->lefttree = outer_plan;
    plan->righttree = NULL;
    node->scan.scanrelid = scanrelid;

    /* these may be overridden by the FDW's PlanDirectModify callback. */
    node->operation = CMD_SELECT;
    node->resultRelation = 0;

    /* fs_server will be filled in by create_foreignscan_plan */
    node->fs_server = InvalidOid;
    node->fdw_exprs = fdw_exprs;
    node->fdw_private = fdw_private;
    node->fdw_scan_tlist = fdw_scan_tlist;
    node->fdw_recheck_quals = fdw_recheck_quals;
    /* fs_relids will be filled in by create_foreignscan_plan */
    node->fs_relids = NULL;
    /* fsSystemCol will be filled in by create_foreignscan_plan */
    node->fsSystemCol = false;

    return node;
}

make_limit()

Limit* make_limit	(	Plan *	lefttree,
		Node *	limitOffset,
		Node *	limitCount,
		LimitOption	limitOption,
		int	uniqNumCols,
		AttrNumber *	uniqColIdx,
		Oid *	uniqOperators,
		Oid *	uniqCollations
	)

Definition at line 6804 of file createplan.c.

References Plan::lefttree, Limit::limitCount, Limit::limitOffset, Limit::limitOption, makeNode, NIL, Limit::plan, Plan::qual, Plan::righttree, Plan::targetlist, Limit::uniqColIdx, Limit::uniqCollations, Limit::uniqNumCols, and Limit::uniqOperators.

Referenced by create_limit_plan(), and create_minmaxagg_plan().

{
    Limit      *node = makeNode(Limit);
    Plan       *plan = &node->plan;

    plan->targetlist = lefttree->targetlist;
    plan->qual = NIL;
    plan->lefttree = lefttree;
    plan->righttree = NULL;

    node->limitOffset = limitOffset;
    node->limitCount = limitCount;
    node->limitOption = limitOption;
    node->uniqNumCols = uniqNumCols;
    node->uniqColIdx = uniqColIdx;
    node->uniqOperators = uniqOperators;
    node->uniqCollations = uniqCollations;

    return node;
}

make_sort_from_sortclauses()

Sort* make_sort_from_sortclauses	(	List *	sortcls,
		Plan *	lefttree
	)

Definition at line 6272 of file createplan.c.

References TargetEntry::expr, exprCollation(), get_sortgroupclause_tle(), lfirst, list_length(), make_sort(), SortGroupClause::nulls_first, palloc(), TargetEntry::resno, SortGroupClause::sortop, and Plan::targetlist.

Referenced by create_unique_plan().

{
    List       *sub_tlist = lefttree->targetlist;
    ListCell   *l;
    int         numsortkeys;
    AttrNumber *sortColIdx;
    Oid        *sortOperators;
    Oid        *collations;
    bool       *nullsFirst;

    /* Convert list-ish representation to arrays wanted by executor */
    numsortkeys = list_length(sortcls);
    sortColIdx = (AttrNumber *) palloc(numsortkeys * sizeof(AttrNumber));
    sortOperators = (Oid *) palloc(numsortkeys * sizeof(Oid));
    collations = (Oid *) palloc(numsortkeys * sizeof(Oid));
    nullsFirst = (bool *) palloc(numsortkeys * sizeof(bool));

    numsortkeys = 0;
    foreach(l, sortcls)
    {
        SortGroupClause *sortcl = (SortGroupClause *) lfirst(l);
        TargetEntry *tle = get_sortgroupclause_tle(sortcl, sub_tlist);

        sortColIdx[numsortkeys] = tle->resno;
        sortOperators[numsortkeys] = sortcl->sortop;
        collations[numsortkeys] = exprCollation((Node *) tle->expr);
        nullsFirst[numsortkeys] = sortcl->nulls_first;
        numsortkeys++;
    }

    return make_sort(lefttree, numsortkeys,
                     sortColIdx, sortOperators,
                     collations, nullsFirst);
}

match_foreign_keys_to_quals()

void match_foreign_keys_to_quals

(

PlannerInfo *

root

)

Definition at line 2483 of file initsplan.c.

References OpExpr::args, RestrictInfo::clause, ForeignKeyOptInfo::con_relid, ForeignKeyOptInfo::confkey, ForeignKeyOptInfo::conkey, ForeignKeyOptInfo::conpfeqop, EquivalenceClass::ec_has_const, PlannerInfo::fkey_list, get_commutator(), get_leftop(), get_rightop(), InvalidOid, IsA, RelOptInfo::joininfo, lappend(), lfirst, list_length(), match_eclasses_to_foreign_key_col(), ForeignKeyOptInfo::nconst_ec, NIL, ForeignKeyOptInfo::nkeys, ForeignKeyOptInfo::nmatched_ec, ForeignKeyOptInfo::nmatched_rcols, ForeignKeyOptInfo::nmatched_ri, OidIsValid, OpExpr::opno, RestrictInfo::outerjoin_delayed, ForeignKeyOptInfo::ref_relid, RELOPT_BASEREL, RelOptInfo::reloptkind, ForeignKeyOptInfo::rinfos, PlannerInfo::simple_rel_array, and PlannerInfo::simple_rel_array_size.

Referenced by query_planner().

{
    List       *newlist = NIL;
    ListCell   *lc;

    foreach(lc, root->fkey_list)
    {
        ForeignKeyOptInfo *fkinfo = (ForeignKeyOptInfo *) lfirst(lc);
        RelOptInfo *con_rel;
        RelOptInfo *ref_rel;
        int         colno;

        /*
         * Either relid might identify a rel that is in the query's rtable but
         * isn't referenced by the jointree so won't have a RelOptInfo.  Hence
         * don't use find_base_rel() here.  We can ignore such FKs.
         */
        if (fkinfo->con_relid >= root->simple_rel_array_size ||
            fkinfo->ref_relid >= root->simple_rel_array_size)
            continue;           /* just paranoia */
        con_rel = root->simple_rel_array[fkinfo->con_relid];
        if (con_rel == NULL)
            continue;
        ref_rel = root->simple_rel_array[fkinfo->ref_relid];
        if (ref_rel == NULL)
            continue;

        /*
         * Ignore FK unless both rels are baserels.  This gets rid of FKs that
         * link to inheritance child rels (otherrels) and those that link to
         * rels removed by join removal (dead rels).
         */
        if (con_rel->reloptkind != RELOPT_BASEREL ||
            ref_rel->reloptkind != RELOPT_BASEREL)
            continue;

        /*
         * Scan the columns and try to match them to eclasses and quals.
         *
         * Note: for simple inner joins, any match should be in an eclass.
         * "Loose" quals that syntactically match an FK equality must have
         * been rejected for EC status because they are outer-join quals or
         * similar.  We can still consider them to match the FK if they are
         * not outerjoin_delayed.
         */
        for (colno = 0; colno < fkinfo->nkeys; colno++)
        {
            EquivalenceClass *ec;
            AttrNumber  con_attno,
                        ref_attno;
            Oid         fpeqop;
            ListCell   *lc2;

            ec = match_eclasses_to_foreign_key_col(root, fkinfo, colno);
            /* Don't bother looking for loose quals if we got an EC match */
            if (ec != NULL)
            {
                fkinfo->nmatched_ec++;
                if (ec->ec_has_const)
                    fkinfo->nconst_ec++;
                continue;
            }

            /*
             * Scan joininfo list for relevant clauses.  Either rel's joininfo
             * list would do equally well; we use con_rel's.
             */
            con_attno = fkinfo->conkey[colno];
            ref_attno = fkinfo->confkey[colno];
            fpeqop = InvalidOid;    /* we'll look this up only if needed */

            foreach(lc2, con_rel->joininfo)
            {
                RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc2);
                OpExpr     *clause = (OpExpr *) rinfo->clause;
                Var        *leftvar;
                Var        *rightvar;

                /* Ignore outerjoin-delayed clauses */
                if (rinfo->outerjoin_delayed)
                    continue;

                /* Only binary OpExprs are useful for consideration */
                if (!IsA(clause, OpExpr) ||
                    list_length(clause->args) != 2)
                    continue;
                leftvar = (Var *) get_leftop((Expr *) clause);
                rightvar = (Var *) get_rightop((Expr *) clause);

                /* Operands must be Vars, possibly with RelabelType */
                while (leftvar && IsA(leftvar, RelabelType))
                    leftvar = (Var *) ((RelabelType *) leftvar)->arg;
                if (!(leftvar && IsA(leftvar, Var)))
                    continue;
                while (rightvar && IsA(rightvar, RelabelType))
                    rightvar = (Var *) ((RelabelType *) rightvar)->arg;
                if (!(rightvar && IsA(rightvar, Var)))
                    continue;

                /* Now try to match the vars to the current foreign key cols */
                if (fkinfo->ref_relid == leftvar->varno &&
                    ref_attno == leftvar->varattno &&
                    fkinfo->con_relid == rightvar->varno &&
                    con_attno == rightvar->varattno)
                {
                    /* Vars match, but is it the right operator? */
                    if (clause->opno == fkinfo->conpfeqop[colno])
                    {
                        fkinfo->rinfos[colno] = lappend(fkinfo->rinfos[colno],
                                                        rinfo);
                        fkinfo->nmatched_ri++;
                    }
                }
                else if (fkinfo->ref_relid == rightvar->varno &&
                         ref_attno == rightvar->varattno &&
                         fkinfo->con_relid == leftvar->varno &&
                         con_attno == leftvar->varattno)
                {
                    /*
                     * Reverse match, must check commutator operator.  Look it
                     * up if we didn't already.  (In the worst case we might
                     * do multiple lookups here, but that would require an FK
                     * equality operator without commutator, which is
                     * unlikely.)
                     */
                    if (!OidIsValid(fpeqop))
                        fpeqop = get_commutator(fkinfo->conpfeqop[colno]);
                    if (clause->opno == fpeqop)
                    {
                        fkinfo->rinfos[colno] = lappend(fkinfo->rinfos[colno],
                                                        rinfo);
                        fkinfo->nmatched_ri++;
                    }
                }
            }
            /* If we found any matching loose quals, count col as matched */
            if (fkinfo->rinfos[colno])
                fkinfo->nmatched_rcols++;
        }

        /*
         * Currently, we drop multicolumn FKs that aren't fully matched to the
         * query.  Later we might figure out how to derive some sort of
         * estimate from them, in which case this test should be weakened to
         * "if ((fkinfo->nmatched_ec + fkinfo->nmatched_rcols) > 0)".
         */
        if ((fkinfo->nmatched_ec + fkinfo->nmatched_rcols) == fkinfo->nkeys)
            newlist = lappend(newlist, fkinfo);
    }
    /* Replace fkey_list, thereby discarding any useless entries */
    root->fkey_list = newlist;
}

materialize_finished_plan()

Plan* materialize_finished_plan

(

Plan *

subplan

)

Definition at line 6384 of file createplan.c.

References cost_material(), Plan::initPlan, make_material(), NIL, Plan::parallel_aware, Plan::parallel_safe, Plan::plan_rows, Plan::plan_width, Plan::startup_cost, Path::startup_cost, Plan::total_cost, and Path::total_cost.

Referenced by build_subplan(), and standard_planner().

{
    Plan       *matplan;
    Path        matpath;        /* dummy for result of cost_material */

    matplan = (Plan *) make_material(subplan);

    /*
     * XXX horrid kluge: if there are any initPlans attached to the subplan,
     * move them up to the Material node, which is now effectively the top
     * plan node in its query level.  This prevents failure in
     * SS_finalize_plan(), which see for comments.  We don't bother adjusting
     * the subplan's cost estimate for this.
     */
    matplan->initPlan = subplan->initPlan;
    subplan->initPlan = NIL;

    /* Set cost data */
    cost_material(&matpath,
                  subplan->startup_cost,
                  subplan->total_cost,
                  subplan->plan_rows,
                  subplan->plan_width);
    matplan->startup_cost = matpath.startup_cost;
    matplan->total_cost = matpath.total_cost;
    matplan->plan_rows = subplan->plan_rows;
    matplan->plan_width = subplan->plan_width;
    matplan->parallel_aware = false;
    matplan->parallel_safe = subplan->parallel_safe;

    return matplan;
}

preprocess_minmax_aggregates()

void preprocess_minmax_aggregates

(

PlannerInfo *

root

)

Definition at line 73 of file planagg.c.

References add_path(), MinMaxAggInfo::aggsortop, Assert, build_minmax_path(), can_minmax_aggs(), create_minmaxagg_path(), create_pathtarget, Query::cteList, elog, ERROR, exprCollation(), exprType(), fetch_upper_rel(), FromExpr::fromlist, get_equality_op_for_ordering_op(), Query::groupClause, Query::groupingSets, Query::hasAggs, Query::hasWindowFuncs, Query::havingQual, RangeTblEntry::inh, IsA, Query::jointree, lfirst, linitial, list_length(), PlannerInfo::minmax_aggs, NIL, OidIsValid, MinMaxAggInfo::param, parse(), PlannerInfo::parse, planner_rt_fetch, PlannerInfo::processed_tlist, Query::rowMarks, RTE_RELATION, RTE_SUBQUERY, RangeTblEntry::rtekind, RangeTblRef::rtindex, Query::setOperations, SS_make_initplan_output_param(), MinMaxAggInfo::target, and UPPERREL_GROUP_AGG.

Referenced by grouping_planner().

{
    Query      *parse = root->parse;
    FromExpr   *jtnode;
    RangeTblRef *rtr;
    RangeTblEntry *rte;
    List       *aggs_list;
    RelOptInfo *grouped_rel;
    ListCell   *lc;

    /* minmax_aggs list should be empty at this point */
    Assert(root->minmax_aggs == NIL);

    /* Nothing to do if query has no aggregates */
    if (!parse->hasAggs)
        return;

    Assert(!parse->setOperations);  /* shouldn't get here if a setop */
    Assert(parse->rowMarks == NIL); /* nor if FOR UPDATE */

    /*
     * Reject unoptimizable cases.
     *
     * We don't handle GROUP BY or windowing, because our current
     * implementations of grouping require looking at all the rows anyway, and
     * so there's not much point in optimizing MIN/MAX.
     */
    if (parse->groupClause || list_length(parse->groupingSets) > 1 ||
        parse->hasWindowFuncs)
        return;

    /*
     * Reject if query contains any CTEs; there's no way to build an indexscan
     * on one so we couldn't succeed here.  (If the CTEs are unreferenced,
     * that's not true, but it doesn't seem worth expending cycles to check.)
     */
    if (parse->cteList)
        return;

    /*
     * We also restrict the query to reference exactly one table, since join
     * conditions can't be handled reasonably.  (We could perhaps handle a
     * query containing cartesian-product joins, but it hardly seems worth the
     * trouble.)  However, the single table could be buried in several levels
     * of FromExpr due to subqueries.  Note the "single" table could be an
     * inheritance parent, too, including the case of a UNION ALL subquery
     * that's been flattened to an appendrel.
     */
    jtnode = parse->jointree;
    while (IsA(jtnode, FromExpr))
    {
        if (list_length(jtnode->fromlist) != 1)
            return;
        jtnode = linitial(jtnode->fromlist);
    }
    if (!IsA(jtnode, RangeTblRef))
        return;
    rtr = (RangeTblRef *) jtnode;
    rte = planner_rt_fetch(rtr->rtindex, root);
    if (rte->rtekind == RTE_RELATION)
         /* ordinary relation, ok */ ;
    else if (rte->rtekind == RTE_SUBQUERY && rte->inh)
         /* flattened UNION ALL subquery, ok */ ;
    else
        return;

    /*
     * Scan the tlist and HAVING qual to find all the aggregates and verify
     * all are MIN/MAX aggregates.  Stop as soon as we find one that isn't.
     */
    aggs_list = NIL;
    if (!can_minmax_aggs(root, &aggs_list))
        return;

    /*
     * OK, there is at least the possibility of performing the optimization.
     * Build an access path for each aggregate.  If any of the aggregates
     * prove to be non-indexable, give up; there is no point in optimizing
     * just some of them.
     */
    foreach(lc, aggs_list)
    {
        MinMaxAggInfo *mminfo = (MinMaxAggInfo *) lfirst(lc);
        Oid         eqop;
        bool        reverse;

        /*
         * We'll need the equality operator that goes with the aggregate's
         * ordering operator.
         */
        eqop = get_equality_op_for_ordering_op(mminfo->aggsortop, &reverse);
        if (!OidIsValid(eqop))  /* shouldn't happen */
            elog(ERROR, "could not find equality operator for ordering operator %u",
                 mminfo->aggsortop);

        /*
         * We can use either an ordering that gives NULLS FIRST or one that
         * gives NULLS LAST; furthermore there's unlikely to be much
         * performance difference between them, so it doesn't seem worth
         * costing out both ways if we get a hit on the first one.  NULLS
         * FIRST is more likely to be available if the operator is a
         * reverse-sort operator, so try that first if reverse.
         */
        if (build_minmax_path(root, mminfo, eqop, mminfo->aggsortop, reverse))
            continue;
        if (build_minmax_path(root, mminfo, eqop, mminfo->aggsortop, !reverse))
            continue;

        /* No indexable path for this aggregate, so fail */
        return;
    }

    /*
     * OK, we can do the query this way.  Prepare to create a MinMaxAggPath
     * node.
     *
     * First, create an output Param node for each agg.  (If we end up not
     * using the MinMaxAggPath, we'll waste a PARAM_EXEC slot for each agg,
     * which is not worth worrying about.  We can't wait till create_plan time
     * to decide whether to make the Param, unfortunately.)
     */
    foreach(lc, aggs_list)
    {
        MinMaxAggInfo *mminfo = (MinMaxAggInfo *) lfirst(lc);

        mminfo->param =
            SS_make_initplan_output_param(root,
                                          exprType((Node *) mminfo->target),
                                          -1,
                                          exprCollation((Node *) mminfo->target));
    }

    /*
     * Create a MinMaxAggPath node with the appropriate estimated costs and
     * other needed data, and add it to the UPPERREL_GROUP_AGG upperrel, where
     * it will compete against the standard aggregate implementation.  (It
     * will likely always win, but we need not assume that here.)
     *
     * Note: grouping_planner won't have created this upperrel yet, but it's
     * fine for us to create it first.  We will not have inserted the correct
     * consider_parallel value in it, but MinMaxAggPath paths are currently
     * never parallel-safe anyway, so that doesn't matter.  Likewise, it
     * doesn't matter that we haven't filled FDW-related fields in the rel.
     * Also, because there are no rowmarks, we know that the processed_tlist
     * doesn't need to change anymore, so making the pathtarget now is safe.
     */
    grouped_rel = fetch_upper_rel(root, UPPERREL_GROUP_AGG, NULL);
    add_path(grouped_rel, (Path *)
             create_minmaxagg_path(root, grouped_rel,
                                   create_pathtarget(root,
                                                     root->processed_tlist),
                                   aggs_list,
                                   (List *) parse->havingQual));
}

process_implied_equality()

RestrictInfo* process_implied_equality	(	PlannerInfo *	root,
		Oid	opno,
		Oid	collation,
		Expr *	item1,
		Expr *	item2,
		Relids	qualscope,
		Relids	nullable_relids,
		Index	security_level,
		bool	below_outer_join,
		bool	both_const
	)

Definition at line 2272 of file initsplan.c.

References add_vars_to_targetlist(), Assert, bms_copy(), bms_is_empty(), bms_is_subset(), bms_membership(), BMS_MULTIPLE, check_mergejoinable(), Const::constisnull, Const::consttype, Const::constvalue, contain_volatile_functions(), copyObject, DatumGetBool, distribute_restrictinfo_to_rels(), eval_const_expressions(), get_relids_in_jointree(), PlannerInfo::hasPseudoConstantQuals, InvalidOid, IsA, Query::jointree, list_free(), make_opclause(), make_restrictinfo(), PlannerInfo::parse, pull_var_clause(), pull_varnos(), PVC_INCLUDE_PLACEHOLDERS, PVC_RECURSE_AGGREGATES, PVC_RECURSE_WINDOWFUNCS, and PostponedQual::relids.

Referenced by generate_base_implied_equalities_const(), and generate_base_implied_equalities_no_const().

{
    RestrictInfo *restrictinfo;
    Node       *clause;
    Relids      relids;
    bool        pseudoconstant = false;

    /*
     * Build the new clause.  Copy to ensure it shares no substructure with
     * original (this is necessary in case there are subselects in there...)
     */
    clause = (Node *) make_opclause(opno,
                                    BOOLOID,    /* opresulttype */
                                    false,  /* opretset */
                                    copyObject(item1),
                                    copyObject(item2),
                                    InvalidOid,
                                    collation);

    /* If both constant, try to reduce to a boolean constant. */
    if (both_const)
    {
        clause = eval_const_expressions(root, clause);

        /* If we produced const TRUE, just drop the clause */
        if (clause && IsA(clause, Const))
        {
            Const      *cclause = (Const *) clause;

            Assert(cclause->consttype == BOOLOID);
            if (!cclause->constisnull && DatumGetBool(cclause->constvalue))
                return NULL;
        }
    }

    /*
     * The rest of this is a very cut-down version of distribute_qual_to_rels.
     * We can skip most of the work therein, but there are a couple of special
     * cases we still have to handle.
     *
     * Retrieve all relids mentioned within the possibly-simplified clause.
     */
    relids = pull_varnos(root, clause);
    Assert(bms_is_subset(relids, qualscope));

    /*
     * If the clause is variable-free, our normal heuristic for pushing it
     * down to just the mentioned rels doesn't work, because there are none.
     * Apply at the given qualscope, or at the top of tree if it's nonvolatile
     * (which it very likely is, but we'll check, just to be sure).
     */
    if (bms_is_empty(relids))
    {
        /* eval at original syntactic level */
        relids = bms_copy(qualscope);
        if (!contain_volatile_functions(clause))
        {
            /* mark as gating qual */
            pseudoconstant = true;
            /* tell createplan.c to check for gating quals */
            root->hasPseudoConstantQuals = true;
            /* if not below outer join, push it to top of tree */
            if (!below_outer_join)
            {
                relids =
                    get_relids_in_jointree((Node *) root->parse->jointree,
                                           false);
            }
        }
    }

    /*
     * Build the RestrictInfo node itself.
     */
    restrictinfo = make_restrictinfo(root,
                                     (Expr *) clause,
                                     true,  /* is_pushed_down */
                                     false, /* outerjoin_delayed */
                                     pseudoconstant,
                                     security_level,
                                     relids,
                                     NULL,  /* outer_relids */
                                     nullable_relids);

    /*
     * If it's a join clause, add vars used in the clause to targetlists of
     * their relations, so that they will be emitted by the plan nodes that
     * scan those relations (else they won't be available at the join node!).
     *
     * Typically, we'd have already done this when the component expressions
     * were first seen by distribute_qual_to_rels; but it is possible that
     * some of the Vars could have missed having that done because they only
     * appeared in single-relation clauses originally.  So do it here for
     * safety.
     */
    if (bms_membership(relids) == BMS_MULTIPLE)
    {
        List       *vars = pull_var_clause(clause,
                                           PVC_RECURSE_AGGREGATES |
                                           PVC_RECURSE_WINDOWFUNCS |
                                           PVC_INCLUDE_PLACEHOLDERS);

        add_vars_to_targetlist(root, vars, relids, false);
        list_free(vars);
    }

    /*
     * Check mergejoinability.  This will usually succeed, since the op came
     * from an EquivalenceClass; but we could have reduced the original clause
     * to a constant.
     */
    check_mergejoinable(restrictinfo);

    /*
     * Note we don't do initialize_mergeclause_eclasses(); the caller can
     * handle that much more cheaply than we can.  It's okay to call
     * distribute_restrictinfo_to_rels() before that happens.
     */

    /*
     * Push the new clause into all the appropriate restrictinfo lists.
     */
    distribute_restrictinfo_to_rels(root, restrictinfo);

    return restrictinfo;
}

query_is_distinct_for()

bool query_is_distinct_for	(	Query *	query,
		List *	colnos,
		List *	opids
	)

Definition at line 775 of file analyzejoins.c.

References SetOperationStmt::all, Assert, castNode, distinct_col_search(), Query::distinctClause, SortGroupClause::eqop, equality_ops_are_compatible(), get_sortgroupclause_tle(), Query::groupClause, SetOperationStmt::groupClauses, GROUPING_SET_EMPTY, Query::groupingSets, Query::hasAggs, Query::hasTargetSRFs, Query::havingQual, lfirst, linitial, list_head(), list_length(), lnext(), OidIsValid, SetOperationStmt::op, TargetEntry::resjunk, TargetEntry::resno, SETOP_NONE, Query::setOperations, and Query::targetList.

Referenced by create_unique_path(), and rel_is_distinct_for().

{
    ListCell   *l;
    Oid         opid;

    Assert(list_length(colnos) == list_length(opids));

    /*
     * DISTINCT (including DISTINCT ON) guarantees uniqueness if all the
     * columns in the DISTINCT clause appear in colnos and operator semantics
     * match.  This is true even if there are SRFs in the DISTINCT columns or
     * elsewhere in the tlist.
     */
    if (query->distinctClause)
    {
        foreach(l, query->distinctClause)
        {
            SortGroupClause *sgc = (SortGroupClause *) lfirst(l);
            TargetEntry *tle = get_sortgroupclause_tle(sgc,
                                                       query->targetList);

            opid = distinct_col_search(tle->resno, colnos, opids);
            if (!OidIsValid(opid) ||
                !equality_ops_are_compatible(opid, sgc->eqop))
                break;          /* exit early if no match */
        }
        if (l == NULL)          /* had matches for all? */
            return true;
    }

    /*
     * Otherwise, a set-returning function in the query's targetlist can
     * result in returning duplicate rows, despite any grouping that might
     * occur before tlist evaluation.  (If all tlist SRFs are within GROUP BY
     * columns, it would be safe because they'd be expanded before grouping.
     * But it doesn't currently seem worth the effort to check for that.)
     */
    if (query->hasTargetSRFs)
        return false;

    /*
     * Similarly, GROUP BY without GROUPING SETS guarantees uniqueness if all
     * the grouped columns appear in colnos and operator semantics match.
     */
    if (query->groupClause && !query->groupingSets)
    {
        foreach(l, query->groupClause)
        {
            SortGroupClause *sgc = (SortGroupClause *) lfirst(l);
            TargetEntry *tle = get_sortgroupclause_tle(sgc,
                                                       query->targetList);

            opid = distinct_col_search(tle->resno, colnos, opids);
            if (!OidIsValid(opid) ||
                !equality_ops_are_compatible(opid, sgc->eqop))
                break;          /* exit early if no match */
        }
        if (l == NULL)          /* had matches for all? */
            return true;
    }
    else if (query->groupingSets)
    {
        /*
         * If we have grouping sets with expressions, we probably don't have
         * uniqueness and analysis would be hard. Punt.
         */
        if (query->groupClause)
            return false;

        /*
         * If we have no groupClause (therefore no grouping expressions), we
         * might have one or many empty grouping sets. If there's just one,
         * then we're returning only one row and are certainly unique. But
         * otherwise, we know we're certainly not unique.
         */
        if (list_length(query->groupingSets) == 1 &&
            ((GroupingSet *) linitial(query->groupingSets))->kind == GROUPING_SET_EMPTY)
            return true;
        else
            return false;
    }
    else
    {
        /*
         * If we have no GROUP BY, but do have aggregates or HAVING, then the
         * result is at most one row so it's surely unique, for any operators.
         */
        if (query->hasAggs || query->havingQual)
            return true;
    }

    /*
     * UNION, INTERSECT, EXCEPT guarantee uniqueness of the whole output row,
     * except with ALL.
     */
    if (query->setOperations)
    {
        SetOperationStmt *topop = castNode(SetOperationStmt, query->setOperations);

        Assert(topop->op != SETOP_NONE);

        if (!topop->all)
        {
            ListCell   *lg;

            /* We're good if all the nonjunk output columns are in colnos */
            lg = list_head(topop->groupClauses);
            foreach(l, query->targetList)
            {
                TargetEntry *tle = (TargetEntry *) lfirst(l);
                SortGroupClause *sgc;

                if (tle->resjunk)
                    continue;   /* ignore resjunk columns */

                /* non-resjunk columns should have grouping clauses */
                Assert(lg != NULL);
                sgc = (SortGroupClause *) lfirst(lg);
                lg = lnext(topop->groupClauses, lg);

                opid = distinct_col_search(tle->resno, colnos, opids);
                if (!OidIsValid(opid) ||
                    !equality_ops_are_compatible(opid, sgc->eqop))
                    break;      /* exit early if no match */
            }
            if (l == NULL)      /* had matches for all? */
                return true;
        }
    }

    /*
     * XXX Are there any other cases in which we can easily see the result
     * must be distinct?
     *
     * If you do add more smarts to this function, be sure to update
     * query_supports_distinctness() to match.
     */

    return false;
}

query_planner()

RelOptInfo* query_planner	(	PlannerInfo *	root,
		query_pathkeys_callback	qp_callback,
		void *	qp_extra
	)

Definition at line 55 of file planmain.c.

References add_base_rels_to_query(), add_other_rels_to_query(), add_path(), add_placeholders_to_base_rels(), Assert, build_base_rel_tlists(), build_simple_rel(), PlannerInfo::canon_pathkeys, RelOptInfo::cheapest_total_path, RelOptInfo::consider_parallel, create_group_result_path(), create_lateral_join_info(), deconstruct_jointree(), distribute_row_identity_vars(), PlannerInfo::ec_merging_done, elog, ERROR, extract_restriction_or_clauses(), find_lateral_references(), find_placeholders_in_jointree(), fix_placeholder_input_needed_levels(), PlannerInfo::fkey_list, force_parallel_mode, FORCE_PARALLEL_OFF, FromExpr::fromlist, PlannerInfo::full_join_clauses, generate_base_implied_equalities(), PlannerInfo::glob, PlannerInfo::initial_rels, is_parallel_safe(), IsA, PlannerInfo::join_cur_level, PlannerInfo::join_info_list, PlannerInfo::join_rel_hash, PlannerInfo::join_rel_level, PlannerInfo::join_rel_list, Query::jointree, PlannerInfo::left_join_clauses, linitial, list_length(), make_one_rel(), match_foreign_keys_to_quals(), NIL, PlannerGlobal::parallelModeOK, Path::param_info, parse(), PlannerInfo::parse, PlannerInfo::placeholder_list, PlannerInfo::processed_tlist, FromExpr::quals, reconsider_outer_join_clauses(), reduce_unique_semijoins(), RelOptInfo::reltarget, remove_useless_joins(), PlannerInfo::right_join_clauses, RTE_RESULT, RangeTblEntry::rtekind, set_cheapest(), setup_simple_rel_arrays(), and PlannerInfo::simple_rte_array.

Referenced by build_minmax_path(), and grouping_planner().

{
    Query      *parse = root->parse;
    List       *joinlist;
    RelOptInfo *final_rel;

    /*
     * Init planner lists to empty.
     *
     * NOTE: append_rel_list was set up by subquery_planner, so do not touch
     * here.
     */
    root->join_rel_list = NIL;
    root->join_rel_hash = NULL;
    root->join_rel_level = NULL;
    root->join_cur_level = 0;
    root->canon_pathkeys = NIL;
    root->left_join_clauses = NIL;
    root->right_join_clauses = NIL;
    root->full_join_clauses = NIL;
    root->join_info_list = NIL;
    root->placeholder_list = NIL;
    root->fkey_list = NIL;
    root->initial_rels = NIL;

    /*
     * Set up arrays for accessing base relations and AppendRelInfos.
     */
    setup_simple_rel_arrays(root);

    /*
     * In the trivial case where the jointree is a single RTE_RESULT relation,
     * bypass all the rest of this function and just make a RelOptInfo and its
     * one access path.  This is worth optimizing because it applies for
     * common cases like "SELECT expression" and "INSERT ... VALUES()".
     */
    Assert(parse->jointree->fromlist != NIL);
    if (list_length(parse->jointree->fromlist) == 1)
    {
        Node       *jtnode = (Node *) linitial(parse->jointree->fromlist);

        if (IsA(jtnode, RangeTblRef))
        {
            int         varno = ((RangeTblRef *) jtnode)->rtindex;
            RangeTblEntry *rte = root->simple_rte_array[varno];

            Assert(rte != NULL);
            if (rte->rtekind == RTE_RESULT)
            {
                /* Make the RelOptInfo for it directly */
                final_rel = build_simple_rel(root, varno, NULL);

                /*
                 * If query allows parallelism in general, check whether the
                 * quals are parallel-restricted.  (We need not check
                 * final_rel->reltarget because it's empty at this point.
                 * Anything parallel-restricted in the query tlist will be
                 * dealt with later.)  This is normally pretty silly, because
                 * a Result-only plan would never be interesting to
                 * parallelize.  However, if force_parallel_mode is on, then
                 * we want to execute the Result in a parallel worker if
                 * possible, so we must do this.
                 */
                if (root->glob->parallelModeOK &&
                    force_parallel_mode != FORCE_PARALLEL_OFF)
                    final_rel->consider_parallel =
                        is_parallel_safe(root, parse->jointree->quals);

                /*
                 * The only path for it is a trivial Result path.  We cheat a
                 * bit here by using a GroupResultPath, because that way we
                 * can just jam the quals into it without preprocessing them.
                 * (But, if you hold your head at the right angle, a FROM-less
                 * SELECT is a kind of degenerate-grouping case, so it's not
                 * that much of a cheat.)
                 */
                add_path(final_rel, (Path *)
                         create_group_result_path(root, final_rel,
                                                  final_rel->reltarget,
                                                  (List *) parse->jointree->quals));

                /* Select cheapest path (pretty easy in this case...) */
                set_cheapest(final_rel);

                /*
                 * We don't need to run generate_base_implied_equalities, but
                 * we do need to pretend that EC merging is complete.
                 */
                root->ec_merging_done = true;

                /*
                 * We still are required to call qp_callback, in case it's
                 * something like "SELECT 2+2 ORDER BY 1".
                 */
                (*qp_callback) (root, qp_extra);

                return final_rel;
            }
        }
    }

    /*
     * Construct RelOptInfo nodes for all base relations used in the query.
     * Appendrel member relations ("other rels") will be added later.
     *
     * Note: the reason we find the baserels by searching the jointree, rather
     * than scanning the rangetable, is that the rangetable may contain RTEs
     * for rels not actively part of the query, for example views.  We don't
     * want to make RelOptInfos for them.
     */
    add_base_rels_to_query(root, (Node *) parse->jointree);

    /*
     * Examine the targetlist and join tree, adding entries to baserel
     * targetlists for all referenced Vars, and generating PlaceHolderInfo
     * entries for all referenced PlaceHolderVars.  Restrict and join clauses
     * are added to appropriate lists belonging to the mentioned relations. We
     * also build EquivalenceClasses for provably equivalent expressions. The
     * SpecialJoinInfo list is also built to hold information about join order
     * restrictions.  Finally, we form a target joinlist for make_one_rel() to
     * work from.
     */
    build_base_rel_tlists(root, root->processed_tlist);

    find_placeholders_in_jointree(root);

    find_lateral_references(root);

    joinlist = deconstruct_jointree(root);

    /*
     * Reconsider any postponed outer-join quals now that we have built up
     * equivalence classes.  (This could result in further additions or
     * mergings of classes.)
     */
    reconsider_outer_join_clauses(root);

    /*
     * If we formed any equivalence classes, generate additional restriction
     * clauses as appropriate.  (Implied join clauses are formed on-the-fly
     * later.)
     */
    generate_base_implied_equalities(root);

    /*
     * We have completed merging equivalence sets, so it's now possible to
     * generate pathkeys in canonical form; so compute query_pathkeys and
     * other pathkeys fields in PlannerInfo.
     */
    (*qp_callback) (root, qp_extra);

    /*
     * Examine any "placeholder" expressions generated during subquery pullup.
     * Make sure that the Vars they need are marked as needed at the relevant
     * join level.  This must be done before join removal because it might
     * cause Vars or placeholders to be needed above a join when they weren't
     * so marked before.
     */
    fix_placeholder_input_needed_levels(root);

    /*
     * Remove any useless outer joins.  Ideally this would be done during
     * jointree preprocessing, but the necessary information isn't available
     * until we've built baserel data structures and classified qual clauses.
     */
    joinlist = remove_useless_joins(root, joinlist);

    /*
     * Also, reduce any semijoins with unique inner rels to plain inner joins.
     * Likewise, this can't be done until now for lack of needed info.
     */
    reduce_unique_semijoins(root);

    /*
     * Now distribute "placeholders" to base rels as needed.  This has to be
     * done after join removal because removal could change whether a
     * placeholder is evaluable at a base rel.
     */
    add_placeholders_to_base_rels(root);

    /*
     * Construct the lateral reference sets now that we have finalized
     * PlaceHolderVar eval levels.
     */
    create_lateral_join_info(root);

    /*
     * Match foreign keys to equivalence classes and join quals.  This must be
     * done after finalizing equivalence classes, and it's useful to wait till
     * after join removal so that we can skip processing foreign keys
     * involving removed relations.
     */
    match_foreign_keys_to_quals(root);

    /*
     * Look for join OR clauses that we can extract single-relation
     * restriction OR clauses from.
     */
    extract_restriction_or_clauses(root);

    /*
     * Now expand appendrels by adding "otherrels" for their children.  We
     * delay this to the end so that we have as much information as possible
     * available for each baserel, including all restriction clauses.  That
     * let us prune away partitions that don't satisfy a restriction clause.
     * Also note that some information such as lateral_relids is propagated
     * from baserels to otherrels here, so we must have computed it already.
     */
    add_other_rels_to_query(root);

    /*
     * Distribute any UPDATE/DELETE row identity variables to the target
     * relations.  This can't be done till we've finished expansion of
     * appendrels.
     */
    distribute_row_identity_vars(root);

    /*
     * Ready to do the primary planning.
     */
    final_rel = make_one_rel(root, joinlist);

    /* Check that we got at least one usable path */
    if (!final_rel || !final_rel->cheapest_total_path ||
        final_rel->cheapest_total_path->param_info != NULL)
        elog(ERROR, "failed to construct the join relation");

    return final_rel;
}

query_supports_distinctness()

bool query_supports_distinctness

(

Query *

query

)

Definition at line 738 of file analyzejoins.c.

References Query::distinctClause, Query::groupClause, Query::groupingSets, Query::hasAggs, Query::hasTargetSRFs, Query::havingQual, NIL, and Query::setOperations.

Referenced by create_unique_path(), and rel_supports_distinctness().

{
    /* SRFs break distinctness except with DISTINCT, see below */
    if (query->hasTargetSRFs && query->distinctClause == NIL)
        return false;

    /* check for features we can prove distinctness with */
    if (query->distinctClause != NIL ||
        query->groupClause != NIL ||
        query->groupingSets != NIL ||
        query->hasAggs ||
        query->havingQual ||
        query->setOperations)
        return true;

    return false;
}

record_plan_function_dependency()

void record_plan_function_dependency	(	PlannerInfo *	root,
		Oid	funcid
	)

Definition at line 2952 of file setrefs.c.

References PlanInvalItem::cacheId, FirstUnpinnedObjectId, GetSysCacheHashValue1, PlannerInfo::glob, PlanInvalItem::hashValue, PlannerGlobal::invalItems, lappend(), makeNode, ObjectIdGetDatum, and PROCOID.

Referenced by fix_expr_common(), inline_function(), and inline_set_returning_function().

{
    /*
     * For performance reasons, we don't bother to track built-in functions;
     * we just assume they'll never change (or at least not in ways that'd
     * invalidate plans using them).  For this purpose we can consider a
     * built-in function to be one with OID less than FirstUnpinnedObjectId.
     * Note that the OID generator guarantees never to generate such an OID
     * after startup, even at OID wraparound.
     */
    if (funcid >= (Oid) FirstUnpinnedObjectId)
    {
        PlanInvalItem *inval_item = makeNode(PlanInvalItem);

        /*
         * It would work to use any syscache on pg_proc, but the easiest is
         * PROCOID since we already have the function's OID at hand.  Note
         * that plancache.c knows we use PROCOID.
         */
        inval_item->cacheId = PROCOID;
        inval_item->hashValue = GetSysCacheHashValue1(PROCOID,
                                                      ObjectIdGetDatum(funcid));

        root->glob->invalItems = lappend(root->glob->invalItems, inval_item);
    }
}

record_plan_type_dependency()

void record_plan_type_dependency	(	PlannerInfo *	root,
		Oid	typid
	)

Definition at line 2992 of file setrefs.c.

References PlanInvalItem::cacheId, FirstUnpinnedObjectId, GetSysCacheHashValue1, PlannerInfo::glob, PlanInvalItem::hashValue, PlannerGlobal::invalItems, lappend(), makeNode, ObjectIdGetDatum, and TYPEOID.

Referenced by eval_const_expressions_mutator().

{
    /*
     * As in record_plan_function_dependency, ignore the possibility that
     * someone would change a built-in domain.
     */
    if (typid >= (Oid) FirstUnpinnedObjectId)
    {
        PlanInvalItem *inval_item = makeNode(PlanInvalItem);

        /*
         * It would work to use any syscache on pg_type, but the easiest is
         * TYPEOID since we already have the type's OID at hand.  Note that
         * plancache.c knows we use TYPEOID.
         */
        inval_item->cacheId = TYPEOID;
        inval_item->hashValue = GetSysCacheHashValue1(TYPEOID,
                                                      ObjectIdGetDatum(typid));

        root->glob->invalItems = lappend(root->glob->invalItems, inval_item);
    }
}

reduce_unique_semijoins()

void reduce_unique_semijoins

(

PlannerInfo *

root

)

Definition at line 508 of file analyzejoins.c.

References bms_get_singleton_member(), bms_union(), SpecialJoinInfo::delay_upper_joins, find_base_rel(), foreach_delete_current, generate_join_implied_equalities(), innerrel_is_unique(), PlannerInfo::join_info_list, JOIN_SEMI, RelOptInfo::joininfo, SpecialJoinInfo::jointype, lfirst, list_concat(), SpecialJoinInfo::min_lefthand, SpecialJoinInfo::min_righthand, and rel_supports_distinctness().

Referenced by query_planner().

{
    ListCell   *lc;

    /*
     * Scan the join_info_list to find semijoins.
     */
    foreach(lc, root->join_info_list)
    {
        SpecialJoinInfo *sjinfo = (SpecialJoinInfo *) lfirst(lc);
        int         innerrelid;
        RelOptInfo *innerrel;
        Relids      joinrelids;
        List       *restrictlist;

        /*
         * Must be a non-delaying semijoin to a single baserel, else we aren't
         * going to be able to do anything with it.  (It's probably not
         * possible for delay_upper_joins to be set on a semijoin, but we
         * might as well check.)
         */
        if (sjinfo->jointype != JOIN_SEMI ||
            sjinfo->delay_upper_joins)
            continue;

        if (!bms_get_singleton_member(sjinfo->min_righthand, &innerrelid))
            continue;

        innerrel = find_base_rel(root, innerrelid);

        /*
         * Before we trouble to run generate_join_implied_equalities, make a
         * quick check to eliminate cases in which we will surely be unable to
         * prove uniqueness of the innerrel.
         */
        if (!rel_supports_distinctness(root, innerrel))
            continue;

        /* Compute the relid set for the join we are considering */
        joinrelids = bms_union(sjinfo->min_lefthand, sjinfo->min_righthand);

        /*
         * Since we're only considering a single-rel RHS, any join clauses it
         * has must be clauses linking it to the semijoin's min_lefthand.  We
         * can also consider EC-derived join clauses.
         */
        restrictlist =
            list_concat(generate_join_implied_equalities(root,
                                                         joinrelids,
                                                         sjinfo->min_lefthand,
                                                         innerrel),
                        innerrel->joininfo);

        /* Test whether the innerrel is unique for those clauses. */
        if (!innerrel_is_unique(root,
                                joinrelids, sjinfo->min_lefthand, innerrel,
                                JOIN_SEMI, restrictlist, true))
            continue;

        /* OK, remove the SpecialJoinInfo from the list. */
        root->join_info_list = foreach_delete_current(root->join_info_list, lc);
    }
}

remove_useless_joins()

List* remove_useless_joins	(	PlannerInfo *	root,
		List *	joinlist
	)

Definition at line 61 of file analyzejoins.c.

References bms_singleton_member(), bms_union(), elog, ERROR, PlannerInfo::join_info_list, join_is_removable(), lfirst, list_delete_cell(), SpecialJoinInfo::min_lefthand, SpecialJoinInfo::min_righthand, remove_rel_from_joinlist(), and remove_rel_from_query().

Referenced by query_planner().

{
    ListCell   *lc;

    /*
     * We are only interested in relations that are left-joined to, so we can
     * scan the join_info_list to find them easily.
     */
restart:
    foreach(lc, root->join_info_list)
    {
        SpecialJoinInfo *sjinfo = (SpecialJoinInfo *) lfirst(lc);
        int         innerrelid;
        int         nremoved;

        /* Skip if not removable */
        if (!join_is_removable(root, sjinfo))
            continue;

        /*
         * Currently, join_is_removable can only succeed when the sjinfo's
         * righthand is a single baserel.  Remove that rel from the query and
         * joinlist.
         */
        innerrelid = bms_singleton_member(sjinfo->min_righthand);

        remove_rel_from_query(root, innerrelid,
                              bms_union(sjinfo->min_lefthand,
                                        sjinfo->min_righthand));

        /* We verify that exactly one reference gets removed from joinlist */
        nremoved = 0;
        joinlist = remove_rel_from_joinlist(joinlist, innerrelid, &nremoved);
        if (nremoved != 1)
            elog(ERROR, "failed to find relation %d in joinlist", innerrelid);

        /*
         * We can delete this SpecialJoinInfo from the list too, since it's no
         * longer of interest.  (Since we'll restart the foreach loop
         * immediately, we don't bother with foreach_delete_current.)
         */
        root->join_info_list = list_delete_cell(root->join_info_list, lc);

        /*
         * Restart the scan.  This is necessary to ensure we find all
         * removable joins independently of ordering of the join_info_list
         * (note that removal of attr_needed bits may make a join appear
         * removable that did not before).
         */
        goto restart;
    }

    return joinlist;
}

set_plan_references()

Plan* set_plan_references	(	PlannerInfo *	root,
		Plan *	plan
	)

Definition at line 250 of file setrefs.c.

References add_rtes_to_flat_rtable(), PlannerInfo::append_rel_list, PlannerGlobal::appendRelations, AppendRelInfo::child_relid, PlannerGlobal::finalrowmarks, PlannerGlobal::finalrtable, PlannerInfo::glob, lappend(), lfirst_node, list_length(), NIL, palloc(), AppendRelInfo::parent_relid, PlanRowMark::prti, PlannerInfo::rowMarks, PlanRowMark::rti, set_plan_refs(), and AppendRelInfo::translated_vars.

Referenced by set_subqueryscan_references(), and standard_planner().

{
    PlannerGlobal *glob = root->glob;
    int         rtoffset = list_length(glob->finalrtable);
    ListCell   *lc;

    /*
     * Add all the query's RTEs to the flattened rangetable.  The live ones
     * will have their rangetable indexes increased by rtoffset.  (Additional
     * RTEs, not referenced by the Plan tree, might get added after those.)
     */
    add_rtes_to_flat_rtable(root, false);

    /*
     * Adjust RT indexes of PlanRowMarks and add to final rowmarks list
     */
    foreach(lc, root->rowMarks)
    {
        PlanRowMark *rc = lfirst_node(PlanRowMark, lc);
        PlanRowMark *newrc;

        /* flat copy is enough since all fields are scalars */
        newrc = (PlanRowMark *) palloc(sizeof(PlanRowMark));
        memcpy(newrc, rc, sizeof(PlanRowMark));

        /* adjust indexes ... but *not* the rowmarkId */
        newrc->rti += rtoffset;
        newrc->prti += rtoffset;

        glob->finalrowmarks = lappend(glob->finalrowmarks, newrc);
    }

    /*
     * Adjust RT indexes of AppendRelInfos and add to final appendrels list.
     * We assume the AppendRelInfos were built during planning and don't need
     * to be copied.
     */
    foreach(lc, root->append_rel_list)
    {
        AppendRelInfo *appinfo = lfirst_node(AppendRelInfo, lc);

        /* adjust RT indexes */
        appinfo->parent_relid += rtoffset;
        appinfo->child_relid += rtoffset;

        /*
         * Rather than adjust the translated_vars entries, just drop 'em.
         * Neither the executor nor EXPLAIN currently need that data.
         */
        appinfo->translated_vars = NIL;

        glob->appendRelations = lappend(glob->appendRelations, appinfo);
    }

    /* Now fix the Plan tree */
    return set_plan_refs(root, plan, rtoffset);
}

Variable Documentation

cursor_tuple_fraction

double cursor_tuple_fraction

Definition at line 69 of file planner.c.

Referenced by standard_planner().

from_collapse_limit

int from_collapse_limit

Definition at line 39 of file initsplan.c.

Referenced by deconstruct_recurse().

join_collapse_limit

int join_collapse_limit

Definition at line 40 of file initsplan.c.

Referenced by deconstruct_recurse().