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, Cardinality numGroups, 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)
void	add_vars_to_attr_needed (PlannerInfo *root, List *vars, Relids where_needed)
void	remove_useless_groupby_columns (PlannerInfo *root)
void	setup_eager_aggregation (PlannerInfo *root)
void	find_lateral_references (PlannerInfo *root)
void	rebuild_lateral_attr_needed (PlannerInfo *root)
void	create_lateral_join_info (PlannerInfo *root)
List *	deconstruct_jointree (PlannerInfo *root)
bool	restriction_is_always_true (PlannerInfo *root, RestrictInfo *restrictinfo)
bool	restriction_is_always_false (PlannerInfo *root, RestrictInfo *restrictinfo)
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, Index security_level, bool both_const)
RestrictInfo *	build_implied_join_equality (PlannerInfo *root, Oid opno, Oid collation, Expr *item1, Expr *item2, Relids qualscope, Index security_level)
void	rebuild_joinclause_attr_needed (PlannerInfo *root)
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 *distinct_cols)
bool	innerrel_is_unique (PlannerInfo *root, Relids joinrelids, Relids outerrelids, RelOptInfo *innerrel, JoinType jointype, List *restrictlist, bool force_cache)
bool	innerrel_is_unique_ext (PlannerInfo *root, Relids joinrelids, Relids outerrelids, RelOptInfo *innerrel, JoinType jointype, List *restrictlist, bool force_cache, List **extra_clauses)
List *	remove_useless_self_joins (PlannerInfo *root, List *joinlist)
Plan *	set_plan_references (PlannerInfo *root, Plan *plan)
bool	trivial_subqueryscan (SubqueryScan *plan)
Param *	find_minmax_agg_replacement_param (PlannerInfo *root, Aggref *aggref)
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 *context)

Variables
PGDLLIMPORT double	cursor_tuple_fraction
PGDLLIMPORT bool	enable_self_join_elimination
PGDLLIMPORT int	from_collapse_limit
PGDLLIMPORT 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 26 of file planmain.h.

Function Documentation

add_base_rels_to_query()

void add_base_rels_to_query ( PlannerInfo *  root, Node *  jtnode  )

extern

Definition at line 178 of file initsplan.c.

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

References add_base_rels_to_query(), build_simple_rel(), elog, ERROR, fb(), FromExpr::fromlist, IsA, j, lfirst, nodeTag, and root.

Referenced by add_base_rels_to_query(), and query_planner().

add_other_rels_to_query()

void add_other_rels_to_query ( PlannerInfo *  root )

extern

Definition at line 216 of file initsplan.c.

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

References expand_inherited_rtentry(), fb(), RELOPT_BASEREL, RelOptInfo::reloptkind, and root.

Referenced by query_planner().

add_vars_to_attr_needed()

void add_vars_to_attr_needed ( PlannerInfo *  root, List *  vars, Relids  where_needed  )

extern

Definition at line 373 of file initsplan.c.

{
    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;
            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);
 
            phinfo->ph_needed = bms_add_members(phinfo->ph_needed,
                                                where_needed);
        }
        else
            elog(ERROR, "unrecognized node type: %d", (int) nodeTag(node));
    }
}

References Assert, bms_add_members(), bms_is_empty, bms_is_subset(), elog, ERROR, fb(), find_base_rel(), find_placeholder_info(), IsA, lfirst, RelOptInfo::min_attr, nodeTag, RelOptInfo::relids, root, Var::varattno, and Var::varno.

Referenced by rebuild_eclass_attr_needed(), rebuild_joinclause_attr_needed(), rebuild_lateral_attr_needed(), and rebuild_placeholder_attr_needed().

add_vars_to_targetlist()

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

extern

Definition at line 302 of file initsplan.c.

{
    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.
                 *
                 * The value available at the rel's scan level has not been
                 * nulled by any outer join, so drop its varnullingrels.
                 * (We'll put those back as we climb up the join tree.)
                 */
                var = copyObject(var);
                var->varnullingrels = NULL;
                rel->reltarget->exprs = lappend(rel->reltarget->exprs, 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);
 
            phinfo->ph_needed = bms_add_members(phinfo->ph_needed,
                                                where_needed);
        }
        else
            elog(ERROR, "unrecognized node type: %d", (int) nodeTag(node));
    }
}

References Assert, bms_add_members(), bms_is_empty, bms_is_subset(), copyObject, elog, ERROR, PathTarget::exprs, fb(), find_base_rel(), find_placeholder_info(), IsA, lappend(), lfirst, RelOptInfo::min_attr, nodeTag, RelOptInfo::relids, RelOptInfo::reltarget, root, 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().

build_base_rel_tlists()

void build_base_rel_tlists ( PlannerInfo *  root, List *  final_tlist  )

extern

Definition at line 255 of file initsplan.c.

{
    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));
        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));
            list_free(having_vars);
        }
    }
}

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

Referenced by distribute_row_identity_vars(), and query_planner().

build_implied_join_equality()

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

extern

Definition at line 3858 of file initsplan.c.

{
    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, /* !has_clone */
                                     false, /* !is_clone */
                                     false, /* pseudoconstant */
                                     security_level,    /* security_level */
                                     qualscope, /* required_relids */
                                     NULL,  /* incompatible_relids */
                                     NULL); /* outer_relids */
 
    /* Set mergejoinability/hashjoinability flags */
    check_mergejoinable(restrictinfo);
    check_hashjoinable(restrictinfo);
    check_memoizable(restrictinfo);
 
    return restrictinfo;
}

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

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

change_plan_targetlist()

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

extern

Definition at line 1992 of file createplan.c.

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

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

Referenced by create_nestloop_plan(), and postgresGetForeignPlan().

create_lateral_join_info()

void create_lateral_join_info ( PlannerInfo *  root )

extern

Definition at line 1283 of file initsplan.c.

{
    bool        found_laterals = false;
    Index       rti;
    ListCell   *lc;
 
    /* We need do nothing if the query contains no LATERAL RTEs */
    if (!root->hasLateralRTEs)
        return;
 
    /* We'll need to have the ph_eval_at values for PlaceHolderVars */
    Assert(root->placeholdersFrozen);
 
    /*
     * 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);
 
                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;
        Relids      lateral_refs;
        int         varno;
 
        if (phinfo->ph_lateral == NULL)
            continue;           /* PHV is uninteresting if no lateral refs */
 
        found_laterals = true;
 
        /*
         * Include only baserels not outer joins in the evaluation sites'
         * lateral relids.  This avoids problems when outer join order gets
         * rearranged, and it should still ensure that the lateral values are
         * available when needed.
         */
        lateral_refs = bms_intersect(phinfo->ph_lateral, root->all_baserels);
        Assert(!bms_is_empty(lateral_refs));
 
        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,
                                lateral_refs);
            brel->lateral_relids =
                bms_add_members(brel->lateral_relids,
                                lateral_refs);
        }
        else
        {
            /* Evaluation site is a join */
            varno = -1;
            while ((varno = bms_next_member(eval_at, varno)) >= 0)
            {
                RelOptInfo *brel = find_base_rel_ignore_join(root, varno);
 
                if (brel == NULL)
                    continue;   /* ignore outer joins in eval_at */
                brel->lateral_relids = bms_add_members(brel->lateral_relids,
                                                       lateral_refs);
            }
        }
    }
 
    /*
     * 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 (bms_is_empty(lateral_relids))
            continue;
 
        /* 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];
 
            if (brel2 == NULL)
                continue;       /* must be an OJ */
 
            Assert(brel2->reloptkind == RELOPT_BASEREL);
            brel2->lateral_referencers =
                bms_add_member(brel2->lateral_referencers, rti);
        }
    }
}

References Assert, bms_add_member(), bms_add_members(), bms_copy(), bms_get_singleton_member(), bms_intersect(), bms_is_empty, bms_is_member(), bms_next_member(), fb(), find_base_rel(), find_base_rel_ignore_join(), find_placeholder_info(), IsA, RelOptInfo::lateral_relids, lfirst, RELOPT_BASEREL, root, and Var::varno.

Referenced by query_planner().

create_plan()

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

extern

Definition at line 339 of file createplan.c.

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

References apply_tlist_labeling(), Assert, CP_EXACT_TLIST, create_plan_recurse(), elog, ERROR, fb(), IsA, NIL, plan, root, and SS_attach_initplans().

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

deconstruct_jointree()

List * deconstruct_jointree ( PlannerInfo *  root )

extern

Definition at line 1522 of file initsplan.c.

{
    List       *result;
    JoinDomain *top_jdomain;
    List       *item_list = NIL;
    ListCell   *lc;
 
    /*
     * After this point, no more PlaceHolderInfos may be made, because
     * make_outerjoininfo requires all active placeholders to be present in
     * root->placeholder_list while we crawl up the join tree.
     */
    root->placeholdersFrozen = true;
 
    /* Fetch the already-created top-level join domain for the query */
    top_jdomain = linitial_node(JoinDomain, root->join_domains);
    top_jdomain->jd_relids = NULL;  /* filled during deconstruct_recurse */
 
    /* Start recursion at top of jointree */
    Assert(root->parse->jointree != NULL &&
           IsA(root->parse->jointree, FromExpr));
 
    /* These are filled as we scan the jointree */
    root->all_baserels = NULL;
    root->outer_join_rels = NULL;
 
    /* Perform the initial scan of the jointree */
    result = deconstruct_recurse(root, (Node *) root->parse->jointree,
                                 top_jdomain, NULL,
                                 &item_list);
 
    /* Now we can form the value of all_query_rels, too */
    root->all_query_rels = bms_union(root->all_baserels, root->outer_join_rels);
 
    /* ... which should match what we computed for the top join domain */
    Assert(bms_equal(root->all_query_rels, top_jdomain->jd_relids));
 
    /* Now scan all the jointree nodes again, and distribute quals */
    foreach(lc, item_list)
    {
        JoinTreeItem *jtitem = (JoinTreeItem *) lfirst(lc);
 
        deconstruct_distribute(root, jtitem);
    }
 
    /*
     * If there were any special joins then we may have some postponed LEFT
     * JOIN clauses to deal with.
     */
    if (root->join_info_list)
    {
        foreach(lc, item_list)
        {
            JoinTreeItem *jtitem = (JoinTreeItem *) lfirst(lc);
 
            if (jtitem->oj_joinclauses != NIL)
                deconstruct_distribute_oj_quals(root, item_list, jtitem);
        }
    }
 
    /* Don't need the JoinTreeItems any more */
    list_free_deep(item_list);
 
    return result;
}

References Assert, bms_equal(), bms_union(), deconstruct_distribute(), deconstruct_distribute_oj_quals(), deconstruct_recurse(), fb(), IsA, lfirst, linitial_node, list_free_deep(), NIL, result, and root.

Referenced by query_planner().

distribute_restrictinfo_to_rels()

void distribute_restrictinfo_to_rels ( PlannerInfo *  root, RestrictInfo *  restrictinfo  )

extern

Definition at line 3629 of file initsplan.c.

{
    Relids      relids = restrictinfo->required_relids;
 
    if (!bms_is_empty(relids))
    {
        int         relid;
 
        if (bms_get_singleton_member(relids, &relid))
        {
            /*
             * There is only one relation participating in the clause, so it
             * is a restriction clause for that relation.
             */
            add_base_clause_to_rel(root, relid, restrictinfo);
        }
        else
        {
            /*
             * 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);
        }
    }
    else
    {
        /*
         * 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");
    }
}

References add_base_clause_to_rel(), add_join_clause_to_rels(), bms_get_singleton_member(), bms_is_empty, check_hashjoinable(), check_memoizable(), elog, ERROR, fb(), and root.

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

extract_query_dependencies_walker()

bool extract_query_dependencies_walker ( Node *  node, PlannerInfo *  context  )

extern

Definition at line 3749 of file setrefs.c.

{
    if (node == NULL)
        return false;
    Assert(!IsA(node, PlaceHolderVar));
    if (IsA(node, Query))
    {
        Query      *query = (Query *) node;
        ListCell   *lc;
 
        if (query->commandType == CMD_UTILITY)
        {
            /*
             * This logic must handle any utility command for which parse
             * analysis was nontrivial (cf. stmt_requires_parse_analysis).
             *
             * Notably, CALL requires its own processing.
             */
            if (IsA(query->utilityStmt, CallStmt))
            {
                CallStmt   *callstmt = (CallStmt *) query->utilityStmt;
 
                /* We need not examine funccall, just the transformed exprs */
                (void) extract_query_dependencies_walker((Node *) callstmt->funcexpr,
                                                         context);
                (void) extract_query_dependencies_walker((Node *) callstmt->outargs,
                                                         context);
                return false;
            }
 
            /*
             * Ignore other utility statements, except those (such as EXPLAIN)
             * that contain a parsed-but-not-planned query.  For those, we
             * just need to transfer our attention to the contained 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 ||
                (rte->rtekind == RTE_SUBQUERY && OidIsValid(rte->relid)) ||
                (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,
                                 context, 0);
    }
    /* Extract function dependencies and check for regclass Consts */
    fix_expr_common(context, node);
    return expression_tree_walker(node, extract_query_dependencies_walker,
                                  context);
}

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

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

find_lateral_references()

void find_lateral_references ( PlannerInfo *  root )

extern

Definition at line 1096 of file initsplan.c.

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

References Assert, extract_lateral_references(), fb(), RELOPT_BASEREL, and root.

Referenced by query_planner().

find_minmax_agg_replacement_param()

Param * find_minmax_agg_replacement_param ( PlannerInfo *  root, Aggref *  aggref  )

extern

Definition at line 3599 of file setrefs.c.

{
    if (root->minmax_aggs != NIL &&
        list_length(aggref->args) == 1)
    {
        TargetEntry *curTarget = (TargetEntry *) linitial(aggref->args);
        ListCell   *lc;
 
        foreach(lc, root->minmax_aggs)
        {
            MinMaxAggInfo *mminfo = (MinMaxAggInfo *) lfirst(lc);
 
            if (mminfo->aggfnoid == aggref->aggfnoid &&
                equal(mminfo->target, curTarget->expr))
                return mminfo->param;
        }
    }
    return NULL;
}

References Aggref::aggfnoid, Aggref::args, equal(), fb(), lfirst, linitial, list_length(), NIL, MinMaxAggInfo::param, and root.

Referenced by finalize_primnode(), fix_scan_expr_mutator(), and fix_upper_expr_mutator().

innerrel_is_unique()

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

extern

Definition at line 1357 of file analyzejoins.c.

{
    return innerrel_is_unique_ext(root, joinrelids, outerrelids, innerrel,
                                  jointype, restrictlist, force_cache, NULL);
}

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

Referenced by add_paths_to_joinrel(), and reduce_unique_semijoins().

innerrel_is_unique_ext()

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

extern

Definition at line 1379 of file analyzejoins.c.

{
    MemoryContext old_context;
    ListCell   *lc;
    UniqueRelInfo *uniqueRelInfo;
    List       *outer_exprs = NIL;
    bool        self_join = (extra_clauses != NULL);
 
    /* 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.  For non-self-join search, 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). For self-join search, we require an exact match of
     * outerrels because we need extra clauses to be valid for our case. Also,
     * for self-join checking we've filtered the clauses list.  Thus, we can
     * match only the result cached for a self-join search for another
     * self-join check.
     */
    foreach(lc, innerrel->unique_for_rels)
    {
        uniqueRelInfo = (UniqueRelInfo *) lfirst(lc);
 
        if ((!self_join && bms_is_subset(uniqueRelInfo->outerrelids, outerrelids)) ||
            (self_join && bms_equal(uniqueRelInfo->outerrelids, outerrelids) &&
             uniqueRelInfo->self_join))
        {
            if (extra_clauses)
                *extra_clauses = uniqueRelInfo->extra_clauses;
            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,
                               self_join ? &outer_exprs : NULL))
    {
        /*
         * 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);
        uniqueRelInfo = makeNode(UniqueRelInfo);
        uniqueRelInfo->outerrelids = bms_copy(outerrelids);
        uniqueRelInfo->self_join = self_join;
        uniqueRelInfo->extra_clauses = outer_exprs;
        innerrel->unique_for_rels = lappend(innerrel->unique_for_rels,
                                            uniqueRelInfo);
        MemoryContextSwitchTo(old_context);
 
        if (extra_clauses)
            *extra_clauses = outer_exprs;
        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's only useful when using GEQO or
         * another planner extension that attempts planning multiple times.
         *
         * 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->assumeReplanning)
        {
            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;
    }
}

References bms_copy(), bms_equal(), bms_is_subset(), fb(), is_innerrel_unique_for(), lappend(), lfirst, makeNode, MemoryContextSwitchTo(), NIL, RelOptInfo::non_unique_for_rels, rel_supports_distinctness(), root, and RelOptInfo::unique_for_rels.

Referenced by innerrel_is_unique(), and remove_self_joins_one_group().

is_projection_capable_path()

bool is_projection_capable_path ( Path *  path )

extern

Definition at line 7231 of file createplan.c.

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

References castNode, CUSTOMPATH_SUPPORT_PROJECTION, fb(), IS_DUMMY_APPEND, and Path::pathtype.

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

is_projection_capable_plan()

bool is_projection_capable_plan ( Plan *  plan )

extern

Definition at line 7281 of file createplan.c.

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

References CUSTOMPATH_SUPPORT_PROJECTION, fb(), nodeTag, and plan.

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

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, Cardinality  numGroups, Size  transitionSpace, Plan *  lefttree  )

extern

Definition at line 6583 of file createplan.c.

{
    Agg        *node = makeNode(Agg);
    Plan       *plan = &node->plan;
 
    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;
}

References Agg::aggParams, Agg::aggsplit, Agg::aggstrategy, Agg::chain, fb(), Agg::groupingSets, makeNode, Agg::numCols, Agg::numGroups, Agg::plan, plan, Plan::righttree, and Agg::transitionSpace.

Referenced by create_agg_plan(), and create_groupingsets_plan().

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  )

extern

Definition at line 5803 of file createplan.c.

{
    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;
 
    /* checkAsUser, fs_server will be filled in by create_foreignscan_plan */
    node->checkAsUser = InvalidOid;
    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, fs_base_relids will be filled by create_foreignscan_plan */
    node->fs_relids = NULL;
    node->fs_base_relids = NULL;
    /* fsSystemCol will be filled in by create_foreignscan_plan */
    node->fsSystemCol = false;
 
    return node;
}

References ForeignScan::checkAsUser, CMD_SELECT, fb(), ForeignScan::fdw_exprs, ForeignScan::fdw_private, ForeignScan::fdw_recheck_quals, ForeignScan::fdw_scan_tlist, ForeignScan::fs_base_relids, ForeignScan::fs_relids, ForeignScan::fs_server, ForeignScan::fsSystemCol, InvalidOid, makeNode, ForeignScan::operation, plan, ForeignScan::resultRelation, Plan::righttree, ForeignScan::scan, and Scan::scanrelid.

Referenced by fileGetForeignPlan(), and postgresGetForeignPlan().

make_limit()

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

extern

Definition at line 6902 of file createplan.c.

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

References fb(), Limit::limitCount, Limit::limitOffset, Limit::limitOption, makeNode, NIL, Limit::plan, plan, Plan::righttree, Plan::targetlist, and Limit::uniqNumCols.

Referenced by create_limit_plan(), and create_minmaxagg_plan().

make_sort_from_sortclauses()

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

extern

Definition at line 6397 of file createplan.c.

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

References exprCollation(), fb(), get_sortgroupclause_tle(), lfirst, list_length(), make_sort(), palloc(), and Plan::targetlist.

match_foreign_keys_to_quals()

void match_foreign_keys_to_quals ( PlannerInfo *  root )

extern

Definition at line 4033 of file initsplan.c.

{
    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, or has been removed by join
         * removal, so that it 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).
         */
        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.
         */
        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;
 
                /* 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;
}

References OpExpr::args, RestrictInfo::clause, EquivalenceClass::ec_has_const, fb(), get_commutator(), get_leftop(), get_rightop(), InvalidOid, IsA, lappend(), lfirst, list_length(), match_eclasses_to_foreign_key_col(), NIL, OidIsValid, OpExpr::opno, RELOPT_BASEREL, and root.

Referenced by query_planner().

materialize_finished_plan()

Plan * materialize_finished_plan ( Plan *  subplan )

extern

Definition at line 6509 of file createplan.c.

{
    Plan       *matplan;
    Path        matpath;        /* dummy for cost_material */
    Cost        initplan_cost;
    bool        unsafe_initplans;
 
    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.
     */
    matplan->initPlan = subplan->initPlan;
    subplan->initPlan = NIL;
 
    /* Move the initplans' cost delta, as well */
    SS_compute_initplan_cost(matplan->initPlan,
                             &initplan_cost, &unsafe_initplans);
    subplan->startup_cost -= initplan_cost;
    subplan->total_cost -= initplan_cost;
 
    /* Set cost data */
    cost_material(&matpath,
                  enable_material,
                  subplan->disabled_nodes,
                  subplan->startup_cost,
                  subplan->total_cost,
                  subplan->plan_rows,
                  subplan->plan_width);
    matplan->disabled_nodes = subplan->disabled_nodes;
    matplan->startup_cost = matpath.startup_cost + initplan_cost;
    matplan->total_cost = matpath.total_cost + initplan_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;
}

References cost_material(), Plan::disabled_nodes, enable_material, fb(), Plan::initPlan, make_material(), NIL, Plan::parallel_safe, Plan::plan_rows, Plan::plan_width, SS_compute_initplan_cost(), Plan::startup_cost, and Plan::total_cost.

Referenced by build_subplan(), and standard_planner().

preprocess_minmax_aggregates()

void preprocess_minmax_aggregates ( PlannerInfo *  root )

extern

Definition at line 74 of file planagg.c.

{
    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;
 
    /*
     * Examine 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, reverse))
            continue;
        if (build_minmax_path(root, mminfo, eqop, mminfo->aggsortop, reverse, !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));
}

References add_path(), Assert, build_minmax_path(), can_minmax_aggs(), create_minmaxagg_path(), create_pathtarget, elog, ERROR, exprCollation(), exprType(), fb(), fetch_upper_rel(), FromExpr::fromlist, get_equality_op_for_ordering_op(), IsA, lfirst, linitial, list_length(), NIL, OidIsValid, MinMaxAggInfo::param, parse(), planner_rt_fetch, root, RTE_RELATION, RTE_SUBQUERY, SS_make_initplan_output_param(), and UPPERREL_GROUP_AGG.

Referenced by grouping_planner().

process_implied_equality()

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

extern

Definition at line 3714 of file initsplan.c.

{
    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 it as a gating qual at the appropriate level (see comments for
     * get_join_domain_min_rels).
     */
    if (bms_is_empty(relids))
    {
        /* eval at join domain's safe level */
        relids = get_join_domain_min_rels(root, qualscope);
        /* mark as gating qual */
        pseudoconstant = true;
        /* tell createplan.c to check for gating quals */
        root->hasPseudoConstantQuals = true;
    }
 
    /*
     * Build the RestrictInfo node itself.
     */
    restrictinfo = make_restrictinfo(root,
                                     (Expr *) clause,
                                     true,  /* is_pushed_down */
                                     false, /* !has_clone */
                                     false, /* !is_clone */
                                     pseudoconstant,
                                     security_level,
                                     relids,
                                     NULL,  /* incompatible_relids */
                                     NULL); /* outer_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.
     *
     * See also rebuild_joinclause_attr_needed, which has to partially repeat
     * this work after removal of an outer join.  (Since we will put this
     * clause into the joininfo lists, that function needn't do any extra work
     * to find it.)
     */
    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);
        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;
}

References add_vars_to_targetlist(), Assert, bms_is_empty, bms_is_subset(), bms_membership(), BMS_MULTIPLE, check_mergejoinable(), copyObject, DatumGetBool(), distribute_restrictinfo_to_rels(), eval_const_expressions(), fb(), get_join_domain_min_rels(), InvalidOid, IsA, list_free(), make_opclause(), make_restrictinfo(), pull_var_clause(), pull_varnos(), PVC_INCLUDE_PLACEHOLDERS, PVC_RECURSE_AGGREGATES, PVC_RECURSE_WINDOWFUNCS, and root.

Referenced by generate_base_implied_equalities_const(), and generate_base_implied_equalities_no_const().

query_is_distinct_for()

bool query_is_distinct_for ( Query *  query, List *  distinct_cols  )

extern

Definition at line 1161 of file analyzejoins.c.

{
    ListCell   *l;
    DistinctColInfo *dcinfo;
 
    /*
     * 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);
 
            dcinfo = distinct_col_search(tle->resno, distinct_cols);
            if (dcinfo == NULL ||
                !equality_ops_are_compatible(dcinfo->opid, sgc->eqop) ||
                !collations_agree_on_equality(dcinfo->collid,
                                              exprCollation((Node *) tle->expr)))
                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);
 
            dcinfo = distinct_col_search(tle->resno, distinct_cols);
            if (dcinfo == NULL ||
                !equality_ops_are_compatible(dcinfo->opid, sgc->eqop) ||
                !collations_agree_on_equality(dcinfo->collid,
                                              exprCollation((Node *) tle->expr)))
                break;          /* exit early if no match */
        }
        if (l == NULL)          /* had matches for all? */
            return true;
    }
    else if (query->groupingSets)
    {
        List       *gsets;
 
        /*
         * 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,
         * or if the DISTINCT clause is used on the GROUP BY, then we're
         * returning only one row and are certainly unique.  But otherwise, we
         * know we're certainly not unique.
         */
        if (query->groupDistinct)
            return true;
 
        gsets = expand_grouping_sets(query->groupingSets, false, -1);
 
        return (list_length(gsets) == 1);
    }
    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);
 
                dcinfo = distinct_col_search(tle->resno, distinct_cols);
                if (dcinfo == NULL ||
                    !equality_ops_are_compatible(dcinfo->opid, sgc->eqop) ||
                    !collations_agree_on_equality(dcinfo->collid,
                                                  exprCollation((Node *) tle->expr)))
                    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;
}

References Assert, castNode, collations_agree_on_equality(), distinct_col_search(), Query::distinctClause, equality_ops_are_compatible(), expand_grouping_sets(), exprCollation(), fb(), get_sortgroupclause_tle(), Query::groupClause, Query::groupDistinct, Query::groupingSets, Query::havingQual, lfirst, list_head(), list_length(), lnext(), SETOP_NONE, Query::setOperations, and Query::targetList.

Referenced by rel_is_distinct_for().

query_planner()

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

extern

Definition at line 54 of file planmain.c.

{
    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->placeholder_array = NULL;
    root->placeholder_array_size = 0;
    root->agg_clause_list = NIL;
    root->group_expr_list = NIL;
    root->tlist_vars = 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.)  We should always do this in a subquery,
                 * since it might be useful to use the subquery in parallel
                 * paths in the parent level.  At top level this is normally
                 * not worth the cycles, because a Result-only plan would
                 * never be interesting to parallelize.  However, if
                 * debug_parallel_query is on, then we want to execute the
                 * Result in a parallel worker if possible, so we must check.
                 */
                if (root->glob->parallelModeOK &&
                    (root->query_level > 1 ||
                     debug_parallel_query != DEBUG_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);
 
    /* Remove any redundant GROUP BY columns */
    remove_useless_groupby_columns(root);
 
    /*
     * 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);
 
    /*
     * Remove self joins on a unique column.
     */
    joinlist = remove_useless_self_joins(root, joinlist);
 
    /*
     * 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);
 
    /*
     * Check if eager aggregation is applicable, and if so, set up
     * root->agg_clause_list and root->group_expr_list.
     */
    setup_eager_aggregation(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/MERGE 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;
}

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(), create_group_result_path(), create_lateral_join_info(), DEBUG_PARALLEL_OFF, debug_parallel_query, deconstruct_jointree(), distribute_row_identity_vars(), elog, ERROR, extract_restriction_or_clauses(), fb(), find_lateral_references(), find_placeholders_in_jointree(), fix_placeholder_input_needed_levels(), generate_base_implied_equalities(), is_parallel_safe(), IsA, linitial, list_length(), make_one_rel(), match_foreign_keys_to_quals(), NIL, parse(), reconsider_outer_join_clauses(), reduce_unique_semijoins(), remove_useless_groupby_columns(), remove_useless_joins(), remove_useless_self_joins(), root, RTE_RESULT, set_cheapest(), setup_eager_aggregation(), and setup_simple_rel_arrays().

Referenced by build_minmax_path(), and grouping_planner().

query_supports_distinctness()

bool query_supports_distinctness ( Query *  query )

extern

Definition at line 1114 of file analyzejoins.c.

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

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

Referenced by rel_supports_distinctness().

rebuild_joinclause_attr_needed()

void rebuild_joinclause_attr_needed ( PlannerInfo *  root )

extern

Definition at line 3961 of file initsplan.c.

{
    /*
     * We must examine all join clauses, but there's no value in processing
     * any join clause more than once.  So it's slightly annoying that we have
     * to find them via the per-base-relation joininfo lists.  Avoid duplicate
     * processing by tracking the rinfo_serial numbers of join clauses we've
     * already seen.  (This doesn't work for is_clone clauses, so we must
     * waste effort on them.)
     */
    Bitmapset  *seen_serials = NULL;
    Index       rti;
 
    /* Scan all baserels for join clauses */
    for (rti = 1; rti < root->simple_rel_array_size; rti++)
    {
        RelOptInfo *brel = root->simple_rel_array[rti];
        ListCell   *lc;
 
        if (brel == NULL)
            continue;
        if (brel->reloptkind != RELOPT_BASEREL)
            continue;
 
        foreach(lc, brel->joininfo)
        {
            RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
            Relids      relids = rinfo->required_relids;
 
            if (!rinfo->is_clone)   /* else serial number is not unique */
            {
                if (bms_is_member(rinfo->rinfo_serial, seen_serials))
                    continue;   /* saw it already */
                seen_serials = bms_add_member(seen_serials,
                                              rinfo->rinfo_serial);
            }
 
            if (bms_membership(relids) == BMS_MULTIPLE)
            {
                List       *vars = pull_var_clause((Node *) rinfo->clause,
                                                   PVC_RECURSE_AGGREGATES |
                                                   PVC_RECURSE_WINDOWFUNCS |
                                                   PVC_INCLUDE_PLACEHOLDERS);
                Relids      where_needed;
 
                if (rinfo->is_clone)
                    where_needed = bms_intersect(relids, root->all_baserels);
                else
                    where_needed = relids;
                add_vars_to_attr_needed(root, vars, where_needed);
                list_free(vars);
            }
        }
    }
}

References add_vars_to_attr_needed(), bms_add_member(), bms_intersect(), bms_is_member(), bms_membership(), BMS_MULTIPLE, RestrictInfo::clause, fb(), RestrictInfo::is_clone, lfirst, list_free(), pull_var_clause(), PVC_INCLUDE_PLACEHOLDERS, PVC_RECURSE_AGGREGATES, PVC_RECURSE_WINDOWFUNCS, RELOPT_BASEREL, RestrictInfo::required_relids, RestrictInfo::rinfo_serial, and root.

Referenced by remove_leftjoinrel_from_query(), and remove_self_join_rel().

rebuild_lateral_attr_needed()

void rebuild_lateral_attr_needed ( PlannerInfo *  root )

extern

Definition at line 1245 of file initsplan.c.

{
    Index       rti;
 
    /* We need do nothing if the query contains no LATERAL RTEs */
    if (!root->hasLateralRTEs)
        return;
 
    /* Examine the same baserels that find_lateral_references did */
    for (rti = 1; rti < root->simple_rel_array_size; rti++)
    {
        RelOptInfo *brel = root->simple_rel_array[rti];
        Relids      where_needed;
 
        if (brel == NULL)
            continue;
        if (brel->reloptkind != RELOPT_BASEREL)
            continue;
 
        /*
         * We don't need to repeat all of extract_lateral_references, since it
         * kindly saved the extracted Vars/PHVs in lateral_vars.
         */
        if (brel->lateral_vars == NIL)
            continue;
 
        where_needed = bms_make_singleton(rti);
 
        add_vars_to_attr_needed(root, brel->lateral_vars, where_needed);
    }
}

References add_vars_to_attr_needed(), bms_make_singleton(), fb(), NIL, RELOPT_BASEREL, and root.

Referenced by remove_leftjoinrel_from_query(), and remove_self_join_rel().

record_plan_function_dependency()

void record_plan_function_dependency ( PlannerInfo *  root, Oid  funcid  )

extern

Definition at line 3632 of file setrefs.c.

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

References fb(), FirstUnpinnedObjectId, GetSysCacheHashValue1, lappend(), makeNode, ObjectIdGetDatum(), and root.

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

record_plan_type_dependency()

void record_plan_type_dependency ( PlannerInfo *  root, Oid  typid  )

extern

Definition at line 3672 of file setrefs.c.

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

References fb(), FirstUnpinnedObjectId, GetSysCacheHashValue1, lappend(), makeNode, ObjectIdGetDatum(), and root.

Referenced by eval_const_expressions_mutator().

reduce_unique_semijoins()

void reduce_unique_semijoins ( PlannerInfo *  root )

extern

Definition at line 875 of file analyzejoins.c.

{
    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 semijoin to a single baserel, else we aren't going to be
         * able to do anything with it.
         */
        if (sjinfo->jointype != JOIN_SEMI)
            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);
        Assert(sjinfo->ojrelid == 0);   /* SEMI joins don't have RT indexes */
 
        /*
         * 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,
                                                         NULL),
                        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);
    }
}

References Assert, bms_get_singleton_member(), bms_union(), fb(), find_base_rel(), foreach_delete_current, generate_join_implied_equalities(), innerrel_is_unique(), JOIN_SEMI, RelOptInfo::joininfo, SpecialJoinInfo::jointype, lfirst, list_concat(), SpecialJoinInfo::min_lefthand, SpecialJoinInfo::min_righthand, SpecialJoinInfo::ojrelid, rel_supports_distinctness(), and root.

Referenced by query_planner().

remove_useless_groupby_columns()

void remove_useless_groupby_columns ( PlannerInfo *  root )

extern

Definition at line 432 of file initsplan.c.

{
    Query      *parse = root->parse;
    Bitmapset **groupbyattnos;
    List      **groupbycols;
    Bitmapset **surplusvars;
    bool        tryremove = false;
    ListCell   *lc;
    int         relid;
 
    /* No chance to do anything if there are less than two GROUP BY items */
    if (list_length(root->processed_groupClause) < 2)
        return;
 
    /* Don't fiddle with the GROUP BY clause if the query has grouping sets */
    if (parse->groupingSets)
        return;
 
    /*
     * Scan the GROUP BY clause to find GROUP BY items that are simple Vars.
     * Fill groupbyattnos[k] with a bitmapset of the column attnos of RTE k
     * that are GROUP BY items, and groupbycols[k] with a parallel list of
     * GroupByColInfo records.  We need the latter so that, when checking a
     * unique index against this rel's GROUP BY items, we can verify that the
     * index's notion of equality agrees with at least one GROUP BY item per
     * index column.
     */
    groupbyattnos = palloc0_array(Bitmapset *, list_length(parse->rtable) + 1);
    groupbycols = palloc0_array(List *, list_length(parse->rtable) + 1);
    foreach(lc, root->processed_groupClause)
    {
        SortGroupClause *sgc = lfirst_node(SortGroupClause, lc);
        TargetEntry *tle = get_sortgroupclause_tle(sgc, parse->targetList);
        Var        *var = (Var *) tle->expr;
        GroupByColInfo *info;
 
        /*
         * Ignore non-Vars and Vars from other query levels.
         *
         * XXX in principle, stable expressions containing Vars could also be
         * removed, if all the Vars are functionally dependent on other GROUP
         * BY items.  But it's not clear that such cases occur often enough to
         * be worth troubling over.
         */
        if (!IsA(var, Var) ||
            var->varlevelsup > 0)
            continue;
 
        /* OK, remember we have this Var */
        relid = var->varno;
        Assert(relid <= list_length(parse->rtable));
 
        /*
         * If this isn't the first column for this relation then we now have
         * multiple columns.  That means there might be some that can be
         * removed.
         */
        tryremove |= !bms_is_empty(groupbyattnos[relid]);
        groupbyattnos[relid] = bms_add_member(groupbyattnos[relid],
                                              var->varattno - FirstLowInvalidHeapAttributeNumber);
 
        info = palloc(sizeof(GroupByColInfo));
        info->attno = var->varattno;
        info->eq_opfamilies = get_mergejoin_opfamilies(sgc->eqop);
        info->coll = var->varcollid;
        groupbycols[relid] = lappend(groupbycols[relid], info);
    }
 
    /*
     * No Vars or didn't find multiple Vars for any relation in the GROUP BY?
     * If so, nothing can be removed, so don't waste more effort trying.
     */
    if (!tryremove)
        return;
 
    /*
     * Consider each relation and see if it is possible to remove some of its
     * Vars from GROUP BY.  For simplicity and speed, we do the actual removal
     * in a separate pass.  Here, we just fill surplusvars[k] with a bitmapset
     * of the column attnos of RTE k that are removable GROUP BY items.
     */
    surplusvars = NULL;         /* don't allocate array unless required */
    relid = 0;
    foreach(lc, parse->rtable)
    {
        RangeTblEntry *rte = lfirst_node(RangeTblEntry, lc);
        RelOptInfo *rel;
        Bitmapset  *relattnos;
        Bitmapset  *best_keycolumns = NULL;
        int32       best_nkeycolumns = PG_INT32_MAX;
 
        relid++;
 
        /* Only plain relations could have primary-key constraints */
        if (rte->rtekind != RTE_RELATION)
            continue;
 
        /*
         * We must skip inheritance parent tables as some of the child rels
         * may cause duplicate rows.  This cannot happen with partitioned
         * tables, however.
         */
        if (rte->inh && rte->relkind != RELKIND_PARTITIONED_TABLE)
            continue;
 
        /* Nothing to do unless this rel has multiple Vars in GROUP BY */
        relattnos = groupbyattnos[relid];
        if (bms_membership(relattnos) != BMS_MULTIPLE)
            continue;
 
        rel = root->simple_rel_array[relid];
 
        /*
         * Now check each index for this relation to see if there are any with
         * columns which are a proper subset of the grouping columns for this
         * relation.
         */
        foreach_node(IndexOptInfo, index, rel->indexlist)
        {
            Bitmapset  *ind_attnos;
            bool        index_check_ok;
 
            /*
             * Skip any non-unique and deferrable indexes.  Predicate indexes
             * have not been checked yet, so we must skip those too as the
             * predOK check that's done later might fail.
             */
            if (!index->unique || !index->immediate || index->indpred != NIL)
                continue;
 
            /* For simplicity, we currently don't support expression indexes */
            if (index->indexprs != NIL)
                continue;
 
            ind_attnos = NULL;
            index_check_ok = true;
            for (int i = 0; i < index->nkeycolumns; i++)
            {
                AttrNumber  indkey_attno = index->indexkeys[i];
                Oid         indkey_opfamily = index->opfamily[i];
                Oid         indkey_coll = index->indexcollations[i];
                ListCell   *lc2;
 
                /*
                 * We must insist that the index columns are all defined NOT
                 * NULL otherwise duplicate NULLs could exist.  However, we
                 * can relax this check when the index is defined with NULLS
                 * NOT DISTINCT as there can only be 1 NULL row, therefore
                 * functional dependency on the unique columns is maintained,
                 * despite the NULL.
                 */
                if (!index->nullsnotdistinct &&
                    !bms_is_member(indkey_attno, rel->notnullattnums))
                {
                    index_check_ok = false;
                    break;
                }
 
                /*
                 * The index proves uniqueness only under its own opfamily and
                 * collation.  Require some GROUP BY item on this column to
                 * use a compatible eqop and collation, the same check
                 * relation_has_unique_index_for() applies to join clauses.
                 */
                foreach(lc2, groupbycols[relid])
                {
                    GroupByColInfo *info = (GroupByColInfo *) lfirst(lc2);
 
                    if (info->attno != indkey_attno)
                        continue;
                    if (list_member_oid(info->eq_opfamilies, indkey_opfamily) &&
                        collations_agree_on_equality(indkey_coll, info->coll))
                        break;
                }
                if (lc2 == NULL)
                {
                    index_check_ok = false;
                    break;
                }
 
                ind_attnos =
                    bms_add_member(ind_attnos,
                                   indkey_attno -
                                   FirstLowInvalidHeapAttributeNumber);
            }
 
            if (!index_check_ok)
                continue;
 
            /*
             * Skip any indexes where the indexed columns aren't a proper
             * subset of the GROUP BY.
             */
            if (bms_subset_compare(ind_attnos, relattnos) != BMS_SUBSET1)
                continue;
 
            /*
             * Record the attribute numbers from the index with the fewest
             * columns.  This allows the largest number of columns to be
             * removed from the GROUP BY clause.  In the future, we may wish
             * to consider using the narrowest set of columns and looking at
             * pg_statistic.stawidth as it might be better to use an index
             * with, say two INT4s, rather than, say, one long varlena column.
             */
            if (index->nkeycolumns < best_nkeycolumns)
            {
                best_keycolumns = ind_attnos;
                best_nkeycolumns = index->nkeycolumns;
            }
        }
 
        /* Did we find a suitable index? */
        if (!bms_is_empty(best_keycolumns))
        {
            /*
             * To easily remember whether we've found anything to do, we don't
             * allocate the surplusvars[] array until we find something.
             */
            if (surplusvars == NULL)
                surplusvars = palloc0_array(Bitmapset *, list_length(parse->rtable) + 1);
 
            /* Remember the attnos of the removable columns */
            surplusvars[relid] = bms_difference(relattnos, best_keycolumns);
        }
    }
 
    /*
     * If we found any surplus Vars, build a new GROUP BY clause without them.
     * (Note: this may leave some TLEs with unreferenced ressortgroupref
     * markings, but that's harmless.)
     */
    if (surplusvars != NULL)
    {
        List       *new_groupby = NIL;
 
        foreach(lc, root->processed_groupClause)
        {
            SortGroupClause *sgc = lfirst_node(SortGroupClause, lc);
            TargetEntry *tle = get_sortgroupclause_tle(sgc, parse->targetList);
            Var        *var = (Var *) tle->expr;
 
            /*
             * New list must include non-Vars, outer Vars, and anything not
             * marked as surplus.
             */
            if (!IsA(var, Var) ||
                var->varlevelsup > 0 ||
                !bms_is_member(var->varattno - FirstLowInvalidHeapAttributeNumber,
                               surplusvars[var->varno]))
                new_groupby = lappend(new_groupby, sgc);
        }
 
        root->processed_groupClause = new_groupby;
    }
}

References Assert, GroupByColInfo::attno, bms_add_member(), bms_difference(), bms_is_empty, bms_is_member(), bms_membership(), BMS_MULTIPLE, BMS_SUBSET1, bms_subset_compare(), GroupByColInfo::coll, collations_agree_on_equality(), GroupByColInfo::eq_opfamilies, fb(), FirstLowInvalidHeapAttributeNumber, foreach_node, get_mergejoin_opfamilies(), get_sortgroupclause_tle(), i, RelOptInfo::indexlist, IsA, lappend(), lfirst, lfirst_node, list_length(), list_member_oid(), NIL, RelOptInfo::notnullattnums, palloc(), palloc0_array, parse(), PG_INT32_MAX, root, RTE_RELATION, Var::varattno, Var::varlevelsup, and Var::varno.

Referenced by query_planner().

remove_useless_joins()

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

extern

Definition at line 93 of file analyzejoins.c.

{
    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_leftjoinrel_from_query(root, innerrelid, sjinfo);
 
        /* 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;
}

References bms_singleton_member(), elog, ERROR, fb(), join_is_removable(), lfirst, list_delete_cell(), SpecialJoinInfo::min_righthand, remove_leftjoinrel_from_query(), remove_rel_from_joinlist(), and root.

Referenced by query_planner().

remove_useless_self_joins()

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

extern

Definition at line 2540 of file analyzejoins.c.

{
    Relids      toRemove = NULL;
    int         relid = -1;
 
    if (!enable_self_join_elimination || joinlist == NIL ||
        (list_length(joinlist) == 1 && !IsA(linitial(joinlist), List)))
        return joinlist;
 
    /*
     * Merge pairs of relations participated in self-join. Remove unnecessary
     * range table entries.
     */
    toRemove = remove_self_joins_recurse(root, joinlist, toRemove);
 
    if (unlikely(toRemove != NULL))
    {
        /* At the end, remove orphaned relation links */
        while ((relid = bms_next_member(toRemove, relid)) >= 0)
        {
            int         nremoved = 0;
 
            joinlist = remove_rel_from_joinlist(joinlist, relid, &nremoved);
            if (nremoved != 1)
                elog(ERROR, "failed to find relation %d in joinlist", relid);
        }
    }
 
    return joinlist;
}

References bms_next_member(), elog, enable_self_join_elimination, ERROR, fb(), IsA, linitial, list_length(), NIL, remove_rel_from_joinlist(), remove_self_joins_recurse(), root, and unlikely.

Referenced by query_planner().

restriction_is_always_false()

bool restriction_is_always_false ( PlannerInfo *  root, RestrictInfo *  restrictinfo  )

extern

Definition at line 3558 of file initsplan.c.

{
    /*
     * For a clone clause, we don't have a reliable way to determine if the
     * input expression of a NullTest is non-nullable: nullingrel bits in
     * clone clauses may not reflect reality, so we dare not draw conclusions
     * from clones about whether Vars are guaranteed not-null.
     */
    if (restrictinfo->has_clone || restrictinfo->is_clone)
        return false;
 
    /* Check for NullTest qual */
    if (IsA(restrictinfo->clause, NullTest))
    {
        NullTest   *nulltest = (NullTest *) restrictinfo->clause;
 
        /* is this NullTest an IS_NULL qual? */
        if (nulltest->nulltesttype != IS_NULL)
            return false;
 
        /*
         * Empty rows can appear NULL in some contexts and NOT NULL in others,
         * so avoid this optimization for row expressions.
         */
        if (nulltest->argisrow)
            return false;
 
        return expr_is_nonnullable(root, nulltest->arg, NOTNULL_SOURCE_RELOPT);
    }
 
    /* If it's an OR, check its sub-clauses */
    if (restriction_is_or_clause(restrictinfo))
    {
        ListCell   *lc;
 
        Assert(is_orclause(restrictinfo->orclause));
 
        /*
         * Currently, when processing OR expressions, we only return true when
         * all of the OR branches are always false.  This could perhaps be
         * expanded to remove OR branches that are provably false.  This may
         * be a useful thing to do as it could result in the OR being left
         * with a single arg.  That's useful as it would allow the OR
         * condition to be replaced with its single argument which may allow
         * use of an index for faster filtering on the remaining condition.
         */
        foreach(lc, ((BoolExpr *) restrictinfo->orclause)->args)
        {
            Node       *orarg = (Node *) lfirst(lc);
 
            if (!IsA(orarg, RestrictInfo) ||
                !restriction_is_always_false(root, (RestrictInfo *) orarg))
                return false;
        }
        return true;
    }
 
    return false;
}

References Assert, expr_is_nonnullable(), fb(), IS_NULL, is_orclause(), IsA, lfirst, NOTNULL_SOURCE_RELOPT, restriction_is_always_false(), restriction_is_or_clause(), and root.

Referenced by add_base_clause_to_rel(), add_join_clause_to_rels(), and restriction_is_always_false().

restriction_is_always_true()

bool restriction_is_always_true ( PlannerInfo *  root, RestrictInfo *  restrictinfo  )

extern

Definition at line 3493 of file initsplan.c.

{
    /*
     * For a clone clause, we don't have a reliable way to determine if the
     * input expression of a NullTest is non-nullable: nullingrel bits in
     * clone clauses may not reflect reality, so we dare not draw conclusions
     * from clones about whether Vars are guaranteed not-null.
     */
    if (restrictinfo->has_clone || restrictinfo->is_clone)
        return false;
 
    /* Check for NullTest qual */
    if (IsA(restrictinfo->clause, NullTest))
    {
        NullTest   *nulltest = (NullTest *) restrictinfo->clause;
 
        /* is this NullTest an IS_NOT_NULL qual? */
        if (nulltest->nulltesttype != IS_NOT_NULL)
            return false;
 
        /*
         * Empty rows can appear NULL in some contexts and NOT NULL in others,
         * so avoid this optimization for row expressions.
         */
        if (nulltest->argisrow)
            return false;
 
        return expr_is_nonnullable(root, nulltest->arg, NOTNULL_SOURCE_RELOPT);
    }
 
    /* If it's an OR, check its sub-clauses */
    if (restriction_is_or_clause(restrictinfo))
    {
        ListCell   *lc;
 
        Assert(is_orclause(restrictinfo->orclause));
 
        /*
         * if any of the given OR branches is provably always true then the
         * entire condition is true.
         */
        foreach(lc, ((BoolExpr *) restrictinfo->orclause)->args)
        {
            Node       *orarg = (Node *) lfirst(lc);
 
            if (!IsA(orarg, RestrictInfo))
                continue;
 
            if (restriction_is_always_true(root, (RestrictInfo *) orarg))
                return true;
        }
    }
 
    return false;
}

References Assert, expr_is_nonnullable(), fb(), IS_NOT_NULL, is_orclause(), IsA, lfirst, NOTNULL_SOURCE_RELOPT, restriction_is_always_true(), restriction_is_or_clause(), and root.

Referenced by add_base_clause_to_rel(), add_join_clause_to_rels(), and restriction_is_always_true().

set_plan_references()

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

extern

Definition at line 291 of file setrefs.c.

{
    Plan       *result;
    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;
 
        /* sanity check on existing row marks */
        Assert(root->simple_rel_array[rc->rti] != NULL &&
               root->simple_rte_array[rc->rti] != NULL);
 
        /* flat copy is enough since all fields are scalars */
        newrc = palloc_object(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);
    }
 
    /* If needed, create workspace for processing AlternativeSubPlans */
    if (root->hasAlternativeSubPlans)
    {
        root->isAltSubplan = (bool *)
            palloc0(list_length(glob->subplans) * sizeof(bool));
        root->isUsedSubplan = (bool *)
            palloc0(list_length(glob->subplans) * sizeof(bool));
    }
 
    /* Now fix the Plan tree */
    result = set_plan_refs(root, plan, rtoffset);
 
    /*
     * If we have AlternativeSubPlans, it is likely that we now have some
     * unreferenced subplans in glob->subplans.  To avoid expending cycles on
     * those subplans later, get rid of them by setting those list entries to
     * NULL.  (Note: we can't do this immediately upon processing an
     * AlternativeSubPlan, because there may be multiple copies of the
     * AlternativeSubPlan, and they can get resolved differently.)
     */
    if (root->hasAlternativeSubPlans)
    {
        foreach(lc, glob->subplans)
        {
            int         ndx = foreach_current_index(lc);
 
            /*
             * If it was used by some AlternativeSubPlan in this query level,
             * but wasn't selected as best by any AlternativeSubPlan, then we
             * don't need it.  Do not touch subplans that aren't parts of
             * AlternativeSubPlans.
             */
            if (root->isAltSubplan[ndx] && !root->isUsedSubplan[ndx])
                lfirst(lc) = NULL;
        }
    }
 
    return result;
}

References add_rtes_to_flat_rtable(), PlannerGlobal::appendRelations, Assert, fb(), PlannerGlobal::finalrowmarks, PlannerGlobal::finalrtable, foreach_current_index, lappend(), lfirst, lfirst_node, list_length(), memcpy(), NIL, palloc0(), palloc_object, plan, result, root, PlanRowMark::rti, set_plan_refs(), and PlannerGlobal::subplans.

Referenced by set_subqueryscan_references(), and standard_planner().

setup_eager_aggregation()

void setup_eager_aggregation ( PlannerInfo *  root )

extern

Definition at line 694 of file initsplan.c.

{
    /*
     * Don't apply eager aggregation if disabled by user.
     */
    if (!enable_eager_aggregate)
        return;
 
    /*
     * Don't apply eager aggregation if there are no available GROUP BY
     * clauses.
     */
    if (!root->processed_groupClause)
        return;
 
    /*
     * For now we don't try to support grouping sets.
     */
    if (root->parse->groupingSets)
        return;
 
    /*
     * For now we don't try to support DISTINCT or ORDER BY aggregates.
     */
    if (root->numOrderedAggs > 0)
        return;
 
    /*
     * If there are any aggregates that do not support partial mode, or any
     * partial aggregates that are non-serializable, do not apply eager
     * aggregation.
     */
    if (root->hasNonPartialAggs || root->hasNonSerialAggs)
        return;
 
    /*
     * We don't try to apply eager aggregation if there are set-returning
     * functions in targetlist.
     */
    if (root->parse->hasTargetSRFs)
        return;
 
    /*
     * Eager aggregation only makes sense if there are multiple base rels in
     * the query.
     */
    if (bms_membership(root->all_baserels) != BMS_MULTIPLE)
        return;
 
    /*
     * Don't apply eager aggregation if any aggregate poses a risk of
     * excessive memory usage during partial aggregation.
     */
    if (is_partial_agg_memory_risky(root))
        return;
 
    /*
     * Collect aggregate expressions and plain Vars that appear in the
     * targetlist and havingQual.
     */
    create_agg_clause_infos(root);
 
    /*
     * If there are no suitable aggregate expressions, we cannot apply eager
     * aggregation.
     */
    if (root->agg_clause_list == NIL)
        return;
 
    /*
     * Collect grouping expressions that appear in grouping clauses.
     */
    create_grouping_expr_infos(root);
}

References bms_membership(), BMS_MULTIPLE, create_agg_clause_infos(), create_grouping_expr_infos(), enable_eager_aggregate, is_partial_agg_memory_risky(), NIL, and root.

Referenced by query_planner().

trivial_subqueryscan()

bool trivial_subqueryscan ( SubqueryScan *  plan )

extern

Definition at line 1528 of file setrefs.c.

{
    int         attrno;
    ListCell   *lp,
               *lc;
 
    /* We might have detected this already; in which case reuse the result */
    if (plan->scanstatus == SUBQUERY_SCAN_TRIVIAL)
        return true;
    if (plan->scanstatus == SUBQUERY_SCAN_NONTRIVIAL)
        return false;
    Assert(plan->scanstatus == SUBQUERY_SCAN_UNKNOWN);
    /* Initially, mark the SubqueryScan as non-deletable from the plan tree */
    plan->scanstatus = SUBQUERY_SCAN_NONTRIVIAL;
 
    if (plan->scan.plan.qual != NIL)
        return false;
 
    if (list_length(plan->scan.plan.targetlist) !=
        list_length(plan->subplan->targetlist))
        return false;           /* tlists not same length */
 
    attrno = 1;
    forboth(lp, plan->scan.plan.targetlist, lc, plan->subplan->targetlist)
    {
        TargetEntry *ptle = (TargetEntry *) lfirst(lp);
        TargetEntry *ctle = (TargetEntry *) lfirst(lc);
 
        if (ptle->resjunk != ctle->resjunk)
            return false;       /* tlist doesn't match junk status */
 
        /*
         * We accept either a Var referencing the corresponding element of the
         * subplan tlist, or a Const equaling the subplan element. See
         * generate_setop_tlist() for motivation.
         */
        if (ptle->expr && IsA(ptle->expr, Var))
        {
            Var        *var = (Var *) ptle->expr;
 
            Assert(var->varno == plan->scan.scanrelid);
            Assert(var->varlevelsup == 0);
            if (var->varattno != attrno)
                return false;   /* out of order */
        }
        else if (ptle->expr && IsA(ptle->expr, Const))
        {
            if (!equal(ptle->expr, ctle->expr))
                return false;
        }
        else
            return false;
 
        attrno++;
    }
 
    /* Re-mark the SubqueryScan as deletable from the plan tree */
    plan->scanstatus = SUBQUERY_SCAN_TRIVIAL;
 
    return true;
}

References Assert, equal(), fb(), forboth, IsA, lfirst, list_length(), NIL, plan, SUBQUERY_SCAN_NONTRIVIAL, SUBQUERY_SCAN_TRIVIAL, SUBQUERY_SCAN_UNKNOWN, Var::varattno, Var::varlevelsup, and Var::varno.

Referenced by mark_async_capable_plan(), and set_subqueryscan_references().

Variable Documentation

cursor_tuple_fraction

PGDLLIMPORT double cursor_tuple_fraction

extern

Definition at line 68 of file planner.c.

Referenced by standard_planner().

enable_self_join_elimination

PGDLLIMPORT bool enable_self_join_elimination

extern

Definition at line 54 of file analyzejoins.c.

Referenced by remove_useless_self_joins().

from_collapse_limit

PGDLLIMPORT int from_collapse_limit

extern

Definition at line 41 of file initsplan.c.

Referenced by deconstruct_recurse().

join_collapse_limit

PGDLLIMPORT int join_collapse_limit

extern

Definition at line 42 of file initsplan.c.

Referenced by deconstruct_recurse().