#include "postgres.h"
#include "access/htup_details.h"
#include "access/table.h"
#include "foreign/fdwapi.h"
#include "nodes/makefuncs.h"
#include "nodes/nodeFuncs.h"
#include "optimizer/appendinfo.h"
#include "optimizer/pathnode.h"
#include "optimizer/planmain.h"
#include "parser/parsetree.h"
#include "utils/lsyscache.h"
#include "utils/rel.h"
#include "utils/syscache.h"

Include dependency graph for appendinfo.c:

Data Structures
struct	adjust_appendrel_attrs_context

Functions
static void	make_inh_translation_list (Relation oldrelation, Relation newrelation, Index newvarno, AppendRelInfo *appinfo)

static Node *	adjust_appendrel_attrs_mutator (Node node, adjust_appendrel_attrs_context context)

AppendRelInfo *	make_append_rel_info (Relation parentrel, Relation childrel, Index parentRTindex, Index childRTindex)

Node *	adjust_appendrel_attrs (PlannerInfo root, Node node, int nappinfos, AppendRelInfo **appinfos)

Node *	adjust_appendrel_attrs_multilevel (PlannerInfo root, Node node, RelOptInfo childrel, RelOptInfo parentrel)

Relids	adjust_child_relids (Relids relids, int nappinfos, AppendRelInfo **appinfos)

Relids	adjust_child_relids_multilevel (PlannerInfo root, Relids relids, RelOptInfo childrel, RelOptInfo *parentrel)

List *	adjust_inherited_attnums (List attnums, AppendRelInfo context)

List *	adjust_inherited_attnums_multilevel (PlannerInfo root, List attnums, Index child_relid, Index top_parent_relid)

void	get_translated_update_targetlist (PlannerInfo root, Index relid, List processed_tlist, List *update_colnos)

AppendRelInfo **	find_appinfos_by_relids (PlannerInfo root, Relids relids, int nappinfos)

void	add_row_identity_var (PlannerInfo root, Var orig_var, Index rtindex, const char *rowid_name)

void	add_row_identity_columns (PlannerInfo root, Index rtindex, RangeTblEntry target_rte, Relation target_relation)

void	distribute_row_identity_vars (PlannerInfo *root)

Function Documentation

◆ add_row_identity_columns()

void add_row_identity_columns	(	PlannerInfo *	root,
		Index	rtindex,
		RangeTblEntry *	target_rte,
		Relation	target_relation
	)

Definition at line 955 of file appendinfo.c.

{
    CmdType     commandType = root->parse->commandType;
    char        relkind = target_relation->rd_rel->relkind;
    Var        *var;
 
    Assert(commandType == CMD_UPDATE || commandType == CMD_DELETE || commandType == CMD_MERGE);
 
    if (relkind == RELKIND_RELATION ||
        relkind == RELKIND_MATVIEW ||
        relkind == RELKIND_PARTITIONED_TABLE)
    {
        /*
         * Emit CTID so that executor can find the row to merge, update or
         * delete.
         */
        var = makeVar(rtindex,
                      SelfItemPointerAttributeNumber,
                      TIDOID,
                      -1,
                      InvalidOid,
                      0);
        add_row_identity_var(root, var, rtindex, "ctid");
    }
    else if (relkind == RELKIND_FOREIGN_TABLE)
    {
        /*
         * Let the foreign table's FDW add whatever junk TLEs it wants.
         */
        FdwRoutine *fdwroutine;
 
        fdwroutine = GetFdwRoutineForRelation(target_relation, false);
 
        if (fdwroutine->AddForeignUpdateTargets != NULL)
            fdwroutine->AddForeignUpdateTargets(root, rtindex,
                                                target_rte, target_relation);
 
        /*
         * For UPDATE, we need to make the FDW fetch unchanged columns by
         * asking it to fetch a whole-row Var.  That's because the top-level
         * targetlist only contains entries for changed columns, but
         * ExecUpdate will need to build the complete new tuple.  (Actually,
         * we only really need this in UPDATEs that are not pushed to the
         * remote side, but it's hard to tell if that will be the case at the
         * point when this function is called.)
         *
         * We will also need the whole row if there are any row triggers, so
         * that the executor will have the "old" row to pass to the trigger.
         * Alas, this misses system columns.
         */
        if (commandType == CMD_UPDATE ||
            (target_relation->trigdesc &&
             (target_relation->trigdesc->trig_delete_after_row ||
              target_relation->trigdesc->trig_delete_before_row)))
        {
            var = makeVar(rtindex,
                          InvalidAttrNumber,
                          RECORDOID,
                          -1,
                          InvalidOid,
                          0);
            add_row_identity_var(root, var, rtindex, "wholerow");
        }
    }
}

References add_row_identity_var(), FdwRoutine::AddForeignUpdateTargets, Assert(), CMD_DELETE, CMD_MERGE, CMD_UPDATE, GetFdwRoutineForRelation(), InvalidAttrNumber, InvalidOid, makeVar(), RelationData::rd_rel, root, SelfItemPointerAttributeNumber, TriggerDesc::trig_delete_after_row, TriggerDesc::trig_delete_before_row, and RelationData::trigdesc.

Referenced by distribute_row_identity_vars(), expand_single_inheritance_child(), and preprocess_targetlist().

◆ add_row_identity_var()

void add_row_identity_var	(	PlannerInfo *	root,
		Var *	orig_var,
		Index	rtindex,
		const char *	rowid_name
	)

Definition at line 860 of file appendinfo.c.

{
    TargetEntry *tle;
    Var        *rowid_var;
    RowIdentityVarInfo *ridinfo;
    ListCell   *lc;
 
    /* For now, the argument must be just a Var of the given rtindex */
    Assert(IsA(orig_var, Var));
    Assert(orig_var->varno == rtindex);
    Assert(orig_var->varlevelsup == 0);
    Assert(orig_var->varnullingrels == NULL);
 
    /*
     * If we're doing non-inherited UPDATE/DELETE/MERGE, there's little need
     * for ROWID_VAR shenanigans.  Just shove the presented Var into the
     * processed_tlist, and we're done.
     */
    if (rtindex == root->parse->resultRelation)
    {
        tle = makeTargetEntry((Expr *) orig_var,
                              list_length(root->processed_tlist) + 1,
                              pstrdup(rowid_name),
                              true);
        root->processed_tlist = lappend(root->processed_tlist, tle);
        return;
    }
 
    /*
     * Otherwise, rtindex should reference a leaf target relation that's being
     * added to the query during expand_inherited_rtentry().
     */
    Assert(bms_is_member(rtindex, root->leaf_result_relids));
    Assert(root->append_rel_array[rtindex] != NULL);
 
    /*
     * We have to find a matching RowIdentityVarInfo, or make one if there is
     * none.  To allow using equal() to match the vars, change the varno to
     * ROWID_VAR, leaving all else alone.
     */
    rowid_var = copyObject(orig_var);
    /* This could eventually become ChangeVarNodes() */
    rowid_var->varno = ROWID_VAR;
 
    /* Look for an existing row-id column of the same name */
    foreach(lc, root->row_identity_vars)
    {
        ridinfo = (RowIdentityVarInfo *) lfirst(lc);
        if (strcmp(rowid_name, ridinfo->rowidname) != 0)
            continue;
        if (equal(rowid_var, ridinfo->rowidvar))
        {
            /* Found a match; we need only record that rtindex needs it too */
            ridinfo->rowidrels = bms_add_member(ridinfo->rowidrels, rtindex);
            return;
        }
        else
        {
            /* Ooops, can't handle this */
            elog(ERROR, "conflicting uses of row-identity name \"%s\"",
                 rowid_name);
        }
    }
 
    /* No request yet, so add a new RowIdentityVarInfo */
    ridinfo = makeNode(RowIdentityVarInfo);
    ridinfo->rowidvar = copyObject(rowid_var);
    /* for the moment, estimate width using just the datatype info */
    ridinfo->rowidwidth = get_typavgwidth(exprType((Node *) rowid_var),
                                          exprTypmod((Node *) rowid_var));
    ridinfo->rowidname = pstrdup(rowid_name);
    ridinfo->rowidrels = bms_make_singleton(rtindex);
 
    root->row_identity_vars = lappend(root->row_identity_vars, ridinfo);
 
    /* Change rowid_var into a reference to this row_identity_vars entry */
    rowid_var->varattno = list_length(root->row_identity_vars);
 
    /* Push the ROWID_VAR reference variable into processed_tlist */
    tle = makeTargetEntry((Expr *) rowid_var,
                          list_length(root->processed_tlist) + 1,
                          pstrdup(rowid_name),
                          true);
    root->processed_tlist = lappend(root->processed_tlist, tle);
}

References Assert(), bms_add_member(), bms_is_member(), bms_make_singleton(), copyObject, elog, equal(), ERROR, exprType(), exprTypmod(), get_typavgwidth(), IsA, lappend(), lfirst, list_length(), makeNode, makeTargetEntry(), pstrdup(), root, ROWID_VAR, RowIdentityVarInfo::rowidname, RowIdentityVarInfo::rowidrels, RowIdentityVarInfo::rowidvar, RowIdentityVarInfo::rowidwidth, Var::varattno, Var::varlevelsup, and Var::varno.

Referenced by add_row_identity_columns(), expand_single_inheritance_child(), and postgresAddForeignUpdateTargets().

◆ adjust_appendrel_attrs()

Node * adjust_appendrel_attrs	(	PlannerInfo *	root,
		Node *	node,
		int	nappinfos,
		AppendRelInfo **	appinfos
	)

Definition at line 200 of file appendinfo.c.

{
    adjust_appendrel_attrs_context context;
 
    context.root = root;
    context.nappinfos = nappinfos;
    context.appinfos = appinfos;
 
    /* If there's nothing to adjust, don't call this function. */
    Assert(nappinfos >= 1 && appinfos != NULL);
 
    /* Should never be translating a Query tree. */
    Assert(node == NULL || !IsA(node, Query));
 
    return adjust_appendrel_attrs_mutator(node, &context);
}

References adjust_appendrel_attrs_mutator(), adjust_appendrel_attrs_context::appinfos, Assert(), IsA, adjust_appendrel_attrs_context::nappinfos, adjust_appendrel_attrs_context::root, and root.

Referenced by add_child_join_rel_equivalences(), add_child_rel_equivalences(), adjust_appendrel_attrs_multilevel(), apply_child_basequals(), apply_scanjoin_target_to_paths(), build_child_join_rel(), build_child_join_reltarget(), build_child_join_sjinfo(), create_partitionwise_grouping_paths(), make_partitionedrel_pruneinfo(), set_append_rel_size(), and try_partitionwise_join().

◆ adjust_appendrel_attrs_multilevel()

Node * adjust_appendrel_attrs_multilevel	(	PlannerInfo *	root,
		Node *	node,
		RelOptInfo *	childrel,
		RelOptInfo *	parentrel
	)

Definition at line 592 of file appendinfo.c.

{
    AppendRelInfo **appinfos;
    int         nappinfos;
 
    /* Recurse if immediate parent is not the top parent. */
    if (childrel->parent != parentrel)
    {
        if (childrel->parent)
            node = adjust_appendrel_attrs_multilevel(root, node,
                                                     childrel->parent,
                                                     parentrel);
        else
            elog(ERROR, "childrel is not a child of parentrel");
    }
 
    /* Now translate for this child. */
    appinfos = find_appinfos_by_relids(root, childrel->relids, &nappinfos);
 
    node = adjust_appendrel_attrs(root, node, nappinfos, appinfos);
 
    pfree(appinfos);
 
    return node;
}

References adjust_appendrel_attrs(), adjust_appendrel_attrs_multilevel(), elog, ERROR, find_appinfos_by_relids(), pfree(), RelOptInfo::relids, and root.

Referenced by add_child_join_rel_equivalences(), add_child_rel_equivalences(), adjust_appendrel_attrs_multilevel(), create_rel_agg_info(), create_unique_paths(), generate_join_implied_equalities_broken(), get_translated_update_targetlist(), grouping_planner(), and make_partitionedrel_pruneinfo().

◆ adjust_appendrel_attrs_mutator()

static Node * adjust_appendrel_attrs_mutator	(	Node *	node,
		adjust_appendrel_attrs_context *	context
	)

static

Definition at line 219 of file appendinfo.c.

{
    AppendRelInfo **appinfos = context->appinfos;
    int         nappinfos = context->nappinfos;
    int         cnt;
 
    if (node == NULL)
        return NULL;
    if (IsA(node, Var))
    {
        Var        *var = (Var *) copyObject(node);
        AppendRelInfo *appinfo = NULL;
 
        if (var->varlevelsup != 0)
            return (Node *) var;    /* no changes needed */
 
        /*
         * You might think we need to adjust var->varnullingrels, but that
         * shouldn't need any changes.  It will contain outer-join relids,
         * while the transformation we are making affects only baserels.
         * Below, we just propagate var->varnullingrels into the translated
         * Var.
         *
         * If var->varnullingrels isn't empty, and the translation wouldn't be
         * a Var, we have to fail.  One could imagine wrapping the translated
         * expression in a PlaceHolderVar, but that won't work because this is
         * typically used after freezing placeholders.  Fortunately, the case
         * appears unreachable at the moment.  We can see nonempty
         * var->varnullingrels here, but only in cases involving partitionwise
         * joining, and in such cases the translations will always be Vars.
         * (Non-Var translations occur only for appendrels made by flattening
         * UNION ALL subqueries.)  Should we need to make this work in future,
         * a possible fix is to mandate that prepjointree.c create PHVs for
         * all non-Var outputs of such subqueries, and then we could look up
         * the pre-existing PHV here.  Or perhaps just wrap the translations
         * that way to begin with?
         *
         * If var->varreturningtype is not VAR_RETURNING_DEFAULT, then that
         * also needs to be copied to the translated Var.  That too would fail
         * if the translation wasn't a Var, but that should never happen since
         * a non-default var->varreturningtype is only used for Vars referring
         * to the result relation, which should never be a flattened UNION ALL
         * subquery.
         */
 
        for (cnt = 0; cnt < nappinfos; cnt++)
        {
            if (var->varno == appinfos[cnt]->parent_relid)
            {
                appinfo = appinfos[cnt];
                break;
            }
        }
 
        if (appinfo)
        {
            var->varno = appinfo->child_relid;
            /* it's now a generated Var, so drop any syntactic labeling */
            var->varnosyn = 0;
            var->varattnosyn = 0;
            if (var->varattno > 0)
            {
                Node       *newnode;
 
                if (var->varattno > list_length(appinfo->translated_vars))
                    elog(ERROR, "attribute %d of relation \"%s\" does not exist",
                         var->varattno, get_rel_name(appinfo->parent_reloid));
                newnode = copyObject(list_nth(appinfo->translated_vars,
                                              var->varattno - 1));
                if (newnode == NULL)
                    elog(ERROR, "attribute %d of relation \"%s\" does not exist",
                         var->varattno, get_rel_name(appinfo->parent_reloid));
                if (IsA(newnode, Var))
                {
                    ((Var *) newnode)->varreturningtype = var->varreturningtype;
                    ((Var *) newnode)->varnullingrels = var->varnullingrels;
                }
                else
                {
                    if (var->varreturningtype != VAR_RETURNING_DEFAULT)
                        elog(ERROR, "failed to apply returningtype to a non-Var");
                    if (var->varnullingrels != NULL)
                        elog(ERROR, "failed to apply nullingrels to a non-Var");
                }
                return newnode;
            }
            else if (var->varattno == 0)
            {
                /*
                 * Whole-row Var: if we are dealing with named rowtypes, we
                 * can use a whole-row Var for the child table plus a coercion
                 * step to convert the tuple layout to the parent's rowtype.
                 * Otherwise we have to generate a RowExpr.
                 */
                if (OidIsValid(appinfo->child_reltype))
                {
                    Assert(var->vartype == appinfo->parent_reltype);
                    if (appinfo->parent_reltype != appinfo->child_reltype)
                    {
                        ConvertRowtypeExpr *r = makeNode(ConvertRowtypeExpr);
 
                        r->arg = (Expr *) var;
                        r->resulttype = appinfo->parent_reltype;
                        r->convertformat = COERCE_IMPLICIT_CAST;
                        r->location = -1;
                        /* Make sure the Var node has the right type ID, too */
                        var->vartype = appinfo->child_reltype;
                        return (Node *) r;
                    }
                }
                else
                {
                    /*
                     * Build a RowExpr containing the translated variables.
                     *
                     * In practice var->vartype will always be RECORDOID here,
                     * so we need to come up with some suitable column names.
                     * We use the parent RTE's column names.
                     *
                     * Note: we can't get here for inheritance cases, so there
                     * is no need to worry that translated_vars might contain
                     * some dummy NULLs.
                     */
                    RowExpr    *rowexpr;
                    List       *fields;
                    RangeTblEntry *rte;
 
                    rte = rt_fetch(appinfo->parent_relid,
                                   context->root->parse->rtable);
                    fields = copyObject(appinfo->translated_vars);
                    rowexpr = makeNode(RowExpr);
                    rowexpr->args = fields;
                    rowexpr->row_typeid = var->vartype;
                    rowexpr->row_format = COERCE_IMPLICIT_CAST;
                    rowexpr->colnames = copyObject(rte->eref->colnames);
                    rowexpr->location = -1;
 
                    if (var->varreturningtype != VAR_RETURNING_DEFAULT)
                        elog(ERROR, "failed to apply returningtype to a non-Var");
                    if (var->varnullingrels != NULL)
                        elog(ERROR, "failed to apply nullingrels to a non-Var");
 
                    return (Node *) rowexpr;
                }
            }
            /* system attributes don't need any other translation */
        }
        else if (var->varno == ROWID_VAR)
        {
            /*
             * If it's a ROWID_VAR placeholder, see if we've reached a leaf
             * target rel, for which we can translate the Var to a specific
             * instantiation.  We should never be asked to translate to a set
             * of relids containing more than one leaf target rel, so the
             * answer will be unique.  If we're still considering non-leaf
             * inheritance levels, return the ROWID_VAR Var as-is.
             */
            Relids      leaf_result_relids = context->root->leaf_result_relids;
            Index       leaf_relid = 0;
 
            for (cnt = 0; cnt < nappinfos; cnt++)
            {
                if (bms_is_member(appinfos[cnt]->child_relid,
                                  leaf_result_relids))
                {
                    if (leaf_relid)
                        elog(ERROR, "cannot translate to multiple leaf relids");
                    leaf_relid = appinfos[cnt]->child_relid;
                }
            }
 
            if (leaf_relid)
            {
                RowIdentityVarInfo *ridinfo = (RowIdentityVarInfo *)
                    list_nth(context->root->row_identity_vars, var->varattno - 1);
 
                if (bms_is_member(leaf_relid, ridinfo->rowidrels))
                {
                    /* Substitute the Var given in the RowIdentityVarInfo */
                    var = copyObject(ridinfo->rowidvar);
                    /* ... but use the correct relid */
                    var->varno = leaf_relid;
                    /* identity vars shouldn't have nulling rels */
                    Assert(var->varnullingrels == NULL);
                    /* varnosyn in the RowIdentityVarInfo is probably wrong */
                    var->varnosyn = 0;
                    var->varattnosyn = 0;
                }
                else
                {
                    /*
                     * This leaf rel can't return the desired value, so
                     * substitute a NULL of the correct type.
                     */
                    return (Node *) makeNullConst(var->vartype,
                                                  var->vartypmod,
                                                  var->varcollid);
                }
            }
        }
        return (Node *) var;
    }
    if (IsA(node, CurrentOfExpr))
    {
        CurrentOfExpr *cexpr = (CurrentOfExpr *) copyObject(node);
 
        for (cnt = 0; cnt < nappinfos; cnt++)
        {
            AppendRelInfo *appinfo = appinfos[cnt];
 
            if (cexpr->cvarno == appinfo->parent_relid)
            {
                cexpr->cvarno = appinfo->child_relid;
                break;
            }
        }
        return (Node *) cexpr;
    }
    if (IsA(node, PlaceHolderVar))
    {
        /* Copy the PlaceHolderVar node with correct mutation of subnodes */
        PlaceHolderVar *phv;
 
        phv = (PlaceHolderVar *) expression_tree_mutator(node,
                                                         adjust_appendrel_attrs_mutator,
                                                         context);
        /* now fix PlaceHolderVar's relid sets */
        if (phv->phlevelsup == 0)
        {
            phv->phrels = adjust_child_relids(phv->phrels,
                                              nappinfos, appinfos);
            /* as above, we needn't touch phnullingrels */
        }
        return (Node *) phv;
    }
    /* Shouldn't need to handle planner auxiliary nodes here */
    Assert(!IsA(node, SpecialJoinInfo));
    Assert(!IsA(node, AppendRelInfo));
    Assert(!IsA(node, PlaceHolderInfo));
    Assert(!IsA(node, MinMaxAggInfo));
 
    /*
     * We have to process RestrictInfo nodes specially.  (Note: although
     * set_append_rel_pathlist will hide RestrictInfos in the parent's
     * baserestrictinfo list from us, it doesn't hide those in joininfo.)
     */
    if (IsA(node, RestrictInfo))
    {
        RestrictInfo *oldinfo = (RestrictInfo *) node;
        RestrictInfo *newinfo = makeNode(RestrictInfo);
 
        /* Copy all flat-copiable fields, notably including rinfo_serial */
        memcpy(newinfo, oldinfo, sizeof(RestrictInfo));
 
        /* Recursively fix the clause itself */
        newinfo->clause = (Expr *)
            adjust_appendrel_attrs_mutator((Node *) oldinfo->clause, context);
 
        /* and the modified version, if an OR clause */
        newinfo->orclause = (Expr *)
            adjust_appendrel_attrs_mutator((Node *) oldinfo->orclause, context);
 
        /* adjust relid sets too */
        newinfo->clause_relids = adjust_child_relids(oldinfo->clause_relids,
                                                     context->nappinfos,
                                                     context->appinfos);
        newinfo->required_relids = adjust_child_relids(oldinfo->required_relids,
                                                       context->nappinfos,
                                                       context->appinfos);
        newinfo->outer_relids = adjust_child_relids(oldinfo->outer_relids,
                                                    context->nappinfos,
                                                    context->appinfos);
        newinfo->left_relids = adjust_child_relids(oldinfo->left_relids,
                                                   context->nappinfos,
                                                   context->appinfos);
        newinfo->right_relids = adjust_child_relids(oldinfo->right_relids,
                                                    context->nappinfos,
                                                    context->appinfos);
 
        /*
         * Reset cached derivative fields, since these might need to have
         * different values when considering the child relation.  Note we
         * don't reset left_ec/right_ec: each child variable is implicitly
         * equivalent to its parent, so still a member of the same EC if any.
         */
        newinfo->eval_cost.startup = -1;
        newinfo->norm_selec = -1;
        newinfo->outer_selec = -1;
        newinfo->left_em = NULL;
        newinfo->right_em = NULL;
        newinfo->scansel_cache = NIL;
        newinfo->left_bucketsize = -1;
        newinfo->right_bucketsize = -1;
        newinfo->left_mcvfreq = -1;
        newinfo->right_mcvfreq = -1;
 
        return (Node *) newinfo;
    }
 
    /*
     * We have to process RelAggInfo nodes specially.
     */
    if (IsA(node, RelAggInfo))
    {
        RelAggInfo *oldinfo = (RelAggInfo *) node;
        RelAggInfo *newinfo = makeNode(RelAggInfo);
 
        newinfo->target = (PathTarget *)
            adjust_appendrel_attrs_mutator((Node *) oldinfo->target,
                                           context);
 
        newinfo->agg_input = (PathTarget *)
            adjust_appendrel_attrs_mutator((Node *) oldinfo->agg_input,
                                           context);
 
        newinfo->group_clauses = oldinfo->group_clauses;
 
        newinfo->group_exprs = (List *)
            adjust_appendrel_attrs_mutator((Node *) oldinfo->group_exprs,
                                           context);
 
        return (Node *) newinfo;
    }
 
    /*
     * We have to process PathTarget nodes specially.
     */
    if (IsA(node, PathTarget))
    {
        PathTarget *oldtarget = (PathTarget *) node;
        PathTarget *newtarget = makeNode(PathTarget);
 
        /* Copy all flat-copiable fields */
        memcpy(newtarget, oldtarget, sizeof(PathTarget));
 
        newtarget->exprs = (List *)
            adjust_appendrel_attrs_mutator((Node *) oldtarget->exprs,
                                           context);
 
        if (oldtarget->sortgrouprefs)
        {
            Size        nbytes = list_length(oldtarget->exprs) * sizeof(Index);
 
            newtarget->sortgrouprefs = (Index *) palloc(nbytes);
            memcpy(newtarget->sortgrouprefs, oldtarget->sortgrouprefs, nbytes);
        }
 
        return (Node *) newtarget;
    }
 
    /*
     * NOTE: we do not need to recurse into sublinks, because they should
     * already have been converted to subplans before we see them.
     */
    Assert(!IsA(node, SubLink));
    Assert(!IsA(node, Query));
    /* We should never see these Query substructures, either. */
    Assert(!IsA(node, RangeTblRef));
    Assert(!IsA(node, JoinExpr));
 
    return expression_tree_mutator(node, adjust_appendrel_attrs_mutator, context);
}

References adjust_appendrel_attrs_mutator(), adjust_child_relids(), RelAggInfo::agg_input, adjust_appendrel_attrs_context::appinfos, ConvertRowtypeExpr::arg, RowExpr::args, Assert(), bms_is_member(), AppendRelInfo::child_relid, AppendRelInfo::child_reltype, RestrictInfo::clause, COERCE_IMPLICIT_CAST, copyObject, CurrentOfExpr::cvarno, elog, ERROR, expression_tree_mutator, PathTarget::exprs, get_rel_name(), RelAggInfo::group_clauses, RelAggInfo::group_exprs, IsA, PlannerInfo::leaf_result_relids, list_length(), list_nth(), ConvertRowtypeExpr::location, RowExpr::location, makeNode, makeNullConst(), adjust_appendrel_attrs_context::nappinfos, NIL, OidIsValid, RestrictInfo::outer_relids, palloc(), AppendRelInfo::parent_relid, AppendRelInfo::parent_reloid, AppendRelInfo::parent_reltype, PlannerInfo::parse, PlaceHolderVar::phlevelsup, RestrictInfo::required_relids, ConvertRowtypeExpr::resulttype, adjust_appendrel_attrs_context::root, PlannerInfo::row_identity_vars, ROWID_VAR, RowIdentityVarInfo::rowidrels, RowIdentityVarInfo::rowidvar, rt_fetch, Query::rtable, RelAggInfo::target, AppendRelInfo::translated_vars, VAR_RETURNING_DEFAULT, Var::varattno, Var::varlevelsup, Var::varno, and Var::varreturningtype.

Referenced by adjust_appendrel_attrs(), and adjust_appendrel_attrs_mutator().

◆ adjust_child_relids()

Relids adjust_child_relids	(	Relids	relids,
		int	nappinfos,
		AppendRelInfo **	appinfos
	)

Definition at line 625 of file appendinfo.c.

{
    Bitmapset  *result = NULL;
    int         cnt;
 
    for (cnt = 0; cnt < nappinfos; cnt++)
    {
        AppendRelInfo *appinfo = appinfos[cnt];
 
        /* Remove parent, add child */
        if (bms_is_member(appinfo->parent_relid, relids))
        {
            /* Make a copy if we are changing the set. */
            if (!result)
                result = bms_copy(relids);
 
            result = bms_del_member(result, appinfo->parent_relid);
            result = bms_add_member(result, appinfo->child_relid);
        }
    }
 
    /* If we made any changes, return the modified copy. */
    if (result)
        return result;
 
    /* Otherwise, return the original set without modification. */
    return relids;
}

References bms_add_member(), bms_copy(), bms_del_member(), bms_is_member(), AppendRelInfo::child_relid, and AppendRelInfo::parent_relid.

Referenced by adjust_appendrel_attrs_mutator(), adjust_child_relids_multilevel(), build_child_join_rel(), build_child_join_sjinfo(), and try_partitionwise_join().

◆ adjust_child_relids_multilevel()

Relids adjust_child_relids_multilevel	(	PlannerInfo *	root,
		Relids	relids,
		RelOptInfo *	childrel,
		RelOptInfo *	parentrel
	)

Definition at line 659 of file appendinfo.c.

{
    AppendRelInfo **appinfos;
    int         nappinfos;
 
    /*
     * If the given relids set doesn't contain any of the parent relids, it
     * will remain unchanged.
     */
    if (!bms_overlap(relids, parentrel->relids))
        return relids;
 
    /* Recurse if immediate parent is not the top parent. */
    if (childrel->parent != parentrel)
    {
        if (childrel->parent)
            relids = adjust_child_relids_multilevel(root, relids,
                                                    childrel->parent,
                                                    parentrel);
        else
            elog(ERROR, "childrel is not a child of parentrel");
    }
 
    /* Now translate for this child. */
    appinfos = find_appinfos_by_relids(root, childrel->relids, &nappinfos);
 
    relids = adjust_child_relids(relids, nappinfos, appinfos);
 
    pfree(appinfos);
 
    return relids;
}

References adjust_child_relids(), adjust_child_relids_multilevel(), bms_overlap(), elog, ERROR, find_appinfos_by_relids(), pfree(), RelOptInfo::relids, and root.

Referenced by adjust_child_relids_multilevel(), and reparameterize_path_by_child().

◆ adjust_inherited_attnums()

List * adjust_inherited_attnums	(	List *	attnums,
		AppendRelInfo *	context
	)

Definition at line 699 of file appendinfo.c.

{
    List       *result = NIL;
    ListCell   *lc;
 
    /* This should only happen for an inheritance case, not UNION ALL */
    Assert(OidIsValid(context->parent_reloid));
 
    /* Look up each attribute in the AppendRelInfo's translated_vars list */
    foreach(lc, attnums)
    {
        AttrNumber  parentattno = lfirst_int(lc);
        Var        *childvar;
 
        /* Look up the translation of this column: it must be a Var */
        if (parentattno <= 0 ||
            parentattno > list_length(context->translated_vars))
            elog(ERROR, "attribute %d of relation \"%s\" does not exist",
                 parentattno, get_rel_name(context->parent_reloid));
        childvar = (Var *) list_nth(context->translated_vars, parentattno - 1);
        if (childvar == NULL || !IsA(childvar, Var))
            elog(ERROR, "attribute %d of relation \"%s\" does not exist",
                 parentattno, get_rel_name(context->parent_reloid));
 
        result = lappend_int(result, childvar->varattno);
    }
    return result;
}

References Assert(), elog, ERROR, get_rel_name(), IsA, lappend_int(), lfirst_int, list_length(), list_nth(), NIL, OidIsValid, AppendRelInfo::parent_reloid, AppendRelInfo::translated_vars, and Var::varattno.

Referenced by adjust_inherited_attnums_multilevel().

◆ adjust_inherited_attnums_multilevel()

List * adjust_inherited_attnums_multilevel	(	PlannerInfo *	root,
		List *	attnums,
		Index	child_relid,
		Index	top_parent_relid
	)

Definition at line 733 of file appendinfo.c.

{
    AppendRelInfo *appinfo = root->append_rel_array[child_relid];
 
    if (!appinfo)
        elog(ERROR, "child rel %d not found in append_rel_array", child_relid);
 
    /* Recurse if immediate parent is not the top parent. */
    if (appinfo->parent_relid != top_parent_relid)
        attnums = adjust_inherited_attnums_multilevel(root, attnums,
                                                      appinfo->parent_relid,
                                                      top_parent_relid);
 
    /* Now translate for this child */
    return adjust_inherited_attnums(attnums, appinfo);
}

References adjust_inherited_attnums(), adjust_inherited_attnums_multilevel(), elog, ERROR, AppendRelInfo::parent_relid, and root.

Referenced by adjust_inherited_attnums_multilevel(), get_translated_update_targetlist(), and grouping_planner().

◆ distribute_row_identity_vars()

void distribute_row_identity_vars ( PlannerInfo * root )

Definition at line 1036 of file appendinfo.c.

{
    Query      *parse = root->parse;
    int         result_relation = parse->resultRelation;
    RangeTblEntry *target_rte;
    RelOptInfo *target_rel;
    ListCell   *lc;
 
    /*
     * There's nothing to do if this isn't an inherited UPDATE/DELETE/MERGE.
     */
    if (parse->commandType != CMD_UPDATE && parse->commandType != CMD_DELETE &&
        parse->commandType != CMD_MERGE)
    {
        Assert(root->row_identity_vars == NIL);
        return;
    }
    target_rte = rt_fetch(result_relation, parse->rtable);
    if (!target_rte->inh)
    {
        Assert(root->row_identity_vars == NIL);
        return;
    }
 
    /*
     * Ordinarily, we expect that leaf result relation(s) will have added some
     * ROWID_VAR Vars to the query.  However, it's possible that constraint
     * exclusion suppressed every leaf relation.  The executor will get upset
     * if the plan has no row identity columns at all, even though it will
     * certainly process no rows.  Handle this edge case by re-opening the top
     * result relation and adding the row identity columns it would have used,
     * as preprocess_targetlist() would have done if it weren't marked "inh".
     * Then re-run build_base_rel_tlists() to ensure that the added columns
     * get propagated to the relation's reltarget.  (This is a bit ugly, but
     * it seems better to confine the ugliness and extra cycles to this
     * unusual corner case.)
     */
    if (root->row_identity_vars == NIL)
    {
        Relation    target_relation;
 
        target_relation = table_open(target_rte->relid, NoLock);
        add_row_identity_columns(root, result_relation,
                                 target_rte, target_relation);
        table_close(target_relation, NoLock);
        build_base_rel_tlists(root, root->processed_tlist);
        /* There are no ROWID_VAR Vars in this case, so we're done. */
        return;
    }
 
    /*
     * Dig through the processed_tlist to find the ROWID_VAR reference Vars,
     * and forcibly copy them into the reltarget list of the topmost target
     * relation.  That's sufficient because they'll be copied to the
     * individual leaf target rels (with appropriate translation) later,
     * during appendrel expansion --- see set_append_rel_size().
     */
    target_rel = find_base_rel(root, result_relation);
 
    foreach(lc, root->processed_tlist)
    {
        TargetEntry *tle = lfirst(lc);
        Var        *var = (Var *) tle->expr;
 
        if (var && IsA(var, Var) && var->varno == ROWID_VAR)
        {
            target_rel->reltarget->exprs =
                lappend(target_rel->reltarget->exprs, copyObject(var));
            /* reltarget cost and width will be computed later */
        }
    }
}

References add_row_identity_columns(), Assert(), build_base_rel_tlists(), CMD_DELETE, CMD_MERGE, CMD_UPDATE, copyObject, TargetEntry::expr, PathTarget::exprs, find_base_rel(), if(), RangeTblEntry::inh, IsA, lappend(), lfirst, NIL, NoLock, parse(), RelOptInfo::reltarget, root, ROWID_VAR, rt_fetch, table_close(), table_open(), and Var::varno.

Referenced by query_planner().

◆ find_appinfos_by_relids()

AppendRelInfo ** find_appinfos_by_relids	(	PlannerInfo *	root,
		Relids	relids,
		int *	nappinfos
	)

Definition at line 804 of file appendinfo.c.

{
    AppendRelInfo **appinfos;
    int         cnt = 0;
    int         i;
 
    /* Allocate an array that's certainly big enough */
    appinfos = (AppendRelInfo **)
        palloc(sizeof(AppendRelInfo *) * bms_num_members(relids));
 
    i = -1;
    while ((i = bms_next_member(relids, i)) >= 0)
    {
        AppendRelInfo *appinfo = root->append_rel_array[i];
 
        if (!appinfo)
        {
            /* Probably i is an OJ index, but let's check */
            if (find_base_rel_ignore_join(root, i) == NULL)
                continue;
            /* It's a base rel, but we lack an append_rel_array entry */
            elog(ERROR, "child rel %d not found in append_rel_array", i);
        }
 
        appinfos[cnt++] = appinfo;
    }
    *nappinfos = cnt;
    return appinfos;
}

References bms_next_member(), bms_num_members(), elog, ERROR, find_base_rel_ignore_join(), i, palloc(), and root.

Referenced by adjust_appendrel_attrs_multilevel(), adjust_child_relids_multilevel(), apply_scanjoin_target_to_paths(), build_child_join_sjinfo(), create_partitionwise_grouping_paths(), make_partitionedrel_pruneinfo(), and try_partitionwise_join().

◆ get_translated_update_targetlist()

void get_translated_update_targetlist	(	PlannerInfo *	root,
		Index	relid,
		List **	processed_tlist,
		List **	update_colnos
	)

Definition at line 761 of file appendinfo.c.

{
    /* This is pretty meaningless for commands other than UPDATE. */
    Assert(root->parse->commandType == CMD_UPDATE);
    if (relid == root->parse->resultRelation)
    {
        /*
         * Non-inheritance case, so it's easy.  The caller might be expecting
         * a tree it can scribble on, though, so copy.
         */
        *processed_tlist = copyObject(root->processed_tlist);
        if (update_colnos)
            *update_colnos = copyObject(root->update_colnos);
    }
    else
    {
        Assert(bms_is_member(relid, root->all_result_relids));
        *processed_tlist = (List *)
            adjust_appendrel_attrs_multilevel(root,
                                              (Node *) root->processed_tlist,
                                              find_base_rel(root, relid),
                                              find_base_rel(root, root->parse->resultRelation));
        if (update_colnos)
            *update_colnos =
                adjust_inherited_attnums_multilevel(root, root->update_colnos,
                                                    relid,
                                                    root->parse->resultRelation);
    }
}

References adjust_appendrel_attrs_multilevel(), adjust_inherited_attnums_multilevel(), Assert(), bms_is_member(), CMD_UPDATE, copyObject, find_base_rel(), and root.

Referenced by postgresPlanDirectModify().

◆ make_append_rel_info()

AppendRelInfo * make_append_rel_info	(	Relation	parentrel,
		Relation	childrel,
		Index	parentRTindex,
		Index	childRTindex
	)

Definition at line 51 of file appendinfo.c.

{
    AppendRelInfo *appinfo = makeNode(AppendRelInfo);
 
    appinfo->parent_relid = parentRTindex;
    appinfo->child_relid = childRTindex;
    appinfo->parent_reltype = parentrel->rd_rel->reltype;
    appinfo->child_reltype = childrel->rd_rel->reltype;
    make_inh_translation_list(parentrel, childrel, childRTindex, appinfo);
    appinfo->parent_reloid = RelationGetRelid(parentrel);
 
    return appinfo;
}

References AppendRelInfo::child_relid, AppendRelInfo::child_reltype, make_inh_translation_list(), makeNode, AppendRelInfo::parent_relid, AppendRelInfo::parent_reloid, AppendRelInfo::parent_reltype, RelationData::rd_rel, and RelationGetRelid.

Referenced by expand_single_inheritance_child().

◆ make_inh_translation_list()

static void make_inh_translation_list	(	Relation	oldrelation,
		Relation	newrelation,
		Index	newvarno,
		AppendRelInfo *	appinfo
	)