#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 "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 883 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 (commandType == CMD_MERGE ||
         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, Query::commandType, GetFdwRoutineForRelation(), InvalidAttrNumber, InvalidOid, makeVar(), PlannerInfo::parse, RelationData::rd_rel, 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 788 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(), PlannerInfo::leaf_result_relids, lfirst, list_length(), makeNode, makeTargetEntry(), PlannerInfo::parse, PlannerInfo::processed_tlist, pstrdup(), PlannerInfo::row_identity_vars, 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 195 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, and adjust_appendrel_attrs_context::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 520 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(), elog(), ERROR, find_appinfos_by_relids(), pfree(), and RelOptInfo::relids.

Referenced by add_child_join_rel_equivalences(), add_child_rel_equivalences(), 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 214 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?
          */
  
         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)->varnullingrels = var->varnullingrels;
                 else 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->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,
                                                          (void *) 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;
     }
  
     /*
      * 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,
                                    (void *) context);
 }

References adjust_child_relids(), adjust_appendrel_attrs_context::appinfos, ConvertRowtypeExpr::arg, RowExpr::args, Assert(), bms_is_member(), AppendRelInfo::child_relid, AppendRelInfo::child_reltype, RestrictInfo::clause, COERCE_IMPLICIT_CAST, Alias::colnames, copyObject, CurrentOfExpr::cvarno, elog(), RangeTblEntry::eref, ERROR, expression_tree_mutator, get_rel_name(), 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, 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, AppendRelInfo::translated_vars, Var::varattno, Var::varlevelsup, and Var::varno.

Referenced by adjust_appendrel_attrs().

◆ adjust_child_relids()

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

Definition at line 553 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(), and build_child_join_sjinfo().

◆ adjust_child_relids_multilevel()

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

Definition at line 587 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(), bms_overlap(), elog(), ERROR, find_appinfos_by_relids(), pfree(), and RelOptInfo::relids.

Referenced by reparameterize_path_by_child().

◆ adjust_inherited_attnums()

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

Definition at line 627 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 661 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(), elog(), ERROR, and AppendRelInfo::parent_relid.

Referenced by get_translated_update_targetlist(), and grouping_planner().

◆ distribute_row_identity_vars()

void distribute_row_identity_vars ( PlannerInfo * root )

Definition at line 965 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".
      * (This is a bit ugly, but it seems better to confine the ugliness and
      * extra cycles to this unusual corner case.)  We needn't worry about
      * fixing the rel's reltarget, as that won't affect the finished plan.
      */
     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);
         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(), CMD_DELETE, CMD_MERGE, CMD_UPDATE, copyObject, TargetEntry::expr, PathTarget::exprs, find_base_rel(), if(), RangeTblEntry::inh, IsA, lappend(), lfirst, NIL, NoLock, parse(), PlannerInfo::parse, PlannerInfo::processed_tlist, RangeTblEntry::relid, RelOptInfo::reltarget, PlannerInfo::row_identity_vars, 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 732 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, and palloc().

Referenced by adjust_appendrel_attrs_multilevel(), adjust_child_relids_multilevel(), apply_scanjoin_target_to_paths(), build_child_join_rel(), 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 689 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(), PlannerInfo::all_result_relids, Assert(), bms_is_member(), CMD_UPDATE, Query::commandType, copyObject, find_base_rel(), PlannerInfo::parse, PlannerInfo::processed_tlist, and PlannerInfo::update_colnos.

Referenced by postgresPlanDirectModify().

◆ make_append_rel_info()

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

Definition at line 50 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
	)