LCOV - code coverage report
Current view: top level - src/backend/optimizer/util - pathnode.c (source / functions) Hit Total Coverage
Test: PostgreSQL 17devel Lines: 1401 1568 89.3 %
Date: 2024-03-29 06:11:42 Functions: 65 65 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * pathnode.c
       4             :  *    Routines to manipulate pathlists and create path nodes
       5             :  *
       6             :  * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
       7             :  * Portions Copyright (c) 1994, Regents of the University of California
       8             :  *
       9             :  *
      10             :  * IDENTIFICATION
      11             :  *    src/backend/optimizer/util/pathnode.c
      12             :  *
      13             :  *-------------------------------------------------------------------------
      14             :  */
      15             : #include "postgres.h"
      16             : 
      17             : #include <math.h>
      18             : 
      19             : #include "foreign/fdwapi.h"
      20             : #include "miscadmin.h"
      21             : #include "nodes/extensible.h"
      22             : #include "optimizer/appendinfo.h"
      23             : #include "optimizer/clauses.h"
      24             : #include "optimizer/cost.h"
      25             : #include "optimizer/optimizer.h"
      26             : #include "optimizer/pathnode.h"
      27             : #include "optimizer/paths.h"
      28             : #include "optimizer/planmain.h"
      29             : #include "optimizer/tlist.h"
      30             : #include "parser/parsetree.h"
      31             : #include "utils/memutils.h"
      32             : #include "utils/selfuncs.h"
      33             : 
      34             : typedef enum
      35             : {
      36             :     COSTS_EQUAL,                /* path costs are fuzzily equal */
      37             :     COSTS_BETTER1,              /* first path is cheaper than second */
      38             :     COSTS_BETTER2,              /* second path is cheaper than first */
      39             :     COSTS_DIFFERENT,            /* neither path dominates the other on cost */
      40             : } PathCostComparison;
      41             : 
      42             : /*
      43             :  * STD_FUZZ_FACTOR is the normal fuzz factor for compare_path_costs_fuzzily.
      44             :  * XXX is it worth making this user-controllable?  It provides a tradeoff
      45             :  * between planner runtime and the accuracy of path cost comparisons.
      46             :  */
      47             : #define STD_FUZZ_FACTOR 1.01
      48             : 
      49             : static List *translate_sub_tlist(List *tlist, int relid);
      50             : static int  append_total_cost_compare(const ListCell *a, const ListCell *b);
      51             : static int  append_startup_cost_compare(const ListCell *a, const ListCell *b);
      52             : static List *reparameterize_pathlist_by_child(PlannerInfo *root,
      53             :                                               List *pathlist,
      54             :                                               RelOptInfo *child_rel);
      55             : static bool pathlist_is_reparameterizable_by_child(List *pathlist,
      56             :                                                    RelOptInfo *child_rel);
      57             : 
      58             : 
      59             : /*****************************************************************************
      60             :  *      MISC. PATH UTILITIES
      61             :  *****************************************************************************/
      62             : 
      63             : /*
      64             :  * compare_path_costs
      65             :  *    Return -1, 0, or +1 according as path1 is cheaper, the same cost,
      66             :  *    or more expensive than path2 for the specified criterion.
      67             :  */
      68             : int
      69      797406 : compare_path_costs(Path *path1, Path *path2, CostSelector criterion)
      70             : {
      71      797406 :     if (criterion == STARTUP_COST)
      72             :     {
      73      407796 :         if (path1->startup_cost < path2->startup_cost)
      74      255668 :             return -1;
      75      152128 :         if (path1->startup_cost > path2->startup_cost)
      76       71240 :             return +1;
      77             : 
      78             :         /*
      79             :          * If paths have the same startup cost (not at all unlikely), order
      80             :          * them by total cost.
      81             :          */
      82       80888 :         if (path1->total_cost < path2->total_cost)
      83       37512 :             return -1;
      84       43376 :         if (path1->total_cost > path2->total_cost)
      85        4298 :             return +1;
      86             :     }
      87             :     else
      88             :     {
      89      389610 :         if (path1->total_cost < path2->total_cost)
      90      370822 :             return -1;
      91       18788 :         if (path1->total_cost > path2->total_cost)
      92        1324 :             return +1;
      93             : 
      94             :         /*
      95             :          * If paths have the same total cost, order them by startup cost.
      96             :          */
      97       17464 :         if (path1->startup_cost < path2->startup_cost)
      98          44 :             return -1;
      99       17420 :         if (path1->startup_cost > path2->startup_cost)
     100          40 :             return +1;
     101             :     }
     102       56458 :     return 0;
     103             : }
     104             : 
     105             : /*
     106             :  * compare_fractional_path_costs
     107             :  *    Return -1, 0, or +1 according as path1 is cheaper, the same cost,
     108             :  *    or more expensive than path2 for fetching the specified fraction
     109             :  *    of the total tuples.
     110             :  *
     111             :  * If fraction is <= 0 or > 1, we interpret it as 1, ie, we select the
     112             :  * path with the cheaper total_cost.
     113             :  */
     114             : int
     115        3222 : compare_fractional_path_costs(Path *path1, Path *path2,
     116             :                               double fraction)
     117             : {
     118             :     Cost        cost1,
     119             :                 cost2;
     120             : 
     121        3222 :     if (fraction <= 0.0 || fraction >= 1.0)
     122        2076 :         return compare_path_costs(path1, path2, TOTAL_COST);
     123        1146 :     cost1 = path1->startup_cost +
     124        1146 :         fraction * (path1->total_cost - path1->startup_cost);
     125        1146 :     cost2 = path2->startup_cost +
     126        1146 :         fraction * (path2->total_cost - path2->startup_cost);
     127        1146 :     if (cost1 < cost2)
     128         676 :         return -1;
     129         470 :     if (cost1 > cost2)
     130         470 :         return +1;
     131           0 :     return 0;
     132             : }
     133             : 
     134             : /*
     135             :  * compare_path_costs_fuzzily
     136             :  *    Compare the costs of two paths to see if either can be said to
     137             :  *    dominate the other.
     138             :  *
     139             :  * We use fuzzy comparisons so that add_path() can avoid keeping both of
     140             :  * a pair of paths that really have insignificantly different cost.
     141             :  *
     142             :  * The fuzz_factor argument must be 1.0 plus delta, where delta is the
     143             :  * fraction of the smaller cost that is considered to be a significant
     144             :  * difference.  For example, fuzz_factor = 1.01 makes the fuzziness limit
     145             :  * be 1% of the smaller cost.
     146             :  *
     147             :  * The two paths are said to have "equal" costs if both startup and total
     148             :  * costs are fuzzily the same.  Path1 is said to be better than path2 if
     149             :  * it has fuzzily better startup cost and fuzzily no worse total cost,
     150             :  * or if it has fuzzily better total cost and fuzzily no worse startup cost.
     151             :  * Path2 is better than path1 if the reverse holds.  Finally, if one path
     152             :  * is fuzzily better than the other on startup cost and fuzzily worse on
     153             :  * total cost, we just say that their costs are "different", since neither
     154             :  * dominates the other across the whole performance spectrum.
     155             :  *
     156             :  * This function also enforces a policy rule that paths for which the relevant
     157             :  * one of parent->consider_startup and parent->consider_param_startup is false
     158             :  * cannot survive comparisons solely on the grounds of good startup cost, so
     159             :  * we never return COSTS_DIFFERENT when that is true for the total-cost loser.
     160             :  * (But if total costs are fuzzily equal, we compare startup costs anyway,
     161             :  * in hopes of eliminating one path or the other.)
     162             :  */
     163             : static PathCostComparison
     164     3460316 : compare_path_costs_fuzzily(Path *path1, Path *path2, double fuzz_factor)
     165             : {
     166             : #define CONSIDER_PATH_STARTUP_COST(p)  \
     167             :     ((p)->param_info == NULL ? (p)->parent->consider_startup : (p)->parent->consider_param_startup)
     168             : 
     169             :     /*
     170             :      * Check total cost first since it's more likely to be different; many
     171             :      * paths have zero startup cost.
     172             :      */
     173     3460316 :     if (path1->total_cost > path2->total_cost * fuzz_factor)
     174             :     {
     175             :         /* path1 fuzzily worse on total cost */
     176     1793276 :         if (CONSIDER_PATH_STARTUP_COST(path1) &&
     177      115544 :             path2->startup_cost > path1->startup_cost * fuzz_factor)
     178             :         {
     179             :             /* ... but path2 fuzzily worse on startup, so DIFFERENT */
     180       78354 :             return COSTS_DIFFERENT;
     181             :         }
     182             :         /* else path2 dominates */
     183     1714922 :         return COSTS_BETTER2;
     184             :     }
     185     1667040 :     if (path2->total_cost > path1->total_cost * fuzz_factor)
     186             :     {
     187             :         /* path2 fuzzily worse on total cost */
     188      888414 :         if (CONSIDER_PATH_STARTUP_COST(path2) &&
     189       50414 :             path1->startup_cost > path2->startup_cost * fuzz_factor)
     190             :         {
     191             :             /* ... but path1 fuzzily worse on startup, so DIFFERENT */
     192       33288 :             return COSTS_DIFFERENT;
     193             :         }
     194             :         /* else path1 dominates */
     195      855126 :         return COSTS_BETTER1;
     196             :     }
     197             :     /* fuzzily the same on total cost ... */
     198      778626 :     if (path1->startup_cost > path2->startup_cost * fuzz_factor)
     199             :     {
     200             :         /* ... but path1 fuzzily worse on startup, so path2 wins */
     201      292008 :         return COSTS_BETTER2;
     202             :     }
     203      486618 :     if (path2->startup_cost > path1->startup_cost * fuzz_factor)
     204             :     {
     205             :         /* ... but path2 fuzzily worse on startup, so path1 wins */
     206       47564 :         return COSTS_BETTER1;
     207             :     }
     208             :     /* fuzzily the same on both costs */
     209      439054 :     return COSTS_EQUAL;
     210             : 
     211             : #undef CONSIDER_PATH_STARTUP_COST
     212             : }
     213             : 
     214             : /*
     215             :  * set_cheapest
     216             :  *    Find the minimum-cost paths from among a relation's paths,
     217             :  *    and save them in the rel's cheapest-path fields.
     218             :  *
     219             :  * cheapest_total_path is normally the cheapest-total-cost unparameterized
     220             :  * path; but if there are no unparameterized paths, we assign it to be the
     221             :  * best (cheapest least-parameterized) parameterized path.  However, only
     222             :  * unparameterized paths are considered candidates for cheapest_startup_path,
     223             :  * so that will be NULL if there are no unparameterized paths.
     224             :  *
     225             :  * The cheapest_parameterized_paths list collects all parameterized paths
     226             :  * that have survived the add_path() tournament for this relation.  (Since
     227             :  * add_path ignores pathkeys for a parameterized path, these will be paths
     228             :  * that have best cost or best row count for their parameterization.  We
     229             :  * may also have both a parallel-safe and a non-parallel-safe path in some
     230             :  * cases for the same parameterization in some cases, but this should be
     231             :  * relatively rare since, most typically, all paths for the same relation
     232             :  * will be parallel-safe or none of them will.)
     233             :  *
     234             :  * cheapest_parameterized_paths always includes the cheapest-total
     235             :  * unparameterized path, too, if there is one; the users of that list find
     236             :  * it more convenient if that's included.
     237             :  *
     238             :  * This is normally called only after we've finished constructing the path
     239             :  * list for the rel node.
     240             :  */
     241             : void
     242     1858688 : set_cheapest(RelOptInfo *parent_rel)
     243             : {
     244             :     Path       *cheapest_startup_path;
     245             :     Path       *cheapest_total_path;
     246             :     Path       *best_param_path;
     247             :     List       *parameterized_paths;
     248             :     ListCell   *p;
     249             : 
     250             :     Assert(IsA(parent_rel, RelOptInfo));
     251             : 
     252     1858688 :     if (parent_rel->pathlist == NIL)
     253           0 :         elog(ERROR, "could not devise a query plan for the given query");
     254             : 
     255     1858688 :     cheapest_startup_path = cheapest_total_path = best_param_path = NULL;
     256     1858688 :     parameterized_paths = NIL;
     257             : 
     258     4146628 :     foreach(p, parent_rel->pathlist)
     259             :     {
     260     2287940 :         Path       *path = (Path *) lfirst(p);
     261             :         int         cmp;
     262             : 
     263     2287940 :         if (path->param_info)
     264             :         {
     265             :             /* Parameterized path, so add it to parameterized_paths */
     266      112788 :             parameterized_paths = lappend(parameterized_paths, path);
     267             : 
     268             :             /*
     269             :              * If we have an unparameterized cheapest-total, we no longer care
     270             :              * about finding the best parameterized path, so move on.
     271             :              */
     272      112788 :             if (cheapest_total_path)
     273       20792 :                 continue;
     274             : 
     275             :             /*
     276             :              * Otherwise, track the best parameterized path, which is the one
     277             :              * with least total cost among those of the minimum
     278             :              * parameterization.
     279             :              */
     280       91996 :             if (best_param_path == NULL)
     281       85060 :                 best_param_path = path;
     282             :             else
     283             :             {
     284        6936 :                 switch (bms_subset_compare(PATH_REQ_OUTER(path),
     285        6936 :                                            PATH_REQ_OUTER(best_param_path)))
     286             :                 {
     287          54 :                     case BMS_EQUAL:
     288             :                         /* keep the cheaper one */
     289          54 :                         if (compare_path_costs(path, best_param_path,
     290             :                                                TOTAL_COST) < 0)
     291           0 :                             best_param_path = path;
     292          54 :                         break;
     293         340 :                     case BMS_SUBSET1:
     294             :                         /* new path is less-parameterized */
     295         340 :                         best_param_path = path;
     296         340 :                         break;
     297           4 :                     case BMS_SUBSET2:
     298             :                         /* old path is less-parameterized, keep it */
     299           4 :                         break;
     300        6538 :                     case BMS_DIFFERENT:
     301             : 
     302             :                         /*
     303             :                          * This means that neither path has the least possible
     304             :                          * parameterization for the rel.  We'll sit on the old
     305             :                          * path until something better comes along.
     306             :                          */
     307        6538 :                         break;
     308             :                 }
     309       91996 :             }
     310             :         }
     311             :         else
     312             :         {
     313             :             /* Unparameterized path, so consider it for cheapest slots */
     314     2175152 :             if (cheapest_total_path == NULL)
     315             :             {
     316     1847912 :                 cheapest_startup_path = cheapest_total_path = path;
     317     1847912 :                 continue;
     318             :             }
     319             : 
     320             :             /*
     321             :              * If we find two paths of identical costs, try to keep the
     322             :              * better-sorted one.  The paths might have unrelated sort
     323             :              * orderings, in which case we can only guess which might be
     324             :              * better to keep, but if one is superior then we definitely
     325             :              * should keep that one.
     326             :              */
     327      327240 :             cmp = compare_path_costs(cheapest_startup_path, path, STARTUP_COST);
     328      327240 :             if (cmp > 0 ||
     329         368 :                 (cmp == 0 &&
     330         368 :                  compare_pathkeys(cheapest_startup_path->pathkeys,
     331             :                                   path->pathkeys) == PATHKEYS_BETTER2))
     332       57688 :                 cheapest_startup_path = path;
     333             : 
     334      327240 :             cmp = compare_path_costs(cheapest_total_path, path, TOTAL_COST);
     335      327240 :             if (cmp > 0 ||
     336          96 :                 (cmp == 0 &&
     337          96 :                  compare_pathkeys(cheapest_total_path->pathkeys,
     338             :                                   path->pathkeys) == PATHKEYS_BETTER2))
     339           0 :                 cheapest_total_path = path;
     340             :         }
     341             :     }
     342             : 
     343             :     /* Add cheapest unparameterized path, if any, to parameterized_paths */
     344     1858688 :     if (cheapest_total_path)
     345     1847912 :         parameterized_paths = lcons(cheapest_total_path, parameterized_paths);
     346             : 
     347             :     /*
     348             :      * If there is no unparameterized path, use the best parameterized path as
     349             :      * cheapest_total_path (but not as cheapest_startup_path).
     350             :      */
     351     1858688 :     if (cheapest_total_path == NULL)
     352       10776 :         cheapest_total_path = best_param_path;
     353             :     Assert(cheapest_total_path != NULL);
     354             : 
     355     1858688 :     parent_rel->cheapest_startup_path = cheapest_startup_path;
     356     1858688 :     parent_rel->cheapest_total_path = cheapest_total_path;
     357     1858688 :     parent_rel->cheapest_unique_path = NULL; /* computed only if needed */
     358     1858688 :     parent_rel->cheapest_parameterized_paths = parameterized_paths;
     359     1858688 : }
     360             : 
     361             : /*
     362             :  * add_path
     363             :  *    Consider a potential implementation path for the specified parent rel,
     364             :  *    and add it to the rel's pathlist if it is worthy of consideration.
     365             :  *    A path is worthy if it has a better sort order (better pathkeys) or
     366             :  *    cheaper cost (on either dimension), or generates fewer rows, than any
     367             :  *    existing path that has the same or superset parameterization rels.
     368             :  *    We also consider parallel-safe paths more worthy than others.
     369             :  *
     370             :  *    We also remove from the rel's pathlist any old paths that are dominated
     371             :  *    by new_path --- that is, new_path is cheaper, at least as well ordered,
     372             :  *    generates no more rows, requires no outer rels not required by the old
     373             :  *    path, and is no less parallel-safe.
     374             :  *
     375             :  *    In most cases, a path with a superset parameterization will generate
     376             :  *    fewer rows (since it has more join clauses to apply), so that those two
     377             :  *    figures of merit move in opposite directions; this means that a path of
     378             :  *    one parameterization can seldom dominate a path of another.  But such
     379             :  *    cases do arise, so we make the full set of checks anyway.
     380             :  *
     381             :  *    There are two policy decisions embedded in this function, along with
     382             :  *    its sibling add_path_precheck.  First, we treat all parameterized paths
     383             :  *    as having NIL pathkeys, so that they cannot win comparisons on the
     384             :  *    basis of sort order.  This is to reduce the number of parameterized
     385             :  *    paths that are kept; see discussion in src/backend/optimizer/README.
     386             :  *
     387             :  *    Second, we only consider cheap startup cost to be interesting if
     388             :  *    parent_rel->consider_startup is true for an unparameterized path, or
     389             :  *    parent_rel->consider_param_startup is true for a parameterized one.
     390             :  *    Again, this allows discarding useless paths sooner.
     391             :  *
     392             :  *    The pathlist is kept sorted by total_cost, with cheaper paths
     393             :  *    at the front.  Within this routine, that's simply a speed hack:
     394             :  *    doing it that way makes it more likely that we will reject an inferior
     395             :  *    path after a few comparisons, rather than many comparisons.
     396             :  *    However, add_path_precheck relies on this ordering to exit early
     397             :  *    when possible.
     398             :  *
     399             :  *    NOTE: discarded Path objects are immediately pfree'd to reduce planner
     400             :  *    memory consumption.  We dare not try to free the substructure of a Path,
     401             :  *    since much of it may be shared with other Paths or the query tree itself;
     402             :  *    but just recycling discarded Path nodes is a very useful savings in
     403             :  *    a large join tree.  We can recycle the List nodes of pathlist, too.
     404             :  *
     405             :  *    As noted in optimizer/README, deleting a previously-accepted Path is
     406             :  *    safe because we know that Paths of this rel cannot yet be referenced
     407             :  *    from any other rel, such as a higher-level join.  However, in some cases
     408             :  *    it is possible that a Path is referenced by another Path for its own
     409             :  *    rel; we must not delete such a Path, even if it is dominated by the new
     410             :  *    Path.  Currently this occurs only for IndexPath objects, which may be
     411             :  *    referenced as children of BitmapHeapPaths as well as being paths in
     412             :  *    their own right.  Hence, we don't pfree IndexPaths when rejecting them.
     413             :  *
     414             :  * 'parent_rel' is the relation entry to which the path corresponds.
     415             :  * 'new_path' is a potential path for parent_rel.
     416             :  *
     417             :  * Returns nothing, but modifies parent_rel->pathlist.
     418             :  */
     419             : void
     420     3621276 : add_path(RelOptInfo *parent_rel, Path *new_path)
     421             : {
     422     3621276 :     bool        accept_new = true;  /* unless we find a superior old path */
     423     3621276 :     int         insert_at = 0;  /* where to insert new item */
     424             :     List       *new_path_pathkeys;
     425             :     ListCell   *p1;
     426             : 
     427             :     /*
     428             :      * This is a convenient place to check for query cancel --- no part of the
     429             :      * planner goes very long without calling add_path().
     430             :      */
     431     3621276 :     CHECK_FOR_INTERRUPTS();
     432             : 
     433             :     /* Pretend parameterized paths have no pathkeys, per comment above */
     434     3621276 :     new_path_pathkeys = new_path->param_info ? NIL : new_path->pathkeys;
     435             : 
     436             :     /*
     437             :      * Loop to check proposed new path against old paths.  Note it is possible
     438             :      * for more than one old path to be tossed out because new_path dominates
     439             :      * it.
     440             :      */
     441     5525574 :     foreach(p1, parent_rel->pathlist)
     442             :     {
     443     3179956 :         Path       *old_path = (Path *) lfirst(p1);
     444     3179956 :         bool        remove_old = false; /* unless new proves superior */
     445             :         PathCostComparison costcmp;
     446             :         PathKeysComparison keyscmp;
     447             :         BMS_Comparison outercmp;
     448             : 
     449             :         /*
     450             :          * Do a fuzzy cost comparison with standard fuzziness limit.
     451             :          */
     452     3179956 :         costcmp = compare_path_costs_fuzzily(new_path, old_path,
     453             :                                              STD_FUZZ_FACTOR);
     454             : 
     455             :         /*
     456             :          * If the two paths compare differently for startup and total cost,
     457             :          * then we want to keep both, and we can skip comparing pathkeys and
     458             :          * required_outer rels.  If they compare the same, proceed with the
     459             :          * other comparisons.  Row count is checked last.  (We make the tests
     460             :          * in this order because the cost comparison is most likely to turn
     461             :          * out "different", and the pathkeys comparison next most likely.  As
     462             :          * explained above, row count very seldom makes a difference, so even
     463             :          * though it's cheap to compare there's not much point in checking it
     464             :          * earlier.)
     465             :          */
     466     3179956 :         if (costcmp != COSTS_DIFFERENT)
     467             :         {
     468             :             /* Similarly check to see if either dominates on pathkeys */
     469             :             List       *old_path_pathkeys;
     470             : 
     471     3068344 :             old_path_pathkeys = old_path->param_info ? NIL : old_path->pathkeys;
     472     3068344 :             keyscmp = compare_pathkeys(new_path_pathkeys,
     473             :                                        old_path_pathkeys);
     474     3068344 :             if (keyscmp != PATHKEYS_DIFFERENT)
     475             :             {
     476     2926946 :                 switch (costcmp)
     477             :                 {
     478      300908 :                     case COSTS_EQUAL:
     479      300908 :                         outercmp = bms_subset_compare(PATH_REQ_OUTER(new_path),
     480      300908 :                                                       PATH_REQ_OUTER(old_path));
     481      300908 :                         if (keyscmp == PATHKEYS_BETTER1)
     482             :                         {
     483        3256 :                             if ((outercmp == BMS_EQUAL ||
     484        3256 :                                  outercmp == BMS_SUBSET1) &&
     485        3256 :                                 new_path->rows <= old_path->rows &&
     486        3248 :                                 new_path->parallel_safe >= old_path->parallel_safe)
     487        3248 :                                 remove_old = true;  /* new dominates old */
     488             :                         }
     489      297652 :                         else if (keyscmp == PATHKEYS_BETTER2)
     490             :                         {
     491       13244 :                             if ((outercmp == BMS_EQUAL ||
     492       13244 :                                  outercmp == BMS_SUBSET2) &&
     493       13244 :                                 new_path->rows >= old_path->rows &&
     494       13100 :                                 new_path->parallel_safe <= old_path->parallel_safe)
     495       13100 :                                 accept_new = false; /* old dominates new */
     496             :                         }
     497             :                         else    /* keyscmp == PATHKEYS_EQUAL */
     498             :                         {
     499      284408 :                             if (outercmp == BMS_EQUAL)
     500             :                             {
     501             :                                 /*
     502             :                                  * Same pathkeys and outer rels, and fuzzily
     503             :                                  * the same cost, so keep just one; to decide
     504             :                                  * which, first check parallel-safety, then
     505             :                                  * rows, then do a fuzzy cost comparison with
     506             :                                  * very small fuzz limit.  (We used to do an
     507             :                                  * exact cost comparison, but that results in
     508             :                                  * annoying platform-specific plan variations
     509             :                                  * due to roundoff in the cost estimates.)  If
     510             :                                  * things are still tied, arbitrarily keep
     511             :                                  * only the old path.  Notice that we will
     512             :                                  * keep only the old path even if the
     513             :                                  * less-fuzzy comparison decides the startup
     514             :                                  * and total costs compare differently.
     515             :                                  */
     516      280590 :                                 if (new_path->parallel_safe >
     517      280590 :                                     old_path->parallel_safe)
     518          48 :                                     remove_old = true;  /* new dominates old */
     519      280542 :                                 else if (new_path->parallel_safe <
     520      280542 :                                          old_path->parallel_safe)
     521         142 :                                     accept_new = false; /* old dominates new */
     522      280400 :                                 else if (new_path->rows < old_path->rows)
     523          24 :                                     remove_old = true;  /* new dominates old */
     524      280376 :                                 else if (new_path->rows > old_path->rows)
     525          16 :                                     accept_new = false; /* old dominates new */
     526      280360 :                                 else if (compare_path_costs_fuzzily(new_path,
     527             :                                                                     old_path,
     528             :                                                                     1.0000000001) == COSTS_BETTER1)
     529       12828 :                                     remove_old = true;  /* new dominates old */
     530             :                                 else
     531      267532 :                                     accept_new = false; /* old equals or
     532             :                                                          * dominates new */
     533             :                             }
     534        3818 :                             else if (outercmp == BMS_SUBSET1 &&
     535         794 :                                      new_path->rows <= old_path->rows &&
     536         766 :                                      new_path->parallel_safe >= old_path->parallel_safe)
     537         766 :                                 remove_old = true;  /* new dominates old */
     538        3052 :                             else if (outercmp == BMS_SUBSET2 &&
     539        2578 :                                      new_path->rows >= old_path->rows &&
     540        2558 :                                      new_path->parallel_safe <= old_path->parallel_safe)
     541        2558 :                                 accept_new = false; /* old dominates new */
     542             :                             /* else different parameterizations, keep both */
     543             :                         }
     544      300908 :                         break;
     545      868862 :                     case COSTS_BETTER1:
     546      868862 :                         if (keyscmp != PATHKEYS_BETTER2)
     547             :                         {
     548      604506 :                             outercmp = bms_subset_compare(PATH_REQ_OUTER(new_path),
     549      604506 :                                                           PATH_REQ_OUTER(old_path));
     550      604506 :                             if ((outercmp == BMS_EQUAL ||
     551      515640 :                                  outercmp == BMS_SUBSET1) &&
     552      515640 :                                 new_path->rows <= old_path->rows &&
     553      512208 :                                 new_path->parallel_safe >= old_path->parallel_safe)
     554      509566 :                                 remove_old = true;  /* new dominates old */
     555             :                         }
     556      868862 :                         break;
     557     1757176 :                     case COSTS_BETTER2:
     558     1757176 :                         if (keyscmp != PATHKEYS_BETTER1)
     559             :                         {
     560     1127852 :                             outercmp = bms_subset_compare(PATH_REQ_OUTER(new_path),
     561     1127852 :                                                           PATH_REQ_OUTER(old_path));
     562     1127852 :                             if ((outercmp == BMS_EQUAL ||
     563     1045154 :                                  outercmp == BMS_SUBSET2) &&
     564     1045154 :                                 new_path->rows >= old_path->rows &&
     565      993980 :                                 new_path->parallel_safe <= old_path->parallel_safe)
     566      992310 :                                 accept_new = false; /* old dominates new */
     567             :                         }
     568     1757176 :                         break;
     569           0 :                     case COSTS_DIFFERENT:
     570             : 
     571             :                         /*
     572             :                          * can't get here, but keep this case to keep compiler
     573             :                          * quiet
     574             :                          */
     575           0 :                         break;
     576             :                 }
     577      253010 :             }
     578             :         }
     579             : 
     580             :         /*
     581             :          * Remove current element from pathlist if dominated by new.
     582             :          */
     583     3179956 :         if (remove_old)
     584             :         {
     585      526480 :             parent_rel->pathlist = foreach_delete_current(parent_rel->pathlist,
     586             :                                                           p1);
     587             : 
     588             :             /*
     589             :              * Delete the data pointed-to by the deleted cell, if possible
     590             :              */
     591      526480 :             if (!IsA(old_path, IndexPath))
     592      508896 :                 pfree(old_path);
     593             :         }
     594             :         else
     595             :         {
     596             :             /* new belongs after this old path if it has cost >= old's */
     597     2653476 :             if (new_path->total_cost >= old_path->total_cost)
     598     2200016 :                 insert_at = foreach_current_index(p1) + 1;
     599             :         }
     600             : 
     601             :         /*
     602             :          * If we found an old path that dominates new_path, we can quit
     603             :          * scanning the pathlist; we will not add new_path, and we assume
     604             :          * new_path cannot dominate any other elements of the pathlist.
     605             :          */
     606     3179956 :         if (!accept_new)
     607     1275658 :             break;
     608             :     }
     609             : 
     610     3621276 :     if (accept_new)
     611             :     {
     612             :         /* Accept the new path: insert it at proper place in pathlist */
     613     2345618 :         parent_rel->pathlist =
     614     2345618 :             list_insert_nth(parent_rel->pathlist, insert_at, new_path);
     615             :     }
     616             :     else
     617             :     {
     618             :         /* Reject and recycle the new path */
     619     1275658 :         if (!IsA(new_path, IndexPath))
     620     1202236 :             pfree(new_path);
     621             :     }
     622     3621276 : }
     623             : 
     624             : /*
     625             :  * add_path_precheck
     626             :  *    Check whether a proposed new path could possibly get accepted.
     627             :  *    We assume we know the path's pathkeys and parameterization accurately,
     628             :  *    and have lower bounds for its costs.
     629             :  *
     630             :  * Note that we do not know the path's rowcount, since getting an estimate for
     631             :  * that is too expensive to do before prechecking.  We assume here that paths
     632             :  * of a superset parameterization will generate fewer rows; if that holds,
     633             :  * then paths with different parameterizations cannot dominate each other
     634             :  * and so we can simply ignore existing paths of another parameterization.
     635             :  * (In the infrequent cases where that rule of thumb fails, add_path will
     636             :  * get rid of the inferior path.)
     637             :  *
     638             :  * At the time this is called, we haven't actually built a Path structure,
     639             :  * so the required information has to be passed piecemeal.
     640             :  */
     641             : bool
     642     3739878 : add_path_precheck(RelOptInfo *parent_rel,
     643             :                   Cost startup_cost, Cost total_cost,
     644             :                   List *pathkeys, Relids required_outer)
     645             : {
     646             :     List       *new_path_pathkeys;
     647             :     bool        consider_startup;
     648             :     ListCell   *p1;
     649             : 
     650             :     /* Pretend parameterized paths have no pathkeys, per add_path policy */
     651     3739878 :     new_path_pathkeys = required_outer ? NIL : pathkeys;
     652             : 
     653             :     /* Decide whether new path's startup cost is interesting */
     654     3739878 :     consider_startup = required_outer ? parent_rel->consider_param_startup : parent_rel->consider_startup;
     655             : 
     656     4884702 :     foreach(p1, parent_rel->pathlist)
     657             :     {
     658     4637486 :         Path       *old_path = (Path *) lfirst(p1);
     659             :         PathKeysComparison keyscmp;
     660             : 
     661             :         /*
     662             :          * We are looking for an old_path with the same parameterization (and
     663             :          * by assumption the same rowcount) that dominates the new path on
     664             :          * pathkeys as well as both cost metrics.  If we find one, we can
     665             :          * reject the new path.
     666             :          *
     667             :          * Cost comparisons here should match compare_path_costs_fuzzily.
     668             :          */
     669     4637486 :         if (total_cost > old_path->total_cost * STD_FUZZ_FACTOR)
     670             :         {
     671             :             /* new path can win on startup cost only if consider_startup */
     672     3302244 :             if (startup_cost > old_path->startup_cost * STD_FUZZ_FACTOR ||
     673     1507794 :                 !consider_startup)
     674             :             {
     675             :                 /* new path loses on cost, so check pathkeys... */
     676             :                 List       *old_path_pathkeys;
     677             : 
     678     3211010 :                 old_path_pathkeys = old_path->param_info ? NIL : old_path->pathkeys;
     679     3211010 :                 keyscmp = compare_pathkeys(new_path_pathkeys,
     680             :                                            old_path_pathkeys);
     681     3211010 :                 if (keyscmp == PATHKEYS_EQUAL ||
     682             :                     keyscmp == PATHKEYS_BETTER2)
     683             :                 {
     684             :                     /* new path does not win on pathkeys... */
     685     2232006 :                     if (bms_equal(required_outer, PATH_REQ_OUTER(old_path)))
     686             :                     {
     687             :                         /* Found an old path that dominates the new one */
     688     2157420 :                         return false;
     689             :                     }
     690             :                 }
     691             :             }
     692             :         }
     693             :         else
     694             :         {
     695             :             /*
     696             :              * Since the pathlist is sorted by total_cost, we can stop looking
     697             :              * once we reach a path with a total_cost larger than the new
     698             :              * path's.
     699             :              */
     700     1335242 :             break;
     701             :         }
     702             :     }
     703             : 
     704     1582458 :     return true;
     705             : }
     706             : 
     707             : /*
     708             :  * add_partial_path
     709             :  *    Like add_path, our goal here is to consider whether a path is worthy
     710             :  *    of being kept around, but the considerations here are a bit different.
     711             :  *    A partial path is one which can be executed in any number of workers in
     712             :  *    parallel such that each worker will generate a subset of the path's
     713             :  *    overall result.
     714             :  *
     715             :  *    As in add_path, the partial_pathlist is kept sorted with the cheapest
     716             :  *    total path in front.  This is depended on by multiple places, which
     717             :  *    just take the front entry as the cheapest path without searching.
     718             :  *
     719             :  *    We don't generate parameterized partial paths for several reasons.  Most
     720             :  *    importantly, they're not safe to execute, because there's nothing to
     721             :  *    make sure that a parallel scan within the parameterized portion of the
     722             :  *    plan is running with the same value in every worker at the same time.
     723             :  *    Fortunately, it seems unlikely to be worthwhile anyway, because having
     724             :  *    each worker scan the entire outer relation and a subset of the inner
     725             :  *    relation will generally be a terrible plan.  The inner (parameterized)
     726             :  *    side of the plan will be small anyway.  There could be rare cases where
     727             :  *    this wins big - e.g. if join order constraints put a 1-row relation on
     728             :  *    the outer side of the topmost join with a parameterized plan on the inner
     729             :  *    side - but we'll have to be content not to handle such cases until
     730             :  *    somebody builds an executor infrastructure that can cope with them.
     731             :  *
     732             :  *    Because we don't consider parameterized paths here, we also don't
     733             :  *    need to consider the row counts as a measure of quality: every path will
     734             :  *    produce the same number of rows.  Neither do we need to consider startup
     735             :  *    costs: parallelism is only used for plans that will be run to completion.
     736             :  *    Therefore, this routine is much simpler than add_path: it needs to
     737             :  *    consider only pathkeys and total cost.
     738             :  *
     739             :  *    As with add_path, we pfree paths that are found to be dominated by
     740             :  *    another partial path; this requires that there be no other references to
     741             :  *    such paths yet.  Hence, GatherPaths must not be created for a rel until
     742             :  *    we're done creating all partial paths for it.  Unlike add_path, we don't
     743             :  *    take an exception for IndexPaths as partial index paths won't be
     744             :  *    referenced by partial BitmapHeapPaths.
     745             :  */
     746             : void
     747       92518 : add_partial_path(RelOptInfo *parent_rel, Path *new_path)
     748             : {
     749       92518 :     bool        accept_new = true;  /* unless we find a superior old path */
     750       92518 :     int         insert_at = 0;  /* where to insert new item */
     751             :     ListCell   *p1;
     752             : 
     753             :     /* Check for query cancel. */
     754       92518 :     CHECK_FOR_INTERRUPTS();
     755             : 
     756             :     /* Path to be added must be parallel safe. */
     757             :     Assert(new_path->parallel_safe);
     758             : 
     759             :     /* Relation should be OK for parallelism, too. */
     760             :     Assert(parent_rel->consider_parallel);
     761             : 
     762             :     /*
     763             :      * As in add_path, throw out any paths which are dominated by the new
     764             :      * path, but throw out the new path if some existing path dominates it.
     765             :      */
     766      124564 :     foreach(p1, parent_rel->partial_pathlist)
     767             :     {
     768       46762 :         Path       *old_path = (Path *) lfirst(p1);
     769       46762 :         bool        remove_old = false; /* unless new proves superior */
     770             :         PathKeysComparison keyscmp;
     771             : 
     772             :         /* Compare pathkeys. */
     773       46762 :         keyscmp = compare_pathkeys(new_path->pathkeys, old_path->pathkeys);
     774             : 
     775             :         /* Unless pathkeys are incompatible, keep just one of the two paths. */
     776       46762 :         if (keyscmp != PATHKEYS_DIFFERENT)
     777             :         {
     778       46564 :             if (new_path->total_cost > old_path->total_cost * STD_FUZZ_FACTOR)
     779             :             {
     780             :                 /* New path costs more; keep it only if pathkeys are better. */
     781       14978 :                 if (keyscmp != PATHKEYS_BETTER1)
     782        6510 :                     accept_new = false;
     783             :             }
     784       31586 :             else if (old_path->total_cost > new_path->total_cost
     785       31586 :                      * STD_FUZZ_FACTOR)
     786             :             {
     787             :                 /* Old path costs more; keep it only if pathkeys are better. */
     788       23048 :                 if (keyscmp != PATHKEYS_BETTER2)
     789       11930 :                     remove_old = true;
     790             :             }
     791        8538 :             else if (keyscmp == PATHKEYS_BETTER1)
     792             :             {
     793             :                 /* Costs are about the same, new path has better pathkeys. */
     794           0 :                 remove_old = true;
     795             :             }
     796        8538 :             else if (keyscmp == PATHKEYS_BETTER2)
     797             :             {
     798             :                 /* Costs are about the same, old path has better pathkeys. */
     799        1668 :                 accept_new = false;
     800             :             }
     801        6870 :             else if (old_path->total_cost > new_path->total_cost * 1.0000000001)
     802             :             {
     803             :                 /* Pathkeys are the same, and the old path costs more. */
     804         332 :                 remove_old = true;
     805             :             }
     806             :             else
     807             :             {
     808             :                 /*
     809             :                  * Pathkeys are the same, and new path isn't materially
     810             :                  * cheaper.
     811             :                  */
     812        6538 :                 accept_new = false;
     813             :             }
     814             :         }
     815             : 
     816             :         /*
     817             :          * Remove current element from partial_pathlist if dominated by new.
     818             :          */
     819       46762 :         if (remove_old)
     820             :         {
     821       12262 :             parent_rel->partial_pathlist =
     822       12262 :                 foreach_delete_current(parent_rel->partial_pathlist, p1);
     823       12262 :             pfree(old_path);
     824             :         }
     825             :         else
     826             :         {
     827             :             /* new belongs after this old path if it has cost >= old's */
     828       34500 :             if (new_path->total_cost >= old_path->total_cost)
     829       22956 :                 insert_at = foreach_current_index(p1) + 1;
     830             :         }
     831             : 
     832             :         /*
     833             :          * If we found an old path that dominates new_path, we can quit
     834             :          * scanning the partial_pathlist; we will not add new_path, and we
     835             :          * assume new_path cannot dominate any later path.
     836             :          */
     837       46762 :         if (!accept_new)
     838       14716 :             break;
     839             :     }
     840             : 
     841       92518 :     if (accept_new)
     842             :     {
     843             :         /* Accept the new path: insert it at proper place */
     844       77802 :         parent_rel->partial_pathlist =
     845       77802 :             list_insert_nth(parent_rel->partial_pathlist, insert_at, new_path);
     846             :     }
     847             :     else
     848             :     {
     849             :         /* Reject and recycle the new path */
     850       14716 :         pfree(new_path);
     851             :     }
     852       92518 : }
     853             : 
     854             : /*
     855             :  * add_partial_path_precheck
     856             :  *    Check whether a proposed new partial path could possibly get accepted.
     857             :  *
     858             :  * Unlike add_path_precheck, we can ignore startup cost and parameterization,
     859             :  * since they don't matter for partial paths (see add_partial_path).  But
     860             :  * we do want to make sure we don't add a partial path if there's already
     861             :  * a complete path that dominates it, since in that case the proposed path
     862             :  * is surely a loser.
     863             :  */
     864             : bool
     865       63342 : add_partial_path_precheck(RelOptInfo *parent_rel, Cost total_cost,
     866             :                           List *pathkeys)
     867             : {
     868             :     ListCell   *p1;
     869             : 
     870             :     /*
     871             :      * Our goal here is twofold.  First, we want to find out whether this path
     872             :      * is clearly inferior to some existing partial path.  If so, we want to
     873             :      * reject it immediately.  Second, we want to find out whether this path
     874             :      * is clearly superior to some existing partial path -- at least, modulo
     875             :      * final cost computations.  If so, we definitely want to consider it.
     876             :      *
     877             :      * Unlike add_path(), we always compare pathkeys here.  This is because we
     878             :      * expect partial_pathlist to be very short, and getting a definitive
     879             :      * answer at this stage avoids the need to call add_path_precheck.
     880             :      */
     881       88598 :     foreach(p1, parent_rel->partial_pathlist)
     882             :     {
     883       70750 :         Path       *old_path = (Path *) lfirst(p1);
     884             :         PathKeysComparison keyscmp;
     885             : 
     886       70750 :         keyscmp = compare_pathkeys(pathkeys, old_path->pathkeys);
     887       70750 :         if (keyscmp != PATHKEYS_DIFFERENT)
     888             :         {
     889       70558 :             if (total_cost > old_path->total_cost * STD_FUZZ_FACTOR &&
     890             :                 keyscmp != PATHKEYS_BETTER1)
     891       45494 :                 return false;
     892       35354 :             if (old_path->total_cost > total_cost * STD_FUZZ_FACTOR &&
     893             :                 keyscmp != PATHKEYS_BETTER2)
     894       10290 :                 return true;
     895             :         }
     896             :     }
     897             : 
     898             :     /*
     899             :      * This path is neither clearly inferior to an existing partial path nor
     900             :      * clearly good enough that it might replace one.  Compare it to
     901             :      * non-parallel plans.  If it loses even before accounting for the cost of
     902             :      * the Gather node, we should definitely reject it.
     903             :      *
     904             :      * Note that we pass the total_cost to add_path_precheck twice.  This is
     905             :      * because it's never advantageous to consider the startup cost of a
     906             :      * partial path; the resulting plans, if run in parallel, will be run to
     907             :      * completion.
     908             :      */
     909       17848 :     if (!add_path_precheck(parent_rel, total_cost, total_cost, pathkeys,
     910             :                            NULL))
     911         700 :         return false;
     912             : 
     913       17148 :     return true;
     914             : }
     915             : 
     916             : 
     917             : /*****************************************************************************
     918             :  *      PATH NODE CREATION ROUTINES
     919             :  *****************************************************************************/
     920             : 
     921             : /*
     922             :  * create_seqscan_path
     923             :  *    Creates a path corresponding to a sequential scan, returning the
     924             :  *    pathnode.
     925             :  */
     926             : Path *
     927      370752 : create_seqscan_path(PlannerInfo *root, RelOptInfo *rel,
     928             :                     Relids required_outer, int parallel_workers)
     929             : {
     930      370752 :     Path       *pathnode = makeNode(Path);
     931             : 
     932      370752 :     pathnode->pathtype = T_SeqScan;
     933      370752 :     pathnode->parent = rel;
     934      370752 :     pathnode->pathtarget = rel->reltarget;
     935      370752 :     pathnode->param_info = get_baserel_parampathinfo(root, rel,
     936             :                                                      required_outer);
     937      370752 :     pathnode->parallel_aware = (parallel_workers > 0);
     938      370752 :     pathnode->parallel_safe = rel->consider_parallel;
     939      370752 :     pathnode->parallel_workers = parallel_workers;
     940      370752 :     pathnode->pathkeys = NIL;    /* seqscan has unordered result */
     941             : 
     942      370752 :     cost_seqscan(pathnode, root, rel, pathnode->param_info);
     943             : 
     944      370752 :     return pathnode;
     945             : }
     946             : 
     947             : /*
     948             :  * create_samplescan_path
     949             :  *    Creates a path node for a sampled table scan.
     950             :  */
     951             : Path *
     952         300 : create_samplescan_path(PlannerInfo *root, RelOptInfo *rel, Relids required_outer)
     953             : {
     954         300 :     Path       *pathnode = makeNode(Path);
     955             : 
     956         300 :     pathnode->pathtype = T_SampleScan;
     957         300 :     pathnode->parent = rel;
     958         300 :     pathnode->pathtarget = rel->reltarget;
     959         300 :     pathnode->param_info = get_baserel_parampathinfo(root, rel,
     960             :                                                      required_outer);
     961         300 :     pathnode->parallel_aware = false;
     962         300 :     pathnode->parallel_safe = rel->consider_parallel;
     963         300 :     pathnode->parallel_workers = 0;
     964         300 :     pathnode->pathkeys = NIL;    /* samplescan has unordered result */
     965             : 
     966         300 :     cost_samplescan(pathnode, root, rel, pathnode->param_info);
     967             : 
     968         300 :     return pathnode;
     969             : }
     970             : 
     971             : /*
     972             :  * create_index_path
     973             :  *    Creates a path node for an index scan.
     974             :  *
     975             :  * 'index' is a usable index.
     976             :  * 'indexclauses' is a list of IndexClause nodes representing clauses
     977             :  *          to be enforced as qual conditions in the scan.
     978             :  * 'indexorderbys' is a list of bare expressions (no RestrictInfos)
     979             :  *          to be used as index ordering operators in the scan.
     980             :  * 'indexorderbycols' is an integer list of index column numbers (zero based)
     981             :  *          the ordering operators can be used with.
     982             :  * 'pathkeys' describes the ordering of the path.
     983             :  * 'indexscandir' is either ForwardScanDirection or BackwardScanDirection.
     984             :  * 'indexonly' is true if an index-only scan is wanted.
     985             :  * 'required_outer' is the set of outer relids for a parameterized path.
     986             :  * 'loop_count' is the number of repetitions of the indexscan to factor into
     987             :  *      estimates of caching behavior.
     988             :  * 'partial_path' is true if constructing a parallel index scan path.
     989             :  *
     990             :  * Returns the new path node.
     991             :  */
     992             : IndexPath *
     993      643440 : create_index_path(PlannerInfo *root,
     994             :                   IndexOptInfo *index,
     995             :                   List *indexclauses,
     996             :                   List *indexorderbys,
     997             :                   List *indexorderbycols,
     998             :                   List *pathkeys,
     999             :                   ScanDirection indexscandir,
    1000             :                   bool indexonly,
    1001             :                   Relids required_outer,
    1002             :                   double loop_count,
    1003             :                   bool partial_path)
    1004             : {
    1005      643440 :     IndexPath  *pathnode = makeNode(IndexPath);
    1006      643440 :     RelOptInfo *rel = index->rel;
    1007             : 
    1008      643440 :     pathnode->path.pathtype = indexonly ? T_IndexOnlyScan : T_IndexScan;
    1009      643440 :     pathnode->path.parent = rel;
    1010      643440 :     pathnode->path.pathtarget = rel->reltarget;
    1011      643440 :     pathnode->path.param_info = get_baserel_parampathinfo(root, rel,
    1012             :                                                           required_outer);
    1013      643440 :     pathnode->path.parallel_aware = false;
    1014      643440 :     pathnode->path.parallel_safe = rel->consider_parallel;
    1015      643440 :     pathnode->path.parallel_workers = 0;
    1016      643440 :     pathnode->path.pathkeys = pathkeys;
    1017             : 
    1018      643440 :     pathnode->indexinfo = index;
    1019      643440 :     pathnode->indexclauses = indexclauses;
    1020      643440 :     pathnode->indexorderbys = indexorderbys;
    1021      643440 :     pathnode->indexorderbycols = indexorderbycols;
    1022      643440 :     pathnode->indexscandir = indexscandir;
    1023             : 
    1024      643440 :     cost_index(pathnode, root, loop_count, partial_path);
    1025             : 
    1026      643440 :     return pathnode;
    1027             : }
    1028             : 
    1029             : /*
    1030             :  * create_bitmap_heap_path
    1031             :  *    Creates a path node for a bitmap scan.
    1032             :  *
    1033             :  * 'bitmapqual' is a tree of IndexPath, BitmapAndPath, and BitmapOrPath nodes.
    1034             :  * 'required_outer' is the set of outer relids for a parameterized path.
    1035             :  * 'loop_count' is the number of repetitions of the indexscan to factor into
    1036             :  *      estimates of caching behavior.
    1037             :  *
    1038             :  * loop_count should match the value used when creating the component
    1039             :  * IndexPaths.
    1040             :  */
    1041             : BitmapHeapPath *
    1042      290220 : create_bitmap_heap_path(PlannerInfo *root,
    1043             :                         RelOptInfo *rel,
    1044             :                         Path *bitmapqual,
    1045             :                         Relids required_outer,
    1046             :                         double loop_count,
    1047             :                         int parallel_degree)
    1048             : {
    1049      290220 :     BitmapHeapPath *pathnode = makeNode(BitmapHeapPath);
    1050             : 
    1051      290220 :     pathnode->path.pathtype = T_BitmapHeapScan;
    1052      290220 :     pathnode->path.parent = rel;
    1053      290220 :     pathnode->path.pathtarget = rel->reltarget;
    1054      290220 :     pathnode->path.param_info = get_baserel_parampathinfo(root, rel,
    1055             :                                                           required_outer);
    1056      290220 :     pathnode->path.parallel_aware = (parallel_degree > 0);
    1057      290220 :     pathnode->path.parallel_safe = rel->consider_parallel;
    1058      290220 :     pathnode->path.parallel_workers = parallel_degree;
    1059      290220 :     pathnode->path.pathkeys = NIL;   /* always unordered */
    1060             : 
    1061      290220 :     pathnode->bitmapqual = bitmapqual;
    1062             : 
    1063      290220 :     cost_bitmap_heap_scan(&pathnode->path, root, rel,
    1064             :                           pathnode->path.param_info,
    1065             :                           bitmapqual, loop_count);
    1066             : 
    1067      290220 :     return pathnode;
    1068             : }
    1069             : 
    1070             : /*
    1071             :  * create_bitmap_and_path
    1072             :  *    Creates a path node representing a BitmapAnd.
    1073             :  */
    1074             : BitmapAndPath *
    1075       33738 : create_bitmap_and_path(PlannerInfo *root,
    1076             :                        RelOptInfo *rel,
    1077             :                        List *bitmapquals)
    1078             : {
    1079       33738 :     BitmapAndPath *pathnode = makeNode(BitmapAndPath);
    1080       33738 :     Relids      required_outer = NULL;
    1081             :     ListCell   *lc;
    1082             : 
    1083       33738 :     pathnode->path.pathtype = T_BitmapAnd;
    1084       33738 :     pathnode->path.parent = rel;
    1085       33738 :     pathnode->path.pathtarget = rel->reltarget;
    1086             : 
    1087             :     /*
    1088             :      * Identify the required outer rels as the union of what the child paths
    1089             :      * depend on.  (Alternatively, we could insist that the caller pass this
    1090             :      * in, but it's more convenient and reliable to compute it here.)
    1091             :      */
    1092      101214 :     foreach(lc, bitmapquals)
    1093             :     {
    1094       67476 :         Path       *bitmapqual = (Path *) lfirst(lc);
    1095             : 
    1096       67476 :         required_outer = bms_add_members(required_outer,
    1097       67476 :                                          PATH_REQ_OUTER(bitmapqual));
    1098             :     }
    1099       33738 :     pathnode->path.param_info = get_baserel_parampathinfo(root, rel,
    1100             :                                                           required_outer);
    1101             : 
    1102             :     /*
    1103             :      * Currently, a BitmapHeapPath, BitmapAndPath, or BitmapOrPath will be
    1104             :      * parallel-safe if and only if rel->consider_parallel is set.  So, we can
    1105             :      * set the flag for this path based only on the relation-level flag,
    1106             :      * without actually iterating over the list of children.
    1107             :      */
    1108       33738 :     pathnode->path.parallel_aware = false;
    1109       33738 :     pathnode->path.parallel_safe = rel->consider_parallel;
    1110       33738 :     pathnode->path.parallel_workers = 0;
    1111             : 
    1112       33738 :     pathnode->path.pathkeys = NIL;   /* always unordered */
    1113             : 
    1114       33738 :     pathnode->bitmapquals = bitmapquals;
    1115             : 
    1116             :     /* this sets bitmapselectivity as well as the regular cost fields: */
    1117       33738 :     cost_bitmap_and_node(pathnode, root);
    1118             : 
    1119       33738 :     return pathnode;
    1120             : }
    1121             : 
    1122             : /*
    1123             :  * create_bitmap_or_path
    1124             :  *    Creates a path node representing a BitmapOr.
    1125             :  */
    1126             : BitmapOrPath *
    1127         960 : create_bitmap_or_path(PlannerInfo *root,
    1128             :                       RelOptInfo *rel,
    1129             :                       List *bitmapquals)
    1130             : {
    1131         960 :     BitmapOrPath *pathnode = makeNode(BitmapOrPath);
    1132         960 :     Relids      required_outer = NULL;
    1133             :     ListCell   *lc;
    1134             : 
    1135         960 :     pathnode->path.pathtype = T_BitmapOr;
    1136         960 :     pathnode->path.parent = rel;
    1137         960 :     pathnode->path.pathtarget = rel->reltarget;
    1138             : 
    1139             :     /*
    1140             :      * Identify the required outer rels as the union of what the child paths
    1141             :      * depend on.  (Alternatively, we could insist that the caller pass this
    1142             :      * in, but it's more convenient and reliable to compute it here.)
    1143             :      */
    1144        2940 :     foreach(lc, bitmapquals)
    1145             :     {
    1146        1980 :         Path       *bitmapqual = (Path *) lfirst(lc);
    1147             : 
    1148        1980 :         required_outer = bms_add_members(required_outer,
    1149        1980 :                                          PATH_REQ_OUTER(bitmapqual));
    1150             :     }
    1151         960 :     pathnode->path.param_info = get_baserel_parampathinfo(root, rel,
    1152             :                                                           required_outer);
    1153             : 
    1154             :     /*
    1155             :      * Currently, a BitmapHeapPath, BitmapAndPath, or BitmapOrPath will be
    1156             :      * parallel-safe if and only if rel->consider_parallel is set.  So, we can
    1157             :      * set the flag for this path based only on the relation-level flag,
    1158             :      * without actually iterating over the list of children.
    1159             :      */
    1160         960 :     pathnode->path.parallel_aware = false;
    1161         960 :     pathnode->path.parallel_safe = rel->consider_parallel;
    1162         960 :     pathnode->path.parallel_workers = 0;
    1163             : 
    1164         960 :     pathnode->path.pathkeys = NIL;   /* always unordered */
    1165             : 
    1166         960 :     pathnode->bitmapquals = bitmapquals;
    1167             : 
    1168             :     /* this sets bitmapselectivity as well as the regular cost fields: */
    1169         960 :     cost_bitmap_or_node(pathnode, root);
    1170             : 
    1171         960 :     return pathnode;
    1172             : }
    1173             : 
    1174             : /*
    1175             :  * create_tidscan_path
    1176             :  *    Creates a path corresponding to a scan by TID, returning the pathnode.
    1177             :  */
    1178             : TidPath *
    1179         756 : create_tidscan_path(PlannerInfo *root, RelOptInfo *rel, List *tidquals,
    1180             :                     Relids required_outer)
    1181             : {
    1182         756 :     TidPath    *pathnode = makeNode(TidPath);
    1183             : 
    1184         756 :     pathnode->path.pathtype = T_TidScan;
    1185         756 :     pathnode->path.parent = rel;
    1186         756 :     pathnode->path.pathtarget = rel->reltarget;
    1187         756 :     pathnode->path.param_info = get_baserel_parampathinfo(root, rel,
    1188             :                                                           required_outer);
    1189         756 :     pathnode->path.parallel_aware = false;
    1190         756 :     pathnode->path.parallel_safe = rel->consider_parallel;
    1191         756 :     pathnode->path.parallel_workers = 0;
    1192         756 :     pathnode->path.pathkeys = NIL;   /* always unordered */
    1193             : 
    1194         756 :     pathnode->tidquals = tidquals;
    1195             : 
    1196         756 :     cost_tidscan(&pathnode->path, root, rel, tidquals,
    1197             :                  pathnode->path.param_info);
    1198             : 
    1199         756 :     return pathnode;
    1200             : }
    1201             : 
    1202             : /*
    1203             :  * create_tidrangescan_path
    1204             :  *    Creates a path corresponding to a scan by a range of TIDs, returning
    1205             :  *    the pathnode.
    1206             :  */
    1207             : TidRangePath *
    1208         202 : create_tidrangescan_path(PlannerInfo *root, RelOptInfo *rel,
    1209             :                          List *tidrangequals, Relids required_outer)
    1210             : {
    1211         202 :     TidRangePath *pathnode = makeNode(TidRangePath);
    1212             : 
    1213         202 :     pathnode->path.pathtype = T_TidRangeScan;
    1214         202 :     pathnode->path.parent = rel;
    1215         202 :     pathnode->path.pathtarget = rel->reltarget;
    1216         202 :     pathnode->path.param_info = get_baserel_parampathinfo(root, rel,
    1217             :                                                           required_outer);
    1218         202 :     pathnode->path.parallel_aware = false;
    1219         202 :     pathnode->path.parallel_safe = rel->consider_parallel;
    1220         202 :     pathnode->path.parallel_workers = 0;
    1221         202 :     pathnode->path.pathkeys = NIL;   /* always unordered */
    1222             : 
    1223         202 :     pathnode->tidrangequals = tidrangequals;
    1224             : 
    1225         202 :     cost_tidrangescan(&pathnode->path, root, rel, tidrangequals,
    1226             :                       pathnode->path.param_info);
    1227             : 
    1228         202 :     return pathnode;
    1229             : }
    1230             : 
    1231             : /*
    1232             :  * create_append_path
    1233             :  *    Creates a path corresponding to an Append plan, returning the
    1234             :  *    pathnode.
    1235             :  *
    1236             :  * Note that we must handle subpaths = NIL, representing a dummy access path.
    1237             :  * Also, there are callers that pass root = NULL.
    1238             :  *
    1239             :  * 'rows', when passed as a non-negative number, will be used to overwrite the
    1240             :  * returned path's row estimate.  Otherwise, the row estimate is calculated
    1241             :  * by totalling the row estimates from the 'subpaths' list.
    1242             :  */
    1243             : AppendPath *
    1244       67400 : create_append_path(PlannerInfo *root,
    1245             :                    RelOptInfo *rel,
    1246             :                    List *subpaths, List *partial_subpaths,
    1247             :                    List *pathkeys, Relids required_outer,
    1248             :                    int parallel_workers, bool parallel_aware,
    1249             :                    double rows)
    1250             : {
    1251       67400 :     AppendPath *pathnode = makeNode(AppendPath);
    1252             :     ListCell   *l;
    1253             : 
    1254             :     Assert(!parallel_aware || parallel_workers > 0);
    1255             : 
    1256       67400 :     pathnode->path.pathtype = T_Append;
    1257       67400 :     pathnode->path.parent = rel;
    1258       67400 :     pathnode->path.pathtarget = rel->reltarget;
    1259             : 
    1260             :     /*
    1261             :      * If this is for a baserel (not a join or non-leaf partition), we prefer
    1262             :      * to apply get_baserel_parampathinfo to construct a full ParamPathInfo
    1263             :      * for the path.  This supports building a Memoize path atop this path,
    1264             :      * and if this is a partitioned table the info may be useful for run-time
    1265             :      * pruning (cf make_partition_pruneinfo()).
    1266             :      *
    1267             :      * However, if we don't have "root" then that won't work and we fall back
    1268             :      * on the simpler get_appendrel_parampathinfo.  There's no point in doing
    1269             :      * the more expensive thing for a dummy path, either.
    1270             :      */
    1271       67400 :     if (rel->reloptkind == RELOPT_BASEREL && root && subpaths != NIL)
    1272       30530 :         pathnode->path.param_info = get_baserel_parampathinfo(root,
    1273             :                                                               rel,
    1274             :                                                               required_outer);
    1275             :     else
    1276       36870 :         pathnode->path.param_info = get_appendrel_parampathinfo(rel,
    1277             :                                                                 required_outer);
    1278             : 
    1279       67400 :     pathnode->path.parallel_aware = parallel_aware;
    1280       67400 :     pathnode->path.parallel_safe = rel->consider_parallel;
    1281       67400 :     pathnode->path.parallel_workers = parallel_workers;
    1282       67400 :     pathnode->path.pathkeys = pathkeys;
    1283             : 
    1284             :     /*
    1285             :      * For parallel append, non-partial paths are sorted by descending total
    1286             :      * costs. That way, the total time to finish all non-partial paths is
    1287             :      * minimized.  Also, the partial paths are sorted by descending startup
    1288             :      * costs.  There may be some paths that require to do startup work by a
    1289             :      * single worker.  In such case, it's better for workers to choose the
    1290             :      * expensive ones first, whereas the leader should choose the cheapest
    1291             :      * startup plan.
    1292             :      */
    1293       67400 :     if (pathnode->path.parallel_aware)
    1294             :     {
    1295             :         /*
    1296             :          * We mustn't fiddle with the order of subpaths when the Append has
    1297             :          * pathkeys.  The order they're listed in is critical to keeping the
    1298             :          * pathkeys valid.
    1299             :          */
    1300             :         Assert(pathkeys == NIL);
    1301             : 
    1302       22610 :         list_sort(subpaths, append_total_cost_compare);
    1303       22610 :         list_sort(partial_subpaths, append_startup_cost_compare);
    1304             :     }
    1305       67400 :     pathnode->first_partial_path = list_length(subpaths);
    1306       67400 :     pathnode->subpaths = list_concat(subpaths, partial_subpaths);
    1307             : 
    1308             :     /*
    1309             :      * Apply query-wide LIMIT if known and path is for sole base relation.
    1310             :      * (Handling this at this low level is a bit klugy.)
    1311             :      */
    1312       67400 :     if (root != NULL && bms_equal(rel->relids, root->all_query_rels))
    1313       37422 :         pathnode->limit_tuples = root->limit_tuples;
    1314             :     else
    1315       29978 :         pathnode->limit_tuples = -1.0;
    1316             : 
    1317      222156 :     foreach(l, pathnode->subpaths)
    1318             :     {
    1319      154756 :         Path       *subpath = (Path *) lfirst(l);
    1320             : 
    1321      275206 :         pathnode->path.parallel_safe = pathnode->path.parallel_safe &&
    1322      120450 :             subpath->parallel_safe;
    1323             : 
    1324             :         /* All child paths must have same parameterization */
    1325             :         Assert(bms_equal(PATH_REQ_OUTER(subpath), required_outer));
    1326             :     }
    1327             : 
    1328             :     Assert(!parallel_aware || pathnode->path.parallel_safe);
    1329             : 
    1330             :     /*
    1331             :      * If there's exactly one child path then the output of the Append is
    1332             :      * necessarily ordered the same as the child's, so we can inherit the
    1333             :      * child's pathkeys if any, overriding whatever the caller might've said.
    1334             :      * Furthermore, if the child's parallel awareness matches the Append's,
    1335             :      * then the Append is a no-op and will be discarded later (in setrefs.c).
    1336             :      * Then we can inherit the child's size and cost too, effectively charging
    1337             :      * zero for the Append.  Otherwise, we must do the normal costsize
    1338             :      * calculation.
    1339             :      */
    1340       67400 :     if (list_length(pathnode->subpaths) == 1)
    1341             :     {
    1342       21600 :         Path       *child = (Path *) linitial(pathnode->subpaths);
    1343             : 
    1344       21600 :         if (child->parallel_aware == parallel_aware)
    1345             :         {
    1346       21168 :             pathnode->path.rows = child->rows;
    1347       21168 :             pathnode->path.startup_cost = child->startup_cost;
    1348       21168 :             pathnode->path.total_cost = child->total_cost;
    1349             :         }
    1350             :         else
    1351         432 :             cost_append(pathnode);
    1352             :         /* Must do this last, else cost_append complains */
    1353       21600 :         pathnode->path.pathkeys = child->pathkeys;
    1354             :     }
    1355             :     else
    1356       45800 :         cost_append(pathnode);
    1357             : 
    1358             :     /* If the caller provided a row estimate, override the computed value. */
    1359       67400 :     if (rows >= 0)
    1360         582 :         pathnode->path.rows = rows;
    1361             : 
    1362       67400 :     return pathnode;
    1363             : }
    1364             : 
    1365             : /*
    1366             :  * append_total_cost_compare
    1367             :  *    list_sort comparator for sorting append child paths
    1368             :  *    by total_cost descending
    1369             :  *
    1370             :  * For equal total costs, we fall back to comparing startup costs; if those
    1371             :  * are equal too, break ties using bms_compare on the paths' relids.
    1372             :  * (This is to avoid getting unpredictable results from list_sort.)
    1373             :  */
    1374             : static int
    1375        1996 : append_total_cost_compare(const ListCell *a, const ListCell *b)
    1376             : {
    1377        1996 :     Path       *path1 = (Path *) lfirst(a);
    1378        1996 :     Path       *path2 = (Path *) lfirst(b);
    1379             :     int         cmp;
    1380             : 
    1381        1996 :     cmp = compare_path_costs(path1, path2, TOTAL_COST);
    1382        1996 :     if (cmp != 0)
    1383        1726 :         return -cmp;
    1384         270 :     return bms_compare(path1->parent->relids, path2->parent->relids);
    1385             : }
    1386             : 
    1387             : /*
    1388             :  * append_startup_cost_compare
    1389             :  *    list_sort comparator for sorting append child paths
    1390             :  *    by startup_cost descending
    1391             :  *
    1392             :  * For equal startup costs, we fall back to comparing total costs; if those
    1393             :  * are equal too, break ties using bms_compare on the paths' relids.
    1394             :  * (This is to avoid getting unpredictable results from list_sort.)
    1395             :  */
    1396             : static int
    1397       33202 : append_startup_cost_compare(const ListCell *a, const ListCell *b)
    1398             : {
    1399       33202 :     Path       *path1 = (Path *) lfirst(a);
    1400       33202 :     Path       *path2 = (Path *) lfirst(b);
    1401             :     int         cmp;
    1402             : 
    1403       33202 :     cmp = compare_path_costs(path1, path2, STARTUP_COST);
    1404       33202 :     if (cmp != 0)
    1405       12872 :         return -cmp;
    1406       20330 :     return bms_compare(path1->parent->relids, path2->parent->relids);
    1407             : }
    1408             : 
    1409             : /*
    1410             :  * create_merge_append_path
    1411             :  *    Creates a path corresponding to a MergeAppend plan, returning the
    1412             :  *    pathnode.
    1413             :  */
    1414             : MergeAppendPath *
    1415        3886 : create_merge_append_path(PlannerInfo *root,
    1416             :                          RelOptInfo *rel,
    1417             :                          List *subpaths,
    1418             :                          List *pathkeys,
    1419             :                          Relids required_outer)
    1420             : {
    1421        3886 :     MergeAppendPath *pathnode = makeNode(MergeAppendPath);
    1422             :     Cost        input_startup_cost;
    1423             :     Cost        input_total_cost;
    1424             :     ListCell   *l;
    1425             : 
    1426        3886 :     pathnode->path.pathtype = T_MergeAppend;
    1427        3886 :     pathnode->path.parent = rel;
    1428        3886 :     pathnode->path.pathtarget = rel->reltarget;
    1429        3886 :     pathnode->path.param_info = get_appendrel_parampathinfo(rel,
    1430             :                                                             required_outer);
    1431        3886 :     pathnode->path.parallel_aware = false;
    1432        3886 :     pathnode->path.parallel_safe = rel->consider_parallel;
    1433        3886 :     pathnode->path.parallel_workers = 0;
    1434        3886 :     pathnode->path.pathkeys = pathkeys;
    1435        3886 :     pathnode->subpaths = subpaths;
    1436             : 
    1437             :     /*
    1438             :      * Apply query-wide LIMIT if known and path is for sole base relation.
    1439             :      * (Handling this at this low level is a bit klugy.)
    1440             :      */
    1441        3886 :     if (bms_equal(rel->relids, root->all_query_rels))
    1442        2028 :         pathnode->limit_tuples = root->limit_tuples;
    1443             :     else
    1444        1858 :         pathnode->limit_tuples = -1.0;
    1445             : 
    1446             :     /*
    1447             :      * Add up the sizes and costs of the input paths.
    1448             :      */
    1449        3886 :     pathnode->path.rows = 0;
    1450        3886 :     input_startup_cost = 0;
    1451        3886 :     input_total_cost = 0;
    1452       14532 :     foreach(l, subpaths)
    1453             :     {
    1454       10646 :         Path       *subpath = (Path *) lfirst(l);
    1455             : 
    1456       10646 :         pathnode->path.rows += subpath->rows;
    1457       19186 :         pathnode->path.parallel_safe = pathnode->path.parallel_safe &&
    1458        8540 :             subpath->parallel_safe;
    1459             : 
    1460       10646 :         if (pathkeys_contained_in(pathkeys, subpath->pathkeys))
    1461             :         {
    1462             :             /* Subpath is adequately ordered, we won't need to sort it */
    1463       10360 :             input_startup_cost += subpath->startup_cost;
    1464       10360 :             input_total_cost += subpath->total_cost;
    1465             :         }
    1466             :         else
    1467             :         {
    1468             :             /* We'll need to insert a Sort node, so include cost for that */
    1469             :             Path        sort_path;  /* dummy for result of cost_sort */
    1470             : 
    1471         286 :             cost_sort(&sort_path,
    1472             :                       root,
    1473             :                       pathkeys,
    1474             :                       subpath->total_cost,
    1475             :                       subpath->rows,
    1476         286 :                       subpath->pathtarget->width,
    1477             :                       0.0,
    1478             :                       work_mem,
    1479             :                       pathnode->limit_tuples);
    1480         286 :             input_startup_cost += sort_path.startup_cost;
    1481         286 :             input_total_cost += sort_path.total_cost;
    1482             :         }
    1483             : 
    1484             :         /* All child paths must have same parameterization */
    1485             :         Assert(bms_equal(PATH_REQ_OUTER(subpath), required_outer));
    1486             :     }
    1487             : 
    1488             :     /*
    1489             :      * Now we can compute total costs of the MergeAppend.  If there's exactly
    1490             :      * one child path and its parallel awareness matches that of the
    1491             :      * MergeAppend, then the MergeAppend is a no-op and will be discarded
    1492             :      * later (in setrefs.c); otherwise we do the normal cost calculation.
    1493             :      */
    1494        3886 :     if (list_length(subpaths) == 1 &&
    1495         110 :         ((Path *) linitial(subpaths))->parallel_aware ==
    1496         110 :         pathnode->path.parallel_aware)
    1497             :     {
    1498         110 :         pathnode->path.startup_cost = input_startup_cost;
    1499         110 :         pathnode->path.total_cost = input_total_cost;
    1500             :     }
    1501             :     else
    1502        3776 :         cost_merge_append(&pathnode->path, root,
    1503             :                           pathkeys, list_length(subpaths),
    1504             :                           input_startup_cost, input_total_cost,
    1505             :                           pathnode->path.rows);
    1506             : 
    1507        3886 :     return pathnode;
    1508             : }
    1509             : 
    1510             : /*
    1511             :  * create_group_result_path
    1512             :  *    Creates a path representing a Result-and-nothing-else plan.
    1513             :  *
    1514             :  * This is only used for degenerate grouping cases, in which we know we
    1515             :  * need to produce one result row, possibly filtered by a HAVING qual.
    1516             :  */
    1517             : GroupResultPath *
    1518      203974 : create_group_result_path(PlannerInfo *root, RelOptInfo *rel,
    1519             :                          PathTarget *target, List *havingqual)
    1520             : {
    1521      203974 :     GroupResultPath *pathnode = makeNode(GroupResultPath);
    1522             : 
    1523      203974 :     pathnode->path.pathtype = T_Result;
    1524      203974 :     pathnode->path.parent = rel;
    1525      203974 :     pathnode->path.pathtarget = target;
    1526      203974 :     pathnode->path.param_info = NULL;    /* there are no other rels... */
    1527      203974 :     pathnode->path.parallel_aware = false;
    1528      203974 :     pathnode->path.parallel_safe = rel->consider_parallel;
    1529      203974 :     pathnode->path.parallel_workers = 0;
    1530      203974 :     pathnode->path.pathkeys = NIL;
    1531      203974 :     pathnode->quals = havingqual;
    1532             : 
    1533             :     /*
    1534             :      * We can't quite use cost_resultscan() because the quals we want to
    1535             :      * account for are not baserestrict quals of the rel.  Might as well just
    1536             :      * hack it here.
    1537             :      */
    1538      203974 :     pathnode->path.rows = 1;
    1539      203974 :     pathnode->path.startup_cost = target->cost.startup;
    1540      203974 :     pathnode->path.total_cost = target->cost.startup +
    1541      203974 :         cpu_tuple_cost + target->cost.per_tuple;
    1542             : 
    1543             :     /*
    1544             :      * Add cost of qual, if any --- but we ignore its selectivity, since our
    1545             :      * rowcount estimate should be 1 no matter what the qual is.
    1546             :      */
    1547      203974 :     if (havingqual)
    1548             :     {
    1549             :         QualCost    qual_cost;
    1550             : 
    1551         516 :         cost_qual_eval(&qual_cost, havingqual, root);
    1552             :         /* havingqual is evaluated once at startup */
    1553         516 :         pathnode->path.startup_cost += qual_cost.startup + qual_cost.per_tuple;
    1554         516 :         pathnode->path.total_cost += qual_cost.startup + qual_cost.per_tuple;
    1555             :     }
    1556             : 
    1557      203974 :     return pathnode;
    1558             : }
    1559             : 
    1560             : /*
    1561             :  * create_material_path
    1562             :  *    Creates a path corresponding to a Material plan, returning the
    1563             :  *    pathnode.
    1564             :  */
    1565             : MaterialPath *
    1566      419878 : create_material_path(RelOptInfo *rel, Path *subpath)
    1567             : {
    1568      419878 :     MaterialPath *pathnode = makeNode(MaterialPath);
    1569             : 
    1570             :     Assert(subpath->parent == rel);
    1571             : 
    1572      419878 :     pathnode->path.pathtype = T_Material;
    1573      419878 :     pathnode->path.parent = rel;
    1574      419878 :     pathnode->path.pathtarget = rel->reltarget;
    1575      419878 :     pathnode->path.param_info = subpath->param_info;
    1576      419878 :     pathnode->path.parallel_aware = false;
    1577      793754 :     pathnode->path.parallel_safe = rel->consider_parallel &&
    1578      373876 :         subpath->parallel_safe;
    1579      419878 :     pathnode->path.parallel_workers = subpath->parallel_workers;
    1580      419878 :     pathnode->path.pathkeys = subpath->pathkeys;
    1581             : 
    1582      419878 :     pathnode->subpath = subpath;
    1583             : 
    1584      419878 :     cost_material(&pathnode->path,
    1585             :                   subpath->startup_cost,
    1586             :                   subpath->total_cost,
    1587             :                   subpath->rows,
    1588      419878 :                   subpath->pathtarget->width);
    1589             : 
    1590      419878 :     return pathnode;
    1591             : }
    1592             : 
    1593             : /*
    1594             :  * create_memoize_path
    1595             :  *    Creates a path corresponding to a Memoize plan, returning the pathnode.
    1596             :  */
    1597             : MemoizePath *
    1598      240650 : create_memoize_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath,
    1599             :                     List *param_exprs, List *hash_operators,
    1600             :                     bool singlerow, bool binary_mode, double calls)
    1601             : {
    1602      240650 :     MemoizePath *pathnode = makeNode(MemoizePath);
    1603             : 
    1604             :     Assert(subpath->parent == rel);
    1605             : 
    1606      240650 :     pathnode->path.pathtype = T_Memoize;
    1607      240650 :     pathnode->path.parent = rel;
    1608      240650 :     pathnode->path.pathtarget = rel->reltarget;
    1609      240650 :     pathnode->path.param_info = subpath->param_info;
    1610      240650 :     pathnode->path.parallel_aware = false;
    1611      471594 :     pathnode->path.parallel_safe = rel->consider_parallel &&
    1612      230944 :         subpath->parallel_safe;
    1613      240650 :     pathnode->path.parallel_workers = subpath->parallel_workers;
    1614      240650 :     pathnode->path.pathkeys = subpath->pathkeys;
    1615             : 
    1616      240650 :     pathnode->subpath = subpath;
    1617      240650 :     pathnode->hash_operators = hash_operators;
    1618      240650 :     pathnode->param_exprs = param_exprs;
    1619      240650 :     pathnode->singlerow = singlerow;
    1620      240650 :     pathnode->binary_mode = binary_mode;
    1621      240650 :     pathnode->calls = calls;
    1622             : 
    1623             :     /*
    1624             :      * For now we set est_entries to 0.  cost_memoize_rescan() does all the
    1625             :      * hard work to determine how many cache entries there are likely to be,
    1626             :      * so it seems best to leave it up to that function to fill this field in.
    1627             :      * If left at 0, the executor will make a guess at a good value.
    1628             :      */
    1629      240650 :     pathnode->est_entries = 0;
    1630             : 
    1631             :     /*
    1632             :      * Add a small additional charge for caching the first entry.  All the
    1633             :      * harder calculations for rescans are performed in cost_memoize_rescan().
    1634             :      */
    1635      240650 :     pathnode->path.startup_cost = subpath->startup_cost + cpu_tuple_cost;
    1636      240650 :     pathnode->path.total_cost = subpath->total_cost + cpu_tuple_cost;
    1637      240650 :     pathnode->path.rows = subpath->rows;
    1638             : 
    1639      240650 :     return pathnode;
    1640             : }
    1641             : 
    1642             : /*
    1643             :  * create_unique_path
    1644             :  *    Creates a path representing elimination of distinct rows from the
    1645             :  *    input data.  Distinct-ness is defined according to the needs of the
    1646             :  *    semijoin represented by sjinfo.  If it is not possible to identify
    1647             :  *    how to make the data unique, NULL is returned.
    1648             :  *
    1649             :  * If used at all, this is likely to be called repeatedly on the same rel;
    1650             :  * and the input subpath should always be the same (the cheapest_total path
    1651             :  * for the rel).  So we cache the result.
    1652             :  */
    1653             : UniquePath *
    1654       29468 : create_unique_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath,
    1655             :                    SpecialJoinInfo *sjinfo)
    1656             : {
    1657             :     UniquePath *pathnode;
    1658             :     Path        sort_path;      /* dummy for result of cost_sort */
    1659             :     Path        agg_path;       /* dummy for result of cost_agg */
    1660             :     MemoryContext oldcontext;
    1661             :     int         numCols;
    1662             : 
    1663             :     /* Caller made a mistake if subpath isn't cheapest_total ... */
    1664             :     Assert(subpath == rel->cheapest_total_path);
    1665             :     Assert(subpath->parent == rel);
    1666             :     /* ... or if SpecialJoinInfo is the wrong one */
    1667             :     Assert(sjinfo->jointype == JOIN_SEMI);
    1668             :     Assert(bms_equal(rel->relids, sjinfo->syn_righthand));
    1669             : 
    1670             :     /* If result already cached, return it */
    1671       29468 :     if (rel->cheapest_unique_path)
    1672       25838 :         return (UniquePath *) rel->cheapest_unique_path;
    1673             : 
    1674             :     /* If it's not possible to unique-ify, return NULL */
    1675        3630 :     if (!(sjinfo->semi_can_btree || sjinfo->semi_can_hash))
    1676         120 :         return NULL;
    1677             : 
    1678             :     /*
    1679             :      * When called during GEQO join planning, we are in a short-lived memory
    1680             :      * context.  We must make sure that the path and any subsidiary data
    1681             :      * structures created for a baserel survive the GEQO cycle, else the
    1682             :      * baserel is trashed for future GEQO cycles.  On the other hand, when we
    1683             :      * are creating those for a joinrel during GEQO, we don't want them to
    1684             :      * clutter the main planning context.  Upshot is that the best solution is
    1685             :      * to explicitly allocate memory in the same context the given RelOptInfo
    1686             :      * is in.
    1687             :      */
    1688        3510 :     oldcontext = MemoryContextSwitchTo(GetMemoryChunkContext(rel));
    1689             : 
    1690        3510 :     pathnode = makeNode(UniquePath);
    1691             : 
    1692        3510 :     pathnode->path.pathtype = T_Unique;
    1693        3510 :     pathnode->path.parent = rel;
    1694        3510 :     pathnode->path.pathtarget = rel->reltarget;
    1695        3510 :     pathnode->path.param_info = subpath->param_info;
    1696        3510 :     pathnode->path.parallel_aware = false;
    1697        6560 :     pathnode->path.parallel_safe = rel->consider_parallel &&
    1698        3050 :         subpath->parallel_safe;
    1699        3510 :     pathnode->path.parallel_workers = subpath->parallel_workers;
    1700             : 
    1701             :     /*
    1702             :      * Assume the output is unsorted, since we don't necessarily have pathkeys
    1703             :      * to represent it.  (This might get overridden below.)
    1704             :      */
    1705        3510 :     pathnode->path.pathkeys = NIL;
    1706             : 
    1707        3510 :     pathnode->subpath = subpath;
    1708             : 
    1709             :     /*
    1710             :      * Under GEQO and when planning child joins, the sjinfo might be
    1711             :      * short-lived, so we'd better make copies of data structures we extract
    1712             :      * from it.
    1713             :      */
    1714        3510 :     pathnode->in_operators = copyObject(sjinfo->semi_operators);
    1715        3510 :     pathnode->uniq_exprs = copyObject(sjinfo->semi_rhs_exprs);
    1716             : 
    1717             :     /*
    1718             :      * If the input is a relation and it has a unique index that proves the
    1719             :      * semi_rhs_exprs are unique, then we don't need to do anything.  Note
    1720             :      * that relation_has_unique_index_for automatically considers restriction
    1721             :      * clauses for the rel, as well.
    1722             :      */
    1723        4396 :     if (rel->rtekind == RTE_RELATION && sjinfo->semi_can_btree &&
    1724         886 :         relation_has_unique_index_for(root, rel, NIL,
    1725             :                                       sjinfo->semi_rhs_exprs,
    1726             :                                       sjinfo->semi_operators))
    1727             :     {
    1728           0 :         pathnode->umethod = UNIQUE_PATH_NOOP;
    1729           0 :         pathnode->path.rows = rel->rows;
    1730           0 :         pathnode->path.startup_cost = subpath->startup_cost;
    1731           0 :         pathnode->path.total_cost = subpath->total_cost;
    1732           0 :         pathnode->path.pathkeys = subpath->pathkeys;
    1733             : 
    1734           0 :         rel->cheapest_unique_path = (Path *) pathnode;
    1735             : 
    1736           0 :         MemoryContextSwitchTo(oldcontext);
    1737             : 
    1738           0 :         return pathnode;
    1739             :     }
    1740             : 
    1741             :     /*
    1742             :      * If the input is a subquery whose output must be unique already, then we
    1743             :      * don't need to do anything.  The test for uniqueness has to consider
    1744             :      * exactly which columns we are extracting; for example "SELECT DISTINCT
    1745             :      * x,y" doesn't guarantee that x alone is distinct. So we cannot check for
    1746             :      * this optimization unless semi_rhs_exprs consists only of simple Vars
    1747             :      * referencing subquery outputs.  (Possibly we could do something with
    1748             :      * expressions in the subquery outputs, too, but for now keep it simple.)
    1749             :      */
    1750        3510 :     if (rel->rtekind == RTE_SUBQUERY)
    1751             :     {
    1752         646 :         RangeTblEntry *rte = planner_rt_fetch(rel->relid, root);
    1753             : 
    1754         646 :         if (query_supports_distinctness(rte->subquery))
    1755             :         {
    1756             :             List       *sub_tlist_colnos;
    1757             : 
    1758         610 :             sub_tlist_colnos = translate_sub_tlist(sjinfo->semi_rhs_exprs,
    1759         610 :                                                    rel->relid);
    1760             : 
    1761         732 :             if (sub_tlist_colnos &&
    1762         122 :                 query_is_distinct_for(rte->subquery,
    1763             :                                       sub_tlist_colnos,
    1764             :                                       sjinfo->semi_operators))
    1765             :             {
    1766           0 :                 pathnode->umethod = UNIQUE_PATH_NOOP;
    1767           0 :                 pathnode->path.rows = rel->rows;
    1768           0 :                 pathnode->path.startup_cost = subpath->startup_cost;
    1769           0 :                 pathnode->path.total_cost = subpath->total_cost;
    1770           0 :                 pathnode->path.pathkeys = subpath->pathkeys;
    1771             : 
    1772           0 :                 rel->cheapest_unique_path = (Path *) pathnode;
    1773             : 
    1774           0 :                 MemoryContextSwitchTo(oldcontext);
    1775             : 
    1776           0 :                 return pathnode;
    1777             :             }
    1778             :         }
    1779             :     }
    1780             : 
    1781             :     /* Estimate number of output rows */
    1782        3510 :     pathnode->path.rows = estimate_num_groups(root,
    1783             :                                               sjinfo->semi_rhs_exprs,
    1784             :                                               rel->rows,
    1785             :                                               NULL,
    1786             :                                               NULL);
    1787        3510 :     numCols = list_length(sjinfo->semi_rhs_exprs);
    1788             : 
    1789        3510 :     if (sjinfo->semi_can_btree)
    1790             :     {
    1791             :         /*
    1792             :          * Estimate cost for sort+unique implementation
    1793             :          */
    1794        3510 :         cost_sort(&sort_path, root, NIL,
    1795             :                   subpath->total_cost,
    1796             :                   rel->rows,
    1797        3510 :                   subpath->pathtarget->width,
    1798             :                   0.0,
    1799             :                   work_mem,
    1800             :                   -1.0);
    1801             : 
    1802             :         /*
    1803             :          * Charge one cpu_operator_cost per comparison per input tuple. We
    1804             :          * assume all columns get compared at most of the tuples. (XXX
    1805             :          * probably this is an overestimate.)  This should agree with
    1806             :          * create_upper_unique_path.
    1807             :          */
    1808        3510 :         sort_path.total_cost += cpu_operator_cost * rel->rows * numCols;
    1809             :     }
    1810             : 
    1811        3510 :     if (sjinfo->semi_can_hash)
    1812             :     {
    1813             :         /*
    1814             :          * Estimate the overhead per hashtable entry at 64 bytes (same as in
    1815             :          * planner.c).
    1816             :          */
    1817        3510 :         int         hashentrysize = subpath->pathtarget->width + 64;
    1818             : 
    1819        3510 :         if (hashentrysize * pathnode->path.rows > get_hash_memory_limit())
    1820             :         {
    1821             :             /*
    1822             :              * We should not try to hash.  Hack the SpecialJoinInfo to
    1823             :              * remember this, in case we come through here again.
    1824             :              */
    1825           0 :             sjinfo->semi_can_hash = false;
    1826             :         }
    1827             :         else
    1828        3510 :             cost_agg(&agg_path, root,
    1829             :                      AGG_HASHED, NULL,
    1830             :                      numCols, pathnode->path.rows,
    1831             :                      NIL,
    1832             :                      subpath->startup_cost,
    1833             :                      subpath->total_cost,
    1834             :                      rel->rows,
    1835        3510 :                      subpath->pathtarget->width);
    1836             :     }
    1837             : 
    1838        3510 :     if (sjinfo->semi_can_btree && sjinfo->semi_can_hash)
    1839             :     {
    1840        3510 :         if (agg_path.total_cost < sort_path.total_cost)
    1841        3376 :             pathnode->umethod = UNIQUE_PATH_HASH;
    1842             :         else
    1843         134 :             pathnode->umethod = UNIQUE_PATH_SORT;
    1844             :     }
    1845           0 :     else if (sjinfo->semi_can_btree)
    1846           0 :         pathnode->umethod = UNIQUE_PATH_SORT;
    1847           0 :     else if (sjinfo->semi_can_hash)
    1848           0 :         pathnode->umethod = UNIQUE_PATH_HASH;
    1849             :     else
    1850             :     {
    1851             :         /* we can get here only if we abandoned hashing above */
    1852           0 :         MemoryContextSwitchTo(oldcontext);
    1853           0 :         return NULL;
    1854             :     }
    1855             : 
    1856        3510 :     if (pathnode->umethod == UNIQUE_PATH_HASH)
    1857             :     {
    1858        3376 :         pathnode->path.startup_cost = agg_path.startup_cost;
    1859        3376 :         pathnode->path.total_cost = agg_path.total_cost;
    1860             :     }
    1861             :     else
    1862             :     {
    1863         134 :         pathnode->path.startup_cost = sort_path.startup_cost;
    1864         134 :         pathnode->path.total_cost = sort_path.total_cost;
    1865             :     }
    1866             : 
    1867        3510 :     rel->cheapest_unique_path = (Path *) pathnode;
    1868             : 
    1869        3510 :     MemoryContextSwitchTo(oldcontext);
    1870             : 
    1871        3510 :     return pathnode;
    1872             : }
    1873             : 
    1874             : /*
    1875             :  * create_gather_merge_path
    1876             :  *
    1877             :  *    Creates a path corresponding to a gather merge scan, returning
    1878             :  *    the pathnode.
    1879             :  */
    1880             : GatherMergePath *
    1881        9798 : create_gather_merge_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath,
    1882             :                          PathTarget *target, List *pathkeys,
    1883             :                          Relids required_outer, double *rows)
    1884             : {
    1885        9798 :     GatherMergePath *pathnode = makeNode(GatherMergePath);
    1886        9798 :     Cost        input_startup_cost = 0;
    1887        9798 :     Cost        input_total_cost = 0;
    1888             : 
    1889             :     Assert(subpath->parallel_safe);
    1890             :     Assert(pathkeys);
    1891             : 
    1892        9798 :     pathnode->path.pathtype = T_GatherMerge;
    1893        9798 :     pathnode->path.parent = rel;
    1894        9798 :     pathnode->path.param_info = get_baserel_parampathinfo(root, rel,
    1895             :                                                           required_outer);
    1896        9798 :     pathnode->path.parallel_aware = false;
    1897             : 
    1898        9798 :     pathnode->subpath = subpath;
    1899        9798 :     pathnode->num_workers = subpath->parallel_workers;
    1900        9798 :     pathnode->path.pathkeys = pathkeys;
    1901        9798 :     pathnode->path.pathtarget = target ? target : rel->reltarget;
    1902        9798 :     pathnode->path.rows += subpath->rows;
    1903             : 
    1904        9798 :     if (pathkeys_contained_in(pathkeys, subpath->pathkeys))
    1905             :     {
    1906             :         /* Subpath is adequately ordered, we won't need to sort it */
    1907        9798 :         input_startup_cost += subpath->startup_cost;
    1908        9798 :         input_total_cost += subpath->total_cost;
    1909             :     }
    1910             :     else
    1911             :     {
    1912             :         /* We'll need to insert a Sort node, so include cost for that */
    1913             :         Path        sort_path;  /* dummy for result of cost_sort */
    1914             : 
    1915           0 :         cost_sort(&sort_path,
    1916             :                   root,
    1917             :                   pathkeys,
    1918             :                   subpath->total_cost,
    1919             :                   subpath->rows,
    1920           0 :                   subpath->pathtarget->width,
    1921             :                   0.0,
    1922             :                   work_mem,
    1923             :                   -1);
    1924           0 :         input_startup_cost += sort_path.startup_cost;
    1925           0 :         input_total_cost += sort_path.total_cost;
    1926             :     }
    1927             : 
    1928        9798 :     cost_gather_merge(pathnode, root, rel, pathnode->path.param_info,
    1929             :                       input_startup_cost, input_total_cost, rows);
    1930             : 
    1931        9798 :     return pathnode;
    1932             : }
    1933             : 
    1934             : /*
    1935             :  * translate_sub_tlist - get subquery column numbers represented by tlist
    1936             :  *
    1937             :  * The given targetlist usually contains only Vars referencing the given relid.
    1938             :  * Extract their varattnos (ie, the column numbers of the subquery) and return
    1939             :  * as an integer List.
    1940             :  *
    1941             :  * If any of the tlist items is not a simple Var, we cannot determine whether
    1942             :  * the subquery's uniqueness condition (if any) matches ours, so punt and
    1943             :  * return NIL.
    1944             :  */
    1945             : static List *
    1946         610 : translate_sub_tlist(List *tlist, int relid)
    1947             : {
    1948         610 :     List       *result = NIL;
    1949             :     ListCell   *l;
    1950             : 
    1951         732 :     foreach(l, tlist)
    1952             :     {
    1953         610 :         Var        *var = (Var *) lfirst(l);
    1954             : 
    1955         610 :         if (!var || !IsA(var, Var) ||
    1956         122 :             var->varno != relid)
    1957         488 :             return NIL;         /* punt */
    1958             : 
    1959         122 :         result = lappend_int(result, var->varattno);
    1960             :     }
    1961         122 :     return result;
    1962             : }
    1963             : 
    1964             : /*
    1965             :  * create_gather_path
    1966             :  *    Creates a path corresponding to a gather scan, returning the
    1967             :  *    pathnode.
    1968             :  *
    1969             :  * 'rows' may optionally be set to override row estimates from other sources.
    1970             :  */
    1971             : GatherPath *
    1972       15932 : create_gather_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath,
    1973             :                    PathTarget *target, Relids required_outer, double *rows)
    1974             : {
    1975       15932 :     GatherPath *pathnode = makeNode(GatherPath);
    1976             : 
    1977             :     Assert(subpath->parallel_safe);
    1978             : 
    1979       15932 :     pathnode->path.pathtype = T_Gather;
    1980       15932 :     pathnode->path.parent = rel;
    1981       15932 :     pathnode->path.pathtarget = target;
    1982       15932 :     pathnode->path.param_info = get_baserel_parampathinfo(root, rel,
    1983             :                                                           required_outer);
    1984       15932 :     pathnode->path.parallel_aware = false;
    1985       15932 :     pathnode->path.parallel_safe = false;
    1986       15932 :     pathnode->path.parallel_workers = 0;
    1987       15932 :     pathnode->path.pathkeys = NIL;   /* Gather has unordered result */
    1988             : 
    1989       15932 :     pathnode->subpath = subpath;
    1990       15932 :     pathnode->num_workers = subpath->parallel_workers;
    1991       15932 :     pathnode->single_copy = false;
    1992             : 
    1993       15932 :     if (pathnode->num_workers == 0)
    1994             :     {
    1995           0 :         pathnode->path.pathkeys = subpath->pathkeys;
    1996           0 :         pathnode->num_workers = 1;
    1997           0 :         pathnode->single_copy = true;
    1998             :     }
    1999             : 
    2000       15932 :     cost_gather(pathnode, root, rel, pathnode->path.param_info, rows);
    2001             : 
    2002       15932 :     return pathnode;
    2003             : }
    2004             : 
    2005             : /*
    2006             :  * create_subqueryscan_path
    2007             :  *    Creates a path corresponding to a scan of a subquery,
    2008             :  *    returning the pathnode.
    2009             :  *
    2010             :  * Caller must pass trivial_pathtarget = true if it believes rel->reltarget to
    2011             :  * be trivial, ie just a fetch of all the subquery output columns in order.
    2012             :  * While we could determine that here, the caller can usually do it more
    2013             :  * efficiently (or at least amortize it over multiple calls).
    2014             :  */
    2015             : SubqueryScanPath *
    2016       38754 : create_subqueryscan_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath,
    2017             :                          bool trivial_pathtarget,
    2018             :                          List *pathkeys, Relids required_outer)
    2019             : {
    2020       38754 :     SubqueryScanPath *pathnode = makeNode(SubqueryScanPath);
    2021             : 
    2022       38754 :     pathnode->path.pathtype = T_SubqueryScan;
    2023       38754 :     pathnode->path.parent = rel;
    2024       38754 :     pathnode->path.pathtarget = rel->reltarget;
    2025       38754 :     pathnode->path.param_info = get_baserel_parampathinfo(root, rel,
    2026             :                                                           required_outer);
    2027       38754 :     pathnode->path.parallel_aware = false;
    2028       63822 :     pathnode->path.parallel_safe = rel->consider_parallel &&
    2029       25068 :         subpath->parallel_safe;
    2030       38754 :     pathnode->path.parallel_workers = subpath->parallel_workers;
    2031       38754 :     pathnode->path.pathkeys = pathkeys;
    2032       38754 :     pathnode->subpath = subpath;
    2033             : 
    2034       38754 :     cost_subqueryscan(pathnode, root, rel, pathnode->path.param_info,
    2035             :                       trivial_pathtarget);
    2036             : 
    2037       38754 :     return pathnode;
    2038             : }
    2039             : 
    2040             : /*
    2041             :  * create_functionscan_path
    2042             :  *    Creates a path corresponding to a sequential scan of a function,
    2043             :  *    returning the pathnode.
    2044             :  */
    2045             : Path *
    2046       39782 : create_functionscan_path(PlannerInfo *root, RelOptInfo *rel,
    2047             :                          List *pathkeys, Relids required_outer)
    2048             : {
    2049       39782 :     Path       *pathnode = makeNode(Path);
    2050             : 
    2051       39782 :     pathnode->pathtype = T_FunctionScan;
    2052       39782 :     pathnode->parent = rel;
    2053       39782 :     pathnode->pathtarget = rel->reltarget;
    2054       39782 :     pathnode->param_info = get_baserel_parampathinfo(root, rel,
    2055             :                                                      required_outer);
    2056       39782 :     pathnode->parallel_aware = false;
    2057       39782 :     pathnode->parallel_safe = rel->consider_parallel;
    2058       39782 :     pathnode->parallel_workers = 0;
    2059       39782 :     pathnode->pathkeys = pathkeys;
    2060             : 
    2061       39782 :     cost_functionscan(pathnode, root, rel, pathnode->param_info);
    2062             : 
    2063       39782 :     return pathnode;
    2064             : }
    2065             : 
    2066             : /*
    2067             :  * create_tablefuncscan_path
    2068             :  *    Creates a path corresponding to a sequential scan of a table function,
    2069             :  *    returning the pathnode.
    2070             :  */
    2071             : Path *
    2072         222 : create_tablefuncscan_path(PlannerInfo *root, RelOptInfo *rel,
    2073             :                           Relids required_outer)
    2074             : {
    2075         222 :     Path       *pathnode = makeNode(Path);
    2076             : 
    2077         222 :     pathnode->pathtype = T_TableFuncScan;
    2078         222 :     pathnode->parent = rel;
    2079         222 :     pathnode->pathtarget = rel->reltarget;
    2080         222 :     pathnode->param_info = get_baserel_parampathinfo(root, rel,
    2081             :                                                      required_outer);
    2082         222 :     pathnode->parallel_aware = false;
    2083         222 :     pathnode->parallel_safe = rel->consider_parallel;
    2084         222 :     pathnode->parallel_workers = 0;
    2085         222 :     pathnode->pathkeys = NIL;    /* result is always unordered */
    2086             : 
    2087         222 :     cost_tablefuncscan(pathnode, root, rel, pathnode->param_info);
    2088             : 
    2089         222 :     return pathnode;
    2090             : }
    2091             : 
    2092             : /*
    2093             :  * create_valuesscan_path
    2094             :  *    Creates a path corresponding to a scan of a VALUES list,
    2095             :  *    returning the pathnode.
    2096             :  */
    2097             : Path *
    2098        7708 : create_valuesscan_path(PlannerInfo *root, RelOptInfo *rel,
    2099             :                        Relids required_outer)
    2100             : {
    2101        7708 :     Path       *pathnode = makeNode(Path);
    2102             : 
    2103        7708 :     pathnode->pathtype = T_ValuesScan;
    2104        7708 :     pathnode->parent = rel;
    2105        7708 :     pathnode->pathtarget = rel->reltarget;
    2106        7708 :     pathnode->param_info = get_baserel_parampathinfo(root, rel,
    2107             :                                                      required_outer);
    2108        7708 :     pathnode->parallel_aware = false;
    2109        7708 :     pathnode->parallel_safe = rel->consider_parallel;
    2110        7708 :     pathnode->parallel_workers = 0;
    2111        7708 :     pathnode->pathkeys = NIL;    /* result is always unordered */
    2112             : 
    2113        7708 :     cost_valuesscan(pathnode, root, rel, pathnode->param_info);
    2114             : 
    2115        7708 :     return pathnode;
    2116             : }
    2117             : 
    2118             : /*
    2119             :  * create_ctescan_path
    2120             :  *    Creates a path corresponding to a scan of a non-self-reference CTE,
    2121             :  *    returning the pathnode.
    2122             :  */
    2123             : Path *
    2124        3210 : create_ctescan_path(PlannerInfo *root, RelOptInfo *rel,
    2125             :                     List *pathkeys, Relids required_outer)
    2126             : {
    2127        3210 :     Path       *pathnode = makeNode(Path);
    2128             : 
    2129        3210 :     pathnode->pathtype = T_CteScan;
    2130        3210 :     pathnode->parent = rel;
    2131        3210 :     pathnode->pathtarget = rel->reltarget;
    2132        3210 :     pathnode->param_info = get_baserel_parampathinfo(root, rel,
    2133             :                                                      required_outer);
    2134        3210 :     pathnode->parallel_aware = false;
    2135        3210 :     pathnode->parallel_safe = rel->consider_parallel;
    2136        3210 :     pathnode->parallel_workers = 0;
    2137        3210 :     pathnode->pathkeys = pathkeys;
    2138             : 
    2139        3210 :     cost_ctescan(pathnode, root, rel, pathnode->param_info);
    2140             : 
    2141        3210 :     return pathnode;
    2142             : }
    2143             : 
    2144             : /*
    2145             :  * create_namedtuplestorescan_path
    2146             :  *    Creates a path corresponding to a scan of a named tuplestore, returning
    2147             :  *    the pathnode.
    2148             :  */
    2149             : Path *
    2150         442 : create_namedtuplestorescan_path(PlannerInfo *root, RelOptInfo *rel,
    2151             :                                 Relids required_outer)
    2152             : {
    2153         442 :     Path       *pathnode = makeNode(Path);
    2154             : 
    2155         442 :     pathnode->pathtype = T_NamedTuplestoreScan;
    2156         442 :     pathnode->parent = rel;
    2157         442 :     pathnode->pathtarget = rel->reltarget;
    2158         442 :     pathnode->param_info = get_baserel_parampathinfo(root, rel,
    2159             :                                                      required_outer);
    2160         442 :     pathnode->parallel_aware = false;
    2161         442 :     pathnode->parallel_safe = rel->consider_parallel;
    2162         442 :     pathnode->parallel_workers = 0;
    2163         442 :     pathnode->pathkeys = NIL;    /* result is always unordered */
    2164             : 
    2165         442 :     cost_namedtuplestorescan(pathnode, root, rel, pathnode->param_info);
    2166             : 
    2167         442 :     return pathnode;
    2168             : }
    2169             : 
    2170             : /*
    2171             :  * create_resultscan_path
    2172             :  *    Creates a path corresponding to a scan of an RTE_RESULT relation,
    2173             :  *    returning the pathnode.
    2174             :  */
    2175             : Path *
    2176        1610 : create_resultscan_path(PlannerInfo *root, RelOptInfo *rel,
    2177             :                        Relids required_outer)
    2178             : {
    2179        1610 :     Path       *pathnode = makeNode(Path);
    2180             : 
    2181        1610 :     pathnode->pathtype = T_Result;
    2182        1610 :     pathnode->parent = rel;
    2183        1610 :     pathnode->pathtarget = rel->reltarget;
    2184        1610 :     pathnode->param_info = get_baserel_parampathinfo(root, rel,
    2185             :                                                      required_outer);
    2186        1610 :     pathnode->parallel_aware = false;
    2187        1610 :     pathnode->parallel_safe = rel->consider_parallel;
    2188        1610 :     pathnode->parallel_workers = 0;
    2189        1610 :     pathnode->pathkeys = NIL;    /* result is always unordered */
    2190             : 
    2191        1610 :     cost_resultscan(pathnode, root, rel, pathnode->param_info);
    2192             : 
    2193        1610 :     return pathnode;
    2194             : }
    2195             : 
    2196             : /*
    2197             :  * create_worktablescan_path
    2198             :  *    Creates a path corresponding to a scan of a self-reference CTE,
    2199             :  *    returning the pathnode.
    2200             :  */
    2201             : Path *
    2202         808 : create_worktablescan_path(PlannerInfo *root, RelOptInfo *rel,
    2203             :                           Relids required_outer)
    2204             : {
    2205         808 :     Path       *pathnode = makeNode(Path);
    2206             : 
    2207         808 :     pathnode->pathtype = T_WorkTableScan;
    2208         808 :     pathnode->parent = rel;
    2209         808 :     pathnode->pathtarget = rel->reltarget;
    2210         808 :     pathnode->param_info = get_baserel_parampathinfo(root, rel,
    2211             :                                                      required_outer);
    2212         808 :     pathnode->parallel_aware = false;
    2213         808 :     pathnode->parallel_safe = rel->consider_parallel;
    2214         808 :     pathnode->parallel_workers = 0;
    2215         808 :     pathnode->pathkeys = NIL;    /* result is always unordered */
    2216             : 
    2217             :     /* Cost is the same as for a regular CTE scan */
    2218         808 :     cost_ctescan(pathnode, root, rel, pathnode->param_info);
    2219             : 
    2220         808 :     return pathnode;
    2221             : }
    2222             : 
    2223             : /*
    2224             :  * create_foreignscan_path
    2225             :  *    Creates a path corresponding to a scan of a foreign base table,
    2226             :  *    returning the pathnode.
    2227             :  *
    2228             :  * This function is never called from core Postgres; rather, it's expected
    2229             :  * to be called by the GetForeignPaths function of a foreign data wrapper.
    2230             :  * We make the FDW supply all fields of the path, since we do not have any way
    2231             :  * to calculate them in core.  However, there is a usually-sane default for
    2232             :  * the pathtarget (rel->reltarget), so we let a NULL for "target" select that.
    2233             :  */
    2234             : ForeignPath *
    2235        3542 : create_foreignscan_path(PlannerInfo *root, RelOptInfo *rel,
    2236             :                         PathTarget *target,
    2237             :                         double rows, Cost startup_cost, Cost total_cost,
    2238             :                         List *pathkeys,
    2239             :                         Relids required_outer,
    2240             :                         Path *fdw_outerpath,
    2241             :                         List *fdw_restrictinfo,
    2242             :                         List *fdw_private)
    2243             : {
    2244        3542 :     ForeignPath *pathnode = makeNode(ForeignPath);
    2245             : 
    2246             :     /* Historically some FDWs were confused about when to use this */
    2247             :     Assert(IS_SIMPLE_REL(rel));
    2248             : 
    2249        3542 :     pathnode->path.pathtype = T_ForeignScan;
    2250        3542 :     pathnode->path.parent = rel;
    2251        3542 :     pathnode->path.pathtarget = target ? target : rel->reltarget;
    2252        3542 :     pathnode->path.param_info = get_baserel_parampathinfo(root, rel,
    2253             :                                                           required_outer);
    2254        3542 :     pathnode->path.parallel_aware = false;
    2255        3542 :     pathnode->path.parallel_safe = rel->consider_parallel;
    2256        3542 :     pathnode->path.parallel_workers = 0;
    2257        3542 :     pathnode->path.rows = rows;
    2258        3542 :     pathnode->path.startup_cost = startup_cost;
    2259        3542 :     pathnode->path.total_cost = total_cost;
    2260        3542 :     pathnode->path.pathkeys = pathkeys;
    2261             : 
    2262        3542 :     pathnode->fdw_outerpath = fdw_outerpath;
    2263        3542 :     pathnode->fdw_restrictinfo = fdw_restrictinfo;
    2264        3542 :     pathnode->fdw_private = fdw_private;
    2265             : 
    2266        3542 :     return pathnode;
    2267             : }
    2268             : 
    2269             : /*
    2270             :  * create_foreign_join_path
    2271             :  *    Creates a path corresponding to a scan of a foreign join,
    2272             :  *    returning the pathnode.
    2273             :  *
    2274             :  * This function is never called from core Postgres; rather, it's expected
    2275             :  * to be called by the GetForeignJoinPaths function of a foreign data wrapper.
    2276             :  * We make the FDW supply all fields of the path, since we do not have any way
    2277             :  * to calculate them in core.  However, there is a usually-sane default for
    2278             :  * the pathtarget (rel->reltarget), so we let a NULL for "target" select that.
    2279             :  */
    2280             : ForeignPath *
    2281        1116 : create_foreign_join_path(PlannerInfo *root, RelOptInfo *rel,
    2282             :                          PathTarget *target,
    2283             :                          double rows, Cost startup_cost, Cost total_cost,
    2284             :                          List *pathkeys,
    2285             :                          Relids required_outer,
    2286             :                          Path *fdw_outerpath,
    2287             :                          List *fdw_restrictinfo,
    2288             :                          List *fdw_private)
    2289             : {
    2290        1116 :     ForeignPath *pathnode = makeNode(ForeignPath);
    2291             : 
    2292             :     /*
    2293             :      * We should use get_joinrel_parampathinfo to handle parameterized paths,
    2294             :      * but the API of this function doesn't support it, and existing
    2295             :      * extensions aren't yet trying to build such paths anyway.  For the
    2296             :      * moment just throw an error if someone tries it; eventually we should
    2297             :      * revisit this.
    2298             :      */
    2299        1116 :     if (!bms_is_empty(required_outer) || !bms_is_empty(rel->lateral_relids))
    2300           0 :         elog(ERROR, "parameterized foreign joins are not supported yet");
    2301             : 
    2302        1116 :     pathnode->path.pathtype = T_ForeignScan;
    2303        1116 :     pathnode->path.parent = rel;
    2304        1116 :     pathnode->path.pathtarget = target ? target : rel->reltarget;
    2305        1116 :     pathnode->path.param_info = NULL;    /* XXX see above */
    2306        1116 :     pathnode->path.parallel_aware = false;
    2307        1116 :     pathnode->path.parallel_safe = rel->consider_parallel;
    2308        1116 :     pathnode->path.parallel_workers = 0;
    2309        1116 :     pathnode->path.rows = rows;
    2310        1116 :     pathnode->path.startup_cost = startup_cost;
    2311        1116 :     pathnode->path.total_cost = total_cost;
    2312        1116 :     pathnode->path.pathkeys = pathkeys;
    2313             : 
    2314        1116 :     pathnode->fdw_outerpath = fdw_outerpath;
    2315        1116 :     pathnode->fdw_restrictinfo = fdw_restrictinfo;
    2316        1116 :     pathnode->fdw_private = fdw_private;
    2317             : 
    2318        1116 :     return pathnode;
    2319             : }
    2320             : 
    2321             : /*
    2322             :  * create_foreign_upper_path
    2323             :  *    Creates a path corresponding to an upper relation that's computed
    2324             :  *    directly by an FDW, returning the pathnode.
    2325             :  *
    2326             :  * This function is never called from core Postgres; rather, it's expected to
    2327             :  * be called by the GetForeignUpperPaths function of a foreign data wrapper.
    2328             :  * We make the FDW supply all fields of the path, since we do not have any way
    2329             :  * to calculate them in core.  However, there is a usually-sane default for
    2330             :  * the pathtarget (rel->reltarget), so we let a NULL for "target" select that.
    2331             :  */
    2332             : ForeignPath *
    2333         570 : create_foreign_upper_path(PlannerInfo *root, RelOptInfo *rel,
    2334             :                           PathTarget *target,
    2335             :                           double rows, Cost startup_cost, Cost total_cost,
    2336             :                           List *pathkeys,
    2337             :                           Path *fdw_outerpath,
    2338             :                           List *fdw_restrictinfo,
    2339             :                           List *fdw_private)
    2340             : {
    2341         570 :     ForeignPath *pathnode = makeNode(ForeignPath);
    2342             : 
    2343             :     /*
    2344             :      * Upper relations should never have any lateral references, since joining
    2345             :      * is complete.
    2346             :      */
    2347             :     Assert(bms_is_empty(rel->lateral_relids));
    2348             : 
    2349         570 :     pathnode->path.pathtype = T_ForeignScan;
    2350         570 :     pathnode->path.parent = rel;
    2351         570 :     pathnode->path.pathtarget = target ? target : rel->reltarget;
    2352         570 :     pathnode->path.param_info = NULL;
    2353         570 :     pathnode->path.parallel_aware = false;
    2354         570 :     pathnode->path.parallel_safe = rel->consider_parallel;
    2355         570 :     pathnode->path.parallel_workers = 0;
    2356         570 :     pathnode->path.rows = rows;
    2357         570 :     pathnode->path.startup_cost = startup_cost;
    2358         570 :     pathnode->path.total_cost = total_cost;
    2359         570 :     pathnode->path.pathkeys = pathkeys;
    2360             : 
    2361         570 :     pathnode->fdw_outerpath = fdw_outerpath;
    2362         570 :     pathnode->fdw_restrictinfo = fdw_restrictinfo;
    2363         570 :     pathnode->fdw_private = fdw_private;
    2364             : 
    2365         570 :     return pathnode;
    2366             : }
    2367             : 
    2368             : /*
    2369             :  * calc_nestloop_required_outer
    2370             :  *    Compute the required_outer set for a nestloop join path
    2371             :  *
    2372             :  * Note: when considering a child join, the inputs nonetheless use top-level
    2373             :  * parent relids
    2374             :  *
    2375             :  * Note: result must not share storage with either input
    2376             :  */
    2377             : Relids
    2378     2437186 : calc_nestloop_required_outer(Relids outerrelids,
    2379             :                              Relids outer_paramrels,
    2380             :                              Relids innerrelids,
    2381             :                              Relids inner_paramrels)
    2382             : {
    2383             :     Relids      required_outer;
    2384             : 
    2385             :     /* inner_path can require rels from outer path, but not vice versa */
    2386             :     Assert(!bms_overlap(outer_paramrels, innerrelids));
    2387             :     /* easy case if inner path is not parameterized */
    2388     2437186 :     if (!inner_paramrels)
    2389     1648630 :         return bms_copy(outer_paramrels);
    2390             :     /* else, form the union ... */
    2391      788556 :     required_outer = bms_union(outer_paramrels, inner_paramrels);
    2392             :     /* ... and remove any mention of now-satisfied outer rels */
    2393      788556 :     required_outer = bms_del_members(required_outer,
    2394             :                                      outerrelids);
    2395      788556 :     return required_outer;
    2396             : }
    2397             : 
    2398             : /*
    2399             :  * calc_non_nestloop_required_outer
    2400             :  *    Compute the required_outer set for a merge or hash join path
    2401             :  *
    2402             :  * Note: result must not share storage with either input
    2403             :  */
    2404             : Relids
    2405     1604740 : calc_non_nestloop_required_outer(Path *outer_path, Path *inner_path)
    2406             : {
    2407     1604740 :     Relids      outer_paramrels = PATH_REQ_OUTER(outer_path);
    2408     1604740 :     Relids      inner_paramrels = PATH_REQ_OUTER(inner_path);
    2409             :     Relids      innerrelids PG_USED_FOR_ASSERTS_ONLY;
    2410             :     Relids      outerrelids PG_USED_FOR_ASSERTS_ONLY;
    2411             :     Relids      required_outer;
    2412             : 
    2413             :     /*
    2414             :      * Any parameterization of the input paths refers to topmost parents of
    2415             :      * the relevant relations, because reparameterize_path_by_child() hasn't
    2416             :      * been called yet.  So we must consider topmost parents of the relations
    2417             :      * being joined, too, while checking for disallowed parameterization
    2418             :      * cases.
    2419             :      */
    2420     1604740 :     if (inner_path->parent->top_parent_relids)
    2421       34436 :         innerrelids = inner_path->parent->top_parent_relids;
    2422             :     else
    2423     1570304 :         innerrelids = inner_path->parent->relids;
    2424             : 
    2425     1604740 :     if (outer_path->parent->top_parent_relids)
    2426       34436 :         outerrelids = outer_path->parent->top_parent_relids;
    2427             :     else
    2428     1570304 :         outerrelids = outer_path->parent->relids;
    2429             : 
    2430             :     /* neither path can require rels from the other */
    2431             :     Assert(!bms_overlap(outer_paramrels, innerrelids));
    2432             :     Assert(!bms_overlap(inner_paramrels, outerrelids));
    2433             :     /* form the union ... */
    2434     1604740 :     required_outer = bms_union(outer_paramrels, inner_paramrels);
    2435             :     /* we do not need an explicit test for empty; bms_union gets it right */
    2436     1604740 :     return required_outer;
    2437             : }
    2438             : 
    2439             : /*
    2440             :  * create_nestloop_path
    2441             :  *    Creates a pathnode corresponding to a nestloop join between two
    2442             :  *    relations.
    2443             :  *
    2444             :  * 'joinrel' is the join relation.
    2445             :  * 'jointype' is the type of join required
    2446             :  * 'workspace' is the result from initial_cost_nestloop
    2447             :  * 'extra' contains various information about the join
    2448             :  * 'outer_path' is the outer path
    2449             :  * 'inner_path' is the inner path
    2450             :  * 'restrict_clauses' are the RestrictInfo nodes to apply at the join
    2451             :  * 'pathkeys' are the path keys of the new join path
    2452             :  * 'required_outer' is the set of required outer rels
    2453             :  *
    2454             :  * Returns the resulting path node.
    2455             :  */
    2456             : NestPath *
    2457     1122872 : create_nestloop_path(PlannerInfo *root,
    2458             :                      RelOptInfo *joinrel,
    2459             :                      JoinType jointype,
    2460             :                      JoinCostWorkspace *workspace,
    2461             :                      JoinPathExtraData *extra,
    2462             :                      Path *outer_path,
    2463             :                      Path *inner_path,
    2464             :                      List *restrict_clauses,
    2465             :                      List *pathkeys,
    2466             :                      Relids required_outer)
    2467             : {
    2468     1122872 :     NestPath   *pathnode = makeNode(NestPath);
    2469     1122872 :     Relids      inner_req_outer = PATH_REQ_OUTER(inner_path);
    2470             :     Relids      outerrelids;
    2471             : 
    2472             :     /*
    2473             :      * Paths are parameterized by top-level parents, so run parameterization
    2474             :      * tests on the parent relids.
    2475             :      */
    2476     1122872 :     if (outer_path->parent->top_parent_relids)
    2477       15346 :         outerrelids = outer_path->parent->top_parent_relids;
    2478             :     else
    2479     1107526 :         outerrelids = outer_path->parent->relids;
    2480             : 
    2481             :     /*
    2482             :      * If the inner path is parameterized by the outer, we must drop any
    2483             :      * restrict_clauses that are due to be moved into the inner path.  We have
    2484             :      * to do this now, rather than postpone the work till createplan time,
    2485             :      * because the restrict_clauses list can affect the size and cost
    2486             :      * estimates for this path.  We detect such clauses by checking for serial
    2487             :      * number match to clauses already enforced in the inner path.
    2488             :      */
    2489     1122872 :     if (bms_overlap(inner_req_outer, outerrelids))
    2490             :     {
    2491      315418 :         Bitmapset  *enforced_serials = get_param_path_clause_serials(inner_path);
    2492      315418 :         List       *jclauses = NIL;
    2493             :         ListCell   *lc;
    2494             : 
    2495      686738 :         foreach(lc, restrict_clauses)
    2496             :         {
    2497      371320 :             RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
    2498             : 
    2499      371320 :             if (!bms_is_member(rinfo->rinfo_serial, enforced_serials))
    2500       47724 :                 jclauses = lappend(jclauses, rinfo);
    2501             :         }
    2502      315418 :         restrict_clauses = jclauses;
    2503             :     }
    2504             : 
    2505     1122872 :     pathnode->jpath.path.pathtype = T_NestLoop;
    2506     1122872 :     pathnode->jpath.path.parent = joinrel;
    2507     1122872 :     pathnode->jpath.path.pathtarget = joinrel->reltarget;
    2508     1122872 :     pathnode->jpath.path.param_info =
    2509     1122872 :         get_joinrel_parampathinfo(root,
    2510             :                                   joinrel,
    2511             :                                   outer_path,
    2512             :                                   inner_path,
    2513             :                                   extra->sjinfo,
    2514             :                                   required_outer,
    2515             :                                   &restrict_clauses);
    2516     1122872 :     pathnode->jpath.path.parallel_aware = false;
    2517     3270192 :     pathnode->jpath.path.parallel_safe = joinrel->consider_parallel &&
    2518     1122872 :         outer_path->parallel_safe && inner_path->parallel_safe;
    2519             :     /* This is a foolish way to estimate parallel_workers, but for now... */
    2520     1122872 :     pathnode->jpath.path.parallel_workers = outer_path->parallel_workers;
    2521     1122872 :     pathnode->jpath.path.pathkeys = pathkeys;
    2522     1122872 :     pathnode->jpath.jointype = jointype;
    2523     1122872 :     pathnode->jpath.inner_unique = extra->inner_unique;
    2524     1122872 :     pathnode->jpath.outerjoinpath = outer_path;
    2525     1122872 :     pathnode->jpath.innerjoinpath = inner_path;
    2526     1122872 :     pathnode->jpath.joinrestrictinfo = restrict_clauses;
    2527             : 
    2528     1122872 :     final_cost_nestloop(root, pathnode, workspace, extra);
    2529             : 
    2530     1122872 :     return pathnode;
    2531             : }
    2532             : 
    2533             : /*
    2534             :  * create_mergejoin_path
    2535             :  *    Creates a pathnode corresponding to a mergejoin join between
    2536             :  *    two relations
    2537             :  *
    2538             :  * 'joinrel' is the join relation
    2539             :  * 'jointype' is the type of join required
    2540             :  * 'workspace' is the result from initial_cost_mergejoin
    2541             :  * 'extra' contains various information about the join
    2542             :  * 'outer_path' is the outer path
    2543             :  * 'inner_path' is the inner path
    2544             :  * 'restrict_clauses' are the RestrictInfo nodes to apply at the join
    2545             :  * 'pathkeys' are the path keys of the new join path
    2546             :  * 'required_outer' is the set of required outer rels
    2547             :  * 'mergeclauses' are the RestrictInfo nodes to use as merge clauses
    2548             :  *      (this should be a subset of the restrict_clauses list)
    2549             :  * 'outersortkeys' are the sort varkeys for the outer relation
    2550             :  * 'innersortkeys' are the sort varkeys for the inner relation
    2551             :  */
    2552             : MergePath *
    2553      250804 : create_mergejoin_path(PlannerInfo *root,
    2554             :                       RelOptInfo *joinrel,
    2555             :                       JoinType jointype,
    2556             :                       JoinCostWorkspace *workspace,
    2557             :                       JoinPathExtraData *extra,
    2558             :                       Path *outer_path,
    2559             :                       Path *inner_path,
    2560             :                       List *restrict_clauses,
    2561             :                       List *pathkeys,
    2562             :                       Relids required_outer,
    2563             :                       List *mergeclauses,
    2564             :                       List *outersortkeys,
    2565             :                       List *innersortkeys)
    2566             : {
    2567      250804 :     MergePath  *pathnode = makeNode(MergePath);
    2568             : 
    2569      250804 :     pathnode->jpath.path.pathtype = T_MergeJoin;
    2570      250804 :     pathnode->jpath.path.parent = joinrel;
    2571      250804 :     pathnode->jpath.path.pathtarget = joinrel->reltarget;
    2572      250804 :     pathnode->jpath.path.param_info =
    2573      250804 :         get_joinrel_parampathinfo(root,
    2574             :                                   joinrel,
    2575             :                                   outer_path,
    2576             :                                   inner_path,
    2577             :                                   extra->sjinfo,
    2578             :                                   required_outer,
    2579             :                                   &restrict_clauses);
    2580      250804 :     pathnode->jpath.path.parallel_aware = false;
    2581      723820 :     pathnode->jpath.path.parallel_safe = joinrel->consider_parallel &&
    2582      250804 :         outer_path->parallel_safe && inner_path->parallel_safe;
    2583             :     /* This is a foolish way to estimate parallel_workers, but for now... */
    2584      250804 :     pathnode->jpath.path.parallel_workers = outer_path->parallel_workers;
    2585      250804 :     pathnode->jpath.path.pathkeys = pathkeys;
    2586      250804 :     pathnode->jpath.jointype = jointype;
    2587      250804 :     pathnode->jpath.inner_unique = extra->inner_unique;
    2588      250804 :     pathnode->jpath.outerjoinpath = outer_path;
    2589      250804 :     pathnode->jpath.innerjoinpath = inner_path;
    2590      250804 :     pathnode->jpath.joinrestrictinfo = restrict_clauses;
    2591      250804 :     pathnode->path_mergeclauses = mergeclauses;
    2592      250804 :     pathnode->outersortkeys = outersortkeys;
    2593      250804 :     pathnode->innersortkeys = innersortkeys;
    2594             :     /* pathnode->skip_mark_restore will be set by final_cost_mergejoin */
    2595             :     /* pathnode->materialize_inner will be set by final_cost_mergejoin */
    2596             : 
    2597      250804 :     final_cost_mergejoin(root, pathnode, workspace, extra);
    2598             : 
    2599      250804 :     return pathnode;
    2600             : }
    2601             : 
    2602             : /*
    2603             :  * create_hashjoin_path
    2604             :  *    Creates a pathnode corresponding to a hash join between two relations.
    2605             :  *
    2606             :  * 'joinrel' is the join relation
    2607             :  * 'jointype' is the type of join required
    2608             :  * 'workspace' is the result from initial_cost_hashjoin
    2609             :  * 'extra' contains various information about the join
    2610             :  * 'outer_path' is the cheapest outer path
    2611             :  * 'inner_path' is the cheapest inner path
    2612             :  * 'parallel_hash' to select Parallel Hash of inner path (shared hash table)
    2613             :  * 'restrict_clauses' are the RestrictInfo nodes to apply at the join
    2614             :  * 'required_outer' is the set of required outer rels
    2615             :  * 'hashclauses' are the RestrictInfo nodes to use as hash clauses
    2616             :  *      (this should be a subset of the restrict_clauses list)
    2617             :  */
    2618             : HashPath *
    2619      219072 : create_hashjoin_path(PlannerInfo *root,
    2620             :                      RelOptInfo *joinrel,
    2621             :                      JoinType jointype,
    2622             :                      JoinCostWorkspace *workspace,
    2623             :                      JoinPathExtraData *extra,
    2624             :                      Path *outer_path,
    2625             :                      Path *inner_path,
    2626             :                      bool parallel_hash,
    2627             :                      List *restrict_clauses,
    2628             :                      Relids required_outer,
    2629             :                      List *hashclauses)
    2630             : {
    2631      219072 :     HashPath   *pathnode = makeNode(HashPath);
    2632             : 
    2633      219072 :     pathnode->jpath.path.pathtype = T_HashJoin;
    2634      219072 :     pathnode->jpath.path.parent = joinrel;
    2635      219072 :     pathnode->jpath.path.pathtarget = joinrel->reltarget;
    2636      219072 :     pathnode->jpath.path.param_info =
    2637      219072 :         get_joinrel_parampathinfo(root,
    2638             :                                   joinrel,
    2639             :                                   outer_path,
    2640             :                                   inner_path,
    2641             :                                   extra->sjinfo,
    2642             :                                   required_outer,
    2643             :                                   &restrict_clauses);
    2644      219072 :     pathnode->jpath.path.parallel_aware =
    2645      219072 :         joinrel->consider_parallel && parallel_hash;
    2646      630064 :     pathnode->jpath.path.parallel_safe = joinrel->consider_parallel &&
    2647      219072 :         outer_path->parallel_safe && inner_path->parallel_safe;
    2648             :     /* This is a foolish way to estimate parallel_workers, but for now... */
    2649      219072 :     pathnode->jpath.path.parallel_workers = outer_path->parallel_workers;
    2650             : 
    2651             :     /*
    2652             :      * A hashjoin never has pathkeys, since its output ordering is
    2653             :      * unpredictable due to possible batching.  XXX If the inner relation is
    2654             :      * small enough, we could instruct the executor that it must not batch,
    2655             :      * and then we could assume that the output inherits the outer relation's
    2656             :      * ordering, which might save a sort step.  However there is considerable
    2657             :      * downside if our estimate of the inner relation size is badly off. For
    2658             :      * the moment we don't risk it.  (Note also that if we wanted to take this
    2659             :      * seriously, joinpath.c would have to consider many more paths for the
    2660             :      * outer rel than it does now.)
    2661             :      */
    2662      219072 :     pathnode->jpath.path.pathkeys = NIL;
    2663      219072 :     pathnode->jpath.jointype = jointype;
    2664      219072 :     pathnode->jpath.inner_unique = extra->inner_unique;
    2665      219072 :     pathnode->jpath.outerjoinpath = outer_path;
    2666      219072 :     pathnode->jpath.innerjoinpath = inner_path;
    2667      219072 :     pathnode->jpath.joinrestrictinfo = restrict_clauses;
    2668      219072 :     pathnode->path_hashclauses = hashclauses;
    2669             :     /* final_cost_hashjoin will fill in pathnode->num_batches */
    2670             : 
    2671      219072 :     final_cost_hashjoin(root, pathnode, workspace, extra);
    2672             : 
    2673      219072 :     return pathnode;
    2674             : }
    2675             : 
    2676             : /*
    2677             :  * create_projection_path
    2678             :  *    Creates a pathnode that represents performing a projection.
    2679             :  *
    2680             :  * 'rel' is the parent relation associated with the result
    2681             :  * 'subpath' is the path representing the source of data
    2682             :  * 'target' is the PathTarget to be computed
    2683             :  */
    2684             : ProjectionPath *
    2685      367776 : create_projection_path(PlannerInfo *root,
    2686             :                        RelOptInfo *rel,
    2687             :                        Path *subpath,
    2688             :                        PathTarget *target)
    2689             : {
    2690      367776 :     ProjectionPath *pathnode = makeNode(ProjectionPath);
    2691             :     PathTarget *oldtarget;
    2692             : 
    2693             :     /*
    2694             :      * We mustn't put a ProjectionPath directly above another; it's useless
    2695             :      * and will confuse create_projection_plan.  Rather than making sure all
    2696             :      * callers handle that, let's implement it here, by stripping off any
    2697             :      * ProjectionPath in what we're given.  Given this rule, there won't be
    2698             :      * more than one.
    2699             :      */
    2700      367776 :     if (IsA(subpath, ProjectionPath))
    2701             :     {
    2702          12 :         ProjectionPath *subpp = (ProjectionPath *) subpath;
    2703             : 
    2704             :         Assert(subpp->path.parent == rel);
    2705          12 :         subpath = subpp->subpath;
    2706             :         Assert(!IsA(subpath, ProjectionPath));
    2707             :     }
    2708             : 
    2709      367776 :     pathnode->path.pathtype = T_Result;
    2710      367776 :     pathnode->path.parent = rel;
    2711      367776 :     pathnode->path.pathtarget = target;
    2712             :     /* For now, assume we are above any joins, so no parameterization */
    2713      367776 :     pathnode->path.param_info = NULL;
    2714      367776 :     pathnode->path.parallel_aware = false;
    2715      824462 :     pathnode->path.parallel_safe = rel->consider_parallel &&
    2716      456064 :         subpath->parallel_safe &&
    2717       88288 :         is_parallel_safe(root, (Node *) target->exprs);
    2718      367776 :     pathnode->path.parallel_workers = subpath->parallel_workers;
    2719             :     /* Projection does not change the sort order */
    2720      367776 :     pathnode->path.pathkeys = subpath->pathkeys;
    2721             : 
    2722      367776 :     pathnode->subpath = subpath;
    2723             : 
    2724             :     /*
    2725             :      * We might not need a separate Result node.  If the input plan node type
    2726             :      * can project, we can just tell it to project something else.  Or, if it
    2727             :      * can't project but the desired target has the same expression list as
    2728             :      * what the input will produce anyway, we can still give it the desired
    2729             :      * tlist (possibly changing its ressortgroupref labels, but nothing else).
    2730             :      * Note: in the latter case, create_projection_plan has to recheck our
    2731             :      * conclusion; see comments therein.
    2732             :      */
    2733      367776 :     oldtarget = subpath->pathtarget;
    2734      382660 :     if (is_projection_capable_path(subpath) ||
    2735       14884 :         equal(oldtarget->exprs, target->exprs))
    2736             :     {
    2737             :         /* No separate Result node needed */
    2738      365724 :         pathnode->dummypp = true;
    2739             : 
    2740             :         /*
    2741             :          * Set cost of plan as subpath's cost, adjusted for tlist replacement.
    2742             :          */
    2743      365724 :         pathnode->path.rows = subpath->rows;
    2744      365724 :         pathnode->path.startup_cost = subpath->startup_cost +
    2745      365724 :             (target->cost.startup - oldtarget->cost.startup);
    2746      365724 :         pathnode->path.total_cost = subpath->total_cost +
    2747      365724 :             (target->cost.startup - oldtarget->cost.startup) +
    2748      365724 :             (target->cost.per_tuple - oldtarget->cost.per_tuple) * subpath->rows;
    2749             :     }
    2750             :     else
    2751             :     {
    2752             :         /* We really do need the Result node */
    2753        2052 :         pathnode->dummypp = false;
    2754             : 
    2755             :         /*
    2756             :          * The Result node's cost is cpu_tuple_cost per row, plus the cost of
    2757             :          * evaluating the tlist.  There is no qual to worry about.
    2758             :          */
    2759        2052 :         pathnode->path.rows = subpath->rows;
    2760        2052 :         pathnode->path.startup_cost = subpath->startup_cost +
    2761        2052 :             target->cost.startup;
    2762        2052 :         pathnode->path.total_cost = subpath->total_cost +
    2763        2052 :             target->cost.startup +
    2764        2052 :             (cpu_tuple_cost + target->cost.per_tuple) * subpath->rows;
    2765             :     }
    2766             : 
    2767      367776 :     return pathnode;
    2768             : }
    2769             : 
    2770             : /*
    2771             :  * apply_projection_to_path
    2772             :  *    Add a projection step, or just apply the target directly to given path.
    2773             :  *
    2774             :  * This has the same net effect as create_projection_path(), except that if
    2775             :  * a separate Result plan node isn't needed, we just replace the given path's
    2776             :  * pathtarget with the desired one.  This must be used only when the caller
    2777             :  * knows that the given path isn't referenced elsewhere and so can be modified
    2778             :  * in-place.
    2779             :  *
    2780             :  * If the input path is a GatherPath or GatherMergePath, we try to push the
    2781             :  * new target down to its input as well; this is a yet more invasive
    2782             :  * modification of the input path, which create_projection_path() can't do.
    2783             :  *
    2784             :  * Note that we mustn't change the source path's parent link; so when it is
    2785             :  * add_path'd to "rel" things will be a bit inconsistent.  So far that has
    2786             :  * not caused any trouble.
    2787             :  *
    2788             :  * 'rel' is the parent relation associated with the result
    2789             :  * 'path' is the path representing the source of data
    2790             :  * 'target' is the PathTarget to be computed
    2791             :  */
    2792             : Path *
    2793       28132 : apply_projection_to_path(PlannerInfo *root,
    2794             :                          RelOptInfo *rel,
    2795             :                          Path *path,
    2796             :                          PathTarget *target)
    2797             : {
    2798             :     QualCost    oldcost;
    2799             : 
    2800             :     /*
    2801             :      * If given path can't project, we might need a Result node, so make a
    2802             :      * separate ProjectionPath.
    2803             :      */
    2804       28132 :     if (!is_projection_capable_path(path))
    2805       13780 :         return (Path *) create_projection_path(root, rel, path, target);
    2806             : 
    2807             :     /*
    2808             :      * We can just jam the desired tlist into the existing path, being sure to
    2809             :      * update its cost estimates appropriately.
    2810             :      */
    2811       14352 :     oldcost = path->pathtarget->cost;
    2812       14352 :     path->pathtarget = target;
    2813             : 
    2814       14352 :     path->startup_cost += target->cost.startup - oldcost.startup;
    2815       14352 :     path->total_cost += target->cost.startup - oldcost.startup +
    2816       14352 :         (target->cost.per_tuple - oldcost.per_tuple) * path->rows;
    2817             : 
    2818             :     /*
    2819             :      * If the path happens to be a Gather or GatherMerge path, we'd like to
    2820             :      * arrange for the subpath to return the required target list so that
    2821             :      * workers can help project.  But if there is something that is not
    2822             :      * parallel-safe in the target expressions, then we can't.
    2823             :      */
    2824       14808 :     if ((IsA(path, GatherPath) || IsA(path, GatherMergePath)) &&
    2825         456 :         is_parallel_safe(root, (Node *) target->exprs))
    2826             :     {
    2827             :         /*
    2828             :          * We always use create_projection_path here, even if the subpath is
    2829             :          * projection-capable, so as to avoid modifying the subpath in place.
    2830             :          * It seems unlikely at present that there could be any other
    2831             :          * references to the subpath, but better safe than sorry.
    2832             :          *
    2833             :          * Note that we don't change the parallel path's cost estimates; it
    2834             :          * might be appropriate to do so, to reflect the fact that the bulk of
    2835             :          * the target evaluation will happen in workers.
    2836             :          */
    2837         456 :         if (IsA(path, GatherPath))
    2838             :         {
    2839           0 :             GatherPath *gpath = (GatherPath *) path;
    2840             : 
    2841           0 :             gpath->subpath = (Path *)
    2842           0 :                 create_projection_path(root,
    2843           0 :                                        gpath->subpath->parent,
    2844             :                                        gpath->subpath,
    2845             :                                        target);
    2846             :         }
    2847             :         else
    2848             :         {
    2849         456 :             GatherMergePath *gmpath = (GatherMergePath *) path;
    2850             : 
    2851         456 :             gmpath->subpath = (Path *)
    2852         456 :                 create_projection_path(root,
    2853         456 :                                        gmpath->subpath->parent,
    2854             :                                        gmpath->subpath,
    2855             :                                        target);
    2856             :         }
    2857             :     }
    2858       13896 :     else if (path->parallel_safe &&
    2859        6002 :              !is_parallel_safe(root, (Node *) target->exprs))
    2860             :     {
    2861             :         /*
    2862             :          * We're inserting a parallel-restricted target list into a path
    2863             :          * currently marked parallel-safe, so we have to mark it as no longer
    2864             :          * safe.
    2865             :          */
    2866          12 :         path->parallel_safe = false;
    2867             :     }
    2868             : 
    2869       14352 :     return path;
    2870             : }
    2871             : 
    2872             : /*
    2873             :  * create_set_projection_path
    2874             :  *    Creates a pathnode that represents performing a projection that
    2875             :  *    includes set-returning functions.
    2876             :  *
    2877             :  * 'rel' is the parent relation associated with the result
    2878             :  * 'subpath' is the path representing the source of data
    2879             :  * 'target' is the PathTarget to be computed
    2880             :  */
    2881             : ProjectSetPath *
    2882        8432 : create_set_projection_path(PlannerInfo *root,
    2883             :                            RelOptInfo *rel,
    2884             :                            Path *subpath,
    2885             :                            PathTarget *target)
    2886             : {
    2887        8432 :     ProjectSetPath *pathnode = makeNode(ProjectSetPath);
    2888             :     double      tlist_rows;
    2889             :     ListCell   *lc;
    2890             : 
    2891        8432 :     pathnode->path.pathtype = T_ProjectSet;
    2892        8432 :     pathnode->path.parent = rel;
    2893        8432 :     pathnode->path.pathtarget = target;
    2894             :     /* For now, assume we are above any joins, so no parameterization */
    2895        8432 :     pathnode->path.param_info = NULL;
    2896        8432 :     pathnode->path.parallel_aware = false;
    2897       18574 :     pathnode->path.parallel_safe = rel->consider_parallel &&
    2898       10106 :         subpath->parallel_safe &&
    2899        1674 :         is_parallel_safe(root, (Node *) target->exprs);
    2900        8432 :     pathnode->path.parallel_workers = subpath->parallel_workers;
    2901             :     /* Projection does not change the sort order XXX? */
    2902        8432 :     pathnode->path.pathkeys = subpath->pathkeys;
    2903             : 
    2904        8432 :     pathnode->subpath = subpath;
    2905             : 
    2906             :     /*
    2907             :      * Estimate number of rows produced by SRFs for each row of input; if
    2908             :      * there's more than one in this node, use the maximum.
    2909             :      */
    2910        8432 :     tlist_rows = 1;
    2911       18728 :     foreach(lc, target->exprs)
    2912             :     {
    2913       10296 :         Node       *node = (Node *) lfirst(lc);
    2914             :         double      itemrows;
    2915             : 
    2916       10296 :         itemrows = expression_returns_set_rows(root, node);
    2917       10296 :         if (tlist_rows < itemrows)
    2918        8204 :             tlist_rows = itemrows;
    2919             :     }
    2920             : 
    2921             :     /*
    2922             :      * In addition to the cost of evaluating the tlist, charge cpu_tuple_cost
    2923             :      * per input row, and half of cpu_tuple_cost for each added output row.
    2924             :      * This is slightly bizarre maybe, but it's what 9.6 did; we may revisit
    2925             :      * this estimate later.
    2926             :      */
    2927        8432 :     pathnode->path.rows = subpath->rows * tlist_rows;
    2928        8432 :     pathnode->path.startup_cost = subpath->startup_cost +
    2929        8432 :         target->cost.startup;
    2930        8432 :     pathnode->path.total_cost = subpath->total_cost +
    2931        8432 :         target->cost.startup +
    2932        8432 :         (cpu_tuple_cost + target->cost.per_tuple) * subpath->rows +
    2933        8432 :         (pathnode->path.rows - subpath->rows) * cpu_tuple_cost / 2;
    2934             : 
    2935        8432 :     return pathnode;
    2936             : }
    2937             : 
    2938             : /*
    2939             :  * create_incremental_sort_path
    2940             :  *    Creates a pathnode that represents performing an incremental sort.
    2941             :  *
    2942             :  * 'rel' is the parent relation associated with the result
    2943             :  * 'subpath' is the path representing the source of data
    2944             :  * 'pathkeys' represents the desired sort order
    2945             :  * 'presorted_keys' is the number of keys by which the input path is
    2946             :  *      already sorted
    2947             :  * 'limit_tuples' is the estimated bound on the number of output tuples,
    2948             :  *      or -1 if no LIMIT or couldn't estimate
    2949             :  */
    2950             : IncrementalSortPath *
    2951        7654 : create_incremental_sort_path(PlannerInfo *root,
    2952             :                              RelOptInfo *rel,
    2953             :                              Path *subpath,
    2954             :                              List *pathkeys,
    2955             :                              int presorted_keys,
    2956             :                              double limit_tuples)
    2957             : {
    2958        7654 :     IncrementalSortPath *sort = makeNode(IncrementalSortPath);
    2959        7654 :     SortPath   *pathnode = &sort->spath;
    2960             : 
    2961        7654 :     pathnode->path.pathtype = T_IncrementalSort;
    2962        7654 :     pathnode->path.parent = rel;
    2963             :     /* Sort doesn't project, so use source path's pathtarget */
    2964        7654 :     pathnode->path.pathtarget = subpath->pathtarget;
    2965             :     /* For now, assume we are above any joins, so no parameterization */
    2966        7654 :     pathnode->path.param_info = NULL;
    2967        7654 :     pathnode->path.parallel_aware = false;
    2968       11116 :     pathnode->path.parallel_safe = rel->consider_parallel &&
    2969        3462 :         subpath->parallel_safe;
    2970        7654 :     pathnode->path.parallel_workers = subpath->parallel_workers;
    2971        7654 :     pathnode->path.pathkeys = pathkeys;
    2972             : 
    2973        7654 :     pathnode->subpath = subpath;
    2974             : 
    2975        7654 :     cost_incremental_sort(&pathnode->path,
    2976             :                           root, pathkeys, presorted_keys,
    2977             :                           subpath->startup_cost,
    2978             :                           subpath->total_cost,
    2979             :                           subpath->rows,
    2980        7654 :                           subpath->pathtarget->width,
    2981             :                           0.0,  /* XXX comparison_cost shouldn't be 0? */
    2982             :                           work_mem, limit_tuples);
    2983             : 
    2984        7654 :     sort->nPresortedCols = presorted_keys;
    2985             : 
    2986        7654 :     return sort;
    2987             : }
    2988             : 
    2989             : /*
    2990             :  * create_sort_path
    2991             :  *    Creates a pathnode that represents performing an explicit sort.
    2992             :  *
    2993             :  * 'rel' is the parent relation associated with the result
    2994             :  * 'subpath' is the path representing the source of data
    2995             :  * 'pathkeys' represents the desired sort order
    2996             :  * 'limit_tuples' is the estimated bound on the number of output tuples,
    2997             :  *      or -1 if no LIMIT or couldn't estimate
    2998             :  */
    2999             : SortPath *
    3000       80606 : create_sort_path(PlannerInfo *root,
    3001             :                  RelOptInfo *rel,
    3002             :                  Path *subpath,
    3003             :                  List *pathkeys,
    3004             :                  double limit_tuples)
    3005             : {
    3006       80606 :     SortPath   *pathnode = makeNode(SortPath);
    3007             : 
    3008       80606 :     pathnode->path.pathtype = T_Sort;
    3009       80606 :     pathnode->path.parent = rel;
    3010             :     /* Sort doesn't project, so use source path's pathtarget */
    3011       80606 :     pathnode->path.pathtarget = subpath->pathtarget;
    3012             :     /* For now, assume we are above any joins, so no parameterization */
    3013       80606 :     pathnode->path.param_info = NULL;
    3014       80606 :     pathnode->path.parallel_aware = false;
    3015      135902 :     pathnode->path.parallel_safe = rel->consider_parallel &&
    3016       55296 :         subpath->parallel_safe;
    3017       80606 :     pathnode->path.parallel_workers = subpath->parallel_workers;
    3018       80606 :     pathnode->path.pathkeys = pathkeys;
    3019             : 
    3020       80606 :     pathnode->subpath = subpath;
    3021             : 
    3022       80606 :     cost_sort(&pathnode->path, root, pathkeys,
    3023             :               subpath->total_cost,
    3024             :               subpath->rows,
    3025       80606 :               subpath->pathtarget->width,
    3026             :               0.0,              /* XXX comparison_cost shouldn't be 0? */
    3027             :               work_mem, limit_tuples);
    3028             : 
    3029       80606 :     return pathnode;
    3030             : }
    3031             : 
    3032             : /*
    3033             :  * create_group_path
    3034             :  *    Creates a pathnode that represents performing grouping of presorted input
    3035             :  *
    3036             :  * 'rel' is the parent relation associated with the result
    3037             :  * 'subpath' is the path representing the source of data
    3038             :  * 'target' is the PathTarget to be computed
    3039             :  * 'groupClause' is a list of SortGroupClause's representing the grouping
    3040             :  * 'qual' is the HAVING quals if any
    3041             :  * 'numGroups' is the estimated number of groups
    3042             :  */
    3043             : GroupPath *
    3044        1118 : create_group_path(PlannerInfo *root,
    3045             :                   RelOptInfo *rel,
    3046             :                   Path *subpath,
    3047             :                   List *groupClause,
    3048             :                   List *qual,
    3049             :                   double numGroups)
    3050             : {
    3051        1118 :     GroupPath  *pathnode = makeNode(GroupPath);
    3052        1118 :     PathTarget *target = rel->reltarget;
    3053             : 
    3054        1118 :     pathnode->path.pathtype = T_Group;
    3055        1118 :     pathnode->path.parent = rel;
    3056        1118 :     pathnode->path.pathtarget = target;
    3057             :     /* For now, assume we are above any joins, so no parameterization */
    3058        1118 :     pathnode->path.param_info = NULL;
    3059        1118 :     pathnode->path.parallel_aware = false;
    3060        1844 :     pathnode->path.parallel_safe = rel->consider_parallel &&
    3061         726 :         subpath->parallel_safe;
    3062        1118 :     pathnode->path.parallel_workers = subpath->parallel_workers;
    3063             :     /* Group doesn't change sort ordering */
    3064        1118 :     pathnode->path.pathkeys = subpath->pathkeys;
    3065             : 
    3066        1118 :     pathnode->subpath = subpath;
    3067             : 
    3068        1118 :     pathnode->groupClause = groupClause;
    3069        1118 :     pathnode->qual = qual;
    3070             : 
    3071        1118 :     cost_group(&pathnode->path, root,
    3072             :                list_length(groupClause),
    3073             :                numGroups,
    3074             :                qual,
    3075             :                subpath->startup_cost, subpath->total_cost,
    3076             :                subpath->rows);
    3077             : 
    3078             :     /* add tlist eval cost for each output row */
    3079        1118 :     pathnode->path.startup_cost += target->cost.startup;
    3080        1118 :     pathnode->path.total_cost += target->cost.startup +
    3081        1118 :         target->cost.per_tuple * pathnode->path.rows;
    3082             : 
    3083        1118 :     return pathnode;
    3084             : }
    3085             : 
    3086             : /*
    3087             :  * create_upper_unique_path
    3088             :  *    Creates a pathnode that represents performing an explicit Unique step
    3089             :  *    on presorted input.
    3090             :  *
    3091             :  * This produces a Unique plan node, but the use-case is so different from
    3092             :  * create_unique_path that it doesn't seem worth trying to merge the two.
    3093             :  *
    3094             :  * 'rel' is the parent relation associated with the result
    3095             :  * 'subpath' is the path representing the source of data
    3096             :  * 'numCols' is the number of grouping columns
    3097             :  * 'numGroups' is the estimated number of groups
    3098             :  *
    3099             :  * The input path must be sorted on the grouping columns, plus possibly
    3100             :  * additional columns; so the first numCols pathkeys are the grouping columns
    3101             :  */
    3102             : UpperUniquePath *
    3103        6606 : create_upper_unique_path(PlannerInfo *root,
    3104             :                          RelOptInfo *rel,
    3105             :                          Path *subpath,
    3106             :                          int numCols,
    3107             :                          double numGroups)
    3108             : {
    3109        6606 :     UpperUniquePath *pathnode = makeNode(UpperUniquePath);
    3110             : 
    3111        6606 :     pathnode->path.pathtype = T_Unique;
    3112        6606 :     pathnode->path.parent = rel;
    3113             :     /* Unique doesn't project, so use source path's pathtarget */
    3114        6606 :     pathnode->path.pathtarget = subpath->pathtarget;
    3115             :     /* For now, assume we are above any joins, so no parameterization */
    3116        6606 :     pathnode->path.param_info = NULL;
    3117        6606 :     pathnode->path.parallel_aware = false;
    3118       10118 :     pathnode->path.parallel_safe = rel->consider_parallel &&
    3119        3512 :         subpath->parallel_safe;
    3120        6606 :     pathnode->path.parallel_workers = subpath->parallel_workers;
    3121             :     /* Unique doesn't change the input ordering */
    3122        6606 :     pathnode->path.pathkeys = subpath->pathkeys;
    3123             : 
    3124        6606 :     pathnode->subpath = subpath;
    3125        6606 :     pathnode->numkeys = numCols;
    3126             : 
    3127             :     /*
    3128             :      * Charge one cpu_operator_cost per comparison per input tuple. We assume
    3129             :      * all columns get compared at most of the tuples.  (XXX probably this is
    3130             :      * an overestimate.)
    3131             :      */
    3132        6606 :     pathnode->path.startup_cost = subpath->startup_cost;
    3133        6606 :     pathnode->path.total_cost = subpath->total_cost +
    3134        6606 :         cpu_operator_cost * subpath->rows * numCols;
    3135        6606 :     pathnode->path.rows = numGroups;
    3136             : 
    3137        6606 :     return pathnode;
    3138             : }
    3139             : 
    3140             : /*
    3141             :  * create_agg_path
    3142             :  *    Creates a pathnode that represents performing aggregation/grouping
    3143             :  *
    3144             :  * 'rel' is the parent relation associated with the result
    3145             :  * 'subpath' is the path representing the source of data
    3146             :  * 'target' is the PathTarget to be computed
    3147             :  * 'aggstrategy' is the Agg node's basic implementation strategy
    3148             :  * 'aggsplit' is the Agg node's aggregate-splitting mode
    3149             :  * 'groupClause' is a list of SortGroupClause's representing the grouping
    3150             :  * 'qual' is the HAVING quals if any
    3151             :  * 'aggcosts' contains cost info about the aggregate functions to be computed
    3152             :  * 'numGroups' is the estimated number of groups (1 if not grouping)
    3153             :  */
    3154             : AggPath *
    3155       51320 : create_agg_path(PlannerInfo *root,
    3156             :                 RelOptInfo *rel,
    3157             :                 Path *subpath,
    3158             :                 PathTarget *target,
    3159             :                 AggStrategy aggstrategy,
    3160             :                 AggSplit aggsplit,
    3161             :                 List *groupClause,
    3162             :                 List *qual,
    3163             :                 const AggClauseCosts *aggcosts,
    3164             :                 double numGroups)
    3165             : {
    3166       51320 :     AggPath    *pathnode = makeNode(AggPath);
    3167             : 
    3168       51320 :     pathnode->path.pathtype = T_Agg;
    3169       51320 :     pathnode->path.parent = rel;
    3170       51320 :     pathnode->path.pathtarget = target;
    3171             :     /* For now, assume we are above any joins, so no parameterization */
    3172       51320 :     pathnode->path.param_info = NULL;
    3173       51320 :     pathnode->path.parallel_aware = false;
    3174       87104 :     pathnode->path.parallel_safe = rel->consider_parallel &&
    3175       35784 :         subpath->parallel_safe;
    3176       51320 :     pathnode->path.parallel_workers = subpath->parallel_workers;
    3177             : 
    3178       51320 :     if (aggstrategy == AGG_SORTED)
    3179             :     {
    3180             :         /*
    3181             :          * Attempt to preserve the order of the subpath.  Additional pathkeys
    3182             :          * may have been added in adjust_group_pathkeys_for_groupagg() to
    3183             :          * support ORDER BY / DISTINCT aggregates.  Pathkeys added there
    3184             :          * belong to columns within the aggregate function, so we must strip
    3185             :          * these additional pathkeys off as those columns are unavailable
    3186             :          * above the aggregate node.
    3187             :          */
    3188        7344 :         if (list_length(subpath->pathkeys) > root->num_groupby_pathkeys)
    3189         326 :             pathnode->path.pathkeys = list_copy_head(subpath->pathkeys,
    3190             :                                                      root->num_groupby_pathkeys);
    3191             :         else
    3192        7018 :             pathnode->path.pathkeys = subpath->pathkeys;  /* preserves order */
    3193             :     }
    3194             :     else
    3195       43976 :         pathnode->path.pathkeys = NIL;   /* output is unordered */
    3196             : 
    3197       51320 :     pathnode->subpath = subpath;
    3198             : 
    3199       51320 :     pathnode->aggstrategy = aggstrategy;
    3200       51320 :     pathnode->aggsplit = aggsplit;
    3201       51320 :     pathnode->numGroups = numGroups;
    3202       51320 :     pathnode->transitionSpace = aggcosts ? aggcosts->transitionSpace : 0;
    3203       51320 :     pathnode->groupClause = groupClause;
    3204       51320 :     pathnode->qual = qual;
    3205             : 
    3206       51320 :     cost_agg(&pathnode->path, root,
    3207             :              aggstrategy, aggcosts,
    3208             :              list_length(groupClause), numGroups,
    3209             :              qual,
    3210             :              subpath->startup_cost, subpath->total_cost,
    3211       51320 :              subpath->rows, subpath->pathtarget->width);
    3212             : 
    3213             :     /* add tlist eval cost for each output row */
    3214       51320 :     pathnode->path.startup_cost += target->cost.startup;
    3215       51320 :     pathnode->path.total_cost += target->cost.startup +
    3216       51320 :         target->cost.per_tuple * pathnode->path.rows;
    3217             : 
    3218       51320 :     return pathnode;
    3219             : }
    3220             : 
    3221             : /*
    3222             :  * create_groupingsets_path
    3223             :  *    Creates a pathnode that represents performing GROUPING SETS aggregation
    3224             :  *
    3225             :  * GroupingSetsPath represents sorted grouping with one or more grouping sets.
    3226             :  * The input path's result must be sorted to match the last entry in
    3227             :  * rollup_groupclauses.
    3228             :  *
    3229             :  * 'rel' is the parent relation associated with the result
    3230             :  * 'subpath' is the path representing the source of data
    3231             :  * 'target' is the PathTarget to be computed
    3232             :  * 'having_qual' is the HAVING quals if any
    3233             :  * 'rollups' is a list of RollupData nodes
    3234             :  * 'agg_costs' contains cost info about the aggregate functions to be computed
    3235             :  */
    3236             : GroupingSetsPath *
    3237        1792 : create_groupingsets_path(PlannerInfo *root,
    3238             :                          RelOptInfo *rel,
    3239             :                          Path *subpath,
    3240             :                          List *having_qual,
    3241             :                          AggStrategy aggstrategy,
    3242             :                          List *rollups,
    3243             :                          const AggClauseCosts *agg_costs)
    3244             : {
    3245        1792 :     GroupingSetsPath *pathnode = makeNode(GroupingSetsPath);
    3246        1792 :     PathTarget *target = rel->reltarget;
    3247             :     ListCell   *lc;
    3248        1792 :     bool        is_first = true;
    3249        1792 :     bool        is_first_sort = true;
    3250             : 
    3251             :     /* The topmost generated Plan node will be an Agg */
    3252        1792 :     pathnode->path.pathtype = T_Agg;
    3253        1792 :     pathnode->path.parent = rel;
    3254        1792 :     pathnode->path.pathtarget = target;
    3255        1792 :     pathnode->path.param_info = subpath->param_info;
    3256        1792 :     pathnode->path.parallel_aware = false;
    3257        2614 :     pathnode->path.parallel_safe = rel->consider_parallel &&
    3258         822 :         subpath->parallel_safe;
    3259        1792 :     pathnode->path.parallel_workers = subpath->parallel_workers;
    3260        1792 :     pathnode->subpath = subpath;
    3261             : 
    3262             :     /*
    3263             :      * Simplify callers by downgrading AGG_SORTED to AGG_PLAIN, and AGG_MIXED
    3264             :      * to AGG_HASHED, here if possible.
    3265             :      */
    3266        2556 :     if (aggstrategy == AGG_SORTED &&
    3267         764 :         list_length(rollups) == 1 &&
    3268         362 :         ((RollupData *) linitial(rollups))->groupClause == NIL)
    3269          42 :         aggstrategy = AGG_PLAIN;
    3270             : 
    3271        2636 :     if (aggstrategy == AGG_MIXED &&
    3272         844 :         list_length(rollups) == 1)
    3273           0 :         aggstrategy = AGG_HASHED;
    3274             : 
    3275             :     /*
    3276             :      * Output will be in sorted order by group_pathkeys if, and only if, there
    3277             :      * is a single rollup operation on a non-empty list of grouping
    3278             :      * expressions.
    3279             :      */
    3280        1792 :     if (aggstrategy == AGG_SORTED && list_length(rollups) == 1)
    3281         320 :         pathnode->path.pathkeys = root->group_pathkeys;
    3282             :     else
    3283        1472 :         pathnode->path.pathkeys = NIL;
    3284             : 
    3285        1792 :     pathnode->aggstrategy = aggstrategy;
    3286        1792 :     pathnode->rollups = rollups;
    3287        1792 :     pathnode->qual = having_qual;
    3288        1792 :     pathnode->transitionSpace = agg_costs ? agg_costs->transitionSpace : 0;
    3289             : 
    3290             :     Assert(rollups != NIL);
    3291             :     Assert(aggstrategy != AGG_PLAIN || list_length(rollups) == 1);
    3292             :     Assert(aggstrategy != AGG_MIXED || list_length(rollups) > 1);
    3293             : 
    3294        6396 :     foreach(lc, rollups)
    3295             :     {
    3296        4604 :         RollupData *rollup = lfirst(lc);
    3297        4604 :         List       *gsets = rollup->gsets;
    3298        4604 :         int         numGroupCols = list_length(linitial(gsets));
    3299             : 
    3300             :         /*
    3301             :          * In AGG_SORTED or AGG_PLAIN mode, the first rollup takes the
    3302             :          * (already-sorted) input, and following ones do their own sort.
    3303             :          *
    3304             :          * In AGG_HASHED mode, there is one rollup for each grouping set.
    3305             :          *
    3306             :          * In AGG_MIXED mode, the first rollups are hashed, the first
    3307             :          * non-hashed one takes the (already-sorted) input, and following ones
    3308             :          * do their own sort.
    3309             :          */
    3310        4604 :         if (is_first)
    3311             :         {
    3312        1792 :             cost_agg(&pathnode->path, root,
    3313             :                      aggstrategy,
    3314             :                      agg_costs,
    3315             :                      numGroupCols,
    3316             :                      rollup->numGroups,
    3317             :                      having_qual,
    3318             :                      subpath->startup_cost,
    3319             :                      subpath->total_cost,
    3320             :                      subpath->rows,
    3321        1792 :                      subpath->pathtarget->width);
    3322        1792 :             is_first = false;
    3323        1792 :             if (!rollup->is_hashed)
    3324         764 :                 is_first_sort = false;
    3325             :         }
    3326             :         else
    3327             :         {
    3328             :             Path        sort_path;  /* dummy for result of cost_sort */
    3329             :             Path        agg_path;   /* dummy for result of cost_agg */
    3330             : 
    3331        2812 :             if (rollup->is_hashed || is_first_sort)
    3332             :             {
    3333             :                 /*
    3334             :                  * Account for cost of aggregation, but don't charge input
    3335             :                  * cost again
    3336             :                  */
    3337        2158 :                 cost_agg(&agg_path, root,
    3338        2158 :                          rollup->is_hashed ? AGG_HASHED : AGG_SORTED,
    3339             :                          agg_costs,
    3340             :                          numGroupCols,
    3341             :                          rollup->numGroups,
    3342             :                          having_qual,
    3343             :                          0.0, 0.0,
    3344             :                          subpath->rows,
    3345        2158 :                          subpath->pathtarget->width);
    3346        2158 :                 if (!rollup->is_hashed)
    3347         844 :                     is_first_sort = false;
    3348             :             }
    3349             :             else
    3350             :             {
    3351             :                 /* Account for cost of sort, but don't charge input cost again */
    3352         654 :                 cost_sort(&sort_path, root, NIL,
    3353             :                           0.0,
    3354             :                           subpath->rows,
    3355         654 :                           subpath->pathtarget->width,
    3356             :                           0.0,
    3357             :                           work_mem,
    3358             :                           -1.0);
    3359             : 
    3360             :                 /* Account for cost of aggregation */
    3361             : 
    3362         654 :                 cost_agg(&agg_path, root,
    3363             :                          AGG_SORTED,
    3364             :                          agg_costs,
    3365             :                          numGroupCols,
    3366             :                          rollup->numGroups,
    3367             :                          having_qual,
    3368             :                          sort_path.startup_cost,
    3369             :                          sort_path.total_cost,
    3370             :                          sort_path.rows,
    3371         654 :                          subpath->pathtarget->width);
    3372             :             }
    3373             : 
    3374        2812 :             pathnode->path.total_cost += agg_path.total_cost;
    3375        2812 :             pathnode->path.rows += agg_path.rows;
    3376             :         }
    3377             :     }
    3378             : 
    3379             :     /* add tlist eval cost for each output row */
    3380        1792 :     pathnode->path.startup_cost += target->cost.startup;
    3381        1792 :     pathnode->path.total_cost += target->cost.startup +
    3382        1792 :         target->cost.per_tuple * pathnode->path.rows;
    3383             : 
    3384        1792 :     return pathnode;
    3385             : }
    3386             : 
    3387             : /*
    3388             :  * create_minmaxagg_path
    3389             :  *    Creates a pathnode that represents computation of MIN/MAX aggregates
    3390             :  *
    3391             :  * 'rel' is the parent relation associated with the result
    3392             :  * 'target' is the PathTarget to be computed
    3393             :  * 'mmaggregates' is a list of MinMaxAggInfo structs
    3394             :  * 'quals' is the HAVING quals if any
    3395             :  */
    3396             : MinMaxAggPath *
    3397         386 : create_minmaxagg_path(PlannerInfo *root,
    3398             :                       RelOptInfo *rel,
    3399             :                       PathTarget *target,
    3400             :                       List *mmaggregates,
    3401             :                       List *quals)
    3402             : {
    3403         386 :     MinMaxAggPath *pathnode = makeNode(MinMaxAggPath);
    3404             :     Cost        initplan_cost;
    3405             :     ListCell   *lc;
    3406             : 
    3407             :     /* The topmost generated Plan node will be a Result */
    3408         386 :     pathnode->path.pathtype = T_Result;
    3409         386 :     pathnode->path.parent = rel;
    3410         386 :     pathnode->path.pathtarget = target;
    3411             :     /* For now, assume we are above any joins, so no parameterization */
    3412         386 :     pathnode->path.param_info = NULL;
    3413         386 :     pathnode->path.parallel_aware = false;
    3414         386 :     pathnode->path.parallel_safe = true; /* might change below */
    3415         386 :     pathnode->path.parallel_workers = 0;
    3416             :     /* Result is one unordered row */
    3417         386 :     pathnode->path.rows = 1;
    3418         386 :     pathnode->path.pathkeys = NIL;
    3419             : 
    3420         386 :     pathnode->mmaggregates = mmaggregates;
    3421         386 :     pathnode->quals = quals;
    3422             : 
    3423             :     /* Calculate cost of all the initplans, and check parallel safety */
    3424         386 :     initplan_cost = 0;
    3425         808 :     foreach(lc, mmaggregates)
    3426             :     {
    3427         422 :         MinMaxAggInfo *mminfo = (MinMaxAggInfo *) lfirst(lc);
    3428             : 
    3429         422 :         initplan_cost += mminfo->pathcost;
    3430         422 :         if (!mminfo->path->parallel_safe)
    3431          86 :             pathnode->path.parallel_safe = false;
    3432             :     }
    3433             : 
    3434             :     /* add tlist eval cost for each output row, plus cpu_tuple_cost */
    3435         386 :     pathnode->path.startup_cost = initplan_cost + target->cost.startup;
    3436         386 :     pathnode->path.total_cost = initplan_cost + target->cost.startup +
    3437         386 :         target->cost.per_tuple + cpu_tuple_cost;
    3438             : 
    3439             :     /*
    3440             :      * Add cost of qual, if any --- but we ignore its selectivity, since our
    3441             :      * rowcount estimate should be 1 no matter what the qual is.
    3442             :      */
    3443         386 :     if (quals)
    3444             :     {
    3445             :         QualCost    qual_cost;
    3446             : 
    3447           0 :         cost_qual_eval(&qual_cost, quals, root);
    3448           0 :         pathnode->path.startup_cost += qual_cost.startup;
    3449           0 :         pathnode->path.total_cost += qual_cost.startup + qual_cost.per_tuple;
    3450             :     }
    3451             : 
    3452             :     /*
    3453             :      * If the initplans were all parallel-safe, also check safety of the
    3454             :      * target and quals.  (The Result node itself isn't parallelizable, but if
    3455             :      * we are in a subquery then it can be useful for the outer query to know
    3456             :      * that this one is parallel-safe.)
    3457             :      */
    3458         386 :     if (pathnode->path.parallel_safe)
    3459         300 :         pathnode->path.parallel_safe =
    3460         600 :             is_parallel_safe(root, (Node *) target->exprs) &&
    3461         300 :             is_parallel_safe(root, (Node *) quals);
    3462             : 
    3463         386 :     return pathnode;
    3464             : }
    3465             : 
    3466             : /*
    3467             :  * create_windowagg_path
    3468             :  *    Creates a pathnode that represents computation of window functions
    3469             :  *
    3470             :  * 'rel' is the parent relation associated with the result
    3471             :  * 'subpath' is the path representing the source of data
    3472             :  * 'target' is the PathTarget to be computed
    3473             :  * 'windowFuncs' is a list of WindowFunc structs
    3474             :  * 'winclause' is a WindowClause that is common to all the WindowFuncs
    3475             :  * 'qual' WindowClause.runconditions from lower-level WindowAggPaths.
    3476             :  *      Must always be NIL when topwindow == false
    3477             :  * 'topwindow' pass as true only for the top-level WindowAgg. False for all
    3478             :  *      intermediate WindowAggs.
    3479             :  *
    3480             :  * The input must be sorted according to the WindowClause's PARTITION keys
    3481             :  * plus ORDER BY keys.
    3482             :  */
    3483             : WindowAggPath *
    3484        2630 : create_windowagg_path(PlannerInfo *root,
    3485             :                       RelOptInfo *rel,
    3486             :                       Path *subpath,
    3487             :                       PathTarget *target,
    3488             :                       List *windowFuncs,
    3489             :                       WindowClause *winclause,
    3490             :                       List *qual,
    3491             :                       bool topwindow)
    3492             : {
    3493        2630 :     WindowAggPath *pathnode = makeNode(WindowAggPath);
    3494             : 
    3495             :     /* qual can only be set for the topwindow */
    3496             :     Assert(qual == NIL || topwindow);
    3497             : 
    3498        2630 :     pathnode->path.pathtype = T_WindowAgg;
    3499        2630 :     pathnode->path.parent = rel;
    3500        2630 :     pathnode->path.pathtarget = target;
    3501             :     /* For now, assume we are above any joins, so no parameterization */
    3502        2630 :     pathnode->path.param_info = NULL;
    3503        2630 :     pathnode->path.parallel_aware = false;
    3504        2630 :     pathnode->path.parallel_safe = rel->consider_parallel &&
    3505           0 :         subpath->parallel_safe;
    3506        2630 :     pathnode->path.parallel_workers = subpath->parallel_workers;
    3507             :     /* WindowAgg preserves the input sort order */
    3508        2630 :     pathnode->path.pathkeys = subpath->pathkeys;
    3509             : 
    3510        2630 :     pathnode->subpath = subpath;
    3511        2630 :     pathnode->winclause = winclause;
    3512        2630 :     pathnode->qual = qual;
    3513        2630 :     pathnode->topwindow = topwindow;
    3514             : 
    3515             :     /*
    3516             :      * For costing purposes, assume that there are no redundant partitioning
    3517             :      * or ordering columns; it's not worth the trouble to deal with that
    3518             :      * corner case here.  So we just pass the unmodified list lengths to
    3519             :      * cost_windowagg.
    3520             :      */
    3521        2630 :     cost_windowagg(&pathnode->path, root,
    3522             :                    windowFuncs,
    3523             :                    winclause,
    3524             :                    subpath->startup_cost,
    3525             :                    subpath->total_cost,
    3526             :                    subpath->rows);
    3527             : 
    3528             :     /* add tlist eval cost for each output row */
    3529        2630 :     pathnode->path.startup_cost += target->cost.startup;
    3530        2630 :     pathnode->path.total_cost += target->cost.startup +
    3531        2630 :         target->cost.per_tuple * pathnode->path.rows;
    3532             : 
    3533        2630 :     return pathnode;
    3534             : }
    3535             : 
    3536             : /*
    3537             :  * create_setop_path
    3538             :  *    Creates a pathnode that represents computation of INTERSECT or EXCEPT
    3539             :  *
    3540             :  * 'rel' is the parent relation associated with the result
    3541             :  * 'subpath' is the path representing the source of data
    3542             :  * 'cmd' is the specific semantics (INTERSECT or EXCEPT, with/without ALL)
    3543             :  * 'strategy' is the implementation strategy (sorted or hashed)
    3544             :  * 'distinctList' is a list of SortGroupClause's representing the grouping
    3545             :  * 'flagColIdx' is the column number where the flag column will be, if any
    3546             :  * 'firstFlag' is the flag value for the first input relation when hashing;
    3547             :  *      or -1 when sorting
    3548             :  * 'numGroups' is the estimated number of distinct groups
    3549             :  * 'outputRows' is the estimated number of output rows
    3550             :  */
    3551             : SetOpPath *
    3552         600 : create_setop_path(PlannerInfo *root,
    3553             :                   RelOptInfo *rel,
    3554             :                   Path *subpath,
    3555             :                   SetOpCmd cmd,
    3556             :                   SetOpStrategy strategy,
    3557             :                   List *distinctList,
    3558             :                   AttrNumber flagColIdx,
    3559             :                   int firstFlag,
    3560             :                   double numGroups,
    3561             :                   double outputRows)
    3562             : {
    3563         600 :     SetOpPath  *pathnode = makeNode(SetOpPath);
    3564             : 
    3565         600 :     pathnode->path.pathtype = T_SetOp;
    3566         600 :     pathnode->path.parent = rel;
    3567             :     /* SetOp doesn't project, so use source path's pathtarget */
    3568         600 :     pathnode->path.pathtarget = subpath->pathtarget;
    3569             :     /* For now, assume we are above any joins, so no parameterization */
    3570         600 :     pathnode->path.param_info = NULL;
    3571         600 :     pathnode->path.parallel_aware = false;
    3572         600 :     pathnode->path.parallel_safe = rel->consider_parallel &&
    3573           0 :         subpath->parallel_safe;
    3574         600 :     pathnode->path.parallel_workers = subpath->parallel_workers;
    3575             :     /* SetOp preserves the input sort order if in sort mode */
    3576         600 :     pathnode->path.pathkeys =
    3577         600 :         (strategy == SETOP_SORTED) ? subpath->pathkeys : NIL;
    3578             : 
    3579         600 :     pathnode->subpath = subpath;
    3580         600 :     pathnode->cmd = cmd;
    3581         600 :     pathnode->strategy = strategy;
    3582         600 :     pathnode->distinctList = distinctList;
    3583         600 :     pathnode->flagColIdx = flagColIdx;
    3584         600 :     pathnode->firstFlag = firstFlag;
    3585         600 :     pathnode->numGroups = numGroups;
    3586             : 
    3587             :     /*
    3588             :      * Charge one cpu_operator_cost per comparison per input tuple. We assume
    3589             :      * all columns get compared at most of the tuples.
    3590             :      */
    3591         600 :     pathnode->path.startup_cost = subpath->startup_cost;
    3592        1200 :     pathnode->path.total_cost = subpath->total_cost +
    3593         600 :         cpu_operator_cost * subpath->rows * list_length(distinctList);
    3594         600 :     pathnode->path.rows = outputRows;
    3595             : 
    3596         600 :     return pathnode;
    3597             : }
    3598             : 
    3599             : /*
    3600             :  * create_recursiveunion_path
    3601             :  *    Creates a pathnode that represents a recursive UNION node
    3602             :  *
    3603             :  * 'rel' is the parent relation associated with the result
    3604             :  * 'leftpath' is the source of data for the non-recursive term
    3605             :  * 'rightpath' is the source of data for the recursive term
    3606             :  * 'target' is the PathTarget to be computed
    3607             :  * 'distinctList' is a list of SortGroupClause's representing the grouping
    3608             :  * 'wtParam' is the ID of Param representing work table
    3609             :  * 'numGroups' is the estimated number of groups
    3610             :  *
    3611             :  * For recursive UNION ALL, distinctList is empty and numGroups is zero
    3612             :  */
    3613             : RecursiveUnionPath *
    3614         802 : create_recursiveunion_path(PlannerInfo *root,
    3615             :                            RelOptInfo *rel,
    3616             :                            Path *leftpath,
    3617             :                            Path *rightpath,
    3618             :                            PathTarget *target,
    3619             :                            List *distinctList,
    3620             :                            int wtParam,
    3621             :                            double numGroups)
    3622             : {
    3623         802 :     RecursiveUnionPath *pathnode = makeNode(RecursiveUnionPath);
    3624             : 
    3625         802 :     pathnode->path.pathtype = T_RecursiveUnion;
    3626         802 :     pathnode->path.parent = rel;
    3627         802 :     pathnode->path.pathtarget = target;
    3628             :     /* For now, assume we are above any joins, so no parameterization */
    3629         802 :     pathnode->path.param_info = NULL;
    3630         802 :     pathnode->path.parallel_aware = false;
    3631        1604 :     pathnode->path.parallel_safe = rel->consider_parallel &&
    3632         802 :         leftpath->parallel_safe && rightpath->parallel_safe;
    3633             :     /* Foolish, but we'll do it like joins for now: */
    3634         802 :     pathnode->path.parallel_workers = leftpath->parallel_workers;
    3635             :     /* RecursiveUnion result is always unsorted */
    3636         802 :     pathnode->path.pathkeys = NIL;
    3637             : 
    3638         802 :     pathnode->leftpath = leftpath;
    3639         802 :     pathnode->rightpath = rightpath;
    3640         802 :     pathnode->distinctList = distinctList;
    3641         802 :     pathnode->wtParam = wtParam;
    3642         802 :     pathnode->numGroups = numGroups;
    3643             : 
    3644         802 :     cost_recursive_union(&pathnode->path, leftpath, rightpath);
    3645             : 
    3646         802 :     return pathnode;
    3647             : }
    3648             : 
    3649             : /*
    3650             :  * create_lockrows_path
    3651             :  *    Creates a pathnode that represents acquiring row locks
    3652             :  *
    3653             :  * 'rel' is the parent relation associated with the result
    3654             :  * 'subpath' is the path representing the source of data
    3655             :  * 'rowMarks' is a list of PlanRowMark's
    3656             :  * 'epqParam' is the ID of Param for EvalPlanQual re-eval
    3657             :  */
    3658             : LockRowsPath *
    3659        7918 : create_lockrows_path(PlannerInfo *root, RelOptInfo *rel,
    3660             :                      Path *subpath, List *rowMarks, int epqParam)
    3661             : {
    3662        7918 :     LockRowsPath *pathnode = makeNode(LockRowsPath);
    3663             : 
    3664        7918 :     pathnode->path.pathtype = T_LockRows;
    3665        7918 :     pathnode->path.parent = rel;
    3666             :     /* LockRows doesn't project, so use source path's pathtarget */
    3667        7918 :     pathnode->path.pathtarget = subpath->pathtarget;
    3668             :     /* For now, assume we are above any joins, so no parameterization */
    3669        7918 :     pathnode->path.param_info = NULL;
    3670        7918 :     pathnode->path.parallel_aware = false;
    3671        7918 :     pathnode->path.parallel_safe = false;
    3672        7918 :     pathnode->path.parallel_workers = 0;
    3673        7918 :     pathnode->path.rows = subpath->rows;
    3674             : 
    3675             :     /*
    3676             :      * The result cannot be assumed sorted, since locking might cause the sort
    3677             :      * key columns to be replaced with new values.
    3678             :      */
    3679        7918 :     pathnode->path.pathkeys = NIL;
    3680             : 
    3681        7918 :     pathnode->subpath = subpath;
    3682        7918 :     pathnode->rowMarks = rowMarks;
    3683        7918 :     pathnode->epqParam = epqParam;
    3684             : 
    3685             :     /*
    3686             :      * We should charge something extra for the costs of row locking and
    3687             :      * possible refetches, but it's hard to say how much.  For now, use
    3688             :      * cpu_tuple_cost per row.
    3689             :      */
    3690        7918 :     pathnode->path.startup_cost = subpath->startup_cost;
    3691        7918 :     pathnode->path.total_cost = subpath->total_cost +
    3692        7918 :         cpu_tuple_cost * subpath->rows;
    3693             : 
    3694        7918 :     return pathnode;
    3695             : }
    3696             : 
    3697             : /*
    3698             :  * create_modifytable_path
    3699             :  *    Creates a pathnode that represents performing INSERT/UPDATE/DELETE/MERGE
    3700             :  *    mods
    3701             :  *
    3702             :  * 'rel' is the parent relation associated with the result
    3703             :  * 'subpath' is a Path producing source data
    3704             :  * 'operation' is the operation type
    3705             :  * 'canSetTag' is true if we set the command tag/es_processed
    3706             :  * 'nominalRelation' is the parent RT index for use of EXPLAIN
    3707             :  * 'rootRelation' is the partitioned/inherited table root RTI, or 0 if none
    3708             :  * 'partColsUpdated' is true if any partitioning columns are being updated,
    3709             :  *      either from the target relation or a descendent partitioned table.
    3710             :  * 'resultRelations' is an integer list of actual RT indexes of target rel(s)
    3711             :  * 'updateColnosLists' is a list of UPDATE target column number lists
    3712             :  *      (one sublist per rel); or NIL if not an UPDATE
    3713             :  * 'withCheckOptionLists' is a list of WCO lists (one per rel)
    3714             :  * 'returningLists' is a list of RETURNING tlists (one per rel)
    3715             :  * 'rowMarks' is a list of PlanRowMarks (non-locking only)
    3716             :  * 'onconflict' is the ON CONFLICT clause, or NULL
    3717             :  * 'epqParam' is the ID of Param for EvalPlanQual re-eval
    3718             :  * 'mergeActionLists' is a list of lists of MERGE actions (one per rel)
    3719             :  */
    3720             : ModifyTablePath *
    3721       88382 : create_modifytable_path(PlannerInfo *root, RelOptInfo *rel,
    3722             :                         Path *subpath,
    3723             :                         CmdType operation, bool canSetTag,
    3724             :                         Index nominalRelation, Index rootRelation,
    3725             :                         bool partColsUpdated,
    3726             :                         List *resultRelations,
    3727             :                         List *updateColnosLists,
    3728             :                         List *withCheckOptionLists, List *returningLists,
    3729             :                         List *rowMarks, OnConflictExpr *onconflict,
    3730             :                         List *mergeActionLists, int epqParam)
    3731             : {
    3732       88382 :     ModifyTablePath *pathnode = makeNode(ModifyTablePath);
    3733             : 
    3734             :     Assert(operation == CMD_MERGE ||
    3735             :            (operation == CMD_UPDATE ?
    3736             :             list_length(resultRelations) == list_length(updateColnosLists) :
    3737             :             updateColnosLists == NIL));
    3738             :     Assert(withCheckOptionLists == NIL ||
    3739             :            list_length(resultRelations) == list_length(withCheckOptionLists));
    3740             :     Assert(returningLists == NIL ||
    3741             :            list_length(resultRelations) == list_length(returningLists));
    3742             : 
    3743       88382 :     pathnode->path.pathtype = T_ModifyTable;
    3744       88382 :     pathnode->path.parent = rel;
    3745             :     /* pathtarget is not interesting, just make it minimally valid */
    3746       88382 :     pathnode->path.pathtarget = rel->reltarget;
    3747             :     /* For now, assume we are above any joins, so no parameterization */
    3748       88382 :     pathnode->path.param_info = NULL;
    3749       88382 :     pathnode->path.parallel_aware = false;
    3750       88382 :     pathnode->path.parallel_safe = false;
    3751       88382 :     pathnode->path.parallel_workers = 0;
    3752       88382 :     pathnode->path.pathkeys = NIL;
    3753             : 
    3754             :     /*
    3755             :      * Compute cost & rowcount as subpath cost & rowcount (if RETURNING)
    3756             :      *
    3757             :      * Currently, we don't charge anything extra for the actual table
    3758             :      * modification work, nor for the WITH CHECK OPTIONS or RETURNING
    3759             :      * expressions if any.  It would only be window dressing, since
    3760             :      * ModifyTable is always a top-level node and there is no way for the
    3761             :      * costs to change any higher-level planning choices.  But we might want
    3762             :      * to make it look better sometime.
    3763             :      */
    3764       88382 :     pathnode->path.startup_cost = subpath->startup_cost;
    3765       88382 :     pathnode->path.total_cost = subpath->total_cost;
    3766       88382 :     if (returningLists != NIL)
    3767             :     {
    3768        2386 :         pathnode->path.rows = subpath->rows;
    3769             : 
    3770             :         /*
    3771             :          * Set width to match the subpath output.  XXX this is totally wrong:
    3772             :          * we should return an average of the RETURNING tlist widths.  But
    3773             :          * it's what happened historically, and improving it is a task for
    3774             :          * another day.  (Again, it's mostly window dressing.)
    3775             :          */
    3776        2386 :         pathnode->path.pathtarget->width = subpath->pathtarget->width;
    3777             :     }
    3778             :     else
    3779             :     {
    3780       85996 :         pathnode->path.rows = 0;
    3781       85996 :         pathnode->path.pathtarget->width = 0;
    3782             :     }
    3783             : 
    3784       88382 :     pathnode->subpath = subpath;
    3785       88382 :     pathnode->operation = operation;
    3786       88382 :     pathnode->canSetTag = canSetTag;
    3787       88382 :     pathnode->nominalRelation = nominalRelation;
    3788       88382 :     pathnode->rootRelation = rootRelation;
    3789       88382 :     pathnode->partColsUpdated = partColsUpdated;
    3790       88382 :     pathnode->resultRelations = resultRelations;
    3791       88382 :     pathnode->updateColnosLists = updateColnosLists;
    3792       88382 :     pathnode->withCheckOptionLists = withCheckOptionLists;
    3793       88382 :     pathnode->returningLists = returningLists;
    3794       88382 :     pathnode->rowMarks = rowMarks;
    3795       88382 :     pathnode->onconflict = onconflict;
    3796       88382 :     pathnode->epqParam = epqParam;
    3797       88382 :     pathnode->mergeActionLists = mergeActionLists;
    3798             : 
    3799       88382 :     return pathnode;
    3800             : }
    3801             : 
    3802             : /*
    3803             :  * create_limit_path
    3804             :  *    Creates a pathnode that represents performing LIMIT/OFFSET
    3805             :  *
    3806             :  * In addition to providing the actual OFFSET and LIMIT expressions,
    3807             :  * the caller must provide estimates of their values for costing purposes.
    3808             :  * The estimates are as computed by preprocess_limit(), ie, 0 represents
    3809             :  * the clause not being present, and -1 means it's present but we could
    3810             :  * not estimate its value.
    3811             :  *
    3812             :  * 'rel' is the parent relation associated with the result
    3813             :  * 'subpath' is the path representing the source of data
    3814             :  * 'limitOffset' is the actual OFFSET expression, or NULL
    3815             :  * 'limitCount' is the actual LIMIT expression, or NULL
    3816             :  * 'offset_est' is the estimated value of the OFFSET expression
    3817             :  * 'count_est' is the estimated value of the LIMIT expression
    3818             :  */
    3819             : LimitPath *
    3820        5592 : create_limit_path(PlannerInfo *root, RelOptInfo *rel,
    3821             :                   Path *subpath,
    3822             :                   Node *limitOffset, Node *limitCount,
    3823             :                   LimitOption limitOption,
    3824             :                   int64 offset_est, int64 count_est)
    3825             : {
    3826        5592 :     LimitPath  *pathnode = makeNode(LimitPath);
    3827             : 
    3828        5592 :     pathnode->path.pathtype = T_Limit;
    3829        5592 :     pathnode->path.parent = rel;
    3830             :     /* Limit doesn't project, so use source path's pathtarget */
    3831        5592 :     pathnode->path.pathtarget = subpath->pathtarget;
    3832             :     /* For now, assume we are above any joins, so no parameterization */
    3833        5592 :     pathnode->path.param_info = NULL;
    3834        5592 :     pathnode->path.parallel_aware = false;
    3835        7824 :     pathnode->path.parallel_safe = rel->consider_parallel &&
    3836        2232 :         subpath->parallel_safe;
    3837        5592 :     pathnode->path.parallel_workers = subpath->parallel_workers;
    3838        5592 :     pathnode->path.rows = subpath->rows;
    3839        5592 :     pathnode->path.startup_cost = subpath->startup_cost;
    3840        5592 :     pathnode->path.total_cost = subpath->total_cost;
    3841        5592 :     pathnode->path.pathkeys = subpath->pathkeys;
    3842        5592 :     pathnode->subpath = subpath;
    3843        5592 :     pathnode->limitOffset = limitOffset;
    3844        5592 :     pathnode->limitCount = limitCount;
    3845        5592 :     pathnode->limitOption = limitOption;
    3846             : 
    3847             :     /*
    3848             :      * Adjust the output rows count and costs according to the offset/limit.
    3849             :      */
    3850        5592 :     adjust_limit_rows_costs(&pathnode->path.rows,
    3851             :                             &pathnode->path.startup_cost,
    3852             :                             &pathnode->path.total_cost,
    3853             :                             offset_est, count_est);
    3854             : 
    3855        5592 :     return pathnode;
    3856             : }
    3857             : 
    3858             : /*
    3859             :  * adjust_limit_rows_costs
    3860             :  *    Adjust the size and cost estimates for a LimitPath node according to the
    3861             :  *    offset/limit.
    3862             :  *
    3863             :  * This is only a cosmetic issue if we are at top level, but if we are
    3864             :  * building a subquery then it's important to report correct info to the outer
    3865             :  * planner.
    3866             :  *
    3867             :  * When the offset or count couldn't be estimated, use 10% of the estimated
    3868             :  * number of rows emitted from the subpath.
    3869             :  *
    3870             :  * XXX we don't bother to add eval costs of the offset/limit expressions
    3871             :  * themselves to the path costs.  In theory we should, but in most cases those
    3872             :  * expressions are trivial and it's just not worth the trouble.
    3873             :  */
    3874             : void
    3875        5774 : adjust_limit_rows_costs(double *rows,   /* in/out parameter */
    3876             :                         Cost *startup_cost, /* in/out parameter */
    3877             :                         Cost *total_cost,   /* in/out parameter */
    3878             :                         int64 offset_est,
    3879             :                         int64 count_est)
    3880             : {
    3881        5774 :     double      input_rows = *rows;
    3882        5774 :     Cost        input_startup_cost = *startup_cost;
    3883        5774 :     Cost        input_total_cost = *total_cost;
    3884             : 
    3885        5774 :     if (offset_est != 0)
    3886             :     {
    3887             :         double      offset_rows;
    3888             : 
    3889         672 :         if (offset_est > 0)
    3890         648 :             offset_rows = (double) offset_est;
    3891             :         else
    3892          24 :             offset_rows = clamp_row_est(input_rows * 0.10);
    3893         672 :         if (offset_rows > *rows)
    3894          26 :             offset_rows = *rows;
    3895         672 :         if (input_rows > 0)
    3896         672 :             *startup_cost +=
    3897         672 :                 (input_total_cost - input_startup_cost)
    3898         672 :                 * offset_rows / input_rows;
    3899         672 :         *rows -= offset_rows;
    3900         672 :         if (*rows < 1)
    3901          26 :             *rows = 1;
    3902             :     }
    3903             : 
    3904        5774 :     if (count_est != 0)
    3905             :     {
    3906             :         double      count_rows;
    3907             : 
    3908        5726 :         if (count_est > 0)
    3909        5720 :             count_rows = (double) count_est;
    3910             :         else
    3911           6 :             count_rows = clamp_row_est(input_rows * 0.10);
    3912        5726 :         if (count_rows > *rows)
    3913         236 :             count_rows = *rows;
    3914        5726 :         if (input_rows > 0)
    3915        5726 :             *total_cost = *startup_cost +
    3916        5726 :                 (input_total_cost - input_startup_cost)
    3917        5726 :                 * count_rows / input_rows;
    3918        5726 :         *rows = count_rows;
    3919        5726 :         if (*rows < 1)
    3920           0 :             *rows = 1;
    3921             :     }
    3922        5774 : }
    3923             : 
    3924             : 
    3925             : /*
    3926             :  * reparameterize_path
    3927             :  *      Attempt to modify a Path to have greater parameterization
    3928             :  *
    3929             :  * We use this to attempt to bring all child paths of an appendrel to the
    3930             :  * same parameterization level, ensuring that they all enforce the same set
    3931             :  * of join quals (and thus that that parameterization can be attributed to
    3932             :  * an append path built from such paths).  Currently, only a few path types
    3933             :  * are supported here, though more could be added at need.  We return NULL
    3934             :  * if we can't reparameterize the given path.
    3935             :  *
    3936             :  * Note: we intentionally do not pass created paths to add_path(); it would
    3937             :  * possibly try to delete them on the grounds of being cost-inferior to the
    3938             :  * paths they were made from, and we don't want that.  Paths made here are
    3939             :  * not necessarily of general-purpose usefulness, but they can be useful
    3940             :  * as members of an append path.
    3941             :  */
    3942             : Path *
    3943         308 : reparameterize_path(PlannerInfo *root, Path *path,
    3944             :                     Relids required_outer,
    3945             :                     double loop_count)
    3946             : {
    3947         308 :     RelOptInfo *rel = path->parent;
    3948             : 
    3949             :     /* Can only increase, not decrease, path's parameterization */
    3950         308 :     if (!bms_is_subset(PATH_REQ_OUTER(path), required_outer))
    3951           0 :         return NULL;
    3952         308 :     switch (path->pathtype)
    3953             :     {
    3954         228 :         case T_SeqScan:
    3955         228 :             return create_seqscan_path(root, rel, required_outer, 0);
    3956           0 :         case T_SampleScan:
    3957           0 :             return (Path *) create_samplescan_path(root, rel, required_outer);
    3958           0 :         case T_IndexScan:
    3959             :         case T_IndexOnlyScan:
    3960             :             {
    3961           0 :                 IndexPath  *ipath = (IndexPath *) path;
    3962           0 :                 IndexPath  *newpath = makeNode(IndexPath);
    3963             : 
    3964             :                 /*
    3965             :                  * We can't use create_index_path directly, and would not want
    3966             :                  * to because it would re-compute the indexqual conditions
    3967             :                  * which is wasted effort.  Instead we hack things a bit:
    3968             :                  * flat-copy the path node, revise its param_info, and redo
    3969             :                  * the cost estimate.
    3970             :                  */
    3971           0 :                 memcpy(newpath, ipath, sizeof(IndexPath));
    3972           0 :                 newpath->path.param_info =
    3973           0 :                     get_baserel_parampathinfo(root, rel, required_outer);
    3974           0 :                 cost_index(newpath, root, loop_count, false);
    3975           0 :                 return (Path *) newpath;
    3976             :             }
    3977           0 :         case T_BitmapHeapScan:
    3978             :             {
    3979           0 :                 BitmapHeapPath *bpath = (BitmapHeapPath *) path;
    3980             : 
    3981           0 :                 return (Path *) create_bitmap_heap_path(root,
    3982             :                                                         rel,
    3983             :                                                         bpath->bitmapqual,
    3984             :                                                         required_outer,
    3985             :                                                         loop_count, 0);
    3986             :             }
    3987           0 :         case T_SubqueryScan:
    3988             :             {
    3989           0 :                 SubqueryScanPath *spath = (SubqueryScanPath *) path;
    3990           0 :                 Path       *subpath = spath->subpath;
    3991             :                 bool        trivial_pathtarget;
    3992             : 
    3993             :                 /*
    3994             :                  * If existing node has zero extra cost, we must have decided
    3995             :                  * its target is trivial.  (The converse is not true, because
    3996             :                  * it might have a trivial target but quals to enforce; but in
    3997             :                  * that case the new node will too, so it doesn't matter
    3998             :                  * whether we get the right answer here.)
    3999             :                  */
    4000           0 :                 trivial_pathtarget =
    4001           0 :                     (subpath->total_cost == spath->path.total_cost);
    4002             : 
    4003           0 :                 return (Path *) create_subqueryscan_path(root,
    4004             :                                                          rel,
    4005             :                                                          subpath,
    4006             :                                                          trivial_pathtarget,
    4007             :                                                          spath->path.pathkeys,
    4008             :                                                          required_outer);
    4009             :             }
    4010          48 :         case T_Result:
    4011             :             /* Supported only for RTE_RESULT scan paths */
    4012          48 :             if (IsA(path, Path))
    4013          48 :                 return create_resultscan_path(root, rel, required_outer);
    4014           0 :             break;
    4015           0 :         case T_Append:
    4016             :             {
    4017           0 :                 AppendPath *apath = (AppendPath *) path;
    4018           0 :                 List       *childpaths = NIL;
    4019           0 :                 List       *partialpaths = NIL;
    4020             :                 int         i;
    4021             :                 ListCell   *lc;
    4022             : 
    4023             :                 /* Reparameterize the children */
    4024           0 :                 i = 0;
    4025           0 :                 foreach(lc, apath->subpaths)
    4026             :                 {
    4027           0 :                     Path       *spath = (Path *) lfirst(lc);
    4028             : 
    4029           0 :                     spath = reparameterize_path(root, spath,
    4030             :                                                 required_outer,
    4031             :                                                 loop_count);
    4032           0 :                     if (spath == NULL)
    4033           0 :                         return NULL;
    4034             :                     /* We have to re-split the regular and partial paths */
    4035           0 :                     if (i < apath->first_partial_path)
    4036           0 :                         childpaths = lappend(childpaths, spath);
    4037             :                     else
    4038           0 :                         partialpaths = lappend(partialpaths, spath);
    4039           0 :                     i++;
    4040             :                 }
    4041           0 :                 return (Path *)
    4042           0 :                     create_append_path(root, rel, childpaths, partialpaths,
    4043             :                                        apath->path.pathkeys, required_outer,
    4044             :                                        apath->path.parallel_workers,
    4045           0 :                                        apath->path.parallel_aware,
    4046             :                                        -1);
    4047             :             }
    4048           0 :         case T_Material:
    4049             :             {
    4050           0 :                 MaterialPath *mpath = (MaterialPath *) path;
    4051           0 :                 Path       *spath = mpath->subpath;
    4052             : 
    4053           0 :                 spath = reparameterize_path(root, spath,
    4054             :                                             required_outer,
    4055             :                                             loop_count);
    4056           0 :                 if (spath == NULL)
    4057           0 :                     return NULL;
    4058           0 :                 return (Path *) create_material_path(rel, spath);
    4059             :             }
    4060           0 :         case T_Memoize:
    4061             :             {
    4062           0 :                 MemoizePath *mpath = (MemoizePath *) path;
    4063           0 :                 Path       *spath = mpath->subpath;
    4064             : 
    4065           0 :                 spath = reparameterize_path(root, spath,
    4066             :                                             required_outer,
    4067             :                                             loop_count);
    4068           0 :                 if (spath == NULL)
    4069           0 :                     return NULL;
    4070           0 :                 return (Path *) create_memoize_path(root, rel,
    4071             :                                                     spath,
    4072             :                                                     mpath->param_exprs,
    4073             :                                                     mpath->hash_operators,
    4074           0 :                                                     mpath->singlerow,
    4075           0 :                                                     mpath->binary_mode,
    4076             :                                                     mpath->calls);
    4077             :             }
    4078          32 :         default:
    4079          32 :             break;
    4080             :     }
    4081          32 :     return NULL;
    4082             : }
    4083             : 
    4084             : /*
    4085             :  * reparameterize_path_by_child
    4086             :  *      Given a path parameterized by the parent of the given child relation,
    4087             :  *      translate the path to be parameterized by the given child relation.
    4088             :  *
    4089             :  * Most fields in the path are not changed, but any expressions must be
    4090             :  * adjusted to refer to the correct varnos, and any subpaths must be
    4091             :  * recursively reparameterized.  Other fields that refer to specific relids
    4092             :  * also need adjustment.
    4093             :  *
    4094             :  * The cost, number of rows, width and parallel path properties depend upon
    4095             :  * path->parent, which does not change during the translation.  So we need
    4096             :  * not change those.
    4097             :  *
    4098             :  * Currently, only a few path types are supported here, though more could be
    4099             :  * added at need.  We return NULL if we can't reparameterize the given path.
    4100             :  *
    4101             :  * Note that this function can change referenced RangeTblEntries, RelOptInfos
    4102             :  * and IndexOptInfos as well as the Path structures.  Therefore, it's only safe
    4103             :  * to call during create_plan(), when we have made a final choice of which Path
    4104             :  * to use for each RangeTblEntry/RelOptInfo/IndexOptInfo.
    4105             :  *
    4106             :  * Keep this code in sync with path_is_reparameterizable_by_child()!
    4107             :  */
    4108             : Path *
    4109       80270 : reparameterize_path_by_child(PlannerInfo *root, Path *path,
    4110             :                              RelOptInfo *child_rel)
    4111             : {
    4112             :     Path       *new_path;
    4113             :     ParamPathInfo *new_ppi;
    4114             :     ParamPathInfo *old_ppi;
    4115             :     Relids      required_outer;
    4116             : 
    4117             : #define ADJUST_CHILD_ATTRS(node) \
    4118             :     ((node) = (void *) adjust_appendrel_attrs_multilevel(root, \
    4119             :                                                          (Node *) (node), \
    4120             :                                                          child_rel, \
    4121             :                                                          child_rel->top_parent))
    4122             : 
    4123             : #define REPARAMETERIZE_CHILD_PATH(path) \
    4124             : do { \
    4125             :     (path) = reparameterize_path_by_child(root, (path), child_rel); \
    4126             :     if ((path) == NULL) \
    4127             :         return NULL; \
    4128             : } while(0)
    4129             : 
    4130             : #define REPARAMETERIZE_CHILD_PATH_LIST(pathlist) \
    4131             : do { \
    4132             :     if ((pathlist) != NIL) \
    4133             :     { \
    4134             :         (pathlist) = reparameterize_pathlist_by_child(root, (pathlist), \
    4135             :                                                       child_rel); \
    4136             :         if ((pathlist) == NIL) \
    4137             :             return NULL; \
    4138             :     } \
    4139             : } while(0)
    4140             : 
    4141             :     /*
    4142             :      * If the path is not parameterized by the parent of the given relation,
    4143             :      * it doesn't need reparameterization.
    4144             :      */
    4145       80270 :     if (!path->param_info ||
    4146       42680 :         !bms_overlap(PATH_REQ_OUTER(path), child_rel->top_parent_relids))
    4147       79382 :         return path;
    4148             : 
    4149             :     /*
    4150             :      * If possible, reparameterize the given path.
    4151             :      *
    4152             :      * This function is currently only applied to the inner side of a nestloop
    4153             :      * join that is being partitioned by the partitionwise-join code.  Hence,
    4154             :      * we need only support path types that plausibly arise in that context.
    4155             :      * (In particular, supporting sorted path types would be a waste of code
    4156             :      * and cycles: even if we translated them here, they'd just lose in
    4157             :      * subsequent cost comparisons.)  If we do see an unsupported path type,
    4158             :      * that just means we won't be able to generate a partitionwise-join plan
    4159             :      * using that path type.
    4160             :      */
    4161         888 :     switch (nodeTag(path))
    4162             :     {
    4163         228 :         case T_Path:
    4164         228 :             new_path = path;
    4165         228 :             ADJUST_CHILD_ATTRS(new_path->parent->baserestrictinfo);
    4166         228 :             if (path->pathtype == T_SampleScan)
    4167             :             {
    4168          48 :                 Index       scan_relid = path->parent->relid;
    4169             :                 RangeTblEntry *rte;
    4170             : 
    4171             :                 /* it should be a base rel with a tablesample clause... */
    4172             :                 Assert(scan_relid > 0);
    4173          48 :                 rte = planner_rt_fetch(scan_relid, root);
    4174             :                 Assert(rte->rtekind == RTE_RELATION);
    4175             :                 Assert(rte->tablesample != NULL);
    4176             : 
    4177          48 :                 ADJUST_CHILD_ATTRS(rte->tablesample);
    4178             :             }
    4179         228 :             break;
    4180             : 
    4181         444 :         case T_IndexPath:
    4182             :             {
    4183         444 :                 IndexPath  *ipath = (IndexPath *) path;
    4184             : 
    4185         444 :                 ADJUST_CHILD_ATTRS(ipath->indexinfo->indrestrictinfo);
    4186         444 :                 ADJUST_CHILD_ATTRS(ipath->indexclauses);
    4187         444 :                 new_path = (Path *) ipath;
    4188             :             }
    4189         444 :             break;
    4190             : 
    4191          48 :         case T_BitmapHeapPath:
    4192             :             {
    4193          48 :                 BitmapHeapPath *bhpath = (BitmapHeapPath *) path;
    4194             : 
    4195          48 :                 ADJUST_CHILD_ATTRS(bhpath->path.parent->baserestrictinfo);
    4196          48 :                 REPARAMETERIZE_CHILD_PATH(bhpath->bitmapqual);
    4197          48 :                 new_path = (Path *) bhpath;
    4198             :             }
    4199          48 :             break;
    4200             : 
    4201          24 :         case T_BitmapAndPath:
    4202             :             {
    4203          24 :                 BitmapAndPath *bapath = (BitmapAndPath *) path;
    4204             : 
    4205          24 :                 REPARAMETERIZE_CHILD_PATH_LIST(bapath->bitmapquals);
    4206          24 :                 new_path = (Path *) bapath;
    4207             :             }
    4208          24 :             break;
    4209             : 
    4210          24 :         case T_BitmapOrPath:
    4211             :             {
    4212          24 :                 BitmapOrPath *bopath = (BitmapOrPath *) path;
    4213             : 
    4214          24 :                 REPARAMETERIZE_CHILD_PATH_LIST(bopath->bitmapquals);
    4215          24 :                 new_path = (Path *) bopath;
    4216             :             }
    4217          24 :             break;
    4218             : 
    4219           0 :         case T_ForeignPath:
    4220             :             {
    4221           0 :                 ForeignPath *fpath = (ForeignPath *) path;
    4222             :                 ReparameterizeForeignPathByChild_function rfpc_func;
    4223             : 
    4224           0 :                 ADJUST_CHILD_ATTRS(fpath->path.parent->baserestrictinfo);
    4225           0 :                 if (fpath->fdw_outerpath)
    4226           0 :                     REPARAMETERIZE_CHILD_PATH(fpath->fdw_outerpath);
    4227           0 :                 if (fpath->fdw_restrictinfo)
    4228           0 :                     ADJUST_CHILD_ATTRS(fpath->fdw_restrictinfo);
    4229             : 
    4230             :                 /* Hand over to FDW if needed. */
    4231           0 :                 rfpc_func =
    4232           0 :                     path->parent->fdwroutine->ReparameterizeForeignPathByChild;
    4233           0 :                 if (rfpc_func)
    4234           0 :                     fpath->fdw_private = rfpc_func(root, fpath->fdw_private,
    4235             :                                                    child_rel);
    4236           0 :                 new_path = (Path *) fpath;
    4237             :             }
    4238           0 :             break;
    4239             : 
    4240           0 :         case T_CustomPath:
    4241             :             {
    4242           0 :                 CustomPath *cpath = (CustomPath *) path;
    4243             : 
    4244           0 :                 ADJUST_CHILD_ATTRS(cpath->path.parent->baserestrictinfo);
    4245           0 :                 REPARAMETERIZE_CHILD_PATH_LIST(cpath->custom_paths);
    4246           0 :                 if (cpath->custom_restrictinfo)
    4247           0 :                     ADJUST_CHILD_ATTRS(cpath->custom_restrictinfo);
    4248           0 :                 if (cpath->methods &&
    4249           0 :                     cpath->methods->ReparameterizeCustomPathByChild)
    4250           0 :                     cpath->custom_private =
    4251           0 :                         cpath->methods->ReparameterizeCustomPathByChild(root,
    4252             :                                                                         cpath->custom_private,
    4253             :                                                                         child_rel);
    4254           0 :                 new_path = (Path *) cpath;
    4255             :             }
    4256           0 :             break;
    4257             : 
    4258          36 :         case T_NestPath:
    4259             :             {
    4260          36 :                 NestPath   *npath = (NestPath *) path;
    4261          36 :                 JoinPath   *jpath = (JoinPath *) npath;
    4262             : 
    4263          36 :                 REPARAMETERIZE_CHILD_PATH(jpath->outerjoinpath);
    4264          36 :                 REPARAMETERIZE_CHILD_PATH(jpath->innerjoinpath);
    4265          36 :                 ADJUST_CHILD_ATTRS(jpath->joinrestrictinfo);
    4266          36 :                 new_path = (Path *) npath;
    4267             :             }
    4268          36 :             break;
    4269             : 
    4270           0 :         case T_MergePath:
    4271             :             {
    4272           0 :                 MergePath  *mpath = (MergePath *) path;
    4273           0 :                 JoinPath   *jpath = (JoinPath *) mpath;
    4274             : 
    4275           0 :                 REPARAMETERIZE_CHILD_PATH(jpath->outerjoinpath);
    4276           0 :                 REPARAMETERIZE_CHILD_PATH(jpath->innerjoinpath);
    4277           0 :                 ADJUST_CHILD_ATTRS(jpath->joinrestrictinfo);
    4278           0 :                 ADJUST_CHILD_ATTRS(mpath->path_mergeclauses);
    4279           0 :                 new_path = (Path *) mpath;
    4280             :             }
    4281           0 :             break;
    4282             : 
    4283          48 :         case T_HashPath:
    4284             :             {
    4285          48 :                 HashPath   *hpath = (HashPath *) path;
    4286          48 :                 JoinPath   *jpath = (JoinPath *) hpath;
    4287             : 
    4288          48 :                 REPARAMETERIZE_CHILD_PATH(jpath->outerjoinpath);
    4289          48 :                 REPARAMETERIZE_CHILD_PATH(jpath->innerjoinpath);
    4290          48 :                 ADJUST_CHILD_ATTRS(jpath->joinrestrictinfo);
    4291          48 :                 ADJUST_CHILD_ATTRS(hpath->path_hashclauses);
    4292          48 :                 new_path = (Path *) hpath;
    4293             :             }
    4294          48 :             break;
    4295             : 
    4296          24 :         case T_AppendPath:
    4297             :             {
    4298          24 :                 AppendPath *apath = (AppendPath *) path;
    4299             : 
    4300          24 :                 REPARAMETERIZE_CHILD_PATH_LIST(apath->subpaths);
    4301          24 :                 new_path = (Path *) apath;
    4302             :             }
    4303          24 :             break;
    4304             : 
    4305           0 :         case T_MaterialPath:
    4306             :             {
    4307           0 :                 MaterialPath *mpath = (MaterialPath *) path;
    4308             : 
    4309           0 :                 REPARAMETERIZE_CHILD_PATH(mpath->subpath);
    4310           0 :                 new_path = (Path *) mpath;
    4311             :             }
    4312           0 :             break;
    4313             : 
    4314          12 :         case T_MemoizePath:
    4315             :             {
    4316          12 :                 MemoizePath *mpath = (MemoizePath *) path;
    4317             : 
    4318          12 :                 REPARAMETERIZE_CHILD_PATH(mpath->subpath);
    4319          12 :                 ADJUST_CHILD_ATTRS(mpath->param_exprs);
    4320          12 :                 new_path = (Path *) mpath;
    4321             :             }
    4322          12 :             break;
    4323             : 
    4324           0 :         case T_GatherPath:
    4325             :             {
    4326           0 :                 GatherPath *gpath = (GatherPath *) path;
    4327             : 
    4328           0 :                 REPARAMETERIZE_CHILD_PATH(gpath->subpath);
    4329           0 :                 new_path = (Path *) gpath;
    4330             :             }
    4331           0 :             break;
    4332             : 
    4333           0 :         default:
    4334             :             /* We don't know how to reparameterize this path. */
    4335           0 :             return NULL;
    4336             :     }
    4337             : 
    4338             :     /*
    4339             :      * Adjust the parameterization information, which refers to the topmost
    4340             :      * parent. The topmost parent can be multiple levels away from the given
    4341             :      * child, hence use multi-level expression adjustment routines.
    4342             :      */
    4343         888 :     old_ppi = new_path->param_info;
    4344             :     required_outer =
    4345         888 :         adjust_child_relids_multilevel(root, old_ppi->ppi_req_outer,
    4346             :                                        child_rel,
    4347         888 :                                        child_rel->top_parent);
    4348             : 
    4349             :     /* If we already have a PPI for this parameterization, just return it */
    4350         888 :     new_ppi = find_param_path_info(new_path->parent, required_outer);
    4351             : 
    4352             :     /*
    4353             :      * If not, build a new one and link it to the list of PPIs. For the same
    4354             :      * reason as explained in mark_dummy_rel(), allocate new PPI in the same
    4355             :      * context the given RelOptInfo is in.
    4356             :      */
    4357         888 :     if (new_ppi == NULL)
    4358             :     {
    4359             :         MemoryContext oldcontext;
    4360         780 :         RelOptInfo *rel = path->parent;
    4361             : 
    4362         780 :         oldcontext = MemoryContextSwitchTo(GetMemoryChunkContext(rel));
    4363             : 
    4364         780 :         new_ppi = makeNode(ParamPathInfo);
    4365         780 :         new_ppi->ppi_req_outer = bms_copy(required_outer);
    4366         780 :         new_ppi->ppi_rows = old_ppi->ppi_rows;
    4367         780 :         new_ppi->ppi_clauses = old_ppi->ppi_clauses;
    4368         780 :         ADJUST_CHILD_ATTRS(new_ppi->ppi_clauses);
    4369         780 :         new_ppi->ppi_serials = bms_copy(old_ppi->ppi_serials);
    4370         780 :         rel->ppilist = lappend(rel->ppilist, new_ppi);
    4371             : 
    4372         780 :         MemoryContextSwitchTo(oldcontext);
    4373             :     }
    4374         888 :     bms_free(required_outer);
    4375             : 
    4376         888 :     new_path->param_info = new_ppi;
    4377             : 
    4378             :     /*
    4379             :      * Adjust the path target if the parent of the outer relation is
    4380             :      * referenced in the targetlist. This can happen when only the parent of
    4381             :      * outer relation is laterally referenced in this relation.
    4382             :      */
    4383         888 :     if (bms_overlap(path->parent->lateral_relids,
    4384         888 :                     child_rel->top_parent_relids))
    4385             :     {
    4386         480 :         new_path->pathtarget = copy_pathtarget(new_path->pathtarget);
    4387         480 :         ADJUST_CHILD_ATTRS(new_path->pathtarget->exprs);
    4388             :     }
    4389             : 
    4390         888 :     return new_path;
    4391             : }
    4392             : 
    4393             : /*
    4394             :  * path_is_reparameterizable_by_child
    4395             :  *      Given a path parameterized by the parent of the given child relation,
    4396             :  *      see if it can be translated to be parameterized by the child relation.
    4397             :  *
    4398             :  * This must return true if and only if reparameterize_path_by_child()
    4399             :  * would succeed on this path.  Currently it's sufficient to verify that
    4400             :  * the path and all of its subpaths (if any) are of the types handled by
    4401             :  * that function.  However, subpaths that are not parameterized can be
    4402             :  * disregarded since they won't require translation.
    4403             :  */
    4404             : bool
    4405       31188 : path_is_reparameterizable_by_child(Path *path, RelOptInfo *child_rel)
    4406             : {
    4407             : #define REJECT_IF_PATH_NOT_REPARAMETERIZABLE(path) \
    4408             : do { \
    4409             :     if (!path_is_reparameterizable_by_child(path, child_rel)) \
    4410             :         return false; \
    4411             : } while(0)
    4412             : 
    4413             : #define REJECT_IF_PATH_LIST_NOT_REPARAMETERIZABLE(pathlist) \
    4414             : do { \
    4415             :     if (!pathlist_is_reparameterizable_by_child(pathlist, child_rel)) \
    4416             :         return false; \
    4417             : } while(0)
    4418             : 
    4419             :     /*
    4420             :      * If the path is not parameterized by the parent of the given relation,
    4421             :      * it doesn't need reparameterization.
    4422             :      */
    4423       31188 :     if (!path->param_info ||
    4424       30852 :         !bms_overlap(PATH_REQ_OUTER(path), child_rel->top_parent_relids))
    4425         912 :         return true;
    4426             : 
    4427             :     /*
    4428             :      * Check that the path type is one that reparameterize_path_by_child() can
    4429             :      * handle, and recursively check subpaths.
    4430             :      */
    4431       30276 :     switch (nodeTag(path))
    4432             :     {
    4433       20208 :         case T_Path:
    4434             :         case T_IndexPath:
    4435       20208 :             break;
    4436             : 
    4437          48 :         case T_BitmapHeapPath:
    4438             :             {
    4439          48 :                 BitmapHeapPath *bhpath = (BitmapHeapPath *) path;
    4440             : 
    4441          48 :                 REJECT_IF_PATH_NOT_REPARAMETERIZABLE(bhpath->bitmapqual);
    4442             :             }
    4443          48 :             break;
    4444             : 
    4445          24 :         case T_BitmapAndPath:
    4446             :             {
    4447          24 :                 BitmapAndPath *bapath = (BitmapAndPath *) path;
    4448             : 
    4449          24 :                 REJECT_IF_PATH_LIST_NOT_REPARAMETERIZABLE(bapath->bitmapquals);
    4450             :             }
    4451          24 :             break;
    4452             : 
    4453          24 :         case T_BitmapOrPath:
    4454             :             {
    4455          24 :                 BitmapOrPath *bopath = (BitmapOrPath *) path;
    4456             : 
    4457          24 :                 REJECT_IF_PATH_LIST_NOT_REPARAMETERIZABLE(bopath->bitmapquals);
    4458             :             }
    4459          24 :             break;
    4460             : 
    4461         148 :         case T_ForeignPath:
    4462             :             {
    4463         148 :                 ForeignPath *fpath = (ForeignPath *) path;
    4464             : 
    4465         148 :                 if (fpath->fdw_outerpath)
    4466           0 :                     REJECT_IF_PATH_NOT_REPARAMETERIZABLE(fpath->fdw_outerpath);
    4467             :             }
    4468         148 :             break;
    4469             : 
    4470           0 :         case T_CustomPath:
    4471             :             {
    4472           0 :                 CustomPath *cpath = (CustomPath *) path;
    4473             : 
    4474           0 :                 REJECT_IF_PATH_LIST_NOT_REPARAMETERIZABLE(cpath->custom_paths);
    4475             :             }
    4476           0 :             break;
    4477             : 
    4478        1176 :         case T_NestPath:
    4479             :         case T_MergePath:
    4480             :         case T_HashPath:
    4481             :             {
    4482        1176 :                 JoinPath   *jpath = (JoinPath *) path;
    4483             : 
    4484        1176 :                 REJECT_IF_PATH_NOT_REPARAMETERIZABLE(jpath->outerjoinpath);
    4485        1176 :                 REJECT_IF_PATH_NOT_REPARAMETERIZABLE(jpath->innerjoinpath);
    4486             :             }
    4487        1176 :             break;
    4488             : 
    4489         192 :         case T_AppendPath:
    4490             :             {
    4491         192 :                 AppendPath *apath = (AppendPath *) path;
    4492             : 
    4493         192 :                 REJECT_IF_PATH_LIST_NOT_REPARAMETERIZABLE(apath->subpaths);
    4494             :             }
    4495         192 :             break;
    4496             : 
    4497           0 :         case T_MaterialPath:
    4498             :             {
    4499           0 :                 MaterialPath *mpath = (MaterialPath *) path;
    4500             : 
    4501           0 :                 REJECT_IF_PATH_NOT_REPARAMETERIZABLE(mpath->subpath);
    4502             :             }
    4503           0 :             break;
    4504             : 
    4505        8456 :         case T_MemoizePath:
    4506             :             {
    4507        8456 :                 MemoizePath *mpath = (MemoizePath *) path;
    4508             : 
    4509        8456 :                 REJECT_IF_PATH_NOT_REPARAMETERIZABLE(mpath->subpath);
    4510             :             }
    4511        8456 :             break;
    4512             : 
    4513           0 :         case T_GatherPath:
    4514             :             {
    4515           0 :                 GatherPath *gpath = (GatherPath *) path;
    4516             : 
    4517           0 :                 REJECT_IF_PATH_NOT_REPARAMETERIZABLE(gpath->subpath);
    4518             :             }
    4519           0 :             break;
    4520             : 
    4521           0 :         default:
    4522             :             /* We don't know how to reparameterize this path. */
    4523           0 :             return false;
    4524             :     }
    4525             : 
    4526       30276 :     return true;
    4527             : }
    4528             : 
    4529             : /*
    4530             :  * reparameterize_pathlist_by_child
    4531             :  *      Helper function to reparameterize a list of paths by given child rel.
    4532             :  *
    4533             :  * Returns NIL to indicate failure, so pathlist had better not be NIL.
    4534             :  */
    4535             : static List *
    4536          72 : reparameterize_pathlist_by_child(PlannerInfo *root,
    4537             :                                  List *pathlist,
    4538             :                                  RelOptInfo *child_rel)
    4539             : {
    4540             :     ListCell   *lc;
    4541          72 :     List       *result = NIL;
    4542             : 
    4543         216 :     foreach(lc, pathlist)
    4544             :     {
    4545         144 :         Path       *path = reparameterize_path_by_child(root, lfirst(lc),
    4546             :                                                         child_rel);
    4547             : 
    4548         144 :         if (path == NULL)
    4549             :         {
    4550           0 :             list_free(result);
    4551           0 :             return NIL;
    4552             :         }
    4553             : 
    4554         144 :         result = lappend(result, path);
    4555             :     }
    4556             : 
    4557          72 :     return result;
    4558             : }
    4559             : 
    4560             : /*
    4561             :  * pathlist_is_reparameterizable_by_child
    4562             :  *      Helper function to check if a list of paths can be reparameterized.
    4563             :  */
    4564             : static bool
    4565         240 : pathlist_is_reparameterizable_by_child(List *pathlist, RelOptInfo *child_rel)
    4566             : {
    4567             :     ListCell   *lc;
    4568             : 
    4569         720 :     foreach(lc, pathlist)
    4570             :     {
    4571         480 :         Path       *path = (Path *) lfirst(lc);
    4572             : 
    4573         480 :         if (!path_is_reparameterizable_by_child(path, child_rel))
    4574           0 :             return false;
    4575             :     }
    4576             : 
    4577         240 :     return true;
    4578             : }

Generated by: LCOV version 1.14