#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:

Typedefs
typedef struct ExplainState	ExplainState

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

typedef void(*	planner_setup_hook_type) (PlannerGlobal glob, Query parse, const char query_string, int cursorOptions, double tuple_fraction, ExplainState *es)

typedef void(*	planner_shutdown_hook_type) (PlannerGlobal glob, Query parse, const char query_string, PlannedStmt pstmt)

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, ExplainState *es)

PlannerInfo *	subquery_planner (PlannerGlobal glob, Query parse, char plan_name, PlannerInfo parent_root, PlannerInfo alternative_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)

RelOptInfo *	create_unique_paths (PlannerInfo root, RelOptInfo rel, SpecialJoinInfo *sjinfo)

char *	choose_plan_name (PlannerGlobal glob, const char name, bool always_number)

Variables
PGDLLIMPORT planner_hook_type	planner_hook

PGDLLIMPORT planner_setup_hook_type	planner_setup_hook

PGDLLIMPORT planner_shutdown_hook_type	planner_shutdown_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 50 of file planner.h.

◆ ExplainState

typedef struct ExplainState ExplainState

Definition at line 25 of file planner.h.

◆ planner_hook_type

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

Definition at line 28 of file planner.h.

◆ planner_setup_hook_type

typedef void(* planner_setup_hook_type) (PlannerGlobal *glob, Query *parse, const char *query_string, int cursorOptions, double *tuple_fraction, ExplainState *es)

Definition at line 36 of file planner.h.

◆ planner_shutdown_hook_type

typedef void(* planner_shutdown_hook_type) (PlannerGlobal *glob, Query *parse, const char *query_string, PlannedStmt *pstmt)

Definition at line 44 of file planner.h.

Function Documentation

◆ choose_plan_name()

char * choose_plan_name	(	PlannerGlobal *	glob,
		const char *	name,
		bool	always_number
	)

extern

Definition at line 9044 of file planner.c.

{
    unsigned    n;
 
    /*
     * If a numeric suffix is not required, then search the list of
     * previously-assigned names for a match. If none is found, then we can
     * use the provided name without modification.
     */
    if (!always_number)
    {
        bool        found = false;
 
        foreach_ptr(char, subplan_name, glob->subplanNames)
        {
            if (strcmp(subplan_name, name) == 0)
            {
                found = true;
                break;
            }
        }
 
        if (!found)
        {
            /* pstrdup here is just to avoid cast-away-const */
            char       *chosen_name = pstrdup(name);
 
            glob->subplanNames = lappend(glob->subplanNames, chosen_name);
            return chosen_name;
        }
    }
 
    /*
     * If a numeric suffix is required or if the un-suffixed name is already
     * in use, then loop until we find a positive integer that produces a
     * novel name.
     */
    for (n = 1; true; ++n)
    {
        char       *proposed_name = psprintf("%s_%u", name, n);
        bool        found = false;
 
        foreach_ptr(char, subplan_name, glob->subplanNames)
        {
            if (strcmp(subplan_name, proposed_name) == 0)
            {
                found = true;
                break;
            }
        }
 
        if (!found)
        {
            glob->subplanNames = lappend(glob->subplanNames, proposed_name);
            return proposed_name;
        }
 
        pfree(proposed_name);
    }
}

References fb(), foreach_ptr, lappend(), name, pfree(), psprintf(), and pstrdup().

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

◆ create_unique_paths()

RelOptInfo * create_unique_paths	(	PlannerInfo *	root,
		RelOptInfo *	rel,
		SpecialJoinInfo *	sjinfo
	)

extern

Definition at line 8492 of file planner.c.

{
    RelOptInfo *unique_rel;
    List       *sortPathkeys = NIL;
    List       *groupClause = NIL;
    MemoryContext oldcontext;
 
    /* Caller made a mistake if SpecialJoinInfo is the wrong one */
    Assert(sjinfo->jointype == JOIN_SEMI);
    Assert(bms_equal(rel->relids, sjinfo->syn_righthand));
 
    /* If result already cached, return it */
    if (rel->unique_rel)
        return rel->unique_rel;
 
    /* If it's not possible to unique-ify, return NULL */
    if (!(sjinfo->semi_can_btree || sjinfo->semi_can_hash))
        return NULL;
 
    /*
     * Punt if this is a child relation and we failed to build a unique-ified
     * relation for its parent.  This can happen if all the RHS columns were
     * found to be equated to constants when unique-ifying the parent table,
     * leaving no columns to unique-ify.
     */
    if (IS_OTHER_REL(rel) && rel->top_parent->unique_rel == NULL)
        return NULL;
 
    /*
     * When called during GEQO join planning, we are in a short-lived memory
     * context.  We must make sure that the unique rel and any subsidiary data
     * structures created for a baserel survive the GEQO cycle, else the
     * baserel is trashed for future GEQO cycles.  On the other hand, when we
     * are creating those for a joinrel during GEQO, we don't want them to
     * clutter the main planning context.  Upshot is that the best solution is
     * to explicitly allocate memory in the same context the given RelOptInfo
     * is in.
     */
    oldcontext = MemoryContextSwitchTo(GetMemoryChunkContext(rel));
 
    unique_rel = makeNode(RelOptInfo);
    memcpy(unique_rel, rel, sizeof(RelOptInfo));
 
    /*
     * clear path info
     */
    unique_rel->pathlist = NIL;
    unique_rel->ppilist = NIL;
    unique_rel->partial_pathlist = NIL;
    unique_rel->cheapest_startup_path = NULL;
    unique_rel->cheapest_total_path = NULL;
    unique_rel->cheapest_parameterized_paths = NIL;
 
    /*
     * Build the target list for the unique rel.  We also build the pathkeys
     * that represent the ordering requirements for the sort-based
     * implementation, and the list of SortGroupClause nodes that represent
     * the columns to be grouped on for the hash-based implementation.
     *
     * For a child rel, we can construct these fields from those of its
     * parent.
     */
    if (IS_OTHER_REL(rel))
    {
        PathTarget *child_unique_target;
        PathTarget *parent_unique_target;
 
        parent_unique_target = rel->top_parent->unique_rel->reltarget;
 
        child_unique_target = copy_pathtarget(parent_unique_target);
 
        /* Translate the target expressions */
        child_unique_target->exprs = (List *)
            adjust_appendrel_attrs_multilevel(root,
                                              (Node *) parent_unique_target->exprs,
                                              rel,
                                              rel->top_parent);
 
        unique_rel->reltarget = child_unique_target;
 
        sortPathkeys = rel->top_parent->unique_pathkeys;
        groupClause = rel->top_parent->unique_groupclause;
    }
    else
    {
        List       *newtlist;
        int         nextresno;
        List       *sortList = NIL;
        ListCell   *lc1;
        ListCell   *lc2;
 
        /*
         * The values we are supposed to unique-ify may be expressions in the
         * variables of the input rel's targetlist.  We have to add any such
         * expressions to the unique rel's targetlist.
         *
         * To complicate matters, some of the values to be unique-ified may be
         * known redundant by the EquivalenceClass machinery (e.g., because
         * they have been equated to constants).  There is no need to compare
         * such values during unique-ification, and indeed we had better not
         * try because the Vars involved may not have propagated as high as
         * the semijoin's level.  We use make_pathkeys_for_sortclauses to
         * detect such cases, which is a tad inefficient but it doesn't seem
         * worth building specialized infrastructure for this.
         */
        newtlist = make_tlist_from_pathtarget(rel->reltarget);
        nextresno = list_length(newtlist) + 1;
 
        forboth(lc1, sjinfo->semi_rhs_exprs, lc2, sjinfo->semi_operators)
        {
            Expr       *uniqexpr = lfirst(lc1);
            Oid         in_oper = lfirst_oid(lc2);
            Oid         sortop;
            TargetEntry *tle;
            bool        made_tle = false;
 
            tle = tlist_member(uniqexpr, newtlist);
            if (!tle)
            {
                tle = makeTargetEntry(uniqexpr,
                                      nextresno,
                                      NULL,
                                      false);
                newtlist = lappend(newtlist, tle);
                nextresno++;
                made_tle = true;
            }
 
            /*
             * Try to build an ORDER BY list to sort the input compatibly.  We
             * do this for each sortable clause even when the clauses are not
             * all sortable, so that we can detect clauses that are redundant
             * according to the pathkey machinery.
             */
            sortop = get_ordering_op_for_equality_op(in_oper, false);
            if (OidIsValid(sortop))
            {
                Oid         eqop;
                SortGroupClause *sortcl;
 
                /*
                 * The Unique node will need equality operators.  Normally
                 * these are the same as the IN clause operators, but if those
                 * are cross-type operators then the equality operators are
                 * the ones for the IN clause operators' RHS datatype.
                 */
                eqop = get_equality_op_for_ordering_op(sortop, NULL);
                if (!OidIsValid(eqop))  /* shouldn't happen */
                    elog(ERROR, "could not find equality operator for ordering operator %u",
                         sortop);
 
                sortcl = makeNode(SortGroupClause);
                sortcl->tleSortGroupRef = assignSortGroupRef(tle, newtlist);
                sortcl->eqop = eqop;
                sortcl->sortop = sortop;
                sortcl->reverse_sort = false;
                sortcl->nulls_first = false;
                sortcl->hashable = false;   /* no need to make this accurate */
                sortList = lappend(sortList, sortcl);
 
                /*
                 * At each step, convert the SortGroupClause list to pathkey
                 * form.  If the just-added SortGroupClause is redundant, the
                 * result will be shorter than the SortGroupClause list.
                 */
                sortPathkeys = make_pathkeys_for_sortclauses(root, sortList,
                                                             newtlist);
                if (list_length(sortPathkeys) != list_length(sortList))
                {
                    /* Drop the redundant SortGroupClause */
                    sortList = list_delete_last(sortList);
                    Assert(list_length(sortPathkeys) == list_length(sortList));
                    /* Undo tlist addition, if we made one */
                    if (made_tle)
                    {
                        newtlist = list_delete_last(newtlist);
                        nextresno--;
                    }
                    /* We need not consider this clause for hashing, either */
                    continue;
                }
            }
            else if (sjinfo->semi_can_btree)    /* shouldn't happen */
                elog(ERROR, "could not find ordering operator for equality operator %u",
                     in_oper);
 
            if (sjinfo->semi_can_hash)
            {
                /* Create a GROUP BY list for the Agg node to use */
                Oid         eq_oper;
                SortGroupClause *groupcl;
 
                /*
                 * Get the hashable equality operators for the Agg node to
                 * use. Normally these are the same as the IN clause
                 * operators, but if those are cross-type operators then the
                 * equality operators are the ones for the IN clause
                 * operators' RHS datatype.
                 */
                if (!get_compatible_hash_operators(in_oper, NULL, &eq_oper))
                    elog(ERROR, "could not find compatible hash operator for operator %u",
                         in_oper);
 
                groupcl = makeNode(SortGroupClause);
                groupcl->tleSortGroupRef = assignSortGroupRef(tle, newtlist);
                groupcl->eqop = eq_oper;
                groupcl->sortop = sortop;
                groupcl->reverse_sort = false;
                groupcl->nulls_first = false;
                groupcl->hashable = true;
                groupClause = lappend(groupClause, groupcl);
            }
        }
 
        /*
         * Done building the sortPathkeys and groupClause.  But the
         * sortPathkeys are bogus if not all the clauses were sortable.
         */
        if (!sjinfo->semi_can_btree)
            sortPathkeys = NIL;
 
        /*
         * It can happen that all the RHS columns are equated to constants.
         * We'd have to do something special to unique-ify in that case, and
         * it's such an unlikely-in-the-real-world case that it's not worth
         * the effort.  So just punt if we found no columns to unique-ify.
         */
        if (sortPathkeys == NIL && groupClause == NIL)
        {
            MemoryContextSwitchTo(oldcontext);
            return NULL;
        }
 
        /* Convert the required targetlist back to PathTarget form */
        unique_rel->reltarget = create_pathtarget(root, newtlist);
    }
 
    /* build unique paths based on input rel's pathlist */
    create_final_unique_paths(root, rel, sortPathkeys, groupClause,
                              sjinfo, unique_rel);
 
    /* build unique paths based on input rel's partial_pathlist */
    create_partial_unique_paths(root, rel, sortPathkeys, groupClause,
                                sjinfo, unique_rel);
 
    /* Now choose the best path(s) */
    set_cheapest(unique_rel);
 
    /*
     * There shouldn't be any partial paths for the unique relation;
     * otherwise, we won't be able to properly guarantee uniqueness.
     */
    Assert(unique_rel->partial_pathlist == NIL);
 
    /* Cache the result */
    rel->unique_rel = unique_rel;
    rel->unique_pathkeys = sortPathkeys;
    rel->unique_groupclause = groupClause;
 
    MemoryContextSwitchTo(oldcontext);
 
    return unique_rel;
}

References adjust_appendrel_attrs_multilevel(), Assert, assignSortGroupRef(), bms_equal(), RelOptInfo::cheapest_parameterized_paths, RelOptInfo::cheapest_startup_path, RelOptInfo::cheapest_total_path, copy_pathtarget(), create_final_unique_paths(), create_partial_unique_paths(), create_pathtarget, elog, ERROR, fb(), forboth, get_compatible_hash_operators(), get_equality_op_for_ordering_op(), get_ordering_op_for_equality_op(), GetMemoryChunkContext(), IS_OTHER_REL, JOIN_SEMI, SpecialJoinInfo::jointype, lappend(), lfirst, lfirst_oid, list_delete_last(), list_length(), make_pathkeys_for_sortclauses(), make_tlist_from_pathtarget(), makeNode, makeTargetEntry(), memcpy(), MemoryContextSwitchTo(), NIL, OidIsValid, RelOptInfo::partial_pathlist, RelOptInfo::pathlist, RelOptInfo::ppilist, RelOptInfo::relids, RelOptInfo::reltarget, root, SpecialJoinInfo::semi_can_btree, SpecialJoinInfo::semi_can_hash, SpecialJoinInfo::semi_operators, SpecialJoinInfo::semi_rhs_exprs, set_cheapest(), SpecialJoinInfo::syn_righthand, tlist_member(), RelOptInfo::unique_groupclause, RelOptInfo::unique_pathkeys, and RelOptInfo::unique_rel.

Referenced by join_is_legal(), and populate_joinrel_with_paths().

◆ get_cheapest_fractional_path()

Path * get_cheapest_fractional_path	(	RelOptInfo *	rel,
		double	tuple_fraction
	)

extern

Definition at line 6677 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->param_info)
            continue;
 
        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(), fb(), lfirst, and RelOptInfo::pathlist.

Referenced by add_paths_to_append_rel(), make_subplan(), and standard_planner().

◆ limit_needed()

bool limit_needed ( Query * parse )

extern

Definition at line 2861 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(), fb(), IsA, and parse().

Referenced by grouping_planner(), and set_rel_consider_parallel().

◆ mark_partial_aggref()

void mark_partial_aggref	(	Aggref *	agg,
		AggSplit	aggsplit
	)

extern

Definition at line 5838 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, fb(), and OidIsValid.

Referenced by convert_combining_aggrefs(), create_rel_agg_info(), and make_partial_grouping_target().

◆ preprocess_phv_expression()

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

extern

Definition at line 1500 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
	)

extern

Definition at line 2610 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, fb(), GetFdwRoutineByRelId(), FdwRoutine::GetForeignRowMarkType, LCS_FORKEYSHARE, LCS_FORNOKEYUPDATE, LCS_FORSHARE, LCS_FORUPDATE, LCS_NONE, ROW_MARK_COPY, ROW_MARK_EXCLUSIVE, ROW_MARK_KEYSHARE, ROW_MARK_NOKEYEXCLUSIVE, ROW_MARK_REFERENCE, ROW_MARK_SHARE, and RTE_RELATION.

Referenced by expand_single_inheritance_child(), and preprocess_rowmarks().

◆ standard_planner()

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

extern

Definition at line 333 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,
               *lc;
 
    /*
     * 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->allRelids = NULL;
    glob->prunableRelids = NULL;
    glob->finalrteperminfos = NIL;
    glob->finalrowmarks = NIL;
    glob->resultRelations = NIL;
    glob->appendRelations = NIL;
    glob->partPruneInfos = 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;
    glob->partition_directory = NULL;
    glob->rel_notnullatts_hash = NULL;
 
    /*
     * 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;
    }
 
    /*
     * Compute the initial path generation strategy mask.
     *
     * Some strategies, such as PGS_FOREIGNJOIN, have no corresponding enable_*
     * GUC, and so the corresponding bits are always set in the default
     * strategy mask.
     *
     * It may seem surprising that enable_indexscan sets both PGS_INDEXSCAN
     * and PGS_INDEXONLYSCAN. However, the historical behavior of this GUC
     * corresponds to this exactly: enable_indexscan=off disables both
     * index-scan and index-only scan paths, whereas enable_indexonlyscan=off
     * converts the index-only scan paths that we would have considered into
     * index scan paths.
     */
    glob->default_pgs_mask = PGS_APPEND | PGS_MERGE_APPEND | PGS_FOREIGNJOIN |
        PGS_GATHER | PGS_CONSIDER_NONPARTIAL;
    if (enable_tidscan)
        glob->default_pgs_mask |= PGS_TIDSCAN;
    if (enable_seqscan)
        glob->default_pgs_mask |= PGS_SEQSCAN;
    if (enable_indexscan)
        glob->default_pgs_mask |= PGS_INDEXSCAN | PGS_INDEXONLYSCAN;
    if (enable_indexonlyscan)
        glob->default_pgs_mask |= PGS_CONSIDER_INDEXONLY;
    if (enable_bitmapscan)
        glob->default_pgs_mask |= PGS_BITMAPSCAN;
    if (enable_mergejoin)
    {
        glob->default_pgs_mask |= PGS_MERGEJOIN_PLAIN;
        if (enable_material)
            glob->default_pgs_mask |= PGS_MERGEJOIN_MATERIALIZE;
    }
    if (enable_nestloop)
    {
        glob->default_pgs_mask |= PGS_NESTLOOP_PLAIN;
        if (enable_material)
            glob->default_pgs_mask |= PGS_NESTLOOP_MATERIALIZE;
        if (enable_memoize)
            glob->default_pgs_mask |= PGS_NESTLOOP_MEMOIZE;
    }
    if (enable_hashjoin)
        glob->default_pgs_mask |= PGS_HASHJOIN;
    if (enable_gathermerge)
        glob->default_pgs_mask |= PGS_GATHER_MERGE;
    if (enable_partitionwise_join)
        glob->default_pgs_mask |= PGS_CONSIDER_PARTITIONWISE;
 
    /* Allow plugins to take control after we've initialized "glob" */
    if (planner_setup_hook)
        (*planner_setup_hook) (glob, parse, query_string, cursorOptions,
                               &tuple_fraction, es);
 
    /* primary planning entry point (may recurse for subqueries) */
    root = subquery_planner(glob, parse, NULL, NULL, 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->planOrigin = PLAN_STMT_STANDARD;
    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->partPruneInfos = glob->partPruneInfos;
    result->rtable = glob->finalrtable;
    result->unprunableRelids = bms_difference(glob->allRelids,
                                              glob->prunableRelids);
    result->permInfos = glob->finalrteperminfos;
    result->subrtinfos = glob->subrtinfos;
    result->appendRelations = glob->appendRelations;
    result->subplans = glob->subplans;
    result->rewindPlanIDs = glob->rewindPlanIDs;
    result->rowMarks = glob->finalrowmarks;
 
    /*
     * Compute resultRelationRelids and rowMarkRelids from resultRelations and
     * rowMarks. These can be used for cheap membership checks.
     */
    foreach(lc, glob->resultRelations)
        result->resultRelationRelids = bms_add_member(result->resultRelationRelids,
                                                      lfirst_int(lc));
    foreach(lc, glob->finalrowmarks)
        result->rowMarkRelids = bms_add_member(result->rowMarkRelids,
                                               ((PlanRowMark *) lfirst(lc))->rti);
 
    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->elidedNodes = glob->elidedNodes;
    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;
    }
 
    /* Allow plugins to take control before we discard "glob" */
    if (planner_shutdown_hook)
        (*planner_shutdown_hook) (glob, parse, query_string, result);
 
    if (glob->partition_directory != NULL)
        DestroyPartitionDirectory(glob->partition_directory);
 
    return result;
}

References PlannerGlobal::allRelids, PlannerGlobal::appendRelations, Assert, bms_add_member(), bms_difference(), CMD_SELECT, 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::default_pgs_mask, PlannerGlobal::dependsOnRole, DestroyPartitionDirectory(), PlannerGlobal::elidedNodes, enable_bitmapscan, enable_gathermerge, enable_hashjoin, enable_indexonlyscan, enable_indexscan, enable_material, enable_memoize, enable_mergejoin, enable_nestloop, enable_partitionwise_join, enable_seqscan, enable_tidscan, ExecSupportsBackwardScan(), fb(), fetch_upper_rel(), PlannerGlobal::finalrowmarks, PlannerGlobal::finalrtable, PlannerGlobal::finalrteperminfos, forboth, get_cheapest_fractional_path(), PlannerGlobal::invalItems, IsParallelWorker, IsUnderPostmaster, jit_above_cost, jit_enabled, jit_expressions, jit_inline_above_cost, jit_optimize_above_cost, jit_tuple_deforming, PlannerGlobal::lastPHId, PlannerGlobal::lastPlanNodeId, PlannerGlobal::lastRowMarkId, lfirst, lfirst_int, lfirst_node, list_length(), makeNode, materialize_finished_plan(), max_parallel_hazard(), max_parallel_workers_per_gather, PlannerGlobal::maxParallelHazard, NIL, parallel_setup_cost, parallel_tuple_cost, PlannerGlobal::parallelModeNeeded, PlannerGlobal::parallelModeOK, PlannerGlobal::paramExecTypes, parse(), PlannerGlobal::partPruneInfos, PGJIT_DEFORM, PGJIT_EXPR, PGJIT_INLINE, PGJIT_NONE, PGJIT_OPT3, PGJIT_PERFORM, PGS_APPEND, PGS_BITMAPSCAN, PGS_CONSIDER_INDEXONLY, PGS_CONSIDER_NONPARTIAL, PGS_CONSIDER_PARTITIONWISE, PGS_FOREIGNJOIN, PGS_GATHER, PGS_GATHER_MERGE, PGS_HASHJOIN, PGS_INDEXONLYSCAN, PGS_INDEXSCAN, PGS_MERGE_APPEND, PGS_MERGEJOIN_MATERIALIZE, PGS_MERGEJOIN_PLAIN, PGS_NESTLOOP_MATERIALIZE, PGS_NESTLOOP_MEMOIZE, PGS_NESTLOOP_PLAIN, PGS_SEQSCAN, PGS_TIDSCAN, PLAN_STMT_STANDARD, planner_setup_hook, planner_shutdown_hook, PlannerGlobal::prunableRelids, PlannerGlobal::relationOids, result, PlannerGlobal::resultRelations, PlannerGlobal::rewindPlanIDs, root, set_plan_references(), SS_compute_initplan_cost(), SS_finalize_plan(), PlannerGlobal::subpaths, PlannerGlobal::subplans, subquery_planner(), PlannerGlobal::subrtinfos, PlannerGlobal::transientPlan, and UPPERREL_FINAL.

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

◆ subquery_planner()

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

extern

Definition at line 757 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->plan_name = plan_name;
    if (alternative_root != NULL)
        root->alternative_plan_name = alternative_root->plan_name;
    else
        root->alternative_plan_name = plan_name;
    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;
    root->assumeReplanning = false;
    if (hasRecursion)
        root->wt_param_id = assign_special_exec_param(root);
    else
        root->wt_param_id = -1;
    root->non_recursive_path = NULL;
 
    /*
     * 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);
 
    /*
     * Scan the rangetable for relation RTEs and retrieve the necessary
     * catalog information for each relation.  Using this information, clear
     * the inh flag for any relation that has no children, collect not-null
     * attribute numbers for any relation that has column not-null
     * constraints, and expand virtual generated columns for any relation that
     * contains them.  Note that this step does not descend into sublinks and
     * subqueries; if we pull up any sublinks or subqueries below, their
     * relation RTEs are processed just before pulling them up.
     */
    parse = root->parse = preprocess_relation_rtes(root);
 
    /*
     * 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_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);
    }
 
    /*
     * This would be a convenient time to check access permissions for all
     * relations mentioned in the query, since it would be better to fail now,
     * before doing any detailed planning.  However, for historical reasons,
     * we leave this to be done at executor startup.
     *
     * Note, however, that we do need to check access permissions for any view
     * relations mentioned in the query, in order to prevent information being
     * leaked by selectivity estimation functions, which only check view owner
     * permissions on underlying tables (see all_rows_selectable() and its
     * callers).  This is a little ugly, because it means that access
     * permissions for views will be checked twice, which is another reason
     * why it would be better to do all the ACL checks here.
     */
    foreach(l, parse->rtable)
    {
        RangeTblEntry *rte = lfirst_node(RangeTblEntry, l);
 
        if (rte->perminfoindex != 0 &&
            rte->relkind == RELKIND_VIEW)
        {
            RTEPermissionInfo *perminfo;
            bool        result;
 
            perminfo = getRTEPermissionInfo(parse->rteperminfos, rte);
            result = ExecCheckOneRelPerms(perminfo);
            if (!result)
                aclcheck_error(ACLCHECK_NO_PRIV, OBJECT_VIEW,
                               get_rel_name(perminfo->relid));
        }
    }
 
    /*
     * 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);
 
    /*
     * If we have grouping sets, expand the groupingSets tree of this query to
     * a flat list of grouping sets.  We need to do this before optimizing
     * HAVING, since we can't easily tell if there's an empty grouping set
     * until we have this representation.
     */
    if (parse->groupingSets)
    {
        parse->groupingSets =
            expand_grouping_sets(parse->groupingSets, parse->groupDistinct, -1);
    }
 
    /*
     * 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 grouping
     * sets and the clause references any columns that are nullable by the
     * grouping sets; the nulled values of those columns are not available
     * before the grouping step.  (The test on groupClause might seem wrong,
     * but it's okay: it's just an optimization to avoid running pull_varnos
     * when there cannot be any Vars in the HAVING clause.)
     *
     * 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 no empty grouping set 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 have to keep the clause in HAVING to
     * ensure that we don't emit a bogus aggregated row.  But then the HAVING
     * clause must be degenerate (variable-free), so we can copy it into WHERE
     * so that query_planner() can use it in a gating Result node. (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're 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 &&
                 (parse->groupingSets == NIL ||
                  (List *) linitial(parse->groupingSets) != NIL))
        {
            /* There is GROUP BY, but no empty grouping set */
            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
        {
            /* There is an empty grouping set (perhaps implicitly) */
            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;
}