LCOV - code coverage report
Current view: top level - src/backend/optimizer/path - allpaths.c (source / functions) Hit Total Coverage
Test: PostgreSQL 19devel Lines: 1157 1226 94.4 %
Date: 2025-10-10 15:18:24 Functions: 52 52 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * allpaths.c
       4             :  *    Routines to find possible search paths for processing a query
       5             :  *
       6             :  * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
       7             :  * Portions Copyright (c) 1994, Regents of the University of California
       8             :  *
       9             :  *
      10             :  * IDENTIFICATION
      11             :  *    src/backend/optimizer/path/allpaths.c
      12             :  *
      13             :  *-------------------------------------------------------------------------
      14             :  */
      15             : 
      16             : #include "postgres.h"
      17             : 
      18             : #include <limits.h>
      19             : #include <math.h>
      20             : 
      21             : #include "access/sysattr.h"
      22             : #include "access/tsmapi.h"
      23             : #include "catalog/pg_class.h"
      24             : #include "catalog/pg_operator.h"
      25             : #include "catalog/pg_proc.h"
      26             : #include "foreign/fdwapi.h"
      27             : #include "miscadmin.h"
      28             : #include "nodes/makefuncs.h"
      29             : #include "nodes/nodeFuncs.h"
      30             : #include "nodes/supportnodes.h"
      31             : #ifdef OPTIMIZER_DEBUG
      32             : #include "nodes/print.h"
      33             : #endif
      34             : #include "optimizer/appendinfo.h"
      35             : #include "optimizer/clauses.h"
      36             : #include "optimizer/cost.h"
      37             : #include "optimizer/geqo.h"
      38             : #include "optimizer/optimizer.h"
      39             : #include "optimizer/pathnode.h"
      40             : #include "optimizer/paths.h"
      41             : #include "optimizer/plancat.h"
      42             : #include "optimizer/planner.h"
      43             : #include "optimizer/prep.h"
      44             : #include "optimizer/tlist.h"
      45             : #include "parser/parse_clause.h"
      46             : #include "parser/parsetree.h"
      47             : #include "partitioning/partbounds.h"
      48             : #include "port/pg_bitutils.h"
      49             : #include "rewrite/rewriteManip.h"
      50             : #include "utils/lsyscache.h"
      51             : #include "utils/selfuncs.h"
      52             : 
      53             : 
      54             : /* Bitmask flags for pushdown_safety_info.unsafeFlags */
      55             : #define UNSAFE_HAS_VOLATILE_FUNC        (1 << 0)
      56             : #define UNSAFE_HAS_SET_FUNC             (1 << 1)
      57             : #define UNSAFE_NOTIN_DISTINCTON_CLAUSE  (1 << 2)
      58             : #define UNSAFE_NOTIN_PARTITIONBY_CLAUSE (1 << 3)
      59             : #define UNSAFE_TYPE_MISMATCH            (1 << 4)
      60             : 
      61             : /* results of subquery_is_pushdown_safe */
      62             : typedef struct pushdown_safety_info
      63             : {
      64             :     unsigned char *unsafeFlags; /* bitmask of reasons why this target list
      65             :                                  * column is unsafe for qual pushdown, or 0 if
      66             :                                  * no reason. */
      67             :     bool        unsafeVolatile; /* don't push down volatile quals */
      68             :     bool        unsafeLeaky;    /* don't push down leaky quals */
      69             : } pushdown_safety_info;
      70             : 
      71             : /* Return type for qual_is_pushdown_safe */
      72             : typedef enum pushdown_safe_type
      73             : {
      74             :     PUSHDOWN_UNSAFE,            /* unsafe to push qual into subquery */
      75             :     PUSHDOWN_SAFE,              /* safe to push qual into subquery */
      76             :     PUSHDOWN_WINDOWCLAUSE_RUNCOND,  /* unsafe, but may work as WindowClause
      77             :                                      * run condition */
      78             : } pushdown_safe_type;
      79             : 
      80             : /* These parameters are set by GUC */
      81             : bool        enable_geqo = false;    /* just in case GUC doesn't set it */
      82             : bool        enable_eager_aggregate = true;
      83             : int         geqo_threshold;
      84             : double      min_eager_agg_group_size;
      85             : int         min_parallel_table_scan_size;
      86             : int         min_parallel_index_scan_size;
      87             : 
      88             : /* Hook for plugins to get control in set_rel_pathlist() */
      89             : set_rel_pathlist_hook_type set_rel_pathlist_hook = NULL;
      90             : 
      91             : /* Hook for plugins to replace standard_join_search() */
      92             : join_search_hook_type join_search_hook = NULL;
      93             : 
      94             : 
      95             : static void set_base_rel_consider_startup(PlannerInfo *root);
      96             : static void set_base_rel_sizes(PlannerInfo *root);
      97             : static void setup_simple_grouped_rels(PlannerInfo *root);
      98             : static void set_base_rel_pathlists(PlannerInfo *root);
      99             : static void set_rel_size(PlannerInfo *root, RelOptInfo *rel,
     100             :                          Index rti, RangeTblEntry *rte);
     101             : static void set_rel_pathlist(PlannerInfo *root, RelOptInfo *rel,
     102             :                              Index rti, RangeTblEntry *rte);
     103             : static void set_plain_rel_size(PlannerInfo *root, RelOptInfo *rel,
     104             :                                RangeTblEntry *rte);
     105             : static void create_plain_partial_paths(PlannerInfo *root, RelOptInfo *rel);
     106             : static void set_rel_consider_parallel(PlannerInfo *root, RelOptInfo *rel,
     107             :                                       RangeTblEntry *rte);
     108             : static void set_plain_rel_pathlist(PlannerInfo *root, RelOptInfo *rel,
     109             :                                    RangeTblEntry *rte);
     110             : static void set_tablesample_rel_size(PlannerInfo *root, RelOptInfo *rel,
     111             :                                      RangeTblEntry *rte);
     112             : static void set_tablesample_rel_pathlist(PlannerInfo *root, RelOptInfo *rel,
     113             :                                          RangeTblEntry *rte);
     114             : static void set_foreign_size(PlannerInfo *root, RelOptInfo *rel,
     115             :                              RangeTblEntry *rte);
     116             : static void set_foreign_pathlist(PlannerInfo *root, RelOptInfo *rel,
     117             :                                  RangeTblEntry *rte);
     118             : static void set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
     119             :                                 Index rti, RangeTblEntry *rte);
     120             : static void set_append_rel_pathlist(PlannerInfo *root, RelOptInfo *rel,
     121             :                                     Index rti, RangeTblEntry *rte);
     122             : static void set_grouped_rel_pathlist(PlannerInfo *root, RelOptInfo *rel);
     123             : static void generate_orderedappend_paths(PlannerInfo *root, RelOptInfo *rel,
     124             :                                          List *live_childrels,
     125             :                                          List *all_child_pathkeys);
     126             : static Path *get_cheapest_parameterized_child_path(PlannerInfo *root,
     127             :                                                    RelOptInfo *rel,
     128             :                                                    Relids required_outer);
     129             : static void accumulate_append_subpath(Path *path,
     130             :                                       List **subpaths,
     131             :                                       List **special_subpaths);
     132             : static Path *get_singleton_append_subpath(Path *path);
     133             : static void set_dummy_rel_pathlist(RelOptInfo *rel);
     134             : static void set_subquery_pathlist(PlannerInfo *root, RelOptInfo *rel,
     135             :                                   Index rti, RangeTblEntry *rte);
     136             : static void set_function_pathlist(PlannerInfo *root, RelOptInfo *rel,
     137             :                                   RangeTblEntry *rte);
     138             : static void set_values_pathlist(PlannerInfo *root, RelOptInfo *rel,
     139             :                                 RangeTblEntry *rte);
     140             : static void set_tablefunc_pathlist(PlannerInfo *root, RelOptInfo *rel,
     141             :                                    RangeTblEntry *rte);
     142             : static void set_cte_pathlist(PlannerInfo *root, RelOptInfo *rel,
     143             :                              RangeTblEntry *rte);
     144             : static void set_namedtuplestore_pathlist(PlannerInfo *root, RelOptInfo *rel,
     145             :                                          RangeTblEntry *rte);
     146             : static void set_result_pathlist(PlannerInfo *root, RelOptInfo *rel,
     147             :                                 RangeTblEntry *rte);
     148             : static void set_worktable_pathlist(PlannerInfo *root, RelOptInfo *rel,
     149             :                                    RangeTblEntry *rte);
     150             : static RelOptInfo *make_rel_from_joinlist(PlannerInfo *root, List *joinlist);
     151             : static bool subquery_is_pushdown_safe(Query *subquery, Query *topquery,
     152             :                                       pushdown_safety_info *safetyInfo);
     153             : static bool recurse_pushdown_safe(Node *setOp, Query *topquery,
     154             :                                   pushdown_safety_info *safetyInfo);
     155             : static void check_output_expressions(Query *subquery,
     156             :                                      pushdown_safety_info *safetyInfo);
     157             : static void compare_tlist_datatypes(List *tlist, List *colTypes,
     158             :                                     pushdown_safety_info *safetyInfo);
     159             : static bool targetIsInAllPartitionLists(TargetEntry *tle, Query *query);
     160             : static pushdown_safe_type qual_is_pushdown_safe(Query *subquery, Index rti,
     161             :                                                 RestrictInfo *rinfo,
     162             :                                                 pushdown_safety_info *safetyInfo);
     163             : static void subquery_push_qual(Query *subquery,
     164             :                                RangeTblEntry *rte, Index rti, Node *qual);
     165             : static void recurse_push_qual(Node *setOp, Query *topquery,
     166             :                               RangeTblEntry *rte, Index rti, Node *qual);
     167             : static void remove_unused_subquery_outputs(Query *subquery, RelOptInfo *rel,
     168             :                                            Bitmapset *extra_used_attrs);
     169             : 
     170             : 
     171             : /*
     172             :  * make_one_rel
     173             :  *    Finds all possible access paths for executing a query, returning a
     174             :  *    single rel that represents the join of all base rels in the query.
     175             :  */
     176             : RelOptInfo *
     177      325366 : make_one_rel(PlannerInfo *root, List *joinlist)
     178             : {
     179             :     RelOptInfo *rel;
     180             :     Index       rti;
     181             :     double      total_pages;
     182             : 
     183             :     /* Mark base rels as to whether we care about fast-start plans */
     184      325366 :     set_base_rel_consider_startup(root);
     185             : 
     186             :     /*
     187             :      * Compute size estimates and consider_parallel flags for each base rel.
     188             :      */
     189      325366 :     set_base_rel_sizes(root);
     190             : 
     191             :     /*
     192             :      * Build grouped relations for simple rels (i.e., base or "other" member
     193             :      * relations) where possible.
     194             :      */
     195      325332 :     setup_simple_grouped_rels(root);
     196             : 
     197             :     /*
     198             :      * We should now have size estimates for every actual table involved in
     199             :      * the query, and we also know which if any have been deleted from the
     200             :      * query by join removal, pruned by partition pruning, or eliminated by
     201             :      * constraint exclusion.  So we can now compute total_table_pages.
     202             :      *
     203             :      * Note that appendrels are not double-counted here, even though we don't
     204             :      * bother to distinguish RelOptInfos for appendrel parents, because the
     205             :      * parents will have pages = 0.
     206             :      *
     207             :      * XXX if a table is self-joined, we will count it once per appearance,
     208             :      * which perhaps is the wrong thing ... but that's not completely clear,
     209             :      * and detecting self-joins here is difficult, so ignore it for now.
     210             :      */
     211      325332 :     total_pages = 0;
     212     1007684 :     for (rti = 1; rti < root->simple_rel_array_size; rti++)
     213             :     {
     214      682352 :         RelOptInfo *brel = root->simple_rel_array[rti];
     215             : 
     216             :         /* there may be empty slots corresponding to non-baserel RTEs */
     217      682352 :         if (brel == NULL)
     218      161690 :             continue;
     219             : 
     220             :         Assert(brel->relid == rti); /* sanity check on array */
     221             : 
     222      520662 :         if (IS_DUMMY_REL(brel))
     223        1352 :             continue;
     224             : 
     225      519310 :         if (IS_SIMPLE_REL(brel))
     226      519310 :             total_pages += (double) brel->pages;
     227             :     }
     228      325332 :     root->total_table_pages = total_pages;
     229             : 
     230             :     /*
     231             :      * Generate access paths for each base rel.
     232             :      */
     233      325332 :     set_base_rel_pathlists(root);
     234             : 
     235             :     /*
     236             :      * Generate access paths for the entire join tree.
     237             :      */
     238      325332 :     rel = make_rel_from_joinlist(root, joinlist);
     239             : 
     240             :     /*
     241             :      * The result should join all and only the query's base + outer-join rels.
     242             :      */
     243             :     Assert(bms_equal(rel->relids, root->all_query_rels));
     244             : 
     245      325332 :     return rel;
     246             : }
     247             : 
     248             : /*
     249             :  * set_base_rel_consider_startup
     250             :  *    Set the consider_[param_]startup flags for each base-relation entry.
     251             :  *
     252             :  * For the moment, we only deal with consider_param_startup here; because the
     253             :  * logic for consider_startup is pretty trivial and is the same for every base
     254             :  * relation, we just let build_simple_rel() initialize that flag correctly to
     255             :  * start with.  If that logic ever gets more complicated it would probably
     256             :  * be better to move it here.
     257             :  */
     258             : static void
     259      325366 : set_base_rel_consider_startup(PlannerInfo *root)
     260             : {
     261             :     /*
     262             :      * Since parameterized paths can only be used on the inside of a nestloop
     263             :      * join plan, there is usually little value in considering fast-start
     264             :      * plans for them.  However, for relations that are on the RHS of a SEMI
     265             :      * or ANTI join, a fast-start plan can be useful because we're only going
     266             :      * to care about fetching one tuple anyway.
     267             :      *
     268             :      * To minimize growth of planning time, we currently restrict this to
     269             :      * cases where the RHS is a single base relation, not a join; there is no
     270             :      * provision for consider_param_startup to get set at all on joinrels.
     271             :      * Also we don't worry about appendrels.  costsize.c's costing rules for
     272             :      * nestloop semi/antijoins don't consider such cases either.
     273             :      */
     274             :     ListCell   *lc;
     275             : 
     276      367840 :     foreach(lc, root->join_info_list)
     277             :     {
     278       42474 :         SpecialJoinInfo *sjinfo = (SpecialJoinInfo *) lfirst(lc);
     279             :         int         varno;
     280             : 
     281       51000 :         if ((sjinfo->jointype == JOIN_SEMI || sjinfo->jointype == JOIN_ANTI) &&
     282        8526 :             bms_get_singleton_member(sjinfo->syn_righthand, &varno))
     283             :         {
     284        8326 :             RelOptInfo *rel = find_base_rel(root, varno);
     285             : 
     286        8326 :             rel->consider_param_startup = true;
     287             :         }
     288             :     }
     289      325366 : }
     290             : 
     291             : /*
     292             :  * set_base_rel_sizes
     293             :  *    Set the size estimates (rows and widths) for each base-relation entry.
     294             :  *    Also determine whether to consider parallel paths for base relations.
     295             :  *
     296             :  * We do this in a separate pass over the base rels so that rowcount
     297             :  * estimates are available for parameterized path generation, and also so
     298             :  * that each rel's consider_parallel flag is set correctly before we begin to
     299             :  * generate paths.
     300             :  */
     301             : static void
     302      325366 : set_base_rel_sizes(PlannerInfo *root)
     303             : {
     304             :     Index       rti;
     305             : 
     306     1007720 :     for (rti = 1; rti < root->simple_rel_array_size; rti++)
     307             :     {
     308      682388 :         RelOptInfo *rel = root->simple_rel_array[rti];
     309             :         RangeTblEntry *rte;
     310             : 
     311             :         /* there may be empty slots corresponding to non-baserel RTEs */
     312      682388 :         if (rel == NULL)
     313      161692 :             continue;
     314             : 
     315             :         Assert(rel->relid == rti);   /* sanity check on array */
     316             : 
     317             :         /* ignore RTEs that are "other rels" */
     318      520696 :         if (rel->reloptkind != RELOPT_BASEREL)
     319       57410 :             continue;
     320             : 
     321      463286 :         rte = root->simple_rte_array[rti];
     322             : 
     323             :         /*
     324             :          * If parallelism is allowable for this query in general, see whether
     325             :          * it's allowable for this rel in particular.  We have to do this
     326             :          * before set_rel_size(), because (a) if this rel is an inheritance
     327             :          * parent, set_append_rel_size() will use and perhaps change the rel's
     328             :          * consider_parallel flag, and (b) for some RTE types, set_rel_size()
     329             :          * goes ahead and makes paths immediately.
     330             :          */
     331      463286 :         if (root->glob->parallelModeOK)
     332      369648 :             set_rel_consider_parallel(root, rel, rte);
     333             : 
     334      463286 :         set_rel_size(root, rel, rti, rte);
     335             :     }
     336      325332 : }
     337             : 
     338             : /*
     339             :  * setup_simple_grouped_rels
     340             :  *    For each simple relation, build a grouped simple relation if eager
     341             :  *    aggregation is possible and if this relation can produce grouped paths.
     342             :  */
     343             : static void
     344      325332 : setup_simple_grouped_rels(PlannerInfo *root)
     345             : {
     346             :     Index       rti;
     347             : 
     348             :     /*
     349             :      * If there are no aggregate expressions or grouping expressions, eager
     350             :      * aggregation is not possible.
     351             :      */
     352      325332 :     if (root->agg_clause_list == NIL ||
     353         658 :         root->group_expr_list == NIL)
     354      324740 :         return;
     355             : 
     356        5074 :     for (rti = 1; rti < root->simple_rel_array_size; rti++)
     357             :     {
     358        4482 :         RelOptInfo *rel = root->simple_rel_array[rti];
     359             : 
     360             :         /* there may be empty slots corresponding to non-baserel RTEs */
     361        4482 :         if (rel == NULL)
     362        1414 :             continue;
     363             : 
     364             :         Assert(rel->relid == rti);   /* sanity check on array */
     365             :         Assert(IS_SIMPLE_REL(rel)); /* sanity check on rel */
     366             : 
     367        3068 :         (void) build_simple_grouped_rel(root, rel);
     368             :     }
     369             : }
     370             : 
     371             : /*
     372             :  * set_base_rel_pathlists
     373             :  *    Finds all paths available for scanning each base-relation entry.
     374             :  *    Sequential scan and any available indices are considered.
     375             :  *    Each useful path is attached to its relation's 'pathlist' field.
     376             :  */
     377             : static void
     378      325332 : set_base_rel_pathlists(PlannerInfo *root)
     379             : {
     380             :     Index       rti;
     381             : 
     382     1007684 :     for (rti = 1; rti < root->simple_rel_array_size; rti++)
     383             :     {
     384      682352 :         RelOptInfo *rel = root->simple_rel_array[rti];
     385             : 
     386             :         /* there may be empty slots corresponding to non-baserel RTEs */
     387      682352 :         if (rel == NULL)
     388      161690 :             continue;
     389             : 
     390             :         Assert(rel->relid == rti);   /* sanity check on array */
     391             : 
     392             :         /* ignore RTEs that are "other rels" */
     393      520662 :         if (rel->reloptkind != RELOPT_BASEREL)
     394       57410 :             continue;
     395             : 
     396      463252 :         set_rel_pathlist(root, rel, rti, root->simple_rte_array[rti]);
     397             :     }
     398      325332 : }
     399             : 
     400             : /*
     401             :  * set_rel_size
     402             :  *    Set size estimates for a base relation
     403             :  */
     404             : static void
     405      520386 : set_rel_size(PlannerInfo *root, RelOptInfo *rel,
     406             :              Index rti, RangeTblEntry *rte)
     407             : {
     408      983672 :     if (rel->reloptkind == RELOPT_BASEREL &&
     409      463286 :         relation_excluded_by_constraints(root, rel, rte))
     410             :     {
     411             :         /*
     412             :          * We proved we don't need to scan the rel via constraint exclusion,
     413             :          * so set up a single dummy path for it.  Here we only check this for
     414             :          * regular baserels; if it's an otherrel, CE was already checked in
     415             :          * set_append_rel_size().
     416             :          *
     417             :          * In this case, we go ahead and set up the relation's path right away
     418             :          * instead of leaving it for set_rel_pathlist to do.  This is because
     419             :          * we don't have a convention for marking a rel as dummy except by
     420             :          * assigning a dummy path to it.
     421             :          */
     422         616 :         set_dummy_rel_pathlist(rel);
     423             :     }
     424      519770 :     else if (rte->inh)
     425             :     {
     426             :         /* It's an "append relation", process accordingly */
     427       25374 :         set_append_rel_size(root, rel, rti, rte);
     428             :     }
     429             :     else
     430             :     {
     431      494396 :         switch (rel->rtekind)
     432             :         {
     433      407602 :             case RTE_RELATION:
     434      407602 :                 if (rte->relkind == RELKIND_FOREIGN_TABLE)
     435             :                 {
     436             :                     /* Foreign table */
     437        2438 :                     set_foreign_size(root, rel, rte);
     438             :                 }
     439      405164 :                 else if (rte->relkind == RELKIND_PARTITIONED_TABLE)
     440             :                 {
     441             :                     /*
     442             :                      * We could get here if asked to scan a partitioned table
     443             :                      * with ONLY.  In that case we shouldn't scan any of the
     444             :                      * partitions, so mark it as a dummy rel.
     445             :                      */
     446          40 :                     set_dummy_rel_pathlist(rel);
     447             :                 }
     448      405124 :                 else if (rte->tablesample != NULL)
     449             :                 {
     450             :                     /* Sampled relation */
     451         306 :                     set_tablesample_rel_size(root, rel, rte);
     452             :                 }
     453             :                 else
     454             :                 {
     455             :                     /* Plain relation */
     456      404818 :                     set_plain_rel_size(root, rel, rte);
     457             :                 }
     458      407568 :                 break;
     459       16760 :             case RTE_SUBQUERY:
     460             : 
     461             :                 /*
     462             :                  * Subqueries don't support making a choice between
     463             :                  * parameterized and unparameterized paths, so just go ahead
     464             :                  * and build their paths immediately.
     465             :                  */
     466       16760 :                 set_subquery_pathlist(root, rel, rti, rte);
     467       16760 :                 break;
     468       51268 :             case RTE_FUNCTION:
     469       51268 :                 set_function_size_estimates(root, rel);
     470       51268 :                 break;
     471         626 :             case RTE_TABLEFUNC:
     472         626 :                 set_tablefunc_size_estimates(root, rel);
     473         626 :                 break;
     474        8264 :             case RTE_VALUES:
     475        8264 :                 set_values_size_estimates(root, rel);
     476        8264 :                 break;
     477        5190 :             case RTE_CTE:
     478             : 
     479             :                 /*
     480             :                  * CTEs don't support making a choice between parameterized
     481             :                  * and unparameterized paths, so just go ahead and build their
     482             :                  * paths immediately.
     483             :                  */
     484        5190 :                 if (rte->self_reference)
     485         932 :                     set_worktable_pathlist(root, rel, rte);
     486             :                 else
     487        4258 :                     set_cte_pathlist(root, rel, rte);
     488        5190 :                 break;
     489         478 :             case RTE_NAMEDTUPLESTORE:
     490             :                 /* Might as well just build the path immediately */
     491         478 :                 set_namedtuplestore_pathlist(root, rel, rte);
     492         478 :                 break;
     493        4208 :             case RTE_RESULT:
     494             :                 /* Might as well just build the path immediately */
     495        4208 :                 set_result_pathlist(root, rel, rte);
     496        4208 :                 break;
     497           0 :             default:
     498           0 :                 elog(ERROR, "unexpected rtekind: %d", (int) rel->rtekind);
     499             :                 break;
     500             :         }
     501             :     }
     502             : 
     503             :     /*
     504             :      * We insist that all non-dummy rels have a nonzero rowcount estimate.
     505             :      */
     506             :     Assert(rel->rows > 0 || IS_DUMMY_REL(rel));
     507      520350 : }
     508             : 
     509             : /*
     510             :  * set_rel_pathlist
     511             :  *    Build access paths for a base relation
     512             :  */
     513             : static void
     514      520488 : set_rel_pathlist(PlannerInfo *root, RelOptInfo *rel,
     515             :                  Index rti, RangeTblEntry *rte)
     516             : {
     517      520488 :     if (IS_DUMMY_REL(rel))
     518             :     {
     519             :         /* We already proved the relation empty, so nothing more to do */
     520             :     }
     521      519274 :     else if (rte->inh)
     522             :     {
     523             :         /* It's an "append relation", process accordingly */
     524       25078 :         set_append_rel_pathlist(root, rel, rti, rte);
     525             :     }
     526             :     else
     527             :     {
     528      494196 :         switch (rel->rtekind)
     529             :         {
     530      407528 :             case RTE_RELATION:
     531      407528 :                 if (rte->relkind == RELKIND_FOREIGN_TABLE)
     532             :                 {
     533             :                     /* Foreign table */
     534        2434 :                     set_foreign_pathlist(root, rel, rte);
     535             :                 }
     536      405094 :                 else if (rte->tablesample != NULL)
     537             :                 {
     538             :                     /* Sampled relation */
     539         306 :                     set_tablesample_rel_pathlist(root, rel, rte);
     540             :                 }
     541             :                 else
     542             :                 {
     543             :                     /* Plain relation */
     544      404788 :                     set_plain_rel_pathlist(root, rel, rte);
     545             :                 }
     546      407528 :                 break;
     547       16634 :             case RTE_SUBQUERY:
     548             :                 /* Subquery --- fully handled during set_rel_size */
     549       16634 :                 break;
     550       51268 :             case RTE_FUNCTION:
     551             :                 /* RangeFunction */
     552       51268 :                 set_function_pathlist(root, rel, rte);
     553       51268 :                 break;
     554         626 :             case RTE_TABLEFUNC:
     555             :                 /* Table Function */
     556         626 :                 set_tablefunc_pathlist(root, rel, rte);
     557         626 :                 break;
     558        8264 :             case RTE_VALUES:
     559             :                 /* Values list */
     560        8264 :                 set_values_pathlist(root, rel, rte);
     561        8264 :                 break;
     562        5190 :             case RTE_CTE:
     563             :                 /* CTE reference --- fully handled during set_rel_size */
     564        5190 :                 break;
     565         478 :             case RTE_NAMEDTUPLESTORE:
     566             :                 /* tuplestore reference --- fully handled during set_rel_size */
     567         478 :                 break;
     568        4208 :             case RTE_RESULT:
     569             :                 /* simple Result --- fully handled during set_rel_size */
     570        4208 :                 break;
     571           0 :             default:
     572           0 :                 elog(ERROR, "unexpected rtekind: %d", (int) rel->rtekind);
     573             :                 break;
     574             :         }
     575             :     }
     576             : 
     577             :     /*
     578             :      * Allow a plugin to editorialize on the set of Paths for this base
     579             :      * relation.  It could add new paths (such as CustomPaths) by calling
     580             :      * add_path(), or add_partial_path() if parallel aware.  It could also
     581             :      * delete or modify paths added by the core code.
     582             :      */
     583      520488 :     if (set_rel_pathlist_hook)
     584           0 :         (*set_rel_pathlist_hook) (root, rel, rti, rte);
     585             : 
     586             :     /*
     587             :      * If this is a baserel, we should normally consider gathering any partial
     588             :      * paths we may have created for it.  We have to do this after calling the
     589             :      * set_rel_pathlist_hook, else it cannot add partial paths to be included
     590             :      * here.
     591             :      *
     592             :      * However, if this is an inheritance child, skip it.  Otherwise, we could
     593             :      * end up with a very large number of gather nodes, each trying to grab
     594             :      * its own pool of workers.  Instead, we'll consider gathering partial
     595             :      * paths for the parent appendrel.
     596             :      *
     597             :      * Also, if this is the topmost scan/join rel, we postpone gathering until
     598             :      * the final scan/join targetlist is available (see grouping_planner).
     599             :      */
     600      520488 :     if (rel->reloptkind == RELOPT_BASEREL &&
     601      463252 :         !bms_equal(rel->relids, root->all_query_rels))
     602      238398 :         generate_useful_gather_paths(root, rel, false);
     603             : 
     604             :     /* Now find the cheapest of the paths for this rel */
     605      520488 :     set_cheapest(rel);
     606             : 
     607             :     /*
     608             :      * If a grouped relation for this rel exists, build partial aggregation
     609             :      * paths for it.
     610             :      *
     611             :      * Note that this can only happen after we've called set_cheapest() for
     612             :      * this base rel, because we need its cheapest paths.
     613             :      */
     614      520488 :     set_grouped_rel_pathlist(root, rel);
     615             : 
     616             : #ifdef OPTIMIZER_DEBUG
     617             :     pprint(rel);
     618             : #endif
     619      520488 : }
     620             : 
     621             : /*
     622             :  * set_plain_rel_size
     623             :  *    Set size estimates for a plain relation (no subquery, no inheritance)
     624             :  */
     625             : static void
     626      404818 : set_plain_rel_size(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
     627             : {
     628             :     /*
     629             :      * Test any partial indexes of rel for applicability.  We must do this
     630             :      * first since partial unique indexes can affect size estimates.
     631             :      */
     632      404818 :     check_index_predicates(root, rel);
     633             : 
     634             :     /* Mark rel with estimated output rows, width, etc */
     635      404818 :     set_baserel_size_estimates(root, rel);
     636      404788 : }
     637             : 
     638             : /*
     639             :  * If this relation could possibly be scanned from within a worker, then set
     640             :  * its consider_parallel flag.
     641             :  */
     642             : static void
     643      412206 : set_rel_consider_parallel(PlannerInfo *root, RelOptInfo *rel,
     644             :                           RangeTblEntry *rte)
     645             : {
     646             :     /*
     647             :      * The flag has previously been initialized to false, so we can just
     648             :      * return if it becomes clear that we can't safely set it.
     649             :      */
     650             :     Assert(!rel->consider_parallel);
     651             : 
     652             :     /* Don't call this if parallelism is disallowed for the entire query. */
     653             :     Assert(root->glob->parallelModeOK);
     654             : 
     655             :     /* This should only be called for baserels and appendrel children. */
     656             :     Assert(IS_SIMPLE_REL(rel));
     657             : 
     658             :     /* Assorted checks based on rtekind. */
     659      412206 :     switch (rte->rtekind)
     660             :     {
     661      354658 :         case RTE_RELATION:
     662             : 
     663             :             /*
     664             :              * Currently, parallel workers can't access the leader's temporary
     665             :              * tables.  We could possibly relax this if we wrote all of its
     666             :              * local buffers at the start of the query and made no changes
     667             :              * thereafter (maybe we could allow hint bit changes), and if we
     668             :              * taught the workers to read them.  Writing a large number of
     669             :              * temporary buffers could be expensive, though, and we don't have
     670             :              * the rest of the necessary infrastructure right now anyway.  So
     671             :              * for now, bail out if we see a temporary table.
     672             :              */
     673      354658 :             if (get_rel_persistence(rte->relid) == RELPERSISTENCE_TEMP)
     674        8468 :                 return;
     675             : 
     676             :             /*
     677             :              * Table sampling can be pushed down to workers if the sample
     678             :              * function and its arguments are safe.
     679             :              */
     680      346190 :             if (rte->tablesample != NULL)
     681             :             {
     682         330 :                 char        proparallel = func_parallel(rte->tablesample->tsmhandler);
     683             : 
     684         330 :                 if (proparallel != PROPARALLEL_SAFE)
     685          36 :                     return;
     686         294 :                 if (!is_parallel_safe(root, (Node *) rte->tablesample->args))
     687          12 :                     return;
     688             :             }
     689             : 
     690             :             /*
     691             :              * Ask FDWs whether they can support performing a ForeignScan
     692             :              * within a worker.  Most often, the answer will be no.  For
     693             :              * example, if the nature of the FDW is such that it opens a TCP
     694             :              * connection with a remote server, each parallel worker would end
     695             :              * up with a separate connection, and these connections might not
     696             :              * be appropriately coordinated between workers and the leader.
     697             :              */
     698      346142 :             if (rte->relkind == RELKIND_FOREIGN_TABLE)
     699             :             {
     700             :                 Assert(rel->fdwroutine);
     701        1552 :                 if (!rel->fdwroutine->IsForeignScanParallelSafe)
     702        1480 :                     return;
     703          72 :                 if (!rel->fdwroutine->IsForeignScanParallelSafe(root, rel, rte))
     704           0 :                     return;
     705             :             }
     706             : 
     707             :             /*
     708             :              * There are additional considerations for appendrels, which we'll
     709             :              * deal with in set_append_rel_size and set_append_rel_pathlist.
     710             :              * For now, just set consider_parallel based on the rel's own
     711             :              * quals and targetlist.
     712             :              */
     713      344662 :             break;
     714             : 
     715       18216 :         case RTE_SUBQUERY:
     716             : 
     717             :             /*
     718             :              * There's no intrinsic problem with scanning a subquery-in-FROM
     719             :              * (as distinct from a SubPlan or InitPlan) in a parallel worker.
     720             :              * If the subquery doesn't happen to have any parallel-safe paths,
     721             :              * then flagging it as consider_parallel won't change anything,
     722             :              * but that's true for plain tables, too.  We must set
     723             :              * consider_parallel based on the rel's own quals and targetlist,
     724             :              * so that if a subquery path is parallel-safe but the quals and
     725             :              * projection we're sticking onto it are not, we correctly mark
     726             :              * the SubqueryScanPath as not parallel-safe.  (Note that
     727             :              * set_subquery_pathlist() might push some of these quals down
     728             :              * into the subquery itself, but that doesn't change anything.)
     729             :              *
     730             :              * We can't push sub-select containing LIMIT/OFFSET to workers as
     731             :              * there is no guarantee that the row order will be fully
     732             :              * deterministic, and applying LIMIT/OFFSET will lead to
     733             :              * inconsistent results at the top-level.  (In some cases, where
     734             :              * the result is ordered, we could relax this restriction.  But it
     735             :              * doesn't currently seem worth expending extra effort to do so.)
     736             :              */
     737             :             {
     738       18216 :                 Query      *subquery = castNode(Query, rte->subquery);
     739             : 
     740       18216 :                 if (limit_needed(subquery))
     741         508 :                     return;
     742             :             }
     743       17708 :             break;
     744             : 
     745           0 :         case RTE_JOIN:
     746             :             /* Shouldn't happen; we're only considering baserels here. */
     747             :             Assert(false);
     748           0 :             return;
     749             : 
     750       27416 :         case RTE_FUNCTION:
     751             :             /* Check for parallel-restricted functions. */
     752       27416 :             if (!is_parallel_safe(root, (Node *) rte->functions))
     753       13034 :                 return;
     754       14382 :             break;
     755             : 
     756         626 :         case RTE_TABLEFUNC:
     757             :             /* not parallel safe */
     758         626 :             return;
     759             : 
     760        2834 :         case RTE_VALUES:
     761             :             /* Check for parallel-restricted functions. */
     762        2834 :             if (!is_parallel_safe(root, (Node *) rte->values_lists))
     763          12 :                 return;
     764        2822 :             break;
     765             : 
     766        4228 :         case RTE_CTE:
     767             : 
     768             :             /*
     769             :              * CTE tuplestores aren't shared among parallel workers, so we
     770             :              * force all CTE scans to happen in the leader.  Also, populating
     771             :              * the CTE would require executing a subplan that's not available
     772             :              * in the worker, might be parallel-restricted, and must get
     773             :              * executed only once.
     774             :              */
     775        4228 :             return;
     776             : 
     777         450 :         case RTE_NAMEDTUPLESTORE:
     778             : 
     779             :             /*
     780             :              * tuplestore cannot be shared, at least without more
     781             :              * infrastructure to support that.
     782             :              */
     783         450 :             return;
     784             : 
     785        3778 :         case RTE_RESULT:
     786             :             /* RESULT RTEs, in themselves, are no problem. */
     787        3778 :             break;
     788           0 :         case RTE_GROUP:
     789             :             /* Shouldn't happen; we're only considering baserels here. */
     790             :             Assert(false);
     791           0 :             return;
     792             :     }
     793             : 
     794             :     /*
     795             :      * If there's anything in baserestrictinfo that's parallel-restricted, we
     796             :      * give up on parallelizing access to this relation.  We could consider
     797             :      * instead postponing application of the restricted quals until we're
     798             :      * above all the parallelism in the plan tree, but it's not clear that
     799             :      * that would be a win in very many cases, and it might be tricky to make
     800             :      * outer join clauses work correctly.  It would likely break equivalence
     801             :      * classes, too.
     802             :      */
     803      383352 :     if (!is_parallel_safe(root, (Node *) rel->baserestrictinfo))
     804       27274 :         return;
     805             : 
     806             :     /*
     807             :      * Likewise, if the relation's outputs are not parallel-safe, give up.
     808             :      * (Usually, they're just Vars, but sometimes they're not.)
     809             :      */
     810      356078 :     if (!is_parallel_safe(root, (Node *) rel->reltarget->exprs))
     811          18 :         return;
     812             : 
     813             :     /* We have a winner. */
     814      356060 :     rel->consider_parallel = true;
     815             : }
     816             : 
     817             : /*
     818             :  * set_plain_rel_pathlist
     819             :  *    Build access paths for a plain relation (no subquery, no inheritance)
     820             :  */
     821             : static void
     822      404788 : set_plain_rel_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
     823             : {
     824             :     Relids      required_outer;
     825             : 
     826             :     /*
     827             :      * We don't support pushing join clauses into the quals of a seqscan, but
     828             :      * it could still have required parameterization due to LATERAL refs in
     829             :      * its tlist.
     830             :      */
     831      404788 :     required_outer = rel->lateral_relids;
     832             : 
     833             :     /*
     834             :      * Consider TID scans.
     835             :      *
     836             :      * If create_tidscan_paths returns true, then a TID scan path is forced.
     837             :      * This happens when rel->baserestrictinfo contains CurrentOfExpr, because
     838             :      * the executor can't handle any other type of path for such queries.
     839             :      * Hence, we return without adding any other paths.
     840             :      */
     841      404788 :     if (create_tidscan_paths(root, rel))
     842         404 :         return;
     843             : 
     844             :     /* Consider sequential scan */
     845      404384 :     add_path(rel, create_seqscan_path(root, rel, required_outer, 0));
     846             : 
     847             :     /* If appropriate, consider parallel sequential scan */
     848      404384 :     if (rel->consider_parallel && required_outer == NULL)
     849      303706 :         create_plain_partial_paths(root, rel);
     850             : 
     851             :     /* Consider index scans */
     852      404384 :     create_index_paths(root, rel);
     853             : }
     854             : 
     855             : /*
     856             :  * create_plain_partial_paths
     857             :  *    Build partial access paths for parallel scan of a plain relation
     858             :  */
     859             : static void
     860      303706 : create_plain_partial_paths(PlannerInfo *root, RelOptInfo *rel)
     861             : {
     862             :     int         parallel_workers;
     863             : 
     864      303706 :     parallel_workers = compute_parallel_worker(rel, rel->pages, -1,
     865             :                                                max_parallel_workers_per_gather);
     866             : 
     867             :     /* If any limit was set to zero, the user doesn't want a parallel scan. */
     868      303706 :     if (parallel_workers <= 0)
     869      276318 :         return;
     870             : 
     871             :     /* Add an unordered partial path based on a parallel sequential scan. */
     872       27388 :     add_partial_path(rel, create_seqscan_path(root, rel, NULL, parallel_workers));
     873             : }
     874             : 
     875             : /*
     876             :  * set_tablesample_rel_size
     877             :  *    Set size estimates for a sampled relation
     878             :  */
     879             : static void
     880         306 : set_tablesample_rel_size(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
     881             : {
     882         306 :     TableSampleClause *tsc = rte->tablesample;
     883             :     TsmRoutine *tsm;
     884             :     BlockNumber pages;
     885             :     double      tuples;
     886             : 
     887             :     /*
     888             :      * Test any partial indexes of rel for applicability.  We must do this
     889             :      * first since partial unique indexes can affect size estimates.
     890             :      */
     891         306 :     check_index_predicates(root, rel);
     892             : 
     893             :     /*
     894             :      * Call the sampling method's estimation function to estimate the number
     895             :      * of pages it will read and the number of tuples it will return.  (Note:
     896             :      * we assume the function returns sane values.)
     897             :      */
     898         306 :     tsm = GetTsmRoutine(tsc->tsmhandler);
     899         306 :     tsm->SampleScanGetSampleSize(root, rel, tsc->args,
     900             :                                  &pages, &tuples);
     901             : 
     902             :     /*
     903             :      * For the moment, because we will only consider a SampleScan path for the
     904             :      * rel, it's okay to just overwrite the pages and tuples estimates for the
     905             :      * whole relation.  If we ever consider multiple path types for sampled
     906             :      * rels, we'll need more complication.
     907             :      */
     908         306 :     rel->pages = pages;
     909         306 :     rel->tuples = tuples;
     910             : 
     911             :     /* Mark rel with estimated output rows, width, etc */
     912         306 :     set_baserel_size_estimates(root, rel);
     913         306 : }
     914             : 
     915             : /*
     916             :  * set_tablesample_rel_pathlist
     917             :  *    Build access paths for a sampled relation
     918             :  */
     919             : static void
     920         306 : set_tablesample_rel_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
     921             : {
     922             :     Relids      required_outer;
     923             :     Path       *path;
     924             : 
     925             :     /*
     926             :      * We don't support pushing join clauses into the quals of a samplescan,
     927             :      * but it could still have required parameterization due to LATERAL refs
     928             :      * in its tlist or TABLESAMPLE arguments.
     929             :      */
     930         306 :     required_outer = rel->lateral_relids;
     931             : 
     932             :     /* Consider sampled scan */
     933         306 :     path = create_samplescan_path(root, rel, required_outer);
     934             : 
     935             :     /*
     936             :      * If the sampling method does not support repeatable scans, we must avoid
     937             :      * plans that would scan the rel multiple times.  Ideally, we'd simply
     938             :      * avoid putting the rel on the inside of a nestloop join; but adding such
     939             :      * a consideration to the planner seems like a great deal of complication
     940             :      * to support an uncommon usage of second-rate sampling methods.  Instead,
     941             :      * if there is a risk that the query might perform an unsafe join, just
     942             :      * wrap the SampleScan in a Materialize node.  We can check for joins by
     943             :      * counting the membership of all_query_rels (note that this correctly
     944             :      * counts inheritance trees as single rels).  If we're inside a subquery,
     945             :      * we can't easily check whether a join might occur in the outer query, so
     946             :      * just assume one is possible.
     947             :      *
     948             :      * GetTsmRoutine is relatively expensive compared to the other tests here,
     949             :      * so check repeatable_across_scans last, even though that's a bit odd.
     950             :      */
     951         586 :     if ((root->query_level > 1 ||
     952         280 :          bms_membership(root->all_query_rels) != BMS_SINGLETON) &&
     953          98 :         !(GetTsmRoutine(rte->tablesample->tsmhandler)->repeatable_across_scans))
     954             :     {
     955           8 :         path = (Path *) create_material_path(rel, path);
     956             :     }
     957             : 
     958         306 :     add_path(rel, path);
     959             : 
     960             :     /* For the moment, at least, there are no other paths to consider */
     961         306 : }
     962             : 
     963             : /*
     964             :  * set_foreign_size
     965             :  *      Set size estimates for a foreign table RTE
     966             :  */
     967             : static void
     968        2438 : set_foreign_size(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
     969             : {
     970             :     /* Mark rel with estimated output rows, width, etc */
     971        2438 :     set_foreign_size_estimates(root, rel);
     972             : 
     973             :     /* Let FDW adjust the size estimates, if it can */
     974        2438 :     rel->fdwroutine->GetForeignRelSize(root, rel, rte->relid);
     975             : 
     976             :     /* ... but do not let it set the rows estimate to zero */
     977        2434 :     rel->rows = clamp_row_est(rel->rows);
     978             : 
     979             :     /*
     980             :      * Also, make sure rel->tuples is not insane relative to rel->rows.
     981             :      * Notably, this ensures sanity if pg_class.reltuples contains -1 and the
     982             :      * FDW doesn't do anything to replace that.
     983             :      */
     984        2434 :     rel->tuples = Max(rel->tuples, rel->rows);
     985        2434 : }
     986             : 
     987             : /*
     988             :  * set_foreign_pathlist
     989             :  *      Build access paths for a foreign table RTE
     990             :  */
     991             : static void
     992        2434 : set_foreign_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
     993             : {
     994             :     /* Call the FDW's GetForeignPaths function to generate path(s) */
     995        2434 :     rel->fdwroutine->GetForeignPaths(root, rel, rte->relid);
     996        2434 : }
     997             : 
     998             : /*
     999             :  * set_append_rel_size
    1000             :  *    Set size estimates for a simple "append relation"
    1001             :  *
    1002             :  * The passed-in rel and RTE represent the entire append relation.  The
    1003             :  * relation's contents are computed by appending together the output of the
    1004             :  * individual member relations.  Note that in the non-partitioned inheritance
    1005             :  * case, the first member relation is actually the same table as is mentioned
    1006             :  * in the parent RTE ... but it has a different RTE and RelOptInfo.  This is
    1007             :  * a good thing because their outputs are not the same size.
    1008             :  */
    1009             : static void
    1010       25374 : set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
    1011             :                     Index rti, RangeTblEntry *rte)
    1012             : {
    1013       25374 :     int         parentRTindex = rti;
    1014             :     bool        has_live_children;
    1015             :     double      parent_tuples;
    1016             :     double      parent_rows;
    1017             :     double      parent_size;
    1018             :     double     *parent_attrsizes;
    1019             :     int         nattrs;
    1020             :     ListCell   *l;
    1021             : 
    1022             :     /* Guard against stack overflow due to overly deep inheritance tree. */
    1023       25374 :     check_stack_depth();
    1024             : 
    1025             :     Assert(IS_SIMPLE_REL(rel));
    1026             : 
    1027             :     /*
    1028             :      * If this is a partitioned baserel, set the consider_partitionwise_join
    1029             :      * flag; currently, we only consider partitionwise joins with the baserel
    1030             :      * if its targetlist doesn't contain a whole-row Var.
    1031             :      */
    1032       25374 :     if (enable_partitionwise_join &&
    1033        4982 :         rel->reloptkind == RELOPT_BASEREL &&
    1034        3962 :         rte->relkind == RELKIND_PARTITIONED_TABLE &&
    1035        3962 :         bms_is_empty(rel->attr_needed[InvalidAttrNumber - rel->min_attr]))
    1036        3886 :         rel->consider_partitionwise_join = true;
    1037             : 
    1038             :     /*
    1039             :      * Initialize to compute size estimates for whole append relation.
    1040             :      *
    1041             :      * We handle tuples estimates by setting "tuples" to the total number of
    1042             :      * tuples accumulated from each live child, rather than using "rows".
    1043             :      * Although an appendrel itself doesn't directly enforce any quals, its
    1044             :      * child relations may.  Therefore, setting "tuples" equal to "rows" for
    1045             :      * an appendrel isn't always appropriate, and can lead to inaccurate cost
    1046             :      * estimates.  For example, when estimating the number of distinct values
    1047             :      * from an appendrel, we would be unable to adjust the estimate based on
    1048             :      * the restriction selectivity (see estimate_num_groups).
    1049             :      *
    1050             :      * We handle width estimates by weighting the widths of different child
    1051             :      * rels proportionally to their number of rows.  This is sensible because
    1052             :      * the use of width estimates is mainly to compute the total relation
    1053             :      * "footprint" if we have to sort or hash it.  To do this, we sum the
    1054             :      * total equivalent size (in "double" arithmetic) and then divide by the
    1055             :      * total rowcount estimate.  This is done separately for the total rel
    1056             :      * width and each attribute.
    1057             :      *
    1058             :      * Note: if you consider changing this logic, beware that child rels could
    1059             :      * have zero rows and/or width, if they were excluded by constraints.
    1060             :      */
    1061       25374 :     has_live_children = false;
    1062       25374 :     parent_tuples = 0;
    1063       25374 :     parent_rows = 0;
    1064       25374 :     parent_size = 0;
    1065       25374 :     nattrs = rel->max_attr - rel->min_attr + 1;
    1066       25374 :     parent_attrsizes = (double *) palloc0(nattrs * sizeof(double));
    1067             : 
    1068      134196 :     foreach(l, root->append_rel_list)
    1069             :     {
    1070      108824 :         AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(l);
    1071             :         int         childRTindex;
    1072             :         RangeTblEntry *childRTE;
    1073             :         RelOptInfo *childrel;
    1074             :         List       *childrinfos;
    1075             :         ListCell   *parentvars;
    1076             :         ListCell   *childvars;
    1077             :         ListCell   *lc;
    1078             : 
    1079             :         /* append_rel_list contains all append rels; ignore others */
    1080      108824 :         if (appinfo->parent_relid != parentRTindex)
    1081       51862 :             continue;
    1082             : 
    1083       57304 :         childRTindex = appinfo->child_relid;
    1084       57304 :         childRTE = root->simple_rte_array[childRTindex];
    1085             : 
    1086             :         /*
    1087             :          * The child rel's RelOptInfo was already created during
    1088             :          * add_other_rels_to_query.
    1089             :          */
    1090       57304 :         childrel = find_base_rel(root, childRTindex);
    1091             :         Assert(childrel->reloptkind == RELOPT_OTHER_MEMBER_REL);
    1092             : 
    1093             :         /* We may have already proven the child to be dummy. */
    1094       57304 :         if (IS_DUMMY_REL(childrel))
    1095          18 :             continue;
    1096             : 
    1097             :         /*
    1098             :          * We have to copy the parent's targetlist and quals to the child,
    1099             :          * with appropriate substitution of variables.  However, the
    1100             :          * baserestrictinfo quals were already copied/substituted when the
    1101             :          * child RelOptInfo was built.  So we don't need any additional setup
    1102             :          * before applying constraint exclusion.
    1103             :          */
    1104       57286 :         if (relation_excluded_by_constraints(root, childrel, childRTE))
    1105             :         {
    1106             :             /*
    1107             :              * This child need not be scanned, so we can omit it from the
    1108             :              * appendrel.
    1109             :              */
    1110         186 :             set_dummy_rel_pathlist(childrel);
    1111         186 :             continue;
    1112             :         }
    1113             : 
    1114             :         /*
    1115             :          * Constraint exclusion failed, so copy the parent's join quals and
    1116             :          * targetlist to the child, with appropriate variable substitutions.
    1117             :          *
    1118             :          * We skip join quals that came from above outer joins that can null
    1119             :          * this rel, since they would be of no value while generating paths
    1120             :          * for the child.  This saves some effort while processing the child
    1121             :          * rel, and it also avoids an implementation restriction in
    1122             :          * adjust_appendrel_attrs (it can't apply nullingrels to a non-Var).
    1123             :          */
    1124       57100 :         childrinfos = NIL;
    1125       70162 :         foreach(lc, rel->joininfo)
    1126             :         {
    1127       13062 :             RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
    1128             : 
    1129       13062 :             if (!bms_overlap(rinfo->clause_relids, rel->nulling_relids))
    1130       10740 :                 childrinfos = lappend(childrinfos,
    1131       10740 :                                       adjust_appendrel_attrs(root,
    1132             :                                                              (Node *) rinfo,
    1133             :                                                              1, &appinfo));
    1134             :         }
    1135       57100 :         childrel->joininfo = childrinfos;
    1136             : 
    1137             :         /*
    1138             :          * Now for the child's targetlist.
    1139             :          *
    1140             :          * NB: the resulting childrel->reltarget->exprs may contain arbitrary
    1141             :          * expressions, which otherwise would not occur in a rel's targetlist.
    1142             :          * Code that might be looking at an appendrel child must cope with
    1143             :          * such.  (Normally, a rel's targetlist would only include Vars and
    1144             :          * PlaceHolderVars.)  XXX we do not bother to update the cost or width
    1145             :          * fields of childrel->reltarget; not clear if that would be useful.
    1146             :          */
    1147      114200 :         childrel->reltarget->exprs = (List *)
    1148       57100 :             adjust_appendrel_attrs(root,
    1149       57100 :                                    (Node *) rel->reltarget->exprs,
    1150             :                                    1, &appinfo);
    1151             : 
    1152             :         /*
    1153             :          * We have to make child entries in the EquivalenceClass data
    1154             :          * structures as well.  This is needed either if the parent
    1155             :          * participates in some eclass joins (because we will want to consider
    1156             :          * inner-indexscan joins on the individual children) or if the parent
    1157             :          * has useful pathkeys (because we should try to build MergeAppend
    1158             :          * paths that produce those sort orderings).
    1159             :          */
    1160       57100 :         if (rel->has_eclass_joins || has_useful_pathkeys(root, rel))
    1161       35326 :             add_child_rel_equivalences(root, appinfo, rel, childrel);
    1162       57100 :         childrel->has_eclass_joins = rel->has_eclass_joins;
    1163             : 
    1164             :         /*
    1165             :          * Note: we could compute appropriate attr_needed data for the child's
    1166             :          * variables, by transforming the parent's attr_needed through the
    1167             :          * translated_vars mapping.  However, currently there's no need
    1168             :          * because attr_needed is only examined for base relations not
    1169             :          * otherrels.  So we just leave the child's attr_needed empty.
    1170             :          */
    1171             : 
    1172             :         /*
    1173             :          * If we consider partitionwise joins with the parent rel, do the same
    1174             :          * for partitioned child rels.
    1175             :          *
    1176             :          * Note: here we abuse the consider_partitionwise_join flag by setting
    1177             :          * it for child rels that are not themselves partitioned.  We do so to
    1178             :          * tell try_partitionwise_join() that the child rel is sufficiently
    1179             :          * valid to be used as a per-partition input, even if it later gets
    1180             :          * proven to be dummy.  (It's not usable until we've set up the
    1181             :          * reltarget and EC entries, which we just did.)
    1182             :          */
    1183       57100 :         if (rel->consider_partitionwise_join)
    1184       13148 :             childrel->consider_partitionwise_join = true;
    1185             : 
    1186             :         /*
    1187             :          * If parallelism is allowable for this query in general, see whether
    1188             :          * it's allowable for this childrel in particular.  But if we've
    1189             :          * already decided the appendrel is not parallel-safe as a whole,
    1190             :          * there's no point in considering parallelism for this child.  For
    1191             :          * consistency, do this before calling set_rel_size() for the child.
    1192             :          */
    1193       57100 :         if (root->glob->parallelModeOK && rel->consider_parallel)
    1194       42558 :             set_rel_consider_parallel(root, childrel, childRTE);
    1195             : 
    1196             :         /*
    1197             :          * Compute the child's size.
    1198             :          */
    1199       57100 :         set_rel_size(root, childrel, childRTindex, childRTE);
    1200             : 
    1201             :         /*
    1202             :          * It is possible that constraint exclusion detected a contradiction
    1203             :          * within a child subquery, even though we didn't prove one above. If
    1204             :          * so, we can skip this child.
    1205             :          */
    1206       57098 :         if (IS_DUMMY_REL(childrel))
    1207         138 :             continue;
    1208             : 
    1209             :         /* We have at least one live child. */
    1210       56960 :         has_live_children = true;
    1211             : 
    1212             :         /*
    1213             :          * If any live child is not parallel-safe, treat the whole appendrel
    1214             :          * as not parallel-safe.  In future we might be able to generate plans
    1215             :          * in which some children are farmed out to workers while others are
    1216             :          * not; but we don't have that today, so it's a waste to consider
    1217             :          * partial paths anywhere in the appendrel unless it's all safe.
    1218             :          * (Child rels visited before this one will be unmarked in
    1219             :          * set_append_rel_pathlist().)
    1220             :          */
    1221       56960 :         if (!childrel->consider_parallel)
    1222       15234 :             rel->consider_parallel = false;
    1223             : 
    1224             :         /*
    1225             :          * Accumulate size information from each live child.
    1226             :          */
    1227             :         Assert(childrel->rows > 0);
    1228             : 
    1229       56960 :         parent_tuples += childrel->tuples;
    1230       56960 :         parent_rows += childrel->rows;
    1231       56960 :         parent_size += childrel->reltarget->width * childrel->rows;
    1232             : 
    1233             :         /*
    1234             :          * Accumulate per-column estimates too.  We need not do anything for
    1235             :          * PlaceHolderVars in the parent list.  If child expression isn't a
    1236             :          * Var, or we didn't record a width estimate for it, we have to fall
    1237             :          * back on a datatype-based estimate.
    1238             :          *
    1239             :          * By construction, child's targetlist is 1-to-1 with parent's.
    1240             :          */
    1241      185960 :         forboth(parentvars, rel->reltarget->exprs,
    1242             :                 childvars, childrel->reltarget->exprs)
    1243             :         {
    1244      129000 :             Var        *parentvar = (Var *) lfirst(parentvars);
    1245      129000 :             Node       *childvar = (Node *) lfirst(childvars);
    1246             : 
    1247      129000 :             if (IsA(parentvar, Var) && parentvar->varno == parentRTindex)
    1248             :             {
    1249      116112 :                 int         pndx = parentvar->varattno - rel->min_attr;
    1250      116112 :                 int32       child_width = 0;
    1251             : 
    1252      116112 :                 if (IsA(childvar, Var) &&
    1253      111320 :                     ((Var *) childvar)->varno == childrel->relid)
    1254             :                 {
    1255      111254 :                     int         cndx = ((Var *) childvar)->varattno - childrel->min_attr;
    1256             : 
    1257      111254 :                     child_width = childrel->attr_widths[cndx];
    1258             :                 }
    1259      116112 :                 if (child_width <= 0)
    1260        4858 :                     child_width = get_typavgwidth(exprType(childvar),
    1261             :                                                   exprTypmod(childvar));
    1262             :                 Assert(child_width > 0);
    1263      116112 :                 parent_attrsizes[pndx] += child_width * childrel->rows;
    1264             :             }
    1265             :         }
    1266             :     }
    1267             : 
    1268       25372 :     if (has_live_children)
    1269             :     {
    1270             :         /*
    1271             :          * Save the finished size estimates.
    1272             :          */
    1273             :         int         i;
    1274             : 
    1275             :         Assert(parent_rows > 0);
    1276       25078 :         rel->tuples = parent_tuples;
    1277       25078 :         rel->rows = parent_rows;
    1278       25078 :         rel->reltarget->width = rint(parent_size / parent_rows);
    1279      234358 :         for (i = 0; i < nattrs; i++)
    1280      209280 :             rel->attr_widths[i] = rint(parent_attrsizes[i] / parent_rows);
    1281             : 
    1282             :         /*
    1283             :          * Note that we leave rel->pages as zero; this is important to avoid
    1284             :          * double-counting the appendrel tree in total_table_pages.
    1285             :          */
    1286             :     }
    1287             :     else
    1288             :     {
    1289             :         /*
    1290             :          * All children were excluded by constraints, so mark the whole
    1291             :          * appendrel dummy.  We must do this in this phase so that the rel's
    1292             :          * dummy-ness is visible when we generate paths for other rels.
    1293             :          */
    1294         294 :         set_dummy_rel_pathlist(rel);
    1295             :     }
    1296             : 
    1297       25372 :     pfree(parent_attrsizes);
    1298       25372 : }
    1299             : 
    1300             : /*
    1301             :  * set_append_rel_pathlist
    1302             :  *    Build access paths for an "append relation"
    1303             :  */
    1304             : static void
    1305       25078 : set_append_rel_pathlist(PlannerInfo *root, RelOptInfo *rel,
    1306             :                         Index rti, RangeTblEntry *rte)
    1307             : {
    1308       25078 :     int         parentRTindex = rti;
    1309       25078 :     List       *live_childrels = NIL;
    1310             :     ListCell   *l;
    1311             : 
    1312             :     /*
    1313             :      * Generate access paths for each member relation, and remember the
    1314             :      * non-dummy children.
    1315             :      */
    1316      133486 :     foreach(l, root->append_rel_list)
    1317             :     {
    1318      108408 :         AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(l);
    1319             :         int         childRTindex;
    1320             :         RangeTblEntry *childRTE;
    1321             :         RelOptInfo *childrel;
    1322             : 
    1323             :         /* append_rel_list contains all append rels; ignore others */
    1324      108408 :         if (appinfo->parent_relid != parentRTindex)
    1325       51172 :             continue;
    1326             : 
    1327             :         /* Re-locate the child RTE and RelOptInfo */
    1328       57236 :         childRTindex = appinfo->child_relid;
    1329       57236 :         childRTE = root->simple_rte_array[childRTindex];
    1330       57236 :         childrel = root->simple_rel_array[childRTindex];
    1331             : 
    1332             :         /*
    1333             :          * If set_append_rel_size() decided the parent appendrel was
    1334             :          * parallel-unsafe at some point after visiting this child rel, we
    1335             :          * need to propagate the unsafety marking down to the child, so that
    1336             :          * we don't generate useless partial paths for it.
    1337             :          */
    1338       57236 :         if (!rel->consider_parallel)
    1339       15430 :             childrel->consider_parallel = false;
    1340             : 
    1341             :         /*
    1342             :          * Compute the child's access paths.
    1343             :          */
    1344       57236 :         set_rel_pathlist(root, childrel, childRTindex, childRTE);
    1345             : 
    1346             :         /*
    1347             :          * If child is dummy, ignore it.
    1348             :          */
    1349       57236 :         if (IS_DUMMY_REL(childrel))
    1350         276 :             continue;
    1351             : 
    1352             :         /*
    1353             :          * Child is live, so add it to the live_childrels list for use below.
    1354             :          */
    1355       56960 :         live_childrels = lappend(live_childrels, childrel);
    1356             :     }
    1357             : 
    1358             :     /* Add paths to the append relation. */
    1359       25078 :     add_paths_to_append_rel(root, rel, live_childrels);
    1360       25078 : }
    1361             : 
    1362             : /*
    1363             :  * set_grouped_rel_pathlist
    1364             :  *    If a grouped relation for the given 'rel' exists, build partial
    1365             :  *    aggregation paths for it.
    1366             :  */
    1367             : static void
    1368      520488 : set_grouped_rel_pathlist(PlannerInfo *root, RelOptInfo *rel)
    1369             : {
    1370             :     RelOptInfo *grouped_rel;
    1371             : 
    1372             :     /*
    1373             :      * If there are no aggregate expressions or grouping expressions, eager
    1374             :      * aggregation is not possible.
    1375             :      */
    1376      520488 :     if (root->agg_clause_list == NIL ||
    1377        3332 :         root->group_expr_list == NIL)
    1378      517420 :         return;
    1379             : 
    1380             :     /* Add paths to the grouped base relation if one exists. */
    1381        3068 :     grouped_rel = rel->grouped_rel;
    1382        3068 :     if (grouped_rel)
    1383             :     {
    1384             :         Assert(IS_GROUPED_REL(grouped_rel));
    1385             : 
    1386         586 :         generate_grouped_paths(root, grouped_rel, rel);
    1387         586 :         set_cheapest(grouped_rel);
    1388             :     }
    1389             : }
    1390             : 
    1391             : 
    1392             : /*
    1393             :  * add_paths_to_append_rel
    1394             :  *      Generate paths for the given append relation given the set of non-dummy
    1395             :  *      child rels.
    1396             :  *
    1397             :  * The function collects all parameterizations and orderings supported by the
    1398             :  * non-dummy children. For every such parameterization or ordering, it creates
    1399             :  * an append path collecting one path from each non-dummy child with given
    1400             :  * parameterization or ordering. Similarly it collects partial paths from
    1401             :  * non-dummy children to create partial append paths.
    1402             :  */
    1403             : void
    1404       46178 : add_paths_to_append_rel(PlannerInfo *root, RelOptInfo *rel,
    1405             :                         List *live_childrels)
    1406             : {
    1407       46178 :     List       *subpaths = NIL;
    1408       46178 :     bool        subpaths_valid = true;
    1409       46178 :     List       *startup_subpaths = NIL;
    1410       46178 :     bool        startup_subpaths_valid = true;
    1411       46178 :     List       *partial_subpaths = NIL;
    1412       46178 :     List       *pa_partial_subpaths = NIL;
    1413       46178 :     List       *pa_nonpartial_subpaths = NIL;
    1414       46178 :     bool        partial_subpaths_valid = true;
    1415             :     bool        pa_subpaths_valid;
    1416       46178 :     List       *all_child_pathkeys = NIL;
    1417       46178 :     List       *all_child_outers = NIL;
    1418             :     ListCell   *l;
    1419       46178 :     double      partial_rows = -1;
    1420             : 
    1421             :     /* If appropriate, consider parallel append */
    1422       46178 :     pa_subpaths_valid = enable_parallel_append && rel->consider_parallel;
    1423             : 
    1424             :     /*
    1425             :      * For every non-dummy child, remember the cheapest path.  Also, identify
    1426             :      * all pathkeys (orderings) and parameterizations (required_outer sets)
    1427             :      * available for the non-dummy member relations.
    1428             :      */
    1429      147794 :     foreach(l, live_childrels)
    1430             :     {
    1431      101616 :         RelOptInfo *childrel = lfirst(l);
    1432             :         ListCell   *lcp;
    1433      101616 :         Path       *cheapest_partial_path = NULL;
    1434             : 
    1435             :         /*
    1436             :          * If child has an unparameterized cheapest-total path, add that to
    1437             :          * the unparameterized Append path we are constructing for the parent.
    1438             :          * If not, there's no workable unparameterized path.
    1439             :          *
    1440             :          * With partitionwise aggregates, the child rel's pathlist may be
    1441             :          * empty, so don't assume that a path exists here.
    1442             :          */
    1443      101616 :         if (childrel->pathlist != NIL &&
    1444      101616 :             childrel->cheapest_total_path->param_info == NULL)
    1445      100884 :             accumulate_append_subpath(childrel->cheapest_total_path,
    1446             :                                       &subpaths, NULL);
    1447             :         else
    1448         732 :             subpaths_valid = false;
    1449             : 
    1450             :         /*
    1451             :          * When the planner is considering cheap startup plans, we'll also
    1452             :          * collect all the cheapest_startup_paths (if set) and build an
    1453             :          * AppendPath containing those as subpaths.
    1454             :          */
    1455      101616 :         if (rel->consider_startup && childrel->cheapest_startup_path != NULL)
    1456        1622 :         {
    1457             :             Path       *cheapest_path;
    1458             : 
    1459             :             /*
    1460             :              * With an indication of how many tuples the query should provide,
    1461             :              * the optimizer tries to choose the path optimal for that
    1462             :              * specific number of tuples.
    1463             :              */
    1464        1622 :             if (root->tuple_fraction > 0.0)
    1465             :                 cheapest_path =
    1466        1622 :                     get_cheapest_fractional_path(childrel,
    1467             :                                                  root->tuple_fraction);
    1468             :             else
    1469           0 :                 cheapest_path = childrel->cheapest_startup_path;
    1470             : 
    1471             :             /* cheapest_startup_path must not be a parameterized path. */
    1472             :             Assert(cheapest_path->param_info == NULL);
    1473        1622 :             accumulate_append_subpath(cheapest_path,
    1474             :                                       &startup_subpaths,
    1475             :                                       NULL);
    1476             :         }
    1477             :         else
    1478       99994 :             startup_subpaths_valid = false;
    1479             : 
    1480             : 
    1481             :         /* Same idea, but for a partial plan. */
    1482      101616 :         if (childrel->partial_pathlist != NIL)
    1483             :         {
    1484       63330 :             cheapest_partial_path = linitial(childrel->partial_pathlist);
    1485       63330 :             accumulate_append_subpath(cheapest_partial_path,
    1486             :                                       &partial_subpaths, NULL);
    1487             :         }
    1488             :         else
    1489       38286 :             partial_subpaths_valid = false;
    1490             : 
    1491             :         /*
    1492             :          * Same idea, but for a parallel append mixing partial and non-partial
    1493             :          * paths.
    1494             :          */
    1495      101616 :         if (pa_subpaths_valid)
    1496             :         {
    1497       76532 :             Path       *nppath = NULL;
    1498             : 
    1499             :             nppath =
    1500       76532 :                 get_cheapest_parallel_safe_total_inner(childrel->pathlist);
    1501             : 
    1502       76532 :             if (cheapest_partial_path == NULL && nppath == NULL)
    1503             :             {
    1504             :                 /* Neither a partial nor a parallel-safe path?  Forget it. */
    1505         546 :                 pa_subpaths_valid = false;
    1506             :             }
    1507       75986 :             else if (nppath == NULL ||
    1508       62880 :                      (cheapest_partial_path != NULL &&
    1509       62880 :                       cheapest_partial_path->total_cost < nppath->total_cost))
    1510             :             {
    1511             :                 /* Partial path is cheaper or the only option. */
    1512             :                 Assert(cheapest_partial_path != NULL);
    1513       62740 :                 accumulate_append_subpath(cheapest_partial_path,
    1514             :                                           &pa_partial_subpaths,
    1515             :                                           &pa_nonpartial_subpaths);
    1516             :             }
    1517             :             else
    1518             :             {
    1519             :                 /*
    1520             :                  * Either we've got only a non-partial path, or we think that
    1521             :                  * a single backend can execute the best non-partial path
    1522             :                  * faster than all the parallel backends working together can
    1523             :                  * execute the best partial path.
    1524             :                  *
    1525             :                  * It might make sense to be more aggressive here.  Even if
    1526             :                  * the best non-partial path is more expensive than the best
    1527             :                  * partial path, it could still be better to choose the
    1528             :                  * non-partial path if there are several such paths that can
    1529             :                  * be given to different workers.  For now, we don't try to
    1530             :                  * figure that out.
    1531             :                  */
    1532       13246 :                 accumulate_append_subpath(nppath,
    1533             :                                           &pa_nonpartial_subpaths,
    1534             :                                           NULL);
    1535             :             }
    1536             :         }
    1537             : 
    1538             :         /*
    1539             :          * Collect lists of all the available path orderings and
    1540             :          * parameterizations for all the children.  We use these as a
    1541             :          * heuristic to indicate which sort orderings and parameterizations we
    1542             :          * should build Append and MergeAppend paths for.
    1543             :          */
    1544      240300 :         foreach(lcp, childrel->pathlist)
    1545             :         {
    1546      138684 :             Path       *childpath = (Path *) lfirst(lcp);
    1547      138684 :             List       *childkeys = childpath->pathkeys;
    1548      138684 :             Relids      childouter = PATH_REQ_OUTER(childpath);
    1549             : 
    1550             :             /* Unsorted paths don't contribute to pathkey list */
    1551      138684 :             if (childkeys != NIL)
    1552             :             {
    1553             :                 ListCell   *lpk;
    1554       36794 :                 bool        found = false;
    1555             : 
    1556             :                 /* Have we already seen this ordering? */
    1557       37000 :                 foreach(lpk, all_child_pathkeys)
    1558             :                 {
    1559       24856 :                     List       *existing_pathkeys = (List *) lfirst(lpk);
    1560             : 
    1561       24856 :                     if (compare_pathkeys(existing_pathkeys,
    1562             :                                          childkeys) == PATHKEYS_EQUAL)
    1563             :                     {
    1564       24650 :                         found = true;
    1565       24650 :                         break;
    1566             :                     }
    1567             :                 }
    1568       36794 :                 if (!found)
    1569             :                 {
    1570             :                     /* No, so add it to all_child_pathkeys */
    1571       12144 :                     all_child_pathkeys = lappend(all_child_pathkeys,
    1572             :                                                  childkeys);
    1573             :                 }
    1574             :             }
    1575             : 
    1576             :             /* Unparameterized paths don't contribute to param-set list */
    1577      138684 :             if (childouter)
    1578             :             {
    1579             :                 ListCell   *lco;
    1580        6596 :                 bool        found = false;
    1581             : 
    1582             :                 /* Have we already seen this param set? */
    1583        7316 :                 foreach(lco, all_child_outers)
    1584             :                 {
    1585        4810 :                     Relids      existing_outers = (Relids) lfirst(lco);
    1586             : 
    1587        4810 :                     if (bms_equal(existing_outers, childouter))
    1588             :                     {
    1589        4090 :                         found = true;
    1590        4090 :                         break;
    1591             :                     }
    1592             :                 }
    1593        6596 :                 if (!found)
    1594             :                 {
    1595             :                     /* No, so add it to all_child_outers */
    1596        2506 :                     all_child_outers = lappend(all_child_outers,
    1597             :                                                childouter);
    1598             :                 }
    1599             :             }
    1600             :         }
    1601             :     }
    1602             : 
    1603             :     /*
    1604             :      * If we found unparameterized paths for all children, build an unordered,
    1605             :      * unparameterized Append path for the rel.  (Note: this is correct even
    1606             :      * if we have zero or one live subpath due to constraint exclusion.)
    1607             :      */
    1608       46178 :     if (subpaths_valid)
    1609       45866 :         add_path(rel, (Path *) create_append_path(root, rel, subpaths, NIL,
    1610             :                                                   NIL, NULL, 0, false,
    1611             :                                                   -1));
    1612             : 
    1613             :     /* build an AppendPath for the cheap startup paths, if valid */
    1614       46178 :     if (startup_subpaths_valid)
    1615         664 :         add_path(rel, (Path *) create_append_path(root, rel, startup_subpaths,
    1616             :                                                   NIL, NIL, NULL, 0, false, -1));
    1617             : 
    1618             :     /*
    1619             :      * Consider an append of unordered, unparameterized partial paths.  Make
    1620             :      * it parallel-aware if possible.
    1621             :      */
    1622       46178 :     if (partial_subpaths_valid && partial_subpaths != NIL)
    1623             :     {
    1624             :         AppendPath *appendpath;
    1625             :         ListCell   *lc;
    1626       27782 :         int         parallel_workers = 0;
    1627             : 
    1628             :         /* Find the highest number of workers requested for any subpath. */
    1629       95586 :         foreach(lc, partial_subpaths)
    1630             :         {
    1631       67804 :             Path       *path = lfirst(lc);
    1632             : 
    1633       67804 :             parallel_workers = Max(parallel_workers, path->parallel_workers);
    1634             :         }
    1635             :         Assert(parallel_workers > 0);
    1636             : 
    1637             :         /*
    1638             :          * If the use of parallel append is permitted, always request at least
    1639             :          * log2(# of children) workers.  We assume it can be useful to have
    1640             :          * extra workers in this case because they will be spread out across
    1641             :          * the children.  The precise formula is just a guess, but we don't
    1642             :          * want to end up with a radically different answer for a table with N
    1643             :          * partitions vs. an unpartitioned table with the same data, so the
    1644             :          * use of some kind of log-scaling here seems to make some sense.
    1645             :          */
    1646       27782 :         if (enable_parallel_append)
    1647             :         {
    1648       27734 :             parallel_workers = Max(parallel_workers,
    1649             :                                    pg_leftmost_one_pos32(list_length(live_childrels)) + 1);
    1650       27734 :             parallel_workers = Min(parallel_workers,
    1651             :                                    max_parallel_workers_per_gather);
    1652             :         }
    1653             :         Assert(parallel_workers > 0);
    1654             : 
    1655             :         /* Generate a partial append path. */
    1656       27782 :         appendpath = create_append_path(root, rel, NIL, partial_subpaths,
    1657             :                                         NIL, NULL, parallel_workers,
    1658             :                                         enable_parallel_append,
    1659             :                                         -1);
    1660             : 
    1661             :         /*
    1662             :          * Make sure any subsequent partial paths use the same row count
    1663             :          * estimate.
    1664             :          */
    1665       27782 :         partial_rows = appendpath->path.rows;
    1666             : 
    1667             :         /* Add the path. */
    1668       27782 :         add_partial_path(rel, (Path *) appendpath);
    1669             :     }
    1670             : 
    1671             :     /*
    1672             :      * Consider a parallel-aware append using a mix of partial and non-partial
    1673             :      * paths.  (This only makes sense if there's at least one child which has
    1674             :      * a non-partial path that is substantially cheaper than any partial path;
    1675             :      * otherwise, we should use the append path added in the previous step.)
    1676             :      */
    1677       46178 :     if (pa_subpaths_valid && pa_nonpartial_subpaths != NIL)
    1678             :     {
    1679             :         AppendPath *appendpath;
    1680             :         ListCell   *lc;
    1681        4664 :         int         parallel_workers = 0;
    1682             : 
    1683             :         /*
    1684             :          * Find the highest number of workers requested for any partial
    1685             :          * subpath.
    1686             :          */
    1687        5566 :         foreach(lc, pa_partial_subpaths)
    1688             :         {
    1689         902 :             Path       *path = lfirst(lc);
    1690             : 
    1691         902 :             parallel_workers = Max(parallel_workers, path->parallel_workers);
    1692             :         }
    1693             : 
    1694             :         /*
    1695             :          * Same formula here as above.  It's even more important in this
    1696             :          * instance because the non-partial paths won't contribute anything to
    1697             :          * the planned number of parallel workers.
    1698             :          */
    1699        4664 :         parallel_workers = Max(parallel_workers,
    1700             :                                pg_leftmost_one_pos32(list_length(live_childrels)) + 1);
    1701        4664 :         parallel_workers = Min(parallel_workers,
    1702             :                                max_parallel_workers_per_gather);
    1703             :         Assert(parallel_workers > 0);
    1704             : 
    1705        4664 :         appendpath = create_append_path(root, rel, pa_nonpartial_subpaths,
    1706             :                                         pa_partial_subpaths,
    1707             :                                         NIL, NULL, parallel_workers, true,
    1708             :                                         partial_rows);
    1709        4664 :         add_partial_path(rel, (Path *) appendpath);
    1710             :     }
    1711             : 
    1712             :     /*
    1713             :      * Also build unparameterized ordered append paths based on the collected
    1714             :      * list of child pathkeys.
    1715             :      */
    1716       46178 :     if (subpaths_valid)
    1717       45866 :         generate_orderedappend_paths(root, rel, live_childrels,
    1718             :                                      all_child_pathkeys);
    1719             : 
    1720             :     /*
    1721             :      * Build Append paths for each parameterization seen among the child rels.
    1722             :      * (This may look pretty expensive, but in most cases of practical
    1723             :      * interest, the child rels will expose mostly the same parameterizations,
    1724             :      * so that not that many cases actually get considered here.)
    1725             :      *
    1726             :      * The Append node itself cannot enforce quals, so all qual checking must
    1727             :      * be done in the child paths.  This means that to have a parameterized
    1728             :      * Append path, we must have the exact same parameterization for each
    1729             :      * child path; otherwise some children might be failing to check the
    1730             :      * moved-down quals.  To make them match up, we can try to increase the
    1731             :      * parameterization of lesser-parameterized paths.
    1732             :      */
    1733       48684 :     foreach(l, all_child_outers)
    1734             :     {
    1735        2506 :         Relids      required_outer = (Relids) lfirst(l);
    1736             :         ListCell   *lcr;
    1737             : 
    1738             :         /* Select the child paths for an Append with this parameterization */
    1739        2506 :         subpaths = NIL;
    1740        2506 :         subpaths_valid = true;
    1741        9198 :         foreach(lcr, live_childrels)
    1742             :         {
    1743        6704 :             RelOptInfo *childrel = (RelOptInfo *) lfirst(lcr);
    1744             :             Path       *subpath;
    1745             : 
    1746        6704 :             if (childrel->pathlist == NIL)
    1747             :             {
    1748             :                 /* failed to make a suitable path for this child */
    1749           0 :                 subpaths_valid = false;
    1750           0 :                 break;
    1751             :             }
    1752             : 
    1753        6704 :             subpath = get_cheapest_parameterized_child_path(root,
    1754             :                                                             childrel,
    1755             :                                                             required_outer);
    1756        6704 :             if (subpath == NULL)
    1757             :             {
    1758             :                 /* failed to make a suitable path for this child */
    1759          12 :                 subpaths_valid = false;
    1760          12 :                 break;
    1761             :             }
    1762        6692 :             accumulate_append_subpath(subpath, &subpaths, NULL);
    1763             :         }
    1764             : 
    1765        2506 :         if (subpaths_valid)
    1766        2494 :             add_path(rel, (Path *)
    1767        2494 :                      create_append_path(root, rel, subpaths, NIL,
    1768             :                                         NIL, required_outer, 0, false,
    1769             :                                         -1));
    1770             :     }
    1771             : 
    1772             :     /*
    1773             :      * When there is only a single child relation, the Append path can inherit
    1774             :      * any ordering available for the child rel's path, so that it's useful to
    1775             :      * consider ordered partial paths.  Above we only considered the cheapest
    1776             :      * partial path for each child, but let's also make paths using any
    1777             :      * partial paths that have pathkeys.
    1778             :      */
    1779       46178 :     if (list_length(live_childrels) == 1)
    1780             :     {
    1781       14370 :         RelOptInfo *childrel = (RelOptInfo *) linitial(live_childrels);
    1782             : 
    1783             :         /* skip the cheapest partial path, since we already used that above */
    1784       14574 :         for_each_from(l, childrel->partial_pathlist, 1)
    1785             :         {
    1786         204 :             Path       *path = (Path *) lfirst(l);
    1787             :             AppendPath *appendpath;
    1788             : 
    1789             :             /* skip paths with no pathkeys. */
    1790         204 :             if (path->pathkeys == NIL)
    1791           0 :                 continue;
    1792             : 
    1793         204 :             appendpath = create_append_path(root, rel, NIL, list_make1(path),
    1794             :                                             NIL, NULL,
    1795             :                                             path->parallel_workers, true,
    1796             :                                             partial_rows);
    1797         204 :             add_partial_path(rel, (Path *) appendpath);
    1798             :         }
    1799             :     }
    1800       46178 : }
    1801             : 
    1802             : /*
    1803             :  * generate_orderedappend_paths
    1804             :  *      Generate ordered append paths for an append relation
    1805             :  *
    1806             :  * Usually we generate MergeAppend paths here, but there are some special
    1807             :  * cases where we can generate simple Append paths, because the subpaths
    1808             :  * can provide tuples in the required order already.
    1809             :  *
    1810             :  * We generate a path for each ordering (pathkey list) appearing in
    1811             :  * all_child_pathkeys.
    1812             :  *
    1813             :  * We consider both cheapest-startup and cheapest-total cases, ie, for each
    1814             :  * interesting ordering, collect all the cheapest startup subpaths and all the
    1815             :  * cheapest total paths, and build a suitable path for each case.
    1816             :  *
    1817             :  * We don't currently generate any parameterized ordered paths here.  While
    1818             :  * it would not take much more code here to do so, it's very unclear that it
    1819             :  * is worth the planning cycles to investigate such paths: there's little
    1820             :  * use for an ordered path on the inside of a nestloop.  In fact, it's likely
    1821             :  * that the current coding of add_path would reject such paths out of hand,
    1822             :  * because add_path gives no credit for sort ordering of parameterized paths,
    1823             :  * and a parameterized MergeAppend is going to be more expensive than the
    1824             :  * corresponding parameterized Append path.  If we ever try harder to support
    1825             :  * parameterized mergejoin plans, it might be worth adding support for
    1826             :  * parameterized paths here to feed such joins.  (See notes in
    1827             :  * optimizer/README for why that might not ever happen, though.)
    1828             :  */
    1829             : static void
    1830       45866 : generate_orderedappend_paths(PlannerInfo *root, RelOptInfo *rel,
    1831             :                              List *live_childrels,
    1832             :                              List *all_child_pathkeys)
    1833             : {
    1834             :     ListCell   *lcp;
    1835       45866 :     List       *partition_pathkeys = NIL;
    1836       45866 :     List       *partition_pathkeys_desc = NIL;
    1837       45866 :     bool        partition_pathkeys_partial = true;
    1838       45866 :     bool        partition_pathkeys_desc_partial = true;
    1839             : 
    1840             :     /*
    1841             :      * Some partitioned table setups may allow us to use an Append node
    1842             :      * instead of a MergeAppend.  This is possible in cases such as RANGE
    1843             :      * partitioned tables where it's guaranteed that an earlier partition must
    1844             :      * contain rows which come earlier in the sort order.  To detect whether
    1845             :      * this is relevant, build pathkey descriptions of the partition ordering,
    1846             :      * for both forward and reverse scans.
    1847             :      */
    1848       74224 :     if (rel->part_scheme != NULL && IS_SIMPLE_REL(rel) &&
    1849       28358 :         partitions_are_ordered(rel->boundinfo, rel->live_parts))
    1850             :     {
    1851       23782 :         partition_pathkeys = build_partition_pathkeys(root, rel,
    1852             :                                                       ForwardScanDirection,
    1853             :                                                       &partition_pathkeys_partial);
    1854             : 
    1855       23782 :         partition_pathkeys_desc = build_partition_pathkeys(root, rel,
    1856             :                                                            BackwardScanDirection,
    1857             :                                                            &partition_pathkeys_desc_partial);
    1858             : 
    1859             :         /*
    1860             :          * You might think we should truncate_useless_pathkeys here, but
    1861             :          * allowing partition keys which are a subset of the query's pathkeys
    1862             :          * can often be useful.  For example, consider a table partitioned by
    1863             :          * RANGE (a, b), and a query with ORDER BY a, b, c.  If we have child
    1864             :          * paths that can produce the a, b, c ordering (perhaps via indexes on
    1865             :          * (a, b, c)) then it works to consider the appendrel output as
    1866             :          * ordered by a, b, c.
    1867             :          */
    1868             :     }
    1869             : 
    1870             :     /* Now consider each interesting sort ordering */
    1871       57950 :     foreach(lcp, all_child_pathkeys)
    1872             :     {
    1873       12084 :         List       *pathkeys = (List *) lfirst(lcp);
    1874       12084 :         List       *startup_subpaths = NIL;
    1875       12084 :         List       *total_subpaths = NIL;
    1876       12084 :         List       *fractional_subpaths = NIL;
    1877       12084 :         bool        startup_neq_total = false;
    1878             :         bool        match_partition_order;
    1879             :         bool        match_partition_order_desc;
    1880             :         int         end_index;
    1881             :         int         first_index;
    1882             :         int         direction;
    1883             : 
    1884             :         /*
    1885             :          * Determine if this sort ordering matches any partition pathkeys we
    1886             :          * have, for both ascending and descending partition order.  If the
    1887             :          * partition pathkeys happen to be contained in pathkeys then it still
    1888             :          * works, as described above, providing that the partition pathkeys
    1889             :          * are complete and not just a prefix of the partition keys.  (In such
    1890             :          * cases we'll be relying on the child paths to have sorted the
    1891             :          * lower-order columns of the required pathkeys.)
    1892             :          */
    1893       12084 :         match_partition_order =
    1894       21900 :             pathkeys_contained_in(pathkeys, partition_pathkeys) ||
    1895       10024 :             (!partition_pathkeys_partial &&
    1896         208 :              pathkeys_contained_in(partition_pathkeys, pathkeys));
    1897             : 
    1898       31464 :         match_partition_order_desc = !match_partition_order &&
    1899        9708 :             (pathkeys_contained_in(pathkeys, partition_pathkeys_desc) ||
    1900        9736 :              (!partition_pathkeys_desc_partial &&
    1901          64 :               pathkeys_contained_in(partition_pathkeys_desc, pathkeys)));
    1902             : 
    1903             :         /*
    1904             :          * When the required pathkeys match the reverse of the partition
    1905             :          * order, we must build the list of paths in reverse starting with the
    1906             :          * last matching partition first.  We can get away without making any
    1907             :          * special cases for this in the loop below by just looping backward
    1908             :          * over the child relations in this case.
    1909             :          */
    1910       12084 :         if (match_partition_order_desc)
    1911             :         {
    1912             :             /* loop backward */
    1913          48 :             first_index = list_length(live_childrels) - 1;
    1914          48 :             end_index = -1;
    1915          48 :             direction = -1;
    1916             : 
    1917             :             /*
    1918             :              * Set this to true to save us having to check for
    1919             :              * match_partition_order_desc in the loop below.
    1920             :              */
    1921          48 :             match_partition_order = true;
    1922             :         }
    1923             :         else
    1924             :         {
    1925             :             /* for all other case, loop forward */
    1926       12036 :             first_index = 0;
    1927       12036 :             end_index = list_length(live_childrels);
    1928       12036 :             direction = 1;
    1929             :         }
    1930             : 
    1931             :         /* Select the child paths for this ordering... */
    1932       43398 :         for (int i = first_index; i != end_index; i += direction)
    1933             :         {
    1934       31314 :             RelOptInfo *childrel = list_nth_node(RelOptInfo, live_childrels, i);
    1935             :             Path       *cheapest_startup,
    1936             :                        *cheapest_total,
    1937       31314 :                        *cheapest_fractional = NULL;
    1938             : 
    1939             :             /* Locate the right paths, if they are available. */
    1940             :             cheapest_startup =
    1941       31314 :                 get_cheapest_path_for_pathkeys(childrel->pathlist,
    1942             :                                                pathkeys,
    1943             :                                                NULL,
    1944             :                                                STARTUP_COST,
    1945             :                                                false);
    1946             :             cheapest_total =
    1947       31314 :                 get_cheapest_path_for_pathkeys(childrel->pathlist,
    1948             :                                                pathkeys,
    1949             :                                                NULL,
    1950             :                                                TOTAL_COST,
    1951             :                                                false);
    1952             : 
    1953             :             /*
    1954             :              * If we can't find any paths with the right order just use the
    1955             :              * cheapest-total path; we'll have to sort it later.
    1956             :              */
    1957       31314 :             if (cheapest_startup == NULL || cheapest_total == NULL)
    1958             :             {
    1959         340 :                 cheapest_startup = cheapest_total =
    1960             :                     childrel->cheapest_total_path;
    1961             :                 /* Assert we do have an unparameterized path for this child */
    1962             :                 Assert(cheapest_total->param_info == NULL);
    1963             :             }
    1964             : 
    1965             :             /*
    1966             :              * When building a fractional path, determine a cheapest
    1967             :              * fractional path for each child relation too. Looking at startup
    1968             :              * and total costs is not enough, because the cheapest fractional
    1969             :              * path may be dominated by two separate paths (one for startup,
    1970             :              * one for total).
    1971             :              *
    1972             :              * When needed (building fractional path), determine the cheapest
    1973             :              * fractional path too.
    1974             :              */
    1975       31314 :             if (root->tuple_fraction > 0)
    1976             :             {
    1977         860 :                 double      path_fraction = root->tuple_fraction;
    1978             : 
    1979             :                 /*
    1980             :                  * Merge Append considers only live children relations.  Dummy
    1981             :                  * relations must be filtered out before.
    1982             :                  */
    1983             :                 Assert(childrel->rows > 0);
    1984             : 
    1985             :                 /* Convert absolute limit to a path fraction */
    1986         860 :                 if (path_fraction >= 1.0)
    1987         860 :                     path_fraction /= childrel->rows;
    1988             : 
    1989             :                 cheapest_fractional =
    1990         860 :                     get_cheapest_fractional_path_for_pathkeys(childrel->pathlist,
    1991             :                                                               pathkeys,
    1992             :                                                               NULL,
    1993             :                                                               path_fraction);
    1994             : 
    1995             :                 /*
    1996             :                  * If we found no path with matching pathkeys, use the
    1997             :                  * cheapest total path instead.
    1998             :                  *
    1999             :                  * XXX We might consider partially sorted paths too (with an
    2000             :                  * incremental sort on top). But we'd have to build all the
    2001             :                  * incremental paths, do the costing etc.
    2002             :                  */
    2003         860 :                 if (!cheapest_fractional)
    2004          44 :                     cheapest_fractional = cheapest_total;
    2005             :             }
    2006             : 
    2007             :             /*
    2008             :              * Notice whether we actually have different paths for the
    2009             :              * "cheapest" and "total" cases; frequently there will be no point
    2010             :              * in two create_merge_append_path() calls.
    2011             :              */
    2012       31314 :             if (cheapest_startup != cheapest_total)
    2013          96 :                 startup_neq_total = true;
    2014             : 
    2015             :             /*
    2016             :              * Collect the appropriate child paths.  The required logic varies
    2017             :              * for the Append and MergeAppend cases.
    2018             :              */
    2019       31314 :             if (match_partition_order)
    2020             :             {
    2021             :                 /*
    2022             :                  * We're going to make a plain Append path.  We don't need
    2023             :                  * most of what accumulate_append_subpath would do, but we do
    2024             :                  * want to cut out child Appends or MergeAppends if they have
    2025             :                  * just a single subpath (and hence aren't doing anything
    2026             :                  * useful).
    2027             :                  */
    2028        6476 :                 cheapest_startup = get_singleton_append_subpath(cheapest_startup);
    2029        6476 :                 cheapest_total = get_singleton_append_subpath(cheapest_total);
    2030             : 
    2031        6476 :                 startup_subpaths = lappend(startup_subpaths, cheapest_startup);
    2032        6476 :                 total_subpaths = lappend(total_subpaths, cheapest_total);
    2033             : 
    2034        6476 :                 if (cheapest_fractional)
    2035             :                 {
    2036         144 :                     cheapest_fractional = get_singleton_append_subpath(cheapest_fractional);
    2037         144 :                     fractional_subpaths = lappend(fractional_subpaths, cheapest_fractional);
    2038             :                 }
    2039             :             }
    2040             :             else
    2041             :             {
    2042             :                 /*
    2043             :                  * Otherwise, rely on accumulate_append_subpath to collect the
    2044             :                  * child paths for the MergeAppend.
    2045             :                  */
    2046       24838 :                 accumulate_append_subpath(cheapest_startup,
    2047             :                                           &startup_subpaths, NULL);
    2048       24838 :                 accumulate_append_subpath(cheapest_total,
    2049             :                                           &total_subpaths, NULL);
    2050             : 
    2051       24838 :                 if (cheapest_fractional)
    2052         716 :                     accumulate_append_subpath(cheapest_fractional,
    2053             :                                               &fractional_subpaths, NULL);
    2054             :             }
    2055             :         }
    2056             : 
    2057             :         /* ... and build the Append or MergeAppend paths */
    2058       12084 :         if (match_partition_order)
    2059             :         {
    2060             :             /* We only need Append */
    2061        2424 :             add_path(rel, (Path *) create_append_path(root,
    2062             :                                                       rel,
    2063             :                                                       startup_subpaths,
    2064             :                                                       NIL,
    2065             :                                                       pathkeys,
    2066             :                                                       NULL,
    2067             :                                                       0,
    2068             :                                                       false,
    2069             :                                                       -1));
    2070        2424 :             if (startup_neq_total)
    2071           0 :                 add_path(rel, (Path *) create_append_path(root,
    2072             :                                                           rel,
    2073             :                                                           total_subpaths,
    2074             :                                                           NIL,
    2075             :                                                           pathkeys,
    2076             :                                                           NULL,
    2077             :                                                           0,
    2078             :                                                           false,
    2079             :                                                           -1));
    2080             : 
    2081        2424 :             if (fractional_subpaths)
    2082          72 :                 add_path(rel, (Path *) create_append_path(root,
    2083             :                                                           rel,
    2084             :                                                           fractional_subpaths,
    2085             :                                                           NIL,
    2086             :                                                           pathkeys,
    2087             :                                                           NULL,
    2088             :                                                           0,
    2089             :                                                           false,
    2090             :                                                           -1));
    2091             :         }
    2092             :         else
    2093             :         {
    2094             :             /* We need MergeAppend */
    2095        9660 :             add_path(rel, (Path *) create_merge_append_path(root,
    2096             :                                                             rel,
    2097             :                                                             startup_subpaths,
    2098             :                                                             pathkeys,
    2099             :                                                             NULL));
    2100        9660 :             if (startup_neq_total)
    2101          60 :                 add_path(rel, (Path *) create_merge_append_path(root,
    2102             :                                                                 rel,
    2103             :                                                                 total_subpaths,
    2104             :                                                                 pathkeys,
    2105             :                                                                 NULL));
    2106             : 
    2107        9660 :             if (fractional_subpaths)
    2108         256 :                 add_path(rel, (Path *) create_merge_append_path(root,
    2109             :                                                                 rel,
    2110             :                                                                 fractional_subpaths,
    2111             :                                                                 pathkeys,
    2112             :                                                                 NULL));
    2113             :         }
    2114             :     }
    2115       45866 : }
    2116             : 
    2117             : /*
    2118             :  * get_cheapest_parameterized_child_path
    2119             :  *      Get cheapest path for this relation that has exactly the requested
    2120             :  *      parameterization.
    2121             :  *
    2122             :  * Returns NULL if unable to create such a path.
    2123             :  */
    2124             : static Path *
    2125        6704 : get_cheapest_parameterized_child_path(PlannerInfo *root, RelOptInfo *rel,
    2126             :                                       Relids required_outer)
    2127             : {
    2128             :     Path       *cheapest;
    2129             :     ListCell   *lc;
    2130             : 
    2131             :     /*
    2132             :      * Look up the cheapest existing path with no more than the needed
    2133             :      * parameterization.  If it has exactly the needed parameterization, we're
    2134             :      * done.
    2135             :      */
    2136        6704 :     cheapest = get_cheapest_path_for_pathkeys(rel->pathlist,
    2137             :                                               NIL,
    2138             :                                               required_outer,
    2139             :                                               TOTAL_COST,
    2140             :                                               false);
    2141             :     Assert(cheapest != NULL);
    2142        6704 :     if (bms_equal(PATH_REQ_OUTER(cheapest), required_outer))
    2143        6364 :         return cheapest;
    2144             : 
    2145             :     /*
    2146             :      * Otherwise, we can "reparameterize" an existing path to match the given
    2147             :      * parameterization, which effectively means pushing down additional
    2148             :      * joinquals to be checked within the path's scan.  However, some existing
    2149             :      * paths might check the available joinquals already while others don't;
    2150             :      * therefore, it's not clear which existing path will be cheapest after
    2151             :      * reparameterization.  We have to go through them all and find out.
    2152             :      */
    2153         340 :     cheapest = NULL;
    2154        1180 :     foreach(lc, rel->pathlist)
    2155             :     {
    2156         840 :         Path       *path = (Path *) lfirst(lc);
    2157             : 
    2158             :         /* Can't use it if it needs more than requested parameterization */
    2159         840 :         if (!bms_is_subset(PATH_REQ_OUTER(path), required_outer))
    2160          24 :             continue;
    2161             : 
    2162             :         /*
    2163             :          * Reparameterization can only increase the path's cost, so if it's
    2164             :          * already more expensive than the current cheapest, forget it.
    2165             :          */
    2166        1272 :         if (cheapest != NULL &&
    2167         456 :             compare_path_costs(cheapest, path, TOTAL_COST) <= 0)
    2168         384 :             continue;
    2169             : 
    2170             :         /* Reparameterize if needed, then recheck cost */
    2171         432 :         if (!bms_equal(PATH_REQ_OUTER(path), required_outer))
    2172             :         {
    2173         356 :             path = reparameterize_path(root, path, required_outer, 1.0);
    2174         356 :             if (path == NULL)
    2175          32 :                 continue;       /* failed to reparameterize this one */
    2176             :             Assert(bms_equal(PATH_REQ_OUTER(path), required_outer));
    2177             : 
    2178         324 :             if (cheapest != NULL &&
    2179           0 :                 compare_path_costs(cheapest, path, TOTAL_COST) <= 0)
    2180           0 :                 continue;
    2181             :         }
    2182             : 
    2183             :         /* We have a new best path */
    2184         400 :         cheapest = path;
    2185             :     }
    2186             : 
    2187             :     /* Return the best path, or NULL if we found no suitable candidate */
    2188         340 :     return cheapest;
    2189             : }
    2190             : 
    2191             : /*
    2192             :  * accumulate_append_subpath
    2193             :  *      Add a subpath to the list being built for an Append or MergeAppend.
    2194             :  *
    2195             :  * It's possible that the child is itself an Append or MergeAppend path, in
    2196             :  * which case we can "cut out the middleman" and just add its child paths to
    2197             :  * our own list.  (We don't try to do this earlier because we need to apply
    2198             :  * both levels of transformation to the quals.)
    2199             :  *
    2200             :  * Note that if we omit a child MergeAppend in this way, we are effectively
    2201             :  * omitting a sort step, which seems fine: if the parent is to be an Append,
    2202             :  * its result would be unsorted anyway, while if the parent is to be a
    2203             :  * MergeAppend, there's no point in a separate sort on a child.
    2204             :  *
    2205             :  * Normally, either path is a partial path and subpaths is a list of partial
    2206             :  * paths, or else path is a non-partial plan and subpaths is a list of those.
    2207             :  * However, if path is a parallel-aware Append, then we add its partial path
    2208             :  * children to subpaths and the rest to special_subpaths.  If the latter is
    2209             :  * NULL, we don't flatten the path at all (unless it contains only partial
    2210             :  * paths).
    2211             :  */
    2212             : static void
    2213      298906 : accumulate_append_subpath(Path *path, List **subpaths, List **special_subpaths)
    2214             : {
    2215      298906 :     if (IsA(path, AppendPath))
    2216             :     {
    2217       15872 :         AppendPath *apath = (AppendPath *) path;
    2218             : 
    2219       15872 :         if (!apath->path.parallel_aware || apath->first_partial_path == 0)
    2220             :         {
    2221       15536 :             *subpaths = list_concat(*subpaths, apath->subpaths);
    2222       15536 :             return;
    2223             :         }
    2224         336 :         else if (special_subpaths != NULL)
    2225             :         {
    2226             :             List       *new_special_subpaths;
    2227             : 
    2228             :             /* Split Parallel Append into partial and non-partial subpaths */
    2229         168 :             *subpaths = list_concat(*subpaths,
    2230         168 :                                     list_copy_tail(apath->subpaths,
    2231             :                                                    apath->first_partial_path));
    2232         168 :             new_special_subpaths = list_copy_head(apath->subpaths,
    2233             :                                                   apath->first_partial_path);
    2234         168 :             *special_subpaths = list_concat(*special_subpaths,
    2235             :                                             new_special_subpaths);
    2236         168 :             return;
    2237             :         }
    2238             :     }
    2239      283034 :     else if (IsA(path, MergeAppendPath))
    2240             :     {
    2241        1220 :         MergeAppendPath *mpath = (MergeAppendPath *) path;
    2242             : 
    2243        1220 :         *subpaths = list_concat(*subpaths, mpath->subpaths);
    2244        1220 :         return;
    2245             :     }
    2246             : 
    2247      281982 :     *subpaths = lappend(*subpaths, path);
    2248             : }
    2249             : 
    2250             : /*
    2251             :  * get_singleton_append_subpath
    2252             :  *      Returns the single subpath of an Append/MergeAppend, or just
    2253             :  *      return 'path' if it's not a single sub-path Append/MergeAppend.
    2254             :  *
    2255             :  * Note: 'path' must not be a parallel-aware path.
    2256             :  */
    2257             : static Path *
    2258       13096 : get_singleton_append_subpath(Path *path)
    2259             : {
    2260             :     Assert(!path->parallel_aware);
    2261             : 
    2262       13096 :     if (IsA(path, AppendPath))
    2263             :     {
    2264         388 :         AppendPath *apath = (AppendPath *) path;
    2265             : 
    2266         388 :         if (list_length(apath->subpaths) == 1)
    2267         192 :             return (Path *) linitial(apath->subpaths);
    2268             :     }
    2269       12708 :     else if (IsA(path, MergeAppendPath))
    2270             :     {
    2271         348 :         MergeAppendPath *mpath = (MergeAppendPath *) path;
    2272             : 
    2273         348 :         if (list_length(mpath->subpaths) == 1)
    2274           0 :             return (Path *) linitial(mpath->subpaths);
    2275             :     }
    2276             : 
    2277       12904 :     return path;
    2278             : }
    2279             : 
    2280             : /*
    2281             :  * set_dummy_rel_pathlist
    2282             :  *    Build a dummy path for a relation that's been excluded by constraints
    2283             :  *
    2284             :  * Rather than inventing a special "dummy" path type, we represent this as an
    2285             :  * AppendPath with no members (see also IS_DUMMY_APPEND/IS_DUMMY_REL macros).
    2286             :  *
    2287             :  * (See also mark_dummy_rel, which does basically the same thing, but is
    2288             :  * typically used to change a rel into dummy state after we already made
    2289             :  * paths for it.)
    2290             :  */
    2291             : static void
    2292        1262 : set_dummy_rel_pathlist(RelOptInfo *rel)
    2293             : {
    2294             :     /* Set dummy size estimates --- we leave attr_widths[] as zeroes */
    2295        1262 :     rel->rows = 0;
    2296        1262 :     rel->reltarget->width = 0;
    2297             : 
    2298             :     /* Discard any pre-existing paths; no further need for them */
    2299        1262 :     rel->pathlist = NIL;
    2300        1262 :     rel->partial_pathlist = NIL;
    2301             : 
    2302             :     /* Set up the dummy path */
    2303        1262 :     add_path(rel, (Path *) create_append_path(NULL, rel, NIL, NIL,
    2304             :                                               NIL, rel->lateral_relids,
    2305             :                                               0, false, -1));
    2306             : 
    2307             :     /*
    2308             :      * We set the cheapest-path fields immediately, just in case they were
    2309             :      * pointing at some discarded path.  This is redundant in current usage
    2310             :      * because set_rel_pathlist will do it later, but it's cheap so we keep it
    2311             :      * for safety and consistency with mark_dummy_rel.
    2312             :      */
    2313        1262 :     set_cheapest(rel);
    2314        1262 : }
    2315             : 
    2316             : /*
    2317             :  * find_window_run_conditions
    2318             :  *      Determine if 'wfunc' is really a WindowFunc and call its prosupport
    2319             :  *      function to determine the function's monotonic properties.  We then
    2320             :  *      see if 'opexpr' can be used to short-circuit execution.
    2321             :  *
    2322             :  * For example row_number() over (order by ...) always produces a value one
    2323             :  * higher than the previous.  If someone has a window function in a subquery
    2324             :  * and has a WHERE clause in the outer query to filter rows <= 10, then we may
    2325             :  * as well stop processing the windowagg once the row number reaches 11.  Here
    2326             :  * we check if 'opexpr' might help us to stop doing needless extra processing
    2327             :  * in WindowAgg nodes.
    2328             :  *
    2329             :  * '*keep_original' is set to true if the caller should also use 'opexpr' for
    2330             :  * its original purpose.  This is set to false if the caller can assume that
    2331             :  * the run condition will handle all of the required filtering.
    2332             :  *
    2333             :  * Returns true if 'opexpr' was found to be useful and was added to the
    2334             :  * WindowFunc's runCondition.  We also set *keep_original accordingly and add
    2335             :  * 'attno' to *run_cond_attrs offset by FirstLowInvalidHeapAttributeNumber.
    2336             :  * If the 'opexpr' cannot be used then we set *keep_original to true and
    2337             :  * return false.
    2338             :  */
    2339             : static bool
    2340         240 : find_window_run_conditions(Query *subquery, AttrNumber attno,
    2341             :                            WindowFunc *wfunc, OpExpr *opexpr, bool wfunc_left,
    2342             :                            bool *keep_original, Bitmapset **run_cond_attrs)
    2343             : {
    2344             :     Oid         prosupport;
    2345             :     Expr       *otherexpr;
    2346             :     SupportRequestWFuncMonotonic req;
    2347             :     SupportRequestWFuncMonotonic *res;
    2348             :     WindowClause *wclause;
    2349             :     List       *opinfos;
    2350             :     OpExpr     *runopexpr;
    2351             :     Oid         runoperator;
    2352             :     ListCell   *lc;
    2353             : 
    2354         240 :     *keep_original = true;
    2355             : 
    2356         240 :     while (IsA(wfunc, RelabelType))
    2357           0 :         wfunc = (WindowFunc *) ((RelabelType *) wfunc)->arg;
    2358             : 
    2359             :     /* we can only work with window functions */
    2360         240 :     if (!IsA(wfunc, WindowFunc))
    2361          24 :         return false;
    2362             : 
    2363             :     /* can't use it if there are subplans in the WindowFunc */
    2364         216 :     if (contain_subplans((Node *) wfunc))
    2365           6 :         return false;
    2366             : 
    2367         210 :     prosupport = get_func_support(wfunc->winfnoid);
    2368             : 
    2369             :     /* Check if there's a support function for 'wfunc' */
    2370         210 :     if (!OidIsValid(prosupport))
    2371          18 :         return false;
    2372             : 
    2373             :     /* get the Expr from the other side of the OpExpr */
    2374         192 :     if (wfunc_left)
    2375         168 :         otherexpr = lsecond(opexpr->args);
    2376             :     else
    2377          24 :         otherexpr = linitial(opexpr->args);
    2378             : 
    2379             :     /*
    2380             :      * The value being compared must not change during the evaluation of the
    2381             :      * window partition.
    2382             :      */
    2383         192 :     if (!is_pseudo_constant_clause((Node *) otherexpr))
    2384           0 :         return false;
    2385             : 
    2386             :     /* find the window clause belonging to the window function */
    2387         192 :     wclause = (WindowClause *) list_nth(subquery->windowClause,
    2388         192 :                                         wfunc->winref - 1);
    2389             : 
    2390         192 :     req.type = T_SupportRequestWFuncMonotonic;
    2391         192 :     req.window_func = wfunc;
    2392         192 :     req.window_clause = wclause;
    2393             : 
    2394             :     /* call the support function */
    2395             :     res = (SupportRequestWFuncMonotonic *)
    2396         192 :         DatumGetPointer(OidFunctionCall1(prosupport,
    2397             :                                          PointerGetDatum(&req)));
    2398             : 
    2399             :     /*
    2400             :      * Nothing to do if the function is neither monotonically increasing nor
    2401             :      * monotonically decreasing.
    2402             :      */
    2403         192 :     if (res == NULL || res->monotonic == MONOTONICFUNC_NONE)
    2404           0 :         return false;
    2405             : 
    2406         192 :     runopexpr = NULL;
    2407         192 :     runoperator = InvalidOid;
    2408         192 :     opinfos = get_op_index_interpretation(opexpr->opno);
    2409             : 
    2410         192 :     foreach(lc, opinfos)
    2411             :     {
    2412         192 :         OpIndexInterpretation *opinfo = (OpIndexInterpretation *) lfirst(lc);
    2413         192 :         CompareType cmptype = opinfo->cmptype;
    2414             : 
    2415             :         /* handle < / <= */
    2416         192 :         if (cmptype == COMPARE_LT || cmptype == COMPARE_LE)
    2417             :         {
    2418             :             /*
    2419             :              * < / <= is supported for monotonically increasing functions in
    2420             :              * the form <wfunc> op <pseudoconst> and <pseudoconst> op <wfunc>
    2421             :              * for monotonically decreasing functions.
    2422             :              */
    2423         138 :             if ((wfunc_left && (res->monotonic & MONOTONICFUNC_INCREASING)) ||
    2424          18 :                 (!wfunc_left && (res->monotonic & MONOTONICFUNC_DECREASING)))
    2425             :             {
    2426         126 :                 *keep_original = false;
    2427         126 :                 runopexpr = opexpr;
    2428         126 :                 runoperator = opexpr->opno;
    2429             :             }
    2430         138 :             break;
    2431             :         }
    2432             :         /* handle > / >= */
    2433          54 :         else if (cmptype == COMPARE_GT || cmptype == COMPARE_GE)
    2434             :         {
    2435             :             /*
    2436             :              * > / >= is supported for monotonically decreasing functions in
    2437             :              * the form <wfunc> op <pseudoconst> and <pseudoconst> op <wfunc>
    2438             :              * for monotonically increasing functions.
    2439             :              */
    2440          18 :             if ((wfunc_left && (res->monotonic & MONOTONICFUNC_DECREASING)) ||
    2441          12 :                 (!wfunc_left && (res->monotonic & MONOTONICFUNC_INCREASING)))
    2442             :             {
    2443          18 :                 *keep_original = false;
    2444          18 :                 runopexpr = opexpr;
    2445          18 :                 runoperator = opexpr->opno;
    2446             :             }
    2447          18 :             break;
    2448             :         }
    2449             :         /* handle = */
    2450          36 :         else if (cmptype == COMPARE_EQ)
    2451             :         {
    2452             :             CompareType newcmptype;
    2453             : 
    2454             :             /*
    2455             :              * When both monotonically increasing and decreasing then the
    2456             :              * return value of the window function will be the same each time.
    2457             :              * We can simply use 'opexpr' as the run condition without
    2458             :              * modifying it.
    2459             :              */
    2460          36 :             if ((res->monotonic & MONOTONICFUNC_BOTH) == MONOTONICFUNC_BOTH)
    2461             :             {
    2462           6 :                 *keep_original = false;
    2463           6 :                 runopexpr = opexpr;
    2464           6 :                 runoperator = opexpr->opno;
    2465           6 :                 break;
    2466             :             }
    2467             : 
    2468             :             /*
    2469             :              * When monotonically increasing we make a qual with <wfunc> <=
    2470             :              * <value> or <value> >= <wfunc> in order to filter out values
    2471             :              * which are above the value in the equality condition.  For
    2472             :              * monotonically decreasing functions we want to filter values
    2473             :              * below the value in the equality condition.
    2474             :              */
    2475          30 :             if (res->monotonic & MONOTONICFUNC_INCREASING)
    2476          30 :                 newcmptype = wfunc_left ? COMPARE_LE : COMPARE_GE;
    2477             :             else
    2478           0 :                 newcmptype = wfunc_left ? COMPARE_GE : COMPARE_LE;
    2479             : 
    2480             :             /* We must keep the original equality qual */
    2481          30 :             *keep_original = true;
    2482          30 :             runopexpr = opexpr;
    2483             : 
    2484             :             /* determine the operator to use for the WindowFuncRunCondition */
    2485          30 :             runoperator = get_opfamily_member_for_cmptype(opinfo->opfamily_id,
    2486             :                                                           opinfo->oplefttype,
    2487             :                                                           opinfo->oprighttype,
    2488             :                                                           newcmptype);
    2489          30 :             break;
    2490             :         }
    2491             :     }
    2492             : 
    2493         192 :     if (runopexpr != NULL)
    2494             :     {
    2495             :         WindowFuncRunCondition *wfuncrc;
    2496             : 
    2497         180 :         wfuncrc = makeNode(WindowFuncRunCondition);
    2498         180 :         wfuncrc->opno = runoperator;
    2499         180 :         wfuncrc->inputcollid = runopexpr->inputcollid;
    2500         180 :         wfuncrc->wfunc_left = wfunc_left;
    2501         180 :         wfuncrc->arg = copyObject(otherexpr);
    2502             : 
    2503         180 :         wfunc->runCondition = lappend(wfunc->runCondition, wfuncrc);
    2504             : 
    2505             :         /* record that this attno was used in a run condition */
    2506         180 :         *run_cond_attrs = bms_add_member(*run_cond_attrs,
    2507             :                                          attno - FirstLowInvalidHeapAttributeNumber);
    2508         180 :         return true;
    2509             :     }
    2510             : 
    2511             :     /* unsupported OpExpr */
    2512          12 :     return false;
    2513             : }
    2514             : 
    2515             : /*
    2516             :  * check_and_push_window_quals
    2517             :  *      Check if 'clause' is a qual that can be pushed into a WindowFunc
    2518             :  *      as a 'runCondition' qual.  These, when present, allow some unnecessary
    2519             :  *      work to be skipped during execution.
    2520             :  *
    2521             :  * 'run_cond_attrs' will be populated with all targetlist resnos of subquery
    2522             :  * targets (offset by FirstLowInvalidHeapAttributeNumber) that we pushed
    2523             :  * window quals for.
    2524             :  *
    2525             :  * Returns true if the caller still must keep the original qual or false if
    2526             :  * the caller can safely ignore the original qual because the WindowAgg node
    2527             :  * will use the runCondition to stop returning tuples.
    2528             :  */
    2529             : static bool
    2530         252 : check_and_push_window_quals(Query *subquery, Node *clause,
    2531             :                             Bitmapset **run_cond_attrs)
    2532             : {
    2533         252 :     OpExpr     *opexpr = (OpExpr *) clause;
    2534         252 :     bool        keep_original = true;
    2535             :     Var        *var1;
    2536             :     Var        *var2;
    2537             : 
    2538             :     /* We're only able to use OpExprs with 2 operands */
    2539         252 :     if (!IsA(opexpr, OpExpr))
    2540          18 :         return true;
    2541             : 
    2542         234 :     if (list_length(opexpr->args) != 2)
    2543           0 :         return true;
    2544             : 
    2545             :     /*
    2546             :      * Currently, we restrict this optimization to strict OpExprs.  The reason
    2547             :      * for this is that during execution, once the runcondition becomes false,
    2548             :      * we stop evaluating WindowFuncs.  To avoid leaving around stale window
    2549             :      * function result values, we set them to NULL.  Having only strict
    2550             :      * OpExprs here ensures that we properly filter out the tuples with NULLs
    2551             :      * in the top-level WindowAgg.
    2552             :      */
    2553         234 :     set_opfuncid(opexpr);
    2554         234 :     if (!func_strict(opexpr->opfuncid))
    2555           0 :         return true;
    2556             : 
    2557             :     /*
    2558             :      * Check for plain Vars that reference window functions in the subquery.
    2559             :      * If we find any, we'll ask find_window_run_conditions() if 'opexpr' can
    2560             :      * be used as part of the run condition.
    2561             :      */
    2562             : 
    2563             :     /* Check the left side of the OpExpr */
    2564         234 :     var1 = linitial(opexpr->args);
    2565         234 :     if (IsA(var1, Var) && var1->varattno > 0)
    2566             :     {
    2567         198 :         TargetEntry *tle = list_nth(subquery->targetList, var1->varattno - 1);
    2568         198 :         WindowFunc *wfunc = (WindowFunc *) tle->expr;
    2569             : 
    2570         198 :         if (find_window_run_conditions(subquery, tle->resno, wfunc, opexpr,
    2571             :                                        true, &keep_original, run_cond_attrs))
    2572         162 :             return keep_original;
    2573             :     }
    2574             : 
    2575             :     /* and check the right side */
    2576          72 :     var2 = lsecond(opexpr->args);
    2577          72 :     if (IsA(var2, Var) && var2->varattno > 0)
    2578             :     {
    2579          42 :         TargetEntry *tle = list_nth(subquery->targetList, var2->varattno - 1);
    2580          42 :         WindowFunc *wfunc = (WindowFunc *) tle->expr;
    2581             : 
    2582          42 :         if (find_window_run_conditions(subquery, tle->resno, wfunc, opexpr,
    2583             :                                        false, &keep_original, run_cond_attrs))
    2584          18 :             return keep_original;
    2585             :     }
    2586             : 
    2587          54 :     return true;
    2588             : }
    2589             : 
    2590             : /*
    2591             :  * set_subquery_pathlist
    2592             :  *      Generate SubqueryScan access paths for a subquery RTE
    2593             :  *
    2594             :  * We don't currently support generating parameterized paths for subqueries
    2595             :  * by pushing join clauses down into them; it seems too expensive to re-plan
    2596             :  * the subquery multiple times to consider different alternatives.
    2597             :  * (XXX that could stand to be reconsidered, now that we use Paths.)
    2598             :  * So the paths made here will be parameterized if the subquery contains
    2599             :  * LATERAL references, otherwise not.  As long as that's true, there's no need
    2600             :  * for a separate set_subquery_size phase: just make the paths right away.
    2601             :  */
    2602             : static void
    2603       16760 : set_subquery_pathlist(PlannerInfo *root, RelOptInfo *rel,
    2604             :                       Index rti, RangeTblEntry *rte)
    2605             : {
    2606       16760 :     Query      *parse = root->parse;
    2607       16760 :     Query      *subquery = rte->subquery;
    2608             :     bool        trivial_pathtarget;
    2609             :     Relids      required_outer;
    2610             :     pushdown_safety_info safetyInfo;
    2611             :     double      tuple_fraction;
    2612             :     RelOptInfo *sub_final_rel;
    2613       16760 :     Bitmapset  *run_cond_attrs = NULL;
    2614             :     ListCell   *lc;
    2615             :     char       *plan_name;
    2616             : 
    2617             :     /*
    2618             :      * Must copy the Query so that planning doesn't mess up the RTE contents
    2619             :      * (really really need to fix the planner to not scribble on its input,
    2620             :      * someday ... but see remove_unused_subquery_outputs to start with).
    2621             :      */
    2622       16760 :     subquery = copyObject(subquery);
    2623             : 
    2624             :     /*
    2625             :      * If it's a LATERAL subquery, it might contain some Vars of the current
    2626             :      * query level, requiring it to be treated as parameterized, even though
    2627             :      * we don't support pushing down join quals into subqueries.
    2628             :      */
    2629       16760 :     required_outer = rel->lateral_relids;
    2630             : 
    2631             :     /*
    2632             :      * Zero out result area for subquery_is_pushdown_safe, so that it can set
    2633             :      * flags as needed while recursing.  In particular, we need a workspace
    2634             :      * for keeping track of the reasons why columns are unsafe to reference.
    2635             :      * These reasons are stored in the bits inside unsafeFlags[i] when we
    2636             :      * discover reasons that column i of the subquery is unsafe to be used in
    2637             :      * a pushed-down qual.
    2638             :      */
    2639       16760 :     memset(&safetyInfo, 0, sizeof(safetyInfo));
    2640       16760 :     safetyInfo.unsafeFlags = (unsigned char *)
    2641       16760 :         palloc0((list_length(subquery->targetList) + 1) * sizeof(unsigned char));
    2642             : 
    2643             :     /*
    2644             :      * If the subquery has the "security_barrier" flag, it means the subquery
    2645             :      * originated from a view that must enforce row-level security.  Then we
    2646             :      * must not push down quals that contain leaky functions.  (Ideally this
    2647             :      * would be checked inside subquery_is_pushdown_safe, but since we don't
    2648             :      * currently pass the RTE to that function, we must do it here.)
    2649             :      */
    2650       16760 :     safetyInfo.unsafeLeaky = rte->security_barrier;
    2651             : 
    2652             :     /*
    2653             :      * If there are any restriction clauses that have been attached to the
    2654             :      * subquery relation, consider pushing them down to become WHERE or HAVING
    2655             :      * quals of the subquery itself.  This transformation is useful because it
    2656             :      * may allow us to generate a better plan for the subquery than evaluating
    2657             :      * all the subquery output rows and then filtering them.
    2658             :      *
    2659             :      * There are several cases where we cannot push down clauses. Restrictions
    2660             :      * involving the subquery are checked by subquery_is_pushdown_safe().
    2661             :      * Restrictions on individual clauses are checked by
    2662             :      * qual_is_pushdown_safe().  Also, we don't want to push down
    2663             :      * pseudoconstant clauses; better to have the gating node above the
    2664             :      * subquery.
    2665             :      *
    2666             :      * Non-pushed-down clauses will get evaluated as qpquals of the
    2667             :      * SubqueryScan node.
    2668             :      *
    2669             :      * XXX Are there any cases where we want to make a policy decision not to
    2670             :      * push down a pushable qual, because it'd result in a worse plan?
    2671             :      */
    2672       18628 :     if (rel->baserestrictinfo != NIL &&
    2673        1868 :         subquery_is_pushdown_safe(subquery, subquery, &safetyInfo))
    2674             :     {
    2675             :         /* OK to consider pushing down individual quals */
    2676        1722 :         List       *upperrestrictlist = NIL;
    2677             :         ListCell   *l;
    2678             : 
    2679        4396 :         foreach(l, rel->baserestrictinfo)
    2680             :         {
    2681        2674 :             RestrictInfo *rinfo = (RestrictInfo *) lfirst(l);
    2682        2674 :             Node       *clause = (Node *) rinfo->clause;
    2683             : 
    2684        2674 :             if (rinfo->pseudoconstant)
    2685             :             {
    2686           4 :                 upperrestrictlist = lappend(upperrestrictlist, rinfo);
    2687           4 :                 continue;
    2688             :             }
    2689             : 
    2690        2670 :             switch (qual_is_pushdown_safe(subquery, rti, rinfo, &safetyInfo))
    2691             :             {
    2692        1964 :                 case PUSHDOWN_SAFE:
    2693             :                     /* Push it down */
    2694        1964 :                     subquery_push_qual(subquery, rte, rti, clause);
    2695        1964 :                     break;
    2696             : 
    2697         252 :                 case PUSHDOWN_WINDOWCLAUSE_RUNCOND:
    2698             : 
    2699             :                     /*
    2700             :                      * Since we can't push the qual down into the subquery,
    2701             :                      * check if it happens to reference a window function.  If
    2702             :                      * so then it might be useful to use for the WindowAgg's
    2703             :                      * runCondition.
    2704             :                      */
    2705         504 :                     if (!subquery->hasWindowFuncs ||
    2706         252 :                         check_and_push_window_quals(subquery, clause,
    2707             :                                                     &run_cond_attrs))
    2708             :                     {
    2709             :                         /*
    2710             :                          * subquery has no window funcs or the clause is not a
    2711             :                          * suitable window run condition qual or it is, but
    2712             :                          * the original must also be kept in the upper query.
    2713             :                          */
    2714         102 :                         upperrestrictlist = lappend(upperrestrictlist, rinfo);
    2715             :                     }
    2716         252 :                     break;
    2717             : 
    2718         454 :                 case PUSHDOWN_UNSAFE:
    2719         454 :                     upperrestrictlist = lappend(upperrestrictlist, rinfo);
    2720         454 :                     break;
    2721             :             }
    2722             :         }
    2723        1722 :         rel->baserestrictinfo = upperrestrictlist;
    2724             :         /* We don't bother recomputing baserestrict_min_security */
    2725             :     }
    2726             : 
    2727       16760 :     pfree(safetyInfo.unsafeFlags);
    2728             : 
    2729             :     /*
    2730             :      * The upper query might not use all the subquery's output columns; if
    2731             :      * not, we can simplify.  Pass the attributes that were pushed down into
    2732             :      * WindowAgg run conditions to ensure we don't accidentally think those
    2733             :      * are unused.
    2734             :      */
    2735       16760 :     remove_unused_subquery_outputs(subquery, rel, run_cond_attrs);
    2736             : 
    2737             :     /*
    2738             :      * We can safely pass the outer tuple_fraction down to the subquery if the
    2739             :      * outer level has no joining, aggregation, or sorting to do. Otherwise
    2740             :      * we'd better tell the subquery to plan for full retrieval. (XXX This
    2741             :      * could probably be made more intelligent ...)
    2742             :      */
    2743       16760 :     if (parse->hasAggs ||
    2744       15514 :         parse->groupClause ||
    2745       15496 :         parse->groupingSets ||
    2746       15496 :         root->hasHavingQual ||
    2747       15496 :         parse->distinctClause ||
    2748       20534 :         parse->sortClause ||
    2749        5546 :         bms_membership(root->all_baserels) == BMS_MULTIPLE)
    2750       12536 :         tuple_fraction = 0.0;   /* default case */
    2751             :     else
    2752        4224 :         tuple_fraction = root->tuple_fraction;
    2753             : 
    2754             :     /* plan_params should not be in use in current query level */
    2755             :     Assert(root->plan_params == NIL);
    2756             : 
    2757             :     /* Generate a subroot and Paths for the subquery */
    2758       16760 :     plan_name = choose_plan_name(root->glob, rte->eref->aliasname, false);
    2759       16760 :     rel->subroot = subquery_planner(root->glob, subquery, plan_name,
    2760             :                                     root, false, tuple_fraction, NULL);
    2761             : 
    2762             :     /* Isolate the params needed by this specific subplan */
    2763       16760 :     rel->subplan_params = root->plan_params;
    2764       16760 :     root->plan_params = NIL;
    2765             : 
    2766             :     /*
    2767             :      * It's possible that constraint exclusion proved the subquery empty. If
    2768             :      * so, it's desirable to produce an unadorned dummy path so that we will
    2769             :      * recognize appropriate optimizations at this query level.
    2770             :      */
    2771       16760 :     sub_final_rel = fetch_upper_rel(rel->subroot, UPPERREL_FINAL, NULL);
    2772             : 
    2773       16760 :     if (IS_DUMMY_REL(sub_final_rel))
    2774             :     {
    2775         126 :         set_dummy_rel_pathlist(rel);
    2776         126 :         return;
    2777             :     }
    2778             : 
    2779             :     /*
    2780             :      * Mark rel with estimated output rows, width, etc.  Note that we have to
    2781             :      * do this before generating outer-query paths, else cost_subqueryscan is
    2782             :      * not happy.
    2783             :      */
    2784       16634 :     set_subquery_size_estimates(root, rel);
    2785             : 
    2786             :     /*
    2787             :      * Also detect whether the reltarget is trivial, so that we can pass that
    2788             :      * info to cost_subqueryscan (rather than re-deriving it multiple times).
    2789             :      * It's trivial if it fetches all the subplan output columns in order.
    2790             :      */
    2791       16634 :     if (list_length(rel->reltarget->exprs) != list_length(subquery->targetList))
    2792        7578 :         trivial_pathtarget = false;
    2793             :     else
    2794             :     {
    2795        9056 :         trivial_pathtarget = true;
    2796       28668 :         foreach(lc, rel->reltarget->exprs)
    2797             :         {
    2798       19910 :             Node       *node = (Node *) lfirst(lc);
    2799             :             Var        *var;
    2800             : 
    2801       19910 :             if (!IsA(node, Var))
    2802             :             {
    2803           0 :                 trivial_pathtarget = false;
    2804           0 :                 break;
    2805             :             }
    2806       19910 :             var = (Var *) node;
    2807       19910 :             if (var->varno != rti ||
    2808       19910 :                 var->varattno != foreach_current_index(lc) + 1)
    2809             :             {
    2810         298 :                 trivial_pathtarget = false;
    2811         298 :                 break;
    2812             :             }
    2813             :         }
    2814             :     }
    2815             : 
    2816             :     /*
    2817             :      * For each Path that subquery_planner produced, make a SubqueryScanPath
    2818             :      * in the outer query.
    2819             :      */
    2820       34044 :     foreach(lc, sub_final_rel->pathlist)
    2821             :     {
    2822       17410 :         Path       *subpath = (Path *) lfirst(lc);
    2823             :         List       *pathkeys;
    2824             : 
    2825             :         /* Convert subpath's pathkeys to outer representation */
    2826       17410 :         pathkeys = convert_subquery_pathkeys(root,
    2827             :                                              rel,
    2828             :                                              subpath->pathkeys,
    2829             :                                              make_tlist_from_pathtarget(subpath->pathtarget));
    2830             : 
    2831             :         /* Generate outer path using this subpath */
    2832       17410 :         add_path(rel, (Path *)
    2833       17410 :                  create_subqueryscan_path(root, rel, subpath,
    2834             :                                           trivial_pathtarget,
    2835             :                                           pathkeys, required_outer));
    2836             :     }
    2837             : 
    2838             :     /* If outer rel allows parallelism, do same for partial paths. */
    2839       16634 :     if (rel->consider_parallel && bms_is_empty(required_outer))
    2840             :     {
    2841             :         /* If consider_parallel is false, there should be no partial paths. */
    2842             :         Assert(sub_final_rel->consider_parallel ||
    2843             :                sub_final_rel->partial_pathlist == NIL);
    2844             : 
    2845             :         /* Same for partial paths. */
    2846       12458 :         foreach(lc, sub_final_rel->partial_pathlist)
    2847             :         {
    2848          42 :             Path       *subpath = (Path *) lfirst(lc);
    2849             :             List       *pathkeys;
    2850             : 
    2851             :             /* Convert subpath's pathkeys to outer representation */
    2852          42 :             pathkeys = convert_subquery_pathkeys(root,
    2853             :                                                  rel,
    2854             :                                                  subpath->pathkeys,
    2855             :                                                  make_tlist_from_pathtarget(subpath->pathtarget));
    2856             : 
    2857             :             /* Generate outer path using this subpath */
    2858          42 :             add_partial_path(rel, (Path *)
    2859          42 :                              create_subqueryscan_path(root, rel, subpath,
    2860             :                                                       trivial_pathtarget,
    2861             :                                                       pathkeys,
    2862             :                                                       required_outer));
    2863             :         }
    2864             :     }
    2865             : }
    2866             : 
    2867             : /*
    2868             :  * set_function_pathlist
    2869             :  *      Build the (single) access path for a function RTE
    2870             :  */
    2871             : static void
    2872       51268 : set_function_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
    2873             : {
    2874             :     Relids      required_outer;
    2875       51268 :     List       *pathkeys = NIL;
    2876             : 
    2877             :     /*
    2878             :      * We don't support pushing join clauses into the quals of a function
    2879             :      * scan, but it could still have required parameterization due to LATERAL
    2880             :      * refs in the function expression.
    2881             :      */
    2882       51268 :     required_outer = rel->lateral_relids;
    2883             : 
    2884             :     /*
    2885             :      * The result is considered unordered unless ORDINALITY was used, in which
    2886             :      * case it is ordered by the ordinal column (the last one).  See if we
    2887             :      * care, by checking for uses of that Var in equivalence classes.
    2888             :      */
    2889       51268 :     if (rte->funcordinality)
    2890             :     {
    2891         932 :         AttrNumber  ordattno = rel->max_attr;
    2892         932 :         Var        *var = NULL;
    2893             :         ListCell   *lc;
    2894             : 
    2895             :         /*
    2896             :          * Is there a Var for it in rel's targetlist?  If not, the query did
    2897             :          * not reference the ordinality column, or at least not in any way
    2898             :          * that would be interesting for sorting.
    2899             :          */
    2900        2116 :         foreach(lc, rel->reltarget->exprs)
    2901             :         {
    2902        2110 :             Var        *node = (Var *) lfirst(lc);
    2903             : 
    2904             :             /* checking varno/varlevelsup is just paranoia */
    2905        2110 :             if (IsA(node, Var) &&
    2906        2110 :                 node->varattno == ordattno &&
    2907         926 :                 node->varno == rel->relid &&
    2908         926 :                 node->varlevelsup == 0)
    2909             :             {
    2910         926 :                 var = node;
    2911         926 :                 break;
    2912             :             }
    2913             :         }
    2914             : 
    2915             :         /*
    2916             :          * Try to build pathkeys for this Var with int8 sorting.  We tell
    2917             :          * build_expression_pathkey not to build any new equivalence class; if
    2918             :          * the Var isn't already mentioned in some EC, it means that nothing
    2919             :          * cares about the ordering.
    2920             :          */
    2921         932 :         if (var)
    2922         926 :             pathkeys = build_expression_pathkey(root,
    2923             :                                                 (Expr *) var,
    2924             :                                                 Int8LessOperator,
    2925             :                                                 rel->relids,
    2926             :                                                 false);
    2927             :     }
    2928             : 
    2929             :     /* Generate appropriate path */
    2930       51268 :     add_path(rel, create_functionscan_path(root, rel,
    2931             :                                            pathkeys, required_outer));
    2932       51268 : }
    2933             : 
    2934             : /*
    2935             :  * set_values_pathlist
    2936             :  *      Build the (single) access path for a VALUES RTE
    2937             :  */
    2938             : static void
    2939        8264 : set_values_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
    2940             : {
    2941             :     Relids      required_outer;
    2942             : 
    2943             :     /*
    2944             :      * We don't support pushing join clauses into the quals of a values scan,
    2945             :      * but it could still have required parameterization due to LATERAL refs
    2946             :      * in the values expressions.
    2947             :      */
    2948        8264 :     required_outer = rel->lateral_relids;
    2949             : 
    2950             :     /* Generate appropriate path */
    2951        8264 :     add_path(rel, create_valuesscan_path(root, rel, required_outer));
    2952        8264 : }
    2953             : 
    2954             : /*
    2955             :  * set_tablefunc_pathlist
    2956             :  *      Build the (single) access path for a table func RTE
    2957             :  */
    2958             : static void
    2959         626 : set_tablefunc_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
    2960             : {
    2961             :     Relids      required_outer;
    2962             : 
    2963             :     /*
    2964             :      * We don't support pushing join clauses into the quals of a tablefunc
    2965             :      * scan, but it could still have required parameterization due to LATERAL
    2966             :      * refs in the function expression.
    2967             :      */
    2968         626 :     required_outer = rel->lateral_relids;
    2969             : 
    2970             :     /* Generate appropriate path */
    2971         626 :     add_path(rel, create_tablefuncscan_path(root, rel,
    2972             :                                             required_outer));
    2973         626 : }
    2974             : 
    2975             : /*
    2976             :  * set_cte_pathlist
    2977             :  *      Build the (single) access path for a non-self-reference CTE RTE
    2978             :  *
    2979             :  * There's no need for a separate set_cte_size phase, since we don't
    2980             :  * support join-qual-parameterized paths for CTEs.
    2981             :  */
    2982             : static void
    2983        4258 : set_cte_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
    2984             : {
    2985             :     Path       *ctepath;
    2986             :     Plan       *cteplan;
    2987             :     PlannerInfo *cteroot;
    2988             :     Index       levelsup;
    2989             :     List       *pathkeys;
    2990             :     int         ndx;
    2991             :     ListCell   *lc;
    2992             :     int         plan_id;
    2993             :     Relids      required_outer;
    2994             : 
    2995             :     /*
    2996             :      * Find the referenced CTE, and locate the path and plan previously made
    2997             :      * for it.
    2998             :      */
    2999        4258 :     levelsup = rte->ctelevelsup;
    3000        4258 :     cteroot = root;
    3001        7452 :     while (levelsup-- > 0)
    3002             :     {
    3003        3194 :         cteroot = cteroot->parent_root;
    3004        3194 :         if (!cteroot)           /* shouldn't happen */
    3005           0 :             elog(ERROR, "bad levelsup for CTE \"%s\"", rte->ctename);
    3006             :     }
    3007             : 
    3008             :     /*
    3009             :      * Note: cte_plan_ids can be shorter than cteList, if we are still working
    3010             :      * on planning the CTEs (ie, this is a side-reference from another CTE).
    3011             :      * So we mustn't use forboth here.
    3012             :      */
    3013        4258 :     ndx = 0;
    3014        5910 :     foreach(lc, cteroot->parse->cteList)
    3015             :     {
    3016        5910 :         CommonTableExpr *cte = (CommonTableExpr *) lfirst(lc);
    3017             : 
    3018        5910 :         if (strcmp(cte->ctename, rte->ctename) == 0)
    3019        4258 :             break;
    3020        1652 :         ndx++;
    3021             :     }
    3022        4258 :     if (lc == NULL)             /* shouldn't happen */
    3023           0 :         elog(ERROR, "could not find CTE \"%s\"", rte->ctename);
    3024        4258 :     if (ndx >= list_length(cteroot->cte_plan_ids))
    3025           0 :         elog(ERROR, "could not find plan for CTE \"%s\"", rte->ctename);
    3026        4258 :     plan_id = list_nth_int(cteroot->cte_plan_ids, ndx);
    3027        4258 :     if (plan_id <= 0)
    3028           0 :         elog(ERROR, "no plan was made for CTE \"%s\"", rte->ctename);
    3029             : 
    3030             :     Assert(list_length(root->glob->subpaths) == list_length(root->glob->subplans));
    3031        4258 :     ctepath = (Path *) list_nth(root->glob->subpaths, plan_id - 1);
    3032        4258 :     cteplan = (Plan *) list_nth(root->glob->subplans, plan_id - 1);
    3033             : 
    3034             :     /* Mark rel with estimated output rows, width, etc */
    3035        4258 :     set_cte_size_estimates(root, rel, cteplan->plan_rows);
    3036             : 
    3037             :     /* Convert the ctepath's pathkeys to outer query's representation */
    3038        4258 :     pathkeys = convert_subquery_pathkeys(root,
    3039             :                                          rel,
    3040             :                                          ctepath->pathkeys,
    3041             :                                          cteplan->targetlist);
    3042             : 
    3043             :     /*
    3044             :      * We don't support pushing join clauses into the quals of a CTE scan, but
    3045             :      * it could still have required parameterization due to LATERAL refs in
    3046             :      * its tlist.
    3047             :      */
    3048        4258 :     required_outer = rel->lateral_relids;
    3049             : 
    3050             :     /* Generate appropriate path */
    3051        4258 :     add_path(rel, create_ctescan_path(root, rel, pathkeys, required_outer));
    3052        4258 : }
    3053             : 
    3054             : /*
    3055             :  * set_namedtuplestore_pathlist
    3056             :  *      Build the (single) access path for a named tuplestore RTE
    3057             :  *
    3058             :  * There's no need for a separate set_namedtuplestore_size phase, since we
    3059             :  * don't support join-qual-parameterized paths for tuplestores.
    3060             :  */
    3061             : static void
    3062         478 : set_namedtuplestore_pathlist(PlannerInfo *root, RelOptInfo *rel,
    3063             :                              RangeTblEntry *rte)
    3064             : {
    3065             :     Relids      required_outer;
    3066             : 
    3067             :     /* Mark rel with estimated output rows, width, etc */
    3068         478 :     set_namedtuplestore_size_estimates(root, rel);
    3069             : 
    3070             :     /*
    3071             :      * We don't support pushing join clauses into the quals of a tuplestore
    3072             :      * scan, but it could still have required parameterization due to LATERAL
    3073             :      * refs in its tlist.
    3074             :      */
    3075         478 :     required_outer = rel->lateral_relids;
    3076             : 
    3077             :     /* Generate appropriate path */
    3078         478 :     add_path(rel, create_namedtuplestorescan_path(root, rel, required_outer));
    3079         478 : }
    3080             : 
    3081             : /*
    3082             :  * set_result_pathlist
    3083             :  *      Build the (single) access path for an RTE_RESULT RTE
    3084             :  *
    3085             :  * There's no need for a separate set_result_size phase, since we
    3086             :  * don't support join-qual-parameterized paths for these RTEs.
    3087             :  */
    3088             : static void
    3089        4208 : set_result_pathlist(PlannerInfo *root, RelOptInfo *rel,
    3090             :                     RangeTblEntry *rte)
    3091             : {
    3092             :     Relids      required_outer;
    3093             : 
    3094             :     /* Mark rel with estimated output rows, width, etc */
    3095        4208 :     set_result_size_estimates(root, rel);
    3096             : 
    3097             :     /*
    3098             :      * We don't support pushing join clauses into the quals of a Result scan,
    3099             :      * but it could still have required parameterization due to LATERAL refs
    3100             :      * in its tlist.
    3101             :      */
    3102        4208 :     required_outer = rel->lateral_relids;
    3103             : 
    3104             :     /* Generate appropriate path */
    3105        4208 :     add_path(rel, create_resultscan_path(root, rel, required_outer));
    3106        4208 : }
    3107             : 
    3108             : /*
    3109             :  * set_worktable_pathlist
    3110             :  *      Build the (single) access path for a self-reference CTE RTE
    3111             :  *
    3112             :  * There's no need for a separate set_worktable_size phase, since we don't
    3113             :  * support join-qual-parameterized paths for CTEs.
    3114             :  */
    3115             : static void
    3116         932 : set_worktable_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
    3117             : {
    3118             :     Path       *ctepath;
    3119             :     PlannerInfo *cteroot;
    3120             :     Index       levelsup;
    3121             :     Relids      required_outer;
    3122             : 
    3123             :     /*
    3124             :      * We need to find the non-recursive term's path, which is in the plan
    3125             :      * level that's processing the recursive UNION, which is one level *below*
    3126             :      * where the CTE comes from.
    3127             :      */
    3128         932 :     levelsup = rte->ctelevelsup;
    3129         932 :     if (levelsup == 0)          /* shouldn't happen */
    3130           0 :         elog(ERROR, "bad levelsup for CTE \"%s\"", rte->ctename);
    3131         932 :     levelsup--;
    3132         932 :     cteroot = root;
    3133        2276 :     while (levelsup-- > 0)
    3134             :     {
    3135        1344 :         cteroot = cteroot->parent_root;
    3136        1344 :         if (!cteroot)           /* shouldn't happen */
    3137           0 :             elog(ERROR, "bad levelsup for CTE \"%s\"", rte->ctename);
    3138             :     }
    3139         932 :     ctepath = cteroot->non_recursive_path;
    3140         932 :     if (!ctepath)               /* shouldn't happen */
    3141           0 :         elog(ERROR, "could not find path for CTE \"%s\"", rte->ctename);
    3142             : 
    3143             :     /* Mark rel with estimated output rows, width, etc */
    3144         932 :     set_cte_size_estimates(root, rel, ctepath->rows);
    3145             : 
    3146             :     /*
    3147             :      * We don't support pushing join clauses into the quals of a worktable
    3148             :      * scan, but it could still have required parameterization due to LATERAL
    3149             :      * refs in its tlist.  (I'm not sure this is actually possible given the
    3150             :      * restrictions on recursive references, but it's easy enough to support.)
    3151             :      */
    3152         932 :     required_outer = rel->lateral_relids;
    3153             : 
    3154             :     /* Generate appropriate path */
    3155         932 :     add_path(rel, create_worktablescan_path(root, rel, required_outer));
    3156         932 : }
    3157             : 
    3158             : /*
    3159             :  * generate_gather_paths
    3160             :  *      Generate parallel access paths for a relation by pushing a Gather or
    3161             :  *      Gather Merge on top of a partial path.
    3162             :  *
    3163             :  * This must not be called until after we're done creating all partial paths
    3164             :  * for the specified relation.  (Otherwise, add_partial_path might delete a
    3165             :  * path that some GatherPath or GatherMergePath has a reference to.)
    3166             :  *
    3167             :  * If we're generating paths for a scan or join relation, override_rows will
    3168             :  * be false, and we'll just use the relation's size estimate.  When we're
    3169             :  * being called for a partially-grouped or partially-distinct path, though, we
    3170             :  * need to override the rowcount estimate.  (It's not clear that the
    3171             :  * particular value we're using here is actually best, but the underlying rel
    3172             :  * has no estimate so we must do something.)
    3173             :  */
    3174             : void
    3175       24456 : generate_gather_paths(PlannerInfo *root, RelOptInfo *rel, bool override_rows)
    3176             : {
    3177             :     Path       *cheapest_partial_path;
    3178             :     Path       *simple_gather_path;
    3179             :     ListCell   *lc;
    3180             :     double      rows;
    3181       24456 :     double     *rowsp = NULL;
    3182             : 
    3183             :     /* If there are no partial paths, there's nothing to do here. */
    3184       24456 :     if (rel->partial_pathlist == NIL)
    3185           0 :         return;
    3186             : 
    3187             :     /* Should we override the rel's rowcount estimate? */
    3188       24456 :     if (override_rows)
    3189        6084 :         rowsp = &rows;
    3190             : 
    3191             :     /*
    3192             :      * The output of Gather is always unsorted, so there's only one partial
    3193             :      * path of interest: the cheapest one.  That will be the one at the front
    3194             :      * of partial_pathlist because of the way add_partial_path works.
    3195             :      */
    3196       24456 :     cheapest_partial_path = linitial(rel->partial_pathlist);
    3197       24456 :     rows = compute_gather_rows(cheapest_partial_path);
    3198             :     simple_gather_path = (Path *)
    3199       24456 :         create_gather_path(root, rel, cheapest_partial_path, rel->reltarget,
    3200             :                            NULL, rowsp);
    3201       24456 :     add_path(rel, simple_gather_path);
    3202             : 
    3203             :     /*
    3204             :      * For each useful ordering, we can consider an order-preserving Gather
    3205             :      * Merge.
    3206             :      */
    3207       54246 :     foreach(lc, rel->partial_pathlist)
    3208             :     {
    3209       29790 :         Path       *subpath = (Path *) lfirst(lc);
    3210             :         GatherMergePath *path;
    3211             : 
    3212       29790 :         if (subpath->pathkeys == NIL)
    3213       23742 :             continue;
    3214             : 
    3215        6048 :         rows = compute_gather_rows(subpath);
    3216        6048 :         path = create_gather_merge_path(root, rel, subpath, rel->reltarget,
    3217             :                                         subpath->pathkeys, NULL, rowsp);
    3218        6048 :         add_path(rel, &path->path);
    3219             :     }
    3220             : }
    3221             : 
    3222             : /*
    3223             :  * get_useful_pathkeys_for_relation
    3224             :  *      Determine which orderings of a relation might be useful.
    3225             :  *
    3226             :  * Getting data in sorted order can be useful either because the requested
    3227             :  * order matches the final output ordering for the overall query we're
    3228             :  * planning, or because it enables an efficient merge join.  Here, we try
    3229             :  * to figure out which pathkeys to consider.
    3230             :  *
    3231             :  * This allows us to do incremental sort on top of an index scan under a gather
    3232             :  * merge node, i.e. parallelized.
    3233             :  *
    3234             :  * If the require_parallel_safe is true, we also require the expressions to
    3235             :  * be parallel safe (which allows pushing the sort below Gather Merge).
    3236             :  *
    3237             :  * XXX At the moment this can only ever return a list with a single element,
    3238             :  * because it looks at query_pathkeys only. So we might return the pathkeys
    3239             :  * directly, but it seems plausible we'll want to consider other orderings
    3240             :  * in the future. For example, we might want to consider pathkeys useful for
    3241             :  * merge joins.
    3242             :  */
    3243             : static List *
    3244       24456 : get_useful_pathkeys_for_relation(PlannerInfo *root, RelOptInfo *rel,
    3245             :                                  bool require_parallel_safe)
    3246             : {
    3247       24456 :     List       *useful_pathkeys_list = NIL;
    3248             : 
    3249             :     /*
    3250             :      * Considering query_pathkeys is always worth it, because it might allow
    3251             :      * us to avoid a total sort when we have a partially presorted path
    3252             :      * available or to push the total sort into the parallel portion of the
    3253             :      * query.
    3254             :      */
    3255       24456 :     if (root->query_pathkeys)
    3256             :     {
    3257             :         ListCell   *lc;
    3258       14940 :         int         npathkeys = 0;  /* useful pathkeys */
    3259             : 
    3260       26078 :         foreach(lc, root->query_pathkeys)
    3261             :         {
    3262       18868 :             PathKey    *pathkey = (PathKey *) lfirst(lc);
    3263       18868 :             EquivalenceClass *pathkey_ec = pathkey->pk_eclass;
    3264             : 
    3265             :             /*
    3266             :              * We can only build a sort for pathkeys that contain a
    3267             :              * safe-to-compute-early EC member computable from the current
    3268             :              * relation's reltarget, so ignore the remainder of the list as
    3269             :              * soon as we find a pathkey without such a member.
    3270             :              *
    3271             :              * It's still worthwhile to return any prefix of the pathkeys list
    3272             :              * that meets this requirement, as we may be able to do an
    3273             :              * incremental sort.
    3274             :              *
    3275             :              * If requested, ensure the sort expression is parallel-safe too.
    3276             :              */
    3277       18868 :             if (!relation_can_be_sorted_early(root, rel, pathkey_ec,
    3278             :                                               require_parallel_safe))
    3279        7730 :                 break;
    3280             : 
    3281       11138 :             npathkeys++;
    3282             :         }
    3283             : 
    3284             :         /*
    3285             :          * The whole query_pathkeys list matches, so append it directly, to
    3286             :          * allow comparing pathkeys easily by comparing list pointer. If we
    3287             :          * have to truncate the pathkeys, we gotta do a copy though.
    3288             :          */
    3289       14940 :         if (npathkeys == list_length(root->query_pathkeys))
    3290        7210 :             useful_pathkeys_list = lappend(useful_pathkeys_list,
    3291        7210 :                                            root->query_pathkeys);
    3292        7730 :         else if (npathkeys > 0)
    3293         474 :             useful_pathkeys_list = lappend(useful_pathkeys_list,
    3294         474 :                                            list_copy_head(root->query_pathkeys,
    3295             :                                                           npathkeys));
    3296             :     }
    3297             : 
    3298       24456 :     return useful_pathkeys_list;
    3299             : }
    3300             : 
    3301             : /*
    3302             :  * generate_useful_gather_paths
    3303             :  *      Generate parallel access paths for a relation by pushing a Gather or
    3304             :  *      Gather Merge on top of a partial path.
    3305             :  *
    3306             :  * Unlike plain generate_gather_paths, this looks both at pathkeys of input
    3307             :  * paths (aiming to preserve the ordering), but also considers ordering that
    3308             :  * might be useful for nodes above the gather merge node, and tries to add
    3309             :  * a sort (regular or incremental) to provide that.
    3310             :  */
    3311             : void
    3312      612466 : generate_useful_gather_paths(PlannerInfo *root, RelOptInfo *rel, bool override_rows)
    3313             : {
    3314             :     ListCell   *lc;
    3315             :     double      rows;
    3316      612466 :     double     *rowsp = NULL;
    3317      612466 :     List       *useful_pathkeys_list = NIL;
    3318      612466 :     Path       *cheapest_partial_path = NULL;
    3319             : 
    3320             :     /* If there are no partial paths, there's nothing to do here. */
    3321      612466 :     if (rel->partial_pathlist == NIL)
    3322      588010 :         return;
    3323             : 
    3324             :     /* Should we override the rel's rowcount estimate? */
    3325       24456 :     if (override_rows)
    3326        6084 :         rowsp = &rows;
    3327             : 
    3328             :     /* generate the regular gather (merge) paths */
    3329       24456 :     generate_gather_paths(root, rel, override_rows);
    3330             : 
    3331             :     /* consider incremental sort for interesting orderings */
    3332       24456 :     useful_pathkeys_list = get_useful_pathkeys_for_relation(root, rel, true);
    3333             : 
    3334             :     /* used for explicit (full) sort paths */
    3335       24456 :     cheapest_partial_path = linitial(rel->partial_pathlist);
    3336             : 
    3337             :     /*
    3338             :      * Consider sorted paths for each interesting ordering. We generate both
    3339             :      * incremental and full sort.
    3340             :      */
    3341       32140 :     foreach(lc, useful_pathkeys_list)
    3342             :     {
    3343        7684 :         List       *useful_pathkeys = lfirst(lc);
    3344             :         ListCell   *lc2;
    3345             :         bool        is_sorted;
    3346             :         int         presorted_keys;
    3347             : 
    3348       17500 :         foreach(lc2, rel->partial_pathlist)
    3349             :         {
    3350        9816 :             Path       *subpath = (Path *) lfirst(lc2);
    3351             :             GatherMergePath *path;
    3352             : 
    3353        9816 :             is_sorted = pathkeys_count_contained_in(useful_pathkeys,
    3354             :                                                     subpath->pathkeys,
    3355             :                                                     &presorted_keys);
    3356             : 
    3357             :             /*
    3358             :              * We don't need to consider the case where a subpath is already
    3359             :              * fully sorted because generate_gather_paths already creates a
    3360             :              * gather merge path for every subpath that has pathkeys present.
    3361             :              *
    3362             :              * But since the subpath is already sorted, we know we don't need
    3363             :              * to consider adding a sort (full or incremental) on top of it,
    3364             :              * so we can continue here.
    3365             :              */
    3366        9816 :             if (is_sorted)
    3367        2398 :                 continue;
    3368             : 
    3369             :             /*
    3370             :              * Try at least sorting the cheapest path and also try
    3371             :              * incrementally sorting any path which is partially sorted
    3372             :              * already (no need to deal with paths which have presorted keys
    3373             :              * when incremental sort is disabled unless it's the cheapest
    3374             :              * input path).
    3375             :              */
    3376        7418 :             if (subpath != cheapest_partial_path &&
    3377         246 :                 (presorted_keys == 0 || !enable_incremental_sort))
    3378         102 :                 continue;
    3379             : 
    3380             :             /*
    3381             :              * Consider regular sort for any path that's not presorted or if
    3382             :              * incremental sort is disabled.  We've no need to consider both
    3383             :              * sort and incremental sort on the same path.  We assume that
    3384             :              * incremental sort is always faster when there are presorted
    3385             :              * keys.
    3386             :              *
    3387             :              * This is not redundant with the gather paths created in
    3388             :              * generate_gather_paths, because that doesn't generate ordered
    3389             :              * output. Here we add an explicit sort to match the useful
    3390             :              * ordering.
    3391             :              */
    3392        7316 :             if (presorted_keys == 0 || !enable_incremental_sort)
    3393             :             {
    3394        7160 :                 subpath = (Path *) create_sort_path(root,
    3395             :                                                     rel,
    3396             :                                                     subpath,
    3397             :                                                     useful_pathkeys,
    3398             :                                                     -1.0);
    3399             :             }
    3400             :             else
    3401         156 :                 subpath = (Path *) create_incremental_sort_path(root,
    3402             :                                                                 rel,
    3403             :                                                                 subpath,
    3404             :                                                                 useful_pathkeys,
    3405             :                                                                 presorted_keys,
    3406             :                                                                 -1);
    3407        7316 :             rows = compute_gather_rows(subpath);
    3408        7316 :             path = create_gather_merge_path(root, rel,
    3409             :                                             subpath,
    3410        7316 :                                             rel->reltarget,
    3411             :                                             subpath->pathkeys,
    3412             :                                             NULL,
    3413             :                                             rowsp);
    3414             : 
    3415        7316 :             add_path(rel, &path->path);
    3416             :         }
    3417             :     }
    3418             : }
    3419             : 
    3420             : /*
    3421             :  * generate_grouped_paths
    3422             :  *      Generate paths for a grouped relation by adding sorted and hashed
    3423             :  *      partial aggregation paths on top of paths of the ungrouped relation.
    3424             :  *
    3425             :  * The information needed is provided by the RelAggInfo structure stored in
    3426             :  * "grouped_rel".
    3427             :  */
    3428             : void
    3429         898 : generate_grouped_paths(PlannerInfo *root, RelOptInfo *grouped_rel,
    3430             :                        RelOptInfo *rel)
    3431             : {
    3432         898 :     RelAggInfo *agg_info = grouped_rel->agg_info;
    3433             :     AggClauseCosts agg_costs;
    3434             :     bool        can_hash;
    3435             :     bool        can_sort;
    3436         898 :     Path       *cheapest_total_path = NULL;
    3437         898 :     Path       *cheapest_partial_path = NULL;
    3438         898 :     double      dNumGroups = 0;
    3439         898 :     double      dNumPartialGroups = 0;
    3440         898 :     List       *group_pathkeys = NIL;
    3441             : 
    3442         898 :     if (IS_DUMMY_REL(rel))
    3443             :     {
    3444           0 :         mark_dummy_rel(grouped_rel);
    3445           0 :         return;
    3446             :     }
    3447             : 
    3448             :     /*
    3449             :      * We push partial aggregation only to the lowest possible level in the
    3450             :      * join tree that is deemed useful.
    3451             :      */
    3452         898 :     if (!bms_equal(agg_info->apply_at, rel->relids) ||
    3453         898 :         !agg_info->agg_useful)
    3454           0 :         return;
    3455             : 
    3456        5388 :     MemSet(&agg_costs, 0, sizeof(AggClauseCosts));
    3457         898 :     get_agg_clause_costs(root, AGGSPLIT_INITIAL_SERIAL, &agg_costs);
    3458             : 
    3459             :     /*
    3460             :      * Determine whether it's possible to perform sort-based implementations
    3461             :      * of grouping, and generate the pathkeys that represent the grouping
    3462             :      * requirements in that case.
    3463             :      */
    3464         898 :     can_sort = grouping_is_sortable(agg_info->group_clauses);
    3465         898 :     if (can_sort)
    3466             :     {
    3467             :         RelOptInfo *top_grouped_rel;
    3468             :         List       *top_group_tlist;
    3469             : 
    3470         502 :         top_grouped_rel = IS_OTHER_REL(rel) ?
    3471        1400 :             rel->top_parent->grouped_rel : grouped_rel;
    3472             :         top_group_tlist =
    3473         898 :             make_tlist_from_pathtarget(top_grouped_rel->agg_info->target);
    3474             : 
    3475             :         group_pathkeys =
    3476         898 :             make_pathkeys_for_sortclauses(root, agg_info->group_clauses,
    3477             :                                           top_group_tlist);
    3478             :     }
    3479             : 
    3480             :     /*
    3481             :      * Determine whether we should consider hash-based implementations of
    3482             :      * grouping.
    3483             :      */
    3484             :     Assert(root->numOrderedAggs == 0);
    3485        1796 :     can_hash = (agg_info->group_clauses != NIL &&
    3486         898 :                 grouping_is_hashable(agg_info->group_clauses));
    3487             : 
    3488             :     /*
    3489             :      * Consider whether we should generate partially aggregated non-partial
    3490             :      * paths.  We can only do this if we have a non-partial path.
    3491             :      */
    3492         898 :     if (rel->pathlist != NIL)
    3493             :     {
    3494         898 :         cheapest_total_path = rel->cheapest_total_path;
    3495             :         Assert(cheapest_total_path != NULL);
    3496             :     }
    3497             : 
    3498             :     /*
    3499             :      * If parallelism is possible for grouped_rel, then we should consider
    3500             :      * generating partially-grouped partial paths.  However, if the ungrouped
    3501             :      * rel has no partial paths, then we can't.
    3502             :      */
    3503         898 :     if (grouped_rel->consider_parallel && rel->partial_pathlist != NIL)
    3504             :     {
    3505         732 :         cheapest_partial_path = linitial(rel->partial_pathlist);
    3506             :         Assert(cheapest_partial_path != NULL);
    3507             :     }
    3508             : 
    3509             :     /* Estimate number of partial groups. */
    3510         898 :     if (cheapest_total_path != NULL)
    3511         898 :         dNumGroups = estimate_num_groups(root,
    3512             :                                          agg_info->group_exprs,
    3513             :                                          cheapest_total_path->rows,
    3514             :                                          NULL, NULL);
    3515         898 :     if (cheapest_partial_path != NULL)
    3516         732 :         dNumPartialGroups = estimate_num_groups(root,
    3517             :                                                 agg_info->group_exprs,
    3518             :                                                 cheapest_partial_path->rows,
    3519             :                                                 NULL, NULL);
    3520             : 
    3521         898 :     if (can_sort && cheapest_total_path != NULL)
    3522             :     {
    3523             :         ListCell   *lc;
    3524             : 
    3525             :         /*
    3526             :          * Use any available suitably-sorted path as input, and also consider
    3527             :          * sorting the cheapest-total path and incremental sort on any paths
    3528             :          * with presorted keys.
    3529             :          *
    3530             :          * To save planning time, we ignore parameterized input paths unless
    3531             :          * they are the cheapest-total path.
    3532             :          */
    3533        2174 :         foreach(lc, rel->pathlist)
    3534             :         {
    3535        1276 :             Path       *input_path = (Path *) lfirst(lc);
    3536             :             Path       *path;
    3537             :             bool        is_sorted;
    3538             :             int         presorted_keys;
    3539             : 
    3540             :             /*
    3541             :              * Ignore parameterized paths that are not the cheapest-total
    3542             :              * path.
    3543             :              */
    3544        1276 :             if (input_path->param_info &&
    3545             :                 input_path != cheapest_total_path)
    3546          30 :                 continue;
    3547             : 
    3548        1270 :             is_sorted = pathkeys_count_contained_in(group_pathkeys,
    3549             :                                                     input_path->pathkeys,
    3550             :                                                     &presorted_keys);
    3551             : 
    3552             :             /*
    3553             :              * Ignore paths that are not suitably or partially sorted, unless
    3554             :              * they are the cheapest total path (no need to deal with paths
    3555             :              * which have presorted keys when incremental sort is disabled).
    3556             :              */
    3557        1270 :             if (!is_sorted && input_path != cheapest_total_path &&
    3558         168 :                 (presorted_keys == 0 || !enable_incremental_sort))
    3559          24 :                 continue;
    3560             : 
    3561             :             /*
    3562             :              * Since the path originates from a non-grouped relation that is
    3563             :              * not aware of eager aggregation, we must ensure that it provides
    3564             :              * the correct input for partial aggregation.
    3565             :              */
    3566        1246 :             path = (Path *) create_projection_path(root,
    3567             :                                                    grouped_rel,
    3568             :                                                    input_path,
    3569        1246 :                                                    agg_info->agg_input);
    3570             : 
    3571        1246 :             if (!is_sorted)
    3572             :             {
    3573             :                 /*
    3574             :                  * We've no need to consider both a sort and incremental sort.
    3575             :                  * We'll just do a sort if there are no presorted keys and an
    3576             :                  * incremental sort when there are presorted keys.
    3577             :                  */
    3578        1036 :                 if (presorted_keys == 0 || !enable_incremental_sort)
    3579         892 :                     path = (Path *) create_sort_path(root,
    3580             :                                                      grouped_rel,
    3581             :                                                      path,
    3582             :                                                      group_pathkeys,
    3583             :                                                      -1.0);
    3584             :                 else
    3585         144 :                     path = (Path *) create_incremental_sort_path(root,
    3586             :                                                                  grouped_rel,
    3587             :                                                                  path,
    3588             :                                                                  group_pathkeys,
    3589             :                                                                  presorted_keys,
    3590             :                                                                  -1.0);
    3591             :             }
    3592             : 
    3593             :             /*
    3594             :              * qual is NIL because the HAVING clause cannot be evaluated until
    3595             :              * the final value of the aggregate is known.
    3596             :              */
    3597        1246 :             path = (Path *) create_agg_path(root,
    3598             :                                             grouped_rel,
    3599             :                                             path,
    3600        1246 :                                             agg_info->target,
    3601             :                                             AGG_SORTED,
    3602             :                                             AGGSPLIT_INITIAL_SERIAL,
    3603             :                                             agg_info->group_clauses,
    3604             :                                             NIL,
    3605             :                                             &agg_costs,
    3606             :                                             dNumGroups);
    3607             : 
    3608        1246 :             add_path(grouped_rel, path);
    3609             :         }
    3610             :     }
    3611             : 
    3612         898 :     if (can_sort && cheapest_partial_path != NULL)
    3613             :     {
    3614             :         ListCell   *lc;
    3615             : 
    3616             :         /* Similar to above logic, but for partial paths. */
    3617        1704 :         foreach(lc, rel->partial_pathlist)
    3618             :         {
    3619         972 :             Path       *input_path = (Path *) lfirst(lc);
    3620             :             Path       *path;
    3621             :             bool        is_sorted;
    3622             :             int         presorted_keys;
    3623             : 
    3624         972 :             is_sorted = pathkeys_count_contained_in(group_pathkeys,
    3625             :                                                     input_path->pathkeys,
    3626             :                                                     &presorted_keys);
    3627             : 
    3628             :             /*
    3629             :              * Ignore paths that are not suitably or partially sorted, unless
    3630             :              * they are the cheapest partial path (no need to deal with paths
    3631             :              * which have presorted keys when incremental sort is disabled).
    3632             :              */
    3633         972 :             if (!is_sorted && input_path != cheapest_partial_path &&
    3634          96 :                 (presorted_keys == 0 || !enable_incremental_sort))
    3635           0 :                 continue;
    3636             : 
    3637             :             /*
    3638             :              * Since the path originates from a non-grouped relation that is
    3639             :              * not aware of eager aggregation, we must ensure that it provides
    3640             :              * the correct input for partial aggregation.
    3641             :              */
    3642         972 :             path = (Path *) create_projection_path(root,
    3643             :                                                    grouped_rel,
    3644             :                                                    input_path,
    3645         972 :                                                    agg_info->agg_input);
    3646             : 
    3647         972 :             if (!is_sorted)
    3648             :             {
    3649             :                 /*
    3650             :                  * We've no need to consider both a sort and incremental sort.
    3651             :                  * We'll just do a sort if there are no presorted keys and an
    3652             :                  * incremental sort when there are presorted keys.
    3653             :                  */
    3654         828 :                 if (presorted_keys == 0 || !enable_incremental_sort)
    3655         732 :                     path = (Path *) create_sort_path(root,
    3656             :                                                      grouped_rel,
    3657             :                                                      path,
    3658             :                                                      group_pathkeys,
    3659             :                                                      -1.0);
    3660             :                 else
    3661          96 :                     path = (Path *) create_incremental_sort_path(root,
    3662             :                                                                  grouped_rel,
    3663             :                                                                  path,
    3664             :                                                                  group_pathkeys,
    3665             :                                                                  presorted_keys,
    3666             :                                                                  -1.0);
    3667             :             }
    3668             : 
    3669             :             /*
    3670             :              * qual is NIL because the HAVING clause cannot be evaluated until
    3671             :              * the final value of the aggregate is known.
    3672             :              */
    3673         972 :             path = (Path *) create_agg_path(root,
    3674             :                                             grouped_rel,
    3675             :                                             path,
    3676         972 :                                             agg_info->target,
    3677             :                                             AGG_SORTED,
    3678             :                                             AGGSPLIT_INITIAL_SERIAL,
    3679             :                                             agg_info->group_clauses,
    3680             :                                             NIL,
    3681             :                                             &agg_costs,
    3682             :                                             dNumPartialGroups);
    3683             : 
    3684         972 :             add_partial_path(grouped_rel, path);
    3685             :         }
    3686             :     }
    3687             : 
    3688             :     /*
    3689             :      * Add a partially-grouped HashAgg Path where possible
    3690             :      */
    3691         898 :     if (can_hash && cheapest_total_path != NULL)
    3692             :     {
    3693             :         Path       *path;
    3694             : 
    3695             :         /*
    3696             :          * Since the path originates from a non-grouped relation that is not
    3697             :          * aware of eager aggregation, we must ensure that it provides the
    3698             :          * correct input for partial aggregation.
    3699             :          */
    3700         898 :         path = (Path *) create_projection_path(root,
    3701             :                                                grouped_rel,
    3702             :                                                cheapest_total_path,
    3703         898 :                                                agg_info->agg_input);
    3704             : 
    3705             :         /*
    3706             :          * qual is NIL because the HAVING clause cannot be evaluated until the
    3707             :          * final value of the aggregate is known.
    3708             :          */
    3709         898 :         path = (Path *) create_agg_path(root,
    3710             :                                         grouped_rel,
    3711             :                                         path,
    3712         898 :                                         agg_info->target,
    3713             :                                         AGG_HASHED,
    3714             :                                         AGGSPLIT_INITIAL_SERIAL,
    3715             :                                         agg_info->group_clauses,
    3716             :                                         NIL,
    3717             :                                         &agg_costs,
    3718             :                                         dNumGroups);
    3719             : 
    3720         898 :         add_path(grouped_rel, path);
    3721             :     }
    3722             : 
    3723             :     /*
    3724             :      * Now add a partially-grouped HashAgg partial Path where possible
    3725             :      */
    3726         898 :     if (can_hash && cheapest_partial_path != NULL)
    3727             :     {
    3728             :         Path       *path;
    3729             : 
    3730             :         /*
    3731             :          * Since the path originates from a non-grouped relation that is not
    3732             :          * aware of eager aggregation, we must ensure that it provides the
    3733             :          * correct input for partial aggregation.
    3734             :          */
    3735         732 :         path = (Path *) create_projection_path(root,
    3736             :                                                grouped_rel,
    3737             :                                                cheapest_partial_path,
    3738         732 :                                                agg_info->agg_input);
    3739             : 
    3740             :         /*
    3741             :          * qual is NIL because the HAVING clause cannot be evaluated until the
    3742             :          * final value of the aggregate is known.
    3743             :          */
    3744         732 :         path = (Path *) create_agg_path(root,
    3745             :                                         grouped_rel,
    3746             :                                         path,
    3747         732 :                                         agg_info->target,
    3748             :                                         AGG_HASHED,
    3749             :                                         AGGSPLIT_INITIAL_SERIAL,
    3750             :                                         agg_info->group_clauses,
    3751             :                                         NIL,
    3752             :                                         &agg_costs,
    3753             :                                         dNumPartialGroups);
    3754             : 
    3755         732 :         add_partial_path(grouped_rel, path);
    3756             :     }
    3757             : }
    3758             : 
    3759             : /*
    3760             :  * make_rel_from_joinlist
    3761             :  *    Build access paths using a "joinlist" to guide the join path search.
    3762             :  *
    3763             :  * See comments for deconstruct_jointree() for definition of the joinlist
    3764             :  * data structure.
    3765             :  */
    3766             : static RelOptInfo *
    3767      328710 : make_rel_from_joinlist(PlannerInfo *root, List *joinlist)
    3768             : {
    3769             :     int         levels_needed;
    3770             :     List       *initial_rels;
    3771             :     ListCell   *jl;
    3772             : 
    3773             :     /*
    3774             :      * Count the number of child joinlist nodes.  This is the depth of the
    3775             :      * dynamic-programming algorithm we must employ to consider all ways of
    3776             :      * joining the child nodes.
    3777             :      */
    3778      328710 :     levels_needed = list_length(joinlist);
    3779             : 
    3780      328710 :     if (levels_needed <= 0)
    3781           0 :         return NULL;            /* nothing to do? */
    3782             : 
    3783             :     /*
    3784             :      * Construct a list of rels corresponding to the child joinlist nodes.
    3785             :      * This may contain both base rels and rels constructed according to
    3786             :      * sub-joinlists.
    3787             :      */
    3788      328710 :     initial_rels = NIL;
    3789      795340 :     foreach(jl, joinlist)
    3790             :     {
    3791      466630 :         Node       *jlnode = (Node *) lfirst(jl);
    3792             :         RelOptInfo *thisrel;
    3793             : 
    3794      466630 :         if (IsA(jlnode, RangeTblRef))
    3795             :         {
    3796      463252 :             int         varno = ((RangeTblRef *) jlnode)->rtindex;
    3797             : 
    3798      463252 :             thisrel = find_base_rel(root, varno);
    3799             :         }
    3800        3378 :         else if (IsA(jlnode, List))
    3801             :         {
    3802             :             /* Recurse to handle subproblem */
    3803        3378 :             thisrel = make_rel_from_joinlist(root, (List *) jlnode);
    3804             :         }
    3805             :         else
    3806             :         {
    3807           0 :             elog(ERROR, "unrecognized joinlist node type: %d",
    3808             :                  (int) nodeTag(jlnode));
    3809             :             thisrel = NULL;     /* keep compiler quiet */
    3810             :         }
    3811             : 
    3812      466630 :         initial_rels = lappend(initial_rels, thisrel);
    3813             :     }
    3814             : 
    3815      328710 :     if (levels_needed == 1)
    3816             :     {
    3817             :         /*
    3818             :          * Single joinlist node, so we're done.
    3819             :          */
    3820      227734 :         return (RelOptInfo *) linitial(initial_rels);
    3821             :     }
    3822             :     else
    3823             :     {
    3824             :         /*
    3825             :          * Consider the different orders in which we could join the rels,
    3826             :          * using a plugin, GEQO, or the regular join search code.
    3827             :          *
    3828             :          * We put the initial_rels list into a PlannerInfo field because
    3829             :          * has_legal_joinclause() needs to look at it (ugly :-().
    3830             :          */
    3831      100976 :         root->initial_rels = initial_rels;
    3832             : 
    3833      100976 :         if (join_search_hook)
    3834           0 :             return (*join_search_hook) (root, levels_needed, initial_rels);
    3835      100976 :         else if (enable_geqo && levels_needed >= geqo_threshold)
    3836          42 :             return geqo(root, levels_needed, initial_rels);
    3837             :         else
    3838      100934 :             return standard_join_search(root, levels_needed, initial_rels);
    3839             :     }
    3840             : }
    3841             : 
    3842             : /*
    3843             :  * standard_join_search
    3844             :  *    Find possible joinpaths for a query by successively finding ways
    3845             :  *    to join component relations into join relations.
    3846             :  *
    3847             :  * 'levels_needed' is the number of iterations needed, ie, the number of
    3848             :  *      independent jointree items in the query.  This is > 1.
    3849             :  *
    3850             :  * 'initial_rels' is a list of RelOptInfo nodes for each independent
    3851             :  *      jointree item.  These are the components to be joined together.
    3852             :  *      Note that levels_needed == list_length(initial_rels).
    3853             :  *
    3854             :  * Returns the final level of join relations, i.e., the relation that is
    3855             :  * the result of joining all the original relations together.
    3856             :  * At least one implementation path must be provided for this relation and
    3857             :  * all required sub-relations.
    3858             :  *
    3859             :  * To support loadable plugins that modify planner behavior by changing the
    3860             :  * join searching algorithm, we provide a hook variable that lets a plugin
    3861             :  * replace or supplement this function.  Any such hook must return the same
    3862             :  * final join relation as the standard code would, but it might have a
    3863             :  * different set of implementation paths attached, and only the sub-joinrels
    3864             :  * needed for these paths need have been instantiated.
    3865             :  *
    3866             :  * Note to plugin authors: the functions invoked during standard_join_search()
    3867             :  * modify root->join_rel_list and root->join_rel_hash.  If you want to do more
    3868             :  * than one join-order search, you'll probably need to save and restore the
    3869             :  * original states of those data structures.  See geqo_eval() for an example.
    3870             :  */
    3871             : RelOptInfo *
    3872      100934 : standard_join_search(PlannerInfo *root, int levels_needed, List *initial_rels)
    3873             : {
    3874             :     int         lev;
    3875             :     RelOptInfo *rel;
    3876             : 
    3877             :     /*
    3878             :      * This function cannot be invoked recursively within any one planning
    3879             :      * problem, so join_rel_level[] can't be in use already.
    3880             :      */
    3881             :     Assert(root->join_rel_level == NULL);
    3882             : 
    3883             :     /*
    3884             :      * We employ a simple "dynamic programming" algorithm: we first find all
    3885             :      * ways to build joins of two jointree items, then all ways to build joins
    3886             :      * of three items (from two-item joins and single items), then four-item
    3887             :      * joins, and so on until we have considered all ways to join all the
    3888             :      * items into one rel.
    3889             :      *
    3890             :      * root->join_rel_level[j] is a list of all the j-item rels.  Initially we
    3891             :      * set root->join_rel_level[1] to represent all the single-jointree-item
    3892             :      * relations.
    3893             :      */
    3894      100934 :     root->join_rel_level = (List **) palloc0((levels_needed + 1) * sizeof(List *));
    3895             : 
    3896      100934 :     root->join_rel_level[1] = initial_rels;
    3897             : 
    3898      238794 :     for (lev = 2; lev <= levels_needed; lev++)
    3899             :     {
    3900             :         ListCell   *lc;
    3901             : 
    3902             :         /*
    3903             :          * Determine all possible pairs of relations to be joined at this
    3904             :          * level, and build paths for making each one from every available
    3905             :          * pair of lower-level relations.
    3906             :          */
    3907      137860 :         join_search_one_level(root, lev);
    3908             : 
    3909             :         /*
    3910             :          * Run generate_partitionwise_join_paths() and
    3911             :          * generate_useful_gather_paths() for each just-processed joinrel.  We
    3912             :          * could not do this earlier because both regular and partial paths
    3913             :          * can get added to a particular joinrel at multiple times within
    3914             :          * join_search_one_level.
    3915             :          *
    3916             :          * After that, we're done creating paths for the joinrel, so run
    3917             :          * set_cheapest().
    3918             :          *
    3919             :          * In addition, we also run generate_grouped_paths() for the grouped
    3920             :          * relation of each just-processed joinrel, and run set_cheapest() for
    3921             :          * the grouped relation afterwards.
    3922             :          */
    3923      348130 :         foreach(lc, root->join_rel_level[lev])
    3924             :         {
    3925             :             bool        is_top_rel;
    3926             : 
    3927      210270 :             rel = (RelOptInfo *) lfirst(lc);
    3928             : 
    3929      210270 :             is_top_rel = bms_equal(rel->relids, root->all_query_rels);
    3930             : 
    3931             :             /* Create paths for partitionwise joins. */
    3932      210270 :             generate_partitionwise_join_paths(root, rel);
    3933             : 
    3934             :             /*
    3935             :              * Except for the topmost scan/join rel, consider gathering
    3936             :              * partial paths.  We'll do the same for the topmost scan/join rel
    3937             :              * once we know the final targetlist (see grouping_planner's and
    3938             :              * its call to apply_scanjoin_target_to_paths).
    3939             :              */
    3940      210270 :             if (!is_top_rel)
    3941      109834 :                 generate_useful_gather_paths(root, rel, false);
    3942             : 
    3943             :             /* Find and save the cheapest paths for this rel */
    3944      210270 :             set_cheapest(rel);
    3945             : 
    3946             :             /*
    3947             :              * Except for the topmost scan/join rel, consider generating
    3948             :              * partial aggregation paths for the grouped relation on top of
    3949             :              * the paths of this rel.  After that, we're done creating paths
    3950             :              * for the grouped relation, so run set_cheapest().
    3951             :              */
    3952      210270 :             if (rel->grouped_rel != NULL && !is_top_rel)
    3953             :             {
    3954          72 :                 RelOptInfo *grouped_rel = rel->grouped_rel;
    3955             : 
    3956             :                 Assert(IS_GROUPED_REL(grouped_rel));
    3957             : 
    3958          72 :                 generate_grouped_paths(root, grouped_rel, rel);
    3959          72 :                 set_cheapest(grouped_rel);
    3960             :             }
    3961             : 
    3962             : #ifdef OPTIMIZER_DEBUG
    3963             :             pprint(rel);
    3964             : #endif
    3965             :         }
    3966             :     }
    3967             : 
    3968             :     /*
    3969             :      * We should have a single rel at the final level.
    3970             :      */
    3971      100934 :     if (root->join_rel_level[levels_needed] == NIL)
    3972           0 :         elog(ERROR, "failed to build any %d-way joins", levels_needed);
    3973             :     Assert(list_length(root->join_rel_level[levels_needed]) == 1);
    3974             : 
    3975      100934 :     rel = (RelOptInfo *) linitial(root->join_rel_level[levels_needed]);
    3976             : 
    3977      100934 :     root->join_rel_level = NULL;
    3978             : 
    3979      100934 :     return rel;
    3980             : }
    3981             : 
    3982             : /*****************************************************************************
    3983             :  *          PUSHING QUALS DOWN INTO SUBQUERIES
    3984             :  *****************************************************************************/
    3985             : 
    3986             : /*
    3987             :  * subquery_is_pushdown_safe - is a subquery safe for pushing down quals?
    3988             :  *
    3989             :  * subquery is the particular component query being checked.  topquery
    3990             :  * is the top component of a set-operations tree (the same Query if no
    3991             :  * set-op is involved).
    3992             :  *
    3993             :  * Conditions checked here:
    3994             :  *
    3995             :  * 1. If the subquery has a LIMIT clause, we must not push down any quals,
    3996             :  * since that could change the set of rows returned.
    3997             :  *
    3998             :  * 2. If the subquery contains EXCEPT or EXCEPT ALL set ops we cannot push
    3999             :  * quals into it, because that could change the results.
    4000             :  *
    4001             :  * 3. If the subquery uses DISTINCT, we cannot push volatile quals into it.
    4002             :  * This is because upper-level quals should semantically be evaluated only
    4003             :  * once per distinct row, not once per original row, and if the qual is
    4004             :  * volatile then extra evaluations could change the results.  (This issue
    4005             :  * does not apply to other forms of aggregation such as GROUP BY, because
    4006             :  * when those are present we push into HAVING not WHERE, so that the quals
    4007             :  * are still applied after aggregation.)
    4008             :  *
    4009             :  * 4. If the subquery contains window functions, we cannot push volatile quals
    4010             :  * into it.  The issue here is a bit different from DISTINCT: a volatile qual
    4011             :  * might succeed for some rows of a window partition and fail for others,
    4012             :  * thereby changing the partition contents and thus the window functions'
    4013             :  * results for rows that remain.
    4014             :  *
    4015             :  * 5. If the subquery contains any set-returning functions in its targetlist,
    4016             :  * we cannot push volatile quals into it.  That would push them below the SRFs
    4017             :  * and thereby change the number of times they are evaluated.  Also, a
    4018             :  * volatile qual could succeed for some SRF output rows and fail for others,
    4019             :  * a behavior that cannot occur if it's evaluated before SRF expansion.
    4020             :  *
    4021             :  * 6. If the subquery has nonempty grouping sets, we cannot push down any
    4022             :  * quals.  The concern here is that a qual referencing a "constant" grouping
    4023             :  * column could get constant-folded, which would be improper because the value
    4024             :  * is potentially nullable by grouping-set expansion.  This restriction could
    4025             :  * be removed if we had a parsetree representation that shows that such
    4026             :  * grouping columns are not really constant.  (There are other ideas that
    4027             :  * could be used to relax this restriction, but that's the approach most
    4028             :  * likely to get taken in the future.  Note that there's not much to be gained
    4029             :  * so long as subquery_planner can't move HAVING clauses to WHERE within such
    4030             :  * a subquery.)
    4031             :  *
    4032             :  * In addition, we make several checks on the subquery's output columns to see
    4033             :  * if it is safe to reference them in pushed-down quals.  If output column k
    4034             :  * is found to be unsafe to reference, we set the reason for that inside
    4035             :  * safetyInfo->unsafeFlags[k], but we don't reject the subquery overall since
    4036             :  * column k might not be referenced by some/all quals.  The unsafeFlags[]
    4037             :  * array will be consulted later by qual_is_pushdown_safe().  It's better to
    4038             :  * do it this way than to make the checks directly in qual_is_pushdown_safe(),
    4039             :  * because when the subquery involves set operations we have to check the
    4040             :  * output expressions in each arm of the set op.
    4041             :  *
    4042             :  * Note: pushing quals into a DISTINCT subquery is theoretically dubious:
    4043             :  * we're effectively assuming that the quals cannot distinguish values that
    4044             :  * the DISTINCT's equality operator sees as equal, yet there are many
    4045             :  * counterexamples to that assumption.  However use of such a qual with a
    4046             :  * DISTINCT subquery would be unsafe anyway, since there's no guarantee which
    4047             :  * "equal" value will be chosen as the output value by the DISTINCT operation.
    4048             :  * So we don't worry too much about that.  Another objection is that if the
    4049             :  * qual is expensive to evaluate, running it for each original row might cost
    4050             :  * more than we save by eliminating rows before the DISTINCT step.  But it
    4051             :  * would be very hard to estimate that at this stage, and in practice pushdown
    4052             :  * seldom seems to make things worse, so we ignore that problem too.
    4053             :  *
    4054             :  * Note: likewise, pushing quals into a subquery with window functions is a
    4055             :  * bit dubious: the quals might remove some rows of a window partition while
    4056             :  * leaving others, causing changes in the window functions' results for the
    4057             :  * surviving rows.  We insist that such a qual reference only partitioning
    4058             :  * columns, but again that only protects us if the qual does not distinguish
    4059             :  * values that the partitioning equality operator sees as equal.  The risks
    4060             :  * here are perhaps larger than for DISTINCT, since no de-duplication of rows
    4061             :  * occurs and thus there is no theoretical problem with such a qual.  But
    4062             :  * we'll do this anyway because the potential performance benefits are very
    4063             :  * large, and we've seen no field complaints about the longstanding comparable
    4064             :  * behavior with DISTINCT.
    4065             :  */
    4066             : static bool
    4067        2180 : subquery_is_pushdown_safe(Query *subquery, Query *topquery,
    4068             :                           pushdown_safety_info *safetyInfo)
    4069             : {
    4070             :     SetOperationStmt *topop;
    4071             : 
    4072             :     /* Check point 1 */
    4073        2180 :     if (subquery->limitOffset != NULL || subquery->limitCount != NULL)
    4074         134 :         return false;
    4075             : 
    4076             :     /* Check point 6 */
    4077        2046 :     if (subquery->groupClause && subquery->groupingSets)
    4078          12 :         return false;
    4079             : 
    4080             :     /* Check points 3, 4, and 5 */
    4081        2034 :     if (subquery->distinctClause ||
    4082        1950 :         subquery->hasWindowFuncs ||
    4083        1684 :         subquery->hasTargetSRFs)
    4084         546 :         safetyInfo->unsafeVolatile = true;
    4085             : 
    4086             :     /*
    4087             :      * If we're at a leaf query, check for unsafe expressions in its target
    4088             :      * list, and mark any reasons why they're unsafe in unsafeFlags[].
    4089             :      * (Non-leaf nodes in setop trees have only simple Vars in their tlists,
    4090             :      * so no need to check them.)
    4091             :      */
    4092        2034 :     if (subquery->setOperations == NULL)
    4093        1878 :         check_output_expressions(subquery, safetyInfo);
    4094             : 
    4095             :     /* Are we at top level, or looking at a setop component? */
    4096        2034 :     if (subquery == topquery)
    4097             :     {
    4098             :         /* Top level, so check any component queries */
    4099        1722 :         if (subquery->setOperations != NULL)
    4100         156 :             if (!recurse_pushdown_safe(subquery->setOperations, topquery,
    4101             :                                        safetyInfo))
    4102           0 :                 return false;
    4103             :     }
    4104             :     else
    4105             :     {
    4106             :         /* Setop component must not have more components (too weird) */
    4107         312 :         if (subquery->setOperations != NULL)
    4108           0 :             return false;
    4109             :         /* Check whether setop component output types match top level */
    4110         312 :         topop = castNode(SetOperationStmt, topquery->setOperations);
    4111             :         Assert(topop);
    4112         312 :         compare_tlist_datatypes(subquery->targetList,
    4113             :                                 topop->colTypes,
    4114             :                                 safetyInfo);
    4115             :     }
    4116        2034 :     return true;
    4117             : }
    4118             : 
    4119             : /*
    4120             :  * Helper routine to recurse through setOperations tree
    4121             :  */
    4122             : static bool
    4123         468 : recurse_pushdown_safe(Node *setOp, Query *topquery,
    4124             :                       pushdown_safety_info *safetyInfo)
    4125             : {
    4126         468 :     if (IsA(setOp, RangeTblRef))
    4127             :     {
    4128         312 :         RangeTblRef *rtr = (RangeTblRef *) setOp;
    4129         312 :         RangeTblEntry *rte = rt_fetch(rtr->rtindex, topquery->rtable);
    4130         312 :         Query      *subquery = rte->subquery;
    4131             : 
    4132             :         Assert(subquery != NULL);
    4133         312 :         return subquery_is_pushdown_safe(subquery, topquery, safetyInfo);
    4134             :     }
    4135         156 :     else if (IsA(setOp, SetOperationStmt))
    4136             :     {
    4137         156 :         SetOperationStmt *op = (SetOperationStmt *) setOp;
    4138             : 
    4139             :         /* EXCEPT is no good (point 2 for subquery_is_pushdown_safe) */
    4140         156 :         if (op->op == SETOP_EXCEPT)
    4141           0 :             return false;
    4142             :         /* Else recurse */
    4143         156 :         if (!recurse_pushdown_safe(op->larg, topquery, safetyInfo))
    4144           0 :             return false;
    4145         156 :         if (!recurse_pushdown_safe(op->rarg, topquery, safetyInfo))
    4146           0 :             return false;
    4147             :     }
    4148             :     else
    4149             :     {
    4150           0 :         elog(ERROR, "unrecognized node type: %d",
    4151             :              (int) nodeTag(setOp));
    4152             :     }
    4153         156 :     return true;
    4154             : }
    4155             : 
    4156             : /*
    4157             :  * check_output_expressions - check subquery's output expressions for safety
    4158             :  *
    4159             :  * There are several cases in which it's unsafe to push down an upper-level
    4160             :  * qual if it references a particular output column of a subquery.  We check
    4161             :  * each output column of the subquery and set flags in unsafeFlags[k] when we
    4162             :  * see that column is unsafe for a pushed-down qual to reference.  The
    4163             :  * conditions checked here are:
    4164             :  *
    4165             :  * 1. We must not push down any quals that refer to subselect outputs that
    4166             :  * return sets, else we'd introduce functions-returning-sets into the
    4167             :  * subquery's WHERE/HAVING quals.
    4168             :  *
    4169             :  * 2. We must not push down any quals that refer to subselect outputs that
    4170             :  * contain volatile functions, for fear of introducing strange results due
    4171             :  * to multiple evaluation of a volatile function.
    4172             :  *
    4173             :  * 3. If the subquery uses DISTINCT ON, we must not push down any quals that
    4174             :  * refer to non-DISTINCT output columns, because that could change the set
    4175             :  * of rows returned.  (This condition is vacuous for DISTINCT, because then
    4176             :  * there are no non-DISTINCT output columns, so we needn't check.  Note that
    4177             :  * subquery_is_pushdown_safe already reported that we can't use volatile
    4178             :  * quals if there's DISTINCT or DISTINCT ON.)
    4179             :  *
    4180             :  * 4. If the subquery has any window functions, we must not push down quals
    4181             :  * that reference any output columns that are not listed in all the subquery's
    4182             :  * window PARTITION BY clauses.  We can push down quals that use only
    4183             :  * partitioning columns because they should succeed or fail identically for
    4184             :  * every row of any one window partition, and totally excluding some
    4185             :  * partitions will not change a window function's results for remaining
    4186             :  * partitions.  (Again, this also requires nonvolatile quals, but
    4187             :  * subquery_is_pushdown_safe handles that.).  Subquery columns marked as
    4188             :  * unsafe for this reason can still have WindowClause run conditions pushed
    4189             :  * down.
    4190             :  */
    4191             : static void
    4192        1878 : check_output_expressions(Query *subquery, pushdown_safety_info *safetyInfo)
    4193             : {
    4194             :     ListCell   *lc;
    4195             : 
    4196       18022 :     foreach(lc, subquery->targetList)
    4197             :     {
    4198       16144 :         TargetEntry *tle = (TargetEntry *) lfirst(lc);
    4199             : 
    4200       16144 :         if (tle->resjunk)
    4201         134 :             continue;           /* ignore resjunk columns */
    4202             : 
    4203             :         /* Functions returning sets are unsafe (point 1) */
    4204       16010 :         if (subquery->hasTargetSRFs &&
    4205         668 :             (safetyInfo->unsafeFlags[tle->resno] &
    4206         668 :              UNSAFE_HAS_SET_FUNC) == 0 &&
    4207         668 :             expression_returns_set((Node *) tle->expr))
    4208             :         {
    4209         376 :             safetyInfo->unsafeFlags[tle->resno] |= UNSAFE_HAS_SET_FUNC;
    4210         376 :             continue;
    4211             :         }
    4212             : 
    4213             :         /* Volatile functions are unsafe (point 2) */
    4214       15634 :         if ((safetyInfo->unsafeFlags[tle->resno] &
    4215       15622 :              UNSAFE_HAS_VOLATILE_FUNC) == 0 &&
    4216       15622 :             contain_volatile_functions((Node *) tle->expr))
    4217             :         {
    4218          78 :             safetyInfo->unsafeFlags[tle->resno] |= UNSAFE_HAS_VOLATILE_FUNC;
    4219          78 :             continue;
    4220             :         }
    4221             : 
    4222             :         /* If subquery uses DISTINCT ON, check point 3 */
    4223       15556 :         if (subquery->hasDistinctOn &&
    4224           0 :             (safetyInfo->unsafeFlags[tle->resno] &
    4225           0 :              UNSAFE_NOTIN_DISTINCTON_CLAUSE) == 0 &&
    4226           0 :             !targetIsInSortList(tle, InvalidOid, subquery->distinctClause))
    4227             :         {
    4228             :             /* non-DISTINCT column, so mark it unsafe */
    4229           0 :             safetyInfo->unsafeFlags[tle->resno] |= UNSAFE_NOTIN_DISTINCTON_CLAUSE;
    4230           0 :             continue;
    4231             :         }
    4232             : 
    4233             :         /* If subquery uses window functions, check point 4 */
    4234       15556 :         if (subquery->hasWindowFuncs &&
    4235        1090 :             (safetyInfo->unsafeFlags[tle->resno] &
    4236        2092 :              UNSAFE_NOTIN_DISTINCTON_CLAUSE) == 0 &&
    4237        1090 :             !targetIsInAllPartitionLists(tle, subquery))
    4238             :         {
    4239             :             /* not present in all PARTITION BY clauses, so mark it unsafe */
    4240        1002 :             safetyInfo->unsafeFlags[tle->resno] |= UNSAFE_NOTIN_PARTITIONBY_CLAUSE;
    4241        1002 :             continue;
    4242             :         }
    4243             :     }
    4244        1878 : }
    4245             : 
    4246             : /*
    4247             :  * For subqueries using UNION/UNION ALL/INTERSECT/INTERSECT ALL, we can
    4248             :  * push quals into each component query, but the quals can only reference
    4249             :  * subquery columns that suffer no type coercions in the set operation.
    4250             :  * Otherwise there are possible semantic gotchas.  So, we check the
    4251             :  * component queries to see if any of them have output types different from
    4252             :  * the top-level setop outputs.  We set the UNSAFE_TYPE_MISMATCH bit in
    4253             :  * unsafeFlags[k] if column k has different type in any component.
    4254             :  *
    4255             :  * We don't have to care about typmods here: the only allowed difference
    4256             :  * between set-op input and output typmods is input is a specific typmod
    4257             :  * and output is -1, and that does not require a coercion.
    4258             :  *
    4259             :  * tlist is a subquery tlist.
    4260             :  * colTypes is an OID list of the top-level setop's output column types.
    4261             :  * safetyInfo is the pushdown_safety_info to set unsafeFlags[] for.
    4262             :  */
    4263             : static void
    4264         312 : compare_tlist_datatypes(List *tlist, List *colTypes,
    4265             :                         pushdown_safety_info *safetyInfo)
    4266             : {
    4267             :     ListCell   *l;
    4268         312 :     ListCell   *colType = list_head(colTypes);
    4269             : 
    4270         984 :     foreach(l, tlist)
    4271             :     {
    4272         672 :         TargetEntry *tle = (TargetEntry *) lfirst(l);
    4273             : 
    4274         672 :         if (tle->resjunk)
    4275           0 :             continue;           /* ignore resjunk columns */
    4276         672 :         if (colType == NULL)
    4277           0 :             elog(ERROR, "wrong number of tlist entries");
    4278         672 :         if (exprType((Node *) tle->expr) != lfirst_oid(colType))
    4279         104 :             safetyInfo->unsafeFlags[tle->resno] |= UNSAFE_TYPE_MISMATCH;
    4280         672 :         colType = lnext(colTypes, colType);
    4281             :     }
    4282         312 :     if (colType != NULL)
    4283           0 :         elog(ERROR, "wrong number of tlist entries");
    4284         312 : }
    4285             : 
    4286             : /*
    4287             :  * targetIsInAllPartitionLists
    4288             :  *      True if the TargetEntry is listed in the PARTITION BY clause
    4289             :  *      of every window defined in the query.
    4290             :  *
    4291             :  * It would be safe to ignore windows not actually used by any window
    4292             :  * function, but it's not easy to get that info at this stage; and it's
    4293             :  * unlikely to be useful to spend any extra cycles getting it, since
    4294             :  * unreferenced window definitions are probably infrequent in practice.
    4295             :  */
    4296             : static bool
    4297        1090 : targetIsInAllPartitionLists(TargetEntry *tle, Query *query)
    4298             : {
    4299             :     ListCell   *lc;
    4300             : 
    4301        1202 :     foreach(lc, query->windowClause)
    4302             :     {
    4303        1114 :         WindowClause *wc = (WindowClause *) lfirst(lc);
    4304             : 
    4305        1114 :         if (!targetIsInSortList(tle, InvalidOid, wc->partitionClause))
    4306        1002 :             return false;
    4307             :     }
    4308          88 :     return true;
    4309             : }
    4310             : 
    4311             : /*
    4312             :  * qual_is_pushdown_safe - is a particular rinfo safe to push down?
    4313             :  *
    4314             :  * rinfo is a restriction clause applying to the given subquery (whose RTE
    4315             :  * has index rti in the parent query).
    4316             :  *
    4317             :  * Conditions checked here:
    4318             :  *
    4319             :  * 1. rinfo's clause must not contain any SubPlans (mainly because it's
    4320             :  * unclear that it will work correctly: SubLinks will already have been
    4321             :  * transformed into SubPlans in the qual, but not in the subquery).  Note that
    4322             :  * SubLinks that transform to initplans are safe, and will be accepted here
    4323             :  * because what we'll see in the qual is just a Param referencing the initplan
    4324             :  * output.
    4325             :  *
    4326             :  * 2. If unsafeVolatile is set, rinfo's clause must not contain any volatile
    4327             :  * functions.
    4328             :  *
    4329             :  * 3. If unsafeLeaky is set, rinfo's clause must not contain any leaky
    4330             :  * functions that are passed Var nodes, and therefore might reveal values from
    4331             :  * the subquery as side effects.
    4332             :  *
    4333             :  * 4. rinfo's clause must not refer to the whole-row output of the subquery
    4334             :  * (since there is no easy way to name that within the subquery itself).
    4335             :  *
    4336             :  * 5. rinfo's clause must not refer to any subquery output columns that were
    4337             :  * found to be unsafe to reference by subquery_is_pushdown_safe().
    4338             :  */
    4339             : static pushdown_safe_type
    4340        2670 : qual_is_pushdown_safe(Query *subquery, Index rti, RestrictInfo *rinfo,
    4341             :                       pushdown_safety_info *safetyInfo)
    4342             : {
    4343        2670 :     pushdown_safe_type safe = PUSHDOWN_SAFE;
    4344        2670 :     Node       *qual = (Node *) rinfo->clause;
    4345             :     List       *vars;
    4346             :     ListCell   *vl;
    4347             : 
    4348             :     /* Refuse subselects (point 1) */
    4349        2670 :     if (contain_subplans(qual))
    4350          66 :         return PUSHDOWN_UNSAFE;
    4351             : 
    4352             :     /* Refuse volatile quals if we found they'd be unsafe (point 2) */
    4353        3256 :     if (safetyInfo->unsafeVolatile &&
    4354         652 :         contain_volatile_functions((Node *) rinfo))
    4355          18 :         return PUSHDOWN_UNSAFE;
    4356             : 
    4357             :     /* Refuse leaky quals if told to (point 3) */
    4358        3768 :     if (safetyInfo->unsafeLeaky &&
    4359        1182 :         contain_leaked_vars(qual))
    4360         162 :         return PUSHDOWN_UNSAFE;
    4361             : 
    4362             :     /*
    4363             :      * Examine all Vars used in clause.  Since it's a restriction clause, all
    4364             :      * such Vars must refer to subselect output columns ... unless this is
    4365             :      * part of a LATERAL subquery, in which case there could be lateral
    4366             :      * references.
    4367             :      *
    4368             :      * By omitting the relevant flags, this also gives us a cheap sanity check
    4369             :      * that no aggregates or window functions appear in the qual.  Those would
    4370             :      * be unsafe to push down, but at least for the moment we could never see
    4371             :      * any in a qual anyhow.
    4372             :      */
    4373        2424 :     vars = pull_var_clause(qual, PVC_INCLUDE_PLACEHOLDERS);
    4374        4748 :     foreach(vl, vars)
    4375             :     {
    4376        2532 :         Var        *var = (Var *) lfirst(vl);
    4377             : 
    4378             :         /*
    4379             :          * XXX Punt if we find any PlaceHolderVars in the restriction clause.
    4380             :          * It's not clear whether a PHV could safely be pushed down, and even
    4381             :          * less clear whether such a situation could arise in any cases of
    4382             :          * practical interest anyway.  So for the moment, just refuse to push
    4383             :          * down.
    4384             :          */
    4385        2532 :         if (!IsA(var, Var))
    4386             :         {
    4387           0 :             safe = PUSHDOWN_UNSAFE;
    4388           0 :             break;
    4389             :         }
    4390             : 
    4391             :         /*
    4392             :          * Punt if we find any lateral references.  It would be safe to push
    4393             :          * these down, but we'd have to convert them into outer references,
    4394             :          * which subquery_push_qual lacks the infrastructure to do.  The case
    4395             :          * arises so seldom that it doesn't seem worth working hard on.
    4396             :          */
    4397        2532 :         if (var->varno != rti)
    4398             :         {
    4399          12 :             safe = PUSHDOWN_UNSAFE;
    4400          12 :             break;
    4401             :         }
    4402             : 
    4403             :         /* Subqueries have no system columns */
    4404             :         Assert(var->varattno >= 0);
    4405             : 
    4406             :         /* Check point 4 */
    4407        2520 :         if (var->varattno == 0)
    4408             :         {
    4409           0 :             safe = PUSHDOWN_UNSAFE;
    4410           0 :             break;
    4411             :         }
    4412             : 
    4413             :         /* Check point 5 */
    4414        2520 :         if (safetyInfo->unsafeFlags[var->varattno] != 0)
    4415             :         {
    4416         526 :             if (safetyInfo->unsafeFlags[var->varattno] &
    4417             :                 (UNSAFE_HAS_VOLATILE_FUNC | UNSAFE_HAS_SET_FUNC |
    4418             :                  UNSAFE_NOTIN_DISTINCTON_CLAUSE | UNSAFE_TYPE_MISMATCH))
    4419             :             {
    4420         196 :                 safe = PUSHDOWN_UNSAFE;
    4421         196 :                 break;
    4422             :             }
    4423             :             else
    4424             :             {
    4425             :                 /* UNSAFE_NOTIN_PARTITIONBY_CLAUSE is ok for run conditions */
    4426         330 :                 safe = PUSHDOWN_WINDOWCLAUSE_RUNCOND;
    4427             :                 /* don't break, we might find another Var that's unsafe */
    4428             :             }
    4429             :         }
    4430             :     }
    4431             : 
    4432        2424 :     list_free(vars);
    4433             : 
    4434        2424 :     return safe;
    4435             : }
    4436             : 
    4437             : /*
    4438             :  * subquery_push_qual - push down a qual that we have determined is safe
    4439             :  */
    4440             : static void
    4441        2228 : subquery_push_qual(Query *subquery, RangeTblEntry *rte, Index rti, Node *qual)
    4442             : {
    4443        2228 :     if (subquery->setOperations != NULL)
    4444             :     {
    4445             :         /* Recurse to push it separately to each component query */
    4446         132 :         recurse_push_qual(subquery->setOperations, subquery,
    4447             :                           rte, rti, qual);
    4448             :     }
    4449             :     else
    4450             :     {
    4451             :         /*
    4452             :          * We need to replace Vars in the qual (which must refer to outputs of
    4453             :          * the subquery) with copies of the subquery's targetlist expressions.
    4454             :          * Note that at this point, any uplevel Vars in the qual should have
    4455             :          * been replaced with Params, so they need no work.
    4456             :          *
    4457             :          * This step also ensures that when we are pushing into a setop tree,
    4458             :          * each component query gets its own copy of the qual.
    4459             :          */
    4460        2096 :         qual = ReplaceVarsFromTargetList(qual, rti, 0, rte,
    4461             :                                          subquery->targetList,
    4462             :                                          subquery->resultRelation,
    4463             :                                          REPLACEVARS_REPORT_ERROR, 0,
    4464             :                                          &subquery->hasSubLinks);
    4465             : 
    4466             :         /*
    4467             :          * Now attach the qual to the proper place: normally WHERE, but if the
    4468             :          * subquery uses grouping or aggregation, put it in HAVING (since the
    4469             :          * qual really refers to the group-result rows).
    4470             :          */
    4471        2096 :         if (subquery->hasAggs || subquery->groupClause || subquery->groupingSets || subquery->havingQual)
    4472         278 :             subquery->havingQual = make_and_qual(subquery->havingQual, qual);
    4473             :         else
    4474        1818 :             subquery->jointree->quals =
    4475        1818 :                 make_and_qual(subquery->jointree->quals, qual);
    4476             : 
    4477             :         /*
    4478             :          * We need not change the subquery's hasAggs or hasSubLinks flags,
    4479             :          * since we can't be pushing down any aggregates that weren't there
    4480             :          * before, and we don't push down subselects at all.
    4481             :          */
    4482             :     }
    4483        2228 : }
    4484             : 
    4485             : /*
    4486             :  * Helper routine to recurse through setOperations tree
    4487             :  */
    4488             : static void
    4489         396 : recurse_push_qual(Node *setOp, Query *topquery,
    4490             :                   RangeTblEntry *rte, Index rti, Node *qual)
    4491             : {
    4492         396 :     if (IsA(setOp, RangeTblRef))
    4493             :     {
    4494         264 :         RangeTblRef *rtr = (RangeTblRef *) setOp;
    4495         264 :         RangeTblEntry *subrte = rt_fetch(rtr->rtindex, topquery->rtable);
    4496         264 :         Query      *subquery = subrte->subquery;
    4497             : 
    4498             :         Assert(subquery != NULL);
    4499         264 :         subquery_push_qual(subquery, rte, rti, qual);
    4500             :     }
    4501         132 :     else if (IsA(setOp, SetOperationStmt))
    4502             :     {
    4503         132 :         SetOperationStmt *op = (SetOperationStmt *) setOp;
    4504             : 
    4505         132 :         recurse_push_qual(op->larg, topquery, rte, rti, qual);
    4506         132 :         recurse_push_qual(op->rarg, topquery, rte, rti, qual);
    4507             :     }
    4508             :     else
    4509             :     {
    4510           0 :         elog(ERROR, "unrecognized node type: %d",
    4511             :              (int) nodeTag(setOp));
    4512             :     }
    4513         396 : }
    4514             : 
    4515             : /*****************************************************************************
    4516             :  *          SIMPLIFYING SUBQUERY TARGETLISTS
    4517             :  *****************************************************************************/
    4518             : 
    4519             : /*
    4520             :  * remove_unused_subquery_outputs
    4521             :  *      Remove subquery targetlist items we don't need
    4522             :  *
    4523             :  * It's possible, even likely, that the upper query does not read all the
    4524             :  * output columns of the subquery.  We can remove any such outputs that are
    4525             :  * not needed by the subquery itself (e.g., as sort/group columns) and do not
    4526             :  * affect semantics otherwise (e.g., volatile functions can't be removed).
    4527             :  * This is useful not only because we might be able to remove expensive-to-
    4528             :  * compute expressions, but because deletion of output columns might allow
    4529             :  * optimizations such as join removal to occur within the subquery.
    4530             :  *
    4531             :  * extra_used_attrs can be passed as non-NULL to mark any columns (offset by
    4532             :  * FirstLowInvalidHeapAttributeNumber) that we should not remove.  This
    4533             :  * parameter is modified by the function, so callers must make a copy if they
    4534             :  * need to use the passed in Bitmapset after calling this function.
    4535             :  *
    4536             :  * To avoid affecting column numbering in the targetlist, we don't physically
    4537             :  * remove unused tlist entries, but rather replace their expressions with NULL
    4538             :  * constants.  This is implemented by modifying subquery->targetList.
    4539             :  */
    4540             : static void
    4541       16760 : remove_unused_subquery_outputs(Query *subquery, RelOptInfo *rel,
    4542             :                                Bitmapset *extra_used_attrs)
    4543             : {
    4544             :     Bitmapset  *attrs_used;
    4545             :     ListCell   *lc;
    4546             : 
    4547             :     /*
    4548             :      * Just point directly to extra_used_attrs. No need to bms_copy as none of
    4549             :      * the current callers use the Bitmapset after calling this function.
    4550             :      */
    4551       16760 :     attrs_used = extra_used_attrs;
    4552             : 
    4553             :     /*
    4554             :      * Do nothing if subquery has UNION/INTERSECT/EXCEPT: in principle we
    4555             :      * could update all the child SELECTs' tlists, but it seems not worth the
    4556             :      * trouble presently.
    4557             :      */
    4558       16760 :     if (subquery->setOperations)
    4559        1386 :         return;
    4560             : 
    4561             :     /*
    4562             :      * If subquery has regular DISTINCT (not DISTINCT ON), we're wasting our
    4563             :      * time: all its output columns must be used in the distinctClause.
    4564             :      */
    4565       15924 :     if (subquery->distinctClause && !subquery->hasDistinctOn)
    4566         246 :         return;
    4567             : 
    4568             :     /*
    4569             :      * Collect a bitmap of all the output column numbers used by the upper
    4570             :      * query.
    4571             :      *
    4572             :      * Add all the attributes needed for joins or final output.  Note: we must
    4573             :      * look at rel's targetlist, not the attr_needed data, because attr_needed
    4574             :      * isn't computed for inheritance child rels, cf set_append_rel_size().
    4575             :      * (XXX might be worth changing that sometime.)
    4576             :      */
    4577       15678 :     pull_varattnos((Node *) rel->reltarget->exprs, rel->relid, &attrs_used);
    4578             : 
    4579             :     /* Add all the attributes used by un-pushed-down restriction clauses. */
    4580       16414 :     foreach(lc, rel->baserestrictinfo)
    4581             :     {
    4582         736 :         RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
    4583             : 
    4584         736 :         pull_varattnos((Node *) rinfo->clause, rel->relid, &attrs_used);
    4585             :     }
    4586             : 
    4587             :     /*
    4588             :      * If there's a whole-row reference to the subquery, we can't remove
    4589             :      * anything.
    4590             :      */
    4591       15678 :     if (bms_is_member(0 - FirstLowInvalidHeapAttributeNumber, attrs_used))
    4592         304 :         return;
    4593             : 
    4594             :     /*
    4595             :      * Run through the tlist and zap entries we don't need.  It's okay to
    4596             :      * modify the tlist items in-place because set_subquery_pathlist made a
    4597             :      * copy of the subquery.
    4598             :      */
    4599       87656 :     foreach(lc, subquery->targetList)
    4600             :     {
    4601       72282 :         TargetEntry *tle = (TargetEntry *) lfirst(lc);
    4602       72282 :         Node       *texpr = (Node *) tle->expr;
    4603             : 
    4604             :         /*
    4605             :          * If it has a sortgroupref number, it's used in some sort/group
    4606             :          * clause so we'd better not remove it.  Also, don't remove any
    4607             :          * resjunk columns, since their reason for being has nothing to do
    4608             :          * with anybody reading the subquery's output.  (It's likely that
    4609             :          * resjunk columns in a sub-SELECT would always have ressortgroupref
    4610             :          * set, but even if they don't, it seems imprudent to remove them.)
    4611             :          */
    4612       72282 :         if (tle->ressortgroupref || tle->resjunk)
    4613        2622 :             continue;
    4614             : 
    4615             :         /*
    4616             :          * If it's used by the upper query, we can't remove it.
    4617             :          */
    4618       69660 :         if (bms_is_member(tle->resno - FirstLowInvalidHeapAttributeNumber,
    4619             :                           attrs_used))
    4620       47150 :             continue;
    4621             : 
    4622             :         /*
    4623             :          * If it contains a set-returning function, we can't remove it since
    4624             :          * that could change the number of rows returned by the subquery.
    4625             :          */
    4626       23550 :         if (subquery->hasTargetSRFs &&
    4627        1040 :             expression_returns_set(texpr))
    4628         772 :             continue;
    4629             : 
    4630             :         /*
    4631             :          * If it contains volatile functions, we daren't remove it for fear
    4632             :          * that the user is expecting their side-effects to happen.
    4633             :          */
    4634       21738 :         if (contain_volatile_functions(texpr))
    4635          32 :             continue;
    4636             : 
    4637             :         /*
    4638             :          * OK, we don't need it.  Replace the expression with a NULL constant.
    4639             :          * Preserve the exposed type of the expression, in case something
    4640             :          * looks at the rowtype of the subquery's result.
    4641             :          */
    4642       21706 :         tle->expr = (Expr *) makeNullConst(exprType(texpr),
    4643             :                                            exprTypmod(texpr),
    4644             :                                            exprCollation(texpr));
    4645             :     }
    4646             : }
    4647             : 
    4648             : /*
    4649             :  * create_partial_bitmap_paths
    4650             :  *    Build partial bitmap heap path for the relation
    4651             :  */
    4652             : void
    4653      144430 : create_partial_bitmap_paths(PlannerInfo *root, RelOptInfo *rel,
    4654             :                             Path *bitmapqual)
    4655             : {
    4656             :     int         parallel_workers;
    4657             :     double      pages_fetched;
    4658             : 
    4659             :     /* Compute heap pages for bitmap heap scan */
    4660      144430 :     pages_fetched = compute_bitmap_pages(root, rel, bitmapqual, 1.0,
    4661             :                                          NULL, NULL);
    4662             : 
    4663      144430 :     parallel_workers = compute_parallel_worker(rel, pages_fetched, -1,
    4664             :                                                max_parallel_workers_per_gather);
    4665             : 
    4666      144430 :     if (parallel_workers <= 0)
    4667      140242 :         return;
    4668             : 
    4669        4188 :     add_partial_path(rel, (Path *) create_bitmap_heap_path(root, rel,
    4670             :                                                            bitmapqual, rel->lateral_relids, 1.0, parallel_workers));
    4671             : }
    4672             : 
    4673             : /*
    4674             :  * Compute the number of parallel workers that should be used to scan a
    4675             :  * relation.  We compute the parallel workers based on the size of the heap to
    4676             :  * be scanned and the size of the index to be scanned, then choose a minimum
    4677             :  * of those.
    4678             :  *
    4679             :  * "heap_pages" is the number of pages from the table that we expect to scan, or
    4680             :  * -1 if we don't expect to scan any.
    4681             :  *
    4682             :  * "index_pages" is the number of pages from the index that we expect to scan, or
    4683             :  * -1 if we don't expect to scan any.
    4684             :  *
    4685             :  * "max_workers" is caller's limit on the number of workers.  This typically
    4686             :  * comes from a GUC.
    4687             :  */
    4688             : int
    4689      757162 : compute_parallel_worker(RelOptInfo *rel, double heap_pages, double index_pages,
    4690             :                         int max_workers)
    4691             : {
    4692      757162 :     int         parallel_workers = 0;
    4693             : 
    4694             :     /*
    4695             :      * If the user has set the parallel_workers reloption, use that; otherwise
    4696             :      * select a default number of workers.
    4697             :      */
    4698      757162 :     if (rel->rel_parallel_workers != -1)
    4699        1914 :         parallel_workers = rel->rel_parallel_workers;
    4700             :     else
    4701             :     {
    4702             :         /*
    4703             :          * If the number of pages being scanned is insufficient to justify a
    4704             :          * parallel scan, just return zero ... unless it's an inheritance
    4705             :          * child. In that case, we want to generate a parallel path here
    4706             :          * anyway.  It might not be worthwhile just for this relation, but
    4707             :          * when combined with all of its inheritance siblings it may well pay
    4708             :          * off.
    4709             :          */
    4710      755248 :         if (rel->reloptkind == RELOPT_BASEREL &&
    4711      715734 :             ((heap_pages >= 0 && heap_pages < min_parallel_table_scan_size) ||
    4712       23402 :              (index_pages >= 0 && index_pages < min_parallel_index_scan_size)))
    4713      714950 :             return 0;
    4714             : 
    4715       40298 :         if (heap_pages >= 0)
    4716             :         {
    4717             :             int         heap_parallel_threshold;
    4718       38164 :             int         heap_parallel_workers = 1;
    4719             : 
    4720             :             /*
    4721             :              * Select the number of workers based on the log of the size of
    4722             :              * the relation.  This probably needs to be a good deal more
    4723             :              * sophisticated, but we need something here for now.  Note that
    4724             :              * the upper limit of the min_parallel_table_scan_size GUC is
    4725             :              * chosen to prevent overflow here.
    4726             :              */
    4727       38164 :             heap_parallel_threshold = Max(min_parallel_table_scan_size, 1);
    4728       43028 :             while (heap_pages >= (BlockNumber) (heap_parallel_threshold * 3))
    4729             :             {
    4730        4864 :                 heap_parallel_workers++;
    4731        4864 :                 heap_parallel_threshold *= 3;
    4732        4864 :                 if (heap_parallel_threshold > INT_MAX / 3)
    4733           0 :                     break;      /* avoid overflow */
    4734             :             }
    4735             : 
    4736       38164 :             parallel_workers = heap_parallel_workers;
    4737             :         }
    4738             : 
    4739       40298 :         if (index_pages >= 0)
    4740             :         {
    4741        9824 :             int         index_parallel_workers = 1;
    4742             :             int         index_parallel_threshold;
    4743             : 
    4744             :             /* same calculation as for heap_pages above */
    4745        9824 :             index_parallel_threshold = Max(min_parallel_index_scan_size, 1);
    4746       10100 :             while (index_pages >= (BlockNumber) (index_parallel_threshold * 3))
    4747             :             {
    4748         276 :                 index_parallel_workers++;
    4749         276 :                 index_parallel_threshold *= 3;
    4750         276 :                 if (index_parallel_threshold > INT_MAX / 3)
    4751           0 :                     break;      /* avoid overflow */
    4752             :             }
    4753             : 
    4754        9824 :             if (parallel_workers > 0)
    4755        7690 :                 parallel_workers = Min(parallel_workers, index_parallel_workers);
    4756             :             else
    4757        2134 :                 parallel_workers = index_parallel_workers;
    4758             :         }
    4759             :     }
    4760             : 
    4761             :     /* In no case use more than caller supplied maximum number of workers */
    4762       42212 :     parallel_workers = Min(parallel_workers, max_workers);
    4763             : 
    4764       42212 :     return parallel_workers;
    4765             : }
    4766             : 
    4767             : /*
    4768             :  * generate_partitionwise_join_paths
    4769             :  *      Create paths representing partitionwise join for given partitioned
    4770             :  *      join relation.
    4771             :  *
    4772             :  * This must not be called until after we are done adding paths for all
    4773             :  * child-joins. Otherwise, add_path might delete a path to which some path
    4774             :  * generated here has a reference.
    4775             :  */
    4776             : void
    4777      235240 : generate_partitionwise_join_paths(PlannerInfo *root, RelOptInfo *rel)
    4778             : {
    4779      235240 :     List       *live_children = NIL;
    4780             :     int         cnt_parts;
    4781             :     int         num_parts;
    4782             :     RelOptInfo **part_rels;
    4783             : 
    4784             :     /* Handle only join relations here. */
    4785      235240 :     if (!IS_JOIN_REL(rel))
    4786           0 :         return;
    4787             : 
    4788             :     /* We've nothing to do if the relation is not partitioned. */
    4789      235240 :     if (!IS_PARTITIONED_REL(rel))
    4790      228094 :         return;
    4791             : 
    4792             :     /* The relation should have consider_partitionwise_join set. */
    4793             :     Assert(rel->consider_partitionwise_join);
    4794             : 
    4795             :     /* Guard against stack overflow due to overly deep partition hierarchy. */
    4796        7146 :     check_stack_depth();
    4797             : 
    4798        7146 :     num_parts = rel->nparts;
    4799        7146 :     part_rels = rel->part_rels;
    4800             : 
    4801             :     /* Collect non-dummy child-joins. */
    4802       25448 :     for (cnt_parts = 0; cnt_parts < num_parts; cnt_parts++)
    4803             :     {
    4804       18302 :         RelOptInfo *child_rel = part_rels[cnt_parts];
    4805             : 
    4806             :         /* If it's been pruned entirely, it's certainly dummy. */
    4807       18302 :         if (child_rel == NULL)
    4808          64 :             continue;
    4809             : 
    4810             :         /* Make partitionwise join paths for this partitioned child-join. */
    4811       18238 :         generate_partitionwise_join_paths(root, child_rel);
    4812             : 
    4813             :         /* If we failed to make any path for this child, we must give up. */
    4814       18238 :         if (child_rel->pathlist == NIL)
    4815             :         {
    4816             :             /*
    4817             :              * Mark the parent joinrel as unpartitioned so that later
    4818             :              * functions treat it correctly.
    4819             :              */
    4820           0 :             rel->nparts = 0;
    4821           0 :             return;
    4822             :         }
    4823             : 
    4824             :         /* Else, identify the cheapest path for it. */
    4825       18238 :         set_cheapest(child_rel);
    4826             : 
    4827             :         /* Dummy children need not be scanned, so ignore those. */
    4828       18238 :         if (IS_DUMMY_REL(child_rel))
    4829           0 :             continue;
    4830             : 
    4831             :         /*
    4832             :          * Except for the topmost scan/join rel, consider generating partial
    4833             :          * aggregation paths for the grouped relation on top of the paths of
    4834             :          * this partitioned child-join.  After that, we're done creating paths
    4835             :          * for the grouped relation, so run set_cheapest().
    4836             :          */
    4837       18238 :         if (child_rel->grouped_rel != NULL &&
    4838       12876 :             !bms_equal(IS_OTHER_REL(rel) ?
    4839             :                        rel->top_parent_relids : rel->relids,
    4840       12876 :                        root->all_query_rels))
    4841             :         {
    4842         240 :             RelOptInfo *grouped_rel = child_rel->grouped_rel;
    4843             : 
    4844             :             Assert(IS_GROUPED_REL(grouped_rel));
    4845             : 
    4846         240 :             generate_grouped_paths(root, grouped_rel, child_rel);
    4847         240 :             set_cheapest(grouped_rel);
    4848             :         }
    4849             : 
    4850             : #ifdef OPTIMIZER_DEBUG
    4851             :         pprint(child_rel);
    4852             : #endif
    4853             : 
    4854       18238 :         live_children = lappend(live_children, child_rel);
    4855             :     }
    4856             : 
    4857             :     /* If all child-joins are dummy, parent join is also dummy. */
    4858        7146 :     if (!live_children)
    4859             :     {
    4860           0 :         mark_dummy_rel(rel);
    4861           0 :         return;
    4862             :     }
    4863             : 
    4864             :     /* Build additional paths for this rel from child-join paths. */
    4865        7146 :     add_paths_to_append_rel(root, rel, live_children);
    4866        7146 :     list_free(live_children);
    4867             : }

Generated by: LCOV version 1.16