/*-------------------------------------------------------------------------

 *

 * planner.c

 *    The query optimizer external interface.

 *

 * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group

 * Portions Copyright (c) 1994, Regents of the University of California

 *

 *

 * IDENTIFICATION

 *    src/backend/optimizer/plan/planner.c

 *

 *-------------------------------------------------------------------------

 */

#include "postgres.h"

#include <limits.h>

#include <math.h>

#include "access/genam.h"

#include "access/parallel.h"

#include "access/sysattr.h"

#include "access/table.h"

#include "catalog/pg_aggregate.h"

#include "catalog/pg_inherits.h"

#include "catalog/pg_proc.h"

#include "catalog/pg_type.h"

#include "executor/executor.h"

#include "foreign/fdwapi.h"

#include "jit/jit.h"

#include "lib/bipartite_match.h"

#include "lib/knapsack.h"

#include "miscadmin.h"

#include "nodes/makefuncs.h"

#include "nodes/nodeFuncs.h"

#ifdef OPTIMIZER_DEBUG

#include "nodes/print.h"

#endif

#include "nodes/supportnodes.h"

#include "optimizer/appendinfo.h"

#include "optimizer/clauses.h"

#include "optimizer/cost.h"

#include "optimizer/optimizer.h"

#include "optimizer/paramassign.h"

#include "optimizer/pathnode.h"

#include "optimizer/paths.h"

#include "optimizer/plancat.h"

#include "optimizer/planmain.h"

#include "optimizer/planner.h"

#include "optimizer/prep.h"

#include "optimizer/subselect.h"

#include "optimizer/tlist.h"

#include "parser/analyze.h"

#include "parser/parse_agg.h"

#include "parser/parse_clause.h"

#include "parser/parse_relation.h"

#include "parser/parsetree.h"

#include "partitioning/partdesc.h"

#include "rewrite/rewriteManip.h"

#include "utils/acl.h"

#include "utils/backend_status.h"

#include "utils/lsyscache.h"

#include "utils/rel.h"

#include "utils/selfuncs.h"

/* GUC parameters */

double    cursor_tuple_fraction = DEFAULT_CURSOR_TUPLE_FRACTION;

int     debug_parallel_query = DEBUG_PARALLEL_OFF;

bool    parallel_leader_participation = true;

bool    enable_distinct_reordering = true;

/* Hook for plugins to get control in planner() */

planner_hook_type planner_hook = NULL;

/* Hook for plugins to get control after PlannerGlobal is initialized */

planner_setup_hook_type planner_setup_hook = NULL;

/* Hook for plugins to get control before PlannerGlobal is discarded */

planner_shutdown_hook_type planner_shutdown_hook = NULL;

/* Hook for plugins to get control when grouping_planner() plans upper rels */

create_upper_paths_hook_type create_upper_paths_hook = NULL;

/* Expression kind codes for preprocess_expression */

#define EXPRKIND_QUAL       0

#define EXPRKIND_TARGET       1

#define EXPRKIND_RTFUNC       2

#define EXPRKIND_RTFUNC_LATERAL   3

#define EXPRKIND_VALUES       4

#define EXPRKIND_VALUES_LATERAL   5

#define EXPRKIND_LIMIT        6

#define EXPRKIND_APPINFO      7

#define EXPRKIND_PHV        8

#define EXPRKIND_TABLESAMPLE    9

#define EXPRKIND_ARBITER_ELEM   10

#define EXPRKIND_TABLEFUNC      11

#define EXPRKIND_TABLEFUNC_LATERAL  12

#define EXPRKIND_GROUPEXPR      13

/*

 * Data specific to grouping sets

 */

typedef struct

{

  List     *rollups;

  List     *hash_sets_idx;

  double    dNumHashGroups;

  bool    any_hashable;

  Bitmapset  *unsortable_refs;

  Bitmapset  *unhashable_refs;

  List     *unsortable_sets;

  int      *tleref_to_colnum_map;

} grouping_sets_data;

/*

 * Temporary structure for use during WindowClause reordering in order to be

 * able to sort WindowClauses on partitioning/ordering prefix.

 */

typedef struct

{

  WindowClause *wc;

  List     *uniqueOrder;  /* A List of unique ordering/partitioning

                 * clauses per Window */

} WindowClauseSortData;

/* Passthrough data for standard_qp_callback */

typedef struct

{

  List     *activeWindows;  /* active windows, if any */

  grouping_sets_data *gset_data;  /* grouping sets data, if any */

  SetOperationStmt *setop;  /* parent set operation or NULL if not a

                 * subquery belonging to a set operation */

} standard_qp_extra;

/*

 * Context for find_having_conflicts.  This is the callback context passed to

 * expression_has_grouping_conflict in clauses.c.

 */

typedef struct

{

  Query    *parse;

  Index   group_rtindex;

} having_grouping_ctx;

/* Local functions */

static Node *preprocess_expression(PlannerInfo *root, Node *expr, int kind);

static void preprocess_qual_conditions(PlannerInfo *root, Node *jtnode);

static Bitmapset *find_having_conflicts(Query *parse, Index group_rtindex);

static Oid  having_var_grouping_eqop(Var *var, void *context);

static Oid  group_var_eqop(Query *parse, Var *var);

static void grouping_planner(PlannerInfo *root, double tuple_fraction,

               SetOperationStmt *setops);

static grouping_sets_data *preprocess_grouping_sets(PlannerInfo *root);

static List *remap_to_groupclause_idx(List *groupClause, List *gsets,

                    int *tleref_to_colnum_map);

static void preprocess_rowmarks(PlannerInfo *root);

static double preprocess_limit(PlannerInfo *root,

                 double tuple_fraction,

                 int64 *offset_est, int64 *count_est);

static List *preprocess_groupclause(PlannerInfo *root, List *force);

static List *extract_rollup_sets(List *groupingSets);

static List *reorder_grouping_sets(List *groupingSets, List *sortclause);

static void standard_qp_callback(PlannerInfo *root, void *extra);

static double get_number_of_groups(PlannerInfo *root,

                   double path_rows,

                   grouping_sets_data *gd,

                   List *target_list);

static RelOptInfo *create_grouping_paths(PlannerInfo *root,

                     RelOptInfo *input_rel,

                     PathTarget *target,

                     bool target_parallel_safe,

                     grouping_sets_data *gd);

static bool is_degenerate_grouping(PlannerInfo *root);

static void create_degenerate_grouping_paths(PlannerInfo *root,

                       RelOptInfo *input_rel,

                       RelOptInfo *grouped_rel);

static RelOptInfo *make_grouping_rel(PlannerInfo *root, RelOptInfo *input_rel,

                   PathTarget *target, bool target_parallel_safe,

                   Node *havingQual);

static void create_ordinary_grouping_paths(PlannerInfo *root,

                       RelOptInfo *input_rel,

                       RelOptInfo *grouped_rel,

                       const AggClauseCosts *agg_costs,

                       grouping_sets_data *gd,

                       GroupPathExtraData *extra,

                       RelOptInfo **partially_grouped_rel_p);

static void consider_groupingsets_paths(PlannerInfo *root,

                    RelOptInfo *grouped_rel,

                    Path *path,

                    bool is_sorted,

                    bool can_hash,

                    grouping_sets_data *gd,

                    const AggClauseCosts *agg_costs,

                    double dNumGroups);

static RelOptInfo *create_window_paths(PlannerInfo *root,

                     RelOptInfo *input_rel,

                     PathTarget *input_target,

                     PathTarget *output_target,

                     bool output_target_parallel_safe,

                     WindowFuncLists *wflists,

                     List *activeWindows);

static void create_one_window_path(PlannerInfo *root,

                   RelOptInfo *window_rel,

                   Path *path,

                   PathTarget *input_target,

                   PathTarget *output_target,

                   WindowFuncLists *wflists,

                   List *activeWindows);

static RelOptInfo *create_distinct_paths(PlannerInfo *root,

                     RelOptInfo *input_rel,

                     PathTarget *target);

static void create_partial_distinct_paths(PlannerInfo *root,

                      RelOptInfo *input_rel,

                      RelOptInfo *final_distinct_rel,

                      PathTarget *target);

static RelOptInfo *create_final_distinct_paths(PlannerInfo *root,

                         RelOptInfo *input_rel,

                         RelOptInfo *distinct_rel);

static List *get_useful_pathkeys_for_distinct(PlannerInfo *root,

                        List *needed_pathkeys,

                        List *path_pathkeys);

static RelOptInfo *create_ordered_paths(PlannerInfo *root,

                    RelOptInfo *input_rel,

                    PathTarget *target,

                    bool target_parallel_safe,

                    double limit_tuples);

static PathTarget *make_group_input_target(PlannerInfo *root,

                       PathTarget *final_target);

static PathTarget *make_partial_grouping_target(PlannerInfo *root,

                        PathTarget *grouping_target,

                        Node *havingQual);

static List *postprocess_setop_tlist(List *new_tlist, List *orig_tlist);

static void optimize_window_clauses(PlannerInfo *root,

                  WindowFuncLists *wflists);

static List *select_active_windows(PlannerInfo *root, WindowFuncLists *wflists);

static void name_active_windows(List *activeWindows);

static PathTarget *make_window_input_target(PlannerInfo *root,

                      PathTarget *final_target,

                      List *activeWindows);

static List *make_pathkeys_for_window(PlannerInfo *root, WindowClause *wc,

                    List *tlist);

static PathTarget *make_sort_input_target(PlannerInfo *root,

                      PathTarget *final_target,

                      bool *have_postponed_srfs);

static void adjust_paths_for_srfs(PlannerInfo *root, RelOptInfo *rel,

                  List *targets, List *targets_contain_srfs);

static void add_paths_to_grouping_rel(PlannerInfo *root, RelOptInfo *input_rel,

                    RelOptInfo *grouped_rel,

                    RelOptInfo *partially_grouped_rel,

                    const AggClauseCosts *agg_costs,

                    grouping_sets_data *gd,

                    GroupPathExtraData *extra);

static RelOptInfo *create_partial_grouping_paths(PlannerInfo *root,

                         RelOptInfo *grouped_rel,

                         RelOptInfo *input_rel,

                         grouping_sets_data *gd,

                         GroupPathExtraData *extra,

                         bool force_rel_creation);

static Path *make_ordered_path(PlannerInfo *root,

                 RelOptInfo *rel,

                 Path *path,

                 Path *cheapest_path,

                 List *pathkeys,

                 double limit_tuples);

static void gather_grouping_paths(PlannerInfo *root, RelOptInfo *rel);

static bool can_partial_agg(PlannerInfo *root);

static void apply_scanjoin_target_to_paths(PlannerInfo *root,

                       RelOptInfo *rel,

                       List *scanjoin_targets,

                       List *scanjoin_targets_contain_srfs,

                       bool scanjoin_target_parallel_safe,

                       bool tlist_same_exprs);

static void create_partitionwise_grouping_paths(PlannerInfo *root,

                        RelOptInfo *input_rel,

                        RelOptInfo *grouped_rel,

                        RelOptInfo *partially_grouped_rel,

                        const AggClauseCosts *agg_costs,

                        grouping_sets_data *gd,

                        PartitionwiseAggregateType patype,

                        GroupPathExtraData *extra);

static bool group_by_has_partkey(RelOptInfo *input_rel,

                 List *targetList,

                 List *groupClause);

static int  common_prefix_cmp(const void *a, const void *b);

static List *generate_setop_child_grouplist(SetOperationStmt *op,

                      List *targetlist);

static void create_final_unique_paths(PlannerInfo *root, RelOptInfo *input_rel,

                    List *sortPathkeys, List *groupClause,

                    SpecialJoinInfo *sjinfo, RelOptInfo *unique_rel);

static void create_partial_unique_paths(PlannerInfo *root, RelOptInfo *input_rel,

                    List *sortPathkeys, List *groupClause,

                    SpecialJoinInfo *sjinfo, RelOptInfo *unique_rel);

/*****************************************************************************

 *

 *     Query optimizer entry point

 *

 * Inputs:

 *  parse: an analyzed-and-rewritten query tree for an optimizable statement

 *  query_string: source text for the query tree (used for error reports)

 *  cursorOptions: bitmask of CURSOR_OPT_XXX flags, see parsenodes.h

 *  boundParams: passed-in parameter values, or NULL if none

 *  es: ExplainState if being called from EXPLAIN, else NULL

 *

 * The result is a PlannedStmt tree.

 *

 * PARAM_EXTERN Param nodes within the parse tree can be replaced by Consts

 * using values from boundParams, if those values are marked PARAM_FLAG_CONST.

 * Parameter values not so marked are still relied on for estimation purposes.

 *

 * The ExplainState pointer is not currently used by the core planner, but it

 * is passed through to some planner hooks so that they can report information

 * back to EXPLAIN extension hooks.

 *

 * To support loadable plugins that monitor or modify planner behavior,

 * we provide a hook variable that lets a plugin get control before and

 * after the standard planning process.  The plugin would normally call

 * standard_planner().

 *

 * Note to plugin authors: standard_planner() scribbles on its Query input,

 * so you'd better copy that data structure if you want to plan more than once.

 *

 *****************************************************************************/

PlannedStmt *

planner(Query *parse, const char *query_string, int cursorOptions,

    ParamListInfo boundParams, ExplainState *es)

{

  PlannedStmt *result;

  if (planner_hook)

    result = (*planner_hook) (parse, query_string, cursorOptions,

                  boundParams, es);

  else

    result = standard_planner(parse, query_string, cursorOptions,

                  boundParams, es);

  pgstat_report_plan_id(result->planId, false);

  return result;

}

PlannedStmt *

standard_planner(Query *parse, const char *query_string, int cursorOptions,

         ParamListInfo boundParams, ExplainState *es)

{

  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;

}

/*--------------------

 * subquery_planner

 *    Invokes the planner on a subquery.  We recurse to here for each

 *    sub-SELECT found in the query tree.

 *

 * glob is the global state for the current planner run.

 * parse is the querytree produced by the parser & rewriter.

 * plan_name is the name to assign to this subplan (NULL at the top level).

 * parent_root is the immediate parent Query's info (NULL at the top level).

 * alternative_root is a previously created PlannerInfo for which this query

 * level is an alternative implementation, or else NULL.

 * hasRecursion is true if this is a recursive WITH query.

 * tuple_fraction is the fraction of tuples we expect will be retrieved.

 * tuple_fraction is interpreted as explained for grouping_planner, below.

 * setops is used for set operation subqueries to provide the subquery with

 * the context in which it's being used so that Paths correctly sorted for the

 * set operation can be generated.  NULL when not planning a set operation

 * child, or when a child of a set op that isn't interested in sorted input.

 *

 * Basically, this routine does the stuff that should only be done once

 * per Query object.  It then calls grouping_planner.  At one time,

 * grouping_planner could be invoked recursively on the same Query object;

 * that's not currently true, but we keep the separation between the two

 * routines anyway, in case we need it again someday.

 *

 * subquery_planner will be called recursively to handle sub-Query nodes

 * found within the query's expressions and rangetable.

 *

 * Returns the PlannerInfo struct ("root") that contains all data generated

 * while planning the subquery.  In particular, the Path(s) attached to

 * the (UPPERREL_FINAL, NULL) upperrel represent our conclusions about the

 * cheapest way(s) to implement the query.  The top level will select the

 * best Path and pass it through createplan.c to produce a finished Plan.

 *--------------------

 */

PlannerInfo *

subquery_planner(PlannerGlobal *glob, Query *parse, char *plan_name,

         PlannerInfo *parent_root, PlannerInfo *alternative_root,

         bool hasRecursion, double tuple_fraction,

         SetOperationStmt *setops)

{

  PlannerInfo *root;

  List     *newWithCheckOptions;

  List     *newHaving;

  Bitmapset  *havingPushdownConflicts;

  int     havingIdx;

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

  /*

   * Reject FOR PORTION OF on a generated column.  We can't write to a

   * virtual generated column, and a stored generated column should be

   * written by its own expression.

   *

   * We do this in the planner rather than parse analysis so that updatable

   * views have been rewritten; otherwise they would mask which columns are

   * generated.  We need to check before preprocess_relation_rtes(), so that

   * for virtual generated columns we still have the rangeVar.  After that

   * it is replaced by the column's expression.

   *

   * XXX: We plan to implement PERIODs as stored generated columns, so later

   * we will loosen this restriction if the column belongs to a PERIOD.

   */

  if (parse->forPortionOf)

  {

    ForPortionOfExpr *forPortionOf = parse->forPortionOf;

    RangeTblEntry *rte = rt_fetch(parse->resultRelation, parse->rtable);

    if (get_attgenerated(rte->relid, forPortionOf->rangeVar->varattno))

      ereport(ERROR,

          (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),

           errmsg("cannot use generated column \"%s\" in FOR PORTION OF",

              get_attname(rte->relid,

                    forPortionOf->rangeVar->varattno,

                    false))));

  }

  /*

   * 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().