planner.h File Reference

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

Include dependency graph for planner.h:

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

Go to the source code of this file.

Typedefs
typedef PlannedStmt *(*	planner_hook_type) (Query *parse, const char *query_string, int cursorOptions, ParamListInfo boundParams)
typedef void(*	create_upper_paths_hook_type) (PlannerInfo *root, UpperRelationKind stage, RelOptInfo *input_rel, RelOptInfo *output_rel, void *extra)

Functions
PlannedStmt *	standard_planner (Query *parse, const char *query_string, int cursorOptions, ParamListInfo boundParams)
PlannerInfo *	subquery_planner (PlannerGlobal *glob, Query *parse, PlannerInfo *parent_root, bool hasRecursion, double tuple_fraction, SetOperationStmt *setops)
RowMarkType	select_rowmark_type (RangeTblEntry *rte, LockClauseStrength strength)
bool	limit_needed (Query *parse)
void	mark_partial_aggref (Aggref *agg, AggSplit aggsplit)
Path *	get_cheapest_fractional_path (RelOptInfo *rel, double tuple_fraction)
Expr *	preprocess_phv_expression (PlannerInfo *root, Expr *expr)

Variables
PGDLLIMPORT planner_hook_type	planner_hook
PGDLLIMPORT create_upper_paths_hook_type	create_upper_paths_hook

Typedef Documentation

create_upper_paths_hook_type

typedef void(* create_upper_paths_hook_type) (PlannerInfo *root, UpperRelationKind stage, RelOptInfo *input_rel, RelOptInfo *output_rel, void *extra)

Definition at line 33 of file planner.h.

planner_hook_type

typedef PlannedStmt *(* planner_hook_type) (Query *parse, const char *query_string, int cursorOptions, ParamListInfo boundParams)

Definition at line 26 of file planner.h.

Function Documentation

get_cheapest_fractional_path()

Path * get_cheapest_fractional_path	(	RelOptInfo *	rel,
		double	tuple_fraction
	)

Definition at line 6411 of file planner.c.

{
    Path       *best_path = rel->cheapest_total_path;
    ListCell   *l;
 
    /* If all tuples will be retrieved, just return the cheapest-total path */
    if (tuple_fraction <= 0.0)
        return best_path;
 
    /* Convert absolute # of tuples to a fraction; no need to clamp to 0..1 */
    if (tuple_fraction >= 1.0 && best_path->rows > 0)
        tuple_fraction /= best_path->rows;
 
    foreach(l, rel->pathlist)
    {
        Path       *path = (Path *) lfirst(l);
 
        if (path == rel->cheapest_total_path ||
            compare_fractional_path_costs(best_path, path, tuple_fraction) <= 0)
            continue;
 
        best_path = path;
    }
 
    return best_path;
}

References RelOptInfo::cheapest_total_path, compare_fractional_path_costs(), lfirst, RelOptInfo::pathlist, and Path::rows.

Referenced by make_subplan(), and standard_planner().

limit_needed()

bool limit_needed

(

Query *

parse

)

Definition at line 2685 of file planner.c.

{
    Node       *node;
 
    node = parse->limitCount;
    if (node)
    {
        if (IsA(node, Const))
        {
            /* NULL indicates LIMIT ALL, ie, no limit */
            if (!((Const *) node)->constisnull)
                return true;    /* LIMIT with a constant value */
        }
        else
            return true;        /* non-constant LIMIT */
    }
 
    node = parse->limitOffset;
    if (node)
    {
        if (IsA(node, Const))
        {
            /* Treat NULL as no offset; the executor would too */
            if (!((Const *) node)->constisnull)
            {
                int64       offset = DatumGetInt64(((Const *) node)->constvalue);
 
                if (offset != 0)
                    return true;    /* OFFSET with a nonzero value */
            }
        }
        else
            return true;        /* non-constant OFFSET */
    }
 
    return false;               /* don't need a Limit plan node */
}

References DatumGetInt64(), IsA, and parse().

Referenced by grouping_planner(), and set_rel_consider_parallel().

mark_partial_aggref()

void mark_partial_aggref	(	Aggref *	agg,
		AggSplit	aggsplit
	)

Definition at line 5623 of file planner.c.

{
    /* aggtranstype should be computed by this point */
    Assert(OidIsValid(agg->aggtranstype));
    /* ... but aggsplit should still be as the parser left it */
    Assert(agg->aggsplit == AGGSPLIT_SIMPLE);
 
    /* Mark the Aggref with the intended partial-aggregation mode */
    agg->aggsplit = aggsplit;
 
    /*
     * Adjust result type if needed.  Normally, a partial aggregate returns
     * the aggregate's transition type; but if that's INTERNAL and we're
     * serializing, it returns BYTEA instead.
     */
    if (DO_AGGSPLIT_SKIPFINAL(aggsplit))
    {
        if (agg->aggtranstype == INTERNALOID && DO_AGGSPLIT_SERIALIZE(aggsplit))
            agg->aggtype = BYTEAOID;
        else
            agg->aggtype = agg->aggtranstype;
    }
}

References AGGSPLIT_SIMPLE, Assert, DO_AGGSPLIT_SERIALIZE, DO_AGGSPLIT_SKIPFINAL, and OidIsValid.

Referenced by convert_combining_aggrefs(), and make_partial_grouping_target().

preprocess_phv_expression()

Expr * preprocess_phv_expression	(	PlannerInfo *	root,
		Expr *	expr
	)

Definition at line 1331 of file planner.c.

{
    return (Expr *) preprocess_expression(root, (Node *) expr, EXPRKIND_PHV);
}

References EXPRKIND_PHV, preprocess_expression(), and root.

Referenced by extract_lateral_references().

select_rowmark_type()

RowMarkType select_rowmark_type	(	RangeTblEntry *	rte,
		LockClauseStrength	strength
	)

Definition at line 2434 of file planner.c.

{
    if (rte->rtekind != RTE_RELATION)
    {
        /* If it's not a table at all, use ROW_MARK_COPY */
        return ROW_MARK_COPY;
    }
    else if (rte->relkind == RELKIND_FOREIGN_TABLE)
    {
        /* Let the FDW select the rowmark type, if it wants to */
        FdwRoutine *fdwroutine = GetFdwRoutineByRelId(rte->relid);
 
        if (fdwroutine->GetForeignRowMarkType != NULL)
            return fdwroutine->GetForeignRowMarkType(rte, strength);
        /* Otherwise, use ROW_MARK_COPY by default */
        return ROW_MARK_COPY;
    }
    else
    {
        /* Regular table, apply the appropriate lock type */
        switch (strength)
        {
            case LCS_NONE:
 
                /*
                 * We don't need a tuple lock, only the ability to re-fetch
                 * the row.
                 */
                return ROW_MARK_REFERENCE;
                break;
            case LCS_FORKEYSHARE:
                return ROW_MARK_KEYSHARE;
                break;
            case LCS_FORSHARE:
                return ROW_MARK_SHARE;
                break;
            case LCS_FORNOKEYUPDATE:
                return ROW_MARK_NOKEYEXCLUSIVE;
                break;
            case LCS_FORUPDATE:
                return ROW_MARK_EXCLUSIVE;
                break;
        }
        elog(ERROR, "unrecognized LockClauseStrength %d", (int) strength);
        return ROW_MARK_EXCLUSIVE;  /* keep compiler quiet */
    }
}

References elog, ERROR, GetFdwRoutineByRelId(), FdwRoutine::GetForeignRowMarkType, LCS_FORKEYSHARE, LCS_FORNOKEYUPDATE, LCS_FORSHARE, LCS_FORUPDATE, LCS_NONE, RangeTblEntry::relid, ROW_MARK_COPY, ROW_MARK_EXCLUSIVE, ROW_MARK_KEYSHARE, ROW_MARK_NOKEYEXCLUSIVE, ROW_MARK_REFERENCE, ROW_MARK_SHARE, RTE_RELATION, and RangeTblEntry::rtekind.

Referenced by expand_single_inheritance_child(), and preprocess_rowmarks().

standard_planner()

PlannedStmt * standard_planner	(	Query *	parse,
		const char *	query_string,
		int	cursorOptions,
		ParamListInfo	boundParams
	)

Definition at line 297 of file planner.c.

{
    PlannedStmt *result;
    PlannerGlobal *glob;
    double      tuple_fraction;
    PlannerInfo *root;
    RelOptInfo *final_rel;
    Path       *best_path;
    Plan       *top_plan;
    ListCell   *lp,
               *lr;
 
    /*
     * Set up global state for this planner invocation.  This data is needed
     * across all levels of sub-Query that might exist in the given command,
     * so we keep it in a separate struct that's linked to by each per-Query
     * PlannerInfo.
     */
    glob = makeNode(PlannerGlobal);
 
    glob->boundParams = boundParams;
    glob->subplans = NIL;
    glob->subpaths = NIL;
    glob->subroots = NIL;
    glob->rewindPlanIDs = NULL;
    glob->finalrtable = NIL;
    glob->finalrteperminfos = NIL;
    glob->finalrowmarks = NIL;
    glob->resultRelations = NIL;
    glob->appendRelations = NIL;
    glob->relationOids = NIL;
    glob->invalItems = NIL;
    glob->paramExecTypes = NIL;
    glob->lastPHId = 0;
    glob->lastRowMarkId = 0;
    glob->lastPlanNodeId = 0;
    glob->transientPlan = false;
    glob->dependsOnRole = false;
 
    /*
     * Assess whether it's feasible to use parallel mode for this query. We
     * can't do this in a standalone backend, or if the command will try to
     * modify any data, or if this is a cursor operation, or if GUCs are set
     * to values that don't permit parallelism, or if parallel-unsafe
     * functions are present in the query tree.
     *
     * (Note that we do allow CREATE TABLE AS, SELECT INTO, and CREATE
     * MATERIALIZED VIEW to use parallel plans, but this is safe only because
     * the command is writing into a completely new table which workers won't
     * be able to see.  If the workers could see the table, the fact that
     * group locking would cause them to ignore the leader's heavyweight GIN
     * page locks would make this unsafe.  We'll have to fix that somehow if
     * we want to allow parallel inserts in general; updates and deletes have
     * additional problems especially around combo CIDs.)
     *
     * For now, we don't try to use parallel mode if we're running inside a
     * parallel worker.  We might eventually be able to relax this
     * restriction, but for now it seems best not to have parallel workers
     * trying to create their own parallel workers.
     */
    if ((cursorOptions & CURSOR_OPT_PARALLEL_OK) != 0 &&
        IsUnderPostmaster &&
        parse->commandType == CMD_SELECT &&
        !parse->hasModifyingCTE &&
        max_parallel_workers_per_gather > 0 &&
        !IsParallelWorker())
    {
        /* all the cheap tests pass, so scan the query tree */
        glob->maxParallelHazard = max_parallel_hazard(parse);
        glob->parallelModeOK = (glob->maxParallelHazard != PROPARALLEL_UNSAFE);
    }
    else
    {
        /* skip the query tree scan, just assume it's unsafe */
        glob->maxParallelHazard = PROPARALLEL_UNSAFE;
        glob->parallelModeOK = false;
    }
 
    /*
     * glob->parallelModeNeeded is normally set to false here and changed to
     * true during plan creation if a Gather or Gather Merge plan is actually
     * created (cf. create_gather_plan, create_gather_merge_plan).
     *
     * However, if debug_parallel_query = on or debug_parallel_query =
     * regress, then we impose parallel mode whenever it's safe to do so, even
     * if the final plan doesn't use parallelism.  It's not safe to do so if
     * the query contains anything parallel-unsafe; parallelModeOK will be
     * false in that case.  Note that parallelModeOK can't change after this
     * point. Otherwise, everything in the query is either parallel-safe or
     * parallel-restricted, and in either case it should be OK to impose
     * parallel-mode restrictions.  If that ends up breaking something, then
     * either some function the user included in the query is incorrectly
     * labeled as parallel-safe or parallel-restricted when in reality it's
     * parallel-unsafe, or else the query planner itself has a bug.
     */
    glob->parallelModeNeeded = glob->parallelModeOK &&
        (debug_parallel_query != DEBUG_PARALLEL_OFF);
 
    /* Determine what fraction of the plan is likely to be scanned */
    if (cursorOptions & CURSOR_OPT_FAST_PLAN)
    {
        /*
         * We have no real idea how many tuples the user will ultimately FETCH
         * from a cursor, but it is often the case that he doesn't want 'em
         * all, or would prefer a fast-start plan anyway so that he can
         * process some of the tuples sooner.  Use a GUC parameter to decide
         * what fraction to optimize for.
         */
        tuple_fraction = cursor_tuple_fraction;
 
        /*
         * We document cursor_tuple_fraction as simply being a fraction, which
         * means the edge cases 0 and 1 have to be treated specially here.  We
         * convert 1 to 0 ("all the tuples") and 0 to a very small fraction.
         */
        if (tuple_fraction >= 1.0)
            tuple_fraction = 0.0;
        else if (tuple_fraction <= 0.0)
            tuple_fraction = 1e-10;
    }
    else
    {
        /* Default assumption is we need all the tuples */
        tuple_fraction = 0.0;
    }
 
    /* primary planning entry point (may recurse for subqueries) */
    root = subquery_planner(glob, parse, NULL, false, tuple_fraction, NULL);
 
    /* Select best Path and turn it into a Plan */
    final_rel = fetch_upper_rel(root, UPPERREL_FINAL, NULL);
    best_path = get_cheapest_fractional_path(final_rel, tuple_fraction);
 
    top_plan = create_plan(root, best_path);
 
    /*
     * If creating a plan for a scrollable cursor, make sure it can run
     * backwards on demand.  Add a Material node at the top at need.
     */
    if (cursorOptions & CURSOR_OPT_SCROLL)
    {
        if (!ExecSupportsBackwardScan(top_plan))
            top_plan = materialize_finished_plan(top_plan);
    }
 
    /*
     * Optionally add a Gather node for testing purposes, provided this is
     * actually a safe thing to do.
     *
     * We can add Gather even when top_plan has parallel-safe initPlans, but
     * then we have to move the initPlans to the Gather node because of
     * SS_finalize_plan's limitations.  That would cause cosmetic breakage of
     * regression tests when debug_parallel_query = regress, because initPlans
     * that would normally appear on the top_plan move to the Gather, causing
     * them to disappear from EXPLAIN output.  That doesn't seem worth kluging
     * EXPLAIN to hide, so skip it when debug_parallel_query = regress.
     */
    if (debug_parallel_query != DEBUG_PARALLEL_OFF &&
        top_plan->parallel_safe &&
        (top_plan->initPlan == NIL ||
         debug_parallel_query != DEBUG_PARALLEL_REGRESS))
    {
        Gather     *gather = makeNode(Gather);
        Cost        initplan_cost;
        bool        unsafe_initplans;
 
        gather->plan.targetlist = top_plan->targetlist;
        gather->plan.qual = NIL;
        gather->plan.lefttree = top_plan;
        gather->plan.righttree = NULL;
        gather->num_workers = 1;
        gather->single_copy = true;
        gather->invisible = (debug_parallel_query == DEBUG_PARALLEL_REGRESS);
 
        /* Transfer any initPlans to the new top node */
        gather->plan.initPlan = top_plan->initPlan;
        top_plan->initPlan = NIL;
 
        /*
         * Since this Gather has no parallel-aware descendants to signal to,
         * we don't need a rescan Param.
         */
        gather->rescan_param = -1;
 
        /*
         * Ideally we'd use cost_gather here, but setting up dummy path data
         * to satisfy it doesn't seem much cleaner than knowing what it does.
         */
        gather->plan.startup_cost = top_plan->startup_cost +
            parallel_setup_cost;
        gather->plan.total_cost = top_plan->total_cost +
            parallel_setup_cost + parallel_tuple_cost * top_plan->plan_rows;
        gather->plan.plan_rows = top_plan->plan_rows;
        gather->plan.plan_width = top_plan->plan_width;
        gather->plan.parallel_aware = false;
        gather->plan.parallel_safe = false;
 
        /*
         * Delete the initplans' cost from top_plan.  We needn't add it to the
         * Gather node, since the above coding already included it there.
         */
        SS_compute_initplan_cost(gather->plan.initPlan,
                                 &initplan_cost, &unsafe_initplans);
        top_plan->startup_cost -= initplan_cost;
        top_plan->total_cost -= initplan_cost;
 
        /* use parallel mode for parallel plans. */
        root->glob->parallelModeNeeded = true;
 
        top_plan = &gather->plan;
    }
 
    /*
     * If any Params were generated, run through the plan tree and compute
     * each plan node's extParam/allParam sets.  Ideally we'd merge this into
     * set_plan_references' tree traversal, but for now it has to be separate
     * because we need to visit subplans before not after main plan.
     */
    if (glob->paramExecTypes != NIL)
    {
        Assert(list_length(glob->subplans) == list_length(glob->subroots));
        forboth(lp, glob->subplans, lr, glob->subroots)
        {
            Plan       *subplan = (Plan *) lfirst(lp);
            PlannerInfo *subroot = lfirst_node(PlannerInfo, lr);
 
            SS_finalize_plan(subroot, subplan);
        }
        SS_finalize_plan(root, top_plan);
    }
 
    /* final cleanup of the plan */
    Assert(glob->finalrtable == NIL);
    Assert(glob->finalrteperminfos == NIL);
    Assert(glob->finalrowmarks == NIL);
    Assert(glob->resultRelations == NIL);
    Assert(glob->appendRelations == NIL);
    top_plan = set_plan_references(root, top_plan);
    /* ... and the subplans (both regular subplans and initplans) */
    Assert(list_length(glob->subplans) == list_length(glob->subroots));
    forboth(lp, glob->subplans, lr, glob->subroots)
    {
        Plan       *subplan = (Plan *) lfirst(lp);
        PlannerInfo *subroot = lfirst_node(PlannerInfo, lr);
 
        lfirst(lp) = set_plan_references(subroot, subplan);
    }
 
    /* build the PlannedStmt result */
    result = makeNode(PlannedStmt);
 
    result->commandType = parse->commandType;
    result->queryId = parse->queryId;
    result->hasReturning = (parse->returningList != NIL);
    result->hasModifyingCTE = parse->hasModifyingCTE;
    result->canSetTag = parse->canSetTag;
    result->transientPlan = glob->transientPlan;
    result->dependsOnRole = glob->dependsOnRole;
    result->parallelModeNeeded = glob->parallelModeNeeded;
    result->planTree = top_plan;
    result->rtable = glob->finalrtable;
    result->permInfos = glob->finalrteperminfos;
    result->resultRelations = glob->resultRelations;
    result->appendRelations = glob->appendRelations;
    result->subplans = glob->subplans;
    result->rewindPlanIDs = glob->rewindPlanIDs;
    result->rowMarks = glob->finalrowmarks;
    result->relationOids = glob->relationOids;
    result->invalItems = glob->invalItems;
    result->paramExecTypes = glob->paramExecTypes;
    /* utilityStmt should be null, but we might as well copy it */
    result->utilityStmt = parse->utilityStmt;
    result->stmt_location = parse->stmt_location;
    result->stmt_len = parse->stmt_len;
 
    result->jitFlags = PGJIT_NONE;
    if (jit_enabled && jit_above_cost >= 0 &&
        top_plan->total_cost > jit_above_cost)
    {
        result->jitFlags |= PGJIT_PERFORM;
 
        /*
         * Decide how much effort should be put into generating better code.
         */
        if (jit_optimize_above_cost >= 0 &&
            top_plan->total_cost > jit_optimize_above_cost)
            result->jitFlags |= PGJIT_OPT3;
        if (jit_inline_above_cost >= 0 &&
            top_plan->total_cost > jit_inline_above_cost)
            result->jitFlags |= PGJIT_INLINE;
 
        /*
         * Decide which operations should be JITed.
         */
        if (jit_expressions)
            result->jitFlags |= PGJIT_EXPR;
        if (jit_tuple_deforming)
            result->jitFlags |= PGJIT_DEFORM;
    }
 
    if (glob->partition_directory != NULL)
        DestroyPartitionDirectory(glob->partition_directory);
 
    return result;
}

References PlannerGlobal::appendRelations, PlannedStmt::appendRelations, Assert, PlannedStmt::canSetTag, CMD_SELECT, PlannedStmt::commandType, create_plan(), CURSOR_OPT_FAST_PLAN, CURSOR_OPT_PARALLEL_OK, CURSOR_OPT_SCROLL, cursor_tuple_fraction, DEBUG_PARALLEL_OFF, debug_parallel_query, DEBUG_PARALLEL_REGRESS, PlannerGlobal::dependsOnRole, PlannedStmt::dependsOnRole, DestroyPartitionDirectory(), ExecSupportsBackwardScan(), fetch_upper_rel(), PlannerGlobal::finalrowmarks, PlannerGlobal::finalrtable, PlannerGlobal::finalrteperminfos, forboth, get_cheapest_fractional_path(), PlannedStmt::hasModifyingCTE, PlannedStmt::hasReturning, Plan::initPlan, PlannerGlobal::invalItems, PlannedStmt::invalItems, Gather::invisible, IsParallelWorker, IsUnderPostmaster, jit_above_cost, jit_enabled, jit_expressions, jit_inline_above_cost, jit_optimize_above_cost, jit_tuple_deforming, PlannedStmt::jitFlags, PlannerGlobal::lastPHId, PlannerGlobal::lastPlanNodeId, PlannerGlobal::lastRowMarkId, Plan::lefttree, lfirst, lfirst_node, list_length(), makeNode, materialize_finished_plan(), max_parallel_hazard(), max_parallel_workers_per_gather, PlannerGlobal::maxParallelHazard, NIL, Gather::num_workers, Plan::parallel_aware, Plan::parallel_safe, parallel_setup_cost, parallel_tuple_cost, PlannerGlobal::parallelModeNeeded, PlannedStmt::parallelModeNeeded, PlannerGlobal::parallelModeOK, PlannerGlobal::paramExecTypes, PlannedStmt::paramExecTypes, parse(), PlannedStmt::permInfos, PGJIT_DEFORM, PGJIT_EXPR, PGJIT_INLINE, PGJIT_NONE, PGJIT_OPT3, PGJIT_PERFORM, Gather::plan, Plan::plan_rows, Plan::plan_width, PlannedStmt::planTree, Plan::qual, PlannedStmt::queryId, PlannerGlobal::relationOids, PlannedStmt::relationOids, Gather::rescan_param, PlannerGlobal::resultRelations, PlannedStmt::resultRelations, PlannerGlobal::rewindPlanIDs, PlannedStmt::rewindPlanIDs, Plan::righttree, root, PlannedStmt::rowMarks, PlannedStmt::rtable, set_plan_references(), Gather::single_copy, SS_compute_initplan_cost(), SS_finalize_plan(), Plan::startup_cost, PlannedStmt::stmt_len, PlannedStmt::stmt_location, PlannerGlobal::subpaths, PlannerGlobal::subplans, PlannedStmt::subplans, subquery_planner(), Plan::targetlist, Plan::total_cost, PlannerGlobal::transientPlan, PlannedStmt::transientPlan, UPPERREL_FINAL, and PlannedStmt::utilityStmt.

Referenced by delay_execution_planner(), pgss_planner(), and planner().

subquery_planner()

PlannerInfo * subquery_planner	(	PlannerGlobal *	glob,
		Query *	parse,
		PlannerInfo *	parent_root,
		bool	hasRecursion,
		double	tuple_fraction,
		SetOperationStmt *	setops
	)

Definition at line 638 of file planner.c.

{
    PlannerInfo *root;
    List       *newWithCheckOptions;
    List       *newHaving;
    bool        hasOuterJoins;
    bool        hasResultRTEs;
    RelOptInfo *final_rel;
    ListCell   *l;
 
    /* Create a PlannerInfo data structure for this subquery */
    root = makeNode(PlannerInfo);
    root->parse = parse;
    root->glob = glob;
    root->query_level = parent_root ? parent_root->query_level + 1 : 1;
    root->parent_root = parent_root;
    root->plan_params = NIL;
    root->outer_params = NULL;
    root->planner_cxt = CurrentMemoryContext;
    root->init_plans = NIL;
    root->cte_plan_ids = NIL;
    root->multiexpr_params = NIL;
    root->join_domains = NIL;
    root->eq_classes = NIL;
    root->ec_merging_done = false;
    root->last_rinfo_serial = 0;
    root->all_result_relids =
        parse->resultRelation ? bms_make_singleton(parse->resultRelation) : NULL;
    root->leaf_result_relids = NULL;    /* we'll find out leaf-ness later */
    root->append_rel_list = NIL;
    root->row_identity_vars = NIL;
    root->rowMarks = NIL;
    memset(root->upper_rels, 0, sizeof(root->upper_rels));
    memset(root->upper_targets, 0, sizeof(root->upper_targets));
    root->processed_groupClause = NIL;
    root->processed_distinctClause = NIL;
    root->processed_tlist = NIL;
    root->update_colnos = NIL;
    root->grouping_map = NULL;
    root->minmax_aggs = NIL;
    root->qual_security_level = 0;
    root->hasPseudoConstantQuals = false;
    root->hasAlternativeSubPlans = false;
    root->placeholdersFrozen = false;
    root->hasRecursion = hasRecursion;
    if (hasRecursion)
        root->wt_param_id = assign_special_exec_param(root);
    else
        root->wt_param_id = -1;
    root->non_recursive_path = NULL;
    root->partColsUpdated = false;
 
    /*
     * Create the top-level join domain.  This won't have valid contents until
     * deconstruct_jointree fills it in, but the node needs to exist before
     * that so we can build EquivalenceClasses referencing it.
     */
    root->join_domains = list_make1(makeNode(JoinDomain));
 
    /*
     * If there is a WITH list, process each WITH query and either convert it
     * to RTE_SUBQUERY RTE(s) or build an initplan SubPlan structure for it.
     */
    if (parse->cteList)
        SS_process_ctes(root);
 
    /*
     * If it's a MERGE command, transform the joinlist as appropriate.
     */
    transform_MERGE_to_join(parse);
 
    /*
     * If the FROM clause is empty, replace it with a dummy RTE_RESULT RTE, so
     * that we don't need so many special cases to deal with that situation.
     */
    replace_empty_jointree(parse);
 
    /*
     * Look for ANY and EXISTS SubLinks in WHERE and JOIN/ON clauses, and try
     * to transform them into joins.  Note that this step does not descend
     * into subqueries; if we pull up any subqueries below, their SubLinks are
     * processed just before pulling them up.
     */
    if (parse->hasSubLinks)
        pull_up_sublinks(root);
 
    /*
     * Scan the rangetable for function RTEs, do const-simplification on them,
     * and then inline them if possible (producing subqueries that might get
     * pulled up next).  Recursion issues here are handled in the same way as
     * for SubLinks.
     */
    preprocess_function_rtes(root);
 
    /*
     * Check to see if any subqueries in the jointree can be merged into this
     * query.
     */
    pull_up_subqueries(root);
 
    /*
     * If this is a simple UNION ALL query, flatten it into an appendrel. We
     * do this now because it requires applying pull_up_subqueries to the leaf
     * queries of the UNION ALL, which weren't touched above because they
     * weren't referenced by the jointree (they will be after we do this).
     */
    if (parse->setOperations)
        flatten_simple_union_all(root);
 
    /*
     * Survey the rangetable to see what kinds of entries are present.  We can
     * skip some later processing if relevant SQL features are not used; for
     * example if there are no JOIN RTEs we can avoid the expense of doing
     * flatten_join_alias_vars().  This must be done after we have finished
     * adding rangetable entries, of course.  (Note: actually, processing of
     * inherited or partitioned rels can cause RTEs for their child tables to
     * get added later; but those must all be RTE_RELATION entries, so they
     * don't invalidate the conclusions drawn here.)
     */
    root->hasJoinRTEs = false;
    root->hasLateralRTEs = false;
    root->group_rtindex = 0;
    hasOuterJoins = false;
    hasResultRTEs = false;
    foreach(l, parse->rtable)
    {
        RangeTblEntry *rte = lfirst_node(RangeTblEntry, l);
 
        switch (rte->rtekind)
        {
            case RTE_RELATION:
                if (rte->inh)
                {
                    /*
                     * Check to see if the relation actually has any children;
                     * if not, clear the inh flag so we can treat it as a
                     * plain base relation.
                     *
                     * Note: this could give a false-positive result, if the
                     * rel once had children but no longer does.  We used to
                     * be able to clear rte->inh later on when we discovered
                     * that, but no more; we have to handle such cases as
                     * full-fledged inheritance.
                     */
                    rte->inh = has_subclass(rte->relid);
                }
                break;
            case RTE_JOIN:
                root->hasJoinRTEs = true;
                if (IS_OUTER_JOIN(rte->jointype))
                    hasOuterJoins = true;
                break;
            case RTE_RESULT:
                hasResultRTEs = true;
                break;
            case RTE_GROUP:
                Assert(parse->hasGroupRTE);
                root->group_rtindex = list_cell_number(parse->rtable, l) + 1;
                break;
            default:
                /* No work here for other RTE types */
                break;
        }
 
        if (rte->lateral)
            root->hasLateralRTEs = true;
 
        /*
         * We can also determine the maximum security level required for any
         * securityQuals now.  Addition of inheritance-child RTEs won't affect
         * this, because child tables don't have their own securityQuals; see
         * expand_single_inheritance_child().
         */
        if (rte->securityQuals)
            root->qual_security_level = Max(root->qual_security_level,
                                            list_length(rte->securityQuals));
    }
 
    /*
     * If we have now verified that the query target relation is
     * non-inheriting, mark it as a leaf target.
     */
    if (parse->resultRelation)
    {
        RangeTblEntry *rte = rt_fetch(parse->resultRelation, parse->rtable);
 
        if (!rte->inh)
            root->leaf_result_relids =
                bms_make_singleton(parse->resultRelation);
    }
 
    /*
     * Preprocess RowMark information.  We need to do this after subquery
     * pullup, so that all base relations are present.
     */
    preprocess_rowmarks(root);
 
    /*
     * Set hasHavingQual to remember if HAVING clause is present.  Needed
     * because preprocess_expression will reduce a constant-true condition to
     * an empty qual list ... but "HAVING TRUE" is not a semantic no-op.
     */
    root->hasHavingQual = (parse->havingQual != NULL);
 
    /*
     * Do expression preprocessing on targetlist and quals, as well as other
     * random expressions in the querytree.  Note that we do not need to
     * handle sort/group expressions explicitly, because they are actually
     * part of the targetlist.
     */
    parse->targetList = (List *)
        preprocess_expression(root, (Node *) parse->targetList,
                              EXPRKIND_TARGET);
 
    newWithCheckOptions = NIL;
    foreach(l, parse->withCheckOptions)
    {
        WithCheckOption *wco = lfirst_node(WithCheckOption, l);
 
        wco->qual = preprocess_expression(root, wco->qual,
                                          EXPRKIND_QUAL);
        if (wco->qual != NULL)
            newWithCheckOptions = lappend(newWithCheckOptions, wco);
    }
    parse->withCheckOptions = newWithCheckOptions;
 
    parse->returningList = (List *)
        preprocess_expression(root, (Node *) parse->returningList,
                              EXPRKIND_TARGET);
 
    preprocess_qual_conditions(root, (Node *) parse->jointree);
 
    parse->havingQual = preprocess_expression(root, parse->havingQual,
                                              EXPRKIND_QUAL);
 
    foreach(l, parse->windowClause)
    {
        WindowClause *wc = lfirst_node(WindowClause, l);
 
        /* partitionClause/orderClause are sort/group expressions */
        wc->startOffset = preprocess_expression(root, wc->startOffset,
                                                EXPRKIND_LIMIT);
        wc->endOffset = preprocess_expression(root, wc->endOffset,
                                              EXPRKIND_LIMIT);
    }
 
    parse->limitOffset = preprocess_expression(root, parse->limitOffset,
                                               EXPRKIND_LIMIT);
    parse->limitCount = preprocess_expression(root, parse->limitCount,
                                              EXPRKIND_LIMIT);
 
    if (parse->onConflict)
    {
        parse->onConflict->arbiterElems = (List *)
            preprocess_expression(root,
                                  (Node *) parse->onConflict->arbiterElems,
                                  EXPRKIND_ARBITER_ELEM);
        parse->onConflict->arbiterWhere =
            preprocess_expression(root,
                                  parse->onConflict->arbiterWhere,
                                  EXPRKIND_QUAL);
        parse->onConflict->onConflictSet = (List *)
            preprocess_expression(root,
                                  (Node *) parse->onConflict->onConflictSet,
                                  EXPRKIND_TARGET);
        parse->onConflict->onConflictWhere =
            preprocess_expression(root,
                                  parse->onConflict->onConflictWhere,
                                  EXPRKIND_QUAL);
        /* exclRelTlist contains only Vars, so no preprocessing needed */
    }
 
    foreach(l, parse->mergeActionList)
    {
        MergeAction *action = (MergeAction *) lfirst(l);
 
        action->targetList = (List *)
            preprocess_expression(root,
                                  (Node *) action->targetList,
                                  EXPRKIND_TARGET);
        action->qual =
            preprocess_expression(root,
                                  (Node *) action->qual,
                                  EXPRKIND_QUAL);
    }
 
    parse->mergeJoinCondition =
        preprocess_expression(root, parse->mergeJoinCondition, EXPRKIND_QUAL);
 
    root->append_rel_list = (List *)
        preprocess_expression(root, (Node *) root->append_rel_list,
                              EXPRKIND_APPINFO);
 
    /* Also need to preprocess expressions within RTEs */
    foreach(l, parse->rtable)
    {
        RangeTblEntry *rte = lfirst_node(RangeTblEntry, l);
        int         kind;
        ListCell   *lcsq;
 
        if (rte->rtekind == RTE_RELATION)
        {
            if (rte->tablesample)
                rte->tablesample = (TableSampleClause *)
                    preprocess_expression(root,
                                          (Node *) rte->tablesample,
                                          EXPRKIND_TABLESAMPLE);
        }
        else if (rte->rtekind == RTE_SUBQUERY)
        {
            /*
             * We don't want to do all preprocessing yet on the subquery's
             * expressions, since that will happen when we plan it.  But if it
             * contains any join aliases of our level, those have to get
             * expanded now, because planning of the subquery won't do it.
             * That's only possible if the subquery is LATERAL.
             */
            if (rte->lateral && root->hasJoinRTEs)
                rte->subquery = (Query *)
                    flatten_join_alias_vars(root, root->parse,
                                            (Node *) rte->subquery);
        }
        else if (rte->rtekind == RTE_FUNCTION)
        {
            /* Preprocess the function expression(s) fully */
            kind = rte->lateral ? EXPRKIND_RTFUNC_LATERAL : EXPRKIND_RTFUNC;
            rte->functions = (List *)
                preprocess_expression(root, (Node *) rte->functions, kind);
        }
        else if (rte->rtekind == RTE_TABLEFUNC)
        {
            /* Preprocess the function expression(s) fully */
            kind = rte->lateral ? EXPRKIND_TABLEFUNC_LATERAL : EXPRKIND_TABLEFUNC;
            rte->tablefunc = (TableFunc *)
                preprocess_expression(root, (Node *) rte->tablefunc, kind);
        }
        else if (rte->rtekind == RTE_VALUES)
        {
            /* Preprocess the values lists fully */
            kind = rte->lateral ? EXPRKIND_VALUES_LATERAL : EXPRKIND_VALUES;
            rte->values_lists = (List *)
                preprocess_expression(root, (Node *) rte->values_lists, kind);
        }
        else if (rte->rtekind == RTE_GROUP)
        {
            /* Preprocess the groupexprs list fully */
            rte->groupexprs = (List *)
                preprocess_expression(root, (Node *) rte->groupexprs,
                                      EXPRKIND_GROUPEXPR);
        }
 
        /*
         * Process each element of the securityQuals list as if it were a
         * separate qual expression (as indeed it is).  We need to do it this
         * way to get proper canonicalization of AND/OR structure.  Note that
         * this converts each element into an implicit-AND sublist.
         */
        foreach(lcsq, rte->securityQuals)
        {
            lfirst(lcsq) = preprocess_expression(root,
                                                 (Node *) lfirst(lcsq),
                                                 EXPRKIND_QUAL);
        }
    }
 
    /*
     * Now that we are done preprocessing expressions, and in particular done
     * flattening join alias variables, get rid of the joinaliasvars lists.
     * They no longer match what expressions in the rest of the tree look
     * like, because we have not preprocessed expressions in those lists (and
     * do not want to; for example, expanding a SubLink there would result in
     * a useless unreferenced subplan).  Leaving them in place simply creates
     * a hazard for later scans of the tree.  We could try to prevent that by
     * using QTW_IGNORE_JOINALIASES in every tree scan done after this point,
     * but that doesn't sound very reliable.
     */
    if (root->hasJoinRTEs)
    {
        foreach(l, parse->rtable)
        {
            RangeTblEntry *rte = lfirst_node(RangeTblEntry, l);
 
            rte->joinaliasvars = NIL;
        }
    }
 
    /*
     * Replace any Vars in the subquery's targetlist and havingQual that
     * reference GROUP outputs with the underlying grouping expressions.
     *
     * Note that we need to perform this replacement after we've preprocessed
     * the grouping expressions.  This is to ensure that there is only one
     * instance of SubPlan for each SubLink contained within the grouping
     * expressions.
     */
    if (parse->hasGroupRTE)
    {
        parse->targetList = (List *)
            flatten_group_exprs(root, root->parse, (Node *) parse->targetList);
        parse->havingQual =
            flatten_group_exprs(root, root->parse, parse->havingQual);
    }
 
    /* Constant-folding might have removed all set-returning functions */
    if (parse->hasTargetSRFs)
        parse->hasTargetSRFs = expression_returns_set((Node *) parse->targetList);
 
    /*
     * In some cases we may want to transfer a HAVING clause into WHERE. We
     * cannot do so if the HAVING clause contains aggregates (obviously) or
     * volatile functions (since a HAVING clause is supposed to be executed
     * only once per group).  We also can't do this if there are any nonempty
     * grouping sets and the clause references any columns that are nullable
     * by the grouping sets; moving such a clause into WHERE would potentially
     * change the results.  (If there are only empty grouping sets, then the
     * HAVING clause must be degenerate as discussed below.)
     *
     * Also, it may be that the clause is so expensive to execute that we're
     * better off doing it only once per group, despite the loss of
     * selectivity.  This is hard to estimate short of doing the entire
     * planning process twice, so we use a heuristic: clauses containing
     * subplans are left in HAVING.  Otherwise, we move or copy the HAVING
     * clause into WHERE, in hopes of eliminating tuples before aggregation
     * instead of after.
     *
     * If the query has explicit grouping then we can simply move such a
     * clause into WHERE; any group that fails the clause will not be in the
     * output because none of its tuples will reach the grouping or
     * aggregation stage.  Otherwise we must have a degenerate (variable-free)
     * HAVING clause, which we put in WHERE so that query_planner() can use it
     * in a gating Result node, but also keep in HAVING to ensure that we
     * don't emit a bogus aggregated row. (This could be done better, but it
     * seems not worth optimizing.)
     *
     * Note that a HAVING clause may contain expressions that are not fully
     * preprocessed.  This can happen if these expressions are part of
     * grouping items.  In such cases, they are replaced with GROUP Vars in
     * the parser and then replaced back after we've done with expression
     * preprocessing on havingQual.  This is not an issue if the clause
     * remains in HAVING, because these expressions will be matched to lower
     * target items in setrefs.c.  However, if the clause is moved or copied
     * into WHERE, we need to ensure that these expressions are fully
     * preprocessed.
     *
     * Note that both havingQual and parse->jointree->quals are in
     * implicitly-ANDed-list form at this point, even though they are declared
     * as Node *.
     */
    newHaving = NIL;
    foreach(l, (List *) parse->havingQual)
    {
        Node       *havingclause = (Node *) lfirst(l);
 
        if (contain_agg_clause(havingclause) ||
            contain_volatile_functions(havingclause) ||
            contain_subplans(havingclause) ||
            (parse->groupClause && parse->groupingSets &&
             bms_is_member(root->group_rtindex, pull_varnos(root, havingclause))))
        {
            /* keep it in HAVING */
            newHaving = lappend(newHaving, havingclause);
        }
        else if (parse->groupClause)
        {
            Node       *whereclause;
 
            /* Preprocess the HAVING clause fully */
            whereclause = preprocess_expression(root, havingclause,
                                                EXPRKIND_QUAL);
            /* ... and move it to WHERE */
            parse->jointree->quals = (Node *)
                list_concat((List *) parse->jointree->quals,
                            (List *) whereclause);
        }
        else
        {
            Node       *whereclause;
 
            /* Preprocess the HAVING clause fully */
            whereclause = preprocess_expression(root, copyObject(havingclause),
                                                EXPRKIND_QUAL);
            /* ... and put a copy in WHERE */
            parse->jointree->quals = (Node *)
                list_concat((List *) parse->jointree->quals,
                            (List *) whereclause);
            /* ... and also keep it in HAVING */
            newHaving = lappend(newHaving, havingclause);
        }
    }
    parse->havingQual = (Node *) newHaving;
 
    /*
     * If we have any outer joins, try to reduce them to plain inner joins.
     * This step is most easily done after we've done expression
     * preprocessing.
     */
    if (hasOuterJoins)
        reduce_outer_joins(root);
 
    /*
     * If we have any RTE_RESULT relations, see if they can be deleted from
     * the jointree.  We also rely on this processing to flatten single-child
     * FromExprs underneath outer joins.  This step is most effectively done
     * after we've done expression preprocessing and outer join reduction.
     */
    if (hasResultRTEs || hasOuterJoins)
        remove_useless_result_rtes(root);
 
    /*
     * Do the main planning.
     */
    grouping_planner(root, tuple_fraction, setops);
 
    /*
     * Capture the set of outer-level param IDs we have access to, for use in
     * extParam/allParam calculations later.
     */
    SS_identify_outer_params(root);
 
    /*
     * If any initPlans were created in this query level, adjust the surviving
     * Paths' costs and parallel-safety flags to account for them.  The
     * initPlans won't actually get attached to the plan tree till
     * create_plan() runs, but we must include their effects now.
     */
    final_rel = fetch_upper_rel(root, UPPERREL_FINAL, NULL);
    SS_charge_for_initplans(root, final_rel);
 
    /*
     * Make sure we've identified the cheapest Path for the final rel.  (By
     * doing this here not in grouping_planner, we include initPlan costs in
     * the decision, though it's unlikely that will change anything.)
     */
    set_cheapest(final_rel);
 
    return root;
}

References generate_unaccent_rules::action, Assert, assign_special_exec_param(), bms_is_member(), bms_make_singleton(), contain_agg_clause(), contain_subplans(), contain_volatile_functions(), copyObject, CurrentMemoryContext, WindowClause::endOffset, expression_returns_set(), EXPRKIND_APPINFO, EXPRKIND_ARBITER_ELEM, EXPRKIND_GROUPEXPR, EXPRKIND_LIMIT, EXPRKIND_QUAL, EXPRKIND_RTFUNC, EXPRKIND_RTFUNC_LATERAL, EXPRKIND_TABLEFUNC, EXPRKIND_TABLEFUNC_LATERAL, EXPRKIND_TABLESAMPLE, EXPRKIND_TARGET, EXPRKIND_VALUES, EXPRKIND_VALUES_LATERAL, fetch_upper_rel(), flatten_group_exprs(), flatten_join_alias_vars(), flatten_simple_union_all(), RangeTblEntry::functions, grouping_planner(), has_subclass(), RangeTblEntry::inh, IS_OUTER_JOIN, RangeTblEntry::jointype, lappend(), lfirst, lfirst_node, list_cell_number(), list_concat(), list_length(), list_make1, makeNode, Max, NIL, parse(), preprocess_expression(), preprocess_function_rtes(), preprocess_qual_conditions(), preprocess_rowmarks(), pull_up_sublinks(), pull_up_subqueries(), pull_varnos(), WithCheckOption::qual, PlannerInfo::query_level, reduce_outer_joins(), RangeTblEntry::relid, remove_useless_result_rtes(), replace_empty_jointree(), root, rt_fetch, RTE_FUNCTION, RTE_GROUP, RTE_JOIN, RTE_RELATION, RTE_RESULT, RTE_SUBQUERY, RTE_TABLEFUNC, RTE_VALUES, RangeTblEntry::rtekind, set_cheapest(), SS_charge_for_initplans(), SS_identify_outer_params(), SS_process_ctes(), WindowClause::startOffset, RangeTblEntry::subquery, RangeTblEntry::tablefunc, RangeTblEntry::tablesample, transform_MERGE_to_join(), UPPERREL_FINAL, and RangeTblEntry::values_lists.

Referenced by make_subplan(), recurse_set_operations(), set_subquery_pathlist(), SS_process_ctes(), and standard_planner().

Variable Documentation

create_upper_paths_hook

PGDLLIMPORT create_upper_paths_hook_type create_upper_paths_hook

extern

Definition at line 75 of file planner.c.

Referenced by create_distinct_paths(), create_ordered_paths(), create_ordinary_grouping_paths(), create_partial_distinct_paths(), create_window_paths(), grouping_planner(), and postprocess_setop_rel().

planner_hook

PGDLLIMPORT planner_hook_type planner_hook

extern

Definition at line 72 of file planner.c.

Referenced by _PG_init(), and planner().