LCOV - code coverage report
Current view: top level - src/backend/optimizer/prep - prepjointree.c (source / functions) Hit Total Coverage
Test: PostgreSQL 15devel Lines: 912 1029 88.6 %
Date: 2021-12-05 02:08:31 Functions: 39 41 95.1 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * prepjointree.c
       4             :  *    Planner preprocessing for subqueries and join tree manipulation.
       5             :  *
       6             :  * NOTE: the intended sequence for invoking these operations is
       7             :  *      replace_empty_jointree
       8             :  *      pull_up_sublinks
       9             :  *      preprocess_function_rtes
      10             :  *      pull_up_subqueries
      11             :  *      flatten_simple_union_all
      12             :  *      do expression preprocessing (including flattening JOIN alias vars)
      13             :  *      reduce_outer_joins
      14             :  *      remove_useless_result_rtes
      15             :  *
      16             :  *
      17             :  * Portions Copyright (c) 1996-2021, PostgreSQL Global Development Group
      18             :  * Portions Copyright (c) 1994, Regents of the University of California
      19             :  *
      20             :  *
      21             :  * IDENTIFICATION
      22             :  *    src/backend/optimizer/prep/prepjointree.c
      23             :  *
      24             :  *-------------------------------------------------------------------------
      25             :  */
      26             : #include "postgres.h"
      27             : 
      28             : #include "catalog/pg_type.h"
      29             : #include "funcapi.h"
      30             : #include "nodes/makefuncs.h"
      31             : #include "nodes/nodeFuncs.h"
      32             : #include "optimizer/clauses.h"
      33             : #include "optimizer/optimizer.h"
      34             : #include "optimizer/placeholder.h"
      35             : #include "optimizer/prep.h"
      36             : #include "optimizer/subselect.h"
      37             : #include "optimizer/tlist.h"
      38             : #include "parser/parse_relation.h"
      39             : #include "parser/parsetree.h"
      40             : #include "rewrite/rewriteManip.h"
      41             : 
      42             : 
      43             : typedef struct pullup_replace_vars_context
      44             : {
      45             :     PlannerInfo *root;
      46             :     List       *targetlist;     /* tlist of subquery being pulled up */
      47             :     RangeTblEntry *target_rte;  /* RTE of subquery */
      48             :     Relids      relids;         /* relids within subquery, as numbered after
      49             :                                  * pullup (set only if target_rte->lateral) */
      50             :     bool       *outer_hasSubLinks;  /* -> outer query's hasSubLinks */
      51             :     int         varno;          /* varno of subquery */
      52             :     bool        need_phvs;      /* do we need PlaceHolderVars? */
      53             :     bool        wrap_non_vars;  /* do we need 'em on *all* non-Vars? */
      54             :     Node      **rv_cache;       /* cache for results with PHVs */
      55             : } pullup_replace_vars_context;
      56             : 
      57             : typedef struct reduce_outer_joins_state
      58             : {
      59             :     Relids      relids;         /* base relids within this subtree */
      60             :     bool        contains_outer; /* does subtree contain outer join(s)? */
      61             :     List       *sub_states;     /* List of states for subtree components */
      62             : } reduce_outer_joins_state;
      63             : 
      64             : static Node *pull_up_sublinks_jointree_recurse(PlannerInfo *root, Node *jtnode,
      65             :                                                Relids *relids);
      66             : static Node *pull_up_sublinks_qual_recurse(PlannerInfo *root, Node *node,
      67             :                                            Node **jtlink1, Relids available_rels1,
      68             :                                            Node **jtlink2, Relids available_rels2);
      69             : static Node *pull_up_subqueries_recurse(PlannerInfo *root, Node *jtnode,
      70             :                                         JoinExpr *lowest_outer_join,
      71             :                                         JoinExpr *lowest_nulling_outer_join,
      72             :                                         AppendRelInfo *containing_appendrel);
      73             : static Node *pull_up_simple_subquery(PlannerInfo *root, Node *jtnode,
      74             :                                      RangeTblEntry *rte,
      75             :                                      JoinExpr *lowest_outer_join,
      76             :                                      JoinExpr *lowest_nulling_outer_join,
      77             :                                      AppendRelInfo *containing_appendrel);
      78             : static Node *pull_up_simple_union_all(PlannerInfo *root, Node *jtnode,
      79             :                                       RangeTblEntry *rte);
      80             : static void pull_up_union_leaf_queries(Node *setOp, PlannerInfo *root,
      81             :                                        int parentRTindex, Query *setOpQuery,
      82             :                                        int childRToffset);
      83             : static void make_setop_translation_list(Query *query, int newvarno,
      84             :                                         AppendRelInfo *appinfo);
      85             : static bool is_simple_subquery(PlannerInfo *root, Query *subquery,
      86             :                                RangeTblEntry *rte,
      87             :                                JoinExpr *lowest_outer_join);
      88             : static Node *pull_up_simple_values(PlannerInfo *root, Node *jtnode,
      89             :                                    RangeTblEntry *rte);
      90             : static bool is_simple_values(PlannerInfo *root, RangeTblEntry *rte);
      91             : static Node *pull_up_constant_function(PlannerInfo *root, Node *jtnode,
      92             :                                        RangeTblEntry *rte,
      93             :                                        JoinExpr *lowest_nulling_outer_join,
      94             :                                        AppendRelInfo *containing_appendrel);
      95             : static bool is_simple_union_all(Query *subquery);
      96             : static bool is_simple_union_all_recurse(Node *setOp, Query *setOpQuery,
      97             :                                         List *colTypes);
      98             : static bool is_safe_append_member(Query *subquery);
      99             : static bool jointree_contains_lateral_outer_refs(PlannerInfo *root,
     100             :                                                  Node *jtnode, bool restricted,
     101             :                                                  Relids safe_upper_varnos);
     102             : static void perform_pullup_replace_vars(PlannerInfo *root,
     103             :                                         pullup_replace_vars_context *rvcontext,
     104             :                                         JoinExpr *lowest_nulling_outer_join,
     105             :                                         AppendRelInfo *containing_appendrel);
     106             : static void replace_vars_in_jointree(Node *jtnode,
     107             :                                      pullup_replace_vars_context *context,
     108             :                                      JoinExpr *lowest_nulling_outer_join);
     109             : static Node *pullup_replace_vars(Node *expr,
     110             :                                  pullup_replace_vars_context *context);
     111             : static Node *pullup_replace_vars_callback(Var *var,
     112             :                                           replace_rte_variables_context *context);
     113             : static Query *pullup_replace_vars_subquery(Query *query,
     114             :                                            pullup_replace_vars_context *context);
     115             : static reduce_outer_joins_state *reduce_outer_joins_pass1(Node *jtnode);
     116             : static void reduce_outer_joins_pass2(Node *jtnode,
     117             :                                      reduce_outer_joins_state *state,
     118             :                                      PlannerInfo *root,
     119             :                                      Relids nonnullable_rels,
     120             :                                      List *nonnullable_vars,
     121             :                                      List *forced_null_vars);
     122             : static Node *remove_useless_results_recurse(PlannerInfo *root, Node *jtnode);
     123             : static int  get_result_relid(PlannerInfo *root, Node *jtnode);
     124             : static void remove_result_refs(PlannerInfo *root, int varno, Node *newjtloc);
     125             : static bool find_dependent_phvs(PlannerInfo *root, int varno);
     126             : static bool find_dependent_phvs_in_jointree(PlannerInfo *root,
     127             :                                             Node *node, int varno);
     128             : static void substitute_phv_relids(Node *node,
     129             :                                   int varno, Relids subrelids);
     130             : static void fix_append_rel_relids(List *append_rel_list, int varno,
     131             :                                   Relids subrelids);
     132             : static Node *find_jointree_node_for_rel(Node *jtnode, int relid);
     133             : 
     134             : 
     135             : /*
     136             :  * replace_empty_jointree
     137             :  *      If the Query's jointree is empty, replace it with a dummy RTE_RESULT
     138             :  *      relation.
     139             :  *
     140             :  * By doing this, we can avoid a bunch of corner cases that formerly existed
     141             :  * for SELECTs with omitted FROM clauses.  An example is that a subquery
     142             :  * with empty jointree previously could not be pulled up, because that would
     143             :  * have resulted in an empty relid set, making the subquery not uniquely
     144             :  * identifiable for join or PlaceHolderVar processing.
     145             :  *
     146             :  * Unlike most other functions in this file, this function doesn't recurse;
     147             :  * we rely on other processing to invoke it on sub-queries at suitable times.
     148             :  */
     149             : void
     150      479912 : replace_empty_jointree(Query *parse)
     151             : {
     152             :     RangeTblEntry *rte;
     153             :     Index       rti;
     154             :     RangeTblRef *rtr;
     155             : 
     156             :     /* Nothing to do if jointree is already nonempty */
     157      479912 :     if (parse->jointree->fromlist != NIL)
     158      343906 :         return;
     159             : 
     160             :     /* We mustn't change it in the top level of a setop tree, either */
     161      139430 :     if (parse->setOperations)
     162        3424 :         return;
     163             : 
     164             :     /* Create suitable RTE */
     165      136006 :     rte = makeNode(RangeTblEntry);
     166      136006 :     rte->rtekind = RTE_RESULT;
     167      136006 :     rte->eref = makeAlias("*RESULT*", NIL);
     168             : 
     169             :     /* Add it to rangetable */
     170      136006 :     parse->rtable = lappend(parse->rtable, rte);
     171      136006 :     rti = list_length(parse->rtable);
     172             : 
     173             :     /* And jam a reference into the jointree */
     174      136006 :     rtr = makeNode(RangeTblRef);
     175      136006 :     rtr->rtindex = rti;
     176      136006 :     parse->jointree->fromlist = list_make1(rtr);
     177             : }
     178             : 
     179             : /*
     180             :  * pull_up_sublinks
     181             :  *      Attempt to pull up ANY and EXISTS SubLinks to be treated as
     182             :  *      semijoins or anti-semijoins.
     183             :  *
     184             :  * A clause "foo op ANY (sub-SELECT)" can be processed by pulling the
     185             :  * sub-SELECT up to become a rangetable entry and treating the implied
     186             :  * comparisons as quals of a semijoin.  However, this optimization *only*
     187             :  * works at the top level of WHERE or a JOIN/ON clause, because we cannot
     188             :  * distinguish whether the ANY ought to return FALSE or NULL in cases
     189             :  * involving NULL inputs.  Also, in an outer join's ON clause we can only
     190             :  * do this if the sublink is degenerate (ie, references only the nullable
     191             :  * side of the join).  In that case it is legal to push the semijoin
     192             :  * down into the nullable side of the join.  If the sublink references any
     193             :  * nonnullable-side variables then it would have to be evaluated as part
     194             :  * of the outer join, which makes things way too complicated.
     195             :  *
     196             :  * Under similar conditions, EXISTS and NOT EXISTS clauses can be handled
     197             :  * by pulling up the sub-SELECT and creating a semijoin or anti-semijoin.
     198             :  *
     199             :  * This routine searches for such clauses and does the necessary parsetree
     200             :  * transformations if any are found.
     201             :  *
     202             :  * This routine has to run before preprocess_expression(), so the quals
     203             :  * clauses are not yet reduced to implicit-AND format, and are not guaranteed
     204             :  * to be AND/OR-flat either.  That means we need to recursively search through
     205             :  * explicit AND clauses.  We stop as soon as we hit a non-AND item.
     206             :  */
     207             : void
     208       71736 : pull_up_sublinks(PlannerInfo *root)
     209             : {
     210             :     Node       *jtnode;
     211             :     Relids      relids;
     212             : 
     213             :     /* Begin recursion through the jointree */
     214       71736 :     jtnode = pull_up_sublinks_jointree_recurse(root,
     215       71736 :                                                (Node *) root->parse->jointree,
     216             :                                                &relids);
     217             : 
     218             :     /*
     219             :      * root->parse->jointree must always be a FromExpr, so insert a dummy one
     220             :      * if we got a bare RangeTblRef or JoinExpr out of the recursion.
     221             :      */
     222       71736 :     if (IsA(jtnode, FromExpr))
     223       61618 :         root->parse->jointree = (FromExpr *) jtnode;
     224             :     else
     225       10118 :         root->parse->jointree = makeFromExpr(list_make1(jtnode), NULL);
     226       71736 : }
     227             : 
     228             : /*
     229             :  * Recurse through jointree nodes for pull_up_sublinks()
     230             :  *
     231             :  * In addition to returning the possibly-modified jointree node, we return
     232             :  * a relids set of the contained rels into *relids.
     233             :  */
     234             : static Node *
     235      322686 : pull_up_sublinks_jointree_recurse(PlannerInfo *root, Node *jtnode,
     236             :                                   Relids *relids)
     237             : {
     238      322686 :     if (jtnode == NULL)
     239             :     {
     240           0 :         *relids = NULL;
     241             :     }
     242      322686 :     else if (IsA(jtnode, RangeTblRef))
     243             :     {
     244      167402 :         int         varno = ((RangeTblRef *) jtnode)->rtindex;
     245             : 
     246      167402 :         *relids = bms_make_singleton(varno);
     247             :         /* jtnode is returned unmodified */
     248             :     }
     249      155284 :     else if (IsA(jtnode, FromExpr))
     250             :     {
     251       71740 :         FromExpr   *f = (FromExpr *) jtnode;
     252       71740 :         List       *newfromlist = NIL;
     253       71740 :         Relids      frelids = NULL;
     254             :         FromExpr   *newf;
     255             :         Node       *jtlink;
     256             :         ListCell   *l;
     257             : 
     258             :         /* First, recurse to process children and collect their relids */
     259      144970 :         foreach(l, f->fromlist)
     260             :         {
     261             :             Node       *newchild;
     262             :             Relids      childrelids;
     263             : 
     264       73230 :             newchild = pull_up_sublinks_jointree_recurse(root,
     265       73230 :                                                          lfirst(l),
     266             :                                                          &childrelids);
     267       73230 :             newfromlist = lappend(newfromlist, newchild);
     268       73230 :             frelids = bms_join(frelids, childrelids);
     269             :         }
     270             :         /* Build the replacement FromExpr; no quals yet */
     271       71740 :         newf = makeFromExpr(newfromlist, NULL);
     272             :         /* Set up a link representing the rebuilt jointree */
     273       71740 :         jtlink = (Node *) newf;
     274             :         /* Now process qual --- all children are available for use */
     275       71740 :         newf->quals = pull_up_sublinks_qual_recurse(root, f->quals,
     276             :                                                     &jtlink, frelids,
     277             :                                                     NULL, NULL);
     278             : 
     279             :         /*
     280             :          * Note that the result will be either newf, or a stack of JoinExprs
     281             :          * with newf at the base.  We rely on subsequent optimization steps to
     282             :          * flatten this and rearrange the joins as needed.
     283             :          *
     284             :          * Although we could include the pulled-up subqueries in the returned
     285             :          * relids, there's no need since upper quals couldn't refer to their
     286             :          * outputs anyway.
     287             :          */
     288       71740 :         *relids = frelids;
     289       71740 :         jtnode = jtlink;
     290             :     }
     291       83544 :     else if (IsA(jtnode, JoinExpr))
     292             :     {
     293             :         JoinExpr   *j;
     294             :         Relids      leftrelids;
     295             :         Relids      rightrelids;
     296             :         Node       *jtlink;
     297             : 
     298             :         /*
     299             :          * Make a modifiable copy of join node, but don't bother copying its
     300             :          * subnodes (yet).
     301             :          */
     302       83544 :         j = (JoinExpr *) palloc(sizeof(JoinExpr));
     303       83544 :         memcpy(j, jtnode, sizeof(JoinExpr));
     304       83544 :         jtlink = (Node *) j;
     305             : 
     306             :         /* Recurse to process children and collect their relids */
     307       83544 :         j->larg = pull_up_sublinks_jointree_recurse(root, j->larg,
     308             :                                                     &leftrelids);
     309       83544 :         j->rarg = pull_up_sublinks_jointree_recurse(root, j->rarg,
     310             :                                                     &rightrelids);
     311             : 
     312             :         /*
     313             :          * Now process qual, showing appropriate child relids as available,
     314             :          * and attach any pulled-up jointree items at the right place. In the
     315             :          * inner-join case we put new JoinExprs above the existing one (much
     316             :          * as for a FromExpr-style join).  In outer-join cases the new
     317             :          * JoinExprs must go into the nullable side of the outer join. The
     318             :          * point of the available_rels machinations is to ensure that we only
     319             :          * pull up quals for which that's okay.
     320             :          *
     321             :          * We don't expect to see any pre-existing JOIN_SEMI or JOIN_ANTI
     322             :          * nodes here.
     323             :          */
     324       83544 :         switch (j->jointype)
     325             :         {
     326       25614 :             case JOIN_INNER:
     327       25614 :                 j->quals = pull_up_sublinks_qual_recurse(root, j->quals,
     328             :                                                          &jtlink,
     329             :                                                          bms_union(leftrelids,
     330             :                                                                    rightrelids),
     331             :                                                          NULL, NULL);
     332       25614 :                 break;
     333       57930 :             case JOIN_LEFT:
     334       57930 :                 j->quals = pull_up_sublinks_qual_recurse(root, j->quals,
     335             :                                                          &j->rarg,
     336             :                                                          rightrelids,
     337             :                                                          NULL, NULL);
     338       57930 :                 break;
     339           0 :             case JOIN_FULL:
     340             :                 /* can't do anything with full-join quals */
     341           0 :                 break;
     342           0 :             case JOIN_RIGHT:
     343           0 :                 j->quals = pull_up_sublinks_qual_recurse(root, j->quals,
     344             :                                                          &j->larg,
     345             :                                                          leftrelids,
     346             :                                                          NULL, NULL);
     347           0 :                 break;
     348           0 :             default:
     349           0 :                 elog(ERROR, "unrecognized join type: %d",
     350             :                      (int) j->jointype);
     351             :                 break;
     352             :         }
     353             : 
     354             :         /*
     355             :          * Although we could include the pulled-up subqueries in the returned
     356             :          * relids, there's no need since upper quals couldn't refer to their
     357             :          * outputs anyway.  But we *do* need to include the join's own rtindex
     358             :          * because we haven't yet collapsed join alias variables, so upper
     359             :          * levels would mistakenly think they couldn't use references to this
     360             :          * join.
     361             :          */
     362       83544 :         *relids = bms_join(leftrelids, rightrelids);
     363       83544 :         if (j->rtindex)
     364       83544 :             *relids = bms_add_member(*relids, j->rtindex);
     365       83544 :         jtnode = jtlink;
     366             :     }
     367             :     else
     368           0 :         elog(ERROR, "unrecognized node type: %d",
     369             :              (int) nodeTag(jtnode));
     370      322686 :     return jtnode;
     371             : }
     372             : 
     373             : /*
     374             :  * Recurse through top-level qual nodes for pull_up_sublinks()
     375             :  *
     376             :  * jtlink1 points to the link in the jointree where any new JoinExprs should
     377             :  * be inserted if they reference available_rels1 (i.e., available_rels1
     378             :  * denotes the relations present underneath jtlink1).  Optionally, jtlink2 can
     379             :  * point to a second link where new JoinExprs should be inserted if they
     380             :  * reference available_rels2 (pass NULL for both those arguments if not used).
     381             :  * Note that SubLinks referencing both sets of variables cannot be optimized.
     382             :  * If we find multiple pull-up-able SubLinks, they'll get stacked onto jtlink1
     383             :  * and/or jtlink2 in the order we encounter them.  We rely on subsequent
     384             :  * optimization to rearrange the stack if appropriate.
     385             :  *
     386             :  * Returns the replacement qual node, or NULL if the qual should be removed.
     387             :  */
     388             : static Node *
     389      328470 : pull_up_sublinks_qual_recurse(PlannerInfo *root, Node *node,
     390             :                               Node **jtlink1, Relids available_rels1,
     391             :                               Node **jtlink2, Relids available_rels2)
     392             : {
     393      328470 :     if (node == NULL)
     394        7406 :         return NULL;
     395      321064 :     if (IsA(node, SubLink))
     396             :     {
     397        1004 :         SubLink    *sublink = (SubLink *) node;
     398             :         JoinExpr   *j;
     399             :         Relids      child_rels;
     400             : 
     401             :         /* Is it a convertible ANY or EXISTS clause? */
     402        1004 :         if (sublink->subLinkType == ANY_SUBLINK)
     403             :         {
     404         752 :             if ((j = convert_ANY_sublink_to_join(root, sublink,
     405             :                                                  available_rels1)) != NULL)
     406             :             {
     407             :                 /* Yes; insert the new join node into the join tree */
     408         680 :                 j->larg = *jtlink1;
     409         680 :                 *jtlink1 = (Node *) j;
     410             :                 /* Recursively process pulled-up jointree nodes */
     411         680 :                 j->rarg = pull_up_sublinks_jointree_recurse(root,
     412             :                                                             j->rarg,
     413             :                                                             &child_rels);
     414             : 
     415             :                 /*
     416             :                  * Now recursively process the pulled-up quals.  Any inserted
     417             :                  * joins can get stacked onto either j->larg or j->rarg,
     418             :                  * depending on which rels they reference.
     419             :                  */
     420         680 :                 j->quals = pull_up_sublinks_qual_recurse(root,
     421             :                                                          j->quals,
     422             :                                                          &j->larg,
     423             :                                                          available_rels1,
     424             :                                                          &j->rarg,
     425             :                                                          child_rels);
     426             :                 /* Return NULL representing constant TRUE */
     427         680 :                 return NULL;
     428             :             }
     429          72 :             if (available_rels2 != NULL &&
     430           0 :                 (j = convert_ANY_sublink_to_join(root, sublink,
     431             :                                                  available_rels2)) != NULL)
     432             :             {
     433             :                 /* Yes; insert the new join node into the join tree */
     434           0 :                 j->larg = *jtlink2;
     435           0 :                 *jtlink2 = (Node *) j;
     436             :                 /* Recursively process pulled-up jointree nodes */
     437           0 :                 j->rarg = pull_up_sublinks_jointree_recurse(root,
     438             :                                                             j->rarg,
     439             :                                                             &child_rels);
     440             : 
     441             :                 /*
     442             :                  * Now recursively process the pulled-up quals.  Any inserted
     443             :                  * joins can get stacked onto either j->larg or j->rarg,
     444             :                  * depending on which rels they reference.
     445             :                  */
     446           0 :                 j->quals = pull_up_sublinks_qual_recurse(root,
     447             :                                                          j->quals,
     448             :                                                          &j->larg,
     449             :                                                          available_rels2,
     450             :                                                          &j->rarg,
     451             :                                                          child_rels);
     452             :                 /* Return NULL representing constant TRUE */
     453           0 :                 return NULL;
     454             :             }
     455             :         }
     456         252 :         else if (sublink->subLinkType == EXISTS_SUBLINK)
     457             :         {
     458         224 :             if ((j = convert_EXISTS_sublink_to_join(root, sublink, false,
     459             :                                                     available_rels1)) != NULL)
     460             :             {
     461             :                 /* Yes; insert the new join node into the join tree */
     462         170 :                 j->larg = *jtlink1;
     463         170 :                 *jtlink1 = (Node *) j;
     464             :                 /* Recursively process pulled-up jointree nodes */
     465         170 :                 j->rarg = pull_up_sublinks_jointree_recurse(root,
     466             :                                                             j->rarg,
     467             :                                                             &child_rels);
     468             : 
     469             :                 /*
     470             :                  * Now recursively process the pulled-up quals.  Any inserted
     471             :                  * joins can get stacked onto either j->larg or j->rarg,
     472             :                  * depending on which rels they reference.
     473             :                  */
     474         170 :                 j->quals = pull_up_sublinks_qual_recurse(root,
     475             :                                                          j->quals,
     476             :                                                          &j->larg,
     477             :                                                          available_rels1,
     478             :                                                          &j->rarg,
     479             :                                                          child_rels);
     480             :                 /* Return NULL representing constant TRUE */
     481         170 :                 return NULL;
     482             :             }
     483          54 :             if (available_rels2 != NULL &&
     484           0 :                 (j = convert_EXISTS_sublink_to_join(root, sublink, false,
     485             :                                                     available_rels2)) != NULL)
     486             :             {
     487             :                 /* Yes; insert the new join node into the join tree */
     488           0 :                 j->larg = *jtlink2;
     489           0 :                 *jtlink2 = (Node *) j;
     490             :                 /* Recursively process pulled-up jointree nodes */
     491           0 :                 j->rarg = pull_up_sublinks_jointree_recurse(root,
     492             :                                                             j->rarg,
     493             :                                                             &child_rels);
     494             : 
     495             :                 /*
     496             :                  * Now recursively process the pulled-up quals.  Any inserted
     497             :                  * joins can get stacked onto either j->larg or j->rarg,
     498             :                  * depending on which rels they reference.
     499             :                  */
     500           0 :                 j->quals = pull_up_sublinks_qual_recurse(root,
     501             :                                                          j->quals,
     502             :                                                          &j->larg,
     503             :                                                          available_rels2,
     504             :                                                          &j->rarg,
     505             :                                                          child_rels);
     506             :                 /* Return NULL representing constant TRUE */
     507           0 :                 return NULL;
     508             :             }
     509             :         }
     510             :         /* Else return it unmodified */
     511         154 :         return node;
     512             :     }
     513      320060 :     if (is_notclause(node))
     514             :     {
     515             :         /* If the immediate argument of NOT is EXISTS, try to convert */
     516       12490 :         SubLink    *sublink = (SubLink *) get_notclausearg((Expr *) node);
     517             :         JoinExpr   *j;
     518             :         Relids      child_rels;
     519             : 
     520       12490 :         if (sublink && IsA(sublink, SubLink))
     521             :         {
     522        9858 :             if (sublink->subLinkType == EXISTS_SUBLINK)
     523             :             {
     524        9802 :                 if ((j = convert_EXISTS_sublink_to_join(root, sublink, true,
     525             :                                                         available_rels1)) != NULL)
     526             :                 {
     527             :                     /* Yes; insert the new join node into the join tree */
     528        9782 :                     j->larg = *jtlink1;
     529        9782 :                     *jtlink1 = (Node *) j;
     530             :                     /* Recursively process pulled-up jointree nodes */
     531        9782 :                     j->rarg = pull_up_sublinks_jointree_recurse(root,
     532             :                                                                 j->rarg,
     533             :                                                                 &child_rels);
     534             : 
     535             :                     /*
     536             :                      * Now recursively process the pulled-up quals.  Because
     537             :                      * we are underneath a NOT, we can't pull up sublinks that
     538             :                      * reference the left-hand stuff, but it's still okay to
     539             :                      * pull up sublinks referencing j->rarg.
     540             :                      */
     541        9782 :                     j->quals = pull_up_sublinks_qual_recurse(root,
     542             :                                                              j->quals,
     543             :                                                              &j->rarg,
     544             :                                                              child_rels,
     545             :                                                              NULL, NULL);
     546             :                     /* Return NULL representing constant TRUE */
     547        9782 :                     return NULL;
     548             :                 }
     549          20 :                 if (available_rels2 != NULL &&
     550           0 :                     (j = convert_EXISTS_sublink_to_join(root, sublink, true,
     551             :                                                         available_rels2)) != NULL)
     552             :                 {
     553             :                     /* Yes; insert the new join node into the join tree */
     554           0 :                     j->larg = *jtlink2;
     555           0 :                     *jtlink2 = (Node *) j;
     556             :                     /* Recursively process pulled-up jointree nodes */
     557           0 :                     j->rarg = pull_up_sublinks_jointree_recurse(root,
     558             :                                                                 j->rarg,
     559             :                                                                 &child_rels);
     560             : 
     561             :                     /*
     562             :                      * Now recursively process the pulled-up quals.  Because
     563             :                      * we are underneath a NOT, we can't pull up sublinks that
     564             :                      * reference the left-hand stuff, but it's still okay to
     565             :                      * pull up sublinks referencing j->rarg.
     566             :                      */
     567           0 :                     j->quals = pull_up_sublinks_qual_recurse(root,
     568             :                                                              j->quals,
     569             :                                                              &j->rarg,
     570             :                                                              child_rels,
     571             :                                                              NULL, NULL);
     572             :                     /* Return NULL representing constant TRUE */
     573           0 :                     return NULL;
     574             :                 }
     575             :             }
     576             :         }
     577             :         /* Else return it unmodified */
     578        2708 :         return node;
     579             :     }
     580      307570 :     if (is_andclause(node))
     581             :     {
     582             :         /* Recurse into AND clause */
     583       64760 :         List       *newclauses = NIL;
     584             :         ListCell   *l;
     585             : 
     586      227314 :         foreach(l, ((BoolExpr *) node)->args)
     587             :         {
     588      162554 :             Node       *oldclause = (Node *) lfirst(l);
     589             :             Node       *newclause;
     590             : 
     591      162554 :             newclause = pull_up_sublinks_qual_recurse(root,
     592             :                                                       oldclause,
     593             :                                                       jtlink1,
     594             :                                                       available_rels1,
     595             :                                                       jtlink2,
     596             :                                                       available_rels2);
     597      162554 :             if (newclause)
     598      160356 :                 newclauses = lappend(newclauses, newclause);
     599             :         }
     600             :         /* We might have got back fewer clauses than we started with */
     601       64760 :         if (newclauses == NIL)
     602         482 :             return NULL;
     603       64278 :         else if (list_length(newclauses) == 1)
     604         614 :             return (Node *) linitial(newclauses);
     605             :         else
     606       63664 :             return (Node *) make_andclause(newclauses);
     607             :     }
     608             :     /* Stop if not an AND */
     609      242810 :     return node;
     610             : }
     611             : 
     612             : /*
     613             :  * preprocess_function_rtes
     614             :  *      Constant-simplify any FUNCTION RTEs in the FROM clause, and then
     615             :  *      attempt to "inline" any that are set-returning functions.
     616             :  *
     617             :  * If an RTE_FUNCTION rtable entry invokes a set-returning function that
     618             :  * contains just a simple SELECT, we can convert the rtable entry to an
     619             :  * RTE_SUBQUERY entry exposing the SELECT directly.  This is especially
     620             :  * useful if the subquery can then be "pulled up" for further optimization,
     621             :  * but we do it even if not, to reduce executor overhead.
     622             :  *
     623             :  * This has to be done before we have started to do any optimization of
     624             :  * subqueries, else any such steps wouldn't get applied to subqueries
     625             :  * obtained via inlining.  However, we do it after pull_up_sublinks
     626             :  * so that we can inline any functions used in SubLink subselects.
     627             :  *
     628             :  * The reason for applying const-simplification at this stage is that
     629             :  * (a) we'd need to do it anyway to inline a SRF, and (b) by doing it now,
     630             :  * we can be sure that pull_up_constant_function() will see constants
     631             :  * if there are constants to be seen.  This approach also guarantees
     632             :  * that every FUNCTION RTE has been const-simplified, allowing planner.c's
     633             :  * preprocess_expression() to skip doing it again.
     634             :  *
     635             :  * Like most of the planner, this feels free to scribble on its input data
     636             :  * structure.
     637             :  */
     638             : void
     639      469960 : preprocess_function_rtes(PlannerInfo *root)
     640             : {
     641             :     ListCell   *rt;
     642             : 
     643     1307738 :     foreach(rt, root->parse->rtable)
     644             :     {
     645      837782 :         RangeTblEntry *rte = (RangeTblEntry *) lfirst(rt);
     646             : 
     647      837782 :         if (rte->rtekind == RTE_FUNCTION)
     648             :         {
     649             :             Query      *funcquery;
     650             : 
     651             :             /* Apply const-simplification */
     652       66078 :             rte->functions = (List *)
     653       66078 :                 eval_const_expressions(root, (Node *) rte->functions);
     654             : 
     655             :             /* Check safety of expansion, and expand if possible */
     656       66078 :             funcquery = inline_set_returning_function(root, rte);
     657       66074 :             if (funcquery)
     658             :             {
     659             :                 /* Successful expansion, convert the RTE to a subquery */
     660          92 :                 rte->rtekind = RTE_SUBQUERY;
     661          92 :                 rte->subquery = funcquery;
     662          92 :                 rte->security_barrier = false;
     663             :                 /* Clear fields that should not be set in a subquery RTE */
     664          92 :                 rte->functions = NIL;
     665          92 :                 rte->funcordinality = false;
     666             :             }
     667             :         }
     668             :     }
     669      469956 : }
     670             : 
     671             : /*
     672             :  * pull_up_subqueries
     673             :  *      Look for subqueries in the rangetable that can be pulled up into
     674             :  *      the parent query.  If the subquery has no special features like
     675             :  *      grouping/aggregation then we can merge it into the parent's jointree.
     676             :  *      Also, subqueries that are simple UNION ALL structures can be
     677             :  *      converted into "append relations".
     678             :  */
     679             : void
     680      469956 : pull_up_subqueries(PlannerInfo *root)
     681             : {
     682             :     /* Top level of jointree must always be a FromExpr */
     683             :     Assert(IsA(root->parse->jointree, FromExpr));
     684             :     /* Recursion starts with no containing join nor appendrel */
     685      939908 :     root->parse->jointree = (FromExpr *)
     686      469956 :         pull_up_subqueries_recurse(root, (Node *) root->parse->jointree,
     687             :                                    NULL, NULL, NULL);
     688             :     /* We should still have a FromExpr */
     689             :     Assert(IsA(root->parse->jointree, FromExpr));
     690      469952 : }
     691             : 
     692             : /*
     693             :  * pull_up_subqueries_recurse
     694             :  *      Recursive guts of pull_up_subqueries.
     695             :  *
     696             :  * This recursively processes the jointree and returns a modified jointree.
     697             :  *
     698             :  * If this jointree node is within either side of an outer join, then
     699             :  * lowest_outer_join references the lowest such JoinExpr node; otherwise
     700             :  * it is NULL.  We use this to constrain the effects of LATERAL subqueries.
     701             :  *
     702             :  * If this jointree node is within the nullable side of an outer join, then
     703             :  * lowest_nulling_outer_join references the lowest such JoinExpr node;
     704             :  * otherwise it is NULL.  This forces use of the PlaceHolderVar mechanism for
     705             :  * references to non-nullable targetlist items, but only for references above
     706             :  * that join.
     707             :  *
     708             :  * If we are looking at a member subquery of an append relation,
     709             :  * containing_appendrel describes that relation; else it is NULL.
     710             :  * This forces use of the PlaceHolderVar mechanism for all non-Var targetlist
     711             :  * items, and puts some additional restrictions on what can be pulled up.
     712             :  *
     713             :  * A tricky aspect of this code is that if we pull up a subquery we have
     714             :  * to replace Vars that reference the subquery's outputs throughout the
     715             :  * parent query, including quals attached to jointree nodes above the one
     716             :  * we are currently processing!  We handle this by being careful to maintain
     717             :  * validity of the jointree structure while recursing, in the following sense:
     718             :  * whenever we recurse, all qual expressions in the tree must be reachable
     719             :  * from the top level, in case the recursive call needs to modify them.
     720             :  *
     721             :  * Notice also that we can't turn pullup_replace_vars loose on the whole
     722             :  * jointree, because it'd return a mutated copy of the tree; we have to
     723             :  * invoke it just on the quals, instead.  This behavior is what makes it
     724             :  * reasonable to pass lowest_outer_join and lowest_nulling_outer_join as
     725             :  * pointers rather than some more-indirect way of identifying the lowest
     726             :  * OJs.  Likewise, we don't replace append_rel_list members but only their
     727             :  * substructure, so the containing_appendrel reference is safe to use.
     728             :  */
     729             : static Node *
     730     1232600 : pull_up_subqueries_recurse(PlannerInfo *root, Node *jtnode,
     731             :                            JoinExpr *lowest_outer_join,
     732             :                            JoinExpr *lowest_nulling_outer_join,
     733             :                            AppendRelInfo *containing_appendrel)
     734             : {
     735             :     Assert(jtnode != NULL);
     736     1232600 :     if (IsA(jtnode, RangeTblRef))
     737             :     {
     738      623832 :         int         varno = ((RangeTblRef *) jtnode)->rtindex;
     739      623832 :         RangeTblEntry *rte = rt_fetch(varno, root->parse->rtable);
     740             : 
     741             :         /*
     742             :          * Is this a subquery RTE, and if so, is the subquery simple enough to
     743             :          * pull up?
     744             :          *
     745             :          * If we are looking at an append-relation member, we can't pull it up
     746             :          * unless is_safe_append_member says so.
     747             :          */
     748      661652 :         if (rte->rtekind == RTE_SUBQUERY &&
     749       70492 :             is_simple_subquery(root, rte->subquery, rte, lowest_outer_join) &&
     750        1916 :             (containing_appendrel == NULL ||
     751        1916 :              is_safe_append_member(rte->subquery)))
     752       32370 :             return pull_up_simple_subquery(root, jtnode, rte,
     753             :                                            lowest_outer_join,
     754             :                                            lowest_nulling_outer_join,
     755             :                                            containing_appendrel);
     756             : 
     757             :         /*
     758             :          * Alternatively, is it a simple UNION ALL subquery?  If so, flatten
     759             :          * into an "append relation".
     760             :          *
     761             :          * It's safe to do this regardless of whether this query is itself an
     762             :          * appendrel member.  (If you're thinking we should try to flatten the
     763             :          * two levels of appendrel together, you're right; but we handle that
     764             :          * in set_append_rel_pathlist, not here.)
     765             :          */
     766      596912 :         if (rte->rtekind == RTE_SUBQUERY &&
     767        5450 :             is_simple_union_all(rte->subquery))
     768         802 :             return pull_up_simple_union_all(root, jtnode, rte);
     769             : 
     770             :         /*
     771             :          * Or perhaps it's a simple VALUES RTE?
     772             :          *
     773             :          * We don't allow VALUES pullup below an outer join nor into an
     774             :          * appendrel (such cases are impossible anyway at the moment).
     775             :          */
     776      590660 :         if (rte->rtekind == RTE_VALUES &&
     777        5428 :             lowest_outer_join == NULL &&
     778        5428 :             containing_appendrel == NULL &&
     779        5428 :             is_simple_values(root, rte))
     780         692 :             return pull_up_simple_values(root, jtnode, rte);
     781             : 
     782             :         /*
     783             :          * Or perhaps it's a FUNCTION RTE that we could inline?
     784             :          */
     785      589968 :         if (rte->rtekind == RTE_FUNCTION)
     786       65982 :             return pull_up_constant_function(root, jtnode, rte,
     787             :                                              lowest_nulling_outer_join,
     788             :                                              containing_appendrel);
     789             : 
     790             :         /* Otherwise, do nothing at this node. */
     791             :     }
     792      608768 :     else if (IsA(jtnode, FromExpr))
     793             :     {
     794      480078 :         FromExpr   *f = (FromExpr *) jtnode;
     795             :         ListCell   *l;
     796             : 
     797             :         Assert(containing_appendrel == NULL);
     798             :         /* Recursively transform all the child nodes */
     799      983086 :         foreach(l, f->fromlist)
     800             :         {
     801      503012 :             lfirst(l) = pull_up_subqueries_recurse(root, lfirst(l),
     802             :                                                    lowest_outer_join,
     803             :                                                    lowest_nulling_outer_join,
     804             :                                                    NULL);
     805             :         }
     806             :     }
     807      128690 :     else if (IsA(jtnode, JoinExpr))
     808             :     {
     809      128690 :         JoinExpr   *j = (JoinExpr *) jtnode;
     810             : 
     811             :         Assert(containing_appendrel == NULL);
     812             :         /* Recurse, being careful to tell myself when inside outer join */
     813      128690 :         switch (j->jointype)
     814             :         {
     815       39054 :             case JOIN_INNER:
     816       39054 :                 j->larg = pull_up_subqueries_recurse(root, j->larg,
     817             :                                                      lowest_outer_join,
     818             :                                                      lowest_nulling_outer_join,
     819             :                                                      NULL);
     820       39054 :                 j->rarg = pull_up_subqueries_recurse(root, j->rarg,
     821             :                                                      lowest_outer_join,
     822             :                                                      lowest_nulling_outer_join,
     823             :                                                      NULL);
     824       39054 :                 break;
     825       88846 :             case JOIN_LEFT:
     826             :             case JOIN_SEMI:
     827             :             case JOIN_ANTI:
     828       88846 :                 j->larg = pull_up_subqueries_recurse(root, j->larg,
     829             :                                                      j,
     830             :                                                      lowest_nulling_outer_join,
     831             :                                                      NULL);
     832       88846 :                 j->rarg = pull_up_subqueries_recurse(root, j->rarg,
     833             :                                                      j,
     834             :                                                      j,
     835             :                                                      NULL);
     836       88846 :                 break;
     837         602 :             case JOIN_FULL:
     838         602 :                 j->larg = pull_up_subqueries_recurse(root, j->larg,
     839             :                                                      j,
     840             :                                                      j,
     841             :                                                      NULL);
     842         602 :                 j->rarg = pull_up_subqueries_recurse(root, j->rarg,
     843             :                                                      j,
     844             :                                                      j,
     845             :                                                      NULL);
     846         602 :                 break;
     847         188 :             case JOIN_RIGHT:
     848         188 :                 j->larg = pull_up_subqueries_recurse(root, j->larg,
     849             :                                                      j,
     850             :                                                      j,
     851             :                                                      NULL);
     852         188 :                 j->rarg = pull_up_subqueries_recurse(root, j->rarg,
     853             :                                                      j,
     854             :                                                      lowest_nulling_outer_join,
     855             :                                                      NULL);
     856         188 :                 break;
     857           0 :             default:
     858           0 :                 elog(ERROR, "unrecognized join type: %d",
     859             :                      (int) j->jointype);
     860             :                 break;
     861             :         }
     862             :     }
     863             :     else
     864           0 :         elog(ERROR, "unrecognized node type: %d",
     865             :              (int) nodeTag(jtnode));
     866     1132750 :     return jtnode;
     867             : }
     868             : 
     869             : /*
     870             :  * pull_up_simple_subquery
     871             :  *      Attempt to pull up a single simple subquery.
     872             :  *
     873             :  * jtnode is a RangeTblRef that has been tentatively identified as a simple
     874             :  * subquery by pull_up_subqueries.  We return the replacement jointree node,
     875             :  * or jtnode itself if we determine that the subquery can't be pulled up
     876             :  * after all.
     877             :  *
     878             :  * rte is the RangeTblEntry referenced by jtnode.  Remaining parameters are
     879             :  * as for pull_up_subqueries_recurse.
     880             :  */
     881             : static Node *
     882       32370 : pull_up_simple_subquery(PlannerInfo *root, Node *jtnode, RangeTblEntry *rte,
     883             :                         JoinExpr *lowest_outer_join,
     884             :                         JoinExpr *lowest_nulling_outer_join,
     885             :                         AppendRelInfo *containing_appendrel)
     886             : {
     887       32370 :     Query      *parse = root->parse;
     888       32370 :     int         varno = ((RangeTblRef *) jtnode)->rtindex;
     889             :     Query      *subquery;
     890             :     PlannerInfo *subroot;
     891             :     int         rtoffset;
     892             :     pullup_replace_vars_context rvcontext;
     893             :     ListCell   *lc;
     894             : 
     895             :     /*
     896             :      * Make a modifiable copy of the subquery to hack on, so that the RTE will
     897             :      * be left unchanged in case we decide below that we can't pull it up
     898             :      * after all.
     899             :      */
     900       32370 :     subquery = copyObject(rte->subquery);
     901             : 
     902             :     /*
     903             :      * Create a PlannerInfo data structure for this subquery.
     904             :      *
     905             :      * NOTE: the next few steps should match the first processing in
     906             :      * subquery_planner().  Can we refactor to avoid code duplication, or
     907             :      * would that just make things uglier?
     908             :      */
     909       32370 :     subroot = makeNode(PlannerInfo);
     910       32370 :     subroot->parse = subquery;
     911       32370 :     subroot->glob = root->glob;
     912       32370 :     subroot->query_level = root->query_level;
     913       32370 :     subroot->parent_root = root->parent_root;
     914       32370 :     subroot->plan_params = NIL;
     915       32370 :     subroot->outer_params = NULL;
     916       32370 :     subroot->planner_cxt = CurrentMemoryContext;
     917       32370 :     subroot->init_plans = NIL;
     918       32370 :     subroot->cte_plan_ids = NIL;
     919       32370 :     subroot->multiexpr_params = NIL;
     920       32370 :     subroot->eq_classes = NIL;
     921       32370 :     subroot->ec_merging_done = false;
     922       32370 :     subroot->all_result_relids = NULL;
     923       32370 :     subroot->leaf_result_relids = NULL;
     924       32370 :     subroot->append_rel_list = NIL;
     925       32370 :     subroot->row_identity_vars = NIL;
     926       32370 :     subroot->rowMarks = NIL;
     927       32370 :     memset(subroot->upper_rels, 0, sizeof(subroot->upper_rels));
     928       32370 :     memset(subroot->upper_targets, 0, sizeof(subroot->upper_targets));
     929       32370 :     subroot->processed_tlist = NIL;
     930       32370 :     subroot->update_colnos = NIL;
     931       32370 :     subroot->grouping_map = NULL;
     932       32370 :     subroot->minmax_aggs = NIL;
     933       32370 :     subroot->qual_security_level = 0;
     934       32370 :     subroot->hasRecursion = false;
     935       32370 :     subroot->wt_param_id = -1;
     936       32370 :     subroot->non_recursive_path = NULL;
     937             : 
     938             :     /* No CTEs to worry about */
     939             :     Assert(subquery->cteList == NIL);
     940             : 
     941             :     /*
     942             :      * If the FROM clause is empty, replace it with a dummy RTE_RESULT RTE, so
     943             :      * that we don't need so many special cases to deal with that situation.
     944             :      */
     945       32370 :     replace_empty_jointree(subquery);
     946             : 
     947             :     /*
     948             :      * Pull up any SubLinks within the subquery's quals, so that we don't
     949             :      * leave unoptimized SubLinks behind.
     950             :      */
     951       32370 :     if (subquery->hasSubLinks)
     952       12648 :         pull_up_sublinks(subroot);
     953             : 
     954             :     /*
     955             :      * Similarly, preprocess its function RTEs to inline any set-returning
     956             :      * functions in its rangetable.
     957             :      */
     958       32370 :     preprocess_function_rtes(subroot);
     959             : 
     960             :     /*
     961             :      * Recursively pull up the subquery's subqueries, so that
     962             :      * pull_up_subqueries' processing is complete for its jointree and
     963             :      * rangetable.
     964             :      *
     965             :      * Note: it's okay that the subquery's recursion starts with NULL for
     966             :      * containing-join info, even if we are within an outer join in the upper
     967             :      * query; the lower query starts with a clean slate for outer-join
     968             :      * semantics.  Likewise, we needn't pass down appendrel state.
     969             :      */
     970       32370 :     pull_up_subqueries(subroot);
     971             : 
     972             :     /*
     973             :      * Now we must recheck whether the subquery is still simple enough to pull
     974             :      * up.  If not, abandon processing it.
     975             :      *
     976             :      * We don't really need to recheck all the conditions involved, but it's
     977             :      * easier just to keep this "if" looking the same as the one in
     978             :      * pull_up_subqueries_recurse.
     979             :      */
     980       32370 :     if (is_simple_subquery(root, subquery, rte, lowest_outer_join) &&
     981        1614 :         (containing_appendrel == NULL || is_safe_append_member(subquery)))
     982             :     {
     983             :         /* good to go */
     984             :     }
     985             :     else
     986             :     {
     987             :         /*
     988             :          * Give up, return unmodified RangeTblRef.
     989             :          *
     990             :          * Note: The work we just did will be redone when the subquery gets
     991             :          * planned on its own.  Perhaps we could avoid that by storing the
     992             :          * modified subquery back into the rangetable, but I'm not gonna risk
     993             :          * it now.
     994             :          */
     995          36 :         return jtnode;
     996             :     }
     997             : 
     998             :     /*
     999             :      * We must flatten any join alias Vars in the subquery's targetlist,
    1000             :      * because pulling up the subquery's subqueries might have changed their
    1001             :      * expansions into arbitrary expressions, which could affect
    1002             :      * pullup_replace_vars' decisions about whether PlaceHolderVar wrappers
    1003             :      * are needed for tlist entries.  (Likely it'd be better to do
    1004             :      * flatten_join_alias_vars on the whole query tree at some earlier stage,
    1005             :      * maybe even in the rewriter; but for now let's just fix this case here.)
    1006             :      */
    1007       32334 :     subquery->targetList = (List *)
    1008       32334 :         flatten_join_alias_vars(subroot->parse, (Node *) subquery->targetList);
    1009             : 
    1010             :     /*
    1011             :      * Adjust level-0 varnos in subquery so that we can append its rangetable
    1012             :      * to upper query's.  We have to fix the subquery's append_rel_list as
    1013             :      * well.
    1014             :      */
    1015       32334 :     rtoffset = list_length(parse->rtable);
    1016       32334 :     OffsetVarNodes((Node *) subquery, rtoffset, 0);
    1017       32334 :     OffsetVarNodes((Node *) subroot->append_rel_list, rtoffset, 0);
    1018             : 
    1019             :     /*
    1020             :      * Upper-level vars in subquery are now one level closer to their parent
    1021             :      * than before.
    1022             :      */
    1023       32334 :     IncrementVarSublevelsUp((Node *) subquery, -1, 1);
    1024       32334 :     IncrementVarSublevelsUp((Node *) subroot->append_rel_list, -1, 1);
    1025             : 
    1026             :     /*
    1027             :      * The subquery's targetlist items are now in the appropriate form to
    1028             :      * insert into the top query, except that we may need to wrap them in
    1029             :      * PlaceHolderVars.  Set up required context data for pullup_replace_vars.
    1030             :      */
    1031       32334 :     rvcontext.root = root;
    1032       32334 :     rvcontext.targetlist = subquery->targetList;
    1033       32334 :     rvcontext.target_rte = rte;
    1034       32334 :     if (rte->lateral)
    1035         380 :         rvcontext.relids = get_relids_in_jointree((Node *) subquery->jointree,
    1036             :                                                   true);
    1037             :     else                        /* won't need relids */
    1038       31954 :         rvcontext.relids = NULL;
    1039       32334 :     rvcontext.outer_hasSubLinks = &parse->hasSubLinks;
    1040       32334 :     rvcontext.varno = varno;
    1041             :     /* these flags will be set below, if needed */
    1042       32334 :     rvcontext.need_phvs = false;
    1043       32334 :     rvcontext.wrap_non_vars = false;
    1044             :     /* initialize cache array with indexes 0 .. length(tlist) */
    1045       32334 :     rvcontext.rv_cache = palloc0((list_length(subquery->targetList) + 1) *
    1046             :                                  sizeof(Node *));
    1047             : 
    1048             :     /*
    1049             :      * If we are under an outer join then non-nullable items and lateral
    1050             :      * references may have to be turned into PlaceHolderVars.
    1051             :      */
    1052       32334 :     if (lowest_nulling_outer_join != NULL)
    1053        1332 :         rvcontext.need_phvs = true;
    1054             : 
    1055             :     /*
    1056             :      * If we are dealing with an appendrel member then anything that's not a
    1057             :      * simple Var has to be turned into a PlaceHolderVar.  We force this to
    1058             :      * ensure that what we pull up doesn't get merged into a surrounding
    1059             :      * expression during later processing and then fail to match the
    1060             :      * expression actually available from the appendrel.
    1061             :      */
    1062       32334 :     if (containing_appendrel != NULL)
    1063             :     {
    1064        1578 :         rvcontext.need_phvs = true;
    1065        1578 :         rvcontext.wrap_non_vars = true;
    1066             :     }
    1067             : 
    1068             :     /*
    1069             :      * If the parent query uses grouping sets, we need a PlaceHolderVar for
    1070             :      * anything that's not a simple Var.  Again, this ensures that expressions
    1071             :      * retain their separate identity so that they will match grouping set
    1072             :      * columns when appropriate.  (It'd be sufficient to wrap values used in
    1073             :      * grouping set columns, and do so only in non-aggregated portions of the
    1074             :      * tlist and havingQual, but that would require a lot of infrastructure
    1075             :      * that pullup_replace_vars hasn't currently got.)
    1076             :      */
    1077       32334 :     if (parse->groupingSets)
    1078             :     {
    1079         160 :         rvcontext.need_phvs = true;
    1080         160 :         rvcontext.wrap_non_vars = true;
    1081             :     }
    1082             : 
    1083             :     /*
    1084             :      * Replace all of the top query's references to the subquery's outputs
    1085             :      * with copies of the adjusted subtlist items, being careful not to
    1086             :      * replace any of the jointree structure.
    1087             :      */
    1088       32334 :     perform_pullup_replace_vars(root, &rvcontext,
    1089             :                                 lowest_nulling_outer_join,
    1090             :                                 containing_appendrel);
    1091             : 
    1092             :     /*
    1093             :      * If the subquery had a LATERAL marker, propagate that to any of its
    1094             :      * child RTEs that could possibly now contain lateral cross-references.
    1095             :      * The children might or might not contain any actual lateral
    1096             :      * cross-references, but we have to mark the pulled-up child RTEs so that
    1097             :      * later planner stages will check for such.
    1098             :      */
    1099       32330 :     if (rte->lateral)
    1100             :     {
    1101         964 :         foreach(lc, subquery->rtable)
    1102             :         {
    1103         584 :             RangeTblEntry *child_rte = (RangeTblEntry *) lfirst(lc);
    1104             : 
    1105         584 :             switch (child_rte->rtekind)
    1106             :             {
    1107         256 :                 case RTE_RELATION:
    1108         256 :                     if (child_rte->tablesample)
    1109          12 :                         child_rte->lateral = true;
    1110         256 :                     break;
    1111         132 :                 case RTE_SUBQUERY:
    1112             :                 case RTE_FUNCTION:
    1113             :                 case RTE_VALUES:
    1114             :                 case RTE_TABLEFUNC:
    1115         132 :                     child_rte->lateral = true;
    1116         132 :                     break;
    1117         196 :                 case RTE_JOIN:
    1118             :                 case RTE_CTE:
    1119             :                 case RTE_NAMEDTUPLESTORE:
    1120             :                 case RTE_RESULT:
    1121             :                     /* these can't contain any lateral references */
    1122         196 :                     break;
    1123             :             }
    1124         584 :         }
    1125             :     }
    1126             : 
    1127             :     /*
    1128             :      * Now append the adjusted rtable entries to upper query. (We hold off
    1129             :      * until after fixing the upper rtable entries; no point in running that
    1130             :      * code on the subquery ones too.)
    1131             :      */
    1132       32330 :     parse->rtable = list_concat(parse->rtable, subquery->rtable);
    1133             : 
    1134             :     /*
    1135             :      * Pull up any FOR UPDATE/SHARE markers, too.  (OffsetVarNodes already
    1136             :      * adjusted the marker rtindexes, so just concat the lists.)
    1137             :      */
    1138       32330 :     parse->rowMarks = list_concat(parse->rowMarks, subquery->rowMarks);
    1139             : 
    1140             :     /*
    1141             :      * We also have to fix the relid sets of any PlaceHolderVar nodes in the
    1142             :      * parent query.  (This could perhaps be done by pullup_replace_vars(),
    1143             :      * but it seems cleaner to use two passes.)  Note in particular that any
    1144             :      * PlaceHolderVar nodes just created by pullup_replace_vars() will be
    1145             :      * adjusted, so having created them with the subquery's varno is correct.
    1146             :      *
    1147             :      * Likewise, relids appearing in AppendRelInfo nodes have to be fixed. We
    1148             :      * already checked that this won't require introducing multiple subrelids
    1149             :      * into the single-slot AppendRelInfo structs.
    1150             :      */
    1151       32330 :     if (parse->hasSubLinks || root->glob->lastPHId != 0 ||
    1152       25566 :         root->append_rel_list)
    1153             :     {
    1154             :         Relids      subrelids;
    1155             : 
    1156        7870 :         subrelids = get_relids_in_jointree((Node *) subquery->jointree, false);
    1157        7870 :         substitute_phv_relids((Node *) parse, varno, subrelids);
    1158        7870 :         fix_append_rel_relids(root->append_rel_list, varno, subrelids);
    1159             :     }
    1160             : 
    1161             :     /*
    1162             :      * And now add subquery's AppendRelInfos to our list.
    1163             :      */
    1164       64660 :     root->append_rel_list = list_concat(root->append_rel_list,
    1165       32330 :                                         subroot->append_rel_list);
    1166             : 
    1167             :     /*
    1168             :      * We don't have to do the equivalent bookkeeping for outer-join info,
    1169             :      * because that hasn't been set up yet.  placeholder_list likewise.
    1170             :      */
    1171             :     Assert(root->join_info_list == NIL);
    1172             :     Assert(subroot->join_info_list == NIL);
    1173             :     Assert(root->placeholder_list == NIL);
    1174             :     Assert(subroot->placeholder_list == NIL);
    1175             : 
    1176             :     /*
    1177             :      * We no longer need the RTE's copy of the subquery's query tree.  Getting
    1178             :      * rid of it saves nothing in particular so far as this level of query is
    1179             :      * concerned; but if this query level is in turn pulled up into a parent,
    1180             :      * we'd waste cycles copying the now-unused query tree.
    1181             :      */
    1182       32330 :     rte->subquery = NULL;
    1183             : 
    1184             :     /*
    1185             :      * Miscellaneous housekeeping.
    1186             :      *
    1187             :      * Although replace_rte_variables() faithfully updated parse->hasSubLinks
    1188             :      * if it copied any SubLinks out of the subquery's targetlist, we still
    1189             :      * could have SubLinks added to the query in the expressions of FUNCTION
    1190             :      * and VALUES RTEs copied up from the subquery.  So it's necessary to copy
    1191             :      * subquery->hasSubLinks anyway.  Perhaps this can be improved someday.
    1192             :      */
    1193       32330 :     parse->hasSubLinks |= subquery->hasSubLinks;
    1194             : 
    1195             :     /* If subquery had any RLS conditions, now main query does too */
    1196       32330 :     parse->hasRowSecurity |= subquery->hasRowSecurity;
    1197             : 
    1198             :     /*
    1199             :      * subquery won't be pulled up if it hasAggs, hasWindowFuncs, or
    1200             :      * hasTargetSRFs, so no work needed on those flags
    1201             :      */
    1202             : 
    1203             :     /*
    1204             :      * Return the adjusted subquery jointree to replace the RangeTblRef entry
    1205             :      * in parent's jointree; or, if the FromExpr is degenerate, just return
    1206             :      * its single member.
    1207             :      */
    1208             :     Assert(IsA(subquery->jointree, FromExpr));
    1209             :     Assert(subquery->jointree->fromlist != NIL);
    1210       57882 :     if (subquery->jointree->quals == NULL &&
    1211       25552 :         list_length(subquery->jointree->fromlist) == 1)
    1212       25408 :         return (Node *) linitial(subquery->jointree->fromlist);
    1213             : 
    1214        6922 :     return (Node *) subquery->jointree;
    1215             : }
    1216             : 
    1217             : /*
    1218             :  * pull_up_simple_union_all
    1219             :  *      Pull up a single simple UNION ALL subquery.
    1220             :  *
    1221             :  * jtnode is a RangeTblRef that has been identified as a simple UNION ALL
    1222             :  * subquery by pull_up_subqueries.  We pull up the leaf subqueries and
    1223             :  * build an "append relation" for the union set.  The result value is just
    1224             :  * jtnode, since we don't actually need to change the query jointree.
    1225             :  */
    1226             : static Node *
    1227         802 : pull_up_simple_union_all(PlannerInfo *root, Node *jtnode, RangeTblEntry *rte)
    1228             : {
    1229         802 :     int         varno = ((RangeTblRef *) jtnode)->rtindex;
    1230         802 :     Query      *subquery = rte->subquery;
    1231         802 :     int         rtoffset = list_length(root->parse->rtable);
    1232             :     List       *rtable;
    1233             : 
    1234             :     /*
    1235             :      * Make a modifiable copy of the subquery's rtable, so we can adjust
    1236             :      * upper-level Vars in it.  There are no such Vars in the setOperations
    1237             :      * tree proper, so fixing the rtable should be sufficient.
    1238             :      */
    1239         802 :     rtable = copyObject(subquery->rtable);
    1240             : 
    1241             :     /*
    1242             :      * Upper-level vars in subquery are now one level closer to their parent
    1243             :      * than before.  We don't have to worry about offsetting varnos, though,
    1244             :      * because the UNION leaf queries can't cross-reference each other.
    1245             :      */
    1246         802 :     IncrementVarSublevelsUp_rtable(rtable, -1, 1);
    1247             : 
    1248             :     /*
    1249             :      * If the UNION ALL subquery had a LATERAL marker, propagate that to all
    1250             :      * its children.  The individual children might or might not contain any
    1251             :      * actual lateral cross-references, but we have to mark the pulled-up
    1252             :      * child RTEs so that later planner stages will check for such.
    1253             :      */
    1254         802 :     if (rte->lateral)
    1255             :     {
    1256             :         ListCell   *rt;
    1257             : 
    1258         120 :         foreach(rt, rtable)
    1259             :         {
    1260          80 :             RangeTblEntry *child_rte = (RangeTblEntry *) lfirst(rt);
    1261             : 
    1262             :             Assert(child_rte->rtekind == RTE_SUBQUERY);
    1263          80 :             child_rte->lateral = true;
    1264             :         }
    1265             :     }
    1266             : 
    1267             :     /*
    1268             :      * Append child RTEs to parent rtable.
    1269             :      */
    1270         802 :     root->parse->rtable = list_concat(root->parse->rtable, rtable);
    1271             : 
    1272             :     /*
    1273             :      * Recursively scan the subquery's setOperations tree and add
    1274             :      * AppendRelInfo nodes for leaf subqueries to the parent's
    1275             :      * append_rel_list.  Also apply pull_up_subqueries to the leaf subqueries.
    1276             :      */
    1277             :     Assert(subquery->setOperations);
    1278         802 :     pull_up_union_leaf_queries(subquery->setOperations, root, varno, subquery,
    1279             :                                rtoffset);
    1280             : 
    1281             :     /*
    1282             :      * Mark the parent as an append relation.
    1283             :      */
    1284         802 :     rte->inh = true;
    1285             : 
    1286         802 :     return jtnode;
    1287             : }
    1288             : 
    1289             : /*
    1290             :  * pull_up_union_leaf_queries -- recursive guts of pull_up_simple_union_all
    1291             :  *
    1292             :  * Build an AppendRelInfo for each leaf query in the setop tree, and then
    1293             :  * apply pull_up_subqueries to the leaf query.
    1294             :  *
    1295             :  * Note that setOpQuery is the Query containing the setOp node, whose tlist
    1296             :  * contains references to all the setop output columns.  When called from
    1297             :  * pull_up_simple_union_all, this is *not* the same as root->parse, which is
    1298             :  * the parent Query we are pulling up into.
    1299             :  *
    1300             :  * parentRTindex is the appendrel parent's index in root->parse->rtable.
    1301             :  *
    1302             :  * The child RTEs have already been copied to the parent.  childRToffset
    1303             :  * tells us where in the parent's range table they were copied.  When called
    1304             :  * from flatten_simple_union_all, childRToffset is 0 since the child RTEs
    1305             :  * were already in root->parse->rtable and no RT index adjustment is needed.
    1306             :  */
    1307             : static void
    1308        3522 : pull_up_union_leaf_queries(Node *setOp, PlannerInfo *root, int parentRTindex,
    1309             :                            Query *setOpQuery, int childRToffset)
    1310             : {
    1311        3522 :     if (IsA(setOp, RangeTblRef))
    1312             :     {
    1313        2252 :         RangeTblRef *rtr = (RangeTblRef *) setOp;
    1314             :         int         childRTindex;
    1315             :         AppendRelInfo *appinfo;
    1316             : 
    1317             :         /*
    1318             :          * Calculate the index in the parent's range table
    1319             :          */
    1320        2252 :         childRTindex = childRToffset + rtr->rtindex;
    1321             : 
    1322             :         /*
    1323             :          * Build a suitable AppendRelInfo, and attach to parent's list.
    1324             :          */
    1325        2252 :         appinfo = makeNode(AppendRelInfo);
    1326        2252 :         appinfo->parent_relid = parentRTindex;
    1327        2252 :         appinfo->child_relid = childRTindex;
    1328        2252 :         appinfo->parent_reltype = InvalidOid;
    1329        2252 :         appinfo->child_reltype = InvalidOid;
    1330        2252 :         make_setop_translation_list(setOpQuery, childRTindex, appinfo);
    1331        2252 :         appinfo->parent_reloid = InvalidOid;
    1332        2252 :         root->append_rel_list = lappend(root->append_rel_list, appinfo);
    1333             : 
    1334             :         /*
    1335             :          * Recursively apply pull_up_subqueries to the new child RTE.  (We
    1336             :          * must build the AppendRelInfo first, because this will modify it.)
    1337             :          * Note that we can pass NULL for containing-join info even if we're
    1338             :          * actually under an outer join, because the child's expressions
    1339             :          * aren't going to propagate up to the join.  Also, we ignore the
    1340             :          * possibility that pull_up_subqueries_recurse() returns a different
    1341             :          * jointree node than what we pass it; if it does, the important thing
    1342             :          * is that it replaced the child relid in the AppendRelInfo node.
    1343             :          */
    1344        2252 :         rtr = makeNode(RangeTblRef);
    1345        2252 :         rtr->rtindex = childRTindex;
    1346        2252 :         (void) pull_up_subqueries_recurse(root, (Node *) rtr,
    1347             :                                           NULL, NULL, appinfo);
    1348             :     }
    1349        1270 :     else if (IsA(setOp, SetOperationStmt))
    1350             :     {
    1351        1270 :         SetOperationStmt *op = (SetOperationStmt *) setOp;
    1352             : 
    1353             :         /* Recurse to reach leaf queries */
    1354        1270 :         pull_up_union_leaf_queries(op->larg, root, parentRTindex, setOpQuery,
    1355             :                                    childRToffset);
    1356        1270 :         pull_up_union_leaf_queries(op->rarg, root, parentRTindex, setOpQuery,
    1357             :                                    childRToffset);
    1358             :     }
    1359             :     else
    1360             :     {
    1361           0 :         elog(ERROR, "unrecognized node type: %d",
    1362             :              (int) nodeTag(setOp));
    1363             :     }
    1364        3522 : }
    1365             : 
    1366             : /*
    1367             :  * make_setop_translation_list
    1368             :  *    Build the list of translations from parent Vars to child Vars for
    1369             :  *    a UNION ALL member.  (At this point it's just a simple list of
    1370             :  *    referencing Vars, but if we succeed in pulling up the member
    1371             :  *    subquery, the Vars will get replaced by pulled-up expressions.)
    1372             :  *    Also create the rather trivial reverse-translation array.
    1373             :  */
    1374             : static void
    1375        2252 : make_setop_translation_list(Query *query, int newvarno,
    1376             :                             AppendRelInfo *appinfo)
    1377             : {
    1378        2252 :     List       *vars = NIL;
    1379             :     AttrNumber *pcolnos;
    1380             :     ListCell   *l;
    1381             : 
    1382             :     /* Initialize reverse-translation array with all entries zero */
    1383             :     /* (entries for resjunk columns will stay that way) */
    1384        2252 :     appinfo->num_child_cols = list_length(query->targetList);
    1385        2252 :     appinfo->parent_colnos = pcolnos =
    1386        2252 :         (AttrNumber *) palloc0(appinfo->num_child_cols * sizeof(AttrNumber));
    1387             : 
    1388        7446 :     foreach(l, query->targetList)
    1389             :     {
    1390        5194 :         TargetEntry *tle = (TargetEntry *) lfirst(l);
    1391             : 
    1392        5194 :         if (tle->resjunk)
    1393           0 :             continue;
    1394             : 
    1395        5194 :         vars = lappend(vars, makeVarFromTargetEntry(newvarno, tle));
    1396        5194 :         pcolnos[tle->resno - 1] = tle->resno;
    1397             :     }
    1398             : 
    1399        2252 :     appinfo->translated_vars = vars;
    1400        2252 : }
    1401             : 
    1402             : /*
    1403             :  * is_simple_subquery
    1404             :  *    Check a subquery in the range table to see if it's simple enough
    1405             :  *    to pull up into the parent query.
    1406             :  *
    1407             :  * rte is the RTE_SUBQUERY RangeTblEntry that contained the subquery.
    1408             :  * (Note subquery is not necessarily equal to rte->subquery; it could be a
    1409             :  * processed copy of that.)
    1410             :  * lowest_outer_join is the lowest outer join above the subquery, or NULL.
    1411             :  */
    1412             : static bool
    1413       70190 : is_simple_subquery(PlannerInfo *root, Query *subquery, RangeTblEntry *rte,
    1414             :                    JoinExpr *lowest_outer_join)
    1415             : {
    1416             :     /*
    1417             :      * Let's just make sure it's a valid subselect ...
    1418             :      */
    1419       70190 :     if (!IsA(subquery, Query) ||
    1420       70190 :         subquery->commandType != CMD_SELECT)
    1421           0 :         elog(ERROR, "subquery is bogus");
    1422             : 
    1423             :     /*
    1424             :      * Can't currently pull up a query with setops (unless it's simple UNION
    1425             :      * ALL, which is handled by a different code path). Maybe after querytree
    1426             :      * redesign...
    1427             :      */
    1428       70190 :     if (subquery->setOperations)
    1429        1568 :         return false;
    1430             : 
    1431             :     /*
    1432             :      * Can't pull up a subquery involving grouping, aggregation, SRFs,
    1433             :      * sorting, limiting, or WITH.  (XXX WITH could possibly be allowed later)
    1434             :      *
    1435             :      * We also don't pull up a subquery that has explicit FOR UPDATE/SHARE
    1436             :      * clauses, because pullup would cause the locking to occur semantically
    1437             :      * higher than it should.  Implicit FOR UPDATE/SHARE is okay because in
    1438             :      * that case the locking was originally declared in the upper query
    1439             :      * anyway.
    1440             :      */
    1441       68622 :     if (subquery->hasAggs ||
    1442       68076 :         subquery->hasWindowFuncs ||
    1443       67980 :         subquery->hasTargetSRFs ||
    1444       66864 :         subquery->groupClause ||
    1445       66828 :         subquery->groupingSets ||
    1446       66828 :         subquery->havingQual ||
    1447       66828 :         subquery->sortClause ||
    1448       65956 :         subquery->distinctClause ||
    1449       65796 :         subquery->limitOffset ||
    1450       65612 :         subquery->limitCount ||
    1451       65440 :         subquery->hasForUpdate ||
    1452       65428 :         subquery->cteList)
    1453        3278 :         return false;
    1454             : 
    1455             :     /*
    1456             :      * Don't pull up if the RTE represents a security-barrier view; we
    1457             :      * couldn't prevent information leakage once the RTE's Vars are scattered
    1458             :      * about in the upper query.
    1459             :      */
    1460       65344 :     if (rte->security_barrier)
    1461         188 :         return false;
    1462             : 
    1463             :     /*
    1464             :      * If the subquery is LATERAL, check for pullup restrictions from that.
    1465             :      */
    1466       65156 :     if (rte->lateral)
    1467             :     {
    1468             :         bool        restricted;
    1469             :         Relids      safe_upper_varnos;
    1470             : 
    1471             :         /*
    1472             :          * The subquery's WHERE and JOIN/ON quals mustn't contain any lateral
    1473             :          * references to rels outside a higher outer join (including the case
    1474             :          * where the outer join is within the subquery itself).  In such a
    1475             :          * case, pulling up would result in a situation where we need to
    1476             :          * postpone quals from below an outer join to above it, which is
    1477             :          * probably completely wrong and in any case is a complication that
    1478             :          * doesn't seem worth addressing at the moment.
    1479             :          */
    1480         804 :         if (lowest_outer_join != NULL)
    1481             :         {
    1482         264 :             restricted = true;
    1483         264 :             safe_upper_varnos = get_relids_in_jointree((Node *) lowest_outer_join,
    1484             :                                                        true);
    1485             :         }
    1486             :         else
    1487             :         {
    1488         540 :             restricted = false;
    1489         540 :             safe_upper_varnos = NULL;   /* doesn't matter */
    1490             :         }
    1491             : 
    1492         804 :         if (jointree_contains_lateral_outer_refs(root,
    1493         804 :                                                  (Node *) subquery->jointree,
    1494             :                                                  restricted, safe_upper_varnos))
    1495           8 :             return false;
    1496             : 
    1497             :         /*
    1498             :          * If there's an outer join above the LATERAL subquery, also disallow
    1499             :          * pullup if the subquery's targetlist has any references to rels
    1500             :          * outside the outer join, since these might get pulled into quals
    1501             :          * above the subquery (but in or below the outer join) and then lead
    1502             :          * to qual-postponement issues similar to the case checked for above.
    1503             :          * (We wouldn't need to prevent pullup if no such references appear in
    1504             :          * outer-query quals, but we don't have enough info here to check
    1505             :          * that.  Also, maybe this restriction could be removed if we forced
    1506             :          * such refs to be wrapped in PlaceHolderVars, even when they're below
    1507             :          * the nearest outer join?  But it's a pretty hokey usage, so not
    1508             :          * clear this is worth sweating over.)
    1509             :          */
    1510         796 :         if (lowest_outer_join != NULL)
    1511             :         {
    1512         264 :             Relids      lvarnos = pull_varnos_of_level(root,
    1513         264 :                                                        (Node *) subquery->targetList,
    1514             :                                                        1);
    1515             : 
    1516         264 :             if (!bms_is_subset(lvarnos, safe_upper_varnos))
    1517           8 :                 return false;
    1518             :         }
    1519             :     }
    1520             : 
    1521             :     /*
    1522             :      * Don't pull up a subquery that has any volatile functions in its
    1523             :      * targetlist.  Otherwise we might introduce multiple evaluations of these
    1524             :      * functions, if they get copied to multiple places in the upper query,
    1525             :      * leading to surprising results.  (Note: the PlaceHolderVar mechanism
    1526             :      * doesn't quite guarantee single evaluation; else we could pull up anyway
    1527             :      * and just wrap such items in PlaceHolderVars ...)
    1528             :      */
    1529       65140 :     if (contain_volatile_functions((Node *) subquery->targetList))
    1530          98 :         return false;
    1531             : 
    1532       65042 :     return true;
    1533             : }
    1534             : 
    1535             : /*
    1536             :  * pull_up_simple_values
    1537             :  *      Pull up a single simple VALUES RTE.
    1538             :  *
    1539             :  * jtnode is a RangeTblRef that has been identified as a simple VALUES RTE
    1540             :  * by pull_up_subqueries.  We always return a RangeTblRef representing a
    1541             :  * RESULT RTE to replace it (all failure cases should have been detected by
    1542             :  * is_simple_values()).  Actually, what we return is just jtnode, because
    1543             :  * we replace the VALUES RTE in the rangetable with the RESULT RTE.
    1544             :  *
    1545             :  * rte is the RangeTblEntry referenced by jtnode.  Because of the limited
    1546             :  * possible usage of VALUES RTEs, we do not need the remaining parameters
    1547             :  * of pull_up_subqueries_recurse.
    1548             :  */
    1549             : static Node *
    1550         692 : pull_up_simple_values(PlannerInfo *root, Node *jtnode, RangeTblEntry *rte)
    1551             : {
    1552         692 :     Query      *parse = root->parse;
    1553         692 :     int         varno = ((RangeTblRef *) jtnode)->rtindex;
    1554             :     List       *values_list;
    1555             :     List       *tlist;
    1556             :     AttrNumber  attrno;
    1557             :     pullup_replace_vars_context rvcontext;
    1558             :     ListCell   *lc;
    1559             : 
    1560             :     Assert(rte->rtekind == RTE_VALUES);
    1561             :     Assert(list_length(rte->values_lists) == 1);
    1562             : 
    1563             :     /*
    1564             :      * Need a modifiable copy of the VALUES list to hack on, just in case it's
    1565             :      * multiply referenced.
    1566             :      */
    1567         692 :     values_list = copyObject(linitial(rte->values_lists));
    1568             : 
    1569             :     /*
    1570             :      * The VALUES RTE can't contain any Vars of level zero, let alone any that
    1571             :      * are join aliases, so no need to flatten join alias Vars.
    1572             :      */
    1573             :     Assert(!contain_vars_of_level((Node *) values_list, 0));
    1574             : 
    1575             :     /*
    1576             :      * Set up required context data for pullup_replace_vars.  In particular,
    1577             :      * we have to make the VALUES list look like a subquery targetlist.
    1578             :      */
    1579         692 :     tlist = NIL;
    1580         692 :     attrno = 1;
    1581        1682 :     foreach(lc, values_list)
    1582             :     {
    1583         990 :         tlist = lappend(tlist,
    1584         990 :                         makeTargetEntry((Expr *) lfirst(lc),
    1585             :                                         attrno,
    1586             :                                         NULL,
    1587             :                                         false));
    1588         990 :         attrno++;
    1589             :     }
    1590         692 :     rvcontext.root = root;
    1591         692 :     rvcontext.targetlist = tlist;
    1592         692 :     rvcontext.target_rte = rte;
    1593         692 :     rvcontext.relids = NULL;
    1594         692 :     rvcontext.outer_hasSubLinks = &parse->hasSubLinks;
    1595         692 :     rvcontext.varno = varno;
    1596         692 :     rvcontext.need_phvs = false;
    1597         692 :     rvcontext.wrap_non_vars = false;
    1598             :     /* initialize cache array with indexes 0 .. length(tlist) */
    1599         692 :     rvcontext.rv_cache = palloc0((list_length(tlist) + 1) *
    1600             :                                  sizeof(Node *));
    1601             : 
    1602             :     /*
    1603             :      * Replace all of the top query's references to the RTE's outputs with
    1604             :      * copies of the adjusted VALUES expressions, being careful not to replace
    1605             :      * any of the jointree structure.  We can assume there's no outer joins or
    1606             :      * appendrels in the dummy Query that surrounds a VALUES RTE.
    1607             :      */
    1608         692 :     perform_pullup_replace_vars(root, &rvcontext, NULL, NULL);
    1609             : 
    1610             :     /*
    1611             :      * There should be no appendrels to fix, nor any outer joins and hence no
    1612             :      * PlaceHolderVars.
    1613             :      */
    1614             :     Assert(root->append_rel_list == NIL);
    1615             :     Assert(root->join_info_list == NIL);
    1616             :     Assert(root->placeholder_list == NIL);
    1617             : 
    1618             :     /*
    1619             :      * Replace the VALUES RTE with a RESULT RTE.  The VALUES RTE is the only
    1620             :      * rtable entry in the current query level, so this is easy.
    1621             :      */
    1622             :     Assert(list_length(parse->rtable) == 1);
    1623             : 
    1624             :     /* Create suitable RTE */
    1625         692 :     rte = makeNode(RangeTblEntry);
    1626         692 :     rte->rtekind = RTE_RESULT;
    1627         692 :     rte->eref = makeAlias("*RESULT*", NIL);
    1628             : 
    1629             :     /* Replace rangetable */
    1630         692 :     parse->rtable = list_make1(rte);
    1631             : 
    1632             :     /* We could manufacture a new RangeTblRef, but the one we have is fine */
    1633             :     Assert(varno == 1);
    1634             : 
    1635         692 :     return jtnode;
    1636             : }
    1637             : 
    1638             : /*
    1639             :  * is_simple_values
    1640             :  *    Check a VALUES RTE in the range table to see if it's simple enough
    1641             :  *    to pull up into the parent query.
    1642             :  *
    1643             :  * rte is the RTE_VALUES RangeTblEntry to check.
    1644             :  */
    1645             : static bool
    1646        5428 : is_simple_values(PlannerInfo *root, RangeTblEntry *rte)
    1647             : {
    1648             :     Assert(rte->rtekind == RTE_VALUES);
    1649             : 
    1650             :     /*
    1651             :      * There must be exactly one VALUES list, else it's not semantically
    1652             :      * correct to replace the VALUES RTE with a RESULT RTE, nor would we have
    1653             :      * a unique set of expressions to substitute into the parent query.
    1654             :      */
    1655        5428 :     if (list_length(rte->values_lists) != 1)
    1656        4736 :         return false;
    1657             : 
    1658             :     /*
    1659             :      * Because VALUES can't appear under an outer join (or at least, we won't
    1660             :      * try to pull it up if it does), we need not worry about LATERAL, nor
    1661             :      * about validity of PHVs for the VALUES' outputs.
    1662             :      */
    1663             : 
    1664             :     /*
    1665             :      * Don't pull up a VALUES that contains any set-returning or volatile
    1666             :      * functions.  The considerations here are basically identical to the
    1667             :      * restrictions on a pull-able subquery's targetlist.
    1668             :      */
    1669        1384 :     if (expression_returns_set((Node *) rte->values_lists) ||
    1670         692 :         contain_volatile_functions((Node *) rte->values_lists))
    1671           0 :         return false;
    1672             : 
    1673             :     /*
    1674             :      * Do not pull up a VALUES that's not the only RTE in its parent query.
    1675             :      * This is actually the only case that the parser will generate at the
    1676             :      * moment, and assuming this is true greatly simplifies
    1677             :      * pull_up_simple_values().
    1678             :      */
    1679         692 :     if (list_length(root->parse->rtable) != 1 ||
    1680         692 :         rte != (RangeTblEntry *) linitial(root->parse->rtable))
    1681           0 :         return false;
    1682             : 
    1683         692 :     return true;
    1684             : }
    1685             : 
    1686             : /*
    1687             :  * pull_up_constant_function
    1688             :  *      Pull up an RTE_FUNCTION expression that was simplified to a constant.
    1689             :  *
    1690             :  * jtnode is a RangeTblRef that has been identified as a FUNCTION RTE by
    1691             :  * pull_up_subqueries.  If its expression is just a Const, hoist that value
    1692             :  * up into the parent query, and replace the RTE_FUNCTION with RTE_RESULT.
    1693             :  *
    1694             :  * In principle we could pull up any immutable expression, but we don't.
    1695             :  * That might result in multiple evaluations of the expression, which could
    1696             :  * be costly if it's not just a Const.  Also, the main value of this is
    1697             :  * to let the constant participate in further const-folding, and of course
    1698             :  * that won't happen for a non-Const.
    1699             :  *
    1700             :  * The pulled-up value might need to be wrapped in a PlaceHolderVar if the
    1701             :  * RTE is below an outer join or is part of an appendrel; the extra
    1702             :  * parameters show whether that's needed.
    1703             :  */
    1704             : static Node *
    1705       65982 : pull_up_constant_function(PlannerInfo *root, Node *jtnode,
    1706             :                           RangeTblEntry *rte,
    1707             :                           JoinExpr *lowest_nulling_outer_join,
    1708             :                           AppendRelInfo *containing_appendrel)
    1709             : {
    1710       65982 :     Query      *parse = root->parse;
    1711             :     RangeTblFunction *rtf;
    1712             :     TypeFuncClass functypclass;
    1713             :     Oid         funcrettype;
    1714             :     TupleDesc   tupdesc;
    1715             :     pullup_replace_vars_context rvcontext;
    1716             : 
    1717             :     /* Fail if the RTE has ORDINALITY - we don't implement that here. */
    1718       65982 :     if (rte->funcordinality)
    1719        7626 :         return jtnode;
    1720             : 
    1721             :     /* Fail if RTE isn't a single, simple Const expr */
    1722       58356 :     if (list_length(rte->functions) != 1)
    1723          52 :         return jtnode;
    1724       58304 :     rtf = linitial_node(RangeTblFunction, rte->functions);
    1725       58304 :     if (!IsA(rtf->funcexpr, Const))
    1726       58064 :         return jtnode;
    1727             : 
    1728             :     /*
    1729             :      * If the function's result is not a scalar, we punt.  In principle we
    1730             :      * could break the composite constant value apart into per-column
    1731             :      * constants, but for now it seems not worth the work.
    1732             :      */
    1733         240 :     if (rtf->funccolcount != 1)
    1734          16 :         return jtnode;          /* definitely composite */
    1735             : 
    1736         224 :     functypclass = get_expr_result_type(rtf->funcexpr,
    1737             :                                         &funcrettype,
    1738             :                                         &tupdesc);
    1739         224 :     if (functypclass != TYPEFUNC_SCALAR)
    1740           8 :         return jtnode;          /* must be a one-column composite type */
    1741             : 
    1742             :     /* Create context for applying pullup_replace_vars */
    1743         216 :     rvcontext.root = root;
    1744         216 :     rvcontext.targetlist = list_make1(makeTargetEntry((Expr *) rtf->funcexpr,
    1745             :                                                       1,    /* resno */
    1746             :                                                       NULL, /* resname */
    1747             :                                                       false));  /* resjunk */
    1748         216 :     rvcontext.target_rte = rte;
    1749             : 
    1750             :     /*
    1751             :      * Since this function was reduced to a Const, it doesn't contain any
    1752             :      * lateral references, even if it's marked as LATERAL.  This means we
    1753             :      * don't need to fill relids.
    1754             :      */
    1755         216 :     rvcontext.relids = NULL;
    1756             : 
    1757         216 :     rvcontext.outer_hasSubLinks = &parse->hasSubLinks;
    1758         216 :     rvcontext.varno = ((RangeTblRef *) jtnode)->rtindex;
    1759             :     /* these flags will be set below, if needed */
    1760         216 :     rvcontext.need_phvs = false;
    1761         216 :     rvcontext.wrap_non_vars = false;
    1762             :     /* initialize cache array with indexes 0 .. length(tlist) */
    1763         216 :     rvcontext.rv_cache = palloc0((list_length(rvcontext.targetlist) + 1) *
    1764             :                                  sizeof(Node *));
    1765             : 
    1766             :     /*
    1767             :      * If we are under an outer join then non-nullable items and lateral
    1768             :      * references may have to be turned into PlaceHolderVars.
    1769             :      */
    1770         216 :     if (lowest_nulling_outer_join != NULL)
    1771          12 :         rvcontext.need_phvs = true;
    1772             : 
    1773             :     /*
    1774             :      * If we are dealing with an appendrel member then anything that's not a
    1775             :      * simple Var has to be turned into a PlaceHolderVar.  (See comments in
    1776             :      * pull_up_simple_subquery().)
    1777             :      */
    1778         216 :     if (containing_appendrel != NULL)
    1779             :     {
    1780           0 :         rvcontext.need_phvs = true;
    1781           0 :         rvcontext.wrap_non_vars = true;
    1782             :     }
    1783             : 
    1784             :     /*
    1785             :      * If the parent query uses grouping sets, we need a PlaceHolderVar for
    1786             :      * anything that's not a simple Var.
    1787             :      */
    1788         216 :     if (parse->groupingSets)
    1789             :     {
    1790           0 :         rvcontext.need_phvs = true;
    1791           0 :         rvcontext.wrap_non_vars = true;
    1792             :     }
    1793             : 
    1794             :     /*
    1795             :      * Replace all of the top query's references to the RTE's output with
    1796             :      * copies of the funcexpr, being careful not to replace any of the
    1797             :      * jointree structure.
    1798             :      */
    1799         216 :     perform_pullup_replace_vars(root, &rvcontext,
    1800             :                                 lowest_nulling_outer_join,
    1801             :                                 containing_appendrel);
    1802             : 
    1803             :     /*
    1804             :      * We don't need to bother with changing PlaceHolderVars in the parent
    1805             :      * query.  Their references to the RT index are still good for now, and
    1806             :      * will get removed later if we're able to drop the RTE_RESULT.
    1807             :      */
    1808             : 
    1809             :     /*
    1810             :      * Convert the RTE to be RTE_RESULT type, signifying that we don't need to
    1811             :      * scan it anymore, and zero out RTE_FUNCTION-specific fields.  Also make
    1812             :      * sure the RTE is not marked LATERAL, since elsewhere we don't expect
    1813             :      * RTE_RESULTs to be LATERAL.
    1814             :      */
    1815         216 :     rte->rtekind = RTE_RESULT;
    1816         216 :     rte->functions = NIL;
    1817         216 :     rte->lateral = false;
    1818             : 
    1819             :     /*
    1820             :      * We can reuse the RangeTblRef node.
    1821             :      */
    1822         216 :     return jtnode;
    1823             : }
    1824             : 
    1825             : /*
    1826             :  * is_simple_union_all
    1827             :  *    Check a subquery to see if it's a simple UNION ALL.
    1828             :  *
    1829             :  * We require all the setops to be UNION ALL (no mixing) and there can't be
    1830             :  * any datatype coercions involved, ie, all the leaf queries must emit the
    1831             :  * same datatypes.
    1832             :  */
    1833             : static bool
    1834        5450 : is_simple_union_all(Query *subquery)
    1835             : {
    1836             :     SetOperationStmt *topop;
    1837             : 
    1838             :     /* Let's just make sure it's a valid subselect ... */
    1839        5450 :     if (!IsA(subquery, Query) ||
    1840        5450 :         subquery->commandType != CMD_SELECT)
    1841           0 :         elog(ERROR, "subquery is bogus");
    1842             : 
    1843             :     /* Is it a set-operation query at all? */
    1844        5450 :     topop = castNode(SetOperationStmt, subquery->setOperations);
    1845        5450 :     if (!topop)
    1846        3882 :         return false;
    1847             : 
    1848             :     /* Can't handle ORDER BY, LIMIT/OFFSET, locking, or WITH */
    1849        1568 :     if (subquery->sortClause ||
    1850        1540 :         subquery->limitOffset ||
    1851        1540 :         subquery->limitCount ||
    1852        1540 :         subquery->rowMarks ||
    1853        1540 :         subquery->cteList)
    1854          56 :         return false;
    1855             : 
    1856             :     /* Recursively check the tree of set operations */
    1857        1512 :     return is_simple_union_all_recurse((Node *) topop, subquery,
    1858             :                                        topop->colTypes);
    1859             : }
    1860             : 
    1861             : static bool
    1862        7800 : is_simple_union_all_recurse(Node *setOp, Query *setOpQuery, List *colTypes)
    1863             : {
    1864        7800 :     if (IsA(setOp, RangeTblRef))
    1865             :     {
    1866        2808 :         RangeTblRef *rtr = (RangeTblRef *) setOp;
    1867        2808 :         RangeTblEntry *rte = rt_fetch(rtr->rtindex, setOpQuery->rtable);
    1868        2808 :         Query      *subquery = rte->subquery;
    1869             : 
    1870             :         Assert(subquery != NULL);
    1871             : 
    1872             :         /* Leaf nodes are OK if they match the toplevel column types */
    1873             :         /* We don't have to compare typmods or collations here */
    1874        2808 :         return tlist_same_datatypes(subquery->targetList, colTypes, true);
    1875             :     }
    1876        4992 :     else if (IsA(setOp, SetOperationStmt))
    1877             :     {
    1878        4992 :         SetOperationStmt *op = (SetOperationStmt *) setOp;
    1879             : 
    1880             :         /* Must be UNION ALL */
    1881        4992 :         if (op->op != SETOP_UNION || !op->all)
    1882        3210 :             return false;
    1883             : 
    1884             :         /* Recurse to check inputs */
    1885        3322 :         return is_simple_union_all_recurse(op->larg, setOpQuery, colTypes) &&
    1886        1540 :             is_simple_union_all_recurse(op->rarg, setOpQuery, colTypes);
    1887             :     }
    1888             :     else
    1889             :     {
    1890           0 :         elog(ERROR, "unrecognized node type: %d",
    1891             :              (int) nodeTag(setOp));
    1892             :         return false;           /* keep compiler quiet */
    1893             :     }
    1894             : }
    1895             : 
    1896             : /*
    1897             :  * is_safe_append_member
    1898             :  *    Check a subquery that is a leaf of a UNION ALL appendrel to see if it's
    1899             :  *    safe to pull up.
    1900             :  */
    1901             : static bool
    1902        3530 : is_safe_append_member(Query *subquery)
    1903             : {
    1904             :     FromExpr   *jtnode;
    1905             : 
    1906             :     /*
    1907             :      * It's only safe to pull up the child if its jointree contains exactly
    1908             :      * one RTE, else the AppendRelInfo data structure breaks. The one base RTE
    1909             :      * could be buried in several levels of FromExpr, however.  Also, if the
    1910             :      * child's jointree is completely empty, we can pull up because
    1911             :      * pull_up_simple_subquery will insert a single RTE_RESULT RTE instead.
    1912             :      *
    1913             :      * Also, the child can't have any WHERE quals because there's no place to
    1914             :      * put them in an appendrel.  (This is a bit annoying...) If we didn't
    1915             :      * need to check this, we'd just test whether get_relids_in_jointree()
    1916             :      * yields a singleton set, to be more consistent with the coding of
    1917             :      * fix_append_rel_relids().
    1918             :      */
    1919        3530 :     jtnode = subquery->jointree;
    1920             :     Assert(IsA(jtnode, FromExpr));
    1921             :     /* Check the completely-empty case */
    1922        3530 :     if (jtnode->fromlist == NIL && jtnode->quals == NULL)
    1923         340 :         return true;
    1924             :     /* Check the more general case */
    1925        6086 :     while (IsA(jtnode, FromExpr))
    1926             :     {
    1927        3198 :         if (jtnode->quals != NULL)
    1928         302 :             return false;
    1929        2896 :         if (list_length(jtnode->fromlist) != 1)
    1930           0 :             return false;
    1931        2896 :         jtnode = linitial(jtnode->fromlist);
    1932             :     }
    1933        2888 :     if (!IsA(jtnode, RangeTblRef))
    1934          36 :         return false;
    1935             : 
    1936        2852 :     return true;
    1937             : }
    1938             : 
    1939             : /*
    1940             :  * jointree_contains_lateral_outer_refs
    1941             :  *      Check for disallowed lateral references in a jointree's quals
    1942             :  *
    1943             :  * If restricted is false, all level-1 Vars are allowed (but we still must
    1944             :  * search the jointree, since it might contain outer joins below which there
    1945             :  * will be restrictions).  If restricted is true, return true when any qual
    1946             :  * in the jointree contains level-1 Vars coming from outside the rels listed
    1947             :  * in safe_upper_varnos.
    1948             :  */
    1949             : static bool
    1950        1856 : jointree_contains_lateral_outer_refs(PlannerInfo *root, Node *jtnode,
    1951             :                                      bool restricted,
    1952             :                                      Relids safe_upper_varnos)
    1953             : {
    1954        1856 :     if (jtnode == NULL)
    1955           0 :         return false;
    1956        1856 :     if (IsA(jtnode, RangeTblRef))
    1957         888 :         return false;
    1958         968 :     else if (IsA(jtnode, FromExpr))
    1959             :     {
    1960         820 :         FromExpr   *f = (FromExpr *) jtnode;
    1961             :         ListCell   *l;
    1962             : 
    1963             :         /* First, recurse to check child joins */
    1964        1568 :         foreach(l, f->fromlist)
    1965             :         {
    1966         756 :             if (jointree_contains_lateral_outer_refs(root,
    1967         756 :                                                      lfirst(l),
    1968             :                                                      restricted,
    1969             :                                                      safe_upper_varnos))
    1970           8 :                 return true;
    1971             :         }
    1972             : 
    1973             :         /* Then check the top-level quals */
    1974         812 :         if (restricted &&
    1975         280 :             !bms_is_subset(pull_varnos_of_level(root, f->quals, 1),
    1976             :                            safe_upper_varnos))
    1977           0 :             return true;
    1978             :     }
    1979         148 :     else if (IsA(jtnode, JoinExpr))
    1980             :     {
    1981         148 :         JoinExpr   *j = (JoinExpr *) jtnode;
    1982             : 
    1983             :         /*
    1984             :          * If this is an outer join, we mustn't allow any upper lateral
    1985             :          * references in or below it.
    1986             :          */
    1987         148 :         if (j->jointype != JOIN_INNER)
    1988             :         {
    1989          68 :             restricted = true;
    1990          68 :             safe_upper_varnos = NULL;
    1991             :         }
    1992             : 
    1993             :         /* Check the child joins */
    1994         148 :         if (jointree_contains_lateral_outer_refs(root,
    1995             :                                                  j->larg,
    1996             :                                                  restricted,
    1997             :                                                  safe_upper_varnos))
    1998           0 :             return true;
    1999         148 :         if (jointree_contains_lateral_outer_refs(root,
    2000             :                                                  j->rarg,
    2001             :                                                  restricted,
    2002             :                                                  safe_upper_varnos))
    2003           0 :             return true;
    2004             : 
    2005             :         /* Check the JOIN's qual clauses */
    2006         148 :         if (restricted &&
    2007         148 :             !bms_is_subset(pull_varnos_of_level(root, j->quals, 1),
    2008             :                            safe_upper_varnos))
    2009           8 :             return true;
    2010             :     }
    2011             :     else
    2012           0 :         elog(ERROR, "unrecognized node type: %d",
    2013             :              (int) nodeTag(jtnode));
    2014         952 :     return false;
    2015             : }
    2016             : 
    2017             : /*
    2018             :  * Perform pullup_replace_vars everyplace it's needed in the query tree.
    2019             :  *
    2020             :  * Caller has already filled *rvcontext with data describing what to
    2021             :  * substitute for Vars referencing the target subquery.  In addition
    2022             :  * we need the identity of the lowest outer join that can null the
    2023             :  * target subquery, and its containing appendrel if any.
    2024             :  */
    2025             : static void
    2026       33242 : perform_pullup_replace_vars(PlannerInfo *root,
    2027             :                             pullup_replace_vars_context *rvcontext,
    2028             :                             JoinExpr *lowest_nulling_outer_join,
    2029             :                             AppendRelInfo *containing_appendrel)
    2030             : {
    2031       33242 :     Query      *parse = root->parse;
    2032             :     ListCell   *lc;
    2033             : 
    2034             :     /*
    2035             :      * Replace all of the top query's references to the subquery's outputs
    2036             :      * with copies of the adjusted subtlist items, being careful not to
    2037             :      * replace any of the jointree structure.  (This'd be a lot cleaner if we
    2038             :      * could use query_tree_mutator.)  We have to use PHVs in the targetList,
    2039             :      * returningList, and havingQual, since those are certainly above any
    2040             :      * outer join.  replace_vars_in_jointree tracks its location in the
    2041             :      * jointree and uses PHVs or not appropriately.
    2042             :      */
    2043       33242 :     parse->targetList = (List *)
    2044       33242 :         pullup_replace_vars((Node *) parse->targetList, rvcontext);
    2045       33242 :     parse->returningList = (List *)
    2046       33242 :         pullup_replace_vars((Node *) parse->returningList, rvcontext);
    2047       33242 :     if (parse->onConflict)
    2048             :     {
    2049          32 :         parse->onConflict->onConflictSet = (List *)
    2050          16 :             pullup_replace_vars((Node *) parse->onConflict->onConflictSet,
    2051             :                                 rvcontext);
    2052          16 :         parse->onConflict->onConflictWhere =
    2053          16 :             pullup_replace_vars(parse->onConflict->onConflictWhere,
    2054             :                                 rvcontext);
    2055             : 
    2056             :         /*
    2057             :          * We assume ON CONFLICT's arbiterElems, arbiterWhere, exclRelTlist
    2058             :          * can't contain any references to a subquery.
    2059             :          */
    2060             :     }
    2061       33242 :     replace_vars_in_jointree((Node *) parse->jointree, rvcontext,
    2062             :                              lowest_nulling_outer_join);
    2063             :     Assert(parse->setOperations == NULL);
    2064       33238 :     parse->havingQual = pullup_replace_vars(parse->havingQual, rvcontext);
    2065             : 
    2066             :     /*
    2067             :      * Replace references in the translated_vars lists of appendrels.  When
    2068             :      * pulling up an appendrel member, we do not need PHVs in the list of the
    2069             :      * parent appendrel --- there isn't any outer join between.  Elsewhere,
    2070             :      * use PHVs for safety.  (This analysis could be made tighter but it seems
    2071             :      * unlikely to be worth much trouble.)
    2072             :      */
    2073       36118 :     foreach(lc, root->append_rel_list)
    2074             :     {
    2075        2880 :         AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(lc);
    2076        2880 :         bool        save_need_phvs = rvcontext->need_phvs;
    2077             : 
    2078        2880 :         if (appinfo == containing_appendrel)
    2079        1578 :             rvcontext->need_phvs = false;
    2080        2880 :         appinfo->translated_vars = (List *)
    2081        2880 :             pullup_replace_vars((Node *) appinfo->translated_vars, rvcontext);
    2082        2880 :         rvcontext->need_phvs = save_need_phvs;
    2083             :     }
    2084             : 
    2085             :     /*
    2086             :      * Replace references in the joinaliasvars lists of join RTEs.
    2087             :      *
    2088             :      * You might think that we could avoid using PHVs for alias vars of joins
    2089             :      * below lowest_nulling_outer_join, but that doesn't work because the
    2090             :      * alias vars could be referenced above that join; we need the PHVs to be
    2091             :      * present in such references after the alias vars get flattened.  (It
    2092             :      * might be worth trying to be smarter here, someday.)
    2093             :      */
    2094       91516 :     foreach(lc, parse->rtable)
    2095             :     {
    2096       58278 :         RangeTblEntry *otherrte = (RangeTblEntry *) lfirst(lc);
    2097             : 
    2098       58278 :         if (otherrte->rtekind == RTE_JOIN)
    2099        2686 :             otherrte->joinaliasvars = (List *)
    2100        2686 :                 pullup_replace_vars((Node *) otherrte->joinaliasvars,
    2101             :                                     rvcontext);
    2102             :     }
    2103       33238 : }
    2104             : 
    2105             : /*
    2106             :  * Helper routine for perform_pullup_replace_vars: do pullup_replace_vars on
    2107             :  * every expression in the jointree, without changing the jointree structure
    2108             :  * itself.  Ugly, but there's no other way...
    2109             :  *
    2110             :  * If we are at or below lowest_nulling_outer_join, we can suppress use of
    2111             :  * PlaceHolderVars wrapped around the replacement expressions.
    2112             :  */
    2113             : static void
    2114       78822 : replace_vars_in_jointree(Node *jtnode,
    2115             :                          pullup_replace_vars_context *context,
    2116             :                          JoinExpr *lowest_nulling_outer_join)
    2117             : {
    2118       78822 :     if (jtnode == NULL)
    2119           0 :         return;
    2120       78822 :     if (IsA(jtnode, RangeTblRef))
    2121             :     {
    2122             :         /*
    2123             :          * If the RangeTblRef refers to a LATERAL subquery (that isn't the
    2124             :          * same subquery we're pulling up), it might contain references to the
    2125             :          * target subquery, which we must replace.  We drive this from the
    2126             :          * jointree scan, rather than a scan of the rtable, for a couple of
    2127             :          * reasons: we can avoid processing no-longer-referenced RTEs, and we
    2128             :          * can use the appropriate setting of need_phvs depending on whether
    2129             :          * the RTE is above possibly-nulling outer joins or not.
    2130             :          */
    2131       39676 :         int         varno = ((RangeTblRef *) jtnode)->rtindex;
    2132             : 
    2133       39676 :         if (varno != context->varno) /* ignore target subquery itself */
    2134             :         {
    2135        8012 :             RangeTblEntry *rte = rt_fetch(varno, context->root->parse->rtable);
    2136             : 
    2137             :             Assert(rte != context->target_rte);
    2138        8012 :             if (rte->lateral)
    2139             :             {
    2140         564 :                 switch (rte->rtekind)
    2141             :                 {
    2142           0 :                     case RTE_RELATION:
    2143             :                         /* shouldn't be marked LATERAL unless tablesample */
    2144             :                         Assert(rte->tablesample);
    2145           0 :                         rte->tablesample = (TableSampleClause *)
    2146           0 :                             pullup_replace_vars((Node *) rte->tablesample,
    2147             :                                                 context);
    2148           0 :                         break;
    2149         284 :                     case RTE_SUBQUERY:
    2150         284 :                         rte->subquery =
    2151         284 :                             pullup_replace_vars_subquery(rte->subquery,
    2152             :                                                          context);
    2153         284 :                         break;
    2154         236 :                     case RTE_FUNCTION:
    2155         236 :                         rte->functions = (List *)
    2156         236 :                             pullup_replace_vars((Node *) rte->functions,
    2157             :                                                 context);
    2158         236 :                         break;
    2159          44 :                     case RTE_TABLEFUNC:
    2160          44 :                         rte->tablefunc = (TableFunc *)
    2161          44 :                             pullup_replace_vars((Node *) rte->tablefunc,
    2162             :                                                 context);
    2163          44 :                         break;
    2164           0 :                     case RTE_VALUES:
    2165           0 :                         rte->values_lists = (List *)
    2166           0 :                             pullup_replace_vars((Node *) rte->values_lists,
    2167             :                                                 context);
    2168           0 :                         break;
    2169           0 :                     case RTE_JOIN:
    2170             :                     case RTE_CTE:
    2171             :                     case RTE_NAMEDTUPLESTORE:
    2172             :                     case RTE_RESULT:
    2173             :                         /* these shouldn't be marked LATERAL */
    2174             :                         Assert(false);
    2175           0 :                         break;
    2176             :                 }
    2177       39676 :             }
    2178             :         }
    2179             :     }
    2180       39146 :     else if (IsA(jtnode, FromExpr))
    2181             :     {
    2182       34728 :         FromExpr   *f = (FromExpr *) jtnode;
    2183             :         ListCell   *l;
    2184             : 
    2185       71472 :         foreach(l, f->fromlist)
    2186       36744 :             replace_vars_in_jointree(lfirst(l), context,
    2187             :                                      lowest_nulling_outer_join);
    2188       34728 :         f->quals = pullup_replace_vars(f->quals, context);
    2189             :     }
    2190        4418 :     else if (IsA(jtnode, JoinExpr))
    2191             :     {
    2192        4418 :         JoinExpr   *j = (JoinExpr *) jtnode;
    2193        4418 :         bool        save_need_phvs = context->need_phvs;
    2194             : 
    2195        4418 :         if (j == lowest_nulling_outer_join)
    2196             :         {
    2197             :             /* no more PHVs in or below this join */
    2198        1344 :             context->need_phvs = false;
    2199        1344 :             lowest_nulling_outer_join = NULL;
    2200             :         }
    2201        4418 :         replace_vars_in_jointree(j->larg, context, lowest_nulling_outer_join);
    2202        4418 :         replace_vars_in_jointree(j->rarg, context, lowest_nulling_outer_join);
    2203             : 
    2204             :         /*
    2205             :          * Use PHVs within the join quals of a full join, even when it's the
    2206             :          * lowest nulling outer join.  Otherwise, we cannot identify which
    2207             :          * side of the join a pulled-up var-free expression came from, which
    2208             :          * can lead to failure to make a plan at all because none of the quals
    2209             :          * appear to be mergeable or hashable conditions.  For this purpose we
    2210             :          * don't care about the state of wrap_non_vars, so leave it alone.
    2211             :          */
    2212        4418 :         if (j->jointype == JOIN_FULL)
    2213         384 :             context->need_phvs = true;
    2214             : 
    2215        4418 :         j->quals = pullup_replace_vars(j->quals, context);
    2216             : 
    2217             :         /*
    2218             :          * We don't bother to update the colvars list, since it won't be used
    2219             :          * again ...
    2220             :          */
    2221        4418 :         context->need_phvs = save_need_phvs;
    2222             :     }
    2223             :     else
    2224           0 :         elog(ERROR, "unrecognized node type: %d",
    2225             :              (int) nodeTag(jtnode));
    2226             : }
    2227             : 
    2228             : /*
    2229             :  * Apply pullup variable replacement throughout an expression tree
    2230             :  *
    2231             :  * Returns a modified copy of the tree, so this can't be used where we
    2232             :  * need to do in-place replacement.
    2233             :  */
    2234             : static Node *
    2235      144746 : pullup_replace_vars(Node *expr, pullup_replace_vars_context *context)
    2236             : {
    2237      144746 :     return replace_rte_variables(expr,
    2238             :                                  context->varno, 0,
    2239             :                                  pullup_replace_vars_callback,
    2240             :                                  (void *) context,
    2241             :                                  context->outer_hasSubLinks);
    2242             : }
    2243             : 
    2244             : static Node *
    2245       95558 : pullup_replace_vars_callback(Var *var,
    2246             :                              replace_rte_variables_context *context)
    2247             : {
    2248       95558 :     pullup_replace_vars_context *rcon = (pullup_replace_vars_context *) context->callback_arg;
    2249       95558 :     int         varattno = var->varattno;
    2250             :     Node       *newnode;
    2251             : 
    2252             :     /*
    2253             :      * If PlaceHolderVars are needed, we cache the modified expressions in
    2254             :      * rcon->rv_cache[].  This is not in hopes of any material speed gain
    2255             :      * within this function, but to avoid generating identical PHVs with
    2256             :      * different IDs.  That would result in duplicate evaluations at runtime,
    2257             :      * and possibly prevent optimizations that rely on recognizing different
    2258             :      * references to the same subquery output as being equal().  So it's worth
    2259             :      * a bit of extra effort to avoid it.
    2260             :      */
    2261       95558 :     if (rcon->need_phvs &&
    2262        7426 :         varattno >= InvalidAttrNumber &&
    2263        7426 :         varattno <= list_length(rcon->targetlist) &&
    2264        7426 :         rcon->rv_cache[varattno] != NULL)
    2265             :     {
    2266             :         /* Just copy the entry and fall through to adjust its varlevelsup */
    2267        4072 :         newnode = copyObject(rcon->rv_cache[varattno]);
    2268             :     }
    2269       91486 :     else if (varattno == InvalidAttrNumber)
    2270             :     {
    2271             :         /* Must expand whole-tuple reference into RowExpr */
    2272             :         RowExpr    *rowexpr;
    2273             :         List       *colnames;
    2274             :         List       *fields;
    2275         280 :         bool        save_need_phvs = rcon->need_phvs;
    2276         280 :         int         save_sublevelsup = context->sublevels_up;
    2277             : 
    2278             :         /*
    2279             :          * If generating an expansion for a var of a named rowtype (ie, this
    2280             :          * is a plain relation RTE), then we must include dummy items for
    2281             :          * dropped columns.  If the var is RECORD (ie, this is a JOIN), then
    2282             :          * omit dropped columns. Either way, attach column names to the
    2283             :          * RowExpr for use of ruleutils.c.
    2284             :          *
    2285             :          * In order to be able to cache the results, we always generate the
    2286             :          * expansion with varlevelsup = 0, and then adjust if needed.
    2287             :          */
    2288         280 :         expandRTE(rcon->target_rte,
    2289             :                   var->varno, 0 /* not varlevelsup */ , var->location,
    2290         280 :                   (var->vartype != RECORDOID),
    2291             :                   &colnames, &fields);
    2292             :         /* Adjust the generated per-field Vars, but don't insert PHVs */
    2293         280 :         rcon->need_phvs = false;
    2294         280 :         context->sublevels_up = 0;   /* to match the expandRTE output */
    2295         280 :         fields = (List *) replace_rte_variables_mutator((Node *) fields,
    2296             :                                                         context);
    2297         280 :         rcon->need_phvs = save_need_phvs;
    2298         280 :         context->sublevels_up = save_sublevelsup;
    2299             : 
    2300         280 :         rowexpr = makeNode(RowExpr);
    2301         280 :         rowexpr->args = fields;
    2302         280 :         rowexpr->row_typeid = var->vartype;
    2303         280 :         rowexpr->row_format = COERCE_IMPLICIT_CAST;
    2304         280 :         rowexpr->colnames = colnames;
    2305         280 :         rowexpr->location = var->location;
    2306         280 :         newnode = (Node *) rowexpr;
    2307             : 
    2308             :         /*
    2309             :          * Insert PlaceHolderVar if needed.  Notice that we are wrapping one
    2310             :          * PlaceHolderVar around the whole RowExpr, rather than putting one
    2311             :          * around each element of the row.  This is because we need the
    2312             :          * expression to yield NULL, not ROW(NULL,NULL,...) when it is forced
    2313             :          * to null by an outer join.
    2314             :          */
    2315         280 :         if (rcon->need_phvs)
    2316             :         {
    2317             :             /* RowExpr is certainly not strict, so always need PHV */
    2318             :             newnode = (Node *)
    2319           8 :                 make_placeholder_expr(rcon->root,
    2320             :                                       (Expr *) newnode,
    2321             :                                       bms_make_singleton(rcon->varno));
    2322             :             /* cache it with the PHV, and with varlevelsup still zero */
    2323           8 :             rcon->rv_cache[InvalidAttrNumber] = copyObject(newnode);
    2324             :         }
    2325             :     }
    2326             :     else
    2327             :     {
    2328             :         /* Normal case referencing one targetlist element */
    2329       91206 :         TargetEntry *tle = get_tle_by_resno(rcon->targetlist, varattno);
    2330             : 
    2331       91206 :         if (tle == NULL)        /* shouldn't happen */
    2332           0 :             elog(ERROR, "could not find attribute %d in subquery targetlist",
    2333             :                  varattno);
    2334             : 
    2335             :         /* Make a copy of the tlist item to return */
    2336       91206 :         newnode = (Node *) copyObject(tle->expr);
    2337             : 
    2338             :         /* Insert PlaceHolderVar if needed */
    2339       91206 :         if (rcon->need_phvs)
    2340             :         {
    2341             :             bool        wrap;
    2342             : 
    2343        3346 :             if (newnode && IsA(newnode, Var) &&
    2344        2516 :                 ((Var *) newnode)->varlevelsup == 0)
    2345             :             {
    2346             :                 /*
    2347             :                  * Simple Vars always escape being wrapped, unless they are
    2348             :                  * lateral references to something outside the subquery being
    2349             :                  * pulled up.  (Even then, we could omit the PlaceHolderVar if
    2350             :                  * the referenced rel is under the same lowest outer join, but
    2351             :                  * it doesn't seem worth the trouble to check that.)
    2352             :                  */
    2353        2504 :                 if (rcon->target_rte->lateral &&
    2354         232 :                     !bms_is_member(((Var *) newnode)->varno, rcon->relids))
    2355          16 :                     wrap = true;
    2356             :                 else
    2357        2488 :                     wrap = false;
    2358             :             }
    2359         842 :             else if (newnode && IsA(newnode, PlaceHolderVar) &&
    2360          28 :                      ((PlaceHolderVar *) newnode)->phlevelsup == 0)
    2361             :             {
    2362             :                 /* No need to wrap a PlaceHolderVar with another one, either */
    2363          28 :                 wrap = false;
    2364             :             }
    2365         814 :             else if (rcon->wrap_non_vars)
    2366             :             {
    2367             :                 /* Wrap all non-Vars in a PlaceHolderVar */
    2368          72 :                 wrap = true;
    2369             :             }
    2370             :             else
    2371             :             {
    2372             :                 /*
    2373             :                  * If it contains a Var of the subquery being pulled up, and
    2374             :                  * does not contain any non-strict constructs, then it's
    2375             :                  * certainly nullable so we don't need to insert a
    2376             :                  * PlaceHolderVar.
    2377             :                  *
    2378             :                  * This analysis could be tighter: in particular, a non-strict
    2379             :                  * construct hidden within a lower-level PlaceHolderVar is not
    2380             :                  * reason to add another PHV.  But for now it doesn't seem
    2381             :                  * worth the code to be more exact.
    2382             :                  *
    2383             :                  * Note: in future maybe we should insert a PlaceHolderVar
    2384             :                  * anyway, if the tlist item is expensive to evaluate?
    2385             :                  *
    2386             :                  * For a LATERAL subquery, we have to check the actual var
    2387             :                  * membership of the node, but if it's non-lateral then any
    2388             :                  * level-zero var must belong to the subquery.
    2389             :                  */
    2390         814 :                 if ((rcon->target_rte->lateral ?
    2391          72 :                      bms_overlap(pull_varnos(rcon->root, (Node *) newnode),
    2392          72 :                                  rcon->relids) :
    2393         670 :                      contain_vars_of_level((Node *) newnode, 0)) &&
    2394         176 :                     !contain_nonstrict_functions((Node *) newnode))
    2395             :                 {
    2396             :                     /* No wrap needed */
    2397           0 :                     wrap = false;
    2398             :                 }
    2399             :                 else
    2400             :                 {
    2401             :                     /* Else wrap it in a PlaceHolderVar */
    2402         742 :                     wrap = true;
    2403             :                 }
    2404             :             }
    2405             : 
    2406        3346 :             if (wrap)
    2407             :                 newnode = (Node *)
    2408         830 :                     make_placeholder_expr(rcon->root,
    2409             :                                           (Expr *) newnode,
    2410             :                                           bms_make_singleton(rcon->varno));
    2411             : 
    2412             :             /*
    2413             :              * Cache it if possible (ie, if the attno is in range, which it
    2414             :              * probably always should be).  We can cache the value even if we
    2415             :              * decided we didn't need a PHV, since this result will be
    2416             :              * suitable for any request that has need_phvs.
    2417             :              */
    2418        6692 :             if (varattno > InvalidAttrNumber &&
    2419        3346 :                 varattno <= list_length(rcon->targetlist))
    2420        3346 :                 rcon->rv_cache[varattno] = copyObject(newnode);
    2421             :         }
    2422             :     }
    2423             : 
    2424             :     /* Must adjust varlevelsup if tlist item is from higher query */
    2425       95558 :     if (var->varlevelsup > 0)
    2426         448 :         IncrementVarSublevelsUp(newnode, var->varlevelsup, 0);
    2427             : 
    2428       95558 :     return newnode;
    2429             : }
    2430             : 
    2431             : /*
    2432             :  * Apply pullup variable replacement to a subquery
    2433             :  *
    2434             :  * This needs to be different from pullup_replace_vars() because
    2435             :  * replace_rte_variables will think that it shouldn't increment sublevels_up
    2436             :  * before entering the Query; so we need to call it with sublevels_up == 1.
    2437             :  */
    2438             : static Query *
    2439         284 : pullup_replace_vars_subquery(Query *query,
    2440             :                              pullup_replace_vars_context *context)
    2441             : {
    2442             :     Assert(IsA(query, Query));
    2443         284 :     return (Query *) replace_rte_variables((Node *) query,
    2444             :                                            context->varno, 1,
    2445             :                                            pullup_replace_vars_callback,
    2446             :                                            (void *) context,
    2447             :                                            NULL);
    2448             : }
    2449             : 
    2450             : 
    2451             : /*
    2452             :  * flatten_simple_union_all
    2453             :  *      Try to optimize top-level UNION ALL structure into an appendrel
    2454             :  *
    2455             :  * If a query's setOperations tree consists entirely of simple UNION ALL
    2456             :  * operations, flatten it into an append relation, which we can process more
    2457             :  * intelligently than the general setops case.  Otherwise, do nothing.
    2458             :  *
    2459             :  * In most cases, this can succeed only for a top-level query, because for a
    2460             :  * subquery in FROM, the parent query's invocation of pull_up_subqueries would
    2461             :  * already have flattened the UNION via pull_up_simple_union_all.  But there
    2462             :  * are a few cases we can support here but not in that code path, for example
    2463             :  * when the subquery also contains ORDER BY.
    2464             :  */
    2465             : void
    2466        3424 : flatten_simple_union_all(PlannerInfo *root)
    2467             : {
    2468        3424 :     Query      *parse = root->parse;
    2469             :     SetOperationStmt *topop;
    2470             :     Node       *leftmostjtnode;
    2471             :     int         leftmostRTI;
    2472             :     RangeTblEntry *leftmostRTE;
    2473             :     int         childRTI;
    2474             :     RangeTblEntry *childRTE;
    2475             :     RangeTblRef *rtr;
    2476             : 
    2477             :     /* Shouldn't be called unless query has setops */
    2478        3424 :     topop = castNode(SetOperationStmt, parse->setOperations);
    2479             :     Assert(topop);
    2480             : 
    2481             :     /* Can't optimize away a recursive UNION */
    2482        3424 :     if (root->hasRecursion)
    2483        3244 :         return;
    2484             : 
    2485             :     /*
    2486             :      * Recursively check the tree of set operations.  If not all UNION ALL
    2487             :      * with identical column types, punt.
    2488             :      */
    2489        2966 :     if (!is_simple_union_all_recurse((Node *) topop, parse, topop->colTypes))
    2490        2786 :         return;
    2491             : 
    2492             :     /*
    2493             :      * Locate the leftmost leaf query in the setops tree.  The upper query's
    2494             :      * Vars all refer to this RTE (see transformSetOperationStmt).
    2495             :      */
    2496         180 :     leftmostjtnode = topop->larg;
    2497         278 :     while (leftmostjtnode && IsA(leftmostjtnode, SetOperationStmt))
    2498          98 :         leftmostjtnode = ((SetOperationStmt *) leftmostjtnode)->larg;
    2499             :     Assert(leftmostjtnode && IsA(leftmostjtnode, RangeTblRef));
    2500         180 :     leftmostRTI = ((RangeTblRef *) leftmostjtnode)->rtindex;
    2501         180 :     leftmostRTE = rt_fetch(leftmostRTI, parse->rtable);
    2502             :     Assert(leftmostRTE->rtekind == RTE_SUBQUERY);
    2503             : 
    2504             :     /*
    2505             :      * Make a copy of the leftmost RTE and add it to the rtable.  This copy
    2506             :      * will represent the leftmost leaf query in its capacity as a member of
    2507             :      * the appendrel.  The original will represent the appendrel as a whole.
    2508             :      * (We must do things this way because the upper query's Vars have to be
    2509             :      * seen as referring to the whole appendrel.)
    2510             :      */
    2511         180 :     childRTE = copyObject(leftmostRTE);
    2512         180 :     parse->rtable = lappend(parse->rtable, childRTE);
    2513         180 :     childRTI = list_length(parse->rtable);
    2514             : 
    2515             :     /* Modify the setops tree to reference the child copy */
    2516         180 :     ((RangeTblRef *) leftmostjtnode)->rtindex = childRTI;
    2517             : 
    2518             :     /* Modify the formerly-leftmost RTE to mark it as an appendrel parent */
    2519         180 :     leftmostRTE->inh = true;
    2520             : 
    2521             :     /*
    2522             :      * Form a RangeTblRef for the appendrel, and insert it into FROM.  The top
    2523             :      * Query of a setops tree should have had an empty FromClause initially.
    2524             :      */
    2525         180 :     rtr = makeNode(RangeTblRef);
    2526         180 :     rtr->rtindex = leftmostRTI;
    2527             :     Assert(parse->jointree->fromlist == NIL);
    2528         180 :     parse->jointree->fromlist = list_make1(rtr);
    2529             : 
    2530             :     /*
    2531             :      * Now pretend the query has no setops.  We must do this before trying to
    2532             :      * do subquery pullup, because of Assert in pull_up_simple_subquery.
    2533             :      */
    2534         180 :     parse->setOperations = NULL;
    2535             : 
    2536             :     /*
    2537             :      * Build AppendRelInfo information, and apply pull_up_subqueries to the
    2538             :      * leaf queries of the UNION ALL.  (We must do that now because they
    2539             :      * weren't previously referenced by the jointree, and so were missed by
    2540             :      * the main invocation of pull_up_subqueries.)
    2541             :      */
    2542         180 :     pull_up_union_leaf_queries((Node *) topop, root, leftmostRTI, parse, 0);
    2543             : }
    2544             : 
    2545             : 
    2546             : /*
    2547             :  * reduce_outer_joins
    2548             :  *      Attempt to reduce outer joins to plain inner joins.
    2549             :  *
    2550             :  * The idea here is that given a query like
    2551             :  *      SELECT ... FROM a LEFT JOIN b ON (...) WHERE b.y = 42;
    2552             :  * we can reduce the LEFT JOIN to a plain JOIN if the "=" operator in WHERE
    2553             :  * is strict.  The strict operator will always return NULL, causing the outer
    2554             :  * WHERE to fail, on any row where the LEFT JOIN filled in NULLs for b's
    2555             :  * columns.  Therefore, there's no need for the join to produce null-extended
    2556             :  * rows in the first place --- which makes it a plain join not an outer join.
    2557             :  * (This scenario may not be very likely in a query written out by hand, but
    2558             :  * it's reasonably likely when pushing quals down into complex views.)
    2559             :  *
    2560             :  * More generally, an outer join can be reduced in strength if there is a
    2561             :  * strict qual above it in the qual tree that constrains a Var from the
    2562             :  * nullable side of the join to be non-null.  (For FULL joins this applies
    2563             :  * to each side separately.)
    2564             :  *
    2565             :  * Another transformation we apply here is to recognize cases like
    2566             :  *      SELECT ... FROM a LEFT JOIN b ON (a.x = b.y) WHERE b.y IS NULL;
    2567             :  * If the join clause is strict for b.y, then only null-extended rows could
    2568             :  * pass the upper WHERE, and we can conclude that what the query is really
    2569             :  * specifying is an anti-semijoin.  We change the join type from JOIN_LEFT
    2570             :  * to JOIN_ANTI.  The IS NULL clause then becomes redundant, and must be
    2571             :  * removed to prevent bogus selectivity calculations, but we leave it to
    2572             :  * distribute_qual_to_rels to get rid of such clauses.
    2573             :  *
    2574             :  * Also, we get rid of JOIN_RIGHT cases by flipping them around to become
    2575             :  * JOIN_LEFT.  This saves some code here and in some later planner routines,
    2576             :  * but the main reason to do it is to not need to invent a JOIN_REVERSE_ANTI
    2577             :  * join type.
    2578             :  *
    2579             :  * To ease recognition of strict qual clauses, we require this routine to be
    2580             :  * run after expression preprocessing (i.e., qual canonicalization and JOIN
    2581             :  * alias-var expansion).
    2582             :  */
    2583             : void
    2584       62216 : reduce_outer_joins(PlannerInfo *root)
    2585             : {
    2586             :     reduce_outer_joins_state *state;
    2587             : 
    2588             :     /*
    2589             :      * To avoid doing strictness checks on more quals than necessary, we want
    2590             :      * to stop descending the jointree as soon as there are no outer joins
    2591             :      * below our current point.  This consideration forces a two-pass process.
    2592             :      * The first pass gathers information about which base rels appear below
    2593             :      * each side of each join clause, and about whether there are outer
    2594             :      * join(s) below each side of each join clause. The second pass examines
    2595             :      * qual clauses and changes join types as it descends the tree.
    2596             :      */
    2597       62216 :     state = reduce_outer_joins_pass1((Node *) root->parse->jointree);
    2598             : 
    2599             :     /* planner.c shouldn't have called me if no outer joins */
    2600       62216 :     if (state == NULL || !state->contains_outer)
    2601           0 :         elog(ERROR, "so where are the outer joins?");
    2602             : 
    2603       62216 :     reduce_outer_joins_pass2((Node *) root->parse->jointree,
    2604             :                              state, root, NULL, NIL, NIL);
    2605       62216 : }
    2606             : 
    2607             : /*
    2608             :  * reduce_outer_joins_pass1 - phase 1 data collection
    2609             :  *
    2610             :  * Returns a state node describing the given jointree node.
    2611             :  */
    2612             : static reduce_outer_joins_state *
    2613      342498 : reduce_outer_joins_pass1(Node *jtnode)
    2614             : {
    2615             :     reduce_outer_joins_state *result;
    2616             : 
    2617             :     result = (reduce_outer_joins_state *)
    2618      342498 :         palloc(sizeof(reduce_outer_joins_state));
    2619      342498 :     result->relids = NULL;
    2620      342498 :     result->contains_outer = false;
    2621      342498 :     result->sub_states = NIL;
    2622             : 
    2623      342498 :     if (jtnode == NULL)
    2624           0 :         return result;
    2625      342498 :     if (IsA(jtnode, RangeTblRef))
    2626             :     {
    2627      171294 :         int         varno = ((RangeTblRef *) jtnode)->rtindex;
    2628             : 
    2629      171294 :         result->relids = bms_make_singleton(varno);
    2630             :     }
    2631      171204 :     else if (IsA(jtnode, FromExpr))
    2632             :     {
    2633       63442 :         FromExpr   *f = (FromExpr *) jtnode;
    2634             :         ListCell   *l;
    2635             : 
    2636      128200 :         foreach(l, f->fromlist)
    2637             :         {
    2638             :             reduce_outer_joins_state *sub_state;
    2639             : 
    2640       64758 :             sub_state = reduce_outer_joins_pass1(lfirst(l));
    2641      129516 :             result->relids = bms_add_members(result->relids,
    2642       64758 :                                              sub_state->relids);
    2643       64758 :             result->contains_outer |= sub_state->contains_outer;
    2644       64758 :             result->sub_states = lappend(result->sub_states, sub_state);
    2645             :         }
    2646             :     }
    2647      107762 :     else if (IsA(jtnode, JoinExpr))
    2648             :     {
    2649      107762 :         JoinExpr   *j = (JoinExpr *) jtnode;
    2650             :         reduce_outer_joins_state *sub_state;
    2651             : 
    2652             :         /* join's own RT index is not wanted in result->relids */
    2653      107762 :         if (IS_OUTER_JOIN(j->jointype))
    2654       79208 :             result->contains_outer = true;
    2655             : 
    2656      107762 :         sub_state = reduce_outer_joins_pass1(j->larg);
    2657      215524 :         result->relids = bms_add_members(result->relids,
    2658      107762 :                                          sub_state->relids);
    2659      107762 :         result->contains_outer |= sub_state->contains_outer;
    2660      107762 :         result->sub_states = lappend(result->sub_states, sub_state);
    2661             : 
    2662      107762 :         sub_state = reduce_outer_joins_pass1(j->rarg);
    2663      215524 :         result->relids = bms_add_members(result->relids,
    2664      107762 :                                          sub_state->relids);
    2665      107762 :         result->contains_outer |= sub_state->contains_outer;
    2666      107762 :         result->sub_states = lappend(result->sub_states, sub_state);
    2667             :     }
    2668             :     else
    2669           0 :         elog(ERROR, "unrecognized node type: %d",
    2670             :              (int) nodeTag(jtnode));
    2671      342498 :     return result;
    2672             : }
    2673             : 
    2674             : /*
    2675             :  * reduce_outer_joins_pass2 - phase 2 processing
    2676             :  *
    2677             :  *  jtnode: current jointree node
    2678             :  *  state: state data collected by phase 1 for this node
    2679             :  *  root: toplevel planner state
    2680             :  *  nonnullable_rels: set of base relids forced non-null by upper quals
    2681             :  *  nonnullable_vars: list of Vars forced non-null by upper quals
    2682             :  *  forced_null_vars: list of Vars forced null by upper quals
    2683             :  */
    2684             : static void
    2685      142494 : reduce_outer_joins_pass2(Node *jtnode,
    2686             :                          reduce_outer_joins_state *state,
    2687             :                          PlannerInfo *root,
    2688             :                          Relids nonnullable_rels,
    2689             :                          List *nonnullable_vars,
    2690             :                          List *forced_null_vars)
    2691             : {
    2692             :     /*
    2693             :      * pass 2 should never descend as far as an empty subnode or base rel,
    2694             :      * because it's only called on subtrees marked as contains_outer.
    2695             :      */
    2696      142494 :     if (jtnode == NULL)
    2697           0 :         elog(ERROR, "reached empty jointree");
    2698      142494 :     if (IsA(jtnode, RangeTblRef))
    2699           0 :         elog(ERROR, "reached base rel");
    2700      142494 :     else if (IsA(jtnode, FromExpr))
    2701             :     {
    2702       62934 :         FromExpr   *f = (FromExpr *) jtnode;
    2703             :         ListCell   *l;
    2704             :         ListCell   *s;
    2705             :         Relids      pass_nonnullable_rels;
    2706             :         List       *pass_nonnullable_vars;
    2707             :         List       *pass_forced_null_vars;
    2708             : 
    2709             :         /* Scan quals to see if we can add any constraints */
    2710       62934 :         pass_nonnullable_rels = find_nonnullable_rels(f->quals);
    2711       62934 :         pass_nonnullable_rels = bms_add_members(pass_nonnullable_rels,
    2712             :                                                 nonnullable_rels);
    2713       62934 :         pass_nonnullable_vars = find_nonnullable_vars(f->quals);
    2714       62934 :         pass_nonnullable_vars = list_concat(pass_nonnullable_vars,
    2715             :                                             nonnullable_vars);
    2716       62934 :         pass_forced_null_vars = find_forced_null_vars(f->quals);
    2717       62934 :         pass_forced_null_vars = list_concat(pass_forced_null_vars,
    2718             :                                             forced_null_vars);
    2719             :         /* And recurse --- but only into interesting subtrees */
    2720             :         Assert(list_length(f->fromlist) == list_length(state->sub_states));
    2721      127100 :         forboth(l, f->fromlist, s, state->sub_states)
    2722             :         {
    2723       64166 :             reduce_outer_joins_state *sub_state = lfirst(s);
    2724             : 
    2725       64166 :             if (sub_state->contains_outer)
    2726       62954 :                 reduce_outer_joins_pass2(lfirst(l), sub_state, root,
    2727             :                                          pass_nonnullable_rels,
    2728             :                                          pass_nonnullable_vars,
    2729             :                                          pass_forced_null_vars);
    2730             :         }
    2731       62934 :         bms_free(pass_nonnullable_rels);
    2732             :         /* can't so easily clean up var lists, unfortunately */
    2733             :     }
    2734       79560 :     else if (IsA(jtnode, JoinExpr))
    2735             :     {
    2736       79560 :         JoinExpr   *j = (JoinExpr *) jtnode;
    2737       79560 :         int         rtindex = j->rtindex;
    2738       79560 :         JoinType    jointype = j->jointype;
    2739       79560 :         reduce_outer_joins_state *left_state = linitial(state->sub_states);
    2740       79560 :         reduce_outer_joins_state *right_state = lsecond(state->sub_states);
    2741       79560 :         List       *local_nonnullable_vars = NIL;
    2742       79560 :         bool        computed_local_nonnullable_vars = false;
    2743             : 
    2744             :         /* Can we simplify this join? */
    2745       79560 :         switch (jointype)
    2746             :         {
    2747         344 :             case JOIN_INNER:
    2748         344 :                 break;
    2749       78214 :             case JOIN_LEFT:
    2750       78214 :                 if (bms_overlap(nonnullable_rels, right_state->relids))
    2751         770 :                     jointype = JOIN_INNER;
    2752       78214 :                 break;
    2753         188 :             case JOIN_RIGHT:
    2754         188 :                 if (bms_overlap(nonnullable_rels, left_state->relids))
    2755          28 :                     jointype = JOIN_INNER;
    2756         188 :                 break;
    2757         602 :             case JOIN_FULL:
    2758         602 :                 if (bms_overlap(nonnullable_rels, left_state->relids))
    2759             :                 {
    2760           0 :                     if (bms_overlap(nonnullable_rels, right_state->relids))
    2761           0 :                         jointype = JOIN_INNER;
    2762             :                     else
    2763           0 :                         jointype = JOIN_LEFT;
    2764             :                 }
    2765             :                 else
    2766             :                 {
    2767         602 :                     if (bms_overlap(nonnullable_rels, right_state->relids))
    2768          12 :                         jointype = JOIN_RIGHT;
    2769             :                 }
    2770         602 :                 break;
    2771         212 :             case JOIN_SEMI:
    2772             :             case JOIN_ANTI:
    2773             : 
    2774             :                 /*
    2775             :                  * These could only have been introduced by pull_up_sublinks,
    2776             :                  * so there's no way that upper quals could refer to their
    2777             :                  * righthand sides, and no point in checking.
    2778             :                  */
    2779         212 :                 break;
    2780           0 :             default:
    2781           0 :                 elog(ERROR, "unrecognized join type: %d",
    2782             :                      (int) jointype);
    2783             :                 break;
    2784             :         }
    2785             : 
    2786             :         /*
    2787             :          * Convert JOIN_RIGHT to JOIN_LEFT.  Note that in the case where we
    2788             :          * reduced JOIN_FULL to JOIN_RIGHT, this will mean the JoinExpr no
    2789             :          * longer matches the internal ordering of any CoalesceExpr's built to
    2790             :          * represent merged join variables.  We don't care about that at
    2791             :          * present, but be wary of it ...
    2792             :          */
    2793       79560 :         if (jointype == JOIN_RIGHT)
    2794             :         {
    2795             :             Node       *tmparg;
    2796             : 
    2797         172 :             tmparg = j->larg;
    2798         172 :             j->larg = j->rarg;
    2799         172 :             j->rarg = tmparg;
    2800         172 :             jointype = JOIN_LEFT;
    2801         172 :             right_state = linitial(state->sub_states);
    2802         172 :             left_state = lsecond(state->sub_states);
    2803             :         }
    2804             : 
    2805             :         /*
    2806             :          * See if we can reduce JOIN_LEFT to JOIN_ANTI.  This is the case if
    2807             :          * the join's own quals are strict for any var that was forced null by
    2808             :          * higher qual levels.  NOTE: there are other ways that we could
    2809             :          * detect an anti-join, in particular if we were to check whether Vars
    2810             :          * coming from the RHS must be non-null because of table constraints.
    2811             :          * That seems complicated and expensive though (in particular, one
    2812             :          * would have to be wary of lower outer joins). For the moment this
    2813             :          * seems sufficient.
    2814             :          */
    2815       79560 :         if (jointype == JOIN_LEFT)
    2816             :         {
    2817             :             List       *overlap;
    2818             : 
    2819       77616 :             local_nonnullable_vars = find_nonnullable_vars(j->quals);
    2820       77616 :             computed_local_nonnullable_vars = true;
    2821             : 
    2822             :             /*
    2823             :              * It's not sufficient to check whether local_nonnullable_vars and
    2824             :              * forced_null_vars overlap: we need to know if the overlap
    2825             :              * includes any RHS variables.
    2826             :              */
    2827       77616 :             overlap = list_intersection(local_nonnullable_vars,
    2828             :                                         forced_null_vars);
    2829       78334 :             if (overlap != NIL &&
    2830         718 :                 bms_overlap(pull_varnos(root, (Node *) overlap),
    2831         718 :                             right_state->relids))
    2832         702 :                 jointype = JOIN_ANTI;
    2833             :         }
    2834             : 
    2835             :         /* Apply the jointype change, if any, to both jointree node and RTE */
    2836       79560 :         if (rtindex && jointype != j->jointype)
    2837             :         {
    2838        1672 :             RangeTblEntry *rte = rt_fetch(rtindex, root->parse->rtable);
    2839             : 
    2840             :             Assert(rte->rtekind == RTE_JOIN);
    2841             :             Assert(rte->jointype == j->jointype);
    2842        1672 :             rte->jointype = jointype;
    2843             :         }
    2844       79560 :         j->jointype = jointype;
    2845             : 
    2846             :         /* Only recurse if there's more to do below here */
    2847       79560 :         if (left_state->contains_outer || right_state->contains_outer)
    2848             :         {
    2849             :             Relids      local_nonnullable_rels;
    2850             :             List       *local_forced_null_vars;
    2851             :             Relids      pass_nonnullable_rels;
    2852             :             List       *pass_nonnullable_vars;
    2853             :             List       *pass_forced_null_vars;
    2854             : 
    2855             :             /*
    2856             :              * If this join is (now) inner, we can add any constraints its
    2857             :              * quals provide to those we got from above.  But if it is outer,
    2858             :              * we can pass down the local constraints only into the nullable
    2859             :              * side, because an outer join never eliminates any rows from its
    2860             :              * non-nullable side.  Also, there is no point in passing upper
    2861             :              * constraints into the nullable side, since if there were any
    2862             :              * we'd have been able to reduce the join.  (In the case of upper
    2863             :              * forced-null constraints, we *must not* pass them into the
    2864             :              * nullable side --- they either applied here, or not.) The upshot
    2865             :              * is that we pass either the local or the upper constraints,
    2866             :              * never both, to the children of an outer join.
    2867             :              *
    2868             :              * Note that a SEMI join works like an inner join here: it's okay
    2869             :              * to pass down both local and upper constraints.  (There can't be
    2870             :              * any upper constraints affecting its inner side, but it's not
    2871             :              * worth having a separate code path to avoid passing them.)
    2872             :              *
    2873             :              * At a FULL join we just punt and pass nothing down --- is it
    2874             :              * possible to be smarter?
    2875             :              */
    2876       17304 :             if (jointype != JOIN_FULL)
    2877             :             {
    2878       17198 :                 local_nonnullable_rels = find_nonnullable_rels(j->quals);
    2879       17198 :                 if (!computed_local_nonnullable_vars)
    2880         754 :                     local_nonnullable_vars = find_nonnullable_vars(j->quals);
    2881       17198 :                 local_forced_null_vars = find_forced_null_vars(j->quals);
    2882       17198 :                 if (jointype == JOIN_INNER || jointype == JOIN_SEMI)
    2883             :                 {
    2884             :                     /* OK to merge upper and local constraints */
    2885         550 :                     local_nonnullable_rels = bms_add_members(local_nonnullable_rels,
    2886             :                                                              nonnullable_rels);
    2887         550 :                     local_nonnullable_vars = list_concat(local_nonnullable_vars,
    2888             :                                                          nonnullable_vars);
    2889         550 :                     local_forced_null_vars = list_concat(local_forced_null_vars,
    2890             :                                                          forced_null_vars);
    2891             :                 }
    2892             :             }
    2893             :             else
    2894             :             {
    2895             :                 /* no use in calculating these */
    2896         106 :                 local_nonnullable_rels = NULL;
    2897         106 :                 local_forced_null_vars = NIL;
    2898             :             }
    2899             : 
    2900       17304 :             if (left_state->contains_outer)
    2901             :             {
    2902       16988 :                 if (jointype == JOIN_INNER || jointype == JOIN_SEMI)
    2903             :                 {
    2904             :                     /* pass union of local and upper constraints */
    2905         448 :                     pass_nonnullable_rels = local_nonnullable_rels;
    2906         448 :                     pass_nonnullable_vars = local_nonnullable_vars;
    2907         448 :                     pass_forced_null_vars = local_forced_null_vars;
    2908             :                 }
    2909       16540 :                 else if (jointype != JOIN_FULL) /* ie, LEFT or ANTI */
    2910             :                 {
    2911             :                     /* can't pass local constraints to non-nullable side */
    2912       16458 :                     pass_nonnullable_rels = nonnullable_rels;
    2913       16458 :                     pass_nonnullable_vars = nonnullable_vars;
    2914       16458 :                     pass_forced_null_vars = forced_null_vars;
    2915             :                 }
    2916             :                 else
    2917             :                 {
    2918             :                     /* no constraints pass through JOIN_FULL */
    2919          82 :                     pass_nonnullable_rels = NULL;
    2920          82 :                     pass_nonnullable_vars = NIL;
    2921          82 :                     pass_forced_null_vars = NIL;
    2922             :                 }
    2923       16988 :                 reduce_outer_joins_pass2(j->larg, left_state, root,
    2924             :                                          pass_nonnullable_rels,
    2925             :                                          pass_nonnullable_vars,
    2926             :                                          pass_forced_null_vars);
    2927             :             }
    2928             : 
    2929       17304 :             if (right_state->contains_outer)
    2930             :             {
    2931         336 :                 if (jointype != JOIN_FULL)  /* ie, INNER/LEFT/SEMI/ANTI */
    2932             :                 {
    2933             :                     /* pass appropriate constraints, per comment above */
    2934         312 :                     pass_nonnullable_rels = local_nonnullable_rels;
    2935         312 :                     pass_nonnullable_vars = local_nonnullable_vars;
    2936         312 :                     pass_forced_null_vars = local_forced_null_vars;
    2937             :                 }
    2938             :                 else
    2939             :                 {
    2940             :                     /* no constraints pass through JOIN_FULL */
    2941          24 :                     pass_nonnullable_rels = NULL;
    2942          24 :                     pass_nonnullable_vars = NIL;
    2943          24 :                     pass_forced_null_vars = NIL;
    2944             :                 }
    2945         336 :                 reduce_outer_joins_pass2(j->rarg, right_state, root,
    2946             :                                          pass_nonnullable_rels,
    2947             :                                          pass_nonnullable_vars,
    2948             :                                          pass_forced_null_vars);
    2949             :             }
    2950       17304 :             bms_free(local_nonnullable_rels);
    2951             :         }
    2952             :     }
    2953             :     else
    2954           0 :         elog(ERROR, "unrecognized node type: %d",
    2955             :              (int) nodeTag(jtnode));
    2956      142494 : }
    2957             : 
    2958             : 
    2959             : /*
    2960             :  * remove_useless_result_rtes
    2961             :  *      Attempt to remove RTE_RESULT RTEs from the join tree.
    2962             :  *
    2963             :  * We can remove RTE_RESULT entries from the join tree using the knowledge
    2964             :  * that RTE_RESULT returns exactly one row and has no output columns.  Hence,
    2965             :  * if one is inner-joined to anything else, we can delete it.  Optimizations
    2966             :  * are also possible for some outer-join cases, as detailed below.
    2967             :  *
    2968             :  * Some of these optimizations depend on recognizing empty (constant-true)
    2969             :  * quals for FromExprs and JoinExprs.  That makes it useful to apply this
    2970             :  * optimization pass after expression preprocessing, since that will have
    2971             :  * eliminated constant-true quals, allowing more cases to be recognized as
    2972             :  * optimizable.  What's more, the usual reason for an RTE_RESULT to be present
    2973             :  * is that we pulled up a subquery or VALUES clause, thus very possibly
    2974             :  * replacing Vars with constants, making it more likely that a qual can be
    2975             :  * reduced to constant true.  Also, because some optimizations depend on
    2976             :  * the outer-join type, it's best to have done reduce_outer_joins() first.
    2977             :  *
    2978             :  * A PlaceHolderVar referencing an RTE_RESULT RTE poses an obstacle to this
    2979             :  * process: we must remove the RTE_RESULT's relid from the PHV's phrels, but
    2980             :  * we must not reduce the phrels set to empty.  If that would happen, and
    2981             :  * the RTE_RESULT is an immediate child of an outer join, we have to give up
    2982             :  * and not remove the RTE_RESULT: there is noplace else to evaluate the
    2983             :  * PlaceHolderVar.  (That is, in such cases the RTE_RESULT *does* have output
    2984             :  * columns.)  But if the RTE_RESULT is an immediate child of an inner join,
    2985             :  * we can usually change the PlaceHolderVar's phrels so as to evaluate it at
    2986             :  * the inner join instead.  This is OK because we really only care that PHVs
    2987             :  * are evaluated above or below the correct outer joins.  We can't, however,
    2988             :  * postpone the evaluation of a PHV to above where it is used; so there are
    2989             :  * some checks below on whether output PHVs are laterally referenced in the
    2990             :  * other join input rel(s).
    2991             :  *
    2992             :  * We used to try to do this work as part of pull_up_subqueries() where the
    2993             :  * potentially-optimizable cases get introduced; but it's way simpler, and
    2994             :  * more effective, to do it separately.
    2995             :  */
    2996             : void
    2997      134706 : remove_useless_result_rtes(PlannerInfo *root)
    2998             : {
    2999             :     ListCell   *cell;
    3000             : 
    3001             :     /* Top level of jointree must always be a FromExpr */
    3002             :     Assert(IsA(root->parse->jointree, FromExpr));
    3003             :     /* Recurse ... */
    3004      269412 :     root->parse->jointree = (FromExpr *)
    3005      134706 :         remove_useless_results_recurse(root, (Node *) root->parse->jointree);
    3006             :     /* We should still have a FromExpr */
    3007             :     Assert(IsA(root->parse->jointree, FromExpr));
    3008             : 
    3009             :     /*
    3010             :      * Remove any PlanRowMark referencing an RTE_RESULT RTE.  We obviously
    3011             :      * must do that for any RTE_RESULT that we just removed.  But one for a
    3012             :      * RTE that we did not remove can be dropped anyway: since the RTE has
    3013             :      * only one possible output row, there is no need for EPQ to mark and
    3014             :      * restore that row.
    3015             :      *
    3016             :      * It's necessary, not optional, to remove the PlanRowMark for a surviving
    3017             :      * RTE_RESULT RTE; otherwise we'll generate a whole-row Var for the
    3018             :      * RTE_RESULT, which the executor has no support for.
    3019             :      */
    3020      134730 :     foreach(cell, root->rowMarks)
    3021             :     {
    3022          24 :         PlanRowMark *rc = (PlanRowMark *) lfirst(cell);
    3023             : 
    3024          24 :         if (rt_fetch(rc->rti, root->parse->rtable)->rtekind == RTE_RESULT)
    3025          16 :             root->rowMarks = foreach_delete_current(root->rowMarks, cell);
    3026             :     }
    3027      134706 : }
    3028             : 
    3029             : /*
    3030             :  * remove_useless_results_recurse
    3031             :  *      Recursive guts of remove_useless_result_rtes.
    3032             :  *
    3033             :  * This recursively processes the jointree and returns a modified jointree.
    3034             :  */
    3035             : static Node *
    3036      271504 : remove_useless_results_recurse(PlannerInfo *root, Node *jtnode)
    3037             : {
    3038             :     Assert(jtnode != NULL);
    3039      271504 :     if (IsA(jtnode, RangeTblRef))
    3040             :     {
    3041             :         /* Can't immediately do anything with a RangeTblRef */
    3042             :     }
    3043      135746 :     else if (IsA(jtnode, FromExpr))
    3044             :     {
    3045      135052 :         FromExpr   *f = (FromExpr *) jtnode;
    3046      135052 :         Relids      result_relids = NULL;
    3047             :         ListCell   *cell;
    3048             : 
    3049             :         /*
    3050             :          * We can drop RTE_RESULT rels from the fromlist so long as at least
    3051             :          * one child remains, since joining to a one-row table changes
    3052             :          * nothing.  (But we can't drop a RTE_RESULT that computes PHV(s) that
    3053             :          * are needed by some sibling.  The cleanup transformation below would
    3054             :          * reassign the PHVs to be computed at the join, which is too late for
    3055             :          * the sibling's use.)  The easiest way to mechanize this rule is to
    3056             :          * modify the list in-place.
    3057             :          */
    3058      270462 :         foreach(cell, f->fromlist)
    3059             :         {
    3060      135410 :             Node       *child = (Node *) lfirst(cell);
    3061             :             int         varno;
    3062             : 
    3063             :             /* Recursively transform child ... */
    3064      135410 :             child = remove_useless_results_recurse(root, child);
    3065             :             /* ... and stick it back into the tree */
    3066      135410 :             lfirst(cell) = child;
    3067             : 
    3068             :             /*
    3069             :              * If it's an RTE_RESULT with at least one sibling, and no sibling
    3070             :              * references dependent PHVs, we can drop it.  We don't yet know
    3071             :              * what the inner join's final relid set will be, so postpone
    3072             :              * cleanup of PHVs etc till after this loop.
    3073             :              */
    3074      135990 :             if (list_length(f->fromlist) > 1 &&
    3075         580 :                 (varno = get_result_relid(root, child)) != 0 &&
    3076         160 :                 !find_dependent_phvs_in_jointree(root, (Node *) f, varno))
    3077             :             {
    3078         144 :                 f->fromlist = foreach_delete_current(f->fromlist, cell);
    3079         144 :                 result_relids = bms_add_member(result_relids, varno);
    3080             :             }
    3081             :         }
    3082             : 
    3083             :         /*
    3084             :          * Clean up if we dropped any RTE_RESULT RTEs.  This is a bit
    3085             :          * inefficient if there's more than one, but it seems better to
    3086             :          * optimize the support code for the single-relid case.
    3087             :          */
    3088      135052 :         if (result_relids)
    3089             :         {
    3090         136 :             int         varno = -1;
    3091             : 
    3092         280 :             while ((varno = bms_next_member(result_relids, varno)) >= 0)
    3093         144 :                 remove_result_refs(root, varno, (Node *) f);
    3094             :         }
    3095             : 
    3096             :         /*
    3097             :          * If we're not at the top of the jointree, it's valid to simplify a
    3098             :          * degenerate FromExpr into its single child.  (At the top, we must
    3099             :          * keep the FromExpr since Query.jointree is required to point to a
    3100             :          * FromExpr.)
    3101             :          */
    3102      135052 :         if (f != root->parse->jointree &&
    3103         376 :             f->quals == NULL &&
    3104          30 :             list_length(f->fromlist) == 1)
    3105          30 :             return (Node *) linitial(f->fromlist);
    3106             :     }
    3107         694 :     else if (IsA(jtnode, JoinExpr))
    3108             :     {
    3109         694 :         JoinExpr   *j = (JoinExpr *) jtnode;
    3110             :         int         varno;
    3111             : 
    3112             :         /* First, recurse */
    3113         694 :         j->larg = remove_useless_results_recurse(root, j->larg);
    3114         694 :         j->rarg = remove_useless_results_recurse(root, j->rarg);
    3115             : 
    3116             :         /* Apply join-type-specific optimization rules */
    3117         694 :         switch (j->jointype)
    3118             :         {
    3119         182 :             case JOIN_INNER:
    3120             : 
    3121             :                 /*
    3122             :                  * An inner join is equivalent to a FromExpr, so if either
    3123             :                  * side was simplified to an RTE_RESULT rel, we can replace
    3124             :                  * the join with a FromExpr with just the other side; and if
    3125             :                  * the qual is empty (JOIN ON TRUE) then we can omit the
    3126             :                  * FromExpr as well.
    3127             :                  *
    3128             :                  * Just as in the FromExpr case, we can't simplify if the
    3129             :                  * other input rel references any PHVs that are marked as to
    3130             :                  * be evaluated at the RTE_RESULT rel, because we can't
    3131             :                  * postpone their evaluation in that case.  But we only have
    3132             :                  * to check this in cases where it's syntactically legal for
    3133             :                  * the other input to have a LATERAL reference to the
    3134             :                  * RTE_RESULT rel.  Only RHSes of inner and left joins are
    3135             :                  * allowed to have such refs.
    3136             :                  */
    3137         182 :                 if ((varno = get_result_relid(root, j->larg)) != 0 &&
    3138          22 :                     !find_dependent_phvs_in_jointree(root, j->rarg, varno))
    3139             :                 {
    3140          22 :                     remove_result_refs(root, varno, j->rarg);
    3141          22 :                     if (j->quals)
    3142             :                         jtnode = (Node *)
    3143           8 :                             makeFromExpr(list_make1(j->rarg), j->quals);
    3144             :                     else
    3145          14 :                         jtnode = j->rarg;
    3146             :                 }
    3147         160 :                 else if ((varno = get_result_relid(root, j->rarg)) != 0)
    3148             :                 {
    3149          76 :                     remove_result_refs(root, varno, j->larg);
    3150          76 :                     if (j->quals)
    3151             :                         jtnode = (Node *)
    3152          64 :                             makeFromExpr(list_make1(j->larg), j->quals);
    3153             :                     else
    3154          12 :                         jtnode = j->larg;
    3155             :                 }
    3156         182 :                 break;
    3157         232 :             case JOIN_LEFT:
    3158             : 
    3159             :                 /*
    3160             :                  * We can simplify this case if the RHS is an RTE_RESULT, with
    3161             :                  * two different possibilities:
    3162             :                  *
    3163             :                  * If the qual is empty (JOIN ON TRUE), then the join can be
    3164             :                  * strength-reduced to a plain inner join, since each LHS row
    3165             :                  * necessarily has exactly one join partner.  So we can always
    3166             :                  * discard the RHS, much as in the JOIN_INNER case above.
    3167             :                  * (Again, the LHS could not contain a lateral reference to
    3168             :                  * the RHS.)
    3169             :                  *
    3170             :                  * Otherwise, it's still true that each LHS row should be
    3171             :                  * returned exactly once, and since the RHS returns no columns
    3172             :                  * (unless there are PHVs that have to be evaluated there), we
    3173             :                  * don't much care if it's null-extended or not.  So in this
    3174             :                  * case also, we can just ignore the qual and discard the left
    3175             :                  * join.
    3176             :                  */
    3177         232 :                 if ((varno = get_result_relid(root, j->rarg)) != 0 &&
    3178          40 :                     (j->quals == NULL ||
    3179          16 :                      !find_dependent_phvs(root, varno)))
    3180             :                 {
    3181          24 :                     remove_result_refs(root, varno, j->larg);
    3182          24 :                     jtnode = j->larg;
    3183             :                 }
    3184         232 :                 break;
    3185           0 :             case JOIN_RIGHT:
    3186             :                 /* Mirror-image of the JOIN_LEFT case */
    3187           0 :                 if ((varno = get_result_relid(root, j->larg)) != 0 &&
    3188           0 :                     (j->quals == NULL ||
    3189           0 :                      !find_dependent_phvs(root, varno)))
    3190             :                 {
    3191           0 :                     remove_result_refs(root, varno, j->rarg);
    3192           0 :                     jtnode = j->rarg;
    3193             :                 }
    3194           0 :                 break;
    3195         268 :             case JOIN_SEMI:
    3196             : 
    3197             :                 /*
    3198             :                  * We may simplify this case if the RHS is an RTE_RESULT; the
    3199             :                  * join qual becomes effectively just a filter qual for the
    3200             :                  * LHS, since we should either return the LHS row or not.  For
    3201             :                  * simplicity we inject the filter qual into a new FromExpr.
    3202             :                  *
    3203             :                  * Unlike the LEFT/RIGHT cases, we just Assert that there are
    3204             :                  * no PHVs that need to be evaluated at the semijoin's RHS,
    3205             :                  * since the rest of the query couldn't reference any outputs
    3206             :                  * of the semijoin's RHS.
    3207             :                  */
    3208         268 :                 if ((varno = get_result_relid(root, j->rarg)) != 0)
    3209             :                 {
    3210             :                     Assert(!find_dependent_phvs(root, varno));
    3211           8 :                     remove_result_refs(root, varno, j->larg);
    3212           8 :                     if (j->quals)
    3213             :                         jtnode = (Node *)
    3214           8 :                             makeFromExpr(list_make1(j->larg), j->quals);
    3215             :                     else
    3216           0 :                         jtnode = j->larg;
    3217             :                 }
    3218         268 :                 break;
    3219          12 :             case JOIN_FULL:
    3220             :             case JOIN_ANTI:
    3221             :                 /* We have no special smarts for these cases */
    3222          12 :                 break;
    3223           0 :             default:
    3224           0 :                 elog(ERROR, "unrecognized join type: %d",
    3225             :                      (int) j->jointype);
    3226             :                 break;
    3227             :         }
    3228             :     }
    3229             :     else
    3230           0 :         elog(ERROR, "unrecognized node type: %d",
    3231             :              (int) nodeTag(jtnode));
    3232      271474 :     return jtnode;
    3233             : }
    3234             : 
    3235             : /*
    3236             :  * get_result_relid
    3237             :  *      If jtnode is a RangeTblRef for an RTE_RESULT RTE, return its relid;
    3238             :  *      otherwise return 0.
    3239             :  */
    3240             : static int
    3241        1422 : get_result_relid(PlannerInfo *root, Node *jtnode)
    3242             : {
    3243             :     int         varno;
    3244             : 
    3245        1422 :     if (!IsA(jtnode, RangeTblRef))
    3246         186 :         return 0;
    3247        1236 :     varno = ((RangeTblRef *) jtnode)->rtindex;
    3248        1236 :     if (rt_fetch(varno, root->parse->rtable)->rtekind != RTE_RESULT)
    3249         930 :         return 0;
    3250         306 :     return varno;
    3251             : }
    3252             : 
    3253             : /*
    3254             :  * remove_result_refs
    3255             :  *      Helper routine for dropping an unneeded RTE_RESULT RTE.
    3256             :  *
    3257             :  * This doesn't physically remove the RTE from the jointree, because that's
    3258             :  * more easily handled in remove_useless_results_recurse.  What it does do
    3259             :  * is the necessary cleanup in the rest of the tree: we must adjust any PHVs
    3260             :  * that may reference the RTE.  Be sure to call this at a point where the
    3261             :  * jointree is valid (no disconnected nodes).
    3262             :  *
    3263             :  * Note that we don't need to process the append_rel_list, since RTEs
    3264             :  * referenced directly in the jointree won't be appendrel members.
    3265             :  *
    3266             :  * varno is the RTE_RESULT's relid.
    3267             :  * newjtloc is the jointree location at which any PHVs referencing the
    3268             :  * RTE_RESULT should be evaluated instead.
    3269             :  */
    3270             : static void
    3271         274 : remove_result_refs(PlannerInfo *root, int varno, Node *newjtloc)
    3272             : {
    3273             :     /* Fix up PlaceHolderVars as needed */
    3274             :     /* If there are no PHVs anywhere, we can skip this bit */
    3275         274 :     if (root->glob->lastPHId != 0)
    3276             :     {
    3277             :         Relids      subrelids;
    3278             : 
    3279          60 :         subrelids = get_relids_in_jointree(newjtloc, false);
    3280             :         Assert(!bms_is_empty(subrelids));
    3281          60 :         substitute_phv_relids((Node *) root->parse, varno, subrelids);
    3282          60 :         fix_append_rel_relids(root->append_rel_list, varno, subrelids);
    3283             :     }
    3284             : 
    3285             :     /*
    3286             :      * We also need to remove any PlanRowMark referencing the RTE, but we
    3287             :      * postpone that work until we return to remove_useless_result_rtes.
    3288             :      */
    3289         274 : }
    3290             : 
    3291             : 
    3292             : /*
    3293             :  * find_dependent_phvs - are there any PlaceHolderVars whose relids are
    3294             :  * exactly the given varno?
    3295             :  *
    3296             :  * find_dependent_phvs should be used when we want to see if there are
    3297             :  * any such PHVs anywhere in the Query.  Another use-case is to see if
    3298             :  * a subtree of the join tree contains such PHVs; but for that, we have
    3299             :  * to look not only at the join tree nodes themselves but at the
    3300             :  * referenced RTEs.  For that, use find_dependent_phvs_in_jointree.
    3301             :  */
    3302             : 
    3303             : typedef struct
    3304             : {
    3305             :     Relids      relids;
    3306             :     int         sublevels_up;
    3307             : } find_dependent_phvs_context;
    3308             : 
    3309             : static bool
    3310         784 : find_dependent_phvs_walker(Node *node,
    3311             :                            find_dependent_phvs_context *context)
    3312             : {
    3313         784 :     if (node == NULL)
    3314         192 :         return false;
    3315         592 :     if (IsA(node, PlaceHolderVar))
    3316             :     {
    3317          52 :         PlaceHolderVar *phv = (PlaceHolderVar *) node;
    3318             : 
    3319         104 :         if (phv->phlevelsup == context->sublevels_up &&
    3320          52 :             bms_equal(context->relids, phv->phrels))
    3321          32 :             return true;
    3322             :         /* fall through to examine children */
    3323             :     }
    3324         560 :     if (IsA(node, Query))
    3325             :     {
    3326             :         /* Recurse into subselects */
    3327             :         bool        result;
    3328             : 
    3329          32 :         context->sublevels_up++;
    3330          32 :         result = query_tree_walker((Query *) node,
    3331             :                                    find_dependent_phvs_walker,
    3332             :                                    (void *) context, 0);
    3333          32 :         context->sublevels_up--;
    3334          32 :         return result;
    3335             :     }
    3336             :     /* Shouldn't need to handle planner auxiliary nodes here */
    3337             :     Assert(!IsA(node, SpecialJoinInfo));
    3338             :     Assert(!IsA(node, AppendRelInfo));
    3339             :     Assert(!IsA(node, PlaceHolderInfo));
    3340             :     Assert(!IsA(node, MinMaxAggInfo));
    3341             : 
    3342         528 :     return expression_tree_walker(node, find_dependent_phvs_walker,
    3343             :                                   (void *) context);
    3344             : }
    3345             : 
    3346             : static bool
    3347          16 : find_dependent_phvs(PlannerInfo *root, int varno)
    3348             : {
    3349             :     find_dependent_phvs_context context;
    3350             : 
    3351             :     /* If there are no PHVs anywhere, we needn't work hard */
    3352          16 :     if (root->glob->lastPHId == 0)
    3353           0 :         return false;
    3354             : 
    3355          16 :     context.relids = bms_make_singleton(varno);
    3356          16 :     context.sublevels_up = 0;
    3357             : 
    3358          16 :     return query_tree_walker(root->parse,
    3359             :                              find_dependent_phvs_walker,
    3360             :                              (void *) &context,
    3361             :                              0);
    3362             : }
    3363             : 
    3364             : static bool
    3365         182 : find_dependent_phvs_in_jointree(PlannerInfo *root, Node *node, int varno)
    3366             : {
    3367             :     find_dependent_phvs_context context;
    3368             :     Relids      subrelids;
    3369             :     int         relid;
    3370             : 
    3371             :     /* If there are no PHVs anywhere, we needn't work hard */
    3372         182 :     if (root->glob->lastPHId == 0)
    3373         146 :         return false;
    3374             : 
    3375          36 :     context.relids = bms_make_singleton(varno);
    3376          36 :     context.sublevels_up = 0;
    3377             : 
    3378             :     /*
    3379             :      * See if the jointree fragment itself contains references (in join quals)
    3380             :      */
    3381          36 :     if (find_dependent_phvs_walker(node, &context))
    3382           0 :         return true;
    3383             : 
    3384             :     /*
    3385             :      * Otherwise, identify the set of referenced RTEs (we can ignore joins,
    3386             :      * since they should be flattened already, so their join alias lists no
    3387             :      * longer matter), and tediously check each RTE.  We can ignore RTEs that
    3388             :      * are not marked LATERAL, though, since they couldn't possibly contain
    3389             :      * any cross-references to other RTEs.
    3390             :      */
    3391          36 :     subrelids = get_relids_in_jointree(node, false);
    3392          36 :     relid = -1;
    3393          80 :     while ((relid = bms_next_member(subrelids, relid)) >= 0)
    3394             :     {
    3395          60 :         RangeTblEntry *rte = rt_fetch(relid, root->parse->rtable);
    3396             : 
    3397          76 :         if (rte->lateral &&
    3398          16 :             range_table_entry_walker(rte,
    3399             :                                      find_dependent_phvs_walker,
    3400             :                                      (void *) &context,
    3401             :                                      0))
    3402          16 :             return true;
    3403             :     }
    3404             : 
    3405          20 :     return false;
    3406             : }
    3407             : 
    3408             : /*
    3409             :  * substitute_phv_relids - adjust PlaceHolderVar relid sets after pulling up
    3410             :  * a subquery or removing an RTE_RESULT jointree item
    3411             :  *
    3412             :  * Find any PlaceHolderVar nodes in the given tree that reference the
    3413             :  * pulled-up relid, and change them to reference the replacement relid(s).
    3414             :  *
    3415             :  * NOTE: although this has the form of a walker, we cheat and modify the
    3416             :  * nodes in-place.  This should be OK since the tree was copied by
    3417             :  * pullup_replace_vars earlier.  Avoid scribbling on the original values of
    3418             :  * the bitmapsets, though, because expression_tree_mutator doesn't copy those.
    3419             :  */
    3420             : 
    3421             : typedef struct
    3422             : {
    3423             :     int         varno;
    3424             :     int         sublevels_up;
    3425             :     Relids      subrelids;
    3426             : } substitute_phv_relids_context;
    3427             : 
    3428             : static bool
    3429     1089672 : substitute_phv_relids_walker(Node *node,
    3430             :                              substitute_phv_relids_context *context)
    3431             : {
    3432     1089672 :     if (node == NULL)
    3433      423340 :         return false;
    3434      666332 :     if (IsA(node, PlaceHolderVar))
    3435             :     {
    3436        2964 :         PlaceHolderVar *phv = (PlaceHolderVar *) node;
    3437             : 
    3438        5904 :         if (phv->phlevelsup == context->sublevels_up &&
    3439        2940 :             bms_is_member(context->varno, phv->phrels))
    3440             :         {
    3441        3892 :             phv->phrels = bms_union(phv->phrels,
    3442        1946 :                                     context->subrelids);
    3443        1946 :             phv->phrels = bms_del_member(phv->phrels,
    3444             :                                          context->varno);
    3445             :             /* Assert we haven't broken the PHV */
    3446             :             Assert(!bms_is_empty(phv->phrels));
    3447             :         }
    3448             :         /* fall through to examine children */
    3449             :     }
    3450      666332 :     if (IsA(node, Query))
    3451             :     {
    3452             :         /* Recurse into subselects */
    3453             :         bool        result;
    3454             : 
    3455       26970 :         context->sublevels_up++;
    3456       26970 :         result = query_tree_walker((Query *) node,
    3457             :                                    substitute_phv_relids_walker,
    3458             :                                    (void *) context, 0);
    3459       26970 :         context->sublevels_up--;
    3460       26970 :         return result;
    3461             :     }
    3462             :     /* Shouldn't need to handle planner auxiliary nodes here */
    3463             :     Assert(!IsA(node, SpecialJoinInfo));
    3464             :     Assert(!IsA(node, AppendRelInfo));
    3465             :     Assert(!IsA(node, PlaceHolderInfo));
    3466             :     Assert(!IsA(node, MinMaxAggInfo));
    3467             : 
    3468      639362 :     return expression_tree_walker(node, substitute_phv_relids_walker,
    3469             :                                   (void *) context);
    3470             : }
    3471             : 
    3472             : static void
    3473       10826 : substitute_phv_relids(Node *node, int varno, Relids subrelids)
    3474             : {
    3475             :     substitute_phv_relids_context context;
    3476             : 
    3477       10826 :     context.varno = varno;
    3478       10826 :     context.sublevels_up = 0;
    3479       10826 :     context.subrelids = subrelids;
    3480             : 
    3481             :     /*
    3482             :      * Must be prepared to start with a Query or a bare expression tree.
    3483             :      */
    3484       10826 :     query_or_expression_tree_walker(node,
    3485             :                                     substitute_phv_relids_walker,
    3486             :                                     (void *) &context,
    3487             :                                     0);
    3488       10826 : }
    3489             : 
    3490             : /*
    3491             :  * fix_append_rel_relids: update RT-index fields of AppendRelInfo nodes
    3492             :  *
    3493             :  * When we pull up a subquery, any AppendRelInfo references to the subquery's
    3494             :  * RT index have to be replaced by the substituted relid (and there had better
    3495             :  * be only one).  We also need to apply substitute_phv_relids to their
    3496             :  * translated_vars lists, since those might contain PlaceHolderVars.
    3497             :  *
    3498             :  * We assume we may modify the AppendRelInfo nodes in-place.
    3499             :  */
    3500             : static void
    3501        7930 : fix_append_rel_relids(List *append_rel_list, int varno, Relids subrelids)
    3502             : {
    3503             :     ListCell   *l;
    3504        7930 :     int         subvarno = -1;
    3505             : 
    3506             :     /*
    3507             :      * We only want to extract the member relid once, but we mustn't fail
    3508             :      * immediately if there are multiple members; it could be that none of the
    3509             :      * AppendRelInfo nodes refer to it.  So compute it on first use. Note that
    3510             :      * bms_singleton_member will complain if set is not singleton.
    3511             :      */
    3512       10826 :     foreach(l, append_rel_list)
    3513             :     {
    3514        2896 :         AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(l);
    3515             : 
    3516             :         /* The parent_relid shouldn't ever be a pullup target */
    3517             :         Assert(appinfo->parent_relid != varno);
    3518             : 
    3519        2896 :         if (appinfo->child_relid == varno)
    3520             :         {
    3521        1578 :             if (subvarno < 0)
    3522        1578 :                 subvarno = bms_singleton_member(subrelids);
    3523        1578 :             appinfo->child_relid = subvarno;
    3524             :         }
    3525             : 
    3526             :         /* Also fix up any PHVs in its translated vars */
    3527        2896 :         substitute_phv_relids((Node *) appinfo->translated_vars,
    3528             :                               varno, subrelids);
    3529             :     }
    3530        7930 : }
    3531             : 
    3532             : /*
    3533             :  * get_relids_in_jointree: get set of RT indexes present in a jointree
    3534             :  *
    3535             :  * If include_joins is true, join RT indexes are included; if false,
    3536             :  * only base rels are included.
    3537             :  */
    3538             : Relids
    3539       75412 : get_relids_in_jointree(Node *jtnode, bool include_joins)
    3540             : {
    3541       75412 :     Relids      result = NULL;
    3542             : 
    3543       75412 :     if (jtnode == NULL)
    3544           0 :         return result;
    3545       75412 :     if (IsA(jtnode, RangeTblRef))
    3546             :     {
    3547       38184 :         int         varno = ((RangeTblRef *) jtnode)->rtindex;
    3548             : 
    3549       38184 :         result = bms_make_singleton(varno);
    3550             :     }
    3551       37228 :     else if (IsA(jtnode, FromExpr))
    3552             :     {
    3553       32154 :         FromExpr   *f = (FromExpr *) jtnode;
    3554             :         ListCell   *l;
    3555             : 
    3556       65312 :         foreach(l, f->fromlist)
    3557             :         {
    3558       33158 :             result = bms_join(result,
    3559       33158 :                               get_relids_in_jointree(lfirst(l),
    3560             :                                                      include_joins));
    3561             :         }
    3562             :     }
    3563        5074 :     else if (IsA(jtnode, JoinExpr))
    3564             :     {
    3565        5074 :         JoinExpr   *j = (JoinExpr *) jtnode;
    3566             : 
    3567        5074 :         result = get_relids_in_jointree(j->larg, include_joins);
    3568        5074 :         result = bms_join(result,
    3569             :                           get_relids_in_jointree(j->rarg, include_joins));
    3570        5074 :         if (include_joins && j->rtindex)
    3571         436 :             result = bms_add_member(result, j->rtindex);
    3572             :     }
    3573             :     else
    3574           0 :         elog(ERROR, "unrecognized node type: %d",
    3575             :              (int) nodeTag(jtnode));
    3576       75412 :     return result;
    3577             : }
    3578             : 
    3579             : /*
    3580             :  * get_relids_for_join: get set of base RT indexes making up a join
    3581             :  */
    3582             : Relids
    3583           0 : get_relids_for_join(Query *query, int joinrelid)
    3584             : {
    3585             :     Node       *jtnode;
    3586             : 
    3587           0 :     jtnode = find_jointree_node_for_rel((Node *) query->jointree,
    3588             :                                         joinrelid);
    3589           0 :     if (!jtnode)
    3590           0 :         elog(ERROR, "could not find join node %d", joinrelid);
    3591           0 :     return get_relids_in_jointree(jtnode, false);
    3592             : }
    3593             : 
    3594             : /*
    3595             :  * find_jointree_node_for_rel: locate jointree node for a base or join RT index
    3596             :  *
    3597             :  * Returns NULL if not found
    3598             :  */
    3599             : static Node *
    3600           0 : find_jointree_node_for_rel(Node *jtnode, int relid)
    3601             : {
    3602           0 :     if (jtnode == NULL)
    3603           0 :         return NULL;
    3604           0 :     if (IsA(jtnode, RangeTblRef))
    3605             :     {
    3606           0 :         int         varno = ((RangeTblRef *) jtnode)->rtindex;
    3607             : 
    3608           0 :         if (relid == varno)
    3609           0 :             return jtnode;
    3610             :     }
    3611           0 :     else if (IsA(jtnode, FromExpr))
    3612             :     {
    3613           0 :         FromExpr   *f = (FromExpr *) jtnode;
    3614             :         ListCell   *l;
    3615             : 
    3616           0 :         foreach(l, f->fromlist)
    3617             :         {
    3618           0 :             jtnode = find_jointree_node_for_rel(lfirst(l), relid);
    3619           0 :             if (jtnode)
    3620           0 :                 return jtnode;
    3621             :         }
    3622             :     }
    3623           0 :     else if (IsA(jtnode, JoinExpr))
    3624             :     {
    3625           0 :         JoinExpr   *j = (JoinExpr *) jtnode;
    3626             : 
    3627           0 :         if (relid == j->rtindex)
    3628           0 :             return jtnode;
    3629           0 :         jtnode = find_jointree_node_for_rel(j->larg, relid);
    3630           0 :         if (jtnode)
    3631           0 :             return jtnode;
    3632           0 :         jtnode = find_jointree_node_for_rel(j->rarg, relid);
    3633           0 :         if (jtnode)
    3634           0 :             return jtnode;
    3635             :     }
    3636             :     else
    3637           0 :         elog(ERROR, "unrecognized node type: %d",
    3638             :              (int) nodeTag(jtnode));
    3639           0 :     return NULL;
    3640             : }

Generated by: LCOV version 1.14