LCOV - code coverage report
Current view: top level - src/backend/optimizer/plan - setrefs.c (source / functions) Hit Total Coverage
Test: PostgreSQL 19devel Lines: 1086 1136 95.6 %
Date: 2025-10-10 10:17:52 Functions: 47 48 97.9 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * setrefs.c
       4             :  *    Post-processing of a completed plan tree: fix references to subplan
       5             :  *    vars, compute regproc values for operators, etc
       6             :  *
       7             :  * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
       8             :  * Portions Copyright (c) 1994, Regents of the University of California
       9             :  *
      10             :  *
      11             :  * IDENTIFICATION
      12             :  *    src/backend/optimizer/plan/setrefs.c
      13             :  *
      14             :  *-------------------------------------------------------------------------
      15             :  */
      16             : #include "postgres.h"
      17             : 
      18             : #include "access/transam.h"
      19             : #include "catalog/pg_type.h"
      20             : #include "nodes/makefuncs.h"
      21             : #include "nodes/nodeFuncs.h"
      22             : #include "optimizer/optimizer.h"
      23             : #include "optimizer/pathnode.h"
      24             : #include "optimizer/planmain.h"
      25             : #include "optimizer/planner.h"
      26             : #include "optimizer/subselect.h"
      27             : #include "optimizer/tlist.h"
      28             : #include "parser/parse_relation.h"
      29             : #include "rewrite/rewriteManip.h"
      30             : #include "tcop/utility.h"
      31             : #include "utils/syscache.h"
      32             : 
      33             : 
      34             : typedef enum
      35             : {
      36             :     NRM_EQUAL,                  /* expect exact match of nullingrels */
      37             :     NRM_SUBSET,                 /* actual Var may have a subset of input */
      38             :     NRM_SUPERSET,               /* actual Var may have a superset of input */
      39             : } NullingRelsMatch;
      40             : 
      41             : typedef struct
      42             : {
      43             :     int         varno;          /* RT index of Var */
      44             :     AttrNumber  varattno;       /* attr number of Var */
      45             :     AttrNumber  resno;          /* TLE position of Var */
      46             :     Bitmapset  *varnullingrels; /* Var's varnullingrels */
      47             : } tlist_vinfo;
      48             : 
      49             : typedef struct
      50             : {
      51             :     List       *tlist;          /* underlying target list */
      52             :     int         num_vars;       /* number of plain Var tlist entries */
      53             :     bool        has_ph_vars;    /* are there PlaceHolderVar entries? */
      54             :     bool        has_non_vars;   /* are there other entries? */
      55             :     tlist_vinfo vars[FLEXIBLE_ARRAY_MEMBER];    /* has num_vars entries */
      56             : } indexed_tlist;
      57             : 
      58             : typedef struct
      59             : {
      60             :     PlannerInfo *root;
      61             :     int         rtoffset;
      62             :     double      num_exec;
      63             : } fix_scan_expr_context;
      64             : 
      65             : typedef struct
      66             : {
      67             :     PlannerInfo *root;
      68             :     indexed_tlist *outer_itlist;
      69             :     indexed_tlist *inner_itlist;
      70             :     Index       acceptable_rel;
      71             :     int         rtoffset;
      72             :     NullingRelsMatch nrm_match;
      73             :     double      num_exec;
      74             : } fix_join_expr_context;
      75             : 
      76             : typedef struct
      77             : {
      78             :     PlannerInfo *root;
      79             :     indexed_tlist *subplan_itlist;
      80             :     int         newvarno;
      81             :     int         rtoffset;
      82             :     NullingRelsMatch nrm_match;
      83             :     double      num_exec;
      84             : } fix_upper_expr_context;
      85             : 
      86             : typedef struct
      87             : {
      88             :     PlannerInfo *root;
      89             :     indexed_tlist *subplan_itlist;
      90             :     int         newvarno;
      91             : } fix_windowagg_cond_context;
      92             : 
      93             : /* Context info for flatten_rtes_walker() */
      94             : typedef struct
      95             : {
      96             :     PlannerGlobal *glob;
      97             :     Query      *query;
      98             : } flatten_rtes_walker_context;
      99             : 
     100             : /*
     101             :  * Selecting the best alternative in an AlternativeSubPlan expression requires
     102             :  * estimating how many times that expression will be evaluated.  For an
     103             :  * expression in a plan node's targetlist, the plan's estimated number of
     104             :  * output rows is clearly what to use, but for an expression in a qual it's
     105             :  * far less clear.  Since AlternativeSubPlans aren't heavily used, we don't
     106             :  * want to expend a lot of cycles making such estimates.  What we use is twice
     107             :  * the number of output rows.  That's not entirely unfounded: we know that
     108             :  * clause_selectivity() would fall back to a default selectivity estimate
     109             :  * of 0.5 for any SubPlan, so if the qual containing the SubPlan is the last
     110             :  * to be applied (which it likely would be, thanks to order_qual_clauses()),
     111             :  * this matches what we could have estimated in a far more laborious fashion.
     112             :  * Obviously there are many other scenarios, but it's probably not worth the
     113             :  * trouble to try to improve on this estimate, especially not when we don't
     114             :  * have a better estimate for the selectivity of the SubPlan qual itself.
     115             :  */
     116             : #define NUM_EXEC_TLIST(parentplan)  ((parentplan)->plan_rows)
     117             : #define NUM_EXEC_QUAL(parentplan)   ((parentplan)->plan_rows * 2.0)
     118             : 
     119             : /*
     120             :  * Check if a Const node is a regclass value.  We accept plain OID too,
     121             :  * since a regclass Const will get folded to that type if it's an argument
     122             :  * to oideq or similar operators.  (This might result in some extraneous
     123             :  * values in a plan's list of relation dependencies, but the worst result
     124             :  * would be occasional useless replans.)
     125             :  */
     126             : #define ISREGCLASSCONST(con) \
     127             :     (((con)->consttype == REGCLASSOID || (con)->consttype == OIDOID) && \
     128             :      !(con)->constisnull)
     129             : 
     130             : #define fix_scan_list(root, lst, rtoffset, num_exec) \
     131             :     ((List *) fix_scan_expr(root, (Node *) (lst), rtoffset, num_exec))
     132             : 
     133             : static void add_rtes_to_flat_rtable(PlannerInfo *root, bool recursing);
     134             : static void flatten_unplanned_rtes(PlannerGlobal *glob, RangeTblEntry *rte);
     135             : static bool flatten_rtes_walker(Node *node, flatten_rtes_walker_context *cxt);
     136             : static void add_rte_to_flat_rtable(PlannerGlobal *glob, List *rteperminfos,
     137             :                                    RangeTblEntry *rte);
     138             : static Plan *set_plan_refs(PlannerInfo *root, Plan *plan, int rtoffset);
     139             : static Plan *set_indexonlyscan_references(PlannerInfo *root,
     140             :                                           IndexOnlyScan *plan,
     141             :                                           int rtoffset);
     142             : static Plan *set_subqueryscan_references(PlannerInfo *root,
     143             :                                          SubqueryScan *plan,
     144             :                                          int rtoffset);
     145             : static Plan *clean_up_removed_plan_level(Plan *parent, Plan *child);
     146             : static void set_foreignscan_references(PlannerInfo *root,
     147             :                                        ForeignScan *fscan,
     148             :                                        int rtoffset);
     149             : static void set_customscan_references(PlannerInfo *root,
     150             :                                       CustomScan *cscan,
     151             :                                       int rtoffset);
     152             : static Plan *set_append_references(PlannerInfo *root,
     153             :                                    Append *aplan,
     154             :                                    int rtoffset);
     155             : static Plan *set_mergeappend_references(PlannerInfo *root,
     156             :                                         MergeAppend *mplan,
     157             :                                         int rtoffset);
     158             : static void set_hash_references(PlannerInfo *root, Plan *plan, int rtoffset);
     159             : static Relids offset_relid_set(Relids relids, int rtoffset);
     160             : static Node *fix_scan_expr(PlannerInfo *root, Node *node,
     161             :                            int rtoffset, double num_exec);
     162             : static Node *fix_scan_expr_mutator(Node *node, fix_scan_expr_context *context);
     163             : static bool fix_scan_expr_walker(Node *node, fix_scan_expr_context *context);
     164             : static void set_join_references(PlannerInfo *root, Join *join, int rtoffset);
     165             : static void set_upper_references(PlannerInfo *root, Plan *plan, int rtoffset);
     166             : static void set_param_references(PlannerInfo *root, Plan *plan);
     167             : static Node *convert_combining_aggrefs(Node *node, void *context);
     168             : static void set_dummy_tlist_references(Plan *plan, int rtoffset);
     169             : static indexed_tlist *build_tlist_index(List *tlist);
     170             : static Var *search_indexed_tlist_for_var(Var *var,
     171             :                                          indexed_tlist *itlist,
     172             :                                          int newvarno,
     173             :                                          int rtoffset,
     174             :                                          NullingRelsMatch nrm_match);
     175             : static Var *search_indexed_tlist_for_phv(PlaceHolderVar *phv,
     176             :                                          indexed_tlist *itlist,
     177             :                                          int newvarno,
     178             :                                          NullingRelsMatch nrm_match);
     179             : static Var *search_indexed_tlist_for_non_var(Expr *node,
     180             :                                              indexed_tlist *itlist,
     181             :                                              int newvarno);
     182             : static Var *search_indexed_tlist_for_sortgroupref(Expr *node,
     183             :                                                   Index sortgroupref,
     184             :                                                   indexed_tlist *itlist,
     185             :                                                   int newvarno);
     186             : static List *fix_join_expr(PlannerInfo *root,
     187             :                            List *clauses,
     188             :                            indexed_tlist *outer_itlist,
     189             :                            indexed_tlist *inner_itlist,
     190             :                            Index acceptable_rel,
     191             :                            int rtoffset,
     192             :                            NullingRelsMatch nrm_match,
     193             :                            double num_exec);
     194             : static Node *fix_join_expr_mutator(Node *node,
     195             :                                    fix_join_expr_context *context);
     196             : static Node *fix_upper_expr(PlannerInfo *root,
     197             :                             Node *node,
     198             :                             indexed_tlist *subplan_itlist,
     199             :                             int newvarno,
     200             :                             int rtoffset,
     201             :                             NullingRelsMatch nrm_match,
     202             :                             double num_exec);
     203             : static Node *fix_upper_expr_mutator(Node *node,
     204             :                                     fix_upper_expr_context *context);
     205             : static List *set_returning_clause_references(PlannerInfo *root,
     206             :                                              List *rlist,
     207             :                                              Plan *topplan,
     208             :                                              Index resultRelation,
     209             :                                              int rtoffset);
     210             : static List *set_windowagg_runcondition_references(PlannerInfo *root,
     211             :                                                    List *runcondition,
     212             :                                                    Plan *plan);
     213             : 
     214             : 
     215             : /*****************************************************************************
     216             :  *
     217             :  *      SUBPLAN REFERENCES
     218             :  *
     219             :  *****************************************************************************/
     220             : 
     221             : /*
     222             :  * set_plan_references
     223             :  *
     224             :  * This is the final processing pass of the planner/optimizer.  The plan
     225             :  * tree is complete; we just have to adjust some representational details
     226             :  * for the convenience of the executor:
     227             :  *
     228             :  * 1. We flatten the various subquery rangetables into a single list, and
     229             :  * zero out RangeTblEntry fields that are not useful to the executor.
     230             :  *
     231             :  * 2. We adjust Vars in scan nodes to be consistent with the flat rangetable.
     232             :  *
     233             :  * 3. We adjust Vars in upper plan nodes to refer to the outputs of their
     234             :  * subplans.
     235             :  *
     236             :  * 4. Aggrefs in Agg plan nodes need to be adjusted in some cases involving
     237             :  * partial aggregation or minmax aggregate optimization.
     238             :  *
     239             :  * 5. PARAM_MULTIEXPR Params are replaced by regular PARAM_EXEC Params,
     240             :  * now that we have finished planning all MULTIEXPR subplans.
     241             :  *
     242             :  * 6. AlternativeSubPlan expressions are replaced by just one of their
     243             :  * alternatives, using an estimate of how many times they'll be executed.
     244             :  *
     245             :  * 7. We compute regproc OIDs for operators (ie, we look up the function
     246             :  * that implements each op).
     247             :  *
     248             :  * 8. We create lists of specific objects that the plan depends on.
     249             :  * This will be used by plancache.c to drive invalidation of cached plans.
     250             :  * Relation dependencies are represented by OIDs, and everything else by
     251             :  * PlanInvalItems (this distinction is motivated by the shared-inval APIs).
     252             :  * Currently, relations, user-defined functions, and domains are the only
     253             :  * types of objects that are explicitly tracked this way.
     254             :  *
     255             :  * 9. We assign every plan node in the tree a unique ID.
     256             :  *
     257             :  * We also perform one final optimization step, which is to delete
     258             :  * SubqueryScan, Append, and MergeAppend plan nodes that aren't doing
     259             :  * anything useful.  The reason for doing this last is that
     260             :  * it can't readily be done before set_plan_references, because it would
     261             :  * break set_upper_references: the Vars in the child plan's top tlist
     262             :  * wouldn't match up with the Vars in the outer plan tree.  A SubqueryScan
     263             :  * serves a necessary function as a buffer between outer query and subquery
     264             :  * variable numbering ... but after we've flattened the rangetable this is
     265             :  * no longer a problem, since then there's only one rtindex namespace.
     266             :  * Likewise, Append and MergeAppend buffer between the parent and child vars
     267             :  * of an appendrel, but we don't need to worry about that once we've done
     268             :  * set_plan_references.
     269             :  *
     270             :  * set_plan_references recursively traverses the whole plan tree.
     271             :  *
     272             :  * The return value is normally the same Plan node passed in, but can be
     273             :  * different when the passed-in Plan is a node we decide isn't needed.
     274             :  *
     275             :  * The flattened rangetable entries are appended to root->glob->finalrtable.
     276             :  * Also, rowmarks entries are appended to root->glob->finalrowmarks, and the
     277             :  * RT indexes of ModifyTable result relations to root->glob->resultRelations,
     278             :  * and flattened AppendRelInfos are appended to root->glob->appendRelations.
     279             :  * Plan dependencies are appended to root->glob->relationOids (for relations)
     280             :  * and root->glob->invalItems (for everything else).
     281             :  *
     282             :  * Notice that we modify Plan nodes in-place, but use expression_tree_mutator
     283             :  * to process targetlist and qual expressions.  We can assume that the Plan
     284             :  * nodes were just built by the planner and are not multiply referenced, but
     285             :  * it's not so safe to assume that for expression tree nodes.
     286             :  */
     287             : Plan *
     288      526920 : set_plan_references(PlannerInfo *root, Plan *plan)
     289             : {
     290             :     Plan       *result;
     291      526920 :     PlannerGlobal *glob = root->glob;
     292      526920 :     int         rtoffset = list_length(glob->finalrtable);
     293             :     ListCell   *lc;
     294             : 
     295             :     /*
     296             :      * Add all the query's RTEs to the flattened rangetable.  The live ones
     297             :      * will have their rangetable indexes increased by rtoffset.  (Additional
     298             :      * RTEs, not referenced by the Plan tree, might get added after those.)
     299             :      */
     300      526920 :     add_rtes_to_flat_rtable(root, false);
     301             : 
     302             :     /*
     303             :      * Adjust RT indexes of PlanRowMarks and add to final rowmarks list
     304             :      */
     305      540026 :     foreach(lc, root->rowMarks)
     306             :     {
     307       13106 :         PlanRowMark *rc = lfirst_node(PlanRowMark, lc);
     308             :         PlanRowMark *newrc;
     309             : 
     310             :         /* sanity check on existing row marks */
     311             :         Assert(root->simple_rel_array[rc->rti] != NULL &&
     312             :                root->simple_rte_array[rc->rti] != NULL);
     313             : 
     314             :         /* flat copy is enough since all fields are scalars */
     315       13106 :         newrc = (PlanRowMark *) palloc(sizeof(PlanRowMark));
     316       13106 :         memcpy(newrc, rc, sizeof(PlanRowMark));
     317             : 
     318             :         /* adjust indexes ... but *not* the rowmarkId */
     319       13106 :         newrc->rti += rtoffset;
     320       13106 :         newrc->prti += rtoffset;
     321             : 
     322       13106 :         glob->finalrowmarks = lappend(glob->finalrowmarks, newrc);
     323             :     }
     324             : 
     325             :     /*
     326             :      * Adjust RT indexes of AppendRelInfos and add to final appendrels list.
     327             :      * We assume the AppendRelInfos were built during planning and don't need
     328             :      * to be copied.
     329             :      */
     330      584038 :     foreach(lc, root->append_rel_list)
     331             :     {
     332       57118 :         AppendRelInfo *appinfo = lfirst_node(AppendRelInfo, lc);
     333             : 
     334             :         /* adjust RT indexes */
     335       57118 :         appinfo->parent_relid += rtoffset;
     336       57118 :         appinfo->child_relid += rtoffset;
     337             : 
     338             :         /*
     339             :          * Rather than adjust the translated_vars entries, just drop 'em.
     340             :          * Neither the executor nor EXPLAIN currently need that data.
     341             :          */
     342       57118 :         appinfo->translated_vars = NIL;
     343             : 
     344       57118 :         glob->appendRelations = lappend(glob->appendRelations, appinfo);
     345             :     }
     346             : 
     347             :     /* If needed, create workspace for processing AlternativeSubPlans */
     348      526920 :     if (root->hasAlternativeSubPlans)
     349             :     {
     350        1086 :         root->isAltSubplan = (bool *)
     351        1086 :             palloc0(list_length(glob->subplans) * sizeof(bool));
     352        1086 :         root->isUsedSubplan = (bool *)
     353        1086 :             palloc0(list_length(glob->subplans) * sizeof(bool));
     354             :     }
     355             : 
     356             :     /* Now fix the Plan tree */
     357      526920 :     result = set_plan_refs(root, plan, rtoffset);
     358             : 
     359             :     /*
     360             :      * If we have AlternativeSubPlans, it is likely that we now have some
     361             :      * unreferenced subplans in glob->subplans.  To avoid expending cycles on
     362             :      * those subplans later, get rid of them by setting those list entries to
     363             :      * NULL.  (Note: we can't do this immediately upon processing an
     364             :      * AlternativeSubPlan, because there may be multiple copies of the
     365             :      * AlternativeSubPlan, and they can get resolved differently.)
     366             :      */
     367      526920 :     if (root->hasAlternativeSubPlans)
     368             :     {
     369        5274 :         foreach(lc, glob->subplans)
     370             :         {
     371        4188 :             int         ndx = foreach_current_index(lc);
     372             : 
     373             :             /*
     374             :              * If it was used by some AlternativeSubPlan in this query level,
     375             :              * but wasn't selected as best by any AlternativeSubPlan, then we
     376             :              * don't need it.  Do not touch subplans that aren't parts of
     377             :              * AlternativeSubPlans.
     378             :              */
     379        4188 :             if (root->isAltSubplan[ndx] && !root->isUsedSubplan[ndx])
     380        1672 :                 lfirst(lc) = NULL;
     381             :         }
     382             :     }
     383             : 
     384      526920 :     return result;
     385             : }
     386             : 
     387             : /*
     388             :  * Extract RangeTblEntries from the plan's rangetable, and add to flat rtable
     389             :  *
     390             :  * This can recurse into subquery plans; "recursing" is true if so.
     391             :  *
     392             :  * This also seems like a good place to add the query's RTEPermissionInfos to
     393             :  * the flat rteperminfos.
     394             :  */
     395             : static void
     396      527176 : add_rtes_to_flat_rtable(PlannerInfo *root, bool recursing)
     397             : {
     398      527176 :     PlannerGlobal *glob = root->glob;
     399             :     Index       rti;
     400             :     ListCell   *lc;
     401             : 
     402             :     /*
     403             :      * Add the query's own RTEs to the flattened rangetable.
     404             :      *
     405             :      * At top level, we must add all RTEs so that their indexes in the
     406             :      * flattened rangetable match up with their original indexes.  When
     407             :      * recursing, we only care about extracting relation RTEs (and subquery
     408             :      * RTEs that were once relation RTEs).
     409             :      */
     410     1486598 :     foreach(lc, root->parse->rtable)
     411             :     {
     412      959422 :         RangeTblEntry *rte = (RangeTblEntry *) lfirst(lc);
     413             : 
     414      959422 :         if (!recursing || rte->rtekind == RTE_RELATION ||
     415         246 :             (rte->rtekind == RTE_SUBQUERY && OidIsValid(rte->relid)))
     416      959176 :             add_rte_to_flat_rtable(glob, root->parse->rteperminfos, rte);
     417             :     }
     418             : 
     419             :     /*
     420             :      * If there are any dead subqueries, they are not referenced in the Plan
     421             :      * tree, so we must add RTEs contained in them to the flattened rtable
     422             :      * separately.  (If we failed to do this, the executor would not perform
     423             :      * expected permission checks for tables mentioned in such subqueries.)
     424             :      *
     425             :      * Note: this pass over the rangetable can't be combined with the previous
     426             :      * one, because that would mess up the numbering of the live RTEs in the
     427             :      * flattened rangetable.
     428             :      */
     429      527176 :     rti = 1;
     430     1486598 :     foreach(lc, root->parse->rtable)
     431             :     {
     432      959422 :         RangeTblEntry *rte = (RangeTblEntry *) lfirst(lc);
     433             : 
     434             :         /*
     435             :          * We should ignore inheritance-parent RTEs: their contents have been
     436             :          * pulled up into our rangetable already.  Also ignore any subquery
     437             :          * RTEs without matching RelOptInfos, as they likewise have been
     438             :          * pulled up.
     439             :          */
     440      959422 :         if (rte->rtekind == RTE_SUBQUERY && !rte->inh &&
     441       69128 :             rti < root->simple_rel_array_size)
     442             :         {
     443       69128 :             RelOptInfo *rel = root->simple_rel_array[rti];
     444             : 
     445       69128 :             if (rel != NULL)
     446             :             {
     447             :                 Assert(rel->relid == rti);   /* sanity check on array */
     448             : 
     449             :                 /*
     450             :                  * The subquery might never have been planned at all, if it
     451             :                  * was excluded on the basis of self-contradictory constraints
     452             :                  * in our query level.  In this case apply
     453             :                  * flatten_unplanned_rtes.
     454             :                  *
     455             :                  * If it was planned but the result rel is dummy, we assume
     456             :                  * that it has been omitted from our plan tree (see
     457             :                  * set_subquery_pathlist), and recurse to pull up its RTEs.
     458             :                  *
     459             :                  * Otherwise, it should be represented by a SubqueryScan node
     460             :                  * somewhere in our plan tree, and we'll pull up its RTEs when
     461             :                  * we process that plan node.
     462             :                  *
     463             :                  * However, if we're recursing, then we should pull up RTEs
     464             :                  * whether the subquery is dummy or not, because we've found
     465             :                  * that some upper query level is treating this one as dummy,
     466             :                  * and so we won't scan this level's plan tree at all.
     467             :                  */
     468       32866 :                 if (rel->subroot == NULL)
     469          24 :                     flatten_unplanned_rtes(glob, rte);
     470       65636 :                 else if (recursing ||
     471       32794 :                          IS_DUMMY_REL(fetch_upper_rel(rel->subroot,
     472             :                                                       UPPERREL_FINAL, NULL)))
     473         256 :                     add_rtes_to_flat_rtable(rel->subroot, true);
     474             :             }
     475             :         }
     476      959422 :         rti++;
     477             :     }
     478      527176 : }
     479             : 
     480             : /*
     481             :  * Extract RangeTblEntries from a subquery that was never planned at all
     482             :  */
     483             : 
     484             : static void
     485          24 : flatten_unplanned_rtes(PlannerGlobal *glob, RangeTblEntry *rte)
     486             : {
     487          24 :     flatten_rtes_walker_context cxt = {glob, rte->subquery};
     488             : 
     489             :     /* Use query_tree_walker to find all RTEs in the parse tree */
     490          24 :     (void) query_tree_walker(rte->subquery,
     491             :                              flatten_rtes_walker,
     492             :                              &cxt,
     493             :                              QTW_EXAMINE_RTES_BEFORE);
     494          24 : }
     495             : 
     496             : static bool
     497         600 : flatten_rtes_walker(Node *node, flatten_rtes_walker_context *cxt)
     498             : {
     499         600 :     if (node == NULL)
     500         348 :         return false;
     501         252 :     if (IsA(node, RangeTblEntry))
     502             :     {
     503          18 :         RangeTblEntry *rte = (RangeTblEntry *) node;
     504             : 
     505             :         /* As above, we need only save relation RTEs and former relations */
     506          18 :         if (rte->rtekind == RTE_RELATION ||
     507           0 :             (rte->rtekind == RTE_SUBQUERY && OidIsValid(rte->relid)))
     508          18 :             add_rte_to_flat_rtable(cxt->glob, cxt->query->rteperminfos, rte);
     509          18 :         return false;
     510             :     }
     511         234 :     if (IsA(node, Query))
     512             :     {
     513             :         /*
     514             :          * Recurse into subselects.  Must update cxt->query to this query so
     515             :          * that the rtable and rteperminfos correspond with each other.
     516             :          */
     517           6 :         Query      *save_query = cxt->query;
     518             :         bool        result;
     519             : 
     520           6 :         cxt->query = (Query *) node;
     521           6 :         result = query_tree_walker((Query *) node,
     522             :                                    flatten_rtes_walker,
     523             :                                    cxt,
     524             :                                    QTW_EXAMINE_RTES_BEFORE);
     525           6 :         cxt->query = save_query;
     526           6 :         return result;
     527             :     }
     528         228 :     return expression_tree_walker(node, flatten_rtes_walker, cxt);
     529             : }
     530             : 
     531             : /*
     532             :  * Add (a copy of) the given RTE to the final rangetable and also the
     533             :  * corresponding RTEPermissionInfo, if any, to final rteperminfos.
     534             :  *
     535             :  * In the flat rangetable, we zero out substructure pointers that are not
     536             :  * needed by the executor; this reduces the storage space and copying cost
     537             :  * for cached plans.  We keep only the ctename, alias, eref Alias fields,
     538             :  * which are needed by EXPLAIN, and perminfoindex which is needed by the
     539             :  * executor to fetch the RTE's RTEPermissionInfo.
     540             :  */
     541             : static void
     542      959194 : add_rte_to_flat_rtable(PlannerGlobal *glob, List *rteperminfos,
     543             :                        RangeTblEntry *rte)
     544             : {
     545             :     RangeTblEntry *newrte;
     546             : 
     547             :     /* flat copy to duplicate all the scalar fields */
     548      959194 :     newrte = (RangeTblEntry *) palloc(sizeof(RangeTblEntry));
     549      959194 :     memcpy(newrte, rte, sizeof(RangeTblEntry));
     550             : 
     551             :     /* zap unneeded sub-structure */
     552      959194 :     newrte->tablesample = NULL;
     553      959194 :     newrte->subquery = NULL;
     554      959194 :     newrte->joinaliasvars = NIL;
     555      959194 :     newrte->joinleftcols = NIL;
     556      959194 :     newrte->joinrightcols = NIL;
     557      959194 :     newrte->join_using_alias = NULL;
     558      959194 :     newrte->functions = NIL;
     559      959194 :     newrte->tablefunc = NULL;
     560      959194 :     newrte->values_lists = NIL;
     561      959194 :     newrte->coltypes = NIL;
     562      959194 :     newrte->coltypmods = NIL;
     563      959194 :     newrte->colcollations = NIL;
     564      959194 :     newrte->groupexprs = NIL;
     565      959194 :     newrte->securityQuals = NIL;
     566             : 
     567      959194 :     glob->finalrtable = lappend(glob->finalrtable, newrte);
     568             : 
     569             :     /*
     570             :      * If it's a plain relation RTE (or a subquery that was once a view
     571             :      * reference), add the relation OID to relationOids.  Also add its new RT
     572             :      * index to the set of relations to be potentially accessed during
     573             :      * execution.
     574             :      *
     575             :      * We do this even though the RTE might be unreferenced in the plan tree;
     576             :      * this would correspond to cases such as views that were expanded, child
     577             :      * tables that were eliminated by constraint exclusion, etc. Schema
     578             :      * invalidation on such a rel must still force rebuilding of the plan.
     579             :      *
     580             :      * Note we don't bother to avoid making duplicate list entries.  We could,
     581             :      * but it would probably cost more cycles than it would save.
     582             :      */
     583      959194 :     if (newrte->rtekind == RTE_RELATION ||
     584      439520 :         (newrte->rtekind == RTE_SUBQUERY && OidIsValid(newrte->relid)))
     585             :     {
     586      535318 :         glob->relationOids = lappend_oid(glob->relationOids, newrte->relid);
     587      535318 :         glob->allRelids = bms_add_member(glob->allRelids,
     588      535318 :                                          list_length(glob->finalrtable));
     589             :     }
     590             : 
     591             :     /*
     592             :      * Add a copy of the RTEPermissionInfo, if any, corresponding to this RTE
     593             :      * to the flattened global list.
     594             :      */
     595      959194 :     if (rte->perminfoindex > 0)
     596             :     {
     597             :         RTEPermissionInfo *perminfo;
     598             :         RTEPermissionInfo *newperminfo;
     599             : 
     600             :         /* Get the existing one from this query's rteperminfos. */
     601      493096 :         perminfo = getRTEPermissionInfo(rteperminfos, newrte);
     602             : 
     603             :         /*
     604             :          * Add a new one to finalrteperminfos and copy the contents of the
     605             :          * existing one into it.  Note that addRTEPermissionInfo() also
     606             :          * updates newrte->perminfoindex to point to newperminfo in
     607             :          * finalrteperminfos.
     608             :          */
     609      493096 :         newrte->perminfoindex = 0;   /* expected by addRTEPermissionInfo() */
     610      493096 :         newperminfo = addRTEPermissionInfo(&glob->finalrteperminfos, newrte);
     611      493096 :         memcpy(newperminfo, perminfo, sizeof(RTEPermissionInfo));
     612             :     }
     613      959194 : }
     614             : 
     615             : /*
     616             :  * set_plan_refs: recurse through the Plan nodes of a single subquery level
     617             :  */
     618             : static Plan *
     619     2827824 : set_plan_refs(PlannerInfo *root, Plan *plan, int rtoffset)
     620             : {
     621             :     ListCell   *l;
     622             : 
     623     2827824 :     if (plan == NULL)
     624     1633192 :         return NULL;
     625             : 
     626             :     /* Assign this node a unique ID. */
     627     1194632 :     plan->plan_node_id = root->glob->lastPlanNodeId++;
     628             : 
     629             :     /*
     630             :      * Plan-type-specific fixes
     631             :      */
     632     1194632 :     switch (nodeTag(plan))
     633             :     {
     634      218222 :         case T_SeqScan:
     635             :             {
     636      218222 :                 SeqScan    *splan = (SeqScan *) plan;
     637             : 
     638      218222 :                 splan->scan.scanrelid += rtoffset;
     639      218222 :                 splan->scan.plan.targetlist =
     640      218222 :                     fix_scan_list(root, splan->scan.plan.targetlist,
     641             :                                   rtoffset, NUM_EXEC_TLIST(plan));
     642      218222 :                 splan->scan.plan.qual =
     643      218222 :                     fix_scan_list(root, splan->scan.plan.qual,
     644             :                                   rtoffset, NUM_EXEC_QUAL(plan));
     645             :             }
     646      218222 :             break;
     647         306 :         case T_SampleScan:
     648             :             {
     649         306 :                 SampleScan *splan = (SampleScan *) plan;
     650             : 
     651         306 :                 splan->scan.scanrelid += rtoffset;
     652         306 :                 splan->scan.plan.targetlist =
     653         306 :                     fix_scan_list(root, splan->scan.plan.targetlist,
     654             :                                   rtoffset, NUM_EXEC_TLIST(plan));
     655         306 :                 splan->scan.plan.qual =
     656         306 :                     fix_scan_list(root, splan->scan.plan.qual,
     657             :                                   rtoffset, NUM_EXEC_QUAL(plan));
     658         306 :                 splan->tablesample = (TableSampleClause *)
     659         306 :                     fix_scan_expr(root, (Node *) splan->tablesample,
     660             :                                   rtoffset, 1);
     661             :             }
     662         306 :             break;
     663      140280 :         case T_IndexScan:
     664             :             {
     665      140280 :                 IndexScan  *splan = (IndexScan *) plan;
     666             : 
     667      140280 :                 splan->scan.scanrelid += rtoffset;
     668      140280 :                 splan->scan.plan.targetlist =
     669      140280 :                     fix_scan_list(root, splan->scan.plan.targetlist,
     670             :                                   rtoffset, NUM_EXEC_TLIST(plan));
     671      140280 :                 splan->scan.plan.qual =
     672      140280 :                     fix_scan_list(root, splan->scan.plan.qual,
     673             :                                   rtoffset, NUM_EXEC_QUAL(plan));
     674      140280 :                 splan->indexqual =
     675      140280 :                     fix_scan_list(root, splan->indexqual,
     676             :                                   rtoffset, 1);
     677      140280 :                 splan->indexqualorig =
     678      140280 :                     fix_scan_list(root, splan->indexqualorig,
     679             :                                   rtoffset, NUM_EXEC_QUAL(plan));
     680      140280 :                 splan->indexorderby =
     681      140280 :                     fix_scan_list(root, splan->indexorderby,
     682             :                                   rtoffset, 1);
     683      140280 :                 splan->indexorderbyorig =
     684      140280 :                     fix_scan_list(root, splan->indexorderbyorig,
     685             :                                   rtoffset, NUM_EXEC_QUAL(plan));
     686             :             }
     687      140280 :             break;
     688       18180 :         case T_IndexOnlyScan:
     689             :             {
     690       18180 :                 IndexOnlyScan *splan = (IndexOnlyScan *) plan;
     691             : 
     692       18180 :                 return set_indexonlyscan_references(root, splan, rtoffset);
     693             :             }
     694             :             break;
     695       21728 :         case T_BitmapIndexScan:
     696             :             {
     697       21728 :                 BitmapIndexScan *splan = (BitmapIndexScan *) plan;
     698             : 
     699       21728 :                 splan->scan.scanrelid += rtoffset;
     700             :                 /* no need to fix targetlist and qual */
     701             :                 Assert(splan->scan.plan.targetlist == NIL);
     702             :                 Assert(splan->scan.plan.qual == NIL);
     703       21728 :                 splan->indexqual =
     704       21728 :                     fix_scan_list(root, splan->indexqual, rtoffset, 1);
     705       21728 :                 splan->indexqualorig =
     706       21728 :                     fix_scan_list(root, splan->indexqualorig,
     707             :                                   rtoffset, NUM_EXEC_QUAL(plan));
     708             :             }
     709       21728 :             break;
     710       21054 :         case T_BitmapHeapScan:
     711             :             {
     712       21054 :                 BitmapHeapScan *splan = (BitmapHeapScan *) plan;
     713             : 
     714       21054 :                 splan->scan.scanrelid += rtoffset;
     715       21054 :                 splan->scan.plan.targetlist =
     716       21054 :                     fix_scan_list(root, splan->scan.plan.targetlist,
     717             :                                   rtoffset, NUM_EXEC_TLIST(plan));
     718       21054 :                 splan->scan.plan.qual =
     719       21054 :                     fix_scan_list(root, splan->scan.plan.qual,
     720             :                                   rtoffset, NUM_EXEC_QUAL(plan));
     721       21054 :                 splan->bitmapqualorig =
     722       21054 :                     fix_scan_list(root, splan->bitmapqualorig,
     723             :                                   rtoffset, NUM_EXEC_QUAL(plan));
     724             :             }
     725       21054 :             break;
     726         752 :         case T_TidScan:
     727             :             {
     728         752 :                 TidScan    *splan = (TidScan *) plan;
     729             : 
     730         752 :                 splan->scan.scanrelid += rtoffset;
     731         752 :                 splan->scan.plan.targetlist =
     732         752 :                     fix_scan_list(root, splan->scan.plan.targetlist,
     733             :                                   rtoffset, NUM_EXEC_TLIST(plan));
     734         752 :                 splan->scan.plan.qual =
     735         752 :                     fix_scan_list(root, splan->scan.plan.qual,
     736             :                                   rtoffset, NUM_EXEC_QUAL(plan));
     737         752 :                 splan->tidquals =
     738         752 :                     fix_scan_list(root, splan->tidquals,
     739             :                                   rtoffset, 1);
     740             :             }
     741         752 :             break;
     742        1944 :         case T_TidRangeScan:
     743             :             {
     744        1944 :                 TidRangeScan *splan = (TidRangeScan *) plan;
     745             : 
     746        1944 :                 splan->scan.scanrelid += rtoffset;
     747        1944 :                 splan->scan.plan.targetlist =
     748        1944 :                     fix_scan_list(root, splan->scan.plan.targetlist,
     749             :                                   rtoffset, NUM_EXEC_TLIST(plan));
     750        1944 :                 splan->scan.plan.qual =
     751        1944 :                     fix_scan_list(root, splan->scan.plan.qual,
     752             :                                   rtoffset, NUM_EXEC_QUAL(plan));
     753        1944 :                 splan->tidrangequals =
     754        1944 :                     fix_scan_list(root, splan->tidrangequals,
     755             :                                   rtoffset, 1);
     756             :             }
     757        1944 :             break;
     758       32550 :         case T_SubqueryScan:
     759             :             /* Needs special treatment, see comments below */
     760       32550 :             return set_subqueryscan_references(root,
     761             :                                                (SubqueryScan *) plan,
     762             :                                                rtoffset);
     763       50806 :         case T_FunctionScan:
     764             :             {
     765       50806 :                 FunctionScan *splan = (FunctionScan *) plan;
     766             : 
     767       50806 :                 splan->scan.scanrelid += rtoffset;
     768       50806 :                 splan->scan.plan.targetlist =
     769       50806 :                     fix_scan_list(root, splan->scan.plan.targetlist,
     770             :                                   rtoffset, NUM_EXEC_TLIST(plan));
     771       50806 :                 splan->scan.plan.qual =
     772       50806 :                     fix_scan_list(root, splan->scan.plan.qual,
     773             :                                   rtoffset, NUM_EXEC_QUAL(plan));
     774       50806 :                 splan->functions =
     775       50806 :                     fix_scan_list(root, splan->functions, rtoffset, 1);
     776             :             }
     777       50806 :             break;
     778         626 :         case T_TableFuncScan:
     779             :             {
     780         626 :                 TableFuncScan *splan = (TableFuncScan *) plan;
     781             : 
     782         626 :                 splan->scan.scanrelid += rtoffset;
     783         626 :                 splan->scan.plan.targetlist =
     784         626 :                     fix_scan_list(root, splan->scan.plan.targetlist,
     785             :                                   rtoffset, NUM_EXEC_TLIST(plan));
     786         626 :                 splan->scan.plan.qual =
     787         626 :                     fix_scan_list(root, splan->scan.plan.qual,
     788             :                                   rtoffset, NUM_EXEC_QUAL(plan));
     789         626 :                 splan->tablefunc = (TableFunc *)
     790         626 :                     fix_scan_expr(root, (Node *) splan->tablefunc,
     791             :                                   rtoffset, 1);
     792             :             }
     793         626 :             break;
     794        8278 :         case T_ValuesScan:
     795             :             {
     796        8278 :                 ValuesScan *splan = (ValuesScan *) plan;
     797             : 
     798        8278 :                 splan->scan.scanrelid += rtoffset;
     799        8278 :                 splan->scan.plan.targetlist =
     800        8278 :                     fix_scan_list(root, splan->scan.plan.targetlist,
     801             :                                   rtoffset, NUM_EXEC_TLIST(plan));
     802        8278 :                 splan->scan.plan.qual =
     803        8278 :                     fix_scan_list(root, splan->scan.plan.qual,
     804             :                                   rtoffset, NUM_EXEC_QUAL(plan));
     805        8278 :                 splan->values_lists =
     806        8278 :                     fix_scan_list(root, splan->values_lists,
     807             :                                   rtoffset, 1);
     808             :             }
     809        8278 :             break;
     810        4244 :         case T_CteScan:
     811             :             {
     812        4244 :                 CteScan    *splan = (CteScan *) plan;
     813             : 
     814        4244 :                 splan->scan.scanrelid += rtoffset;
     815        4244 :                 splan->scan.plan.targetlist =
     816        4244 :                     fix_scan_list(root, splan->scan.plan.targetlist,
     817             :                                   rtoffset, NUM_EXEC_TLIST(plan));
     818        4244 :                 splan->scan.plan.qual =
     819        4244 :                     fix_scan_list(root, splan->scan.plan.qual,
     820             :                                   rtoffset, NUM_EXEC_QUAL(plan));
     821             :             }
     822        4244 :             break;
     823         478 :         case T_NamedTuplestoreScan:
     824             :             {
     825         478 :                 NamedTuplestoreScan *splan = (NamedTuplestoreScan *) plan;
     826             : 
     827         478 :                 splan->scan.scanrelid += rtoffset;
     828         478 :                 splan->scan.plan.targetlist =
     829         478 :                     fix_scan_list(root, splan->scan.plan.targetlist,
     830             :                                   rtoffset, NUM_EXEC_TLIST(plan));
     831         478 :                 splan->scan.plan.qual =
     832         478 :                     fix_scan_list(root, splan->scan.plan.qual,
     833             :                                   rtoffset, NUM_EXEC_QUAL(plan));
     834             :             }
     835         478 :             break;
     836         926 :         case T_WorkTableScan:
     837             :             {
     838         926 :                 WorkTableScan *splan = (WorkTableScan *) plan;
     839             : 
     840         926 :                 splan->scan.scanrelid += rtoffset;
     841         926 :                 splan->scan.plan.targetlist =
     842         926 :                     fix_scan_list(root, splan->scan.plan.targetlist,
     843             :                                   rtoffset, NUM_EXEC_TLIST(plan));
     844         926 :                 splan->scan.plan.qual =
     845         926 :                     fix_scan_list(root, splan->scan.plan.qual,
     846             :                                   rtoffset, NUM_EXEC_QUAL(plan));
     847             :             }
     848         926 :             break;
     849        2020 :         case T_ForeignScan:
     850        2020 :             set_foreignscan_references(root, (ForeignScan *) plan, rtoffset);
     851        2020 :             break;
     852           0 :         case T_CustomScan:
     853           0 :             set_customscan_references(root, (CustomScan *) plan, rtoffset);
     854           0 :             break;
     855             : 
     856      139866 :         case T_NestLoop:
     857             :         case T_MergeJoin:
     858             :         case T_HashJoin:
     859      139866 :             set_join_references(root, (Join *) plan, rtoffset);
     860      139866 :             break;
     861             : 
     862        1430 :         case T_Gather:
     863             :         case T_GatherMerge:
     864             :             {
     865        1430 :                 set_upper_references(root, plan, rtoffset);
     866        1430 :                 set_param_references(root, plan);
     867             :             }
     868        1430 :             break;
     869             : 
     870       34638 :         case T_Hash:
     871       34638 :             set_hash_references(root, plan, rtoffset);
     872       34638 :             break;
     873             : 
     874        1988 :         case T_Memoize:
     875             :             {
     876        1988 :                 Memoize    *mplan = (Memoize *) plan;
     877             : 
     878             :                 /*
     879             :                  * Memoize does not evaluate its targetlist.  It just uses the
     880             :                  * same targetlist from its outer subnode.
     881             :                  */
     882        1988 :                 set_dummy_tlist_references(plan, rtoffset);
     883             : 
     884        1988 :                 mplan->param_exprs = fix_scan_list(root, mplan->param_exprs,
     885             :                                                    rtoffset,
     886             :                                                    NUM_EXEC_TLIST(plan));
     887        1988 :                 break;
     888             :             }
     889             : 
     890       91534 :         case T_Material:
     891             :         case T_Sort:
     892             :         case T_IncrementalSort:
     893             :         case T_Unique:
     894             :         case T_SetOp:
     895             : 
     896             :             /*
     897             :              * These plan types don't actually bother to evaluate their
     898             :              * targetlists, because they just return their unmodified input
     899             :              * tuples.  Even though the targetlist won't be used by the
     900             :              * executor, we fix it up for possible use by EXPLAIN (not to
     901             :              * mention ease of debugging --- wrong varnos are very confusing).
     902             :              */
     903       91534 :             set_dummy_tlist_references(plan, rtoffset);
     904             : 
     905             :             /*
     906             :              * Since these plan types don't check quals either, we should not
     907             :              * find any qual expression attached to them.
     908             :              */
     909             :             Assert(plan->qual == NIL);
     910       91534 :             break;
     911        7804 :         case T_LockRows:
     912             :             {
     913        7804 :                 LockRows   *splan = (LockRows *) plan;
     914             : 
     915             :                 /*
     916             :                  * Like the plan types above, LockRows doesn't evaluate its
     917             :                  * tlist or quals.  But we have to fix up the RT indexes in
     918             :                  * its rowmarks.
     919             :                  */
     920        7804 :                 set_dummy_tlist_references(plan, rtoffset);
     921             :                 Assert(splan->plan.qual == NIL);
     922             : 
     923       17970 :                 foreach(l, splan->rowMarks)
     924             :                 {
     925       10166 :                     PlanRowMark *rc = (PlanRowMark *) lfirst(l);
     926             : 
     927       10166 :                     rc->rti += rtoffset;
     928       10166 :                     rc->prti += rtoffset;
     929             :                 }
     930             :             }
     931        7804 :             break;
     932        4814 :         case T_Limit:
     933             :             {
     934        4814 :                 Limit      *splan = (Limit *) plan;
     935             : 
     936             :                 /*
     937             :                  * Like the plan types above, Limit doesn't evaluate its tlist
     938             :                  * or quals.  It does have live expressions for limit/offset,
     939             :                  * however; and those cannot contain subplan variable refs, so
     940             :                  * fix_scan_expr works for them.
     941             :                  */
     942        4814 :                 set_dummy_tlist_references(plan, rtoffset);
     943             :                 Assert(splan->plan.qual == NIL);
     944             : 
     945        4814 :                 splan->limitOffset =
     946        4814 :                     fix_scan_expr(root, splan->limitOffset, rtoffset, 1);
     947        4814 :                 splan->limitCount =
     948        4814 :                     fix_scan_expr(root, splan->limitCount, rtoffset, 1);
     949             :             }
     950        4814 :             break;
     951       42526 :         case T_Agg:
     952             :             {
     953       42526 :                 Agg        *agg = (Agg *) plan;
     954             : 
     955             :                 /*
     956             :                  * If this node is combining partial-aggregation results, we
     957             :                  * must convert its Aggrefs to contain references to the
     958             :                  * partial-aggregate subexpressions that will be available
     959             :                  * from the child plan node.
     960             :                  */
     961       42526 :                 if (DO_AGGSPLIT_COMBINE(agg->aggsplit))
     962             :                 {
     963        1354 :                     plan->targetlist = (List *)
     964        1354 :                         convert_combining_aggrefs((Node *) plan->targetlist,
     965             :                                                   NULL);
     966        1354 :                     plan->qual = (List *)
     967        1354 :                         convert_combining_aggrefs((Node *) plan->qual,
     968             :                                                   NULL);
     969             :                 }
     970             : 
     971       42526 :                 set_upper_references(root, plan, rtoffset);
     972             :             }
     973       42526 :             break;
     974         246 :         case T_Group:
     975         246 :             set_upper_references(root, plan, rtoffset);
     976         246 :             break;
     977        2750 :         case T_WindowAgg:
     978             :             {
     979        2750 :                 WindowAgg  *wplan = (WindowAgg *) plan;
     980             : 
     981             :                 /*
     982             :                  * Adjust the WindowAgg's run conditions by swapping the
     983             :                  * WindowFuncs references out to instead reference the Var in
     984             :                  * the scan slot so that when the executor evaluates the
     985             :                  * runCondition, it receives the WindowFunc's value from the
     986             :                  * slot that the result has just been stored into rather than
     987             :                  * evaluating the WindowFunc all over again.
     988             :                  */
     989        2750 :                 wplan->runCondition = set_windowagg_runcondition_references(root,
     990             :                                                                             wplan->runCondition,
     991             :                                                                             (Plan *) wplan);
     992             : 
     993        2750 :                 set_upper_references(root, plan, rtoffset);
     994             : 
     995             :                 /*
     996             :                  * Like Limit node limit/offset expressions, WindowAgg has
     997             :                  * frame offset expressions, which cannot contain subplan
     998             :                  * variable refs, so fix_scan_expr works for them.
     999             :                  */
    1000        2750 :                 wplan->startOffset =
    1001        2750 :                     fix_scan_expr(root, wplan->startOffset, rtoffset, 1);
    1002        2750 :                 wplan->endOffset =
    1003        2750 :                     fix_scan_expr(root, wplan->endOffset, rtoffset, 1);
    1004        2750 :                 wplan->runCondition = fix_scan_list(root,
    1005             :                                                     wplan->runCondition,
    1006             :                                                     rtoffset,
    1007             :                                                     NUM_EXEC_TLIST(plan));
    1008        2750 :                 wplan->runConditionOrig = fix_scan_list(root,
    1009             :                                                         wplan->runConditionOrig,
    1010             :                                                         rtoffset,
    1011             :                                                         NUM_EXEC_TLIST(plan));
    1012             :             }
    1013        2750 :             break;
    1014      214056 :         case T_Result:
    1015             :             {
    1016      214056 :                 Result     *splan = (Result *) plan;
    1017             : 
    1018             :                 /*
    1019             :                  * Result may or may not have a subplan; if not, it's more
    1020             :                  * like a scan node than an upper node.
    1021             :                  */
    1022      214056 :                 if (splan->plan.lefttree != NULL)
    1023       11758 :                     set_upper_references(root, plan, rtoffset);
    1024             :                 else
    1025             :                 {
    1026             :                     /*
    1027             :                      * The tlist of a childless Result could contain
    1028             :                      * unresolved ROWID_VAR Vars, in case it's representing a
    1029             :                      * target relation which is completely empty because of
    1030             :                      * constraint exclusion.  Replace any such Vars by null
    1031             :                      * constants, as though they'd been resolved for a leaf
    1032             :                      * scan node that doesn't support them.  We could have
    1033             :                      * fix_scan_expr do this, but since the case is only
    1034             :                      * expected to occur here, it seems safer to special-case
    1035             :                      * it here and keep the assertions that ROWID_VARs
    1036             :                      * shouldn't be seen by fix_scan_expr.
    1037             :                      *
    1038             :                      * We also must handle the case where set operations have
    1039             :                      * been short-circuited resulting in a dummy Result node.
    1040             :                      * prepunion.c uses varno==0 for the set op targetlist.
    1041             :                      * See generate_setop_tlist() and generate_setop_tlist().
    1042             :                      * Here we rewrite these to use varno==1, which is the
    1043             :                      * varno of the first set-op child.  Without this, EXPLAIN
    1044             :                      * will have trouble displaying targetlists of dummy set
    1045             :                      * operations.
    1046             :                      */
    1047      472610 :                     foreach(l, splan->plan.targetlist)
    1048             :                     {
    1049      270312 :                         TargetEntry *tle = (TargetEntry *) lfirst(l);
    1050      270312 :                         Var        *var = (Var *) tle->expr;
    1051             : 
    1052      270312 :                         if (var && IsA(var, Var))
    1053             :                         {
    1054        1622 :                             if (var->varno == ROWID_VAR)
    1055          72 :                                 tle->expr = (Expr *) makeNullConst(var->vartype,
    1056             :                                                                    var->vartypmod,
    1057             :                                                                    var->varcollid);
    1058        1550 :                             else if (var->varno == 0)
    1059          30 :                                 tle->expr = (Expr *) makeVar(1,
    1060          30 :                                                              var->varattno,
    1061             :                                                              var->vartype,
    1062             :                                                              var->vartypmod,
    1063             :                                                              var->varcollid,
    1064             :                                                              var->varlevelsup);
    1065             :                         }
    1066             :                     }
    1067             : 
    1068      202298 :                     splan->plan.targetlist =
    1069      202298 :                         fix_scan_list(root, splan->plan.targetlist,
    1070             :                                       rtoffset, NUM_EXEC_TLIST(plan));
    1071      202298 :                     splan->plan.qual =
    1072      202298 :                         fix_scan_list(root, splan->plan.qual,
    1073             :                                       rtoffset, NUM_EXEC_QUAL(plan));
    1074             :                 }
    1075             :                 /* resconstantqual can't contain any subplan variable refs */
    1076      214056 :                 splan->resconstantqual =
    1077      214056 :                     fix_scan_expr(root, splan->resconstantqual, rtoffset, 1);
    1078             :                 /* adjust the relids set */
    1079      214056 :                 splan->relids = offset_relid_set(splan->relids, rtoffset);
    1080             :             }
    1081      214056 :             break;
    1082       11716 :         case T_ProjectSet:
    1083       11716 :             set_upper_references(root, plan, rtoffset);
    1084       11716 :             break;
    1085       92804 :         case T_ModifyTable:
    1086             :             {
    1087       92804 :                 ModifyTable *splan = (ModifyTable *) plan;
    1088       92804 :                 Plan       *subplan = outerPlan(splan);
    1089             : 
    1090             :                 Assert(splan->plan.targetlist == NIL);
    1091             :                 Assert(splan->plan.qual == NIL);
    1092             : 
    1093       92804 :                 splan->withCheckOptionLists =
    1094       92804 :                     fix_scan_list(root, splan->withCheckOptionLists,
    1095             :                                   rtoffset, 1);
    1096             : 
    1097       92804 :                 if (splan->returningLists)
    1098             :                 {
    1099        2900 :                     List       *newRL = NIL;
    1100             :                     ListCell   *lcrl,
    1101             :                                *lcrr;
    1102             : 
    1103             :                     /*
    1104             :                      * Pass each per-resultrel returningList through
    1105             :                      * set_returning_clause_references().
    1106             :                      */
    1107             :                     Assert(list_length(splan->returningLists) == list_length(splan->resultRelations));
    1108        6188 :                     forboth(lcrl, splan->returningLists,
    1109             :                             lcrr, splan->resultRelations)
    1110             :                     {
    1111        3288 :                         List       *rlist = (List *) lfirst(lcrl);
    1112        3288 :                         Index       resultrel = lfirst_int(lcrr);
    1113             : 
    1114        3288 :                         rlist = set_returning_clause_references(root,
    1115             :                                                                 rlist,
    1116             :                                                                 subplan,
    1117             :                                                                 resultrel,
    1118             :                                                                 rtoffset);
    1119        3288 :                         newRL = lappend(newRL, rlist);
    1120             :                     }
    1121        2900 :                     splan->returningLists = newRL;
    1122             : 
    1123             :                     /*
    1124             :                      * Set up the visible plan targetlist as being the same as
    1125             :                      * the first RETURNING list.  This is mostly for the use
    1126             :                      * of EXPLAIN; the executor won't execute that targetlist,
    1127             :                      * although it does use it to prepare the node's result
    1128             :                      * tuple slot.  We postpone this step until here so that
    1129             :                      * we don't have to do set_returning_clause_references()
    1130             :                      * twice on identical targetlists.
    1131             :                      */
    1132        2900 :                     splan->plan.targetlist = copyObject(linitial(newRL));
    1133             :                 }
    1134             : 
    1135             :                 /*
    1136             :                  * We treat ModifyTable with ON CONFLICT as a form of 'pseudo
    1137             :                  * join', where the inner side is the EXCLUDED tuple.
    1138             :                  * Therefore use fix_join_expr to setup the relevant variables
    1139             :                  * to INNER_VAR. We explicitly don't create any OUTER_VARs as
    1140             :                  * those are already used by RETURNING and it seems better to
    1141             :                  * be non-conflicting.
    1142             :                  */
    1143       92804 :                 if (splan->onConflictSet)
    1144             :                 {
    1145             :                     indexed_tlist *itlist;
    1146             : 
    1147         972 :                     itlist = build_tlist_index(splan->exclRelTlist);
    1148             : 
    1149         972 :                     splan->onConflictSet =
    1150        1944 :                         fix_join_expr(root, splan->onConflictSet,
    1151             :                                       NULL, itlist,
    1152         972 :                                       linitial_int(splan->resultRelations),
    1153         972 :                                       rtoffset, NRM_EQUAL, NUM_EXEC_QUAL(plan));
    1154             : 
    1155         972 :                     splan->onConflictWhere = (Node *)
    1156        1944 :                         fix_join_expr(root, (List *) splan->onConflictWhere,
    1157             :                                       NULL, itlist,
    1158         972 :                                       linitial_int(splan->resultRelations),
    1159         972 :                                       rtoffset, NRM_EQUAL, NUM_EXEC_QUAL(plan));
    1160             : 
    1161         972 :                     pfree(itlist);
    1162             : 
    1163         972 :                     splan->exclRelTlist =
    1164         972 :                         fix_scan_list(root, splan->exclRelTlist, rtoffset, 1);
    1165             :                 }
    1166             : 
    1167             :                 /*
    1168             :                  * The MERGE statement produces the target rows by performing
    1169             :                  * a right join between the target relation and the source
    1170             :                  * relation (which could be a plain relation or a subquery).
    1171             :                  * The INSERT and UPDATE actions of the MERGE statement
    1172             :                  * require access to the columns from the source relation. We
    1173             :                  * arrange things so that the source relation attributes are
    1174             :                  * available as INNER_VAR and the target relation attributes
    1175             :                  * are available from the scan tuple.
    1176             :                  */
    1177       92804 :                 if (splan->mergeActionLists != NIL)
    1178             :                 {
    1179        1786 :                     List       *newMJC = NIL;
    1180             :                     ListCell   *lca,
    1181             :                                *lcj,
    1182             :                                *lcr;
    1183             : 
    1184             :                     /*
    1185             :                      * Fix the targetList of individual action nodes so that
    1186             :                      * the so-called "source relation" Vars are referenced as
    1187             :                      * INNER_VAR.  Note that for this to work correctly during
    1188             :                      * execution, the ecxt_innertuple must be set to the tuple
    1189             :                      * obtained by executing the subplan, which is what
    1190             :                      * constitutes the "source relation".
    1191             :                      *
    1192             :                      * We leave the Vars from the result relation (i.e. the
    1193             :                      * target relation) unchanged i.e. those Vars would be
    1194             :                      * picked from the scan slot. So during execution, we must
    1195             :                      * ensure that ecxt_scantuple is setup correctly to refer
    1196             :                      * to the tuple from the target relation.
    1197             :                      */
    1198             :                     indexed_tlist *itlist;
    1199             : 
    1200        1786 :                     itlist = build_tlist_index(subplan->targetlist);
    1201             : 
    1202        3858 :                     forthree(lca, splan->mergeActionLists,
    1203             :                              lcj, splan->mergeJoinConditions,
    1204             :                              lcr, splan->resultRelations)
    1205             :                     {
    1206        2072 :                         List       *mergeActionList = lfirst(lca);
    1207        2072 :                         Node       *mergeJoinCondition = lfirst(lcj);
    1208        2072 :                         Index       resultrel = lfirst_int(lcr);
    1209             : 
    1210        5552 :                         foreach(l, mergeActionList)
    1211             :                         {
    1212        3480 :                             MergeAction *action = (MergeAction *) lfirst(l);
    1213             : 
    1214             :                             /* Fix targetList of each action. */
    1215        3480 :                             action->targetList = fix_join_expr(root,
    1216             :                                                                action->targetList,
    1217             :                                                                NULL, itlist,
    1218             :                                                                resultrel,
    1219             :                                                                rtoffset,
    1220             :                                                                NRM_EQUAL,
    1221             :                                                                NUM_EXEC_TLIST(plan));
    1222             : 
    1223             :                             /* Fix quals too. */
    1224        3480 :                             action->qual = (Node *) fix_join_expr(root,
    1225        3480 :                                                                   (List *) action->qual,
    1226             :                                                                   NULL, itlist,
    1227             :                                                                   resultrel,
    1228             :                                                                   rtoffset,
    1229             :                                                                   NRM_EQUAL,
    1230        3480 :                                                                   NUM_EXEC_QUAL(plan));
    1231             :                         }
    1232             : 
    1233             :                         /* Fix join condition too. */
    1234             :                         mergeJoinCondition = (Node *)
    1235        2072 :                             fix_join_expr(root,
    1236             :                                           (List *) mergeJoinCondition,
    1237             :                                           NULL, itlist,
    1238             :                                           resultrel,
    1239             :                                           rtoffset,
    1240             :                                           NRM_EQUAL,
    1241        2072 :                                           NUM_EXEC_QUAL(plan));
    1242        2072 :                         newMJC = lappend(newMJC, mergeJoinCondition);
    1243             :                     }
    1244        1786 :                     splan->mergeJoinConditions = newMJC;
    1245             :                 }
    1246             : 
    1247       92804 :                 splan->nominalRelation += rtoffset;
    1248       92804 :                 if (splan->rootRelation)
    1249        2862 :                     splan->rootRelation += rtoffset;
    1250       92804 :                 splan->exclRelRTI += rtoffset;
    1251             : 
    1252      188098 :                 foreach(l, splan->resultRelations)
    1253             :                 {
    1254       95294 :                     lfirst_int(l) += rtoffset;
    1255             :                 }
    1256       95704 :                 foreach(l, splan->rowMarks)
    1257             :                 {
    1258        2900 :                     PlanRowMark *rc = (PlanRowMark *) lfirst(l);
    1259             : 
    1260        2900 :                     rc->rti += rtoffset;
    1261        2900 :                     rc->prti += rtoffset;
    1262             :                 }
    1263             : 
    1264             :                 /*
    1265             :                  * Append this ModifyTable node's final result relation RT
    1266             :                  * index(es) to the global list for the plan.
    1267             :                  */
    1268      185608 :                 root->glob->resultRelations =
    1269       92804 :                     list_concat(root->glob->resultRelations,
    1270       92804 :                                 splan->resultRelations);
    1271       92804 :                 if (splan->rootRelation)
    1272             :                 {
    1273        2862 :                     root->glob->resultRelations =
    1274        2862 :                         lappend_int(root->glob->resultRelations,
    1275        2862 :                                     splan->rootRelation);
    1276             :                 }
    1277             :             }
    1278       92804 :             break;
    1279       23906 :         case T_Append:
    1280             :             /* Needs special treatment, see comments below */
    1281       23906 :             return set_append_references(root,
    1282             :                                          (Append *) plan,
    1283             :                                          rtoffset);
    1284         566 :         case T_MergeAppend:
    1285             :             /* Needs special treatment, see comments below */
    1286         566 :             return set_mergeappend_references(root,
    1287             :                                               (MergeAppend *) plan,
    1288             :                                               rtoffset);
    1289         926 :         case T_RecursiveUnion:
    1290             :             /* This doesn't evaluate targetlist or check quals either */
    1291         926 :             set_dummy_tlist_references(plan, rtoffset);
    1292             :             Assert(plan->qual == NIL);
    1293         926 :             break;
    1294         246 :         case T_BitmapAnd:
    1295             :             {
    1296         246 :                 BitmapAnd  *splan = (BitmapAnd *) plan;
    1297             : 
    1298             :                 /* BitmapAnd works like Append, but has no tlist */
    1299             :                 Assert(splan->plan.targetlist == NIL);
    1300             :                 Assert(splan->plan.qual == NIL);
    1301         738 :                 foreach(l, splan->bitmapplans)
    1302             :                 {
    1303         492 :                     lfirst(l) = set_plan_refs(root,
    1304         492 :                                               (Plan *) lfirst(l),
    1305             :                                               rtoffset);
    1306             :                 }
    1307             :             }
    1308         246 :             break;
    1309         422 :         case T_BitmapOr:
    1310             :             {
    1311         422 :                 BitmapOr   *splan = (BitmapOr *) plan;
    1312             : 
    1313             :                 /* BitmapOr works like Append, but has no tlist */
    1314             :                 Assert(splan->plan.targetlist == NIL);
    1315             :                 Assert(splan->plan.qual == NIL);
    1316        1272 :                 foreach(l, splan->bitmapplans)
    1317             :                 {
    1318         850 :                     lfirst(l) = set_plan_refs(root,
    1319         850 :                                               (Plan *) lfirst(l),
    1320             :                                               rtoffset);
    1321             :                 }
    1322             :             }
    1323         422 :             break;
    1324           0 :         default:
    1325           0 :             elog(ERROR, "unrecognized node type: %d",
    1326             :                  (int) nodeTag(plan));
    1327             :             break;
    1328             :     }
    1329             : 
    1330             :     /*
    1331             :      * Now recurse into child plans, if any
    1332             :      *
    1333             :      * NOTE: it is essential that we recurse into child plans AFTER we set
    1334             :      * subplan references in this plan's tlist and quals.  If we did the
    1335             :      * reference-adjustments bottom-up, then we would fail to match this
    1336             :      * plan's var nodes against the already-modified nodes of the children.
    1337             :      */
    1338     1119430 :     plan->lefttree = set_plan_refs(root, plan->lefttree, rtoffset);
    1339     1119430 :     plan->righttree = set_plan_refs(root, plan->righttree, rtoffset);
    1340             : 
    1341     1119430 :     return plan;
    1342             : }
    1343             : 
    1344             : /*
    1345             :  * set_indexonlyscan_references
    1346             :  *      Do set_plan_references processing on an IndexOnlyScan
    1347             :  *
    1348             :  * This is unlike the handling of a plain IndexScan because we have to
    1349             :  * convert Vars referencing the heap into Vars referencing the index.
    1350             :  * We can use the fix_upper_expr machinery for that, by working from a
    1351             :  * targetlist describing the index columns.
    1352             :  */
    1353             : static Plan *
    1354       18180 : set_indexonlyscan_references(PlannerInfo *root,
    1355             :                              IndexOnlyScan *plan,
    1356             :                              int rtoffset)
    1357             : {
    1358             :     indexed_tlist *index_itlist;
    1359             :     List       *stripped_indextlist;
    1360             :     ListCell   *lc;
    1361             : 
    1362             :     /*
    1363             :      * Vars in the plan node's targetlist, qual, and recheckqual must only
    1364             :      * reference columns that the index AM can actually return.  To ensure
    1365             :      * this, remove non-returnable columns (which are marked as resjunk) from
    1366             :      * the indexed tlist.  We can just drop them because the indexed_tlist
    1367             :      * machinery pays attention to TLE resnos, not physical list position.
    1368             :      */
    1369       18180 :     stripped_indextlist = NIL;
    1370       42684 :     foreach(lc, plan->indextlist)
    1371             :     {
    1372       24504 :         TargetEntry *indextle = (TargetEntry *) lfirst(lc);
    1373             : 
    1374       24504 :         if (!indextle->resjunk)
    1375       24452 :             stripped_indextlist = lappend(stripped_indextlist, indextle);
    1376             :     }
    1377             : 
    1378       18180 :     index_itlist = build_tlist_index(stripped_indextlist);
    1379             : 
    1380       18180 :     plan->scan.scanrelid += rtoffset;
    1381       18180 :     plan->scan.plan.targetlist = (List *)
    1382       18180 :         fix_upper_expr(root,
    1383       18180 :                        (Node *) plan->scan.plan.targetlist,
    1384             :                        index_itlist,
    1385             :                        INDEX_VAR,
    1386             :                        rtoffset,
    1387             :                        NRM_EQUAL,
    1388             :                        NUM_EXEC_TLIST((Plan *) plan));
    1389       18180 :     plan->scan.plan.qual = (List *)
    1390       18180 :         fix_upper_expr(root,
    1391       18180 :                        (Node *) plan->scan.plan.qual,
    1392             :                        index_itlist,
    1393             :                        INDEX_VAR,
    1394             :                        rtoffset,
    1395             :                        NRM_EQUAL,
    1396       18180 :                        NUM_EXEC_QUAL((Plan *) plan));
    1397       18180 :     plan->recheckqual = (List *)
    1398       18180 :         fix_upper_expr(root,
    1399       18180 :                        (Node *) plan->recheckqual,
    1400             :                        index_itlist,
    1401             :                        INDEX_VAR,
    1402             :                        rtoffset,
    1403             :                        NRM_EQUAL,
    1404       18180 :                        NUM_EXEC_QUAL((Plan *) plan));
    1405             :     /* indexqual is already transformed to reference index columns */
    1406       18180 :     plan->indexqual = fix_scan_list(root, plan->indexqual,
    1407             :                                     rtoffset, 1);
    1408             :     /* indexorderby is already transformed to reference index columns */
    1409       18180 :     plan->indexorderby = fix_scan_list(root, plan->indexorderby,
    1410             :                                        rtoffset, 1);
    1411             :     /* indextlist must NOT be transformed to reference index columns */
    1412       18180 :     plan->indextlist = fix_scan_list(root, plan->indextlist,
    1413             :                                      rtoffset, NUM_EXEC_TLIST((Plan *) plan));
    1414             : 
    1415       18180 :     pfree(index_itlist);
    1416             : 
    1417       18180 :     return (Plan *) plan;
    1418             : }
    1419             : 
    1420             : /*
    1421             :  * set_subqueryscan_references
    1422             :  *      Do set_plan_references processing on a SubqueryScan
    1423             :  *
    1424             :  * We try to strip out the SubqueryScan entirely; if we can't, we have
    1425             :  * to do the normal processing on it.
    1426             :  */
    1427             : static Plan *
    1428       32550 : set_subqueryscan_references(PlannerInfo *root,
    1429             :                             SubqueryScan *plan,
    1430             :                             int rtoffset)
    1431             : {
    1432             :     RelOptInfo *rel;
    1433             :     Plan       *result;
    1434             : 
    1435             :     /* Need to look up the subquery's RelOptInfo, since we need its subroot */
    1436       32550 :     rel = find_base_rel(root, plan->scan.scanrelid);
    1437             : 
    1438             :     /* Recursively process the subplan */
    1439       32550 :     plan->subplan = set_plan_references(rel->subroot, plan->subplan);
    1440             : 
    1441       32550 :     if (trivial_subqueryscan(plan))
    1442             :     {
    1443             :         /*
    1444             :          * We can omit the SubqueryScan node and just pull up the subplan.
    1445             :          */
    1446       17012 :         result = clean_up_removed_plan_level((Plan *) plan, plan->subplan);
    1447             :     }
    1448             :     else
    1449             :     {
    1450             :         /*
    1451             :          * Keep the SubqueryScan node.  We have to do the processing that
    1452             :          * set_plan_references would otherwise have done on it.  Notice we do
    1453             :          * not do set_upper_references() here, because a SubqueryScan will
    1454             :          * always have been created with correct references to its subplan's
    1455             :          * outputs to begin with.
    1456             :          */
    1457       15538 :         plan->scan.scanrelid += rtoffset;
    1458       15538 :         plan->scan.plan.targetlist =
    1459       15538 :             fix_scan_list(root, plan->scan.plan.targetlist,
    1460             :                           rtoffset, NUM_EXEC_TLIST((Plan *) plan));
    1461       15538 :         plan->scan.plan.qual =
    1462       15538 :             fix_scan_list(root, plan->scan.plan.qual,
    1463             :                           rtoffset, NUM_EXEC_QUAL((Plan *) plan));
    1464             : 
    1465       15538 :         result = (Plan *) plan;
    1466             :     }
    1467             : 
    1468       32550 :     return result;
    1469             : }
    1470             : 
    1471             : /*
    1472             :  * trivial_subqueryscan
    1473             :  *      Detect whether a SubqueryScan can be deleted from the plan tree.
    1474             :  *
    1475             :  * We can delete it if it has no qual to check and the targetlist just
    1476             :  * regurgitates the output of the child plan.
    1477             :  *
    1478             :  * This can be called from mark_async_capable_plan(), a helper function for
    1479             :  * create_append_plan(), before set_subqueryscan_references(), to determine
    1480             :  * triviality of a SubqueryScan that is a child of an Append node.  So we
    1481             :  * cache the result in the SubqueryScan node to avoid repeated computation.
    1482             :  *
    1483             :  * Note: when called from mark_async_capable_plan(), we determine the result
    1484             :  * before running finalize_plan() on the SubqueryScan node (if needed) and
    1485             :  * set_plan_references() on the subplan tree, but this would be safe, because
    1486             :  * 1) finalize_plan() doesn't modify the tlist or quals for the SubqueryScan
    1487             :  *    node (or that for any plan node in the subplan tree), and
    1488             :  * 2) set_plan_references() modifies the tlist for every plan node in the
    1489             :  *    subplan tree, but keeps const/resjunk columns as const/resjunk ones and
    1490             :  *    preserves the length and order of the tlist, and
    1491             :  * 3) set_plan_references() might delete the topmost plan node like an Append
    1492             :  *    or MergeAppend from the subplan tree and pull up the child plan node,
    1493             :  *    but in that case, the tlist for the child plan node exactly matches the
    1494             :  *    parent.
    1495             :  */
    1496             : bool
    1497       43668 : trivial_subqueryscan(SubqueryScan *plan)
    1498             : {
    1499             :     int         attrno;
    1500             :     ListCell   *lp,
    1501             :                *lc;
    1502             : 
    1503             :     /* We might have detected this already; in which case reuse the result */
    1504       43668 :     if (plan->scanstatus == SUBQUERY_SCAN_TRIVIAL)
    1505        4506 :         return true;
    1506       39162 :     if (plan->scanstatus == SUBQUERY_SCAN_NONTRIVIAL)
    1507        6612 :         return false;
    1508             :     Assert(plan->scanstatus == SUBQUERY_SCAN_UNKNOWN);
    1509             :     /* Initially, mark the SubqueryScan as non-deletable from the plan tree */
    1510       32550 :     plan->scanstatus = SUBQUERY_SCAN_NONTRIVIAL;
    1511             : 
    1512       32550 :     if (plan->scan.plan.qual != NIL)
    1513         688 :         return false;
    1514             : 
    1515       63724 :     if (list_length(plan->scan.plan.targetlist) !=
    1516       31862 :         list_length(plan->subplan->targetlist))
    1517        6746 :         return false;           /* tlists not same length */
    1518             : 
    1519       25116 :     attrno = 1;
    1520       76078 :     forboth(lp, plan->scan.plan.targetlist, lc, plan->subplan->targetlist)
    1521             :     {
    1522       59066 :         TargetEntry *ptle = (TargetEntry *) lfirst(lp);
    1523       59066 :         TargetEntry *ctle = (TargetEntry *) lfirst(lc);
    1524             : 
    1525       59066 :         if (ptle->resjunk != ctle->resjunk)
    1526        8104 :             return false;       /* tlist doesn't match junk status */
    1527             : 
    1528             :         /*
    1529             :          * We accept either a Var referencing the corresponding element of the
    1530             :          * subplan tlist, or a Const equaling the subplan element. See
    1531             :          * generate_setop_tlist() for motivation.
    1532             :          */
    1533       59042 :         if (ptle->expr && IsA(ptle->expr, Var))
    1534       48540 :         {
    1535       48732 :             Var        *var = (Var *) ptle->expr;
    1536             : 
    1537             :             Assert(var->varno == plan->scan.scanrelid);
    1538             :             Assert(var->varlevelsup == 0);
    1539       48732 :             if (var->varattno != attrno)
    1540         192 :                 return false;   /* out of order */
    1541             :         }
    1542       10310 :         else if (ptle->expr && IsA(ptle->expr, Const))
    1543             :         {
    1544        8862 :             if (!equal(ptle->expr, ctle->expr))
    1545        6440 :                 return false;
    1546             :         }
    1547             :         else
    1548        1448 :             return false;
    1549             : 
    1550       50962 :         attrno++;
    1551             :     }
    1552             : 
    1553             :     /* Re-mark the SubqueryScan as deletable from the plan tree */
    1554       17012 :     plan->scanstatus = SUBQUERY_SCAN_TRIVIAL;
    1555             : 
    1556       17012 :     return true;
    1557             : }
    1558             : 
    1559             : /*
    1560             :  * clean_up_removed_plan_level
    1561             :  *      Do necessary cleanup when we strip out a SubqueryScan, Append, etc
    1562             :  *
    1563             :  * We are dropping the "parent" plan in favor of returning just its "child".
    1564             :  * A few small tweaks are needed.
    1565             :  */
    1566             : static Plan *
    1567       23506 : clean_up_removed_plan_level(Plan *parent, Plan *child)
    1568             : {
    1569             :     /*
    1570             :      * We have to be sure we don't lose any initplans, so move any that were
    1571             :      * attached to the parent plan to the child.  If any are parallel-unsafe,
    1572             :      * the child is no longer parallel-safe.  As a cosmetic matter, also add
    1573             :      * the initplans' run costs to the child's costs.
    1574             :      */
    1575       23506 :     if (parent->initPlan)
    1576             :     {
    1577             :         Cost        initplan_cost;
    1578             :         bool        unsafe_initplans;
    1579             : 
    1580          36 :         SS_compute_initplan_cost(parent->initPlan,
    1581             :                                  &initplan_cost, &unsafe_initplans);
    1582          36 :         child->startup_cost += initplan_cost;
    1583          36 :         child->total_cost += initplan_cost;
    1584          36 :         if (unsafe_initplans)
    1585          18 :             child->parallel_safe = false;
    1586             : 
    1587             :         /*
    1588             :          * Attach plans this way so that parent's initplans are processed
    1589             :          * before any pre-existing initplans of the child.  Probably doesn't
    1590             :          * matter, but let's preserve the ordering just in case.
    1591             :          */
    1592          36 :         child->initPlan = list_concat(parent->initPlan,
    1593          36 :                                       child->initPlan);
    1594             :     }
    1595             : 
    1596             :     /*
    1597             :      * We also have to transfer the parent's column labeling info into the
    1598             :      * child, else columns sent to client will be improperly labeled if this
    1599             :      * is the topmost plan level.  resjunk and so on may be important too.
    1600             :      */
    1601       23506 :     apply_tlist_labeling(child->targetlist, parent->targetlist);
    1602             : 
    1603       23506 :     return child;
    1604             : }
    1605             : 
    1606             : /*
    1607             :  * set_foreignscan_references
    1608             :  *     Do set_plan_references processing on a ForeignScan
    1609             :  */
    1610             : static void
    1611        2020 : set_foreignscan_references(PlannerInfo *root,
    1612             :                            ForeignScan *fscan,
    1613             :                            int rtoffset)
    1614             : {
    1615             :     /* Adjust scanrelid if it's valid */
    1616        2020 :     if (fscan->scan.scanrelid > 0)
    1617        1456 :         fscan->scan.scanrelid += rtoffset;
    1618             : 
    1619        2020 :     if (fscan->fdw_scan_tlist != NIL || fscan->scan.scanrelid == 0)
    1620         564 :     {
    1621             :         /*
    1622             :          * Adjust tlist, qual, fdw_exprs, fdw_recheck_quals to reference
    1623             :          * foreign scan tuple
    1624             :          */
    1625         564 :         indexed_tlist *itlist = build_tlist_index(fscan->fdw_scan_tlist);
    1626             : 
    1627         564 :         fscan->scan.plan.targetlist = (List *)
    1628         564 :             fix_upper_expr(root,
    1629         564 :                            (Node *) fscan->scan.plan.targetlist,
    1630             :                            itlist,
    1631             :                            INDEX_VAR,
    1632             :                            rtoffset,
    1633             :                            NRM_EQUAL,
    1634             :                            NUM_EXEC_TLIST((Plan *) fscan));
    1635         564 :         fscan->scan.plan.qual = (List *)
    1636         564 :             fix_upper_expr(root,
    1637         564 :                            (Node *) fscan->scan.plan.qual,
    1638             :                            itlist,
    1639             :                            INDEX_VAR,
    1640             :                            rtoffset,
    1641             :                            NRM_EQUAL,
    1642         564 :                            NUM_EXEC_QUAL((Plan *) fscan));
    1643         564 :         fscan->fdw_exprs = (List *)
    1644         564 :             fix_upper_expr(root,
    1645         564 :                            (Node *) fscan->fdw_exprs,
    1646             :                            itlist,
    1647             :                            INDEX_VAR,
    1648             :                            rtoffset,
    1649             :                            NRM_EQUAL,
    1650         564 :                            NUM_EXEC_QUAL((Plan *) fscan));
    1651         564 :         fscan->fdw_recheck_quals = (List *)
    1652         564 :             fix_upper_expr(root,
    1653         564 :                            (Node *) fscan->fdw_recheck_quals,
    1654             :                            itlist,
    1655             :                            INDEX_VAR,
    1656             :                            rtoffset,
    1657             :                            NRM_EQUAL,
    1658         564 :                            NUM_EXEC_QUAL((Plan *) fscan));
    1659         564 :         pfree(itlist);
    1660             :         /* fdw_scan_tlist itself just needs fix_scan_list() adjustments */
    1661         564 :         fscan->fdw_scan_tlist =
    1662         564 :             fix_scan_list(root, fscan->fdw_scan_tlist,
    1663             :                           rtoffset, NUM_EXEC_TLIST((Plan *) fscan));
    1664             :     }
    1665             :     else
    1666             :     {
    1667             :         /*
    1668             :          * Adjust tlist, qual, fdw_exprs, fdw_recheck_quals in the standard
    1669             :          * way
    1670             :          */
    1671        1456 :         fscan->scan.plan.targetlist =
    1672        1456 :             fix_scan_list(root, fscan->scan.plan.targetlist,
    1673             :                           rtoffset, NUM_EXEC_TLIST((Plan *) fscan));
    1674        1456 :         fscan->scan.plan.qual =
    1675        1456 :             fix_scan_list(root, fscan->scan.plan.qual,
    1676             :                           rtoffset, NUM_EXEC_QUAL((Plan *) fscan));
    1677        1456 :         fscan->fdw_exprs =
    1678        1456 :             fix_scan_list(root, fscan->fdw_exprs,
    1679             :                           rtoffset, NUM_EXEC_QUAL((Plan *) fscan));
    1680        1456 :         fscan->fdw_recheck_quals =
    1681        1456 :             fix_scan_list(root, fscan->fdw_recheck_quals,
    1682             :                           rtoffset, NUM_EXEC_QUAL((Plan *) fscan));
    1683             :     }
    1684             : 
    1685        2020 :     fscan->fs_relids = offset_relid_set(fscan->fs_relids, rtoffset);
    1686        2020 :     fscan->fs_base_relids = offset_relid_set(fscan->fs_base_relids, rtoffset);
    1687             : 
    1688             :     /* Adjust resultRelation if it's valid */
    1689        2020 :     if (fscan->resultRelation > 0)
    1690         208 :         fscan->resultRelation += rtoffset;
    1691        2020 : }
    1692             : 
    1693             : /*
    1694             :  * set_customscan_references
    1695             :  *     Do set_plan_references processing on a CustomScan
    1696             :  */
    1697             : static void
    1698           0 : set_customscan_references(PlannerInfo *root,
    1699             :                           CustomScan *cscan,
    1700             :                           int rtoffset)
    1701             : {
    1702             :     ListCell   *lc;
    1703             : 
    1704             :     /* Adjust scanrelid if it's valid */
    1705           0 :     if (cscan->scan.scanrelid > 0)
    1706           0 :         cscan->scan.scanrelid += rtoffset;
    1707             : 
    1708           0 :     if (cscan->custom_scan_tlist != NIL || cscan->scan.scanrelid == 0)
    1709           0 :     {
    1710             :         /* Adjust tlist, qual, custom_exprs to reference custom scan tuple */
    1711           0 :         indexed_tlist *itlist = build_tlist_index(cscan->custom_scan_tlist);
    1712             : 
    1713           0 :         cscan->scan.plan.targetlist = (List *)
    1714           0 :             fix_upper_expr(root,
    1715           0 :                            (Node *) cscan->scan.plan.targetlist,
    1716             :                            itlist,
    1717             :                            INDEX_VAR,
    1718             :                            rtoffset,
    1719             :                            NRM_EQUAL,
    1720             :                            NUM_EXEC_TLIST((Plan *) cscan));
    1721           0 :         cscan->scan.plan.qual = (List *)
    1722           0 :             fix_upper_expr(root,
    1723           0 :                            (Node *) cscan->scan.plan.qual,
    1724             :                            itlist,
    1725             :                            INDEX_VAR,
    1726             :                            rtoffset,
    1727             :                            NRM_EQUAL,
    1728           0 :                            NUM_EXEC_QUAL((Plan *) cscan));
    1729           0 :         cscan->custom_exprs = (List *)
    1730           0 :             fix_upper_expr(root,
    1731           0 :                            (Node *) cscan->custom_exprs,
    1732             :                            itlist,
    1733             :                            INDEX_VAR,
    1734             :                            rtoffset,
    1735             :                            NRM_EQUAL,
    1736           0 :                            NUM_EXEC_QUAL((Plan *) cscan));
    1737           0 :         pfree(itlist);
    1738             :         /* custom_scan_tlist itself just needs fix_scan_list() adjustments */
    1739           0 :         cscan->custom_scan_tlist =
    1740           0 :             fix_scan_list(root, cscan->custom_scan_tlist,
    1741             :                           rtoffset, NUM_EXEC_TLIST((Plan *) cscan));
    1742             :     }
    1743             :     else
    1744             :     {
    1745             :         /* Adjust tlist, qual, custom_exprs in the standard way */
    1746           0 :         cscan->scan.plan.targetlist =
    1747           0 :             fix_scan_list(root, cscan->scan.plan.targetlist,
    1748             :                           rtoffset, NUM_EXEC_TLIST((Plan *) cscan));
    1749           0 :         cscan->scan.plan.qual =
    1750           0 :             fix_scan_list(root, cscan->scan.plan.qual,
    1751             :                           rtoffset, NUM_EXEC_QUAL((Plan *) cscan));
    1752           0 :         cscan->custom_exprs =
    1753           0 :             fix_scan_list(root, cscan->custom_exprs,
    1754             :                           rtoffset, NUM_EXEC_QUAL((Plan *) cscan));
    1755             :     }
    1756             : 
    1757             :     /* Adjust child plan-nodes recursively, if needed */
    1758           0 :     foreach(lc, cscan->custom_plans)
    1759             :     {
    1760           0 :         lfirst(lc) = set_plan_refs(root, (Plan *) lfirst(lc), rtoffset);
    1761             :     }
    1762             : 
    1763           0 :     cscan->custom_relids = offset_relid_set(cscan->custom_relids, rtoffset);
    1764           0 : }
    1765             : 
    1766             : /*
    1767             :  * register_partpruneinfo
    1768             :  *      Subroutine for set_append_references and set_mergeappend_references
    1769             :  *
    1770             :  * Add the PartitionPruneInfo from root->partPruneInfos at the given index
    1771             :  * into PlannerGlobal->partPruneInfos and return its index there.
    1772             :  *
    1773             :  * Also update the RT indexes present in PartitionedRelPruneInfos to add the
    1774             :  * offset.
    1775             :  *
    1776             :  * Finally, if there are initial pruning steps, add the RT indexes of the
    1777             :  * leaf partitions to the set of relations that are prunable at execution
    1778             :  * startup time.
    1779             :  */
    1780             : static int
    1781         554 : register_partpruneinfo(PlannerInfo *root, int part_prune_index, int rtoffset)
    1782             : {
    1783         554 :     PlannerGlobal *glob = root->glob;
    1784             :     PartitionPruneInfo *pinfo;
    1785             :     ListCell   *l;
    1786             : 
    1787             :     Assert(part_prune_index >= 0 &&
    1788             :            part_prune_index < list_length(root->partPruneInfos));
    1789         554 :     pinfo = list_nth_node(PartitionPruneInfo, root->partPruneInfos,
    1790             :                           part_prune_index);
    1791             : 
    1792         554 :     pinfo->relids = offset_relid_set(pinfo->relids, rtoffset);
    1793        1120 :     foreach(l, pinfo->prune_infos)
    1794             :     {
    1795         566 :         List       *prune_infos = lfirst(l);
    1796             :         ListCell   *l2;
    1797             : 
    1798        1534 :         foreach(l2, prune_infos)
    1799             :         {
    1800         968 :             PartitionedRelPruneInfo *prelinfo = lfirst(l2);
    1801             :             int         i;
    1802             : 
    1803         968 :             prelinfo->rtindex += rtoffset;
    1804         968 :             prelinfo->initial_pruning_steps =
    1805         968 :                 fix_scan_list(root, prelinfo->initial_pruning_steps,
    1806             :                               rtoffset, 1);
    1807         968 :             prelinfo->exec_pruning_steps =
    1808         968 :                 fix_scan_list(root, prelinfo->exec_pruning_steps,
    1809             :                               rtoffset, 1);
    1810             : 
    1811        3834 :             for (i = 0; i < prelinfo->nparts; i++)
    1812             :             {
    1813             :                 /*
    1814             :                  * Non-leaf partitions and partitions that do not have a
    1815             :                  * subplan are not included in this map as mentioned in
    1816             :                  * make_partitionedrel_pruneinfo().
    1817             :                  */
    1818        2866 :                 if (prelinfo->leafpart_rti_map[i])
    1819             :                 {
    1820        2322 :                     prelinfo->leafpart_rti_map[i] += rtoffset;
    1821        2322 :                     if (prelinfo->initial_pruning_steps)
    1822         736 :                         glob->prunableRelids = bms_add_member(glob->prunableRelids,
    1823         736 :                                                               prelinfo->leafpart_rti_map[i]);
    1824             :                 }
    1825             :             }
    1826             :         }
    1827             :     }
    1828             : 
    1829         554 :     glob->partPruneInfos = lappend(glob->partPruneInfos, pinfo);
    1830             : 
    1831         554 :     return list_length(glob->partPruneInfos) - 1;
    1832             : }
    1833             : 
    1834             : /*
    1835             :  * set_append_references
    1836             :  *      Do set_plan_references processing on an Append
    1837             :  *
    1838             :  * We try to strip out the Append entirely; if we can't, we have
    1839             :  * to do the normal processing on it.
    1840             :  */
    1841             : static Plan *
    1842       23906 : set_append_references(PlannerInfo *root,
    1843             :                       Append *aplan,
    1844             :                       int rtoffset)
    1845             : {
    1846             :     ListCell   *l;
    1847             : 
    1848             :     /*
    1849             :      * Append, like Sort et al, doesn't actually evaluate its targetlist or
    1850             :      * check quals.  If it's got exactly one child plan, then it's not doing
    1851             :      * anything useful at all, and we can strip it out.
    1852             :      */
    1853             :     Assert(aplan->plan.qual == NIL);
    1854             : 
    1855             :     /* First, we gotta recurse on the children */
    1856       83022 :     foreach(l, aplan->appendplans)
    1857             :     {
    1858       59116 :         lfirst(l) = set_plan_refs(root, (Plan *) lfirst(l), rtoffset);
    1859             :     }
    1860             : 
    1861             :     /*
    1862             :      * See if it's safe to get rid of the Append entirely.  For this to be
    1863             :      * safe, there must be only one child plan and that child plan's parallel
    1864             :      * awareness must match the Append's.  The reason for the latter is that
    1865             :      * if the Append is parallel aware and the child is not, then the calling
    1866             :      * plan may execute the non-parallel aware child multiple times.  (If you
    1867             :      * change these rules, update create_append_path to match.)
    1868             :      */
    1869       23906 :     if (list_length(aplan->appendplans) == 1)
    1870             :     {
    1871        6490 :         Plan       *p = (Plan *) linitial(aplan->appendplans);
    1872             : 
    1873        6490 :         if (p->parallel_aware == aplan->plan.parallel_aware)
    1874        6490 :             return clean_up_removed_plan_level((Plan *) aplan, p);
    1875             :     }
    1876             : 
    1877             :     /*
    1878             :      * Otherwise, clean up the Append as needed.  It's okay to do this after
    1879             :      * recursing to the children, because set_dummy_tlist_references doesn't
    1880             :      * look at those.
    1881             :      */
    1882       17416 :     set_dummy_tlist_references((Plan *) aplan, rtoffset);
    1883             : 
    1884       17416 :     aplan->apprelids = offset_relid_set(aplan->apprelids, rtoffset);
    1885             : 
    1886             :     /*
    1887             :      * Add PartitionPruneInfo, if any, to PlannerGlobal and update the index.
    1888             :      * Also update the RT indexes present in it to add the offset.
    1889             :      */
    1890       17416 :     if (aplan->part_prune_index >= 0)
    1891         518 :         aplan->part_prune_index =
    1892         518 :             register_partpruneinfo(root, aplan->part_prune_index, rtoffset);
    1893             : 
    1894             :     /* We don't need to recurse to lefttree or righttree ... */
    1895             :     Assert(aplan->plan.lefttree == NULL);
    1896             :     Assert(aplan->plan.righttree == NULL);
    1897             : 
    1898       17416 :     return (Plan *) aplan;
    1899             : }
    1900             : 
    1901             : /*
    1902             :  * set_mergeappend_references
    1903             :  *      Do set_plan_references processing on a MergeAppend
    1904             :  *
    1905             :  * We try to strip out the MergeAppend entirely; if we can't, we have
    1906             :  * to do the normal processing on it.
    1907             :  */
    1908             : static Plan *
    1909         566 : set_mergeappend_references(PlannerInfo *root,
    1910             :                            MergeAppend *mplan,
    1911             :                            int rtoffset)
    1912             : {
    1913             :     ListCell   *l;
    1914             : 
    1915             :     /*
    1916             :      * MergeAppend, like Sort et al, doesn't actually evaluate its targetlist
    1917             :      * or check quals.  If it's got exactly one child plan, then it's not
    1918             :      * doing anything useful at all, and we can strip it out.
    1919             :      */
    1920             :     Assert(mplan->plan.qual == NIL);
    1921             : 
    1922             :     /* First, we gotta recurse on the children */
    1923        2152 :     foreach(l, mplan->mergeplans)
    1924             :     {
    1925        1586 :         lfirst(l) = set_plan_refs(root, (Plan *) lfirst(l), rtoffset);
    1926             :     }
    1927             : 
    1928             :     /*
    1929             :      * See if it's safe to get rid of the MergeAppend entirely.  For this to
    1930             :      * be safe, there must be only one child plan and that child plan's
    1931             :      * parallel awareness must match the MergeAppend's.  The reason for the
    1932             :      * latter is that if the MergeAppend is parallel aware and the child is
    1933             :      * not, then the calling plan may execute the non-parallel aware child
    1934             :      * multiple times.  (If you change these rules, update
    1935             :      * create_merge_append_path to match.)
    1936             :      */
    1937         566 :     if (list_length(mplan->mergeplans) == 1)
    1938             :     {
    1939           4 :         Plan       *p = (Plan *) linitial(mplan->mergeplans);
    1940             : 
    1941           4 :         if (p->parallel_aware == mplan->plan.parallel_aware)
    1942           4 :             return clean_up_removed_plan_level((Plan *) mplan, p);
    1943             :     }
    1944             : 
    1945             :     /*
    1946             :      * Otherwise, clean up the MergeAppend as needed.  It's okay to do this
    1947             :      * after recursing to the children, because set_dummy_tlist_references
    1948             :      * doesn't look at those.
    1949             :      */
    1950         562 :     set_dummy_tlist_references((Plan *) mplan, rtoffset);
    1951             : 
    1952         562 :     mplan->apprelids = offset_relid_set(mplan->apprelids, rtoffset);
    1953             : 
    1954             :     /*
    1955             :      * Add PartitionPruneInfo, if any, to PlannerGlobal and update the index.
    1956             :      * Also update the RT indexes present in it to add the offset.
    1957             :      */
    1958         562 :     if (mplan->part_prune_index >= 0)
    1959          36 :         mplan->part_prune_index =
    1960          36 :             register_partpruneinfo(root, mplan->part_prune_index, rtoffset);
    1961             : 
    1962             :     /* We don't need to recurse to lefttree or righttree ... */
    1963             :     Assert(mplan->plan.lefttree == NULL);
    1964             :     Assert(mplan->plan.righttree == NULL);
    1965             : 
    1966         562 :     return (Plan *) mplan;
    1967             : }
    1968             : 
    1969             : /*
    1970             :  * set_hash_references
    1971             :  *     Do set_plan_references processing on a Hash node
    1972             :  */
    1973             : static void
    1974       34638 : set_hash_references(PlannerInfo *root, Plan *plan, int rtoffset)
    1975             : {
    1976       34638 :     Hash       *hplan = (Hash *) plan;
    1977       34638 :     Plan       *outer_plan = plan->lefttree;
    1978             :     indexed_tlist *outer_itlist;
    1979             : 
    1980             :     /*
    1981             :      * Hash's hashkeys are used when feeding tuples into the hashtable,
    1982             :      * therefore have them reference Hash's outer plan (which itself is the
    1983             :      * inner plan of the HashJoin).
    1984             :      */
    1985       34638 :     outer_itlist = build_tlist_index(outer_plan->targetlist);
    1986       34638 :     hplan->hashkeys = (List *)
    1987       34638 :         fix_upper_expr(root,
    1988       34638 :                        (Node *) hplan->hashkeys,
    1989             :                        outer_itlist,
    1990             :                        OUTER_VAR,
    1991             :                        rtoffset,
    1992             :                        NRM_EQUAL,
    1993       34638 :                        NUM_EXEC_QUAL(plan));
    1994             : 
    1995             :     /* Hash doesn't project */
    1996       34638 :     set_dummy_tlist_references(plan, rtoffset);
    1997             : 
    1998             :     /* Hash nodes don't have their own quals */
    1999             :     Assert(plan->qual == NIL);
    2000       34638 : }
    2001             : 
    2002             : /*
    2003             :  * offset_relid_set
    2004             :  *      Apply rtoffset to the members of a Relids set.
    2005             :  */
    2006             : static Relids
    2007      236628 : offset_relid_set(Relids relids, int rtoffset)
    2008             : {
    2009      236628 :     Relids      result = NULL;
    2010             :     int         rtindex;
    2011             : 
    2012             :     /* If there's no offset to apply, we needn't recompute the value */
    2013      236628 :     if (rtoffset == 0)
    2014      216310 :         return relids;
    2015       20318 :     rtindex = -1;
    2016       30972 :     while ((rtindex = bms_next_member(relids, rtindex)) >= 0)
    2017       10654 :         result = bms_add_member(result, rtindex + rtoffset);
    2018       20318 :     return result;
    2019             : }
    2020             : 
    2021             : /*
    2022             :  * copyVar
    2023             :  *      Copy a Var node.
    2024             :  *
    2025             :  * fix_scan_expr and friends do this enough times that it's worth having
    2026             :  * a bespoke routine instead of using the generic copyObject() function.
    2027             :  */
    2028             : static inline Var *
    2029     2074490 : copyVar(Var *var)
    2030             : {
    2031     2074490 :     Var        *newvar = (Var *) palloc(sizeof(Var));
    2032             : 
    2033     2074490 :     *newvar = *var;
    2034     2074490 :     return newvar;
    2035             : }
    2036             : 
    2037             : /*
    2038             :  * fix_expr_common
    2039             :  *      Do generic set_plan_references processing on an expression node
    2040             :  *
    2041             :  * This is code that is common to all variants of expression-fixing.
    2042             :  * We must look up operator opcode info for OpExpr and related nodes,
    2043             :  * add OIDs from regclass Const nodes into root->glob->relationOids, and
    2044             :  * add PlanInvalItems for user-defined functions into root->glob->invalItems.
    2045             :  * We also fill in column index lists for GROUPING() expressions.
    2046             :  *
    2047             :  * We assume it's okay to update opcode info in-place.  So this could possibly
    2048             :  * scribble on the planner's input data structures, but it's OK.
    2049             :  */
    2050             : static void
    2051    14173600 : fix_expr_common(PlannerInfo *root, Node *node)
    2052             : {
    2053             :     /* We assume callers won't call us on a NULL pointer */
    2054    14173600 :     if (IsA(node, Aggref))
    2055             :     {
    2056       55992 :         record_plan_function_dependency(root,
    2057             :                                         ((Aggref *) node)->aggfnoid);
    2058             :     }
    2059    14117608 :     else if (IsA(node, WindowFunc))
    2060             :     {
    2061        3878 :         record_plan_function_dependency(root,
    2062             :                                         ((WindowFunc *) node)->winfnoid);
    2063             :     }
    2064    14113730 :     else if (IsA(node, FuncExpr))
    2065             :     {
    2066      301616 :         record_plan_function_dependency(root,
    2067             :                                         ((FuncExpr *) node)->funcid);
    2068             :     }
    2069    13812114 :     else if (IsA(node, OpExpr))
    2070             :     {
    2071      854034 :         set_opfuncid((OpExpr *) node);
    2072      854034 :         record_plan_function_dependency(root,
    2073             :                                         ((OpExpr *) node)->opfuncid);
    2074             :     }
    2075    12958080 :     else if (IsA(node, DistinctExpr))
    2076             :     {
    2077        1074 :         set_opfuncid((OpExpr *) node);  /* rely on struct equivalence */
    2078        1074 :         record_plan_function_dependency(root,
    2079             :                                         ((DistinctExpr *) node)->opfuncid);
    2080             :     }
    2081    12957006 :     else if (IsA(node, NullIfExpr))
    2082             :     {
    2083         130 :         set_opfuncid((OpExpr *) node);  /* rely on struct equivalence */
    2084         130 :         record_plan_function_dependency(root,
    2085             :                                         ((NullIfExpr *) node)->opfuncid);
    2086             :     }
    2087    12956876 :     else if (IsA(node, ScalarArrayOpExpr))
    2088             :     {
    2089       38044 :         ScalarArrayOpExpr *saop = (ScalarArrayOpExpr *) node;
    2090             : 
    2091       38044 :         set_sa_opfuncid(saop);
    2092       38044 :         record_plan_function_dependency(root, saop->opfuncid);
    2093             : 
    2094       38044 :         if (OidIsValid(saop->hashfuncid))
    2095         664 :             record_plan_function_dependency(root, saop->hashfuncid);
    2096             : 
    2097       38044 :         if (OidIsValid(saop->negfuncid))
    2098          70 :             record_plan_function_dependency(root, saop->negfuncid);
    2099             :     }
    2100    12918832 :     else if (IsA(node, Const))
    2101             :     {
    2102     1398874 :         Const      *con = (Const *) node;
    2103             : 
    2104             :         /* Check for regclass reference */
    2105     1398874 :         if (ISREGCLASSCONST(con))
    2106      263464 :             root->glob->relationOids =
    2107      263464 :                 lappend_oid(root->glob->relationOids,
    2108             :                             DatumGetObjectId(con->constvalue));
    2109             :     }
    2110    11519958 :     else if (IsA(node, GroupingFunc))
    2111             :     {
    2112         350 :         GroupingFunc *g = (GroupingFunc *) node;
    2113         350 :         AttrNumber *grouping_map = root->grouping_map;
    2114             : 
    2115             :         /* If there are no grouping sets, we don't need this. */
    2116             : 
    2117             :         Assert(grouping_map || g->cols == NIL);
    2118             : 
    2119         350 :         if (grouping_map)
    2120             :         {
    2121             :             ListCell   *lc;
    2122         260 :             List       *cols = NIL;
    2123             : 
    2124         684 :             foreach(lc, g->refs)
    2125             :             {
    2126         424 :                 cols = lappend_int(cols, grouping_map[lfirst_int(lc)]);
    2127             :             }
    2128             : 
    2129             :             Assert(!g->cols || equal(cols, g->cols));
    2130             : 
    2131         260 :             if (!g->cols)
    2132         260 :                 g->cols = cols;
    2133             :         }
    2134             :     }
    2135    14173600 : }
    2136             : 
    2137             : /*
    2138             :  * fix_param_node
    2139             :  *      Do set_plan_references processing on a Param
    2140             :  *
    2141             :  * If it's a PARAM_MULTIEXPR, replace it with the appropriate Param from
    2142             :  * root->multiexpr_params; otherwise no change is needed.
    2143             :  * Just for paranoia's sake, we make a copy of the node in either case.
    2144             :  */
    2145             : static Node *
    2146      108752 : fix_param_node(PlannerInfo *root, Param *p)
    2147             : {
    2148      108752 :     if (p->paramkind == PARAM_MULTIEXPR)
    2149             :     {
    2150         286 :         int         subqueryid = p->paramid >> 16;
    2151         286 :         int         colno = p->paramid & 0xFFFF;
    2152             :         List       *params;
    2153             : 
    2154         572 :         if (subqueryid <= 0 ||
    2155         286 :             subqueryid > list_length(root->multiexpr_params))
    2156           0 :             elog(ERROR, "unexpected PARAM_MULTIEXPR ID: %d", p->paramid);
    2157         286 :         params = (List *) list_nth(root->multiexpr_params, subqueryid - 1);
    2158         286 :         if (colno <= 0 || colno > list_length(params))
    2159           0 :             elog(ERROR, "unexpected PARAM_MULTIEXPR ID: %d", p->paramid);
    2160         286 :         return copyObject(list_nth(params, colno - 1));
    2161             :     }
    2162      108466 :     return (Node *) copyObject(p);
    2163             : }
    2164             : 
    2165             : /*
    2166             :  * fix_alternative_subplan
    2167             :  *      Do set_plan_references processing on an AlternativeSubPlan
    2168             :  *
    2169             :  * Choose one of the alternative implementations and return just that one,
    2170             :  * discarding the rest of the AlternativeSubPlan structure.
    2171             :  * Note: caller must still recurse into the result!
    2172             :  *
    2173             :  * We don't make any attempt to fix up cost estimates in the parent plan
    2174             :  * node or higher-level nodes.
    2175             :  */
    2176             : static Node *
    2177        1816 : fix_alternative_subplan(PlannerInfo *root, AlternativeSubPlan *asplan,
    2178             :                         double num_exec)
    2179             : {
    2180        1816 :     SubPlan    *bestplan = NULL;
    2181        1816 :     Cost        bestcost = 0;
    2182             :     ListCell   *lc;
    2183             : 
    2184             :     /*
    2185             :      * Compute the estimated cost of each subplan assuming num_exec
    2186             :      * executions, and keep the cheapest one.  In event of exact equality of
    2187             :      * estimates, we prefer the later plan; this is a bit arbitrary, but in
    2188             :      * current usage it biases us to break ties against fast-start subplans.
    2189             :      */
    2190             :     Assert(asplan->subplans != NIL);
    2191             : 
    2192        5448 :     foreach(lc, asplan->subplans)
    2193             :     {
    2194        3632 :         SubPlan    *curplan = (SubPlan *) lfirst(lc);
    2195             :         Cost        curcost;
    2196             : 
    2197        3632 :         curcost = curplan->startup_cost + num_exec * curplan->per_call_cost;
    2198        3632 :         if (bestplan == NULL || curcost <= bestcost)
    2199             :         {
    2200        2552 :             bestplan = curplan;
    2201        2552 :             bestcost = curcost;
    2202             :         }
    2203             : 
    2204             :         /* Also mark all subplans that are in AlternativeSubPlans */
    2205        3632 :         root->isAltSubplan[curplan->plan_id - 1] = true;
    2206             :     }
    2207             : 
    2208             :     /* Mark the subplan we selected */
    2209        1816 :     root->isUsedSubplan[bestplan->plan_id - 1] = true;
    2210             : 
    2211        1816 :     return (Node *) bestplan;
    2212             : }
    2213             : 
    2214             : /*
    2215             :  * fix_scan_expr
    2216             :  *      Do set_plan_references processing on a scan-level expression
    2217             :  *
    2218             :  * This consists of incrementing all Vars' varnos by rtoffset,
    2219             :  * replacing PARAM_MULTIEXPR Params, expanding PlaceHolderVars,
    2220             :  * replacing Aggref nodes that should be replaced by initplan output Params,
    2221             :  * choosing the best implementation for AlternativeSubPlans,
    2222             :  * looking up operator opcode info for OpExpr and related nodes,
    2223             :  * and adding OIDs from regclass Const nodes into root->glob->relationOids.
    2224             :  *
    2225             :  * 'node': the expression to be modified
    2226             :  * 'rtoffset': how much to increment varnos by
    2227             :  * 'num_exec': estimated number of executions of expression
    2228             :  *
    2229             :  * The expression tree is either copied-and-modified, or modified in-place
    2230             :  * if that seems safe.
    2231             :  */
    2232             : static Node *
    2233     2413164 : fix_scan_expr(PlannerInfo *root, Node *node, int rtoffset, double num_exec)
    2234             : {
    2235             :     fix_scan_expr_context context;
    2236             : 
    2237     2413164 :     context.root = root;
    2238     2413164 :     context.rtoffset = rtoffset;
    2239     2413164 :     context.num_exec = num_exec;
    2240             : 
    2241     2413164 :     if (rtoffset != 0 ||
    2242     2019752 :         root->multiexpr_params != NIL ||
    2243     2019170 :         root->glob->lastPHId != 0 ||
    2244     2008534 :         root->minmax_aggs != NIL ||
    2245     2007760 :         root->hasAlternativeSubPlans)
    2246             :     {
    2247      418734 :         return fix_scan_expr_mutator(node, &context);
    2248             :     }
    2249             :     else
    2250             :     {
    2251             :         /*
    2252             :          * If rtoffset == 0, we don't need to change any Vars, and if there
    2253             :          * are no MULTIEXPR subqueries then we don't need to replace
    2254             :          * PARAM_MULTIEXPR Params, and if there are no placeholders anywhere
    2255             :          * we won't need to remove them, and if there are no minmax Aggrefs we
    2256             :          * won't need to replace them, and if there are no AlternativeSubPlans
    2257             :          * we won't need to remove them.  Then it's OK to just scribble on the
    2258             :          * input node tree instead of copying (since the only change, filling
    2259             :          * in any unset opfuncid fields, is harmless).  This saves just enough
    2260             :          * cycles to be noticeable on trivial queries.
    2261             :          */
    2262     1994430 :         (void) fix_scan_expr_walker(node, &context);
    2263     1994430 :         return node;
    2264             :     }
    2265             : }
    2266             : 
    2267             : static Node *
    2268     2613908 : fix_scan_expr_mutator(Node *node, fix_scan_expr_context *context)
    2269             : {
    2270     2613908 :     if (node == NULL)
    2271      164614 :         return NULL;
    2272     2449294 :     if (IsA(node, Var))
    2273             :     {
    2274      855206 :         Var        *var = copyVar((Var *) node);
    2275             : 
    2276             :         Assert(var->varlevelsup == 0);
    2277             : 
    2278             :         /*
    2279             :          * We should not see Vars marked INNER_VAR, OUTER_VAR, or ROWID_VAR.
    2280             :          * But an indexqual expression could contain INDEX_VAR Vars.
    2281             :          */
    2282             :         Assert(var->varno != INNER_VAR);
    2283             :         Assert(var->varno != OUTER_VAR);
    2284             :         Assert(var->varno != ROWID_VAR);
    2285      855206 :         if (!IS_SPECIAL_VARNO(var->varno))
    2286      807346 :             var->varno += context->rtoffset;
    2287      855206 :         if (var->varnosyn > 0)
    2288      854270 :             var->varnosyn += context->rtoffset;
    2289      855206 :         return (Node *) var;
    2290             :     }
    2291     1594088 :     if (IsA(node, Param))
    2292       93482 :         return fix_param_node(context->root, (Param *) node);
    2293     1500606 :     if (IsA(node, Aggref))
    2294             :     {
    2295         442 :         Aggref     *aggref = (Aggref *) node;
    2296             :         Param      *aggparam;
    2297             : 
    2298             :         /* See if the Aggref should be replaced by a Param */
    2299         442 :         aggparam = find_minmax_agg_replacement_param(context->root, aggref);
    2300         442 :         if (aggparam != NULL)
    2301             :         {
    2302             :             /* Make a copy of the Param for paranoia's sake */
    2303         412 :             return (Node *) copyObject(aggparam);
    2304             :         }
    2305             :         /* If no match, just fall through to process it normally */
    2306             :     }
    2307     1500194 :     if (IsA(node, CurrentOfExpr))
    2308             :     {
    2309           0 :         CurrentOfExpr *cexpr = (CurrentOfExpr *) copyObject(node);
    2310             : 
    2311             :         Assert(!IS_SPECIAL_VARNO(cexpr->cvarno));
    2312           0 :         cexpr->cvarno += context->rtoffset;
    2313           0 :         return (Node *) cexpr;
    2314             :     }
    2315     1500194 :     if (IsA(node, PlaceHolderVar))
    2316             :     {
    2317             :         /* At scan level, we should always just evaluate the contained expr */
    2318        2466 :         PlaceHolderVar *phv = (PlaceHolderVar *) node;
    2319             : 
    2320             :         /* XXX can we assert something about phnullingrels? */
    2321        2466 :         return fix_scan_expr_mutator((Node *) phv->phexpr, context);
    2322             :     }
    2323     1497728 :     if (IsA(node, AlternativeSubPlan))
    2324         294 :         return fix_scan_expr_mutator(fix_alternative_subplan(context->root,
    2325             :                                                              (AlternativeSubPlan *) node,
    2326             :                                                              context->num_exec),
    2327             :                                      context);
    2328     1497434 :     fix_expr_common(context->root, node);
    2329     1497434 :     return expression_tree_mutator(node, fix_scan_expr_mutator, context);
    2330             : }
    2331             : 
    2332             : static bool
    2333    10708278 : fix_scan_expr_walker(Node *node, fix_scan_expr_context *context)
    2334             : {
    2335    10708278 :     if (node == NULL)
    2336     1017722 :         return false;
    2337             :     Assert(!(IsA(node, Var) && ((Var *) node)->varno == ROWID_VAR));
    2338             :     Assert(!IsA(node, PlaceHolderVar));
    2339             :     Assert(!IsA(node, AlternativeSubPlan));
    2340     9690556 :     fix_expr_common(context->root, node);
    2341     9690556 :     return expression_tree_walker(node, fix_scan_expr_walker, context);
    2342             : }
    2343             : 
    2344             : /*
    2345             :  * set_join_references
    2346             :  *    Modify the target list and quals of a join node to reference its
    2347             :  *    subplans, by setting the varnos to OUTER_VAR or INNER_VAR and setting
    2348             :  *    attno values to the result domain number of either the corresponding
    2349             :  *    outer or inner join tuple item.  Also perform opcode lookup for these
    2350             :  *    expressions, and add regclass OIDs to root->glob->relationOids.
    2351             :  */
    2352             : static void
    2353      139866 : set_join_references(PlannerInfo *root, Join *join, int rtoffset)
    2354             : {
    2355      139866 :     Plan       *outer_plan = join->plan.lefttree;
    2356      139866 :     Plan       *inner_plan = join->plan.righttree;
    2357             :     indexed_tlist *outer_itlist;
    2358             :     indexed_tlist *inner_itlist;
    2359             : 
    2360      139866 :     outer_itlist = build_tlist_index(outer_plan->targetlist);
    2361      139866 :     inner_itlist = build_tlist_index(inner_plan->targetlist);
    2362             : 
    2363             :     /*
    2364             :      * First process the joinquals (including merge or hash clauses).  These
    2365             :      * are logically below the join so they can always use all values
    2366             :      * available from the input tlists.  It's okay to also handle
    2367             :      * NestLoopParams now, because those couldn't refer to nullable
    2368             :      * subexpressions.
    2369             :      */
    2370      279732 :     join->joinqual = fix_join_expr(root,
    2371             :                                    join->joinqual,
    2372             :                                    outer_itlist,
    2373             :                                    inner_itlist,
    2374             :                                    (Index) 0,
    2375             :                                    rtoffset,
    2376             :                                    NRM_EQUAL,
    2377      139866 :                                    NUM_EXEC_QUAL((Plan *) join));
    2378             : 
    2379             :     /* Now do join-type-specific stuff */
    2380      139866 :     if (IsA(join, NestLoop))
    2381             :     {
    2382       97488 :         NestLoop   *nl = (NestLoop *) join;
    2383             :         ListCell   *lc;
    2384             : 
    2385      152322 :         foreach(lc, nl->nestParams)
    2386             :         {
    2387       54834 :             NestLoopParam *nlp = (NestLoopParam *) lfirst(lc);
    2388             : 
    2389             :             /*
    2390             :              * Because we don't reparameterize parameterized paths to match
    2391             :              * the outer-join level at which they are used, Vars seen in the
    2392             :              * NestLoopParam expression may have nullingrels that are just a
    2393             :              * subset of those in the Vars actually available from the outer
    2394             :              * side.  (Lateral references can also cause this, as explained in
    2395             :              * the comments for identify_current_nestloop_params.)  Not
    2396             :              * checking this exactly is a bit grotty, but the work needed to
    2397             :              * make things match up perfectly seems well out of proportion to
    2398             :              * the value.
    2399             :              */
    2400      109668 :             nlp->paramval = (Var *) fix_upper_expr(root,
    2401       54834 :                                                    (Node *) nlp->paramval,
    2402             :                                                    outer_itlist,
    2403             :                                                    OUTER_VAR,
    2404             :                                                    rtoffset,
    2405             :                                                    NRM_SUBSET,
    2406             :                                                    NUM_EXEC_TLIST(outer_plan));
    2407             :             /* Check we replaced any PlaceHolderVar with simple Var */
    2408       54834 :             if (!(IsA(nlp->paramval, Var) &&
    2409       54834 :                   nlp->paramval->varno == OUTER_VAR))
    2410           0 :                 elog(ERROR, "NestLoopParam was not reduced to a simple Var");
    2411             :         }
    2412             :     }
    2413       42378 :     else if (IsA(join, MergeJoin))
    2414             :     {
    2415        7740 :         MergeJoin  *mj = (MergeJoin *) join;
    2416             : 
    2417        7740 :         mj->mergeclauses = fix_join_expr(root,
    2418             :                                          mj->mergeclauses,
    2419             :                                          outer_itlist,
    2420             :                                          inner_itlist,
    2421             :                                          (Index) 0,
    2422             :                                          rtoffset,
    2423             :                                          NRM_EQUAL,
    2424        7740 :                                          NUM_EXEC_QUAL((Plan *) join));
    2425             :     }
    2426       34638 :     else if (IsA(join, HashJoin))
    2427             :     {
    2428       34638 :         HashJoin   *hj = (HashJoin *) join;
    2429             : 
    2430       69276 :         hj->hashclauses = fix_join_expr(root,
    2431             :                                         hj->hashclauses,
    2432             :                                         outer_itlist,
    2433             :                                         inner_itlist,
    2434             :                                         (Index) 0,
    2435             :                                         rtoffset,
    2436             :                                         NRM_EQUAL,
    2437       34638 :                                         NUM_EXEC_QUAL((Plan *) join));
    2438             : 
    2439             :         /*
    2440             :          * HashJoin's hashkeys are used to look for matching tuples from its
    2441             :          * outer plan (not the Hash node!) in the hashtable.
    2442             :          */
    2443       34638 :         hj->hashkeys = (List *) fix_upper_expr(root,
    2444       34638 :                                                (Node *) hj->hashkeys,
    2445             :                                                outer_itlist,
    2446             :                                                OUTER_VAR,
    2447             :                                                rtoffset,
    2448             :                                                NRM_EQUAL,
    2449       34638 :                                                NUM_EXEC_QUAL((Plan *) join));
    2450             :     }
    2451             : 
    2452             :     /*
    2453             :      * Now we need to fix up the targetlist and qpqual, which are logically
    2454             :      * above the join.  This means that, if it's not an inner join, any Vars
    2455             :      * and PHVs appearing here should have nullingrels that include the
    2456             :      * effects of the outer join, ie they will have nullingrels equal to the
    2457             :      * input Vars' nullingrels plus the bit added by the outer join.  We don't
    2458             :      * currently have enough info available here to identify what that should
    2459             :      * be, so we just tell fix_join_expr to accept superset nullingrels
    2460             :      * matches instead of exact ones.
    2461             :      */
    2462      139866 :     join->plan.targetlist = fix_join_expr(root,
    2463             :                                           join->plan.targetlist,
    2464             :                                           outer_itlist,
    2465             :                                           inner_itlist,
    2466             :                                           (Index) 0,
    2467             :                                           rtoffset,
    2468      139866 :                                           (join->jointype == JOIN_INNER ? NRM_EQUAL : NRM_SUPERSET),
    2469             :                                           NUM_EXEC_TLIST((Plan *) join));
    2470      139866 :     join->plan.qual = fix_join_expr(root,
    2471             :                                     join->plan.qual,
    2472             :                                     outer_itlist,
    2473             :                                     inner_itlist,
    2474             :                                     (Index) 0,
    2475             :                                     rtoffset,
    2476      139866 :                                     (join->jointype == JOIN_INNER ? NRM_EQUAL : NRM_SUPERSET),
    2477      139866 :                                     NUM_EXEC_QUAL((Plan *) join));
    2478             : 
    2479      139866 :     pfree(outer_itlist);
    2480      139866 :     pfree(inner_itlist);
    2481      139866 : }
    2482             : 
    2483             : /*
    2484             :  * set_upper_references
    2485             :  *    Update the targetlist and quals of an upper-level plan node
    2486             :  *    to refer to the tuples returned by its lefttree subplan.
    2487             :  *    Also perform opcode lookup for these expressions, and
    2488             :  *    add regclass OIDs to root->glob->relationOids.
    2489             :  *
    2490             :  * This is used for single-input plan types like Agg, Group, Result.
    2491             :  *
    2492             :  * In most cases, we have to match up individual Vars in the tlist and
    2493             :  * qual expressions with elements of the subplan's tlist (which was
    2494             :  * generated by flattening these selfsame expressions, so it should have all
    2495             :  * the required variables).  There is an important exception, however:
    2496             :  * depending on where we are in the plan tree, sort/group columns may have
    2497             :  * been pushed into the subplan tlist unflattened.  If these values are also
    2498             :  * needed in the output then we want to reference the subplan tlist element
    2499             :  * rather than recomputing the expression.
    2500             :  */
    2501             : static void
    2502       70426 : set_upper_references(PlannerInfo *root, Plan *plan, int rtoffset)
    2503             : {
    2504       70426 :     Plan       *subplan = plan->lefttree;
    2505             :     indexed_tlist *subplan_itlist;
    2506             :     List       *output_targetlist;
    2507             :     ListCell   *l;
    2508             : 
    2509       70426 :     subplan_itlist = build_tlist_index(subplan->targetlist);
    2510             : 
    2511             :     /*
    2512             :      * If it's a grouping node with grouping sets, any Vars and PHVs appearing
    2513             :      * in the targetlist and quals should have nullingrels that include the
    2514             :      * effects of the grouping step, ie they will have nullingrels equal to
    2515             :      * the input Vars/PHVs' nullingrels plus the RT index of the grouping
    2516             :      * step.  In order to perform exact nullingrels matches, we remove the RT
    2517             :      * index of the grouping step first.
    2518             :      */
    2519       70426 :     if (IsA(plan, Agg) &&
    2520       42526 :         root->group_rtindex > 0 &&
    2521        6512 :         ((Agg *) plan)->groupingSets)
    2522             :     {
    2523         824 :         plan->targetlist = (List *)
    2524         824 :             remove_nulling_relids((Node *) plan->targetlist,
    2525         824 :                                   bms_make_singleton(root->group_rtindex),
    2526             :                                   NULL);
    2527         824 :         plan->qual = (List *)
    2528         824 :             remove_nulling_relids((Node *) plan->qual,
    2529         824 :                                   bms_make_singleton(root->group_rtindex),
    2530             :                                   NULL);
    2531             :     }
    2532             : 
    2533       70426 :     output_targetlist = NIL;
    2534      188878 :     foreach(l, plan->targetlist)
    2535             :     {
    2536      118452 :         TargetEntry *tle = (TargetEntry *) lfirst(l);
    2537             :         Node       *newexpr;
    2538             : 
    2539             :         /* If it's a sort/group item, first try to match by sortref */
    2540      118452 :         if (tle->ressortgroupref != 0)
    2541             :         {
    2542             :             newexpr = (Node *)
    2543       37216 :                 search_indexed_tlist_for_sortgroupref(tle->expr,
    2544             :                                                       tle->ressortgroupref,
    2545             :                                                       subplan_itlist,
    2546             :                                                       OUTER_VAR);
    2547       37216 :             if (!newexpr)
    2548       21672 :                 newexpr = fix_upper_expr(root,
    2549       21672 :                                          (Node *) tle->expr,
    2550             :                                          subplan_itlist,
    2551             :                                          OUTER_VAR,
    2552             :                                          rtoffset,
    2553             :                                          NRM_EQUAL,
    2554             :                                          NUM_EXEC_TLIST(plan));
    2555             :         }
    2556             :         else
    2557       81236 :             newexpr = fix_upper_expr(root,
    2558       81236 :                                      (Node *) tle->expr,
    2559             :                                      subplan_itlist,
    2560             :                                      OUTER_VAR,
    2561             :                                      rtoffset,
    2562             :                                      NRM_EQUAL,
    2563             :                                      NUM_EXEC_TLIST(plan));
    2564      118452 :         tle = flatCopyTargetEntry(tle);
    2565      118452 :         tle->expr = (Expr *) newexpr;
    2566      118452 :         output_targetlist = lappend(output_targetlist, tle);
    2567             :     }
    2568       70426 :     plan->targetlist = output_targetlist;
    2569             : 
    2570       70426 :     plan->qual = (List *)
    2571       70426 :         fix_upper_expr(root,
    2572       70426 :                        (Node *) plan->qual,
    2573             :                        subplan_itlist,
    2574             :                        OUTER_VAR,
    2575             :                        rtoffset,
    2576             :                        NRM_EQUAL,
    2577       70426 :                        NUM_EXEC_QUAL(plan));
    2578             : 
    2579       70426 :     pfree(subplan_itlist);
    2580       70426 : }
    2581             : 
    2582             : /*
    2583             :  * set_param_references
    2584             :  *    Initialize the initParam list in Gather or Gather merge node such that
    2585             :  *    it contains reference of all the params that needs to be evaluated
    2586             :  *    before execution of the node.  It contains the initplan params that are
    2587             :  *    being passed to the plan nodes below it.
    2588             :  */
    2589             : static void
    2590        1430 : set_param_references(PlannerInfo *root, Plan *plan)
    2591             : {
    2592             :     Assert(IsA(plan, Gather) || IsA(plan, GatherMerge));
    2593             : 
    2594        1430 :     if (plan->lefttree->extParam)
    2595             :     {
    2596             :         PlannerInfo *proot;
    2597        1302 :         Bitmapset  *initSetParam = NULL;
    2598             :         ListCell   *l;
    2599             : 
    2600        2778 :         for (proot = root; proot != NULL; proot = proot->parent_root)
    2601             :         {
    2602        1554 :             foreach(l, proot->init_plans)
    2603             :             {
    2604          78 :                 SubPlan    *initsubplan = (SubPlan *) lfirst(l);
    2605             :                 ListCell   *l2;
    2606             : 
    2607         156 :                 foreach(l2, initsubplan->setParam)
    2608             :                 {
    2609          78 :                     initSetParam = bms_add_member(initSetParam, lfirst_int(l2));
    2610             :                 }
    2611             :             }
    2612             :         }
    2613             : 
    2614             :         /*
    2615             :          * Remember the list of all external initplan params that are used by
    2616             :          * the children of Gather or Gather merge node.
    2617             :          */
    2618        1302 :         if (IsA(plan, Gather))
    2619         948 :             ((Gather *) plan)->initParam =
    2620         948 :                 bms_intersect(plan->lefttree->extParam, initSetParam);
    2621             :         else
    2622         354 :             ((GatherMerge *) plan)->initParam =
    2623         354 :                 bms_intersect(plan->lefttree->extParam, initSetParam);
    2624             :     }
    2625        1430 : }
    2626             : 
    2627             : /*
    2628             :  * Recursively scan an expression tree and convert Aggrefs to the proper
    2629             :  * intermediate form for combining aggregates.  This means (1) replacing each
    2630             :  * one's argument list with a single argument that is the original Aggref
    2631             :  * modified to show partial aggregation and (2) changing the upper Aggref to
    2632             :  * show combining aggregation.
    2633             :  *
    2634             :  * After this step, set_upper_references will replace the partial Aggrefs
    2635             :  * with Vars referencing the lower Agg plan node's outputs, so that the final
    2636             :  * form seen by the executor is a combining Aggref with a Var as input.
    2637             :  *
    2638             :  * It's rather messy to postpone this step until setrefs.c; ideally it'd be
    2639             :  * done in createplan.c.  The difficulty is that once we modify the Aggref
    2640             :  * expressions, they will no longer be equal() to their original form and
    2641             :  * so cross-plan-node-level matches will fail.  So this has to happen after
    2642             :  * the plan node above the Agg has resolved its subplan references.
    2643             :  */
    2644             : static Node *
    2645        9974 : convert_combining_aggrefs(Node *node, void *context)
    2646             : {
    2647        9974 :     if (node == NULL)
    2648        1166 :         return NULL;
    2649        8808 :     if (IsA(node, Aggref))
    2650             :     {
    2651        2248 :         Aggref     *orig_agg = (Aggref *) node;
    2652             :         Aggref     *child_agg;
    2653             :         Aggref     *parent_agg;
    2654             : 
    2655             :         /* Assert we've not chosen to partial-ize any unsupported cases */
    2656             :         Assert(orig_agg->aggorder == NIL);
    2657             :         Assert(orig_agg->aggdistinct == NIL);
    2658             : 
    2659             :         /*
    2660             :          * Since aggregate calls can't be nested, we needn't recurse into the
    2661             :          * arguments.  But for safety, flat-copy the Aggref node itself rather
    2662             :          * than modifying it in-place.
    2663             :          */
    2664        2248 :         child_agg = makeNode(Aggref);
    2665        2248 :         memcpy(child_agg, orig_agg, sizeof(Aggref));
    2666             : 
    2667             :         /*
    2668             :          * For the parent Aggref, we want to copy all the fields of the
    2669             :          * original aggregate *except* the args list, which we'll replace
    2670             :          * below, and the aggfilter expression, which should be applied only
    2671             :          * by the child not the parent.  Rather than explicitly knowing about
    2672             :          * all the other fields here, we can momentarily modify child_agg to
    2673             :          * provide a suitable source for copyObject.
    2674             :          */
    2675        2248 :         child_agg->args = NIL;
    2676        2248 :         child_agg->aggfilter = NULL;
    2677        2248 :         parent_agg = copyObject(child_agg);
    2678        2248 :         child_agg->args = orig_agg->args;
    2679        2248 :         child_agg->aggfilter = orig_agg->aggfilter;
    2680             : 
    2681             :         /*
    2682             :          * Now, set up child_agg to represent the first phase of partial
    2683             :          * aggregation.  For now, assume serialization is required.
    2684             :          */
    2685        2248 :         mark_partial_aggref(child_agg, AGGSPLIT_INITIAL_SERIAL);
    2686             : 
    2687             :         /*
    2688             :          * And set up parent_agg to represent the second phase.
    2689             :          */
    2690        2248 :         parent_agg->args = list_make1(makeTargetEntry((Expr *) child_agg,
    2691             :                                                       1, NULL, false));
    2692        2248 :         mark_partial_aggref(parent_agg, AGGSPLIT_FINAL_DESERIAL);
    2693             : 
    2694        2248 :         return (Node *) parent_agg;
    2695             :     }
    2696        6560 :     return expression_tree_mutator(node, convert_combining_aggrefs, context);
    2697             : }
    2698             : 
    2699             : /*
    2700             :  * set_dummy_tlist_references
    2701             :  *    Replace the targetlist of an upper-level plan node with a simple
    2702             :  *    list of OUTER_VAR references to its child.
    2703             :  *
    2704             :  * This is used for plan types like Sort and Append that don't evaluate
    2705             :  * their targetlists.  Although the executor doesn't care at all what's in
    2706             :  * the tlist, EXPLAIN needs it to be realistic.
    2707             :  *
    2708             :  * Note: we could almost use set_upper_references() here, but it fails for
    2709             :  * Append for lack of a lefttree subplan.  Single-purpose code is faster
    2710             :  * anyway.
    2711             :  */
    2712             : static void
    2713      159682 : set_dummy_tlist_references(Plan *plan, int rtoffset)
    2714             : {
    2715             :     List       *output_targetlist;
    2716             :     ListCell   *l;
    2717             : 
    2718      159682 :     output_targetlist = NIL;
    2719      710240 :     foreach(l, plan->targetlist)
    2720             :     {
    2721      550558 :         TargetEntry *tle = (TargetEntry *) lfirst(l);
    2722      550558 :         Var        *oldvar = (Var *) tle->expr;
    2723             :         Var        *newvar;
    2724             : 
    2725             :         /*
    2726             :          * As in search_indexed_tlist_for_non_var(), we prefer to keep Consts
    2727             :          * as Consts, not Vars referencing Consts.  Here, there's no speed
    2728             :          * advantage to be had, but it makes EXPLAIN output look cleaner, and
    2729             :          * again it avoids confusing the executor.
    2730             :          */
    2731      550558 :         if (IsA(oldvar, Const))
    2732             :         {
    2733             :             /* just reuse the existing TLE node */
    2734       11114 :             output_targetlist = lappend(output_targetlist, tle);
    2735       11114 :             continue;
    2736             :         }
    2737             : 
    2738      539444 :         newvar = makeVar(OUTER_VAR,
    2739      539444 :                          tle->resno,
    2740             :                          exprType((Node *) oldvar),
    2741             :                          exprTypmod((Node *) oldvar),
    2742             :                          exprCollation((Node *) oldvar),
    2743             :                          0);
    2744      539444 :         if (IsA(oldvar, Var) &&
    2745      427134 :             oldvar->varnosyn > 0)
    2746             :         {
    2747      387080 :             newvar->varnosyn = oldvar->varnosyn + rtoffset;
    2748      387080 :             newvar->varattnosyn = oldvar->varattnosyn;
    2749             :         }
    2750             :         else
    2751             :         {
    2752      152364 :             newvar->varnosyn = 0;    /* wasn't ever a plain Var */
    2753      152364 :             newvar->varattnosyn = 0;
    2754             :         }
    2755             : 
    2756      539444 :         tle = flatCopyTargetEntry(tle);
    2757      539444 :         tle->expr = (Expr *) newvar;
    2758      539444 :         output_targetlist = lappend(output_targetlist, tle);
    2759             :     }
    2760      159682 :     plan->targetlist = output_targetlist;
    2761             : 
    2762             :     /* We don't touch plan->qual here */
    2763      159682 : }
    2764             : 
    2765             : 
    2766             : /*
    2767             :  * build_tlist_index --- build an index data structure for a child tlist
    2768             :  *
    2769             :  * In most cases, subplan tlists will be "flat" tlists with only Vars,
    2770             :  * so we try to optimize that case by extracting information about Vars
    2771             :  * in advance.  Matching a parent tlist to a child is still an O(N^2)
    2772             :  * operation, but at least with a much smaller constant factor than plain
    2773             :  * tlist_member() searches.
    2774             :  *
    2775             :  * The result of this function is an indexed_tlist struct to pass to
    2776             :  * search_indexed_tlist_for_var() and siblings.
    2777             :  * When done, the indexed_tlist may be freed with a single pfree().
    2778             :  */
    2779             : static indexed_tlist *
    2780      409048 : build_tlist_index(List *tlist)
    2781             : {
    2782             :     indexed_tlist *itlist;
    2783             :     tlist_vinfo *vinfo;
    2784             :     ListCell   *l;
    2785             : 
    2786             :     /* Create data structure with enough slots for all tlist entries */
    2787             :     itlist = (indexed_tlist *)
    2788      409048 :         palloc(offsetof(indexed_tlist, vars) +
    2789      409048 :                list_length(tlist) * sizeof(tlist_vinfo));
    2790             : 
    2791      409048 :     itlist->tlist = tlist;
    2792      409048 :     itlist->has_ph_vars = false;
    2793      409048 :     itlist->has_non_vars = false;
    2794             : 
    2795             :     /* Find the Vars and fill in the index array */
    2796      409048 :     vinfo = itlist->vars;
    2797     3858062 :     foreach(l, tlist)
    2798             :     {
    2799     3449014 :         TargetEntry *tle = (TargetEntry *) lfirst(l);
    2800             : 
    2801     3449014 :         if (tle->expr && IsA(tle->expr, Var))
    2802     3429878 :         {
    2803     3429878 :             Var        *var = (Var *) tle->expr;
    2804             : 
    2805     3429878 :             vinfo->varno = var->varno;
    2806     3429878 :             vinfo->varattno = var->varattno;
    2807     3429878 :             vinfo->resno = tle->resno;
    2808     3429878 :             vinfo->varnullingrels = var->varnullingrels;
    2809     3429878 :             vinfo++;
    2810             :         }
    2811       19136 :         else if (tle->expr && IsA(tle->expr, PlaceHolderVar))
    2812        3430 :             itlist->has_ph_vars = true;
    2813             :         else
    2814       15706 :             itlist->has_non_vars = true;
    2815             :     }
    2816             : 
    2817      409048 :     itlist->num_vars = (vinfo - itlist->vars);
    2818             : 
    2819      409048 :     return itlist;
    2820             : }
    2821             : 
    2822             : /*
    2823             :  * build_tlist_index_other_vars --- build a restricted tlist index
    2824             :  *
    2825             :  * This is like build_tlist_index, but we only index tlist entries that
    2826             :  * are Vars belonging to some rel other than the one specified.  We will set
    2827             :  * has_ph_vars (allowing PlaceHolderVars to be matched), but not has_non_vars
    2828             :  * (so nothing other than Vars and PlaceHolderVars can be matched).
    2829             :  */
    2830             : static indexed_tlist *
    2831        3288 : build_tlist_index_other_vars(List *tlist, int ignore_rel)
    2832             : {
    2833             :     indexed_tlist *itlist;
    2834             :     tlist_vinfo *vinfo;
    2835             :     ListCell   *l;
    2836             : 
    2837             :     /* Create data structure with enough slots for all tlist entries */
    2838             :     itlist = (indexed_tlist *)
    2839        3288 :         palloc(offsetof(indexed_tlist, vars) +
    2840        3288 :                list_length(tlist) * sizeof(tlist_vinfo));
    2841             : 
    2842        3288 :     itlist->tlist = tlist;
    2843        3288 :     itlist->has_ph_vars = false;
    2844        3288 :     itlist->has_non_vars = false;
    2845             : 
    2846             :     /* Find the desired Vars and fill in the index array */
    2847        3288 :     vinfo = itlist->vars;
    2848       12722 :     foreach(l, tlist)
    2849             :     {
    2850        9434 :         TargetEntry *tle = (TargetEntry *) lfirst(l);
    2851             : 
    2852        9434 :         if (tle->expr && IsA(tle->expr, Var))
    2853        5412 :         {
    2854        5412 :             Var        *var = (Var *) tle->expr;
    2855             : 
    2856        5412 :             if (var->varno != ignore_rel)
    2857             :             {
    2858        4146 :                 vinfo->varno = var->varno;
    2859        4146 :                 vinfo->varattno = var->varattno;
    2860        4146 :                 vinfo->resno = tle->resno;
    2861        4146 :                 vinfo->varnullingrels = var->varnullingrels;
    2862        4146 :                 vinfo++;
    2863             :             }
    2864             :         }
    2865        4022 :         else if (tle->expr && IsA(tle->expr, PlaceHolderVar))
    2866          90 :             itlist->has_ph_vars = true;
    2867             :     }
    2868             : 
    2869        3288 :     itlist->num_vars = (vinfo - itlist->vars);
    2870             : 
    2871        3288 :     return itlist;
    2872             : }
    2873             : 
    2874             : /*
    2875             :  * search_indexed_tlist_for_var --- find a Var in an indexed tlist
    2876             :  *
    2877             :  * If a match is found, return a copy of the given Var with suitably
    2878             :  * modified varno/varattno (to wit, newvarno and the resno of the TLE entry).
    2879             :  * Also ensure that varnosyn is incremented by rtoffset.
    2880             :  * If no match, return NULL.
    2881             :  *
    2882             :  * We cross-check the varnullingrels of the subplan output Var based on
    2883             :  * nrm_match.  Most call sites should pass NRM_EQUAL indicating we expect
    2884             :  * an exact match.  However, there are places where we haven't cleaned
    2885             :  * things up completely, and we have to settle for allowing subset or
    2886             :  * superset matches.
    2887             :  */
    2888             : static Var *
    2889     1563064 : search_indexed_tlist_for_var(Var *var, indexed_tlist *itlist,
    2890             :                              int newvarno, int rtoffset,
    2891             :                              NullingRelsMatch nrm_match)
    2892             : {
    2893     1563064 :     int         varno = var->varno;
    2894     1563064 :     AttrNumber  varattno = var->varattno;
    2895             :     tlist_vinfo *vinfo;
    2896             :     int         i;
    2897             : 
    2898     1563064 :     vinfo = itlist->vars;
    2899     1563064 :     i = itlist->num_vars;
    2900    11228466 :     while (i-- > 0)
    2901             :     {
    2902    10870762 :         if (vinfo->varno == varno && vinfo->varattno == varattno)
    2903             :         {
    2904             :             /* Found a match */
    2905     1205360 :             Var        *newvar = copyVar(var);
    2906             : 
    2907             :             /*
    2908             :              * Verify that we kept all the nullingrels machinations straight.
    2909             :              *
    2910             :              * XXX we skip the check for system columns and whole-row Vars.
    2911             :              * That's because such Vars might be row identity Vars, which are
    2912             :              * generated without any varnullingrels.  It'd be hard to do
    2913             :              * otherwise, since they're normally made very early in planning,
    2914             :              * when we haven't looked at the jointree yet and don't know which
    2915             :              * joins might null such Vars.  Doesn't seem worth the expense to
    2916             :              * make them fully valid.  (While it's slightly annoying that we
    2917             :              * thereby lose checking for user-written references to such
    2918             :              * columns, it seems unlikely that a bug in nullingrels logic
    2919             :              * would affect only system columns.)
    2920             :              */
    2921     2376888 :             if (!(varattno <= 0 ||
    2922             :                   (nrm_match == NRM_SUBSET ?
    2923       53990 :                    bms_is_subset(var->varnullingrels, vinfo->varnullingrels) :
    2924             :                    nrm_match == NRM_SUPERSET ?
    2925      361816 :                    bms_is_subset(vinfo->varnullingrels, var->varnullingrels) :
    2926      755722 :                    bms_equal(vinfo->varnullingrels, var->varnullingrels))))
    2927           0 :                 elog(ERROR, "wrong varnullingrels %s (expected %s) for Var %d/%d",
    2928             :                      bmsToString(var->varnullingrels),
    2929             :                      bmsToString(vinfo->varnullingrels),
    2930             :                      varno, varattno);
    2931             : 
    2932     1205360 :             newvar->varno = newvarno;
    2933     1205360 :             newvar->varattno = vinfo->resno;
    2934     1205360 :             if (newvar->varnosyn > 0)
    2935     1204770 :                 newvar->varnosyn += rtoffset;
    2936     1205360 :             return newvar;
    2937             :         }
    2938     9665402 :         vinfo++;
    2939             :     }
    2940      357704 :     return NULL;                /* no match */
    2941             : }
    2942             : 
    2943             : /*
    2944             :  * search_indexed_tlist_for_phv --- find a PlaceHolderVar in an indexed tlist
    2945             :  *
    2946             :  * If a match is found, return a Var constructed to reference the tlist item.
    2947             :  * If no match, return NULL.
    2948             :  *
    2949             :  * Cross-check phnullingrels as in search_indexed_tlist_for_var.
    2950             :  *
    2951             :  * NOTE: it is a waste of time to call this unless itlist->has_ph_vars.
    2952             :  */
    2953             : static Var *
    2954        3562 : search_indexed_tlist_for_phv(PlaceHolderVar *phv,
    2955             :                              indexed_tlist *itlist, int newvarno,
    2956             :                              NullingRelsMatch nrm_match)
    2957             : {
    2958             :     ListCell   *lc;
    2959             : 
    2960        9048 :     foreach(lc, itlist->tlist)
    2961             :     {
    2962        8672 :         TargetEntry *tle = (TargetEntry *) lfirst(lc);
    2963             : 
    2964        8672 :         if (tle->expr && IsA(tle->expr, PlaceHolderVar))
    2965             :         {
    2966        4650 :             PlaceHolderVar *subphv = (PlaceHolderVar *) tle->expr;
    2967             :             Var        *newvar;
    2968             : 
    2969             :             /*
    2970             :              * Analogously to search_indexed_tlist_for_var, we match on phid
    2971             :              * only.  We don't use equal(), partially for speed but mostly
    2972             :              * because phnullingrels might not be exactly equal.
    2973             :              */
    2974        4650 :             if (phv->phid != subphv->phid)
    2975        1464 :                 continue;
    2976             : 
    2977             :             /* Verify that we kept all the nullingrels machinations straight */
    2978        6372 :             if (!(nrm_match == NRM_SUBSET ?
    2979         252 :                   bms_is_subset(phv->phnullingrels, subphv->phnullingrels) :
    2980             :                   nrm_match == NRM_SUPERSET ?
    2981        1674 :                   bms_is_subset(subphv->phnullingrels, phv->phnullingrels) :
    2982        1260 :                   bms_equal(subphv->phnullingrels, phv->phnullingrels)))
    2983           0 :                 elog(ERROR, "wrong phnullingrels %s (expected %s) for PlaceHolderVar %d",
    2984             :                      bmsToString(phv->phnullingrels),
    2985             :                      bmsToString(subphv->phnullingrels),
    2986             :                      phv->phid);
    2987             : 
    2988             :             /* Found a matching subplan output expression */
    2989        3186 :             newvar = makeVarFromTargetEntry(newvarno, tle);
    2990        3186 :             newvar->varnosyn = 0;    /* wasn't ever a plain Var */
    2991        3186 :             newvar->varattnosyn = 0;
    2992        3186 :             return newvar;
    2993             :         }
    2994             :     }
    2995         376 :     return NULL;                /* no match */
    2996             : }
    2997             : 
    2998             : /*
    2999             :  * search_indexed_tlist_for_non_var --- find a non-Var/PHV in an indexed tlist
    3000             :  *
    3001             :  * If a match is found, return a Var constructed to reference the tlist item.
    3002             :  * If no match, return NULL.
    3003             :  *
    3004             :  * NOTE: it is a waste of time to call this unless itlist->has_non_vars.
    3005             :  */
    3006             : static Var *
    3007       37256 : search_indexed_tlist_for_non_var(Expr *node,
    3008             :                                  indexed_tlist *itlist, int newvarno)
    3009             : {
    3010             :     TargetEntry *tle;
    3011             : 
    3012             :     /*
    3013             :      * If it's a simple Const, replacing it with a Var is silly, even if there
    3014             :      * happens to be an identical Const below; a Var is more expensive to
    3015             :      * execute than a Const.  What's more, replacing it could confuse some
    3016             :      * places in the executor that expect to see simple Consts for, eg,
    3017             :      * dropped columns.
    3018             :      */
    3019       37256 :     if (IsA(node, Const))
    3020        1952 :         return NULL;
    3021             : 
    3022       35304 :     tle = tlist_member(node, itlist->tlist);
    3023       35304 :     if (tle)
    3024             :     {
    3025             :         /* Found a matching subplan output expression */
    3026             :         Var        *newvar;
    3027             : 
    3028        9114 :         newvar = makeVarFromTargetEntry(newvarno, tle);
    3029        9114 :         newvar->varnosyn = 0;    /* wasn't ever a plain Var */
    3030        9114 :         newvar->varattnosyn = 0;
    3031        9114 :         return newvar;
    3032             :     }
    3033       26190 :     return NULL;                /* no match */
    3034             : }
    3035             : 
    3036             : /*
    3037             :  * search_indexed_tlist_for_sortgroupref --- find a sort/group expression
    3038             :  *
    3039             :  * If a match is found, return a Var constructed to reference the tlist item.
    3040             :  * If no match, return NULL.
    3041             :  *
    3042             :  * This is needed to ensure that we select the right subplan TLE in cases
    3043             :  * where there are multiple textually-equal()-but-volatile sort expressions.
    3044             :  * And it's also faster than search_indexed_tlist_for_non_var.
    3045             :  */
    3046             : static Var *
    3047       37216 : search_indexed_tlist_for_sortgroupref(Expr *node,
    3048             :                                       Index sortgroupref,
    3049             :                                       indexed_tlist *itlist,
    3050             :                                       int newvarno)
    3051             : {
    3052             :     ListCell   *lc;
    3053             : 
    3054      171194 :     foreach(lc, itlist->tlist)
    3055             :     {
    3056      149522 :         TargetEntry *tle = (TargetEntry *) lfirst(lc);
    3057             : 
    3058             :         /*
    3059             :          * Usually the equal() check is redundant, but in setop plans it may
    3060             :          * not be, since prepunion.c assigns ressortgroupref equal to the
    3061             :          * column resno without regard to whether that matches the topmost
    3062             :          * level's sortgrouprefs and without regard to whether any implicit
    3063             :          * coercions are added in the setop tree.  We might have to clean that
    3064             :          * up someday; but for now, just ignore any false matches.
    3065             :          */
    3066      165198 :         if (tle->ressortgroupref == sortgroupref &&
    3067       15676 :             equal(node, tle->expr))
    3068             :         {
    3069             :             /* Found a matching subplan output expression */
    3070             :             Var        *newvar;
    3071             : 
    3072       15544 :             newvar = makeVarFromTargetEntry(newvarno, tle);
    3073       15544 :             newvar->varnosyn = 0;    /* wasn't ever a plain Var */
    3074       15544 :             newvar->varattnosyn = 0;
    3075       15544 :             return newvar;
    3076             :         }
    3077             :     }
    3078       21672 :     return NULL;                /* no match */
    3079             : }
    3080             : 
    3081             : /*
    3082             :  * fix_join_expr
    3083             :  *     Create a new set of targetlist entries or join qual clauses by
    3084             :  *     changing the varno/varattno values of variables in the clauses
    3085             :  *     to reference target list values from the outer and inner join
    3086             :  *     relation target lists.  Also perform opcode lookup and add
    3087             :  *     regclass OIDs to root->glob->relationOids.
    3088             :  *
    3089             :  * This is used in four different scenarios:
    3090             :  * 1) a normal join clause, where all the Vars in the clause *must* be
    3091             :  *    replaced by OUTER_VAR or INNER_VAR references.  In this case
    3092             :  *    acceptable_rel should be zero so that any failure to match a Var will be
    3093             :  *    reported as an error.
    3094             :  * 2) RETURNING clauses, which may contain both Vars of the target relation
    3095             :  *    and Vars of other relations. In this case we want to replace the
    3096             :  *    other-relation Vars by OUTER_VAR references, while leaving target Vars
    3097             :  *    alone. Thus inner_itlist = NULL and acceptable_rel = the ID of the
    3098             :  *    target relation should be passed.
    3099             :  * 3) ON CONFLICT UPDATE SET/WHERE clauses.  Here references to EXCLUDED are
    3100             :  *    to be replaced with INNER_VAR references, while leaving target Vars (the
    3101             :  *    to-be-updated relation) alone. Correspondingly inner_itlist is to be
    3102             :  *    EXCLUDED elements, outer_itlist = NULL and acceptable_rel the target
    3103             :  *    relation.
    3104             :  * 4) MERGE.  In this case, references to the source relation are to be
    3105             :  *    replaced with INNER_VAR references, leaving Vars of the target
    3106             :  *    relation (the to-be-modified relation) alone.  So inner_itlist is to be
    3107             :  *    the source relation elements, outer_itlist = NULL and acceptable_rel
    3108             :  *    the target relation.
    3109             :  *
    3110             :  * 'clauses' is the targetlist or list of join clauses
    3111             :  * 'outer_itlist' is the indexed target list of the outer join relation,
    3112             :  *      or NULL
    3113             :  * 'inner_itlist' is the indexed target list of the inner join relation,
    3114             :  *      or NULL
    3115             :  * 'acceptable_rel' is either zero or the rangetable index of a relation
    3116             :  *      whose Vars may appear in the clause without provoking an error
    3117             :  * 'rtoffset': how much to increment varnos by
    3118             :  * 'nrm_match': as for search_indexed_tlist_for_var()
    3119             :  * 'num_exec': estimated number of executions of expression
    3120             :  *
    3121             :  * Returns the new expression tree.  The original clause structure is
    3122             :  * not modified.
    3123             :  */
    3124             : static List *
    3125      476240 : fix_join_expr(PlannerInfo *root,
    3126             :               List *clauses,
    3127             :               indexed_tlist *outer_itlist,
    3128             :               indexed_tlist *inner_itlist,
    3129             :               Index acceptable_rel,
    3130             :               int rtoffset,
    3131             :               NullingRelsMatch nrm_match,
    3132             :               double num_exec)
    3133             : {
    3134             :     fix_join_expr_context context;
    3135             : 
    3136      476240 :     context.root = root;
    3137      476240 :     context.outer_itlist = outer_itlist;
    3138      476240 :     context.inner_itlist = inner_itlist;
    3139      476240 :     context.acceptable_rel = acceptable_rel;
    3140      476240 :     context.rtoffset = rtoffset;
    3141      476240 :     context.nrm_match = nrm_match;
    3142      476240 :     context.num_exec = num_exec;
    3143      476240 :     return (List *) fix_join_expr_mutator((Node *) clauses, &context);
    3144             : }
    3145             : 
    3146             : static Node *
    3147     3019898 : fix_join_expr_mutator(Node *node, fix_join_expr_context *context)
    3148             : {
    3149             :     Var        *newvar;
    3150             : 
    3151     3019898 :     if (node == NULL)
    3152      298190 :         return NULL;
    3153     2721708 :     if (IsA(node, Var))
    3154             :     {
    3155      987578 :         Var        *var = (Var *) node;
    3156             : 
    3157             :         /*
    3158             :          * Verify that Vars with non-default varreturningtype only appear in
    3159             :          * the RETURNING list, and refer to the target relation.
    3160             :          */
    3161      987578 :         if (var->varreturningtype != VAR_RETURNING_DEFAULT)
    3162             :         {
    3163        2686 :             if (context->inner_itlist != NULL ||
    3164        2686 :                 context->outer_itlist == NULL ||
    3165        2686 :                 context->acceptable_rel == 0)
    3166           0 :                 elog(ERROR, "variable returning old/new found outside RETURNING list");
    3167        2686 :             if (var->varno != context->acceptable_rel)
    3168           0 :                 elog(ERROR, "wrong varno %d (expected %d) for variable returning old/new",
    3169             :                      var->varno, context->acceptable_rel);
    3170             :         }
    3171             : 
    3172             :         /* Look for the var in the input tlists, first in the outer */
    3173      987578 :         if (context->outer_itlist)
    3174             :         {
    3175      980464 :             newvar = search_indexed_tlist_for_var(var,
    3176             :                                                   context->outer_itlist,
    3177             :                                                   OUTER_VAR,
    3178             :                                                   context->rtoffset,
    3179             :                                                   context->nrm_match);
    3180      980464 :             if (newvar)
    3181      626044 :                 return (Node *) newvar;
    3182             :         }
    3183             : 
    3184             :         /* then in the inner. */
    3185      361534 :         if (context->inner_itlist)
    3186             :         {
    3187      350894 :             newvar = search_indexed_tlist_for_var(var,
    3188             :                                                   context->inner_itlist,
    3189             :                                                   INNER_VAR,
    3190             :                                                   context->rtoffset,
    3191             :                                                   context->nrm_match);
    3192      350894 :             if (newvar)
    3193      347610 :                 return (Node *) newvar;
    3194             :         }
    3195             : 
    3196             :         /* If it's for acceptable_rel, adjust and return it */
    3197       13924 :         if (var->varno == context->acceptable_rel)
    3198             :         {
    3199       13924 :             var = copyVar(var);
    3200       13924 :             var->varno += context->rtoffset;
    3201       13924 :             if (var->varnosyn > 0)
    3202       13262 :                 var->varnosyn += context->rtoffset;
    3203       13924 :             return (Node *) var;
    3204             :         }
    3205             : 
    3206             :         /* No referent found for Var */
    3207           0 :         elog(ERROR, "variable not found in subplan target lists");
    3208             :     }
    3209     1734130 :     if (IsA(node, PlaceHolderVar))
    3210             :     {
    3211        2682 :         PlaceHolderVar *phv = (PlaceHolderVar *) node;
    3212             : 
    3213             :         /* See if the PlaceHolderVar has bubbled up from a lower plan node */
    3214        2682 :         if (context->outer_itlist && context->outer_itlist->has_ph_vars)
    3215             :         {
    3216        1044 :             newvar = search_indexed_tlist_for_phv(phv,
    3217             :                                                   context->outer_itlist,
    3218             :                                                   OUTER_VAR,
    3219             :                                                   context->nrm_match);
    3220        1044 :             if (newvar)
    3221         728 :                 return (Node *) newvar;
    3222             :         }
    3223        1954 :         if (context->inner_itlist && context->inner_itlist->has_ph_vars)
    3224             :         {
    3225        1566 :             newvar = search_indexed_tlist_for_phv(phv,
    3226             :                                                   context->inner_itlist,
    3227             :                                                   INNER_VAR,
    3228             :                                                   context->nrm_match);
    3229        1566 :             if (newvar)
    3230        1506 :                 return (Node *) newvar;
    3231             :         }
    3232             : 
    3233             :         /* If not supplied by input plans, evaluate the contained expr */
    3234             :         /* XXX can we assert something about phnullingrels? */
    3235         448 :         return fix_join_expr_mutator((Node *) phv->phexpr, context);
    3236             :     }
    3237             :     /* Try matching more complex expressions too, if tlists have any */
    3238     1731448 :     if (context->outer_itlist && context->outer_itlist->has_non_vars)
    3239             :     {
    3240        1482 :         newvar = search_indexed_tlist_for_non_var((Expr *) node,
    3241             :                                                   context->outer_itlist,
    3242             :                                                   OUTER_VAR);
    3243        1482 :         if (newvar)
    3244         124 :             return (Node *) newvar;
    3245             :     }
    3246     1731324 :     if (context->inner_itlist && context->inner_itlist->has_non_vars)
    3247             :     {
    3248        6458 :         newvar = search_indexed_tlist_for_non_var((Expr *) node,
    3249             :                                                   context->inner_itlist,
    3250             :                                                   INNER_VAR);
    3251        6458 :         if (newvar)
    3252        1180 :             return (Node *) newvar;
    3253             :     }
    3254             :     /* Special cases (apply only AFTER failing to match to lower tlist) */
    3255     1730144 :     if (IsA(node, Param))
    3256        5870 :         return fix_param_node(context->root, (Param *) node);
    3257     1724274 :     if (IsA(node, AlternativeSubPlan))
    3258        1492 :         return fix_join_expr_mutator(fix_alternative_subplan(context->root,
    3259             :                                                              (AlternativeSubPlan *) node,
    3260             :                                                              context->num_exec),
    3261             :                                      context);
    3262     1722782 :     fix_expr_common(context->root, node);
    3263     1722782 :     return expression_tree_mutator(node, fix_join_expr_mutator, context);
    3264             : }
    3265             : 
    3266             : /*
    3267             :  * fix_upper_expr
    3268             :  *      Modifies an expression tree so that all Var nodes reference outputs
    3269             :  *      of a subplan.  Also looks for Aggref nodes that should be replaced
    3270             :  *      by initplan output Params.  Also performs opcode lookup, and adds
    3271             :  *      regclass OIDs to root->glob->relationOids.
    3272             :  *
    3273             :  * This is used to fix up target and qual expressions of non-join upper-level
    3274             :  * plan nodes, as well as index-only scan nodes.
    3275             :  *
    3276             :  * An error is raised if no matching var can be found in the subplan tlist
    3277             :  * --- so this routine should only be applied to nodes whose subplans'
    3278             :  * targetlists were generated by flattening the expressions used in the
    3279             :  * parent node.
    3280             :  *
    3281             :  * If itlist->has_non_vars is true, then we try to match whole subexpressions
    3282             :  * against elements of the subplan tlist, so that we can avoid recomputing
    3283             :  * expressions that were already computed by the subplan.  (This is relatively
    3284             :  * expensive, so we don't want to try it in the common case where the
    3285             :  * subplan tlist is just a flattened list of Vars.)
    3286             :  *
    3287             :  * 'node': the tree to be fixed (a target item or qual)
    3288             :  * 'subplan_itlist': indexed target list for subplan (or index)
    3289             :  * 'newvarno': varno to use for Vars referencing tlist elements
    3290             :  * 'rtoffset': how much to increment varnos by
    3291             :  * 'nrm_match': as for search_indexed_tlist_for_var()
    3292             :  * 'num_exec': estimated number of executions of expression
    3293             :  *
    3294             :  * The resulting tree is a copy of the original in which all Var nodes have
    3295             :  * varno = newvarno, varattno = resno of corresponding targetlist element.
    3296             :  * The original tree is not modified.
    3297             :  */
    3298             : static Node *
    3299      354240 : fix_upper_expr(PlannerInfo *root,
    3300             :                Node *node,
    3301             :                indexed_tlist *subplan_itlist,
    3302             :                int newvarno,
    3303             :                int rtoffset,
    3304             :                NullingRelsMatch nrm_match,
    3305             :                double num_exec)
    3306             : {
    3307             :     fix_upper_expr_context context;
    3308             : 
    3309      354240 :     context.root = root;
    3310      354240 :     context.subplan_itlist = subplan_itlist;
    3311      354240 :     context.newvarno = newvarno;
    3312      354240 :     context.rtoffset = rtoffset;
    3313      354240 :     context.nrm_match = nrm_match;
    3314      354240 :     context.num_exec = num_exec;
    3315      354240 :     return fix_upper_expr_mutator(node, &context);
    3316             : }
    3317             : 
    3318             : static Node *
    3319     1014384 : fix_upper_expr_mutator(Node *node, fix_upper_expr_context *context)
    3320             : {
    3321             :     Var        *newvar;
    3322             : 
    3323     1014384 :     if (node == NULL)
    3324      308390 :         return NULL;
    3325      705994 :     if (IsA(node, Var))
    3326             :     {
    3327      231706 :         Var        *var = (Var *) node;
    3328             : 
    3329      231706 :         newvar = search_indexed_tlist_for_var(var,
    3330             :                                               context->subplan_itlist,
    3331             :                                               context->newvarno,
    3332             :                                               context->rtoffset,
    3333             :                                               context->nrm_match);
    3334      231706 :         if (!newvar)
    3335           0 :             elog(ERROR, "variable not found in subplan target list");
    3336      231706 :         return (Node *) newvar;
    3337             :     }
    3338      474288 :     if (IsA(node, PlaceHolderVar))
    3339             :     {
    3340        1090 :         PlaceHolderVar *phv = (PlaceHolderVar *) node;
    3341             : 
    3342             :         /* See if the PlaceHolderVar has bubbled up from a lower plan node */
    3343        1090 :         if (context->subplan_itlist->has_ph_vars)
    3344             :         {
    3345         952 :             newvar = search_indexed_tlist_for_phv(phv,
    3346             :                                                   context->subplan_itlist,
    3347             :                                                   context->newvarno,
    3348             :                                                   context->nrm_match);
    3349         952 :             if (newvar)
    3350         952 :                 return (Node *) newvar;
    3351             :         }
    3352             :         /* If not supplied by input plan, evaluate the contained expr */
    3353             :         /* XXX can we assert something about phnullingrels? */
    3354         138 :         return fix_upper_expr_mutator((Node *) phv->phexpr, context);
    3355             :     }
    3356             :     /* Try matching more complex expressions too, if tlist has any */
    3357      473198 :     if (context->subplan_itlist->has_non_vars)
    3358             :     {
    3359       29136 :         newvar = search_indexed_tlist_for_non_var((Expr *) node,
    3360             :                                                   context->subplan_itlist,
    3361             :                                                   context->newvarno);
    3362       29136 :         if (newvar)
    3363        7630 :             return (Node *) newvar;
    3364             :     }
    3365             :     /* Special cases (apply only AFTER failing to match to lower tlist) */
    3366      465568 :     if (IsA(node, Param))
    3367        9400 :         return fix_param_node(context->root, (Param *) node);
    3368      456168 :     if (IsA(node, Aggref))
    3369             :     {
    3370       48030 :         Aggref     *aggref = (Aggref *) node;
    3371             :         Param      *aggparam;
    3372             : 
    3373             :         /* See if the Aggref should be replaced by a Param */
    3374       48030 :         aggparam = find_minmax_agg_replacement_param(context->root, aggref);
    3375       48030 :         if (aggparam != NULL)
    3376             :         {
    3377             :             /* Make a copy of the Param for paranoia's sake */
    3378           0 :             return (Node *) copyObject(aggparam);
    3379             :         }
    3380             :         /* If no match, just fall through to process it normally */
    3381             :     }
    3382      456168 :     if (IsA(node, AlternativeSubPlan))
    3383          30 :         return fix_upper_expr_mutator(fix_alternative_subplan(context->root,
    3384             :                                                               (AlternativeSubPlan *) node,
    3385             :                                                               context->num_exec),
    3386             :                                       context);
    3387      456138 :     fix_expr_common(context->root, node);
    3388      456138 :     return expression_tree_mutator(node, fix_upper_expr_mutator, context);
    3389             : }
    3390             : 
    3391             : /*
    3392             :  * set_returning_clause_references
    3393             :  *      Perform setrefs.c's work on a RETURNING targetlist
    3394             :  *
    3395             :  * If the query involves more than just the result table, we have to
    3396             :  * adjust any Vars that refer to other tables to reference junk tlist
    3397             :  * entries in the top subplan's targetlist.  Vars referencing the result
    3398             :  * table should be left alone, however (the executor will evaluate them
    3399             :  * using the actual heap tuple, after firing triggers if any).  In the
    3400             :  * adjusted RETURNING list, result-table Vars will have their original
    3401             :  * varno (plus rtoffset), but Vars for other rels will have varno OUTER_VAR.
    3402             :  *
    3403             :  * We also must perform opcode lookup and add regclass OIDs to
    3404             :  * root->glob->relationOids.
    3405             :  *
    3406             :  * 'rlist': the RETURNING targetlist to be fixed
    3407             :  * 'topplan': the top subplan node that will be just below the ModifyTable
    3408             :  *      node (note it's not yet passed through set_plan_refs)
    3409             :  * 'resultRelation': RT index of the associated result relation
    3410             :  * 'rtoffset': how much to increment varnos by
    3411             :  *
    3412             :  * Note: the given 'root' is for the parent query level, not the 'topplan'.
    3413             :  * This does not matter currently since we only access the dependency-item
    3414             :  * lists in root->glob, but it would need some hacking if we wanted a root
    3415             :  * that actually matches the subplan.
    3416             :  *
    3417             :  * Note: resultRelation is not yet adjusted by rtoffset.
    3418             :  */
    3419             : static List *
    3420        3288 : set_returning_clause_references(PlannerInfo *root,
    3421             :                                 List *rlist,
    3422             :                                 Plan *topplan,
    3423             :                                 Index resultRelation,
    3424             :                                 int rtoffset)
    3425             : {
    3426             :     indexed_tlist *itlist;
    3427             : 
    3428             :     /*
    3429             :      * We can perform the desired Var fixup by abusing the fix_join_expr
    3430             :      * machinery that formerly handled inner indexscan fixup.  We search the
    3431             :      * top plan's targetlist for Vars of non-result relations, and use
    3432             :      * fix_join_expr to convert RETURNING Vars into references to those tlist
    3433             :      * entries, while leaving result-rel Vars as-is.
    3434             :      *
    3435             :      * PlaceHolderVars will also be sought in the targetlist, but no
    3436             :      * more-complex expressions will be.  Note that it is not possible for a
    3437             :      * PlaceHolderVar to refer to the result relation, since the result is
    3438             :      * never below an outer join.  If that case could happen, we'd have to be
    3439             :      * prepared to pick apart the PlaceHolderVar and evaluate its contained
    3440             :      * expression instead.
    3441             :      */
    3442        3288 :     itlist = build_tlist_index_other_vars(topplan->targetlist, resultRelation);
    3443             : 
    3444        3288 :     rlist = fix_join_expr(root,
    3445             :                           rlist,
    3446             :                           itlist,
    3447             :                           NULL,
    3448             :                           resultRelation,
    3449             :                           rtoffset,
    3450             :                           NRM_EQUAL,
    3451             :                           NUM_EXEC_TLIST(topplan));
    3452             : 
    3453        3288 :     pfree(itlist);
    3454             : 
    3455        3288 :     return rlist;
    3456             : }
    3457             : 
    3458             : /*
    3459             :  * fix_windowagg_condition_expr_mutator
    3460             :  *      Mutator function for replacing WindowFuncs with the corresponding Var
    3461             :  *      in the targetlist which references that WindowFunc.
    3462             :  */
    3463             : static Node *
    3464        3470 : fix_windowagg_condition_expr_mutator(Node *node,
    3465             :                                      fix_windowagg_cond_context *context)
    3466             : {
    3467        3470 :     if (node == NULL)
    3468        2582 :         return NULL;
    3469             : 
    3470         888 :     if (IsA(node, WindowFunc))
    3471             :     {
    3472             :         Var        *newvar;
    3473             : 
    3474         180 :         newvar = search_indexed_tlist_for_non_var((Expr *) node,
    3475             :                                                   context->subplan_itlist,
    3476             :                                                   context->newvarno);
    3477         180 :         if (newvar)
    3478         180 :             return (Node *) newvar;
    3479           0 :         elog(ERROR, "WindowFunc not found in subplan target lists");
    3480             :     }
    3481             : 
    3482         708 :     return expression_tree_mutator(node,
    3483             :                                    fix_windowagg_condition_expr_mutator,
    3484             :                                    context);
    3485             : }
    3486             : 
    3487             : /*
    3488             :  * fix_windowagg_condition_expr
    3489             :  *      Converts references in 'runcondition' so that any WindowFunc
    3490             :  *      references are swapped out for a Var which references the matching
    3491             :  *      WindowFunc in 'subplan_itlist'.
    3492             :  */
    3493             : static List *
    3494        2750 : fix_windowagg_condition_expr(PlannerInfo *root,
    3495             :                              List *runcondition,
    3496             :                              indexed_tlist *subplan_itlist)
    3497             : {
    3498             :     fix_windowagg_cond_context context;
    3499             : 
    3500        2750 :     context.root = root;
    3501        2750 :     context.subplan_itlist = subplan_itlist;
    3502        2750 :     context.newvarno = 0;
    3503             : 
    3504        2750 :     return (List *) fix_windowagg_condition_expr_mutator((Node *) runcondition,
    3505             :                                                          &context);
    3506             : }
    3507             : 
    3508             : /*
    3509             :  * set_windowagg_runcondition_references
    3510             :  *      Converts references in 'runcondition' so that any WindowFunc
    3511             :  *      references are swapped out for a Var which references the matching
    3512             :  *      WindowFunc in 'plan' targetlist.
    3513             :  */
    3514             : static List *
    3515        2750 : set_windowagg_runcondition_references(PlannerInfo *root,
    3516             :                                       List *runcondition,
    3517             :                                       Plan *plan)
    3518             : {
    3519             :     List       *newlist;
    3520             :     indexed_tlist *itlist;
    3521             : 
    3522        2750 :     itlist = build_tlist_index(plan->targetlist);
    3523             : 
    3524        2750 :     newlist = fix_windowagg_condition_expr(root, runcondition, itlist);
    3525             : 
    3526        2750 :     pfree(itlist);
    3527             : 
    3528        2750 :     return newlist;
    3529             : }
    3530             : 
    3531             : /*
    3532             :  * find_minmax_agg_replacement_param
    3533             :  *      If the given Aggref is one that we are optimizing into a subquery
    3534             :  *      (cf. planagg.c), then return the Param that should replace it.
    3535             :  *      Else return NULL.
    3536             :  *
    3537             :  * This is exported so that SS_finalize_plan can use it before setrefs.c runs.
    3538             :  * Note that it will not find anything until we have built a Plan from a
    3539             :  * MinMaxAggPath, as root->minmax_aggs will never be filled otherwise.
    3540             :  */
    3541             : Param *
    3542       62158 : find_minmax_agg_replacement_param(PlannerInfo *root, Aggref *aggref)
    3543             : {
    3544       63126 :     if (root->minmax_aggs != NIL &&
    3545         968 :         list_length(aggref->args) == 1)
    3546             :     {
    3547         968 :         TargetEntry *curTarget = (TargetEntry *) linitial(aggref->args);
    3548             :         ListCell   *lc;
    3549             : 
    3550        1064 :         foreach(lc, root->minmax_aggs)
    3551             :         {
    3552        1064 :             MinMaxAggInfo *mminfo = (MinMaxAggInfo *) lfirst(lc);
    3553             : 
    3554        2032 :             if (mminfo->aggfnoid == aggref->aggfnoid &&
    3555         968 :                 equal(mminfo->target, curTarget->expr))
    3556         968 :                 return mminfo->param;
    3557             :         }
    3558             :     }
    3559       61190 :     return NULL;
    3560             : }
    3561             : 
    3562             : 
    3563             : /*****************************************************************************
    3564             :  *                  QUERY DEPENDENCY MANAGEMENT
    3565             :  *****************************************************************************/
    3566             : 
    3567             : /*
    3568             :  * record_plan_function_dependency
    3569             :  *      Mark the current plan as depending on a particular function.
    3570             :  *
    3571             :  * This is exported so that the function-inlining code can record a
    3572             :  * dependency on a function that it's removed from the plan tree.
    3573             :  */
    3574             : void
    3575     1258742 : record_plan_function_dependency(PlannerInfo *root, Oid funcid)
    3576             : {
    3577             :     /*
    3578             :      * For performance reasons, we don't bother to track built-in functions;
    3579             :      * we just assume they'll never change (or at least not in ways that'd
    3580             :      * invalidate plans using them).  For this purpose we can consider a
    3581             :      * built-in function to be one with OID less than FirstUnpinnedObjectId.
    3582             :      * Note that the OID generator guarantees never to generate such an OID
    3583             :      * after startup, even at OID wraparound.
    3584             :      */
    3585     1258742 :     if (funcid >= (Oid) FirstUnpinnedObjectId)
    3586             :     {
    3587       42010 :         PlanInvalItem *inval_item = makeNode(PlanInvalItem);
    3588             : 
    3589             :         /*
    3590             :          * It would work to use any syscache on pg_proc, but the easiest is
    3591             :          * PROCOID since we already have the function's OID at hand.  Note
    3592             :          * that plancache.c knows we use PROCOID.
    3593             :          */
    3594       42010 :         inval_item->cacheId = PROCOID;
    3595       42010 :         inval_item->hashValue = GetSysCacheHashValue1(PROCOID,
    3596             :                                                       ObjectIdGetDatum(funcid));
    3597             : 
    3598       42010 :         root->glob->invalItems = lappend(root->glob->invalItems, inval_item);
    3599             :     }
    3600     1258742 : }
    3601             : 
    3602             : /*
    3603             :  * record_plan_type_dependency
    3604             :  *      Mark the current plan as depending on a particular type.
    3605             :  *
    3606             :  * This is exported so that eval_const_expressions can record a
    3607             :  * dependency on a domain that it's removed a CoerceToDomain node for.
    3608             :  *
    3609             :  * We don't currently need to record dependencies on domains that the
    3610             :  * plan contains CoerceToDomain nodes for, though that might change in
    3611             :  * future.  Hence, this isn't actually called in this module, though
    3612             :  * someday fix_expr_common might call it.
    3613             :  */
    3614             : void
    3615       18256 : record_plan_type_dependency(PlannerInfo *root, Oid typid)
    3616             : {
    3617             :     /*
    3618             :      * As in record_plan_function_dependency, ignore the possibility that
    3619             :      * someone would change a built-in domain.
    3620             :      */
    3621       18256 :     if (typid >= (Oid) FirstUnpinnedObjectId)
    3622             :     {
    3623       18256 :         PlanInvalItem *inval_item = makeNode(PlanInvalItem);
    3624             : 
    3625             :         /*
    3626             :          * It would work to use any syscache on pg_type, but the easiest is
    3627             :          * TYPEOID since we already have the type's OID at hand.  Note that
    3628             :          * plancache.c knows we use TYPEOID.
    3629             :          */
    3630       18256 :         inval_item->cacheId = TYPEOID;
    3631       18256 :         inval_item->hashValue = GetSysCacheHashValue1(TYPEOID,
    3632             :                                                       ObjectIdGetDatum(typid));
    3633             : 
    3634       18256 :         root->glob->invalItems = lappend(root->glob->invalItems, inval_item);
    3635             :     }
    3636       18256 : }
    3637             : 
    3638             : /*
    3639             :  * extract_query_dependencies
    3640             :  *      Given a rewritten, but not yet planned, query or queries
    3641             :  *      (i.e. a Query node or list of Query nodes), extract dependencies
    3642             :  *      just as set_plan_references would do.  Also detect whether any
    3643             :  *      rewrite steps were affected by RLS.
    3644             :  *
    3645             :  * This is needed by plancache.c to handle invalidation of cached unplanned
    3646             :  * queries.
    3647             :  *
    3648             :  * Note: this does not go through eval_const_expressions, and hence doesn't
    3649             :  * reflect its additions of inlined functions and elided CoerceToDomain nodes
    3650             :  * to the invalItems list.  This is obviously OK for functions, since we'll
    3651             :  * see them in the original query tree anyway.  For domains, it's OK because
    3652             :  * we don't care about domains unless they get elided.  That is, a plan might
    3653             :  * have domain dependencies that the query tree doesn't.
    3654             :  */
    3655             : void
    3656       62158 : extract_query_dependencies(Node *query,
    3657             :                            List **relationOids,
    3658             :                            List **invalItems,
    3659             :                            bool *hasRowSecurity)
    3660             : {
    3661             :     PlannerGlobal glob;
    3662             :     PlannerInfo root;
    3663             : 
    3664             :     /* Make up dummy planner state so we can use this module's machinery */
    3665     1616108 :     MemSet(&glob, 0, sizeof(glob));
    3666       62158 :     glob.type = T_PlannerGlobal;
    3667       62158 :     glob.relationOids = NIL;
    3668       62158 :     glob.invalItems = NIL;
    3669             :     /* Hack: we use glob.dependsOnRole to collect hasRowSecurity flags */
    3670       62158 :     glob.dependsOnRole = false;
    3671             : 
    3672     5842852 :     MemSet(&root, 0, sizeof(root));
    3673       62158 :     root.type = T_PlannerInfo;
    3674       62158 :     root.glob = &glob;
    3675             : 
    3676       62158 :     (void) extract_query_dependencies_walker(query, &root);
    3677             : 
    3678       62158 :     *relationOids = glob.relationOids;
    3679       62158 :     *invalItems = glob.invalItems;
    3680       62158 :     *hasRowSecurity = glob.dependsOnRole;
    3681       62158 : }
    3682             : 
    3683             : /*
    3684             :  * Tree walker for extract_query_dependencies.
    3685             :  *
    3686             :  * This is exported so that expression_planner_with_deps can call it on
    3687             :  * simple expressions (post-planning, not before planning, in that case).
    3688             :  * In that usage, glob.dependsOnRole isn't meaningful, but the relationOids
    3689             :  * and invalItems lists are added to as needed.
    3690             :  */
    3691             : bool
    3692     1668014 : extract_query_dependencies_walker(Node *node, PlannerInfo *context)
    3693             : {
    3694     1668014 :     if (node == NULL)
    3695      795024 :         return false;
    3696             :     Assert(!IsA(node, PlaceHolderVar));
    3697      872990 :     if (IsA(node, Query))
    3698             :     {
    3699       66300 :         Query      *query = (Query *) node;
    3700             :         ListCell   *lc;
    3701             : 
    3702       66300 :         if (query->commandType == CMD_UTILITY)
    3703             :         {
    3704             :             /*
    3705             :              * This logic must handle any utility command for which parse
    3706             :              * analysis was nontrivial (cf. stmt_requires_parse_analysis).
    3707             :              *
    3708             :              * Notably, CALL requires its own processing.
    3709             :              */
    3710        9958 :             if (IsA(query->utilityStmt, CallStmt))
    3711             :             {
    3712         116 :                 CallStmt   *callstmt = (CallStmt *) query->utilityStmt;
    3713             : 
    3714             :                 /* We need not examine funccall, just the transformed exprs */
    3715         116 :                 (void) extract_query_dependencies_walker((Node *) callstmt->funcexpr,
    3716             :                                                          context);
    3717         116 :                 (void) extract_query_dependencies_walker((Node *) callstmt->outargs,
    3718             :                                                          context);
    3719         116 :                 return false;
    3720             :             }
    3721             : 
    3722             :             /*
    3723             :              * Ignore other utility statements, except those (such as EXPLAIN)
    3724             :              * that contain a parsed-but-not-planned query.  For those, we
    3725             :              * just need to transfer our attention to the contained query.
    3726             :              */
    3727        9842 :             query = UtilityContainsQuery(query->utilityStmt);
    3728        9842 :             if (query == NULL)
    3729          36 :                 return false;
    3730             :         }
    3731             : 
    3732             :         /* Remember if any Query has RLS quals applied by rewriter */
    3733       66148 :         if (query->hasRowSecurity)
    3734         222 :             context->glob->dependsOnRole = true;
    3735             : 
    3736             :         /* Collect relation OIDs in this Query's rtable */
    3737      106864 :         foreach(lc, query->rtable)
    3738             :         {
    3739       40716 :             RangeTblEntry *rte = (RangeTblEntry *) lfirst(lc);
    3740             : 
    3741       40716 :             if (rte->rtekind == RTE_RELATION ||
    3742        6956 :                 (rte->rtekind == RTE_SUBQUERY && OidIsValid(rte->relid)) ||
    3743        6566 :                 (rte->rtekind == RTE_NAMEDTUPLESTORE && OidIsValid(rte->relid)))
    3744       34626 :                 context->glob->relationOids =
    3745       34626 :                     lappend_oid(context->glob->relationOids, rte->relid);
    3746             :         }
    3747             : 
    3748             :         /* And recurse into the query's subexpressions */
    3749       66148 :         return query_tree_walker(query, extract_query_dependencies_walker,
    3750             :                                  context, 0);
    3751             :     }
    3752             :     /* Extract function dependencies and check for regclass Consts */
    3753      806690 :     fix_expr_common(context, node);
    3754      806690 :     return expression_tree_walker(node, extract_query_dependencies_walker,
    3755             :                                   context);
    3756             : }

Generated by: LCOV version 1.16