Rework planning and execution of UPDATE and DELETE.

This patch makes two closely related sets of changes:

1. For UPDATE, the subplan of the ModifyTable node now only delivers
the new values of the changed columns (i.e., the expressions computed
in the query's SET clause) plus row identity information such as CTID.
ModifyTable must re-fetch the original tuple to merge in the old
values of any unchanged columns.  The core advantage of this is that
the changed columns are uniform across all tables of an inherited or
partitioned target relation, whereas the other columns might not be.
A secondary advantage, when the UPDATE involves joins, is that less
data needs to pass through the plan tree.  The disadvantage of course
is an extra fetch of each tuple to be updated.  However, that seems to
be very nearly free in context; even worst-case tests don't show it to
add more than a couple percent to the total query cost.  At some point
it might be interesting to combine the re-fetch with the tuple access
that ModifyTable must do anyway to mark the old tuple dead; but that
would require a good deal of refactoring and it seems it wouldn't buy
all that much, so this patch doesn't attempt it.

2. For inherited UPDATE/DELETE, instead of generating a separate
subplan for each target relation, we now generate a single subplan
that is just exactly like a SELECT's plan, then stick ModifyTable
on top of that.  To let ModifyTable know which target relation a
given incoming row refers to, a tableoid junk column is added to
the row identity information.  This gets rid of the horrid hack
that was inheritance_planner(), eliminating O(N^2) planning cost
and memory consumption in cases where there were many unprunable
target relations.

Point 2 of course requires point 1, so that there is a uniform
definition of the non-junk columns to be returned by the subplan.
We can't insist on uniform definition of the row identity junk
columns however, if we want to keep the ability to have both
plain and foreign tables in a partitioning hierarchy.  Since
it wouldn't scale very far to have every child table have its
own row identity column, this patch includes provisions to merge
similar row identity columns into one column of the subplan result.
In particular, we can merge the whole-row Vars typically used as
row identity by FDWs into one column by pretending they are type
RECORD.  (It's still okay for the actual composite Datums to be
labeled with the table's rowtype OID, though.)

There is more that can be done to file down residual inefficiencies
in this patch, but it seems to be committable now.

FDW authors should note several API changes:

* The argument list for AddForeignUpdateTargets() has changed, and so
has the method it must use for adding junk columns to the query.  Call
add_row_identity_var() instead of manipulating the parse tree directly.
You might want to reconsider exactly what you're adding, too.

* PlanDirectModify() must now work a little harder to find the
ForeignScan plan node; if the foreign table is part of a partitioning
hierarchy then the ForeignScan might not be the direct child of
ModifyTable.  See postgres_fdw for sample code.

* To check whether a relation is a target relation, it's no
longer sufficient to compare its relid to root->parse->resultRelation.
Instead, check it against all_result_relids or leaf_result_relids,
as appropriate.

Amit Langote and Tom Lane

Discussion: https://postgr.es/m/CA+HiwqHpHdqdDn48yCEhynnniahH78rwcrv1rEX65-fsZGBOLQ@mail.gmail.com

1 files changed, 400 insertions, 146 deletions

diff --git a/src/backend/optimizer/util/appendinfo.c b/src/backend/optimizer/util/appendinfo.c
index 86922a273c6..af46f581ac1 100644
--- a/src/backend/optimizer/util/appendinfo.c
+++ b/src/backend/optimizer/util/appendinfo.c
@@ -15,9 +15,12 @@
 #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"
@@ -37,8 +40,6 @@ static void make_inh_translation_list(Relation oldrelation,
 									  AppendRelInfo *appinfo);
 static Node *adjust_appendrel_attrs_mutator(Node *node,
 											adjust_appendrel_attrs_context *context);
-static List *adjust_inherited_tlist(List *tlist,
-									AppendRelInfo *context);
 
 
 /*
@@ -194,7 +195,6 @@ Node *
 adjust_appendrel_attrs(PlannerInfo *root, Node *node, int nappinfos,
 					   AppendRelInfo **appinfos)
 {
-	Node	   *result;
 	adjust_appendrel_attrs_context context;
 
 	context.root = root;
@@ -204,40 +204,10 @@ adjust_appendrel_attrs(PlannerInfo *root, Node *node, int nappinfos,
 	/* If there's nothing to adjust, don't call this function. */
 	Assert(nappinfos >= 1 && appinfos != NULL);
 
-	/*
-	 * Must be prepared to start with a Query or a bare expression tree.
-	 */
-	if (node && IsA(node, Query))
-	{
-		Query	   *newnode;
-		int			cnt;
+	/* Should never be translating a Query tree. */
+	Assert(node == NULL || !IsA(node, Query));
 
-		newnode = query_tree_mutator((Query *) node,
-									 adjust_appendrel_attrs_mutator,
-									 (void *) &context,
-									 QTW_IGNORE_RC_SUBQUERIES);
-		for (cnt = 0; cnt < nappinfos; cnt++)
-		{
-			AppendRelInfo *appinfo = appinfos[cnt];
-
-			if (newnode->resultRelation == appinfo->parent_relid)
-			{
-				newnode->resultRelation = appinfo->child_relid;
-				/* Fix tlist resnos too, if it's inherited UPDATE */
-				if (newnode->commandType == CMD_UPDATE)
-					newnode->targetList =
-						adjust_inherited_tlist(newnode->targetList,
-											   appinfo);
-				break;
-			}
-		}
-
-		result = (Node *) newnode;
-	}
-	else
-		result = adjust_appendrel_attrs_mutator(node, &context);
-
-	return result;
+	return adjust_appendrel_attrs_mutator(node, &context);
 }
 
 static Node *
@@ -343,6 +313,57 @@ adjust_appendrel_attrs_mutator(Node *node,
 			}
 			/* 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;
+					/* 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))
@@ -361,44 +382,6 @@ adjust_appendrel_attrs_mutator(Node *node,
 		}
 		return (Node *) cexpr;
 	}
-	if (IsA(node, RangeTblRef))
-	{
-		RangeTblRef *rtr = (RangeTblRef *) copyObject(node);
-
-		for (cnt = 0; cnt < nappinfos; cnt++)
-		{
-			AppendRelInfo *appinfo = appinfos[cnt];
-
-			if (rtr->rtindex == appinfo->parent_relid)
-			{
-				rtr->rtindex = appinfo->child_relid;
-				break;
-			}
-		}
-		return (Node *) rtr;
-	}
-	if (IsA(node, JoinExpr))
-	{
-		/* Copy the JoinExpr node with correct mutation of subnodes */
-		JoinExpr   *j;
-		AppendRelInfo *appinfo;
-
-		j = (JoinExpr *) expression_tree_mutator(node,
-												 adjust_appendrel_attrs_mutator,
-												 (void *) context);
-		/* now fix JoinExpr's rtindex (probably never happens) */
-		for (cnt = 0; cnt < nappinfos; cnt++)
-		{
-			appinfo = appinfos[cnt];
-
-			if (j->rtindex == appinfo->parent_relid)
-			{
-				j->rtindex = appinfo->child_relid;
-				break;
-			}
-		}
-		return (Node *) j;
-	}
 	if (IsA(node, PlaceHolderVar))
 	{
 		/* Copy the PlaceHolderVar node with correct mutation of subnodes */
@@ -486,6 +469,9 @@ adjust_appendrel_attrs_mutator(Node *node,
 	 */
 	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);
@@ -621,100 +607,101 @@ adjust_child_relids_multilevel(PlannerInfo *root, Relids relids,
 }
 
 /*
- * Adjust the targetlist entries of an inherited UPDATE operation
- *
- * The expressions have already been fixed, but we have to make sure that
- * the target resnos match the child table (they may not, in the case of
- * a column that was added after-the-fact by ALTER TABLE).  In some cases
- * this can force us to re-order the tlist to preserve resno ordering.
- * (We do all this work in special cases so that preptlist.c is fast for
- * the typical case.)
- *
- * The given tlist has already been through expression_tree_mutator;
- * therefore the TargetEntry nodes are fresh copies that it's okay to
- * scribble on.
- *
- * Note that this is not needed for INSERT because INSERT isn't inheritable.
+ * adjust_inherited_attnums
+ *	  Translate an integer list of attribute numbers from parent to child.
  */
-static List *
-adjust_inherited_tlist(List *tlist, AppendRelInfo *context)
+List *
+adjust_inherited_attnums(List *attnums, AppendRelInfo *context)
 {
-	bool		changed_it = false;
-	ListCell   *tl;
-	List	   *new_tlist;
-	bool		more;
-	int			attrno;
+	List	   *result = NIL;
+	ListCell   *lc;
 
 	/* This should only happen for an inheritance case, not UNION ALL */
 	Assert(OidIsValid(context->parent_reloid));
 
-	/* Scan tlist and update resnos to match attnums of child rel */
-	foreach(tl, tlist)
+	/* Look up each attribute in the AppendRelInfo's translated_vars list */
+	foreach(lc, attnums)
 	{
-		TargetEntry *tle = (TargetEntry *) lfirst(tl);
+		AttrNumber	parentattno = lfirst_int(lc);
 		Var		   *childvar;
 
-		if (tle->resjunk)
-			continue;			/* ignore junk items */
-
 		/* Look up the translation of this column: it must be a Var */
-		if (tle->resno <= 0 ||
-			tle->resno > list_length(context->translated_vars))
+		if (parentattno <= 0 ||
+			parentattno > list_length(context->translated_vars))
 			elog(ERROR, "attribute %d of relation \"%s\" does not exist",
-				 tle->resno, get_rel_name(context->parent_reloid));
-		childvar = (Var *) list_nth(context->translated_vars, tle->resno - 1);
+				 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",
-				 tle->resno, get_rel_name(context->parent_reloid));
+				 parentattno, get_rel_name(context->parent_reloid));
 
-		if (tle->resno != childvar->varattno)
-		{
-			tle->resno = childvar->varattno;
-			changed_it = true;
-		}
+		result = lappend_int(result, childvar->varattno);
 	}
+	return result;
+}
 
-	/*
-	 * If we changed anything, re-sort the tlist by resno, and make sure
-	 * resjunk entries have resnos above the last real resno.  The sort
-	 * algorithm is a bit stupid, but for such a seldom-taken path, small is
-	 * probably better than fast.
-	 */
-	if (!changed_it)
-		return tlist;
+/*
+ * adjust_inherited_attnums_multilevel
+ *	  As above, but traverse multiple inheritance levels as needed.
+ */
+List *
+adjust_inherited_attnums_multilevel(PlannerInfo *root, List *attnums,
+									Index child_relid, Index top_parent_relid)
+{
+	AppendRelInfo *appinfo = root->append_rel_array[child_relid];
 
-	new_tlist = NIL;
-	more = true;
-	for (attrno = 1; more; attrno++)
-	{
-		more = false;
-		foreach(tl, tlist)
-		{
-			TargetEntry *tle = (TargetEntry *) lfirst(tl);
+	if (!appinfo)
+		elog(ERROR, "child rel %d not found in append_rel_array", child_relid);
 
-			if (tle->resjunk)
-				continue;		/* ignore junk items */
+	/* 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);
 
-			if (tle->resno == attrno)
-				new_tlist = lappend(new_tlist, tle);
-			else if (tle->resno > attrno)
-				more = true;
-		}
-	}
+	/* Now translate for this child */
+	return adjust_inherited_attnums(attnums, appinfo);
+}
 
-	foreach(tl, tlist)
+/*
+ * get_translated_update_targetlist
+ *	  Get the processed_tlist of an UPDATE query, translated as needed to
+ *	  match a child target relation.
+ *
+ * Optionally also return the list of target column numbers translated
+ * to this target relation.  (The resnos in processed_tlist MUST NOT be
+ * relied on for this purpose.)
+ */
+void
+get_translated_update_targetlist(PlannerInfo *root, Index relid,
+								 List **processed_tlist, List **update_colnos)
+{
+	/* This is pretty meaningless for commands other than UPDATE. */
+	Assert(root->parse->commandType == CMD_UPDATE);
+	if (relid == root->parse->resultRelation)
 	{
-		TargetEntry *tle = (TargetEntry *) lfirst(tl);
-
-		if (!tle->resjunk)
-			continue;			/* here, ignore non-junk items */
-
-		tle->resno = attrno;
-		new_tlist = lappend(new_tlist, tle);
-		attrno++;
+		/*
+		 * 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,
+											  bms_make_singleton(relid),
+											  bms_make_singleton(root->parse->resultRelation));
+		if (update_colnos)
+			*update_colnos =
+				adjust_inherited_attnums_multilevel(root, root->update_colnos,
+													relid,
+													root->parse->resultRelation);
 	}
-
-	return new_tlist;
 }
 
 /*
@@ -746,3 +733,270 @@ find_appinfos_by_relids(PlannerInfo *root, Relids relids, int *nappinfos)
 	}
 	return appinfos;
 }
+
+
+/*****************************************************************************
+ *
+ *		ROW-IDENTITY VARIABLE MANAGEMENT
+ *
+ * This code lacks a good home, perhaps.  We choose to keep it here because
+ * adjust_appendrel_attrs_mutator() is its principal co-conspirator.  That
+ * function does most of what is needed to expand ROWID_VAR Vars into the
+ * right things.
+ *
+ *****************************************************************************/
+
+/*
+ * add_row_identity_var
+ *	  Register a row-identity column to be used in UPDATE/DELETE.
+ *
+ * The Var must be equal(), aside from varno, to any other row-identity
+ * column with the same rowid_name.  Thus, for example, "wholerow"
+ * row identities had better use vartype == RECORDOID.
+ *
+ * rtindex is currently redundant with rowid_var->varno, but we specify
+ * it as a separate parameter in case this is ever generalized to support
+ * non-Var expressions.  (We could reasonably handle expressions over
+ * Vars of the specified rtindex, but for now that seems unnecessary.)
+ */
+void
+add_row_identity_var(PlannerInfo *root, Var *orig_var,
+					 Index rtindex, const char *rowid_name)
+{
+	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);
+
+	/*
+	 * If we're doing non-inherited UPDATE/DELETE, 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);
+}
+
+/*
+ * add_row_identity_columns
+ *
+ * This function adds the row identity columns needed by the core code.
+ * FDWs might call add_row_identity_var() for themselves to add nonstandard
+ * columns.  (Duplicate requests are fine.)
+ */
+void
+add_row_identity_columns(PlannerInfo *root, Index rtindex,
+						 RangeTblEntry *target_rte,
+						 Relation target_relation)
+{
+	CmdType		commandType = root->parse->commandType;
+	char		relkind = target_relation->rd_rel->relkind;
+	Var		   *var;
+
+	Assert(commandType == CMD_UPDATE || commandType == CMD_DELETE);
+
+	if (relkind == RELKIND_RELATION ||
+		relkind == RELKIND_MATVIEW ||
+		relkind == RELKIND_PARTITIONED_TABLE)
+	{
+		/*
+		 * Emit CTID so that executor can find the row to 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");
+		}
+	}
+}
+
+/*
+ * distribute_row_identity_vars
+ *
+ * After we have finished identifying all the row identity columns
+ * needed by an inherited UPDATE/DELETE query, make sure that these
+ * columns will be generated by all the target relations.
+ *
+ * This is more or less like what build_base_rel_tlists() does,
+ * except that it would not understand what to do with ROWID_VAR Vars.
+ * Since that function runs before inheritance relations are expanded,
+ * it will never see any such Vars anyway.
+ */
+void
+distribute_row_identity_vars(PlannerInfo *root)
+{
+	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. */
+	if (parse->commandType != CMD_UPDATE && parse->commandType != CMD_DELETE)
+	{
+		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 */
+		}
+	}
+}