LCOV - code coverage report
Current view: top level - src/backend/optimizer/util - inherit.c (source / functions) Hit Total Coverage
Test: PostgreSQL 14devel Lines: 200 201 99.5 %
Date: 2020-12-05 18:06:08 Functions: 6 6 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * inherit.c
       4             :  *    Routines to process child relations in inheritance trees
       5             :  *
       6             :  * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
       7             :  * Portions Copyright (c) 1994, Regents of the University of California
       8             :  *
       9             :  *
      10             :  * IDENTIFICATION
      11             :  *    src/backend/optimizer/path/inherit.c
      12             :  *
      13             :  *-------------------------------------------------------------------------
      14             :  */
      15             : #include "postgres.h"
      16             : 
      17             : #include "access/sysattr.h"
      18             : #include "access/table.h"
      19             : #include "catalog/partition.h"
      20             : #include "catalog/pg_inherits.h"
      21             : #include "catalog/pg_type.h"
      22             : #include "miscadmin.h"
      23             : #include "nodes/makefuncs.h"
      24             : #include "optimizer/appendinfo.h"
      25             : #include "optimizer/inherit.h"
      26             : #include "optimizer/optimizer.h"
      27             : #include "optimizer/pathnode.h"
      28             : #include "optimizer/planmain.h"
      29             : #include "optimizer/planner.h"
      30             : #include "optimizer/prep.h"
      31             : #include "optimizer/restrictinfo.h"
      32             : #include "parser/parsetree.h"
      33             : #include "partitioning/partdesc.h"
      34             : #include "partitioning/partprune.h"
      35             : #include "utils/rel.h"
      36             : 
      37             : 
      38             : static void expand_partitioned_rtentry(PlannerInfo *root, RelOptInfo *relinfo,
      39             :                                        RangeTblEntry *parentrte,
      40             :                                        Index parentRTindex, Relation parentrel,
      41             :                                        PlanRowMark *top_parentrc, LOCKMODE lockmode);
      42             : static void expand_single_inheritance_child(PlannerInfo *root,
      43             :                                             RangeTblEntry *parentrte,
      44             :                                             Index parentRTindex, Relation parentrel,
      45             :                                             PlanRowMark *top_parentrc, Relation childrel,
      46             :                                             RangeTblEntry **childrte_p,
      47             :                                             Index *childRTindex_p);
      48             : static Bitmapset *translate_col_privs(const Bitmapset *parent_privs,
      49             :                                       List *translated_vars);
      50             : static void expand_appendrel_subquery(PlannerInfo *root, RelOptInfo *rel,
      51             :                                       RangeTblEntry *rte, Index rti);
      52             : 
      53             : 
      54             : /*
      55             :  * expand_inherited_rtentry
      56             :  *      Expand a rangetable entry that has the "inh" bit set.
      57             :  *
      58             :  * "inh" is only allowed in two cases: RELATION and SUBQUERY RTEs.
      59             :  *
      60             :  * "inh" on a plain RELATION RTE means that it is a partitioned table or the
      61             :  * parent of a traditional-inheritance set.  In this case we must add entries
      62             :  * for all the interesting child tables to the query's rangetable, and build
      63             :  * additional planner data structures for them, including RelOptInfos,
      64             :  * AppendRelInfos, and possibly PlanRowMarks.
      65             :  *
      66             :  * Note that the original RTE is considered to represent the whole inheritance
      67             :  * set.  In the case of traditional inheritance, the first of the generated
      68             :  * RTEs is an RTE for the same table, but with inh = false, to represent the
      69             :  * parent table in its role as a simple member of the inheritance set.  For
      70             :  * partitioning, we don't need a second RTE because the partitioned table
      71             :  * itself has no data and need not be scanned.
      72             :  *
      73             :  * "inh" on a SUBQUERY RTE means that it's the parent of a UNION ALL group,
      74             :  * which is treated as an appendrel similarly to inheritance cases; however,
      75             :  * we already made RTEs and AppendRelInfos for the subqueries.  We only need
      76             :  * to build RelOptInfos for them, which is done by expand_appendrel_subquery.
      77             :  */
      78             : void
      79       11920 : expand_inherited_rtentry(PlannerInfo *root, RelOptInfo *rel,
      80             :                          RangeTblEntry *rte, Index rti)
      81             : {
      82             :     Oid         parentOID;
      83             :     Relation    oldrelation;
      84             :     LOCKMODE    lockmode;
      85             :     PlanRowMark *oldrc;
      86       11920 :     bool        old_isParent = false;
      87       11920 :     int         old_allMarkTypes = 0;
      88             : 
      89             :     Assert(rte->inh);            /* else caller error */
      90             : 
      91       11920 :     if (rte->rtekind == RTE_SUBQUERY)
      92             :     {
      93        2200 :         expand_appendrel_subquery(root, rel, rte, rti);
      94        2200 :         return;
      95             :     }
      96             : 
      97             :     Assert(rte->rtekind == RTE_RELATION);
      98             : 
      99        9720 :     parentOID = rte->relid;
     100             : 
     101             :     /*
     102             :      * We used to check has_subclass() here, but there's no longer any need
     103             :      * to, because subquery_planner already did.
     104             :      */
     105             : 
     106             :     /*
     107             :      * The rewriter should already have obtained an appropriate lock on each
     108             :      * relation named in the query, so we can open the parent relation without
     109             :      * locking it.  However, for each child relation we add to the query, we
     110             :      * must obtain an appropriate lock, because this will be the first use of
     111             :      * those relations in the parse/rewrite/plan pipeline.  Child rels should
     112             :      * use the same lockmode as their parent.
     113             :      */
     114        9720 :     oldrelation = table_open(parentOID, NoLock);
     115        9720 :     lockmode = rte->rellockmode;
     116             : 
     117             :     /*
     118             :      * If parent relation is selected FOR UPDATE/SHARE, we need to mark its
     119             :      * PlanRowMark as isParent = true, and generate a new PlanRowMark for each
     120             :      * child.
     121             :      */
     122        9720 :     oldrc = get_plan_rowmark(root->rowMarks, rti);
     123        9720 :     if (oldrc)
     124             :     {
     125         784 :         old_isParent = oldrc->isParent;
     126         784 :         oldrc->isParent = true;
     127             :         /* Save initial value of allMarkTypes before children add to it */
     128         784 :         old_allMarkTypes = oldrc->allMarkTypes;
     129             :     }
     130             : 
     131             :     /* Scan the inheritance set and expand it */
     132        9720 :     if (oldrelation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
     133             :     {
     134             :         /*
     135             :          * Partitioned table, so set up for partitioning.
     136             :          */
     137             :         Assert(rte->relkind == RELKIND_PARTITIONED_TABLE);
     138             : 
     139             :         /*
     140             :          * Recursively expand and lock the partitions.  While at it, also
     141             :          * extract the partition key columns of all the partitioned tables.
     142             :          */
     143        7900 :         expand_partitioned_rtentry(root, rel, rte, rti,
     144             :                                    oldrelation, oldrc, lockmode);
     145             :     }
     146             :     else
     147             :     {
     148             :         /*
     149             :          * Ordinary table, so process traditional-inheritance children.  (Note
     150             :          * that partitioned tables are not allowed to have inheritance
     151             :          * children, so it's not possible for both cases to apply.)
     152             :          */
     153             :         List       *inhOIDs;
     154             :         ListCell   *l;
     155             : 
     156             :         /* Scan for all members of inheritance set, acquire needed locks */
     157        1820 :         inhOIDs = find_all_inheritors(parentOID, lockmode, NULL);
     158             : 
     159             :         /*
     160             :          * We used to special-case the situation where the table no longer has
     161             :          * any children, by clearing rte->inh and exiting.  That no longer
     162             :          * works, because this function doesn't get run until after decisions
     163             :          * have been made that depend on rte->inh.  We have to treat such
     164             :          * situations as normal inheritance.  The table itself should always
     165             :          * have been found, though.
     166             :          */
     167             :         Assert(inhOIDs != NIL);
     168             :         Assert(linitial_oid(inhOIDs) == parentOID);
     169             : 
     170             :         /* Expand simple_rel_array and friends to hold child objects. */
     171        1820 :         expand_planner_arrays(root, list_length(inhOIDs));
     172             : 
     173             :         /*
     174             :          * Expand inheritance children in the order the OIDs were returned by
     175             :          * find_all_inheritors.
     176             :          */
     177        6740 :         foreach(l, inhOIDs)
     178             :         {
     179        4922 :             Oid         childOID = lfirst_oid(l);
     180             :             Relation    newrelation;
     181             :             RangeTblEntry *childrte;
     182             :             Index       childRTindex;
     183             : 
     184             :             /* Open rel if needed; we already have required locks */
     185        4922 :             if (childOID != parentOID)
     186        3102 :                 newrelation = table_open(childOID, NoLock);
     187             :             else
     188        1820 :                 newrelation = oldrelation;
     189             : 
     190             :             /*
     191             :              * It is possible that the parent table has children that are temp
     192             :              * tables of other backends.  We cannot safely access such tables
     193             :              * (because of buffering issues), and the best thing to do seems
     194             :              * to be to silently ignore them.
     195             :              */
     196        4922 :             if (childOID != parentOID && RELATION_IS_OTHER_TEMP(newrelation))
     197             :             {
     198          42 :                 table_close(newrelation, lockmode);
     199          42 :                 continue;
     200             :             }
     201             : 
     202             :             /* Create RTE and AppendRelInfo, plus PlanRowMark if needed. */
     203        4880 :             expand_single_inheritance_child(root, rte, rti, oldrelation,
     204             :                                             oldrc, newrelation,
     205             :                                             &childrte, &childRTindex);
     206             : 
     207             :             /* Create the otherrel RelOptInfo too. */
     208        4878 :             (void) build_simple_rel(root, childRTindex, rel);
     209             : 
     210             :             /* Close child relations, but keep locks */
     211        4878 :             if (childOID != parentOID)
     212        3058 :                 table_close(newrelation, NoLock);
     213             :         }
     214             :     }
     215             : 
     216             :     /*
     217             :      * Some children might require different mark types, which would've been
     218             :      * reported into oldrc.  If so, add relevant entries to the top-level
     219             :      * targetlist and update parent rel's reltarget.  This should match what
     220             :      * preprocess_targetlist() would have added if the mark types had been
     221             :      * requested originally.
     222             :      */
     223        9718 :     if (oldrc)
     224             :     {
     225         784 :         int         new_allMarkTypes = oldrc->allMarkTypes;
     226             :         Var        *var;
     227             :         TargetEntry *tle;
     228             :         char        resname[32];
     229         784 :         List       *newvars = NIL;
     230             : 
     231             :         /* The old PlanRowMark should already have necessitated adding TID */
     232             :         Assert(old_allMarkTypes & ~(1 << ROW_MARK_COPY));
     233             : 
     234             :         /* Add whole-row junk Var if needed, unless we had it already */
     235         784 :         if ((new_allMarkTypes & (1 << ROW_MARK_COPY)) &&
     236          38 :             !(old_allMarkTypes & (1 << ROW_MARK_COPY)))
     237             :         {
     238          38 :             var = makeWholeRowVar(planner_rt_fetch(oldrc->rti, root),
     239             :                                   oldrc->rti,
     240             :                                   0,
     241             :                                   false);
     242          38 :             snprintf(resname, sizeof(resname), "wholerow%u", oldrc->rowmarkId);
     243          38 :             tle = makeTargetEntry((Expr *) var,
     244          38 :                                   list_length(root->processed_tlist) + 1,
     245             :                                   pstrdup(resname),
     246             :                                   true);
     247          38 :             root->processed_tlist = lappend(root->processed_tlist, tle);
     248          38 :             newvars = lappend(newvars, var);
     249             :         }
     250             : 
     251             :         /* Add tableoid junk Var, unless we had it already */
     252         784 :         if (!old_isParent)
     253             :         {
     254         784 :             var = makeVar(oldrc->rti,
     255             :                           TableOidAttributeNumber,
     256             :                           OIDOID,
     257             :                           -1,
     258             :                           InvalidOid,
     259             :                           0);
     260         784 :             snprintf(resname, sizeof(resname), "tableoid%u", oldrc->rowmarkId);
     261         784 :             tle = makeTargetEntry((Expr *) var,
     262         784 :                                   list_length(root->processed_tlist) + 1,
     263             :                                   pstrdup(resname),
     264             :                                   true);
     265         784 :             root->processed_tlist = lappend(root->processed_tlist, tle);
     266         784 :             newvars = lappend(newvars, var);
     267             :         }
     268             : 
     269             :         /*
     270             :          * Add the newly added Vars to parent's reltarget.  We needn't worry
     271             :          * about the children's reltargets, they'll be made later.
     272             :          */
     273         784 :         add_vars_to_targetlist(root, newvars, bms_make_singleton(0), false);
     274             :     }
     275             : 
     276        9718 :     table_close(oldrelation, NoLock);
     277             : }
     278             : 
     279             : /*
     280             :  * expand_partitioned_rtentry
     281             :  *      Recursively expand an RTE for a partitioned table.
     282             :  */
     283             : static void
     284        9782 : expand_partitioned_rtentry(PlannerInfo *root, RelOptInfo *relinfo,
     285             :                            RangeTblEntry *parentrte,
     286             :                            Index parentRTindex, Relation parentrel,
     287             :                            PlanRowMark *top_parentrc, LOCKMODE lockmode)
     288             : {
     289             :     PartitionDesc partdesc;
     290             :     Bitmapset  *live_parts;
     291             :     int         num_live_parts;
     292             :     int         i;
     293             : 
     294        9782 :     check_stack_depth();
     295             : 
     296             :     Assert(parentrte->inh);
     297             : 
     298        9782 :     partdesc = PartitionDirectoryLookup(root->glob->partition_directory,
     299             :                                         parentrel);
     300             : 
     301             :     /* A partitioned table should always have a partition descriptor. */
     302             :     Assert(partdesc);
     303             : 
     304             :     /*
     305             :      * Note down whether any partition key cols are being updated. Though it's
     306             :      * the root partitioned table's updatedCols we are interested in, we
     307             :      * instead use parentrte to get the updatedCols. This is convenient
     308             :      * because parentrte already has the root partrel's updatedCols translated
     309             :      * to match the attribute ordering of parentrel.
     310             :      */
     311        9782 :     if (!root->partColsUpdated)
     312        9582 :         root->partColsUpdated =
     313        9582 :             has_partition_attrs(parentrel, parentrte->updatedCols, NULL);
     314             : 
     315             :     /*
     316             :      * There shouldn't be any generated columns in the partition key.
     317             :      */
     318             :     Assert(!has_partition_attrs(parentrel, parentrte->extraUpdatedCols, NULL));
     319             : 
     320             :     /* Nothing further to do here if there are no partitions. */
     321        9782 :     if (partdesc->nparts == 0)
     322          16 :         return;
     323             : 
     324             :     /*
     325             :      * Perform partition pruning using restriction clauses assigned to parent
     326             :      * relation.  live_parts will contain PartitionDesc indexes of partitions
     327             :      * that survive pruning.  Below, we will initialize child objects for the
     328             :      * surviving partitions.
     329             :      */
     330        9766 :     live_parts = prune_append_rel_partitions(relinfo);
     331             : 
     332             :     /* Expand simple_rel_array and friends to hold child objects. */
     333        9766 :     num_live_parts = bms_num_members(live_parts);
     334        9766 :     if (num_live_parts > 0)
     335        9618 :         expand_planner_arrays(root, num_live_parts);
     336             : 
     337             :     /*
     338             :      * We also store partition RelOptInfo pointers in the parent relation.
     339             :      * Since we're palloc0'ing, slots corresponding to pruned partitions will
     340             :      * contain NULL.
     341             :      */
     342             :     Assert(relinfo->part_rels == NULL);
     343        9766 :     relinfo->part_rels = (RelOptInfo **)
     344        9766 :         palloc0(relinfo->nparts * sizeof(RelOptInfo *));
     345             : 
     346             :     /*
     347             :      * Create a child RTE for each live partition.  Note that unlike
     348             :      * traditional inheritance, we don't need a child RTE for the partitioned
     349             :      * table itself, because it's not going to be scanned.
     350             :      */
     351        9766 :     i = -1;
     352       28502 :     while ((i = bms_next_member(live_parts, i)) >= 0)
     353             :     {
     354       18736 :         Oid         childOID = partdesc->oids[i];
     355             :         Relation    childrel;
     356             :         RangeTblEntry *childrte;
     357             :         Index       childRTindex;
     358             :         RelOptInfo *childrelinfo;
     359             : 
     360             :         /* Open rel, acquiring required locks */
     361       18736 :         childrel = table_open(childOID, lockmode);
     362             : 
     363             :         /*
     364             :          * Temporary partitions belonging to other sessions should have been
     365             :          * disallowed at definition, but for paranoia's sake, let's double
     366             :          * check.
     367             :          */
     368       18736 :         if (RELATION_IS_OTHER_TEMP(childrel))
     369           0 :             elog(ERROR, "temporary relation from another session found as partition");
     370             : 
     371             :         /* Create RTE and AppendRelInfo, plus PlanRowMark if needed. */
     372       18736 :         expand_single_inheritance_child(root, parentrte, parentRTindex,
     373             :                                         parentrel, top_parentrc, childrel,
     374             :                                         &childrte, &childRTindex);
     375             : 
     376             :         /* Create the otherrel RelOptInfo too. */
     377       18736 :         childrelinfo = build_simple_rel(root, childRTindex, relinfo);
     378       18736 :         relinfo->part_rels[i] = childrelinfo;
     379       37472 :         relinfo->all_partrels = bms_add_members(relinfo->all_partrels,
     380       18736 :                                                 childrelinfo->relids);
     381             : 
     382             :         /* If this child is itself partitioned, recurse */
     383       18736 :         if (childrel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
     384        1882 :             expand_partitioned_rtentry(root, childrelinfo,
     385             :                                        childrte, childRTindex,
     386             :                                        childrel, top_parentrc, lockmode);
     387             : 
     388             :         /* Close child relation, but keep locks */
     389       18736 :         table_close(childrel, NoLock);
     390             :     }
     391             : }
     392             : 
     393             : /*
     394             :  * expand_single_inheritance_child
     395             :  *      Build a RangeTblEntry and an AppendRelInfo, plus maybe a PlanRowMark.
     396             :  *
     397             :  * We now expand the partition hierarchy level by level, creating a
     398             :  * corresponding hierarchy of AppendRelInfos and RelOptInfos, where each
     399             :  * partitioned descendant acts as a parent of its immediate partitions.
     400             :  * (This is a difference from what older versions of PostgreSQL did and what
     401             :  * is still done in the case of table inheritance for unpartitioned tables,
     402             :  * where the hierarchy is flattened during RTE expansion.)
     403             :  *
     404             :  * PlanRowMarks still carry the top-parent's RTI, and the top-parent's
     405             :  * allMarkTypes field still accumulates values from all descendents.
     406             :  *
     407             :  * "parentrte" and "parentRTindex" are immediate parent's RTE and
     408             :  * RTI. "top_parentrc" is top parent's PlanRowMark.
     409             :  *
     410             :  * The child RangeTblEntry and its RTI are returned in "childrte_p" and
     411             :  * "childRTindex_p" resp.
     412             :  */
     413             : static void
     414       23616 : expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte,
     415             :                                 Index parentRTindex, Relation parentrel,
     416             :                                 PlanRowMark *top_parentrc, Relation childrel,
     417             :                                 RangeTblEntry **childrte_p,
     418             :                                 Index *childRTindex_p)
     419             : {
     420       23616 :     Query      *parse = root->parse;
     421       23616 :     Oid         parentOID = RelationGetRelid(parentrel);
     422       23616 :     Oid         childOID = RelationGetRelid(childrel);
     423             :     RangeTblEntry *childrte;
     424             :     Index       childRTindex;
     425             :     AppendRelInfo *appinfo;
     426             :     TupleDesc   child_tupdesc;
     427             :     List       *parent_colnames;
     428             :     List       *child_colnames;
     429             : 
     430             :     /*
     431             :      * Build an RTE for the child, and attach to query's rangetable list. We
     432             :      * copy most scalar fields of the parent's RTE, but replace relation OID,
     433             :      * relkind, and inh for the child.  Also, set requiredPerms to zero since
     434             :      * all required permissions checks are done on the original RTE. Likewise,
     435             :      * set the child's securityQuals to empty, because we only want to apply
     436             :      * the parent's RLS conditions regardless of what RLS properties
     437             :      * individual children may have.  (This is an intentional choice to make
     438             :      * inherited RLS work like regular permissions checks.) The parent
     439             :      * securityQuals will be propagated to children along with other base
     440             :      * restriction clauses, so we don't need to do it here.  Other
     441             :      * infrastructure of the parent RTE has to be translated to match the
     442             :      * child table's column ordering, which we do below, so a "flat" copy is
     443             :      * sufficient to start with.
     444             :      */
     445       23616 :     childrte = makeNode(RangeTblEntry);
     446       23616 :     memcpy(childrte, parentrte, sizeof(RangeTblEntry));
     447             :     Assert(parentrte->rtekind == RTE_RELATION); /* else this is dubious */
     448       23616 :     childrte->relid = childOID;
     449       23616 :     childrte->relkind = childrel->rd_rel->relkind;
     450             :     /* A partitioned child will need to be expanded further. */
     451       23616 :     if (childrte->relkind == RELKIND_PARTITIONED_TABLE)
     452             :     {
     453             :         Assert(childOID != parentOID);
     454        1882 :         childrte->inh = true;
     455             :     }
     456             :     else
     457       21734 :         childrte->inh = false;
     458       23616 :     childrte->requiredPerms = 0;
     459       23616 :     childrte->securityQuals = NIL;
     460             : 
     461             :     /* Link not-yet-fully-filled child RTE into data structures */
     462       23616 :     parse->rtable = lappend(parse->rtable, childrte);
     463       23616 :     childRTindex = list_length(parse->rtable);
     464       23616 :     *childrte_p = childrte;
     465       23616 :     *childRTindex_p = childRTindex;
     466             : 
     467             :     /*
     468             :      * Build an AppendRelInfo struct for each parent/child pair.
     469             :      */
     470       23616 :     appinfo = make_append_rel_info(parentrel, childrel,
     471             :                                    parentRTindex, childRTindex);
     472       23614 :     root->append_rel_list = lappend(root->append_rel_list, appinfo);
     473             : 
     474             :     /* tablesample is probably null, but copy it */
     475       23614 :     childrte->tablesample = copyObject(parentrte->tablesample);
     476             : 
     477             :     /*
     478             :      * Construct an alias clause for the child, which we can also use as eref.
     479             :      * This is important so that EXPLAIN will print the right column aliases
     480             :      * for child-table columns.  (Since ruleutils.c doesn't have any easy way
     481             :      * to reassociate parent and child columns, we must get the child column
     482             :      * aliases right to start with.  Note that setting childrte->alias forces
     483             :      * ruleutils.c to use these column names, which it otherwise would not.)
     484             :      */
     485       23614 :     child_tupdesc = RelationGetDescr(childrel);
     486       23614 :     parent_colnames = parentrte->eref->colnames;
     487       23614 :     child_colnames = NIL;
     488       91742 :     for (int cattno = 0; cattno < child_tupdesc->natts; cattno++)
     489             :     {
     490       68128 :         Form_pg_attribute att = TupleDescAttr(child_tupdesc, cattno);
     491             :         const char *attname;
     492             : 
     493       68128 :         if (att->attisdropped)
     494             :         {
     495             :             /* Always insert an empty string for a dropped column */
     496        1374 :             attname = "";
     497             :         }
     498      130848 :         else if (appinfo->parent_colnos[cattno] > 0 &&
     499       64094 :                  appinfo->parent_colnos[cattno] <= list_length(parent_colnames))
     500             :         {
     501             :             /* Duplicate the query-assigned name for the parent column */
     502       64094 :             attname = strVal(list_nth(parent_colnames,
     503             :                                       appinfo->parent_colnos[cattno] - 1));
     504             :         }
     505             :         else
     506             :         {
     507             :             /* New column, just use its real name */
     508        2660 :             attname = NameStr(att->attname);
     509             :         }
     510       68128 :         child_colnames = lappend(child_colnames, makeString(pstrdup(attname)));
     511             :     }
     512             : 
     513             :     /*
     514             :      * We just duplicate the parent's table alias name for each child.  If the
     515             :      * plan gets printed, ruleutils.c has to sort out unique table aliases to
     516             :      * use, which it can handle.
     517             :      */
     518       23614 :     childrte->alias = childrte->eref = makeAlias(parentrte->eref->aliasname,
     519             :                                                  child_colnames);
     520             : 
     521             :     /*
     522             :      * Translate the column permissions bitmaps to the child's attnums (we
     523             :      * have to build the translated_vars list before we can do this).  But if
     524             :      * this is the parent table, we can just duplicate the parent's bitmaps.
     525             :      *
     526             :      * Note: we need to do this even though the executor won't run any
     527             :      * permissions checks on the child RTE.  The insertedCols/updatedCols
     528             :      * bitmaps may be examined for trigger-firing purposes.
     529             :      */
     530       23614 :     if (childOID != parentOID)
     531             :     {
     532       21794 :         childrte->selectedCols = translate_col_privs(parentrte->selectedCols,
     533             :                                                      appinfo->translated_vars);
     534       21794 :         childrte->insertedCols = translate_col_privs(parentrte->insertedCols,
     535             :                                                      appinfo->translated_vars);
     536       21794 :         childrte->updatedCols = translate_col_privs(parentrte->updatedCols,
     537             :                                                     appinfo->translated_vars);
     538       21794 :         childrte->extraUpdatedCols = translate_col_privs(parentrte->extraUpdatedCols,
     539             :                                                          appinfo->translated_vars);
     540             :     }
     541             :     else
     542             :     {
     543        1820 :         childrte->selectedCols = bms_copy(parentrte->selectedCols);
     544        1820 :         childrte->insertedCols = bms_copy(parentrte->insertedCols);
     545        1820 :         childrte->updatedCols = bms_copy(parentrte->updatedCols);
     546        1820 :         childrte->extraUpdatedCols = bms_copy(parentrte->extraUpdatedCols);
     547             :     }
     548             : 
     549             :     /*
     550             :      * Store the RTE and appinfo in the respective PlannerInfo arrays, which
     551             :      * the caller must already have allocated space for.
     552             :      */
     553             :     Assert(childRTindex < root->simple_rel_array_size);
     554             :     Assert(root->simple_rte_array[childRTindex] == NULL);
     555       23614 :     root->simple_rte_array[childRTindex] = childrte;
     556             :     Assert(root->append_rel_array[childRTindex] == NULL);
     557       23614 :     root->append_rel_array[childRTindex] = appinfo;
     558             : 
     559             :     /*
     560             :      * Build a PlanRowMark if parent is marked FOR UPDATE/SHARE.
     561             :      */
     562       23614 :     if (top_parentrc)
     563             :     {
     564        1242 :         PlanRowMark *childrc = makeNode(PlanRowMark);
     565             : 
     566        1242 :         childrc->rti = childRTindex;
     567        1242 :         childrc->prti = top_parentrc->rti;
     568        1242 :         childrc->rowmarkId = top_parentrc->rowmarkId;
     569             :         /* Reselect rowmark type, because relkind might not match parent */
     570        1242 :         childrc->markType = select_rowmark_type(childrte,
     571             :                                                 top_parentrc->strength);
     572        1242 :         childrc->allMarkTypes = (1 << childrc->markType);
     573        1242 :         childrc->strength = top_parentrc->strength;
     574        1242 :         childrc->waitPolicy = top_parentrc->waitPolicy;
     575             : 
     576             :         /*
     577             :          * We mark RowMarks for partitioned child tables as parent RowMarks so
     578             :          * that the executor ignores them (except their existence means that
     579             :          * the child tables will be locked using the appropriate mode).
     580             :          */
     581        1242 :         childrc->isParent = (childrte->relkind == RELKIND_PARTITIONED_TABLE);
     582             : 
     583             :         /* Include child's rowmark type in top parent's allMarkTypes */
     584        1242 :         top_parentrc->allMarkTypes |= childrc->allMarkTypes;
     585             : 
     586        1242 :         root->rowMarks = lappend(root->rowMarks, childrc);
     587             :     }
     588       23614 : }
     589             : 
     590             : /*
     591             :  * translate_col_privs
     592             :  *    Translate a bitmapset representing per-column privileges from the
     593             :  *    parent rel's attribute numbering to the child's.
     594             :  *
     595             :  * The only surprise here is that we don't translate a parent whole-row
     596             :  * reference into a child whole-row reference.  That would mean requiring
     597             :  * permissions on all child columns, which is overly strict, since the
     598             :  * query is really only going to reference the inherited columns.  Instead
     599             :  * we set the per-column bits for all inherited columns.
     600             :  */
     601             : static Bitmapset *
     602       87176 : translate_col_privs(const Bitmapset *parent_privs,
     603             :                     List *translated_vars)
     604             : {
     605       87176 :     Bitmapset  *child_privs = NULL;
     606             :     bool        whole_row;
     607             :     int         attno;
     608             :     ListCell   *lc;
     609             : 
     610             :     /* System attributes have the same numbers in all tables */
     611      610232 :     for (attno = FirstLowInvalidHeapAttributeNumber + 1; attno < 0; attno++)
     612             :     {
     613      523056 :         if (bms_is_member(attno - FirstLowInvalidHeapAttributeNumber,
     614             :                           parent_privs))
     615        1720 :             child_privs = bms_add_member(child_privs,
     616             :                                          attno - FirstLowInvalidHeapAttributeNumber);
     617             :     }
     618             : 
     619             :     /* Check if parent has whole-row reference */
     620       87176 :     whole_row = bms_is_member(InvalidAttrNumber - FirstLowInvalidHeapAttributeNumber,
     621             :                               parent_privs);
     622             : 
     623             :     /* And now translate the regular user attributes, using the vars list */
     624       87176 :     attno = InvalidAttrNumber;
     625      334744 :     foreach(lc, translated_vars)
     626             :     {
     627      247568 :         Var        *var = lfirst_node(Var, lc);
     628             : 
     629      247568 :         attno++;
     630      247568 :         if (var == NULL)        /* ignore dropped columns */
     631        7784 :             continue;
     632      478548 :         if (whole_row ||
     633      238764 :             bms_is_member(attno - FirstLowInvalidHeapAttributeNumber,
     634             :                           parent_privs))
     635       47780 :             child_privs = bms_add_member(child_privs,
     636       47780 :                                          var->varattno - FirstLowInvalidHeapAttributeNumber);
     637             :     }
     638             : 
     639       87176 :     return child_privs;
     640             : }
     641             : 
     642             : /*
     643             :  * expand_appendrel_subquery
     644             :  *      Add "other rel" RelOptInfos for the children of an appendrel baserel
     645             :  *
     646             :  * "rel" is a subquery relation that has the rte->inh flag set, meaning it
     647             :  * is a UNION ALL subquery that's been flattened into an appendrel, with
     648             :  * child subqueries listed in root->append_rel_list.  We need to build
     649             :  * a RelOptInfo for each child relation so that we can plan scans on them.
     650             :  */
     651             : static void
     652        2200 : expand_appendrel_subquery(PlannerInfo *root, RelOptInfo *rel,
     653             :                           RangeTblEntry *rte, Index rti)
     654             : {
     655             :     ListCell   *l;
     656             : 
     657        7860 :     foreach(l, root->append_rel_list)
     658             :     {
     659        5660 :         AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(l);
     660        5660 :         Index       childRTindex = appinfo->child_relid;
     661             :         RangeTblEntry *childrte;
     662             :         RelOptInfo *childrel;
     663             : 
     664             :         /* append_rel_list contains all append rels; ignore others */
     665        5660 :         if (appinfo->parent_relid != rti)
     666        1020 :             continue;
     667             : 
     668             :         /* find the child RTE, which should already exist */
     669             :         Assert(childRTindex < root->simple_rel_array_size);
     670        4640 :         childrte = root->simple_rte_array[childRTindex];
     671             :         Assert(childrte != NULL);
     672             : 
     673             :         /* Build the child RelOptInfo. */
     674        4640 :         childrel = build_simple_rel(root, childRTindex, rel);
     675             : 
     676             :         /* Child may itself be an inherited rel, either table or subquery. */
     677        4640 :         if (childrte->inh)
     678         256 :             expand_inherited_rtentry(root, childrel, childrte, childRTindex);
     679             :     }
     680        2200 : }
     681             : 
     682             : 
     683             : /*
     684             :  * apply_child_basequals
     685             :  *      Populate childrel's base restriction quals from parent rel's quals,
     686             :  *      translating them using appinfo.
     687             :  *
     688             :  * If any of the resulting clauses evaluate to constant false or NULL, we
     689             :  * return false and don't apply any quals.  Caller should mark the relation as
     690             :  * a dummy rel in this case, since it doesn't need to be scanned.
     691             :  */
     692             : bool
     693       28254 : apply_child_basequals(PlannerInfo *root, RelOptInfo *parentrel,
     694             :                       RelOptInfo *childrel, RangeTblEntry *childRTE,
     695             :                       AppendRelInfo *appinfo)
     696             : {
     697             :     List       *childquals;
     698             :     Index       cq_min_security;
     699             :     ListCell   *lc;
     700             : 
     701             :     /*
     702             :      * The child rel's targetlist might contain non-Var expressions, which
     703             :      * means that substitution into the quals could produce opportunities for
     704             :      * const-simplification, and perhaps even pseudoconstant quals. Therefore,
     705             :      * transform each RestrictInfo separately to see if it reduces to a
     706             :      * constant or pseudoconstant.  (We must process them separately to keep
     707             :      * track of the security level of each qual.)
     708             :      */
     709       28254 :     childquals = NIL;
     710       28254 :     cq_min_security = UINT_MAX;
     711       45552 :     foreach(lc, parentrel->baserestrictinfo)
     712             :     {
     713       17350 :         RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
     714             :         Node       *childqual;
     715             :         ListCell   *lc2;
     716             : 
     717             :         Assert(IsA(rinfo, RestrictInfo));
     718       17350 :         childqual = adjust_appendrel_attrs(root,
     719       17350 :                                            (Node *) rinfo->clause,
     720             :                                            1, &appinfo);
     721       17350 :         childqual = eval_const_expressions(root, childqual);
     722             :         /* check for flat-out constant */
     723       17350 :         if (childqual && IsA(childqual, Const))
     724             :         {
     725          96 :             if (((Const *) childqual)->constisnull ||
     726          96 :                 !DatumGetBool(((Const *) childqual)->constvalue))
     727             :             {
     728             :                 /* Restriction reduces to constant FALSE or NULL */
     729          52 :                 return false;
     730             :             }
     731             :             /* Restriction reduces to constant TRUE, so drop it */
     732          44 :             continue;
     733             :         }
     734             :         /* might have gotten an AND clause, if so flatten it */
     735       34516 :         foreach(lc2, make_ands_implicit((Expr *) childqual))
     736             :         {
     737       17262 :             Node       *onecq = (Node *) lfirst(lc2);
     738             :             bool        pseudoconstant;
     739             : 
     740             :             /* check for pseudoconstant (no Vars or volatile functions) */
     741       17262 :             pseudoconstant =
     742       17286 :                 !contain_vars_of_level(onecq, 0) &&
     743          24 :                 !contain_volatile_functions(onecq);
     744       17262 :             if (pseudoconstant)
     745             :             {
     746             :                 /* tell createplan.c to check for gating quals */
     747          24 :                 root->hasPseudoConstantQuals = true;
     748             :             }
     749             :             /* reconstitute RestrictInfo with appropriate properties */
     750       17262 :             childquals = lappend(childquals,
     751       51786 :                                  make_restrictinfo((Expr *) onecq,
     752       17262 :                                                    rinfo->is_pushed_down,
     753       17262 :                                                    rinfo->outerjoin_delayed,
     754             :                                                    pseudoconstant,
     755             :                                                    rinfo->security_level,
     756             :                                                    NULL, NULL, NULL));
     757             :             /* track minimum security level among child quals */
     758       17262 :             cq_min_security = Min(cq_min_security, rinfo->security_level);
     759             :         }
     760             :     }
     761             : 
     762             :     /*
     763             :      * In addition to the quals inherited from the parent, we might have
     764             :      * securityQuals associated with this particular child node.  (Currently
     765             :      * this can only happen in appendrels originating from UNION ALL;
     766             :      * inheritance child tables don't have their own securityQuals, see
     767             :      * expand_single_inheritance_child().)  Pull any such securityQuals up
     768             :      * into the baserestrictinfo for the child.  This is similar to
     769             :      * process_security_barrier_quals() for the parent rel, except that we
     770             :      * can't make any general deductions from such quals, since they don't
     771             :      * hold for the whole appendrel.
     772             :      */
     773       28202 :     if (childRTE->securityQuals)
     774             :     {
     775           8 :         Index       security_level = 0;
     776             : 
     777          16 :         foreach(lc, childRTE->securityQuals)
     778             :         {
     779           8 :             List       *qualset = (List *) lfirst(lc);
     780             :             ListCell   *lc2;
     781             : 
     782          16 :             foreach(lc2, qualset)
     783             :             {
     784           8 :                 Expr       *qual = (Expr *) lfirst(lc2);
     785             : 
     786             :                 /* not likely that we'd see constants here, so no check */
     787           8 :                 childquals = lappend(childquals,
     788           8 :                                      make_restrictinfo(qual,
     789             :                                                        true, false, false,
     790             :                                                        security_level,
     791             :                                                        NULL, NULL, NULL));
     792           8 :                 cq_min_security = Min(cq_min_security, security_level);
     793             :             }
     794           8 :             security_level++;
     795             :         }
     796             :         Assert(security_level <= root->qual_security_level);
     797             :     }
     798             : 
     799             :     /*
     800             :      * OK, we've got all the baserestrictinfo quals for this child.
     801             :      */
     802       28202 :     childrel->baserestrictinfo = childquals;
     803       28202 :     childrel->baserestrict_min_security = cq_min_security;
     804             : 
     805       28202 :     return true;
     806             : }

Generated by: LCOV version 1.13