LCOV - code coverage report
Current view: top level - src/backend/optimizer/util - appendinfo.c (source / functions) Hit Total Coverage
Test: PostgreSQL 19devel Lines: 318 336 94.6 %
Date: 2025-10-18 17:18:00 Functions: 14 14 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * appendinfo.c
       4             :  *    Routines for mapping between append parent(s) and children
       5             :  *
       6             :  * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
       7             :  * Portions Copyright (c) 1994, Regents of the University of California
       8             :  *
       9             :  *
      10             :  * IDENTIFICATION
      11             :  *    src/backend/optimizer/util/appendinfo.c
      12             :  *
      13             :  *-------------------------------------------------------------------------
      14             :  */
      15             : #include "postgres.h"
      16             : 
      17             : #include "access/htup_details.h"
      18             : #include "access/table.h"
      19             : #include "foreign/fdwapi.h"
      20             : #include "nodes/makefuncs.h"
      21             : #include "nodes/nodeFuncs.h"
      22             : #include "optimizer/appendinfo.h"
      23             : #include "optimizer/pathnode.h"
      24             : #include "optimizer/planmain.h"
      25             : #include "parser/parsetree.h"
      26             : #include "utils/lsyscache.h"
      27             : #include "utils/rel.h"
      28             : #include "utils/syscache.h"
      29             : 
      30             : 
      31             : typedef struct
      32             : {
      33             :     PlannerInfo *root;
      34             :     int         nappinfos;
      35             :     AppendRelInfo **appinfos;
      36             : } adjust_appendrel_attrs_context;
      37             : 
      38             : static void make_inh_translation_list(Relation oldrelation,
      39             :                                       Relation newrelation,
      40             :                                       Index newvarno,
      41             :                                       AppendRelInfo *appinfo);
      42             : static Node *adjust_appendrel_attrs_mutator(Node *node,
      43             :                                             adjust_appendrel_attrs_context *context);
      44             : 
      45             : 
      46             : /*
      47             :  * make_append_rel_info
      48             :  *    Build an AppendRelInfo for the parent-child pair
      49             :  */
      50             : AppendRelInfo *
      51       42218 : make_append_rel_info(Relation parentrel, Relation childrel,
      52             :                      Index parentRTindex, Index childRTindex)
      53             : {
      54       42218 :     AppendRelInfo *appinfo = makeNode(AppendRelInfo);
      55             : 
      56       42218 :     appinfo->parent_relid = parentRTindex;
      57       42218 :     appinfo->child_relid = childRTindex;
      58       42218 :     appinfo->parent_reltype = parentrel->rd_rel->reltype;
      59       42218 :     appinfo->child_reltype = childrel->rd_rel->reltype;
      60       42218 :     make_inh_translation_list(parentrel, childrel, childRTindex, appinfo);
      61       42216 :     appinfo->parent_reloid = RelationGetRelid(parentrel);
      62             : 
      63       42216 :     return appinfo;
      64             : }
      65             : 
      66             : /*
      67             :  * make_inh_translation_list
      68             :  *    Build the list of translations from parent Vars to child Vars for
      69             :  *    an inheritance child, as well as a reverse-translation array.
      70             :  *
      71             :  * The reverse-translation array has an entry for each child relation
      72             :  * column, which is either the 1-based index of the corresponding parent
      73             :  * column, or 0 if there's no match (that happens for dropped child columns,
      74             :  * as well as child columns beyond those of the parent, which are allowed in
      75             :  * traditional inheritance though not partitioning).
      76             :  *
      77             :  * For paranoia's sake, we match type/collation as well as attribute name.
      78             :  */
      79             : static void
      80       42218 : make_inh_translation_list(Relation oldrelation, Relation newrelation,
      81             :                           Index newvarno,
      82             :                           AppendRelInfo *appinfo)
      83             : {
      84       42218 :     List       *vars = NIL;
      85             :     AttrNumber *pcolnos;
      86       42218 :     TupleDesc   old_tupdesc = RelationGetDescr(oldrelation);
      87       42218 :     TupleDesc   new_tupdesc = RelationGetDescr(newrelation);
      88       42218 :     Oid         new_relid = RelationGetRelid(newrelation);
      89       42218 :     int         oldnatts = old_tupdesc->natts;
      90       42218 :     int         newnatts = new_tupdesc->natts;
      91             :     int         old_attno;
      92       42218 :     int         new_attno = 0;
      93             : 
      94             :     /* Initialize reverse-translation array with all entries zero */
      95       42218 :     appinfo->num_child_cols = newnatts;
      96       42218 :     appinfo->parent_colnos = pcolnos =
      97       42218 :         (AttrNumber *) palloc0(newnatts * sizeof(AttrNumber));
      98             : 
      99      155916 :     for (old_attno = 0; old_attno < oldnatts; old_attno++)
     100             :     {
     101             :         Form_pg_attribute att;
     102             :         char       *attname;
     103             :         Oid         atttypid;
     104             :         int32       atttypmod;
     105             :         Oid         attcollation;
     106             : 
     107      113700 :         att = TupleDescAttr(old_tupdesc, old_attno);
     108      113700 :         if (att->attisdropped)
     109             :         {
     110             :             /* Just put NULL into this list entry */
     111        3132 :             vars = lappend(vars, NULL);
     112        3132 :             continue;
     113             :         }
     114      110568 :         attname = NameStr(att->attname);
     115      110568 :         atttypid = att->atttypid;
     116      110568 :         atttypmod = att->atttypmod;
     117      110568 :         attcollation = att->attcollation;
     118             : 
     119             :         /*
     120             :          * When we are generating the "translation list" for the parent table
     121             :          * of an inheritance set, no need to search for matches.
     122             :          */
     123      110568 :         if (oldrelation == newrelation)
     124             :         {
     125        6860 :             vars = lappend(vars, makeVar(newvarno,
     126        6860 :                                          (AttrNumber) (old_attno + 1),
     127             :                                          atttypid,
     128             :                                          atttypmod,
     129             :                                          attcollation,
     130             :                                          0));
     131        6860 :             pcolnos[old_attno] = old_attno + 1;
     132        6860 :             continue;
     133             :         }
     134             : 
     135             :         /*
     136             :          * Otherwise we have to search for the matching column by name.
     137             :          * There's no guarantee it'll have the same column position, because
     138             :          * of cases like ALTER TABLE ADD COLUMN and multiple inheritance.
     139             :          * However, in simple cases, the relative order of columns is mostly
     140             :          * the same in both relations, so try the column of newrelation that
     141             :          * follows immediately after the one that we just found, and if that
     142             :          * fails, let syscache handle it.
     143             :          */
     144      103708 :         if (new_attno >= newnatts ||
     145      101450 :             (att = TupleDescAttr(new_tupdesc, new_attno))->attisdropped ||
     146      100510 :             strcmp(attname, NameStr(att->attname)) != 0)
     147             :         {
     148             :             HeapTuple   newtup;
     149             : 
     150        8386 :             newtup = SearchSysCacheAttName(new_relid, attname);
     151        8386 :             if (!HeapTupleIsValid(newtup))
     152           0 :                 elog(ERROR, "could not find inherited attribute \"%s\" of relation \"%s\"",
     153             :                      attname, RelationGetRelationName(newrelation));
     154        8386 :             new_attno = ((Form_pg_attribute) GETSTRUCT(newtup))->attnum - 1;
     155             :             Assert(new_attno >= 0 && new_attno < newnatts);
     156        8386 :             ReleaseSysCache(newtup);
     157             : 
     158        8386 :             att = TupleDescAttr(new_tupdesc, new_attno);
     159             :         }
     160             : 
     161             :         /* Found it, check type and collation match */
     162      103708 :         if (atttypid != att->atttypid || atttypmod != att->atttypmod)
     163           2 :             ereport(ERROR,
     164             :                     (errcode(ERRCODE_INVALID_COLUMN_DEFINITION),
     165             :                      errmsg("attribute \"%s\" of relation \"%s\" does not match parent's type",
     166             :                             attname, RelationGetRelationName(newrelation))));
     167      103706 :         if (attcollation != att->attcollation)
     168           0 :             ereport(ERROR,
     169             :                     (errcode(ERRCODE_INVALID_COLUMN_DEFINITION),
     170             :                      errmsg("attribute \"%s\" of relation \"%s\" does not match parent's collation",
     171             :                             attname, RelationGetRelationName(newrelation))));
     172             : 
     173      103706 :         vars = lappend(vars, makeVar(newvarno,
     174      103706 :                                      (AttrNumber) (new_attno + 1),
     175             :                                      atttypid,
     176             :                                      atttypmod,
     177             :                                      attcollation,
     178             :                                      0));
     179      103706 :         pcolnos[new_attno] = old_attno + 1;
     180      103706 :         new_attno++;
     181             :     }
     182             : 
     183       42216 :     appinfo->translated_vars = vars;
     184       42216 : }
     185             : 
     186             : /*
     187             :  * adjust_appendrel_attrs
     188             :  *    Copy the specified query or expression and translate Vars referring to a
     189             :  *    parent rel to refer to the corresponding child rel instead.  We also
     190             :  *    update rtindexes appearing outside Vars, such as resultRelation and
     191             :  *    jointree relids.
     192             :  *
     193             :  * Note: this is only applied after conversion of sublinks to subplans,
     194             :  * so we don't need to cope with recursion into sub-queries.
     195             :  *
     196             :  * Note: this is not hugely different from what pullup_replace_vars() does;
     197             :  * maybe we should try to fold the two routines together.
     198             :  */
     199             : Node *
     200      292680 : adjust_appendrel_attrs(PlannerInfo *root, Node *node, int nappinfos,
     201             :                        AppendRelInfo **appinfos)
     202             : {
     203             :     adjust_appendrel_attrs_context context;
     204             : 
     205      292680 :     context.root = root;
     206      292680 :     context.nappinfos = nappinfos;
     207      292680 :     context.appinfos = appinfos;
     208             : 
     209             :     /* If there's nothing to adjust, don't call this function. */
     210             :     Assert(nappinfos >= 1 && appinfos != NULL);
     211             : 
     212             :     /* Should never be translating a Query tree. */
     213             :     Assert(node == NULL || !IsA(node, Query));
     214             : 
     215      292680 :     return adjust_appendrel_attrs_mutator(node, &context);
     216             : }
     217             : 
     218             : static Node *
     219     1515840 : adjust_appendrel_attrs_mutator(Node *node,
     220             :                                adjust_appendrel_attrs_context *context)
     221             : {
     222     1515840 :     AppendRelInfo **appinfos = context->appinfos;
     223     1515840 :     int         nappinfos = context->nappinfos;
     224             :     int         cnt;
     225             : 
     226     1515840 :     if (node == NULL)
     227      283450 :         return NULL;
     228     1232390 :     if (IsA(node, Var))
     229             :     {
     230      551786 :         Var        *var = (Var *) copyObject(node);
     231      551786 :         AppendRelInfo *appinfo = NULL;
     232             : 
     233      551786 :         if (var->varlevelsup != 0)
     234           0 :             return (Node *) var;    /* no changes needed */
     235             : 
     236             :         /*
     237             :          * You might think we need to adjust var->varnullingrels, but that
     238             :          * shouldn't need any changes.  It will contain outer-join relids,
     239             :          * while the transformation we are making affects only baserels.
     240             :          * Below, we just propagate var->varnullingrels into the translated
     241             :          * Var.
     242             :          *
     243             :          * If var->varnullingrels isn't empty, and the translation wouldn't be
     244             :          * a Var, we have to fail.  One could imagine wrapping the translated
     245             :          * expression in a PlaceHolderVar, but that won't work because this is
     246             :          * typically used after freezing placeholders.  Fortunately, the case
     247             :          * appears unreachable at the moment.  We can see nonempty
     248             :          * var->varnullingrels here, but only in cases involving partitionwise
     249             :          * joining, and in such cases the translations will always be Vars.
     250             :          * (Non-Var translations occur only for appendrels made by flattening
     251             :          * UNION ALL subqueries.)  Should we need to make this work in future,
     252             :          * a possible fix is to mandate that prepjointree.c create PHVs for
     253             :          * all non-Var outputs of such subqueries, and then we could look up
     254             :          * the pre-existing PHV here.  Or perhaps just wrap the translations
     255             :          * that way to begin with?
     256             :          *
     257             :          * If var->varreturningtype is not VAR_RETURNING_DEFAULT, then that
     258             :          * also needs to be copied to the translated Var.  That too would fail
     259             :          * if the translation wasn't a Var, but that should never happen since
     260             :          * a non-default var->varreturningtype is only used for Vars referring
     261             :          * to the result relation, which should never be a flattened UNION ALL
     262             :          * subquery.
     263             :          */
     264             : 
     265      690450 :         for (cnt = 0; cnt < nappinfos; cnt++)
     266             :         {
     267      649492 :             if (var->varno == appinfos[cnt]->parent_relid)
     268             :             {
     269      510828 :                 appinfo = appinfos[cnt];
     270      510828 :                 break;
     271             :             }
     272             :         }
     273             : 
     274      551786 :         if (appinfo)
     275             :         {
     276      510828 :             var->varno = appinfo->child_relid;
     277             :             /* it's now a generated Var, so drop any syntactic labeling */
     278      510828 :             var->varnosyn = 0;
     279      510828 :             var->varattnosyn = 0;
     280      510828 :             if (var->varattno > 0)
     281             :             {
     282             :                 Node       *newnode;
     283             : 
     284      492838 :                 if (var->varattno > list_length(appinfo->translated_vars))
     285           0 :                     elog(ERROR, "attribute %d of relation \"%s\" does not exist",
     286             :                          var->varattno, get_rel_name(appinfo->parent_reloid));
     287      492838 :                 newnode = copyObject(list_nth(appinfo->translated_vars,
     288             :                                               var->varattno - 1));
     289      492838 :                 if (newnode == NULL)
     290           0 :                     elog(ERROR, "attribute %d of relation \"%s\" does not exist",
     291             :                          var->varattno, get_rel_name(appinfo->parent_reloid));
     292      492838 :                 if (IsA(newnode, Var))
     293             :                 {
     294      483990 :                     ((Var *) newnode)->varreturningtype = var->varreturningtype;
     295      483990 :                     ((Var *) newnode)->varnullingrels = var->varnullingrels;
     296             :                 }
     297             :                 else
     298             :                 {
     299        8848 :                     if (var->varreturningtype != VAR_RETURNING_DEFAULT)
     300           0 :                         elog(ERROR, "failed to apply returningtype to a non-Var");
     301        8848 :                     if (var->varnullingrels != NULL)
     302           0 :                         elog(ERROR, "failed to apply nullingrels to a non-Var");
     303             :                 }
     304      492838 :                 return newnode;
     305             :             }
     306       17990 :             else if (var->varattno == 0)
     307             :             {
     308             :                 /*
     309             :                  * Whole-row Var: if we are dealing with named rowtypes, we
     310             :                  * can use a whole-row Var for the child table plus a coercion
     311             :                  * step to convert the tuple layout to the parent's rowtype.
     312             :                  * Otherwise we have to generate a RowExpr.
     313             :                  */
     314        1090 :                 if (OidIsValid(appinfo->child_reltype))
     315             :                 {
     316             :                     Assert(var->vartype == appinfo->parent_reltype);
     317        1034 :                     if (appinfo->parent_reltype != appinfo->child_reltype)
     318             :                     {
     319         842 :                         ConvertRowtypeExpr *r = makeNode(ConvertRowtypeExpr);
     320             : 
     321         842 :                         r->arg = (Expr *) var;
     322         842 :                         r->resulttype = appinfo->parent_reltype;
     323         842 :                         r->convertformat = COERCE_IMPLICIT_CAST;
     324         842 :                         r->location = -1;
     325             :                         /* Make sure the Var node has the right type ID, too */
     326         842 :                         var->vartype = appinfo->child_reltype;
     327         842 :                         return (Node *) r;
     328             :                     }
     329             :                 }
     330             :                 else
     331             :                 {
     332             :                     /*
     333             :                      * Build a RowExpr containing the translated variables.
     334             :                      *
     335             :                      * In practice var->vartype will always be RECORDOID here,
     336             :                      * so we need to come up with some suitable column names.
     337             :                      * We use the parent RTE's column names.
     338             :                      *
     339             :                      * Note: we can't get here for inheritance cases, so there
     340             :                      * is no need to worry that translated_vars might contain
     341             :                      * some dummy NULLs.
     342             :                      */
     343             :                     RowExpr    *rowexpr;
     344             :                     List       *fields;
     345             :                     RangeTblEntry *rte;
     346             : 
     347          56 :                     rte = rt_fetch(appinfo->parent_relid,
     348             :                                    context->root->parse->rtable);
     349          56 :                     fields = copyObject(appinfo->translated_vars);
     350          56 :                     rowexpr = makeNode(RowExpr);
     351          56 :                     rowexpr->args = fields;
     352          56 :                     rowexpr->row_typeid = var->vartype;
     353          56 :                     rowexpr->row_format = COERCE_IMPLICIT_CAST;
     354          56 :                     rowexpr->colnames = copyObject(rte->eref->colnames);
     355          56 :                     rowexpr->location = -1;
     356             : 
     357          56 :                     if (var->varreturningtype != VAR_RETURNING_DEFAULT)
     358           0 :                         elog(ERROR, "failed to apply returningtype to a non-Var");
     359          56 :                     if (var->varnullingrels != NULL)
     360           0 :                         elog(ERROR, "failed to apply nullingrels to a non-Var");
     361             : 
     362          56 :                     return (Node *) rowexpr;
     363             :                 }
     364             :             }
     365             :             /* system attributes don't need any other translation */
     366             :         }
     367       40958 :         else if (var->varno == ROWID_VAR)
     368             :         {
     369             :             /*
     370             :              * If it's a ROWID_VAR placeholder, see if we've reached a leaf
     371             :              * target rel, for which we can translate the Var to a specific
     372             :              * instantiation.  We should never be asked to translate to a set
     373             :              * of relids containing more than one leaf target rel, so the
     374             :              * answer will be unique.  If we're still considering non-leaf
     375             :              * inheritance levels, return the ROWID_VAR Var as-is.
     376             :              */
     377       19302 :             Relids      leaf_result_relids = context->root->leaf_result_relids;
     378       19302 :             Index       leaf_relid = 0;
     379             : 
     380       38604 :             for (cnt = 0; cnt < nappinfos; cnt++)
     381             :             {
     382       19302 :                 if (bms_is_member(appinfos[cnt]->child_relid,
     383             :                                   leaf_result_relids))
     384             :                 {
     385       17122 :                     if (leaf_relid)
     386           0 :                         elog(ERROR, "cannot translate to multiple leaf relids");
     387       17122 :                     leaf_relid = appinfos[cnt]->child_relid;
     388             :                 }
     389             :             }
     390             : 
     391       19302 :             if (leaf_relid)
     392             :             {
     393             :                 RowIdentityVarInfo *ridinfo = (RowIdentityVarInfo *)
     394       17122 :                     list_nth(context->root->row_identity_vars, var->varattno - 1);
     395             : 
     396       17122 :                 if (bms_is_member(leaf_relid, ridinfo->rowidrels))
     397             :                 {
     398             :                     /* Substitute the Var given in the RowIdentityVarInfo */
     399       17030 :                     var = copyObject(ridinfo->rowidvar);
     400             :                     /* ... but use the correct relid */
     401       17030 :                     var->varno = leaf_relid;
     402             :                     /* identity vars shouldn't have nulling rels */
     403             :                     Assert(var->varnullingrels == NULL);
     404             :                     /* varnosyn in the RowIdentityVarInfo is probably wrong */
     405       17030 :                     var->varnosyn = 0;
     406       17030 :                     var->varattnosyn = 0;
     407             :                 }
     408             :                 else
     409             :                 {
     410             :                     /*
     411             :                      * This leaf rel can't return the desired value, so
     412             :                      * substitute a NULL of the correct type.
     413             :                      */
     414          92 :                     return (Node *) makeNullConst(var->vartype,
     415             :                                                   var->vartypmod,
     416             :                                                   var->varcollid);
     417             :                 }
     418             :             }
     419             :         }
     420       57958 :         return (Node *) var;
     421             :     }
     422      680604 :     if (IsA(node, CurrentOfExpr))
     423             :     {
     424         184 :         CurrentOfExpr *cexpr = (CurrentOfExpr *) copyObject(node);
     425             : 
     426         184 :         for (cnt = 0; cnt < nappinfos; cnt++)
     427             :         {
     428         184 :             AppendRelInfo *appinfo = appinfos[cnt];
     429             : 
     430         184 :             if (cexpr->cvarno == appinfo->parent_relid)
     431             :             {
     432         184 :                 cexpr->cvarno = appinfo->child_relid;
     433         184 :                 break;
     434             :             }
     435             :         }
     436         184 :         return (Node *) cexpr;
     437             :     }
     438      680420 :     if (IsA(node, PlaceHolderVar))
     439             :     {
     440             :         /* Copy the PlaceHolderVar node with correct mutation of subnodes */
     441             :         PlaceHolderVar *phv;
     442             : 
     443        2808 :         phv = (PlaceHolderVar *) expression_tree_mutator(node,
     444             :                                                          adjust_appendrel_attrs_mutator,
     445             :                                                          context);
     446             :         /* now fix PlaceHolderVar's relid sets */
     447        2808 :         if (phv->phlevelsup == 0)
     448             :         {
     449        2808 :             phv->phrels = adjust_child_relids(phv->phrels,
     450             :                                               nappinfos, appinfos);
     451             :             /* as above, we needn't touch phnullingrels */
     452             :         }
     453        2808 :         return (Node *) phv;
     454             :     }
     455             :     /* Shouldn't need to handle planner auxiliary nodes here */
     456             :     Assert(!IsA(node, SpecialJoinInfo));
     457             :     Assert(!IsA(node, AppendRelInfo));
     458             :     Assert(!IsA(node, PlaceHolderInfo));
     459             :     Assert(!IsA(node, MinMaxAggInfo));
     460             : 
     461             :     /*
     462             :      * We have to process RestrictInfo nodes specially.  (Note: although
     463             :      * set_append_rel_pathlist will hide RestrictInfos in the parent's
     464             :      * baserestrictinfo list from us, it doesn't hide those in joininfo.)
     465             :      */
     466      677612 :     if (IsA(node, RestrictInfo))
     467             :     {
     468       39434 :         RestrictInfo *oldinfo = (RestrictInfo *) node;
     469       39434 :         RestrictInfo *newinfo = makeNode(RestrictInfo);
     470             : 
     471             :         /* Copy all flat-copiable fields, notably including rinfo_serial */
     472       39434 :         memcpy(newinfo, oldinfo, sizeof(RestrictInfo));
     473             : 
     474             :         /* Recursively fix the clause itself */
     475       39434 :         newinfo->clause = (Expr *)
     476       39434 :             adjust_appendrel_attrs_mutator((Node *) oldinfo->clause, context);
     477             : 
     478             :         /* and the modified version, if an OR clause */
     479       39434 :         newinfo->orclause = (Expr *)
     480       39434 :             adjust_appendrel_attrs_mutator((Node *) oldinfo->orclause, context);
     481             : 
     482             :         /* adjust relid sets too */
     483       39434 :         newinfo->clause_relids = adjust_child_relids(oldinfo->clause_relids,
     484             :                                                      context->nappinfos,
     485             :                                                      context->appinfos);
     486       39434 :         newinfo->required_relids = adjust_child_relids(oldinfo->required_relids,
     487             :                                                        context->nappinfos,
     488             :                                                        context->appinfos);
     489       39434 :         newinfo->outer_relids = adjust_child_relids(oldinfo->outer_relids,
     490             :                                                     context->nappinfos,
     491             :                                                     context->appinfos);
     492       39434 :         newinfo->left_relids = adjust_child_relids(oldinfo->left_relids,
     493             :                                                    context->nappinfos,
     494             :                                                    context->appinfos);
     495       39434 :         newinfo->right_relids = adjust_child_relids(oldinfo->right_relids,
     496             :                                                     context->nappinfos,
     497             :                                                     context->appinfos);
     498             : 
     499             :         /*
     500             :          * Reset cached derivative fields, since these might need to have
     501             :          * different values when considering the child relation.  Note we
     502             :          * don't reset left_ec/right_ec: each child variable is implicitly
     503             :          * equivalent to its parent, so still a member of the same EC if any.
     504             :          */
     505       39434 :         newinfo->eval_cost.startup = -1;
     506       39434 :         newinfo->norm_selec = -1;
     507       39434 :         newinfo->outer_selec = -1;
     508       39434 :         newinfo->left_em = NULL;
     509       39434 :         newinfo->right_em = NULL;
     510       39434 :         newinfo->scansel_cache = NIL;
     511       39434 :         newinfo->left_bucketsize = -1;
     512       39434 :         newinfo->right_bucketsize = -1;
     513       39434 :         newinfo->left_mcvfreq = -1;
     514       39434 :         newinfo->right_mcvfreq = -1;
     515             : 
     516       39434 :         return (Node *) newinfo;
     517             :     }
     518             : 
     519             :     /*
     520             :      * We have to process RelAggInfo nodes specially.
     521             :      */
     522      638178 :     if (IsA(node, RelAggInfo))
     523             :     {
     524       18600 :         RelAggInfo *oldinfo = (RelAggInfo *) node;
     525       18600 :         RelAggInfo *newinfo = makeNode(RelAggInfo);
     526             : 
     527       18600 :         newinfo->target = (PathTarget *)
     528       18600 :             adjust_appendrel_attrs_mutator((Node *) oldinfo->target,
     529             :                                            context);
     530             : 
     531       18600 :         newinfo->agg_input = (PathTarget *)
     532       18600 :             adjust_appendrel_attrs_mutator((Node *) oldinfo->agg_input,
     533             :                                            context);
     534             : 
     535       18600 :         newinfo->group_clauses = oldinfo->group_clauses;
     536             : 
     537       18600 :         newinfo->group_exprs = (List *)
     538       18600 :             adjust_appendrel_attrs_mutator((Node *) oldinfo->group_exprs,
     539             :                                            context);
     540             : 
     541       18600 :         return (Node *) newinfo;
     542             :     }
     543             : 
     544             :     /*
     545             :      * We have to process PathTarget nodes specially.
     546             :      */
     547      619578 :     if (IsA(node, PathTarget))
     548             :     {
     549       37200 :         PathTarget *oldtarget = (PathTarget *) node;
     550       37200 :         PathTarget *newtarget = makeNode(PathTarget);
     551             : 
     552             :         /* Copy all flat-copiable fields */
     553       37200 :         memcpy(newtarget, oldtarget, sizeof(PathTarget));
     554             : 
     555       37200 :         newtarget->exprs = (List *)
     556       37200 :             adjust_appendrel_attrs_mutator((Node *) oldtarget->exprs,
     557             :                                            context);
     558             : 
     559       37200 :         if (oldtarget->sortgrouprefs)
     560             :         {
     561       37200 :             Size        nbytes = list_length(oldtarget->exprs) * sizeof(Index);
     562             : 
     563       37200 :             newtarget->sortgrouprefs = (Index *) palloc(nbytes);
     564       37200 :             memcpy(newtarget->sortgrouprefs, oldtarget->sortgrouprefs, nbytes);
     565             :         }
     566             : 
     567       37200 :         return (Node *) newtarget;
     568             :     }
     569             : 
     570             :     /*
     571             :      * NOTE: we do not need to recurse into sublinks, because they should
     572             :      * already have been converted to subplans before we see them.
     573             :      */
     574             :     Assert(!IsA(node, SubLink));
     575             :     Assert(!IsA(node, Query));
     576             :     /* We should never see these Query substructures, either. */
     577             :     Assert(!IsA(node, RangeTblRef));
     578             :     Assert(!IsA(node, JoinExpr));
     579             : 
     580      582378 :     return expression_tree_mutator(node, adjust_appendrel_attrs_mutator, context);
     581             : }
     582             : 
     583             : /*
     584             :  * adjust_appendrel_attrs_multilevel
     585             :  *    Apply Var translations from an appendrel parent down to a child.
     586             :  *
     587             :  * Replace Vars in the "node" expression that reference "parentrel" with
     588             :  * the appropriate Vars for "childrel".  childrel can be more than one
     589             :  * inheritance level removed from parentrel.
     590             :  */
     591             : Node *
     592       47652 : adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node,
     593             :                                   RelOptInfo *childrel,
     594             :                                   RelOptInfo *parentrel)
     595             : {
     596             :     AppendRelInfo **appinfos;
     597             :     int         nappinfos;
     598             : 
     599             :     /* Recurse if immediate parent is not the top parent. */
     600       47652 :     if (childrel->parent != parentrel)
     601             :     {
     602       16336 :         if (childrel->parent)
     603       16336 :             node = adjust_appendrel_attrs_multilevel(root, node,
     604       16336 :                                                      childrel->parent,
     605             :                                                      parentrel);
     606             :         else
     607           0 :             elog(ERROR, "childrel is not a child of parentrel");
     608             :     }
     609             : 
     610             :     /* Now translate for this child. */
     611       47652 :     appinfos = find_appinfos_by_relids(root, childrel->relids, &nappinfos);
     612             : 
     613       47652 :     node = adjust_appendrel_attrs(root, node, nappinfos, appinfos);
     614             : 
     615       47652 :     pfree(appinfos);
     616             : 
     617       47652 :     return node;
     618             : }
     619             : 
     620             : /*
     621             :  * Substitute child relids for parent relids in a Relid set.  The array of
     622             :  * appinfos specifies the substitutions to be performed.
     623             :  */
     624             : Relids
     625      232262 : adjust_child_relids(Relids relids, int nappinfos, AppendRelInfo **appinfos)
     626             : {
     627      232262 :     Bitmapset  *result = NULL;
     628             :     int         cnt;
     629             : 
     630      630766 :     for (cnt = 0; cnt < nappinfos; cnt++)
     631             :     {
     632      398504 :         AppendRelInfo *appinfo = appinfos[cnt];
     633             : 
     634             :         /* Remove parent, add child */
     635      398504 :         if (bms_is_member(appinfo->parent_relid, relids))
     636             :         {
     637             :             /* Make a copy if we are changing the set. */
     638      254698 :             if (!result)
     639      182386 :                 result = bms_copy(relids);
     640             : 
     641      254698 :             result = bms_del_member(result, appinfo->parent_relid);
     642      254698 :             result = bms_add_member(result, appinfo->child_relid);
     643             :         }
     644             :     }
     645             : 
     646             :     /* If we made any changes, return the modified copy. */
     647      232262 :     if (result)
     648      182386 :         return result;
     649             : 
     650             :     /* Otherwise, return the original set without modification. */
     651       49876 :     return relids;
     652             : }
     653             : 
     654             : /*
     655             :  * Substitute child's relids for parent's relids in a Relid set.
     656             :  * The childrel can be multiple inheritance levels below the parent.
     657             :  */
     658             : Relids
     659        1170 : adjust_child_relids_multilevel(PlannerInfo *root, Relids relids,
     660             :                                RelOptInfo *childrel,
     661             :                                RelOptInfo *parentrel)
     662             : {
     663             :     AppendRelInfo **appinfos;
     664             :     int         nappinfos;
     665             : 
     666             :     /*
     667             :      * If the given relids set doesn't contain any of the parent relids, it
     668             :      * will remain unchanged.
     669             :      */
     670        1170 :     if (!bms_overlap(relids, parentrel->relids))
     671           0 :         return relids;
     672             : 
     673             :     /* Recurse if immediate parent is not the top parent. */
     674        1170 :     if (childrel->parent != parentrel)
     675             :     {
     676         144 :         if (childrel->parent)
     677         144 :             relids = adjust_child_relids_multilevel(root, relids,
     678         144 :                                                     childrel->parent,
     679             :                                                     parentrel);
     680             :         else
     681           0 :             elog(ERROR, "childrel is not a child of parentrel");
     682             :     }
     683             : 
     684             :     /* Now translate for this child. */
     685        1170 :     appinfos = find_appinfos_by_relids(root, childrel->relids, &nappinfos);
     686             : 
     687        1170 :     relids = adjust_child_relids(relids, nappinfos, appinfos);
     688             : 
     689        1170 :     pfree(appinfos);
     690             : 
     691        1170 :     return relids;
     692             : }
     693             : 
     694             : /*
     695             :  * adjust_inherited_attnums
     696             :  *    Translate an integer list of attribute numbers from parent to child.
     697             :  */
     698             : List *
     699        5130 : adjust_inherited_attnums(List *attnums, AppendRelInfo *context)
     700             : {
     701        5130 :     List       *result = NIL;
     702             :     ListCell   *lc;
     703             : 
     704             :     /* This should only happen for an inheritance case, not UNION ALL */
     705             :     Assert(OidIsValid(context->parent_reloid));
     706             : 
     707             :     /* Look up each attribute in the AppendRelInfo's translated_vars list */
     708       11450 :     foreach(lc, attnums)
     709             :     {
     710        6320 :         AttrNumber  parentattno = lfirst_int(lc);
     711             :         Var        *childvar;
     712             : 
     713             :         /* Look up the translation of this column: it must be a Var */
     714       12640 :         if (parentattno <= 0 ||
     715        6320 :             parentattno > list_length(context->translated_vars))
     716           0 :             elog(ERROR, "attribute %d of relation \"%s\" does not exist",
     717             :                  parentattno, get_rel_name(context->parent_reloid));
     718        6320 :         childvar = (Var *) list_nth(context->translated_vars, parentattno - 1);
     719        6320 :         if (childvar == NULL || !IsA(childvar, Var))
     720           0 :             elog(ERROR, "attribute %d of relation \"%s\" does not exist",
     721             :                  parentattno, get_rel_name(context->parent_reloid));
     722             : 
     723        6320 :         result = lappend_int(result, childvar->varattno);
     724             :     }
     725        5130 :     return result;
     726             : }
     727             : 
     728             : /*
     729             :  * adjust_inherited_attnums_multilevel
     730             :  *    As above, but traverse multiple inheritance levels as needed.
     731             :  */
     732             : List *
     733        5130 : adjust_inherited_attnums_multilevel(PlannerInfo *root, List *attnums,
     734             :                                     Index child_relid, Index top_parent_relid)
     735             : {
     736        5130 :     AppendRelInfo *appinfo = root->append_rel_array[child_relid];
     737             : 
     738        5130 :     if (!appinfo)
     739           0 :         elog(ERROR, "child rel %d not found in append_rel_array", child_relid);
     740             : 
     741             :     /* Recurse if immediate parent is not the top parent. */
     742        5130 :     if (appinfo->parent_relid != top_parent_relid)
     743         808 :         attnums = adjust_inherited_attnums_multilevel(root, attnums,
     744             :                                                       appinfo->parent_relid,
     745             :                                                       top_parent_relid);
     746             : 
     747             :     /* Now translate for this child */
     748        5130 :     return adjust_inherited_attnums(attnums, appinfo);
     749             : }
     750             : 
     751             : /*
     752             :  * get_translated_update_targetlist
     753             :  *    Get the processed_tlist of an UPDATE query, translated as needed to
     754             :  *    match a child target relation.
     755             :  *
     756             :  * Optionally also return the list of target column numbers translated
     757             :  * to this target relation.  (The resnos in processed_tlist MUST NOT be
     758             :  * relied on for this purpose.)
     759             :  */
     760             : void
     761         100 : get_translated_update_targetlist(PlannerInfo *root, Index relid,
     762             :                                  List **processed_tlist, List **update_colnos)
     763             : {
     764             :     /* This is pretty meaningless for commands other than UPDATE. */
     765             :     Assert(root->parse->commandType == CMD_UPDATE);
     766         100 :     if (relid == root->parse->resultRelation)
     767             :     {
     768             :         /*
     769             :          * Non-inheritance case, so it's easy.  The caller might be expecting
     770             :          * a tree it can scribble on, though, so copy.
     771             :          */
     772          66 :         *processed_tlist = copyObject(root->processed_tlist);
     773          66 :         if (update_colnos)
     774          66 :             *update_colnos = copyObject(root->update_colnos);
     775             :     }
     776             :     else
     777             :     {
     778             :         Assert(bms_is_member(relid, root->all_result_relids));
     779          34 :         *processed_tlist = (List *)
     780          34 :             adjust_appendrel_attrs_multilevel(root,
     781          34 :                                               (Node *) root->processed_tlist,
     782             :                                               find_base_rel(root, relid),
     783          34 :                                               find_base_rel(root, root->parse->resultRelation));
     784          34 :         if (update_colnos)
     785          34 :             *update_colnos =
     786          34 :                 adjust_inherited_attnums_multilevel(root, root->update_colnos,
     787             :                                                     relid,
     788          34 :                                                     root->parse->resultRelation);
     789             :     }
     790         100 : }
     791             : 
     792             : /*
     793             :  * find_appinfos_by_relids
     794             :  *      Find AppendRelInfo structures for base relations listed in relids.
     795             :  *
     796             :  * The relids argument is typically a join relation's relids, which can
     797             :  * include outer-join RT indexes in addition to baserels.  We silently
     798             :  * ignore the outer joins.
     799             :  *
     800             :  * The AppendRelInfos are returned in an array, which can be pfree'd by the
     801             :  * caller. *nappinfos is set to the number of entries in the array.
     802             :  */
     803             : AppendRelInfo **
     804      100346 : find_appinfos_by_relids(PlannerInfo *root, Relids relids, int *nappinfos)
     805             : {
     806             :     AppendRelInfo **appinfos;
     807      100346 :     int         cnt = 0;
     808             :     int         i;
     809             : 
     810             :     /* Allocate an array that's certainly big enough */
     811             :     appinfos = (AppendRelInfo **)
     812      100346 :         palloc(sizeof(AppendRelInfo *) * bms_num_members(relids));
     813             : 
     814      100346 :     i = -1;
     815      252402 :     while ((i = bms_next_member(relids, i)) >= 0)
     816             :     {
     817      152056 :         AppendRelInfo *appinfo = root->append_rel_array[i];
     818             : 
     819      152056 :         if (!appinfo)
     820             :         {
     821             :             /* Probably i is an OJ index, but let's check */
     822        3576 :             if (find_base_rel_ignore_join(root, i) == NULL)
     823        3576 :                 continue;
     824             :             /* It's a base rel, but we lack an append_rel_array entry */
     825           0 :             elog(ERROR, "child rel %d not found in append_rel_array", i);
     826             :         }
     827             : 
     828      148480 :         appinfos[cnt++] = appinfo;
     829             :     }
     830      100346 :     *nappinfos = cnt;
     831      100346 :     return appinfos;
     832             : }
     833             : 
     834             : 
     835             : /*****************************************************************************
     836             :  *
     837             :  *      ROW-IDENTITY VARIABLE MANAGEMENT
     838             :  *
     839             :  * This code lacks a good home, perhaps.  We choose to keep it here because
     840             :  * adjust_appendrel_attrs_mutator() is its principal co-conspirator.  That
     841             :  * function does most of what is needed to expand ROWID_VAR Vars into the
     842             :  * right things.
     843             :  *
     844             :  *****************************************************************************/
     845             : 
     846             : /*
     847             :  * add_row_identity_var
     848             :  *    Register a row-identity column to be used in UPDATE/DELETE/MERGE.
     849             :  *
     850             :  * The Var must be equal(), aside from varno, to any other row-identity
     851             :  * column with the same rowid_name.  Thus, for example, "wholerow"
     852             :  * row identities had better use vartype == RECORDOID.
     853             :  *
     854             :  * rtindex is currently redundant with rowid_var->varno, but we specify
     855             :  * it as a separate parameter in case this is ever generalized to support
     856             :  * non-Var expressions.  (We could reasonably handle expressions over
     857             :  * Vars of the specified rtindex, but for now that seems unnecessary.)
     858             :  */
     859             : void
     860       28302 : add_row_identity_var(PlannerInfo *root, Var *orig_var,
     861             :                      Index rtindex, const char *rowid_name)
     862             : {
     863             :     TargetEntry *tle;
     864             :     Var        *rowid_var;
     865             :     RowIdentityVarInfo *ridinfo;
     866             :     ListCell   *lc;
     867             : 
     868             :     /* For now, the argument must be just a Var of the given rtindex */
     869             :     Assert(IsA(orig_var, Var));
     870             :     Assert(orig_var->varno == rtindex);
     871             :     Assert(orig_var->varlevelsup == 0);
     872             :     Assert(orig_var->varnullingrels == NULL);
     873             : 
     874             :     /*
     875             :      * If we're doing non-inherited UPDATE/DELETE/MERGE, there's little need
     876             :      * for ROWID_VAR shenanigans.  Just shove the presented Var into the
     877             :      * processed_tlist, and we're done.
     878             :      */
     879       28302 :     if (rtindex == root->parse->resultRelation)
     880             :     {
     881       17208 :         tle = makeTargetEntry((Expr *) orig_var,
     882       17208 :                               list_length(root->processed_tlist) + 1,
     883             :                               pstrdup(rowid_name),
     884             :                               true);
     885       17208 :         root->processed_tlist = lappend(root->processed_tlist, tle);
     886       17208 :         return;
     887             :     }
     888             : 
     889             :     /*
     890             :      * Otherwise, rtindex should reference a leaf target relation that's being
     891             :      * added to the query during expand_inherited_rtentry().
     892             :      */
     893             :     Assert(bms_is_member(rtindex, root->leaf_result_relids));
     894             :     Assert(root->append_rel_array[rtindex] != NULL);
     895             : 
     896             :     /*
     897             :      * We have to find a matching RowIdentityVarInfo, or make one if there is
     898             :      * none.  To allow using equal() to match the vars, change the varno to
     899             :      * ROWID_VAR, leaving all else alone.
     900             :      */
     901       11094 :     rowid_var = copyObject(orig_var);
     902             :     /* This could eventually become ChangeVarNodes() */
     903       11094 :     rowid_var->varno = ROWID_VAR;
     904             : 
     905             :     /* Look for an existing row-id column of the same name */
     906       16768 :     foreach(lc, root->row_identity_vars)
     907             :     {
     908       10950 :         ridinfo = (RowIdentityVarInfo *) lfirst(lc);
     909       10950 :         if (strcmp(rowid_name, ridinfo->rowidname) != 0)
     910        5674 :             continue;
     911        5276 :         if (equal(rowid_var, ridinfo->rowidvar))
     912             :         {
     913             :             /* Found a match; we need only record that rtindex needs it too */
     914        5276 :             ridinfo->rowidrels = bms_add_member(ridinfo->rowidrels, rtindex);
     915        5276 :             return;
     916             :         }
     917             :         else
     918             :         {
     919             :             /* Ooops, can't handle this */
     920           0 :             elog(ERROR, "conflicting uses of row-identity name \"%s\"",
     921             :                  rowid_name);
     922             :         }
     923             :     }
     924             : 
     925             :     /* No request yet, so add a new RowIdentityVarInfo */
     926        5818 :     ridinfo = makeNode(RowIdentityVarInfo);
     927        5818 :     ridinfo->rowidvar = copyObject(rowid_var);
     928             :     /* for the moment, estimate width using just the datatype info */
     929        5818 :     ridinfo->rowidwidth = get_typavgwidth(exprType((Node *) rowid_var),
     930             :                                           exprTypmod((Node *) rowid_var));
     931        5818 :     ridinfo->rowidname = pstrdup(rowid_name);
     932        5818 :     ridinfo->rowidrels = bms_make_singleton(rtindex);
     933             : 
     934        5818 :     root->row_identity_vars = lappend(root->row_identity_vars, ridinfo);
     935             : 
     936             :     /* Change rowid_var into a reference to this row_identity_vars entry */
     937        5818 :     rowid_var->varattno = list_length(root->row_identity_vars);
     938             : 
     939             :     /* Push the ROWID_VAR reference variable into processed_tlist */
     940        5818 :     tle = makeTargetEntry((Expr *) rowid_var,
     941        5818 :                           list_length(root->processed_tlist) + 1,
     942             :                           pstrdup(rowid_name),
     943             :                           true);
     944        5818 :     root->processed_tlist = lappend(root->processed_tlist, tle);
     945             : }
     946             : 
     947             : /*
     948             :  * add_row_identity_columns
     949             :  *
     950             :  * This function adds the row identity columns needed by the core code.
     951             :  * FDWs might call add_row_identity_var() for themselves to add nonstandard
     952             :  * columns.  (Duplicate requests are fine.)
     953             :  */
     954             : void
     955       22868 : add_row_identity_columns(PlannerInfo *root, Index rtindex,
     956             :                          RangeTblEntry *target_rte,
     957             :                          Relation target_relation)
     958             : {
     959       22868 :     CmdType     commandType = root->parse->commandType;
     960       22868 :     char        relkind = target_relation->rd_rel->relkind;
     961             :     Var        *var;
     962             : 
     963             :     Assert(commandType == CMD_UPDATE || commandType == CMD_DELETE || commandType == CMD_MERGE);
     964             : 
     965       22868 :     if (relkind == RELKIND_RELATION ||
     966         716 :         relkind == RELKIND_MATVIEW ||
     967             :         relkind == RELKIND_PARTITIONED_TABLE)
     968             :     {
     969             :         /*
     970             :          * Emit CTID so that executor can find the row to merge, update or
     971             :          * delete.
     972             :          */
     973       22188 :         var = makeVar(rtindex,
     974             :                       SelfItemPointerAttributeNumber,
     975             :                       TIDOID,
     976             :                       -1,
     977             :                       InvalidOid,
     978             :                       0);
     979       22188 :         add_row_identity_var(root, var, rtindex, "ctid");
     980             :     }
     981         680 :     else if (relkind == RELKIND_FOREIGN_TABLE)
     982             :     {
     983             :         /*
     984             :          * Let the foreign table's FDW add whatever junk TLEs it wants.
     985             :          */
     986             :         FdwRoutine *fdwroutine;
     987             : 
     988         386 :         fdwroutine = GetFdwRoutineForRelation(target_relation, false);
     989             : 
     990         386 :         if (fdwroutine->AddForeignUpdateTargets != NULL)
     991         378 :             fdwroutine->AddForeignUpdateTargets(root, rtindex,
     992             :                                                 target_rte, target_relation);
     993             : 
     994             :         /*
     995             :          * For UPDATE, we need to make the FDW fetch unchanged columns by
     996             :          * asking it to fetch a whole-row Var.  That's because the top-level
     997             :          * targetlist only contains entries for changed columns, but
     998             :          * ExecUpdate will need to build the complete new tuple.  (Actually,
     999             :          * we only really need this in UPDATEs that are not pushed to the
    1000             :          * remote side, but it's hard to tell if that will be the case at the
    1001             :          * point when this function is called.)
    1002             :          *
    1003             :          * We will also need the whole row if there are any row triggers, so
    1004             :          * that the executor will have the "old" row to pass to the trigger.
    1005             :          * Alas, this misses system columns.
    1006             :          */
    1007         386 :         if (commandType == CMD_UPDATE ||
    1008         172 :             (target_relation->trigdesc &&
    1009          30 :              (target_relation->trigdesc->trig_delete_after_row ||
    1010          18 :               target_relation->trigdesc->trig_delete_before_row)))
    1011             :         {
    1012         230 :             var = makeVar(rtindex,
    1013             :                           InvalidAttrNumber,
    1014             :                           RECORDOID,
    1015             :                           -1,
    1016             :                           InvalidOid,
    1017             :                           0);
    1018         230 :             add_row_identity_var(root, var, rtindex, "wholerow");
    1019             :         }
    1020             :     }
    1021       22868 : }
    1022             : 
    1023             : /*
    1024             :  * distribute_row_identity_vars
    1025             :  *
    1026             :  * After we have finished identifying all the row identity columns
    1027             :  * needed by an inherited UPDATE/DELETE/MERGE query, make sure that
    1028             :  * these columns will be generated by all the target relations.
    1029             :  *
    1030             :  * This is more or less like what build_base_rel_tlists() does,
    1031             :  * except that it would not understand what to do with ROWID_VAR Vars.
    1032             :  * Since that function runs before inheritance relations are expanded,
    1033             :  * it will never see any such Vars anyway.
    1034             :  */
    1035             : void
    1036      324914 : distribute_row_identity_vars(PlannerInfo *root)
    1037             : {
    1038      324914 :     Query      *parse = root->parse;
    1039      324914 :     int         result_relation = parse->resultRelation;
    1040             :     RangeTblEntry *target_rte;
    1041             :     RelOptInfo *target_rel;
    1042             :     ListCell   *lc;
    1043             : 
    1044             :     /*
    1045             :      * There's nothing to do if this isn't an inherited UPDATE/DELETE/MERGE.
    1046             :      */
    1047      324914 :     if (parse->commandType != CMD_UPDATE && parse->commandType != CMD_DELETE &&
    1048      306474 :         parse->commandType != CMD_MERGE)
    1049             :     {
    1050             :         Assert(root->row_identity_vars == NIL);
    1051      304692 :         return;
    1052             :     }
    1053       20222 :     target_rte = rt_fetch(result_relation, parse->rtable);
    1054       20222 :     if (!target_rte->inh)
    1055             :     {
    1056             :         Assert(root->row_identity_vars == NIL);
    1057       17324 :         return;
    1058             :     }
    1059             : 
    1060             :     /*
    1061             :      * Ordinarily, we expect that leaf result relation(s) will have added some
    1062             :      * ROWID_VAR Vars to the query.  However, it's possible that constraint
    1063             :      * exclusion suppressed every leaf relation.  The executor will get upset
    1064             :      * if the plan has no row identity columns at all, even though it will
    1065             :      * certainly process no rows.  Handle this edge case by re-opening the top
    1066             :      * result relation and adding the row identity columns it would have used,
    1067             :      * as preprocess_targetlist() would have done if it weren't marked "inh".
    1068             :      * Then re-run build_base_rel_tlists() to ensure that the added columns
    1069             :      * get propagated to the relation's reltarget.  (This is a bit ugly, but
    1070             :      * it seems better to confine the ugliness and extra cycles to this
    1071             :      * unusual corner case.)
    1072             :      */
    1073        2898 :     if (root->row_identity_vars == NIL)
    1074             :     {
    1075             :         Relation    target_relation;
    1076             : 
    1077          30 :         target_relation = table_open(target_rte->relid, NoLock);
    1078          30 :         add_row_identity_columns(root, result_relation,
    1079             :                                  target_rte, target_relation);
    1080          30 :         table_close(target_relation, NoLock);
    1081          30 :         build_base_rel_tlists(root, root->processed_tlist);
    1082             :         /* There are no ROWID_VAR Vars in this case, so we're done. */
    1083          30 :         return;
    1084             :     }
    1085             : 
    1086             :     /*
    1087             :      * Dig through the processed_tlist to find the ROWID_VAR reference Vars,
    1088             :      * and forcibly copy them into the reltarget list of the topmost target
    1089             :      * relation.  That's sufficient because they'll be copied to the
    1090             :      * individual leaf target rels (with appropriate translation) later,
    1091             :      * during appendrel expansion --- see set_append_rel_size().
    1092             :      */
    1093        2868 :     target_rel = find_base_rel(root, result_relation);
    1094             : 
    1095       12032 :     foreach(lc, root->processed_tlist)
    1096             :     {
    1097        9164 :         TargetEntry *tle = lfirst(lc);
    1098        9164 :         Var        *var = (Var *) tle->expr;
    1099             : 
    1100        9164 :         if (var && IsA(var, Var) && var->varno == ROWID_VAR)
    1101             :         {
    1102        5818 :             target_rel->reltarget->exprs =
    1103        5818 :                 lappend(target_rel->reltarget->exprs, copyObject(var));
    1104             :             /* reltarget cost and width will be computed later */
    1105             :         }
    1106             :     }
    1107             : }

Generated by: LCOV version 1.16