inherit.c File Reference

#include "postgres.h"
#include "access/sysattr.h"
#include "access/table.h"
#include "catalog/partition.h"
#include "catalog/pg_inherits.h"
#include "catalog/pg_type.h"
#include "miscadmin.h"
#include "nodes/makefuncs.h"
#include "optimizer/appendinfo.h"
#include "optimizer/inherit.h"
#include "optimizer/optimizer.h"
#include "optimizer/pathnode.h"
#include "optimizer/plancat.h"
#include "optimizer/planmain.h"
#include "optimizer/planner.h"
#include "optimizer/prep.h"
#include "optimizer/restrictinfo.h"
#include "parser/parsetree.h"
#include "parser/parse_relation.h"
#include "partitioning/partdesc.h"
#include "partitioning/partprune.h"
#include "utils/rel.h"

Include dependency graph for inherit.c:

Go to the source code of this file.

Functions
static void	expand_partitioned_rtentry (PlannerInfo *root, RelOptInfo *relinfo, RangeTblEntry *parentrte, Index parentRTindex, Relation parentrel, Bitmapset *parent_updatedCols, PlanRowMark *top_parentrc, LOCKMODE lockmode)
static void	expand_single_inheritance_child (PlannerInfo *root, RangeTblEntry *parentrte, Index parentRTindex, Relation parentrel, PlanRowMark *top_parentrc, Relation childrel, RangeTblEntry **childrte_p, Index *childRTindex_p)
static Bitmapset *	translate_col_privs (const Bitmapset *parent_privs, List *translated_vars)
static Bitmapset *	translate_col_privs_multilevel (PlannerInfo *root, RelOptInfo *rel, RelOptInfo *parent_rel, Bitmapset *parent_cols)
static void	expand_appendrel_subquery (PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte, Index rti)
void	expand_inherited_rtentry (PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte, Index rti)
Bitmapset *	get_rel_all_updated_cols (PlannerInfo *root, RelOptInfo *rel)
bool	apply_child_basequals (PlannerInfo *root, RelOptInfo *parentrel, RelOptInfo *childrel, RangeTblEntry *childRTE, AppendRelInfo *appinfo)

Function Documentation

apply_child_basequals()

bool apply_child_basequals	(	PlannerInfo *	root,
		RelOptInfo *	parentrel,
		RelOptInfo *	childrel,
		RangeTblEntry *	childRTE,
		AppendRelInfo *	appinfo
	)

Definition at line 843 of file inherit.c.

{
    List       *childquals;
    Index       cq_min_security;
    ListCell   *lc;
 
    /*
     * The child rel's targetlist might contain non-Var expressions, which
     * means that substitution into the quals could produce opportunities for
     * const-simplification, and perhaps even pseudoconstant quals. Therefore,
     * transform each RestrictInfo separately to see if it reduces to a
     * constant or pseudoconstant.  (We must process them separately to keep
     * track of the security level of each qual.)
     */
    childquals = NIL;
    cq_min_security = UINT_MAX;
    foreach(lc, parentrel->baserestrictinfo)
    {
        RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
        Node       *childqual;
        ListCell   *lc2;
 
        Assert(IsA(rinfo, RestrictInfo));
        childqual = adjust_appendrel_attrs(root,
                                           (Node *) rinfo->clause,
                                           1, &appinfo);
        childqual = eval_const_expressions(root, childqual);
        /* check for flat-out constant */
        if (childqual && IsA(childqual, Const))
        {
            if (((Const *) childqual)->constisnull ||
                !DatumGetBool(((Const *) childqual)->constvalue))
            {
                /* Restriction reduces to constant FALSE or NULL */
                return false;
            }
            /* Restriction reduces to constant TRUE, so drop it */
            continue;
        }
        /* might have gotten an AND clause, if so flatten it */
        foreach(lc2, make_ands_implicit((Expr *) childqual))
        {
            Node       *onecq = (Node *) lfirst(lc2);
            bool        pseudoconstant;
            RestrictInfo *childrinfo;
 
            /* check for pseudoconstant (no Vars or volatile functions) */
            pseudoconstant =
                !contain_vars_of_level(onecq, 0) &&
                !contain_volatile_functions(onecq);
            if (pseudoconstant)
            {
                /* tell createplan.c to check for gating quals */
                root->hasPseudoConstantQuals = true;
            }
            /* reconstitute RestrictInfo with appropriate properties */
            childrinfo = make_restrictinfo(root,
                                           (Expr *) onecq,
                                           rinfo->is_pushed_down,
                                           rinfo->has_clone,
                                           rinfo->is_clone,
                                           pseudoconstant,
                                           rinfo->security_level,
                                           NULL, NULL, NULL);
 
            /* Restriction is proven always false */
            if (restriction_is_always_false(root, childrinfo))
                return false;
            /* Restriction is proven always true, so drop it */
            if (restriction_is_always_true(root, childrinfo))
                continue;
 
            childquals = lappend(childquals, childrinfo);
            /* track minimum security level among child quals */
            cq_min_security = Min(cq_min_security, rinfo->security_level);
        }
    }
 
    /*
     * In addition to the quals inherited from the parent, we might have
     * securityQuals associated with this particular child node.  (Currently
     * this can only happen in appendrels originating from UNION ALL;
     * inheritance child tables don't have their own securityQuals, see
     * expand_single_inheritance_child().)  Pull any such securityQuals up
     * into the baserestrictinfo for the child.  This is similar to
     * process_security_barrier_quals() for the parent rel, except that we
     * can't make any general deductions from such quals, since they don't
     * hold for the whole appendrel.
     */
    if (childRTE->securityQuals)
    {
        Index       security_level = 0;
 
        foreach(lc, childRTE->securityQuals)
        {
            List       *qualset = (List *) lfirst(lc);
            ListCell   *lc2;
 
            foreach(lc2, qualset)
            {
                Expr       *qual = (Expr *) lfirst(lc2);
 
                /* not likely that we'd see constants here, so no check */
                childquals = lappend(childquals,
                                     make_restrictinfo(root, qual,
                                                       true,
                                                       false, false,
                                                       false,
                                                       security_level,
                                                       NULL, NULL, NULL));
                cq_min_security = Min(cq_min_security, security_level);
            }
            security_level++;
        }
        Assert(security_level <= root->qual_security_level);
    }
 
    /*
     * OK, we've got all the baserestrictinfo quals for this child.
     */
    childrel->baserestrictinfo = childquals;
    childrel->baserestrict_min_security = cq_min_security;
 
    return true;
}

References adjust_appendrel_attrs(), Assert(), RelOptInfo::baserestrict_min_security, RelOptInfo::baserestrictinfo, RestrictInfo::clause, contain_vars_of_level(), contain_volatile_functions(), DatumGetBool(), eval_const_expressions(), RestrictInfo::has_clone, RestrictInfo::is_clone, RestrictInfo::is_pushed_down, IsA, lappend(), lfirst, make_ands_implicit(), make_restrictinfo(), Min, NIL, restriction_is_always_false(), restriction_is_always_true(), root, and RestrictInfo::security_level.

Referenced by build_simple_rel().

expand_appendrel_subquery()

static void expand_appendrel_subquery ( PlannerInfo *  root, RelOptInfo *  rel, RangeTblEntry *  rte, Index  rti  )

static

Definition at line 800 of file inherit.c.

{
    ListCell   *l;
 
    foreach(l, root->append_rel_list)
    {
        AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(l);
        Index       childRTindex = appinfo->child_relid;
        RangeTblEntry *childrte;
        RelOptInfo *childrel;
 
        /* append_rel_list contains all append rels; ignore others */
        if (appinfo->parent_relid != rti)
            continue;
 
        /* find the child RTE, which should already exist */
        Assert(childRTindex < root->simple_rel_array_size);
        childrte = root->simple_rte_array[childRTindex];
        Assert(childrte != NULL);
 
        /* Build the child RelOptInfo. */
        childrel = build_simple_rel(root, childRTindex, rel);
 
        /* Child may itself be an inherited rel, either table or subquery. */
        if (childrte->inh)
            expand_inherited_rtentry(root, childrel, childrte, childRTindex);
    }
}

References Assert(), build_simple_rel(), AppendRelInfo::child_relid, expand_inherited_rtentry(), RangeTblEntry::inh, lfirst, AppendRelInfo::parent_relid, and root.

Referenced by expand_inherited_rtentry().

expand_inherited_rtentry()

void expand_inherited_rtentry	(	PlannerInfo *	root,
		RelOptInfo *	rel,
		RangeTblEntry *	rte,
		Index	rti
	)

Definition at line 86 of file inherit.c.

{
    Oid         parentOID;
    Relation    oldrelation;
    LOCKMODE    lockmode;
    PlanRowMark *oldrc;
    bool        old_isParent = false;
    int         old_allMarkTypes = 0;
 
    Assert(rte->inh);           /* else caller error */
 
    if (rte->rtekind == RTE_SUBQUERY)
    {
        expand_appendrel_subquery(root, rel, rte, rti);
        return;
    }
 
    Assert(rte->rtekind == RTE_RELATION);
 
    parentOID = rte->relid;
 
    /*
     * We used to check has_subclass() here, but there's no longer any need
     * to, because subquery_planner already did.
     */
 
    /*
     * The rewriter should already have obtained an appropriate lock on each
     * relation named in the query, so we can open the parent relation without
     * locking it.  However, for each child relation we add to the query, we
     * must obtain an appropriate lock, because this will be the first use of
     * those relations in the parse/rewrite/plan pipeline.  Child rels should
     * use the same lockmode as their parent.
     */
    oldrelation = table_open(parentOID, NoLock);
    lockmode = rte->rellockmode;
 
    /*
     * If parent relation is selected FOR UPDATE/SHARE, we need to mark its
     * PlanRowMark as isParent = true, and generate a new PlanRowMark for each
     * child.
     */
    oldrc = get_plan_rowmark(root->rowMarks, rti);
    if (oldrc)
    {
        old_isParent = oldrc->isParent;
        oldrc->isParent = true;
        /* Save initial value of allMarkTypes before children add to it */
        old_allMarkTypes = oldrc->allMarkTypes;
    }
 
    /* Scan the inheritance set and expand it */
    if (oldrelation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
    {
        RTEPermissionInfo *perminfo;
 
        perminfo = getRTEPermissionInfo(root->parse->rteperminfos, rte);
 
        /*
         * Partitioned table, so set up for partitioning.
         */
        Assert(rte->relkind == RELKIND_PARTITIONED_TABLE);
 
        /*
         * Recursively expand and lock the partitions.  While at it, also
         * extract the partition key columns of all the partitioned tables.
         */
        expand_partitioned_rtentry(root, rel, rte, rti,
                                   oldrelation,
                                   perminfo->updatedCols,
                                   oldrc, lockmode);
    }
    else
    {
        /*
         * Ordinary table, so process traditional-inheritance children.  (Note
         * that partitioned tables are not allowed to have inheritance
         * children, so it's not possible for both cases to apply.)
         */
        List       *inhOIDs;
        ListCell   *l;
 
        /* Scan for all members of inheritance set, acquire needed locks */
        inhOIDs = find_all_inheritors(parentOID, lockmode, NULL);
 
        /*
         * We used to special-case the situation where the table no longer has
         * any children, by clearing rte->inh and exiting.  That no longer
         * works, because this function doesn't get run until after decisions
         * have been made that depend on rte->inh.  We have to treat such
         * situations as normal inheritance.  The table itself should always
         * have been found, though.
         */
        Assert(inhOIDs != NIL);
        Assert(linitial_oid(inhOIDs) == parentOID);
 
        /* Expand simple_rel_array and friends to hold child objects. */
        expand_planner_arrays(root, list_length(inhOIDs));
 
        /*
         * Expand inheritance children in the order the OIDs were returned by
         * find_all_inheritors.
         */
        foreach(l, inhOIDs)
        {
            Oid         childOID = lfirst_oid(l);
            Relation    newrelation;
            RangeTblEntry *childrte;
            Index       childRTindex;
 
            /* Open rel if needed; we already have required locks */
            if (childOID != parentOID)
                newrelation = table_open(childOID, NoLock);
            else
                newrelation = oldrelation;
 
            /*
             * It is possible that the parent table has children that are temp
             * tables of other backends.  We cannot safely access such tables
             * (because of buffering issues), and the best thing to do seems
             * to be to silently ignore them.
             */
            if (childOID != parentOID && RELATION_IS_OTHER_TEMP(newrelation))
            {
                table_close(newrelation, lockmode);
                continue;
            }
 
            /* Create RTE and AppendRelInfo, plus PlanRowMark if needed. */
            expand_single_inheritance_child(root, rte, rti, oldrelation,
                                            oldrc, newrelation,
                                            &childrte, &childRTindex);
 
            /* Create the otherrel RelOptInfo too. */
            (void) build_simple_rel(root, childRTindex, rel);
 
            /* Close child relations, but keep locks */
            if (childOID != parentOID)
                table_close(newrelation, NoLock);
        }
    }
 
    /*
     * Some children might require different mark types, which would've been
     * reported into oldrc.  If so, add relevant entries to the top-level
     * targetlist and update parent rel's reltarget.  This should match what
     * preprocess_targetlist() would have added if the mark types had been
     * requested originally.
     *
     * (Someday it might be useful to fold these resjunk columns into the
     * row-identity-column management used for UPDATE/DELETE.  Today is not
     * that day, however.)
     */
    if (oldrc)
    {
        int         new_allMarkTypes = oldrc->allMarkTypes;
        Var        *var;
        TargetEntry *tle;
        char        resname[32];
        List       *newvars = NIL;
 
        /* Add TID junk Var if needed, unless we had it already */
        if (new_allMarkTypes & ~(1 << ROW_MARK_COPY) &&
            !(old_allMarkTypes & ~(1 << ROW_MARK_COPY)))
        {
            /* Need to fetch TID */
            var = makeVar(oldrc->rti,
                          SelfItemPointerAttributeNumber,
                          TIDOID,
                          -1,
                          InvalidOid,
                          0);
            snprintf(resname, sizeof(resname), "ctid%u", oldrc->rowmarkId);
            tle = makeTargetEntry((Expr *) var,
                                  list_length(root->processed_tlist) + 1,
                                  pstrdup(resname),
                                  true);
            root->processed_tlist = lappend(root->processed_tlist, tle);
            newvars = lappend(newvars, var);
        }
 
        /* Add whole-row junk Var if needed, unless we had it already */
        if ((new_allMarkTypes & (1 << ROW_MARK_COPY)) &&
            !(old_allMarkTypes & (1 << ROW_MARK_COPY)))
        {
            var = makeWholeRowVar(planner_rt_fetch(oldrc->rti, root),
                                  oldrc->rti,
                                  0,
                                  false);
            snprintf(resname, sizeof(resname), "wholerow%u", oldrc->rowmarkId);
            tle = makeTargetEntry((Expr *) var,
                                  list_length(root->processed_tlist) + 1,
                                  pstrdup(resname),
                                  true);
            root->processed_tlist = lappend(root->processed_tlist, tle);
            newvars = lappend(newvars, var);
        }
 
        /* Add tableoid junk Var, unless we had it already */
        if (!old_isParent)
        {
            var = makeVar(oldrc->rti,
                          TableOidAttributeNumber,
                          OIDOID,
                          -1,
                          InvalidOid,
                          0);
            snprintf(resname, sizeof(resname), "tableoid%u", oldrc->rowmarkId);
            tle = makeTargetEntry((Expr *) var,
                                  list_length(root->processed_tlist) + 1,
                                  pstrdup(resname),
                                  true);
            root->processed_tlist = lappend(root->processed_tlist, tle);
            newvars = lappend(newvars, var);
        }
 
        /*
         * Add the newly added Vars to parent's reltarget.  We needn't worry
         * about the children's reltargets, they'll be made later.
         */
        add_vars_to_targetlist(root, newvars, bms_make_singleton(0));
    }
 
    table_close(oldrelation, NoLock);
}

References add_vars_to_targetlist(), PlanRowMark::allMarkTypes, Assert(), bms_make_singleton(), build_simple_rel(), expand_appendrel_subquery(), expand_partitioned_rtentry(), expand_planner_arrays(), expand_single_inheritance_child(), find_all_inheritors(), get_plan_rowmark(), getRTEPermissionInfo(), RangeTblEntry::inh, InvalidOid, PlanRowMark::isParent, lappend(), lfirst_oid, linitial_oid, list_length(), makeTargetEntry(), makeVar(), makeWholeRowVar(), NIL, NoLock, planner_rt_fetch, pstrdup(), RelationData::rd_rel, RELATION_IS_OTHER_TEMP, root, ROW_MARK_COPY, PlanRowMark::rowmarkId, RTE_RELATION, RTE_SUBQUERY, RangeTblEntry::rtekind, PlanRowMark::rti, SelfItemPointerAttributeNumber, snprintf, table_close(), table_open(), TableOidAttributeNumber, and RTEPermissionInfo::updatedCols.

Referenced by add_other_rels_to_query(), and expand_appendrel_subquery().

expand_partitioned_rtentry()

static void expand_partitioned_rtentry ( PlannerInfo *  root, RelOptInfo *  relinfo, RangeTblEntry *  parentrte, Index  parentRTindex, Relation  parentrel, Bitmapset *  parent_updatedCols, PlanRowMark *  top_parentrc, LOCKMODE  lockmode  )

static

Definition at line 318 of file inherit.c.

{
    PartitionDesc partdesc;
    Bitmapset  *live_parts;
    int         num_live_parts;
    int         i;
 
    check_stack_depth();
 
    Assert(parentrte->inh);
 
    partdesc = PartitionDirectoryLookup(root->glob->partition_directory,
                                        parentrel);
 
    /* A partitioned table should always have a partition descriptor. */
    Assert(partdesc);
 
    /*
     * Note down whether any partition key cols are being updated. Though it's
     * the root partitioned table's updatedCols we are interested in,
     * parent_updatedCols provided by the caller contains the root partrel's
     * updatedCols translated to match the attribute ordering of parentrel.
     */
    if (!root->partColsUpdated)
        root->partColsUpdated =
            has_partition_attrs(parentrel, parent_updatedCols, NULL);
 
    /* Nothing further to do here if there are no partitions. */
    if (partdesc->nparts == 0)
        return;
 
    /*
     * Perform partition pruning using restriction clauses assigned to parent
     * relation.  live_parts will contain PartitionDesc indexes of partitions
     * that survive pruning.  Below, we will initialize child objects for the
     * surviving partitions.
     */
    relinfo->live_parts = live_parts = prune_append_rel_partitions(relinfo);
 
    /* Expand simple_rel_array and friends to hold child objects. */
    num_live_parts = bms_num_members(live_parts);
    if (num_live_parts > 0)
        expand_planner_arrays(root, num_live_parts);
 
    /*
     * We also store partition RelOptInfo pointers in the parent relation.
     * Since we're palloc0'ing, slots corresponding to pruned partitions will
     * contain NULL.
     */
    Assert(relinfo->part_rels == NULL);
    relinfo->part_rels = (RelOptInfo **)
        palloc0(relinfo->nparts * sizeof(RelOptInfo *));
 
    /*
     * Create a child RTE for each live partition.  Note that unlike
     * traditional inheritance, we don't need a child RTE for the partitioned
     * table itself, because it's not going to be scanned.
     */
    i = -1;
    while ((i = bms_next_member(live_parts, i)) >= 0)
    {
        Oid         childOID = partdesc->oids[i];
        Relation    childrel;
        RangeTblEntry *childrte;
        Index       childRTindex;
        RelOptInfo *childrelinfo;
 
        /*
         * Open rel, acquiring required locks.  If a partition was recently
         * detached and subsequently dropped, then opening it will fail.  In
         * this case, behave as though the partition had been pruned.
         */
        childrel = try_table_open(childOID, lockmode);
        if (childrel == NULL)
        {
            relinfo->live_parts = bms_del_member(relinfo->live_parts, i);
            continue;
        }
 
        /*
         * Temporary partitions belonging to other sessions should have been
         * disallowed at definition, but for paranoia's sake, let's double
         * check.
         */
        if (RELATION_IS_OTHER_TEMP(childrel))
            elog(ERROR, "temporary relation from another session found as partition");
 
        /* Create RTE and AppendRelInfo, plus PlanRowMark if needed. */
        expand_single_inheritance_child(root, parentrte, parentRTindex,
                                        parentrel, top_parentrc, childrel,
                                        &childrte, &childRTindex);
 
        /* Create the otherrel RelOptInfo too. */
        childrelinfo = build_simple_rel(root, childRTindex, relinfo);
        relinfo->part_rels[i] = childrelinfo;
        relinfo->all_partrels = bms_add_members(relinfo->all_partrels,
                                                childrelinfo->relids);
 
        /* If this child is itself partitioned, recurse */
        if (childrel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
        {
            AppendRelInfo *appinfo = root->append_rel_array[childRTindex];
            Bitmapset  *child_updatedCols;
 
            child_updatedCols = translate_col_privs(parent_updatedCols,
                                                    appinfo->translated_vars);
 
            expand_partitioned_rtentry(root, childrelinfo,
                                       childrte, childRTindex,
                                       childrel,
                                       child_updatedCols,
                                       top_parentrc, lockmode);
        }
 
        /* Close child relation, but keep locks */
        table_close(childrel, NoLock);
    }
}

References RelOptInfo::all_partrels, Assert(), bms_add_members(), bms_del_member(), bms_next_member(), bms_num_members(), build_simple_rel(), check_stack_depth(), elog, ERROR, expand_partitioned_rtentry(), expand_planner_arrays(), expand_single_inheritance_child(), has_partition_attrs(), i, RangeTblEntry::inh, RelOptInfo::live_parts, NoLock, RelOptInfo::nparts, PartitionDescData::nparts, PartitionDescData::oids, palloc0(), PartitionDirectoryLookup(), prune_append_rel_partitions(), RelationData::rd_rel, RELATION_IS_OTHER_TEMP, RelOptInfo::relids, root, table_close(), translate_col_privs(), AppendRelInfo::translated_vars, and try_table_open().

Referenced by expand_inherited_rtentry(), and expand_partitioned_rtentry().

expand_single_inheritance_child()

static void expand_single_inheritance_child ( PlannerInfo *  root, RangeTblEntry *  parentrte, Index  parentRTindex, Relation  parentrel, PlanRowMark *  top_parentrc, Relation  childrel, RangeTblEntry **  childrte_p, Index *  childRTindex_p  )

static

Definition at line 462 of file inherit.c.

{
    Query      *parse = root->parse;
    Oid         parentOID PG_USED_FOR_ASSERTS_ONLY =
        RelationGetRelid(parentrel);
    Oid         childOID = RelationGetRelid(childrel);
    RangeTblEntry *childrte;
    Index       childRTindex;
    AppendRelInfo *appinfo;
    TupleDesc   child_tupdesc;
    List       *parent_colnames;
    List       *child_colnames;
 
    /*
     * Build an RTE for the child, and attach to query's rangetable list. We
     * copy most scalar fields of the parent's RTE, but replace relation OID,
     * relkind, and inh for the child.  Set the child's securityQuals to
     * empty, because we only want to apply the parent's RLS conditions
     * regardless of what RLS properties individual children may have. (This
     * is an intentional choice to make inherited RLS work like regular
     * permissions checks.) The parent securityQuals will be propagated to
     * children along with other base restriction clauses, so we don't need to
     * do it here.  Other infrastructure of the parent RTE has to be
     * translated to match the child table's column ordering, which we do
     * below, so a "flat" copy is sufficient to start with.
     */
    childrte = makeNode(RangeTblEntry);
    memcpy(childrte, parentrte, sizeof(RangeTblEntry));
    Assert(parentrte->rtekind == RTE_RELATION); /* else this is dubious */
    childrte->relid = childOID;
    childrte->relkind = childrel->rd_rel->relkind;
    /* A partitioned child will need to be expanded further. */
    if (childrte->relkind == RELKIND_PARTITIONED_TABLE)
    {
        Assert(childOID != parentOID);
        childrte->inh = true;
    }
    else
        childrte->inh = false;
    childrte->securityQuals = NIL;
 
    /* No permission checking for child RTEs. */
    childrte->perminfoindex = 0;
 
    /* Link not-yet-fully-filled child RTE into data structures */
    parse->rtable = lappend(parse->rtable, childrte);
    childRTindex = list_length(parse->rtable);
    *childrte_p = childrte;
    *childRTindex_p = childRTindex;
 
    /*
     * Build an AppendRelInfo struct for each parent/child pair.
     */
    appinfo = make_append_rel_info(parentrel, childrel,
                                   parentRTindex, childRTindex);
    root->append_rel_list = lappend(root->append_rel_list, appinfo);
 
    /* tablesample is probably null, but copy it */
    childrte->tablesample = copyObject(parentrte->tablesample);
 
    /*
     * Construct an alias clause for the child, which we can also use as eref.
     * This is important so that EXPLAIN will print the right column aliases
     * for child-table columns.  (Since ruleutils.c doesn't have any easy way
     * to reassociate parent and child columns, we must get the child column
     * aliases right to start with.  Note that setting childrte->alias forces
     * ruleutils.c to use these column names, which it otherwise would not.)
     */
    child_tupdesc = RelationGetDescr(childrel);
    parent_colnames = parentrte->eref->colnames;
    child_colnames = NIL;
    for (int cattno = 0; cattno < child_tupdesc->natts; cattno++)
    {
        Form_pg_attribute att = TupleDescAttr(child_tupdesc, cattno);
        const char *attname;
 
        if (att->attisdropped)
        {
            /* Always insert an empty string for a dropped column */
            attname = "";
        }
        else if (appinfo->parent_colnos[cattno] > 0 &&
                 appinfo->parent_colnos[cattno] <= list_length(parent_colnames))
        {
            /* Duplicate the query-assigned name for the parent column */
            attname = strVal(list_nth(parent_colnames,
                                      appinfo->parent_colnos[cattno] - 1));
        }
        else
        {
            /* New column, just use its real name */
            attname = NameStr(att->attname);
        }
        child_colnames = lappend(child_colnames, makeString(pstrdup(attname)));
    }
 
    /*
     * We just duplicate the parent's table alias name for each child.  If the
     * plan gets printed, ruleutils.c has to sort out unique table aliases to
     * use, which it can handle.
     */
    childrte->alias = childrte->eref = makeAlias(parentrte->eref->aliasname,
                                                 child_colnames);
 
    /*
     * Store the RTE and appinfo in the respective PlannerInfo arrays, which
     * the caller must already have allocated space for.
     */
    Assert(childRTindex < root->simple_rel_array_size);
    Assert(root->simple_rte_array[childRTindex] == NULL);
    root->simple_rte_array[childRTindex] = childrte;
    Assert(root->append_rel_array[childRTindex] == NULL);
    root->append_rel_array[childRTindex] = appinfo;
 
    /*
     * Build a PlanRowMark if parent is marked FOR UPDATE/SHARE.
     */
    if (top_parentrc)
    {
        PlanRowMark *childrc = makeNode(PlanRowMark);
 
        childrc->rti = childRTindex;
        childrc->prti = top_parentrc->rti;
        childrc->rowmarkId = top_parentrc->rowmarkId;
        /* Reselect rowmark type, because relkind might not match parent */
        childrc->markType = select_rowmark_type(childrte,
                                                top_parentrc->strength);
        childrc->allMarkTypes = (1 << childrc->markType);
        childrc->strength = top_parentrc->strength;
        childrc->waitPolicy = top_parentrc->waitPolicy;
 
        /*
         * We mark RowMarks for partitioned child tables as parent RowMarks so
         * that the executor ignores them (except their existence means that
         * the child tables will be locked using the appropriate mode).
         */
        childrc->isParent = (childrte->relkind == RELKIND_PARTITIONED_TABLE);
 
        /* Include child's rowmark type in top parent's allMarkTypes */
        top_parentrc->allMarkTypes |= childrc->allMarkTypes;
 
        root->rowMarks = lappend(root->rowMarks, childrc);
    }
 
    /*
     * If we are creating a child of the query target relation (only possible
     * in UPDATE/DELETE/MERGE), add it to all_result_relids, as well as
     * leaf_result_relids if appropriate, and make sure that we generate
     * required row-identity data.
     */
    if (bms_is_member(parentRTindex, root->all_result_relids))
    {
        /* OK, record the child as a result rel too. */
        root->all_result_relids = bms_add_member(root->all_result_relids,
                                                 childRTindex);
 
        /* Non-leaf partitions don't need any row identity info. */
        if (childrte->relkind != RELKIND_PARTITIONED_TABLE)
        {
            Var        *rrvar;
 
            root->leaf_result_relids = bms_add_member(root->leaf_result_relids,
                                                      childRTindex);
 
            /*
             * If we have any child target relations, assume they all need to
             * generate a junk "tableoid" column.  (If only one child survives
             * pruning, we wouldn't really need this, but it's not worth
             * thrashing about to avoid it.)
             */
            rrvar = makeVar(childRTindex,
                            TableOidAttributeNumber,
                            OIDOID,
                            -1,
                            InvalidOid,
                            0);
            add_row_identity_var(root, rrvar, childRTindex, "tableoid");
 
            /* Register any row-identity columns needed by this child. */
            add_row_identity_columns(root, childRTindex,
                                     childrte, childrel);
        }
    }
}

References add_row_identity_columns(), add_row_identity_var(), PlanRowMark::allMarkTypes, Assert(), attname, bms_add_member(), bms_is_member(), copyObject, RangeTblEntry::inh, InvalidOid, PlanRowMark::isParent, lappend(), list_length(), list_nth(), make_append_rel_info(), makeAlias(), makeNode, makeString(), makeVar(), PlanRowMark::markType, NameStr, TupleDescData::natts, NIL, parse(), PG_USED_FOR_ASSERTS_ONLY, PlanRowMark::prti, pstrdup(), RelationData::rd_rel, RelationGetDescr, RelationGetRelid, root, PlanRowMark::rowmarkId, RTE_RELATION, RangeTblEntry::rtekind, PlanRowMark::rti, select_rowmark_type(), PlanRowMark::strength, strVal, TableOidAttributeNumber, RangeTblEntry::tablesample, TupleDescAttr(), and PlanRowMark::waitPolicy.

Referenced by expand_inherited_rtentry(), and expand_partitioned_rtentry().

get_rel_all_updated_cols()

Bitmapset * get_rel_all_updated_cols	(	PlannerInfo *	root,
		RelOptInfo *	rel
	)

Definition at line 657 of file inherit.c.

{
    Index       relid;
    RangeTblEntry *rte;
    RTEPermissionInfo *perminfo;
    Bitmapset  *updatedCols,
               *extraUpdatedCols;
 
    Assert(root->parse->commandType == CMD_UPDATE);
    Assert(IS_SIMPLE_REL(rel));
 
    /*
     * We obtain updatedCols for the query's result relation.  Then, if
     * necessary, we map it to the column numbers of the relation for which
     * they were requested.
     */
    relid = root->parse->resultRelation;
    rte = planner_rt_fetch(relid, root);
    perminfo = getRTEPermissionInfo(root->parse->rteperminfos, rte);
 
    updatedCols = perminfo->updatedCols;
 
    if (rel->relid != relid)
    {
        RelOptInfo *top_parent_rel = find_base_rel(root, relid);
 
        Assert(IS_OTHER_REL(rel));
 
        updatedCols = translate_col_privs_multilevel(root, rel, top_parent_rel,
                                                     updatedCols);
    }
 
    /*
     * Now we must check to see if there are any generated columns that depend
     * on the updatedCols, and add them to the result.
     */
    extraUpdatedCols = get_dependent_generated_columns(root, rel->relid,
                                                       updatedCols);
 
    return bms_union(updatedCols, extraUpdatedCols);
}

References Assert(), bms_union(), CMD_UPDATE, find_base_rel(), get_dependent_generated_columns(), getRTEPermissionInfo(), IS_OTHER_REL, IS_SIMPLE_REL, planner_rt_fetch, RelOptInfo::relid, root, translate_col_privs_multilevel(), and RTEPermissionInfo::updatedCols.

Referenced by postgresPlanForeignModify().

translate_col_privs()

static Bitmapset * translate_col_privs ( const Bitmapset *  parent_privs, List *  translated_vars  )

static

Definition at line 711 of file inherit.c.

{
    Bitmapset  *child_privs = NULL;
    bool        whole_row;
    int         attno;
    ListCell   *lc;
 
    /* System attributes have the same numbers in all tables */
    for (attno = FirstLowInvalidHeapAttributeNumber + 1; attno < 0; attno++)
    {
        if (bms_is_member(attno - FirstLowInvalidHeapAttributeNumber,
                          parent_privs))
            child_privs = bms_add_member(child_privs,
                                         attno - FirstLowInvalidHeapAttributeNumber);
    }
 
    /* Check if parent has whole-row reference */
    whole_row = bms_is_member(InvalidAttrNumber - FirstLowInvalidHeapAttributeNumber,
                              parent_privs);
 
    /* And now translate the regular user attributes, using the vars list */
    attno = InvalidAttrNumber;
    foreach(lc, translated_vars)
    {
        Var        *var = lfirst_node(Var, lc);
 
        attno++;
        if (var == NULL)        /* ignore dropped columns */
            continue;
        if (whole_row ||
            bms_is_member(attno - FirstLowInvalidHeapAttributeNumber,
                          parent_privs))
            child_privs = bms_add_member(child_privs,
                                         var->varattno - FirstLowInvalidHeapAttributeNumber);
    }
 
    return child_privs;
}

References bms_add_member(), bms_is_member(), FirstLowInvalidHeapAttributeNumber, InvalidAttrNumber, lfirst_node, and Var::varattno.

Referenced by expand_partitioned_rtentry(), and translate_col_privs_multilevel().

translate_col_privs_multilevel()

static Bitmapset * translate_col_privs_multilevel ( PlannerInfo *  root, RelOptInfo *  rel, RelOptInfo *  parent_rel, Bitmapset *  parent_cols  )

static

Definition at line 761 of file inherit.c.

{
    AppendRelInfo *appinfo;
 
    /* Fast path for easy case. */
    if (parent_cols == NULL)
        return NULL;
 
    /* Recurse if immediate parent is not the top parent. */
    if (rel->parent != parent_rel)
    {
        if (rel->parent)
            parent_cols = translate_col_privs_multilevel(root, rel->parent,
                                                         parent_rel,
                                                         parent_cols);
        else
            elog(ERROR, "rel with relid %u is not a child rel", rel->relid);
    }
 
    /* Now translate for this child. */
    Assert(root->append_rel_array != NULL);
    appinfo = root->append_rel_array[rel->relid];
    Assert(appinfo != NULL);
 
    return translate_col_privs(parent_cols, appinfo->translated_vars);
}

References Assert(), elog, ERROR, RelOptInfo::relid, root, translate_col_privs(), translate_col_privs_multilevel(), and AppendRelInfo::translated_vars.

Referenced by get_rel_all_updated_cols(), and translate_col_privs_multilevel().