inherit.h File Reference

#include "nodes/pathnodes.h"

Include dependency graph for inherit.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
void	expand_inherited_rtentry (PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte, Index rti)
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 754 of file inherit.c.

References adjust_appendrel_attrs(), Assert, RelOptInfo::baserestrict_min_security, RelOptInfo::baserestrictinfo, RestrictInfo::clause, contain_vars_of_level(), contain_volatile_functions(), DatumGetBool, eval_const_expressions(), PlannerInfo::hasPseudoConstantQuals, RestrictInfo::is_pushed_down, IsA, lappend(), lfirst, make_ands_implicit(), make_restrictinfo(), Min, NIL, RestrictInfo::outerjoin_delayed, RestrictInfo::security_level, and RangeTblEntry::securityQuals.

Referenced by build_simple_rel().

{
    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;

            /* 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 */
            childquals = lappend(childquals,
                                 make_restrictinfo(root,
                                                   (Expr *) onecq,
                                                   rinfo->is_pushed_down,
                                                   rinfo->outerjoin_delayed,
                                                   pseudoconstant,
                                                   rinfo->security_level,
                                                   NULL, NULL, NULL));
            /* 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,
                                                       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;
}

expand_inherited_rtentry()

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

Definition at line 79 of file inherit.c.

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(), RangeTblEntry::inh, InvalidOid, PlanRowMark::isParent, lappend(), lfirst_oid, linitial_oid, list_length(), makeTargetEntry(), makeVar(), makeWholeRowVar(), NIL, NoLock, planner_rt_fetch, PlannerInfo::processed_tlist, pstrdup(), RelationData::rd_rel, RELATION_IS_OTHER_TEMP, RangeTblEntry::relid, RangeTblEntry::relkind, RangeTblEntry::rellockmode, ROW_MARK_COPY, PlanRowMark::rowmarkId, PlannerInfo::rowMarks, RTE_RELATION, RTE_SUBQUERY, RangeTblEntry::rtekind, PlanRowMark::rti, SelfItemPointerAttributeNumber, snprintf, table_close(), table_open(), and TableOidAttributeNumber.

Referenced by add_other_rels_to_query(), and expand_appendrel_subquery().

{
    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)
    {
        /*
         * 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, 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), false);
    }

    table_close(oldrelation, NoLock);
}