#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 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 6298 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 2628 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 5512 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 1272 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 2377 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 287 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 628 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;
     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;
             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);
  
     /* Constant-folding might have removed all set-returning functions */
     if (parse->hasTargetSRFs)
         parse->hasTargetSRFs = expression_returns_set((Node *) parse->targetList);
  
     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);
         wc->runCondition = (List *) preprocess_expression(root,
                                                           (Node *) wc->runCondition,
                                                           EXPRKIND_TARGET);
     }
  
     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);
         }
  
         /*
          * 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;
         }
     }
  
     /*
      * 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; moving such a clause into WHERE would potentially change
      * the results, if any referenced column isn't present in all the grouping
      * sets.  (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 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 ((parse->groupClause && parse->groupingSets) ||
             contain_agg_clause(havingclause) ||
             contain_volatile_functions(havingclause) ||
             contain_subplans(havingclause))
         {
             /* keep it in HAVING */
             newHaving = lappend(newHaving, havingclause);
         }
         else if (parse->groupClause && !parse->groupingSets)
         {
             /* move it to WHERE */
             parse->jointree->quals = (Node *)
                 lappend((List *) parse->jointree->quals, havingclause);
         }
         else
         {
             /* put a copy in WHERE, keep it in HAVING */
             parse->jointree->quals = (Node *)
                 lappend((List *) parse->jointree->quals,
                         copyObject(havingclause));
             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;
 }