speeding up planning with partitions

From 060bd2445ea9cba9adadd73505689d6f06583ee8 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Fri, 24 Aug 2018 12:39:36 +0900
Subject: [PATCH v2 1/3] Overhaul partitioned table update/delete planning

Current method, inheritance_planner, applies grouping_planner and
hence query_planner to the query repeatedly with each leaf partition
replacing the root parent as the query's result relation. One big
drawback of this approach is that it cannot use partprune.c to
perform partition pruning on the partitioned result relation, because
it can only be invoked if query_planner sees the partitioned relation
itself in the query.  That is not true with the existing method,
because as mentioned above, query_planner is invoked with the
partitioned relation replaced with individual leaf partitions.

While most of the work in each repitition of grouping_planner (and
query_planner) is same, a couple of things may differ from partition
to partition -- 1. Join planning may produce different Paths for
joining against different result partitions, 2. grouping_planner
may produce different top-level target lists for different
partitions, based on their TupleDescs.

This commit rearranges things so that, only the planning steps that
affect 1 and 2 above are repeated for partitions that are selected by
query_planner by applying partprune.c based pruning to the original
partitioned result rel.

That makes things faster because  1. partprune.c based pruning is
used instead of using constraint exclusion for each partition, 2.
grouping_planner (and query_planner) is invoked only once instead of
for every partition thus saving cycles and memory.

This still doesn't help much if no partitions are pruned, because
we still repeat join planning and makes copies of the query for
each partition, but for common cases where only handful partitions
remain after pruning, this makes things significanly faster.
---
 doc/src/sgml/ddl.sgml                        |  15 +-
 src/backend/optimizer/path/allpaths.c        |  97 ++++++-
 src/backend/optimizer/plan/planmain.c        |   4 +-
 src/backend/optimizer/plan/planner.c         | 378 ++++++++++++++++++++-------
 src/backend/optimizer/prep/prepunion.c       |  28 +-
 src/backend/optimizer/util/plancat.c         |  30 ---
 src/test/regress/expected/partition_join.out |   4 +-
 7 files changed, 416 insertions(+), 140 deletions(-)

diff --git a/doc/src/sgml/ddl.sgml b/doc/src/sgml/ddl.sgml
index b5ed1b7939..53c479fbb8 100644
--- a/doc/src/sgml/ddl.sgml
+++ b/doc/src/sgml/ddl.sgml
@@ -3933,16 +3933,6 @@ EXPLAIN SELECT count(*) FROM measurement WHERE logdate &gt;= DATE '2008-01-01';
     <xref linkend="guc-enable-partition-pruning"/> setting.
    </para>
 
-   <note>
-    <para>
-     Currently, pruning of partitions during the planning of an
-     <command>UPDATE</command> or <command>DELETE</command> command is
-     implemented using the constraint exclusion method (however, it is
-     controlled by the <literal>enable_partition_pruning</literal> rather than
-     <literal>constraint_exclusion</literal>) &mdash; see the following section
-     for details and caveats that apply.
-    </para>
-
     <para>
      Execution-time partition pruning currently occurs for the
      <literal>Append</literal> and <literal>MergeAppend</literal> node types.
@@ -3964,9 +3954,8 @@ EXPLAIN SELECT count(*) FROM measurement WHERE logdate &gt;= DATE '2008-01-01';
 
    <para>
     <firstterm>Constraint exclusion</firstterm> is a query optimization
-    technique similar to partition pruning.  While it is primarily used
-    for partitioning implemented using the legacy inheritance method, it can be
-    used for other purposes, including with declarative partitioning.
+    technique similar to partition pruning.  It is primarily used
+    for partitioning implemented using the legacy inheritance method.
    </para>
 
    <para>
diff --git a/src/backend/optimizer/path/allpaths.c b/src/backend/optimizer/path/allpaths.c
index 0e80aeb65c..5937c0436a 100644
--- a/src/backend/optimizer/path/allpaths.c
+++ b/src/backend/optimizer/path/allpaths.c
@@ -36,6 +36,7 @@
 #include "optimizer/pathnode.h"
 #include "optimizer/paths.h"
 #include "optimizer/plancat.h"
+#include "optimizer/planmain.h"
 #include "optimizer/planner.h"
 #include "optimizer/prep.h"
 #include "optimizer/restrictinfo.h"
@@ -119,6 +120,9 @@ static void set_namedtuplestore_pathlist(PlannerInfo *root, RelOptInfo *rel,
 static void set_worktable_pathlist(PlannerInfo *root, RelOptInfo *rel,
 					   RangeTblEntry *rte);
 static RelOptInfo *make_rel_from_joinlist(PlannerInfo *root, List *joinlist);
+static RelOptInfo *partitionwise_make_rel_from_joinlist(PlannerInfo *root,
+						RelOptInfo *parent,
+						List *joinlist);
 static bool subquery_is_pushdown_safe(Query *subquery, Query *topquery,
 						  pushdown_safety_info *safetyInfo);
 static bool recurse_pushdown_safe(Node *setOp, Query *topquery,
@@ -181,13 +185,30 @@ make_one_rel(PlannerInfo *root, List *joinlist)
 
 	/*
 	 * Generate access paths for the entire join tree.
+	 *
+	 * If we're doing this for an UPDATE or DELETE query whose target is a
+	 * partitioned table, we must do the join planning against each of its
+	 * leaf partitions instead.
 	 */
-	rel = make_rel_from_joinlist(root, joinlist);
+	if (root->parse->resultRelation &&
+		root->parse->commandType != CMD_INSERT &&
+		root->simple_rel_array[root->parse->resultRelation] &&
+		root->simple_rel_array[root->parse->resultRelation]->part_scheme)
+	{
+		RelOptInfo *rootrel = root->simple_rel_array[root->parse->resultRelation];
 
-	/*
-	 * The result should join all and only the query's base rels.
-	 */
-	Assert(bms_equal(rel->relids, root->all_baserels));
+		rel = partitionwise_make_rel_from_joinlist(root, rootrel, joinlist);
+	}
+	else
+	{
+		rel = make_rel_from_joinlist(root, joinlist);
+
+		/*
+		 * The result should join all and only the query's base rels.
+		 */
+		Assert(bms_equal(rel->relids, root->all_baserels));
+
+	}
 
 	return rel;
 }
@@ -2591,6 +2612,72 @@ generate_gather_paths(PlannerInfo *root, RelOptInfo *rel, bool override_rows)
 }
 
 /*
+ * partitionwise_make_rel_from_joinlist
+ *		performs join planning against each of the leaf partitions contained
+ *		in the partition tree whose root relation is 'parent'
+ *
+ * Recursively called for each partitioned table contained in a given
+ *partition tree.
+ */
+static RelOptInfo *
+partitionwise_make_rel_from_joinlist(PlannerInfo *root,
+									 RelOptInfo *parent,
+									 List *joinlist)
+{
+	int		i;
+
+	Assert(root->parse->resultRelation != 0);
+	Assert(parent->part_scheme != NULL);
+
+	for (i = 0; i < parent->nparts; i++)
+	{
+		RelOptInfo *partrel = parent->part_rels[i];
+		AppendRelInfo *appinfo;
+		List	   *translated_joinlist;
+		List	   *saved_join_info_list = list_copy(root->join_info_list);
+
+		/* Ignore pruned partitions. */
+		if (IS_DUMMY_REL(partrel))
+			continue;
+
+		/*
+		 * Hack to make the join planning code believe that 'partrel' can
+		 * be joined against.
+		 */
+		partrel->reloptkind = RELOPT_BASEREL;
+
+		/*
+		 * Replace references to the parent rel in expressions relevant to join
+		 * planning.
+		 */
+		appinfo = root->append_rel_array[partrel->relid];
+		translated_joinlist = (List *)
+						adjust_appendrel_attrs(root, (Node *) joinlist,
+											   1, &appinfo);
+		root->join_info_list = (List *)
+						adjust_appendrel_attrs(root,
+											   (Node *) root->join_info_list,
+											   1, &appinfo);
+		/* Reset join planning data structures for a new partition. */
+		root->join_rel_list = NIL;
+		root->join_rel_hash = NULL;
+
+		/* Recurse if the partition is itself a partitioned table. */
+		if (partrel->part_scheme != NULL)
+			partrel = partitionwise_make_rel_from_joinlist(root, partrel,
+														translated_joinlist);
+		else
+			/* Perform the join planning and save the resulting relation. */
+			parent->part_rels[i] =
+						make_rel_from_joinlist(root, translated_joinlist);
+
+		root->join_info_list = saved_join_info_list;
+	}
+
+	return parent;
+}
+
+/*
  * make_rel_from_joinlist
  *	  Build access paths using a "joinlist" to guide the join path search.
  *
diff --git a/src/backend/optimizer/plan/planmain.c b/src/backend/optimizer/plan/planmain.c
index b05adc70c4..3f0d80eaa6 100644
--- a/src/backend/optimizer/plan/planmain.c
+++ b/src/backend/optimizer/plan/planmain.c
@@ -266,7 +266,9 @@ query_planner(PlannerInfo *root, List *tlist,
 
 	/* Check that we got at least one usable path */
 	if (!final_rel || !final_rel->cheapest_total_path ||
-		final_rel->cheapest_total_path->param_info != NULL)
+		final_rel->cheapest_total_path->param_info != NULL ||
+		(final_rel->relid == root->parse->resultRelation &&
+		 root->parse->commandType == CMD_INSERT))
 		elog(ERROR, "failed to construct the join relation");
 
 	return final_rel;
diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index 96bf0601a8..076dbd3d62 100644
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -238,6 +238,16 @@ static bool group_by_has_partkey(RelOptInfo *input_rel,
 					 List *targetList,
 					 List *groupClause);
 
+static void partitionwise_adjust_scanjoin_target(PlannerInfo *root,
+									 RelOptInfo *parent,
+									 List **partition_subroots,
+									 List **partitioned_rels,
+									 List **resultRelations,
+									 List **subpaths,
+									 List **WCOLists,
+									 List **returningLists,
+									 List **rowMarks);
+
 
 /*****************************************************************************
  *
@@ -959,7 +969,9 @@ subquery_planner(PlannerGlobal *glob, Query *parse,
 	 * needs special processing, else go straight to grouping_planner.
 	 */
 	if (parse->resultRelation &&
-		rt_fetch(parse->resultRelation, parse->rtable)->inh)
+		rt_fetch(parse->resultRelation, parse->rtable)->inh &&
+		rt_fetch(parse->resultRelation, parse->rtable)->relkind !=
+				 RELKIND_PARTITIONED_TABLE)
 		inheritance_planner(root);
 	else
 		grouping_planner(root, false, tuple_fraction);
@@ -1688,6 +1700,14 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 	RelOptInfo *current_rel;
 	RelOptInfo *final_rel;
 	ListCell   *lc;
+	List	   *orig_parse_tlist = list_copy(parse->targetList);
+	List	   *partition_subroots = NIL;
+	List	   *partitioned_rels = NIL;
+	List	   *partition_resultRelations = NIL;
+	List	   *partition_subpaths = NIL;
+	List	   *partition_WCOLists = NIL;
+	List	   *partition_returningLists = NIL;
+	List	   *partition_rowMarks = NIL;
 
 	/* Tweak caller-supplied tuple_fraction if have LIMIT/OFFSET */
 	if (parse->limitCount || parse->limitOffset)
@@ -2018,13 +2038,44 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 			scanjoin_targets_contain_srfs = NIL;
 		}
 
-		/* Apply scan/join target. */
-		scanjoin_target_same_exprs = list_length(scanjoin_targets) == 1
-			&& equal(scanjoin_target->exprs, current_rel->reltarget->exprs);
-		apply_scanjoin_target_to_paths(root, current_rel, scanjoin_targets,
-									   scanjoin_targets_contain_srfs,
-									   scanjoin_target_parallel_safe,
-									   scanjoin_target_same_exprs);
+		/*
+		 * For an UPDATE/DELETE query whose target is partitioned table, we
+		 * must generate the targetlist for each of its leaf partitions and
+		 * apply that.
+		 */
+		if (current_rel->reloptkind == RELOPT_BASEREL &&
+			current_rel->part_scheme &&
+			current_rel->relid == root->parse->resultRelation &&
+			parse->commandType != CMD_INSERT)
+		{
+			/*
+			 * scanjoin_target shouldn't have changed from final_target,
+			 * because UPDATE/DELETE doesn't support various features that
+			 * would've required modifications that are performed above.
+			 * That's important because we'll generate final_target freshly
+			 * for each partition in partitionwise_adjust_scanjoin_target.
+			 */
+			Assert(scanjoin_target == final_target);
+			root->parse->targetList = orig_parse_tlist;
+			partitionwise_adjust_scanjoin_target(root, current_rel,
+												 &partition_subroots,
+												 &partitioned_rels,
+												 &partition_resultRelations,
+												 &partition_subpaths,
+												 &partition_WCOLists,
+												 &partition_returningLists,
+												 &partition_rowMarks);
+		}
+		else
+		{
+			/* Apply scan/join target. */
+			scanjoin_target_same_exprs = list_length(scanjoin_targets) == 1
+				&& equal(scanjoin_target->exprs, current_rel->reltarget->exprs);
+			apply_scanjoin_target_to_paths(root, current_rel, scanjoin_targets,
+										   scanjoin_targets_contain_srfs,
+										   scanjoin_target_parallel_safe,
+										   scanjoin_target_same_exprs);
+		}
 
 		/*
 		 * Save the various upper-rel PathTargets we just computed into
@@ -2136,93 +2187,119 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 	final_rel->useridiscurrent = current_rel->useridiscurrent;
 	final_rel->fdwroutine = current_rel->fdwroutine;
 
-	/*
-	 * Generate paths for the final_rel.  Insert all surviving paths, with
-	 * LockRows, Limit, and/or ModifyTable steps added if needed.
-	 */
-	foreach(lc, current_rel->pathlist)
+	if (current_rel->reloptkind == RELOPT_BASEREL &&
+		current_rel->relid == root->parse->resultRelation &&
+		current_rel->part_scheme &&
+		parse->commandType != CMD_INSERT)
 	{
-		Path	   *path = (Path *) lfirst(lc);
-
-		/*
-		 * If there is a FOR [KEY] UPDATE/SHARE clause, add the LockRows node.
-		 * (Note: we intentionally test parse->rowMarks not root->rowMarks
-		 * here.  If there are only non-locking rowmarks, they should be
-		 * handled by the ModifyTable node instead.  However, root->rowMarks
-		 * is what goes into the LockRows node.)
-		 */
-		if (parse->rowMarks)
-		{
-			path = (Path *) create_lockrows_path(root, final_rel, path,
-												 root->rowMarks,
-												 SS_assign_special_param(root));
-		}
-
-		/*
-		 * If there is a LIMIT/OFFSET clause, add the LIMIT node.
-		 */
-		if (limit_needed(parse))
-		{
-			path = (Path *) create_limit_path(root, final_rel, path,
-											  parse->limitOffset,
-											  parse->limitCount,
-											  offset_est, count_est);
-		}
-
-		/*
-		 * If this is an INSERT/UPDATE/DELETE, and we're not being called from
-		 * inheritance_planner, add the ModifyTable node.
-		 */
-		if (parse->commandType != CMD_SELECT && !inheritance_update)
-		{
-			List	   *withCheckOptionLists;
-			List	   *returningLists;
-			List	   *rowMarks;
-
-			/*
-			 * Set up the WITH CHECK OPTION and RETURNING lists-of-lists, if
-			 * needed.
-			 */
-			if (parse->withCheckOptions)
-				withCheckOptionLists = list_make1(parse->withCheckOptions);
-			else
-				withCheckOptionLists = NIL;
-
-			if (parse->returningList)
-				returningLists = list_make1(parse->returningList);
-			else
-				returningLists = NIL;
-
-			/*
-			 * If there was a FOR [KEY] UPDATE/SHARE clause, the LockRows node
-			 * will have dealt with fetching non-locked marked rows, else we
-			 * need to have ModifyTable do that.
-			 */
-			if (parse->rowMarks)
-				rowMarks = NIL;
-			else
-				rowMarks = root->rowMarks;
-
-			path = (Path *)
+		Path *path = (Path *)
 				create_modifytable_path(root, final_rel,
 										parse->commandType,
 										parse->canSetTag,
 										parse->resultRelation,
-										NIL,
-										false,
-										list_make1_int(parse->resultRelation),
-										list_make1(path),
-										list_make1(root),
-										withCheckOptionLists,
-										returningLists,
-										rowMarks,
-										parse->onConflict,
+										partitioned_rels,
+										root->partColsUpdated,
+										partition_resultRelations,
+										partition_subpaths,
+										partition_subroots,
+										partition_WCOLists,
+										partition_returningLists,
+										partition_rowMarks,
+										NULL,
 										SS_assign_special_param(root));
-		}
-
-		/* And shove it into final_rel */
 		add_path(final_rel, path);
 	}
+	else
+	{
+		/*
+		 * Generate paths for the final_rel.  Insert all surviving paths, with
+		 * LockRows, Limit, and/or ModifyTable steps added if needed.
+		 */
+		foreach(lc, current_rel->pathlist)
+		{
+			Path	   *path = (Path *) lfirst(lc);
+
+			/*
+			 * If there is a FOR [KEY] UPDATE/SHARE clause, add the LockRows
+			 * node. (Note: we intentionally test parse->rowMarks not
+			 * root->rowMarks here.  If there are only non-locking rowmarks,
+			 * they should be handled by the ModifyTable node instead.
+			 * However, root->rowMarks is what goes into the LockRows node.)
+			 */
+			if (parse->rowMarks)
+			{
+				path = (Path *)
+							create_lockrows_path(root, final_rel, path,
+												 root->rowMarks,
+												 SS_assign_special_param(root));
+			}
+
+			/*
+			 * If there is a LIMIT/OFFSET clause, add the LIMIT node.
+			 */
+			if (limit_needed(parse))
+			{
+				path = (Path *) create_limit_path(root, final_rel, path,
+												  parse->limitOffset,
+												  parse->limitCount,
+												  offset_est, count_est);
+			}
+
+			/*
+			 * If this is an INSERT/UPDATE/DELETE, and we're not being called
+			 * from inheritance_planner, add the ModifyTable node.
+			 */
+			if (parse->commandType != CMD_SELECT && !inheritance_update)
+			{
+				List	   *withCheckOptionLists;
+				List	   *returningLists;
+				List	   *rowMarks;
+
+				/*
+				 * Set up the WITH CHECK OPTION and RETURNING lists-of-lists,
+				 * if needed.
+				 */
+				if (parse->withCheckOptions)
+					withCheckOptionLists = list_make1(parse->withCheckOptions);
+				else
+					withCheckOptionLists = NIL;
+
+				if (parse->returningList)
+					returningLists = list_make1(parse->returningList);
+				else
+					returningLists = NIL;
+
+				/*
+				 * If there was a FOR [KEY] UPDATE/SHARE clause, the LockRows
+				 * node will have dealt with fetching non-locked marked rows,
+				 * else we need to have ModifyTable do that.
+				 */
+				if (parse->rowMarks)
+					rowMarks = NIL;
+				else
+					rowMarks = root->rowMarks;
+
+				path = (Path *)
+					create_modifytable_path(root, final_rel,
+											parse->commandType,
+											parse->canSetTag,
+											parse->resultRelation,
+											NIL,
+											false,
+											list_make1_int(parse->resultRelation),
+											list_make1(path),
+											list_make1(root),
+											withCheckOptionLists,
+											returningLists,
+											rowMarks,
+											parse->onConflict,
+											SS_assign_special_param(root));
+			}
+
+			/* And shove it into final_rel */
+			add_path(final_rel, path);
+		}
+	}
 
 	/*
 	 * Generate partial paths for final_rel, too, if outer query levels might
@@ -2259,6 +2336,129 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 }
 
 /*
+ * partitionwise_adjust_scanjoin_target
+ *		adjusts query's targetlist for each partition in the partition tree
+ *		whose root is 'parent' and apply it to their paths via
+ *		apply_scanjoin_target_to_paths
+ *
+ * Its output also consists of various pieces of information that will go
+ * into the ModifyTable node that will be created for this query.
+ */
+static void
+partitionwise_adjust_scanjoin_target(PlannerInfo *root,
+									 RelOptInfo *parent,
+									 List **subroots,
+									 List **partitioned_rels,
+									 List **resultRelations,
+									 List **subpaths,
+									 List **WCOLists,
+									 List **returningLists,
+									 List **rowMarks)
+{
+	Query  *parse = root->parse;
+	int		i;
+
+	*partitioned_rels = lappend(*partitioned_rels,
+								list_make1_int(parent->relid));
+
+	for (i = 0; i < parent->nparts; i++)
+	{
+		RelOptInfo *child_rel = parent->part_rels[i];
+		AppendRelInfo *appinfo;
+		int			relid;
+		List	   *tlist;
+		PathTarget *scanjoin_target;
+		bool		scanjoin_target_parallel_safe;
+		bool		scanjoin_target_same_exprs;
+		PlannerInfo *partition_subroot;
+		Query	   *partition_parse;
+
+		/* Ignore pruned partitions. */
+		if (IS_DUMMY_REL(child_rel))
+			continue;
+
+		/*
+		 * Extract the original relid of partition to fetch its AppendRelInfo.
+		 * We must find it like this, because
+		 * partitionwise_make_rel_from_joinlist replaces the original rel
+		 * with one generated by join planning which may be different.
+		 */
+		relid = -1;
+		while ((relid = bms_next_member(child_rel->relids, relid)) > 0)
+			if (root->append_rel_array[relid] &&
+				root->append_rel_array[relid]->parent_relid ==
+				parent->relid)
+				break;
+
+		appinfo = root->append_rel_array[relid];
+
+		/* Translate Query structure for this partition. */
+		partition_parse = (Query *)
+						adjust_appendrel_attrs(root,
+											   (Node *) parse,
+											   1, &appinfo);
+
+		/* Recurse if partition is itself a partitioned table. */
+		if (child_rel->part_scheme)
+		{
+			root->parse = partition_parse;
+			partitionwise_adjust_scanjoin_target(root, child_rel,
+												 subroots,
+												 partitioned_rels,
+												 resultRelations,
+												 subpaths,
+												 WCOLists,
+												 returningLists,
+												 rowMarks);
+			/* Restore the Query for processing the next partition. */
+			root->parse = parse;
+		}
+		else
+		{
+			/*
+			 * Generate a separate PlannerInfo for this partition.  We'll need
+			 * it when generating the ModifyTable subplan for this partition.
+			 */
+			partition_subroot = makeNode(PlannerInfo);
+			*subroots = lappend(*subroots, partition_subroot);
+			memcpy(partition_subroot, root, sizeof(PlannerInfo));
+			partition_subroot->parse = partition_parse;
+
+			/*
+			 * Preprocess the translated targetlist and save it in the
+			 * partition's PlannerInfo for the perusal of later planning
+			 * steps.
+			 */
+			tlist = preprocess_targetlist(partition_subroot);
+			partition_subroot->processed_tlist = tlist;
+
+			/* Apply scan/join target. */
+			scanjoin_target = create_pathtarget(root, tlist);
+			scanjoin_target_same_exprs = equal(scanjoin_target->exprs,
+											   child_rel->reltarget->exprs);
+			scanjoin_target_parallel_safe =
+				is_parallel_safe(root, (Node *) scanjoin_target->exprs);
+			apply_scanjoin_target_to_paths(root, child_rel,
+										   list_make1(scanjoin_target),
+										   NIL,
+										   scanjoin_target_parallel_safe,
+										   scanjoin_target_same_exprs);
+
+			/* Collect information that will go into the ModifyTable */
+			*resultRelations = lappend_int(*resultRelations, relid);
+			*subpaths = lappend(*subpaths, child_rel->cheapest_total_path);
+			if (partition_parse->withCheckOptions)
+				*WCOLists = lappend(*WCOLists, partition_parse->withCheckOptions);
+			if (partition_parse->returningList)
+				*returningLists = lappend(*returningLists,
+										  partition_parse->returningList);
+			if (partition_parse->rowMarks)
+				*rowMarks = lappend(*rowMarks, partition_parse->rowMarks);
+		}
+	}
+}
+
+/*
  * Do preprocessing for groupingSets clause and related data.  This handles the
  * preliminary steps of expanding the grouping sets, organizing them into lists
  * of rollups, and preparing annotations which will later be filled in with
@@ -6964,7 +7164,9 @@ apply_scanjoin_target_to_paths(PlannerInfo *root,
 		}
 
 		/* Build new paths for this relation by appending child paths. */
-		if (live_children != NIL)
+		if (live_children != NIL &&
+			!(rel->reloptkind == RELOPT_BASEREL &&
+			  rel->relid == root->parse->resultRelation))
 			add_paths_to_append_rel(root, rel, live_children);
 	}
 
diff --git a/src/backend/optimizer/prep/prepunion.c b/src/backend/optimizer/prep/prepunion.c
index 690b6bbab7..f4c485cdc9 100644
--- a/src/backend/optimizer/prep/prepunion.c
+++ b/src/backend/optimizer/prep/prepunion.c
@@ -2265,8 +2265,34 @@ adjust_appendrel_attrs_mutator(Node *node,
 											  context->appinfos);
 		return (Node *) phv;
 	}
+
+	if (IsA(node, SpecialJoinInfo))
+	{
+		SpecialJoinInfo *oldinfo = (SpecialJoinInfo *) node;
+		SpecialJoinInfo *newinfo = makeNode(SpecialJoinInfo);
+
+		memcpy(newinfo, oldinfo, sizeof(SpecialJoinInfo));
+		newinfo->min_lefthand = adjust_child_relids(oldinfo->min_lefthand,
+													context->nappinfos,
+													context->appinfos);
+		newinfo->min_righthand = adjust_child_relids(oldinfo->min_righthand,
+													 context->nappinfos,
+													 context->appinfos);
+		newinfo->syn_lefthand = adjust_child_relids(oldinfo->syn_lefthand,
+													context->nappinfos,
+													context->appinfos);
+		newinfo->syn_righthand = adjust_child_relids(oldinfo->syn_righthand,
+													 context->nappinfos,
+													 context->appinfos);
+		newinfo->semi_rhs_exprs =
+					(List *) expression_tree_mutator((Node *)
+													 oldinfo->semi_rhs_exprs,
+													 adjust_appendrel_attrs_mutator,
+													 (void *) context);
+		return (Node *) newinfo;
+	}
+
 	/* 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));
diff --git a/src/backend/optimizer/util/plancat.c b/src/backend/optimizer/util/plancat.c
index 8369e3ad62..8d67f21f42 100644
--- a/src/backend/optimizer/util/plancat.c
+++ b/src/backend/optimizer/util/plancat.c
@@ -1265,36 +1265,6 @@ get_relation_constraints(PlannerInfo *root,
 		}
 	}
 
-	/*
-	 * Append partition predicates, if any.
-	 *
-	 * For selects, partition pruning uses the parent table's partition bound
-	 * descriptor, instead of constraint exclusion which is driven by the
-	 * individual partition's partition constraint.
-	 */
-	if (enable_partition_pruning && root->parse->commandType != CMD_SELECT)
-	{
-		List	   *pcqual = RelationGetPartitionQual(relation);
-
-		if (pcqual)
-		{
-			/*
-			 * Run the partition quals through const-simplification similar to
-			 * check constraints.  We skip canonicalize_qual, though, because
-			 * partition quals should be in canonical form already; also,
-			 * since the qual is in implicit-AND format, we'd have to
-			 * explicitly convert it to explicit-AND format and back again.
-			 */
-			pcqual = (List *) eval_const_expressions(root, (Node *) pcqual);
-
-			/* Fix Vars to have the desired varno */
-			if (varno != 1)
-				ChangeVarNodes((Node *) pcqual, 1, varno, 0);
-
-			result = list_concat(result, pcqual);
-		}
-	}
-
 	heap_close(relation, NoLock);
 
 	return result;
diff --git a/src/test/regress/expected/partition_join.out b/src/test/regress/expected/partition_join.out
index 7d04d12c6e..9074182512 100644
--- a/src/test/regress/expected/partition_join.out
+++ b/src/test/regress/expected/partition_join.out
@@ -1752,7 +1752,7 @@ WHERE EXISTS (
                Filter: (c IS NULL)
          ->  Nested Loop
                ->  Seq Scan on int4_tbl
-               ->  Subquery Scan on ss_1
+               ->  Subquery Scan on ss
                      ->  Limit
                            ->  Seq Scan on int8_tbl int8_tbl_1
    ->  Nested Loop Semi Join
@@ -1760,7 +1760,7 @@ WHERE EXISTS (
                Filter: (c IS NULL)
          ->  Nested Loop
                ->  Seq Scan on int4_tbl
-               ->  Subquery Scan on ss_2
+               ->  Subquery Scan on ss
                      ->  Limit
                            ->  Seq Scan on int8_tbl int8_tbl_2
 (28 rows)
-- 
2.11.0

From 023ce5b76136c3a53bbf6401599d40362b2de719 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Wed, 16 May 2018 14:35:40 +0900
Subject: [PATCH v2 2/3] Lazy creation of partition objects for planning

With the current approach, *all* partitions are opened and range
table entries are created for them in the planner's prep phase, which
is much sooner than when partition pruning is performed.  This means
that query_planner ends up spending cycles and memory on many
partitions that potentially won't be included in the plan, such
as creating RelOptInfos, AppendRelInfos.

To avoid that, add partition range table entries and other planning
data structures for only partitions that remain after applying
partition pruning.

Some code like that of partitionwise join rely on the fact that even
though partitions may have been pruned, they would still have a
RelOptInfo, albeit marked dummy to handle the outer join case where
the pruned partition appears on the nullable side of join.  So this
commit also teaches the partitionwise join code to allocate dummy
RelOptInfos for pruned partitions.

There are couple of regression test diffs caused by the fact that
we no longer allocate a duplicate RT entry for a partitioned table
in its role as child and also that the individual partition RT
entries are now created in the order in which their parent's are
processed whereas previously they'd be added to the range table
in the order of depth-first expansion of the tree.
---
 src/backend/optimizer/path/allpaths.c             |  65 +++--
 src/backend/optimizer/path/joinrels.c             |   8 +
 src/backend/optimizer/plan/initsplan.c            |  66 +++++
 src/backend/optimizer/plan/planmain.c             |  30 ---
 src/backend/optimizer/plan/planner.c              |  19 +-
 src/backend/optimizer/prep/prepunion.c            | 314 +++++++++-------------
 src/backend/optimizer/util/plancat.c              |  16 +-
 src/backend/optimizer/util/relnode.c              | 172 ++++++++++--
 src/backend/partitioning/partprune.c              | 109 ++++----
 src/include/nodes/relation.h                      |   5 +
 src/include/optimizer/pathnode.h                  |   6 +
 src/include/optimizer/plancat.h                   |   2 +-
 src/include/optimizer/planmain.h                  |   3 +
 src/include/optimizer/prep.h                      |  10 +
 src/include/partitioning/partprune.h              |   2 +-
 src/test/regress/expected/join.out                |  22 +-
 src/test/regress/expected/partition_aggregate.out |   4 +-
 17 files changed, 507 insertions(+), 346 deletions(-)

diff --git a/src/backend/optimizer/path/allpaths.c b/src/backend/optimizer/path/allpaths.c
index 5937c0436a..9abaab25fa 100644
--- a/src/backend/optimizer/path/allpaths.c
+++ b/src/backend/optimizer/path/allpaths.c
@@ -151,6 +151,7 @@ make_one_rel(PlannerInfo *root, List *joinlist)
 {
 	RelOptInfo *rel;
 	Index		rti;
+	double		total_pages;
 
 	/*
 	 * Construct the all_baserels Relids set.
@@ -181,6 +182,35 @@ make_one_rel(PlannerInfo *root, List *joinlist)
 	 * then generate access paths.
 	 */
 	set_base_rel_sizes(root);
+
+	/*
+	 * We should now have size estimates for every actual table involved in
+	 * the query, and we also know which if any have been deleted from the
+	 * query by join removal; so we can compute total_table_pages.
+	 *
+	 * Note that appendrels are not double-counted here, even though we don't
+	 * bother to distinguish RelOptInfos for appendrel parents, because the
+	 * parents will still have size zero.
+	 *
+	 * XXX if a table is self-joined, we will count it once per appearance,
+	 * which perhaps is the wrong thing ... but that's not completely clear,
+	 * and detecting self-joins here is difficult, so ignore it for now.
+	 */
+	total_pages = 0;
+	for (rti = 1; rti < root->simple_rel_array_size; rti++)
+	{
+		RelOptInfo *brel = root->simple_rel_array[rti];
+
+		if (brel == NULL)
+			continue;
+
+		Assert(brel->relid == rti); /* sanity check on array */
+
+		if (IS_SIMPLE_REL(brel))
+			total_pages += (double) brel->pages;
+	}
+	root->total_table_pages = total_pages;
+
 	set_base_rel_pathlists(root);
 
 	/*
@@ -896,8 +926,6 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 	double	   *parent_attrsizes;
 	int			nattrs;
 	ListCell   *l;
-	Relids		live_children = NULL;
-	bool		did_pruning = false;
 
 	/* Guard against stack overflow due to overly deep inheritance tree. */
 	check_stack_depth();
@@ -913,21 +941,14 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 	 * partitioned table's list will contain all such indexes.
 	 */
 	if (rte->relkind == RELKIND_PARTITIONED_TABLE)
+	{
 		rel->partitioned_child_rels = list_make1_int(rti);
 
-	/*
-	 * If the partitioned relation has any baserestrictinfo quals then we
-	 * attempt to use these quals to prune away partitions that cannot
-	 * possibly contain any tuples matching these quals.  In this case we'll
-	 * store the relids of all partitions which could possibly contain a
-	 * matching tuple, and skip anything else in the loop below.
-	 */
-	if (enable_partition_pruning &&
-		rte->relkind == RELKIND_PARTITIONED_TABLE &&
-		rel->baserestrictinfo != NIL)
-	{
-		live_children = prune_append_rel_partitions(rel);
-		did_pruning = true;
+		/*
+		 * And do prunin.  Note that this adds AppendRelInfo's of only the
+		 * partitions that are not pruned.
+		 */
+		prune_append_rel_partitions(root, rel);
 	}
 
 	/*
@@ -1178,13 +1199,6 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 			continue;
 		}
 
-		if (did_pruning && !bms_is_member(appinfo->child_relid, live_children))
-		{
-			/* This partition was pruned; skip it. */
-			set_dummy_rel_pathlist(childrel);
-			continue;
-		}
-
 		if (relation_excluded_by_constraints(root, childrel, childRTE))
 		{
 			/*
@@ -2629,16 +2643,15 @@ partitionwise_make_rel_from_joinlist(PlannerInfo *root,
 	Assert(root->parse->resultRelation != 0);
 	Assert(parent->part_scheme != NULL);
 
-	for (i = 0; i < parent->nparts; i++)
+	i = -1;
+	while ((i = bms_next_member(parent->live_parts, i)) >= 0)
 	{
 		RelOptInfo *partrel = parent->part_rels[i];
 		AppendRelInfo *appinfo;
 		List	   *translated_joinlist;
 		List	   *saved_join_info_list = list_copy(root->join_info_list);
 
-		/* Ignore pruned partitions. */
-		if (IS_DUMMY_REL(partrel))
-			continue;
+		Assert (partrel != NULL);
 
 		/*
 		 * Hack to make the join planning code believe that 'partrel' can
diff --git a/src/backend/optimizer/path/joinrels.c b/src/backend/optimizer/path/joinrels.c
index 7008e1318e..8542b95f4b 100644
--- a/src/backend/optimizer/path/joinrels.c
+++ b/src/backend/optimizer/path/joinrels.c
@@ -1369,6 +1369,11 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
 		AppendRelInfo **appinfos;
 		int			nappinfos;
 
+		if (child_rel1 == NULL)
+			child_rel1 = build_dummy_partition_rel(root, rel1, cnt_parts);
+		if (child_rel2 == NULL)
+			child_rel2 = build_dummy_partition_rel(root, rel2, cnt_parts);
+
 		/* We should never try to join two overlapping sets of rels. */
 		Assert(!bms_overlap(child_rel1->relids, child_rel2->relids));
 		child_joinrelids = bms_union(child_rel1->relids, child_rel2->relids);
@@ -1407,6 +1412,9 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
 		populate_joinrel_with_paths(root, child_rel1, child_rel2,
 									child_joinrel, child_sjinfo,
 									child_restrictlist);
+		if (!IS_DUMMY_REL(child_joinrel))
+			joinrel->live_parts = bms_add_member(joinrel->live_parts,
+												 cnt_parts);
 	}
 }
 
diff --git a/src/backend/optimizer/plan/initsplan.c b/src/backend/optimizer/plan/initsplan.c
index 01335db511..beb3e95101 100644
--- a/src/backend/optimizer/plan/initsplan.c
+++ b/src/backend/optimizer/plan/initsplan.c
@@ -132,6 +132,72 @@ add_base_rels_to_query(PlannerInfo *root, Node *jtnode)
 			 (int) nodeTag(jtnode));
 }
 
+/*
+ * add_rel_partitions_to_query
+ *		create range table entries and "otherrel" RelOptInfos and for the
+ *		partitions of 'rel' specified by the caller
+ *
+ * To store the objects thus created, various arrays in 'root' are expanded
+ * by repalloc'ing them.
+ */
+void
+add_rel_partitions_to_query(PlannerInfo *root, RelOptInfo *rel,
+							bool scan_all_parts,
+							Bitmapset *partindexes)
+{
+	int		new_size;
+	int		num_added_parts;
+	int		i;
+
+	Assert(partindexes != NULL || scan_all_parts);
+
+	/* Expand the PlannerInfo arrays to hold new partition objects. */
+	num_added_parts = scan_all_parts ? rel->nparts :
+						bms_num_members(partindexes);
+	new_size = root->simple_rel_array_size + num_added_parts;
+	root->simple_rte_array = (RangeTblEntry **)
+							repalloc(root->simple_rte_array,
+									 sizeof(RangeTblEntry *) * new_size);
+	root->simple_rel_array = (RelOptInfo **)
+								repalloc(root->simple_rel_array,
+										 sizeof(RelOptInfo *) * new_size);
+	if (root->append_rel_array)
+		root->append_rel_array = (AppendRelInfo **)
+									repalloc(root->append_rel_array,
+									 sizeof(AppendRelInfo *) * new_size);
+	else
+		root->append_rel_array = (AppendRelInfo **)
+									palloc0(sizeof(AppendRelInfo *) *
+											new_size);
+
+	/* Set the contents of just allocated memory to 0. */
+	MemSet(root->simple_rte_array + root->simple_rel_array_size,
+		   0, sizeof(RangeTblEntry *) * num_added_parts);
+	MemSet(root->simple_rel_array + root->simple_rel_array_size,
+		   0, sizeof(RelOptInfo *) * num_added_parts);
+	MemSet(root->append_rel_array + root->simple_rel_array_size,
+		   0, sizeof(AppendRelInfo *) * num_added_parts);
+	root->simple_rel_array_size = new_size;
+
+	/* And add the partitions. */
+	if (scan_all_parts)
+	{
+		for (i = 0; i < rel->nparts; i++)
+		{
+			rel->part_rels[i] = build_partition_rel(root, rel,
+													rel->part_oids[i]);
+			rel->live_parts = bms_add_member(rel->live_parts, i);
+		}
+	}
+	else
+	{
+		rel->live_parts = partindexes;
+		i = -1;
+		while ((i = bms_next_member(partindexes, i)) >= 0)
+			rel->part_rels[i] = build_partition_rel(root, rel,
+													rel->part_oids[i]);
+	}
+}
 
 /*****************************************************************************
  *
diff --git a/src/backend/optimizer/plan/planmain.c b/src/backend/optimizer/plan/planmain.c
index 3f0d80eaa6..1bd3f0e350 100644
--- a/src/backend/optimizer/plan/planmain.c
+++ b/src/backend/optimizer/plan/planmain.c
@@ -57,8 +57,6 @@ query_planner(PlannerInfo *root, List *tlist,
 	Query	   *parse = root->parse;
 	List	   *joinlist;
 	RelOptInfo *final_rel;
-	Index		rti;
-	double		total_pages;
 
 	/*
 	 * If the query has an empty join tree, then it's something easy like
@@ -232,34 +230,6 @@ query_planner(PlannerInfo *root, List *tlist,
 	extract_restriction_or_clauses(root);
 
 	/*
-	 * We should now have size estimates for every actual table involved in
-	 * the query, and we also know which if any have been deleted from the
-	 * query by join removal; so we can compute total_table_pages.
-	 *
-	 * Note that appendrels are not double-counted here, even though we don't
-	 * bother to distinguish RelOptInfos for appendrel parents, because the
-	 * parents will still have size zero.
-	 *
-	 * XXX if a table is self-joined, we will count it once per appearance,
-	 * which perhaps is the wrong thing ... but that's not completely clear,
-	 * and detecting self-joins here is difficult, so ignore it for now.
-	 */
-	total_pages = 0;
-	for (rti = 1; rti < root->simple_rel_array_size; rti++)
-	{
-		RelOptInfo *brel = root->simple_rel_array[rti];
-
-		if (brel == NULL)
-			continue;
-
-		Assert(brel->relid == rti); /* sanity check on array */
-
-		if (IS_SIMPLE_REL(brel))
-			total_pages += (double) brel->pages;
-	}
-	root->total_table_pages = total_pages;
-
-	/*
 	 * Ready to do the primary planning.
 	 */
 	final_rel = make_one_rel(root, joinlist);
diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index 076dbd3d62..cce6757115 100644
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -2361,7 +2361,8 @@ partitionwise_adjust_scanjoin_target(PlannerInfo *root,
 	*partitioned_rels = lappend(*partitioned_rels,
 								list_make1_int(parent->relid));
 
-	for (i = 0; i < parent->nparts; i++)
+	i = -1;
+	while ((i = bms_next_member(parent->live_parts, i)) >= 0)
 	{
 		RelOptInfo *child_rel = parent->part_rels[i];
 		AppendRelInfo *appinfo;
@@ -2373,9 +2374,7 @@ partitionwise_adjust_scanjoin_target(PlannerInfo *root,
 		PlannerInfo *partition_subroot;
 		Query	   *partition_parse;
 
-		/* Ignore pruned partitions. */
-		if (IS_DUMMY_REL(child_rel))
-			continue;
+		Assert (child_rel != NULL);
 
 		/*
 		 * Extract the original relid of partition to fetch its AppendRelInfo.
@@ -7122,18 +7121,21 @@ apply_scanjoin_target_to_paths(PlannerInfo *root,
 	 */
 	if (rel->part_scheme && rel->part_rels)
 	{
-		int			partition_idx;
+		int			i;
 		List	   *live_children = NIL;
 
 		/* Adjust each partition. */
-		for (partition_idx = 0; partition_idx < rel->nparts; partition_idx++)
+		i = -1;
+		while ((i = bms_next_member(rel->live_parts, i)) >= 0)
 		{
-			RelOptInfo *child_rel = rel->part_rels[partition_idx];
+			RelOptInfo *child_rel = rel->part_rels[i];
 			ListCell   *lc;
 			AppendRelInfo **appinfos;
 			int			nappinfos;
 			List	   *child_scanjoin_targets = NIL;
 
+			Assert(child_rel != NULL);
+
 			/* Translate scan/join targets for this child. */
 			appinfos = find_appinfos_by_relids(root, child_rel->relids,
 											   &nappinfos);
@@ -7237,6 +7239,9 @@ create_partitionwise_grouping_paths(PlannerInfo *root,
 		RelOptInfo *child_grouped_rel;
 		RelOptInfo *child_partially_grouped_rel;
 
+		if (child_input_rel == NULL)
+			continue;
+
 		/* Input child rel must have a path */
 		Assert(child_input_rel->pathlist != NIL);
 
diff --git a/src/backend/optimizer/prep/prepunion.c b/src/backend/optimizer/prep/prepunion.c
index f4c485cdc9..279f686fb0 100644
--- a/src/backend/optimizer/prep/prepunion.c
+++ b/src/backend/optimizer/prep/prepunion.c
@@ -49,6 +49,8 @@
 #include "parser/parse_coerce.h"
 #include "parser/parsetree.h"
 #include "utils/lsyscache.h"
+#include "utils/lsyscache.h"
+#include "utils/partcache.h"
 #include "utils/rel.h"
 #include "utils/selfuncs.h"
 #include "utils/syscache.h"
@@ -101,21 +103,10 @@ static List *generate_append_tlist(List *colTypes, List *colCollations,
 static List *generate_setop_grouplist(SetOperationStmt *op, List *targetlist);
 static void expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte,
 						 Index rti);
-static void expand_partitioned_rtentry(PlannerInfo *root,
-						   RangeTblEntry *parentrte,
-						   Index parentRTindex, Relation parentrel,
-						   PlanRowMark *top_parentrc, LOCKMODE lockmode,
-						   List **appinfos);
-static void expand_single_inheritance_child(PlannerInfo *root,
-								RangeTblEntry *parentrte,
-								Index parentRTindex, Relation parentrel,
-								PlanRowMark *top_parentrc, Relation childrel,
-								List **appinfos, RangeTblEntry **childrte_p,
-								Index *childRTindex_p);
-static void make_inh_translation_list(Relation oldrelation,
-						  Relation newrelation,
-						  Index newvarno,
-						  List **translated_vars);
+static void make_inh_translation_list(TupleDesc old_tupdesc,
+						  TupleDesc new_tupdesc,
+						  RangeTblEntry *oldrte, RangeTblEntry *newrte,
+						  Index newvarno, List **translated_vars);
 static Bitmapset *translate_col_privs(const Bitmapset *parent_privs,
 					List *translated_vars);
 static Node *adjust_appendrel_attrs_mutator(Node *node,
@@ -1522,6 +1513,7 @@ expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti)
 	LOCKMODE	lockmode;
 	List	   *inhOIDs;
 	ListCell   *l;
+	List	   *appinfos = NIL;
 
 	/* Does RT entry allow inheritance? */
 	if (!rte->inh)
@@ -1585,173 +1577,58 @@ expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti)
 	if (oldrc)
 		oldrc->isParent = true;
 
+	/* Partitioned tables are expanded elsewhere. */
+	if (rte->relkind == RELKIND_PARTITIONED_TABLE)
+	{
+		list_free(inhOIDs);
+		return;
+	}
+
 	/*
 	 * Must open the parent relation to examine its tupdesc.  We need not lock
 	 * it; we assume the rewriter already did.
 	 */
 	oldrelation = heap_open(parentOID, NoLock);
 
-	/* Scan the inheritance set and expand it */
-	if (RelationGetPartitionDesc(oldrelation) != NULL)
+	foreach(l, inhOIDs)
 	{
-		Assert(rte->relkind == RELKIND_PARTITIONED_TABLE);
+		Oid			childOID = lfirst_oid(l);
+		Index		childRTindex = 0;
+		RangeTblEntry *childrte = NULL;
+		AppendRelInfo *appinfo = NULL;
 
-		/*
-		 * If this table has partitions, recursively expand them in the order
-		 * in which they appear in the PartitionDesc.  While at it, also
-		 * extract the partition key columns of all the partitioned tables.
-		 */
-		expand_partitioned_rtentry(root, rte, rti, oldrelation, oldrc,
-								   lockmode, &root->append_rel_list);
+		add_inheritance_child_to_query(root, rte, rti,
+									   oldrelation->rd_rel->reltype,
+									   RelationGetDescr(oldrelation),
+									   oldrc, childOID, NoLock,
+									   &appinfo, &childrte,
+									   &childRTindex);
+		Assert(childRTindex > 1);
+		Assert(childrte != NULL);
+		Assert(appinfo != NULL);
+		appinfos = lappend(appinfos, appinfo);
 	}
+
+	/*
+	 * If all the children were temp tables, pretend it's a
+	 * non-inheritance situation; we don't need Append node in that case.
+	 * The duplicate RTE we added for the parent table is harmless, so we
+	 * don't bother to get rid of it; ditto for the useless PlanRowMark
+	 * node.
+	 */
+	if (list_length(appinfos) < 2)
+		rte->inh = false;
 	else
-	{
-		List	   *appinfos = NIL;
-		RangeTblEntry *childrte;
-		Index		childRTindex;
-
-		/*
-		 * This table has no partitions.  Expand any plain inheritance
-		 * children in the order the OIDs were returned by
-		 * find_all_inheritors.
-		 */
-		foreach(l, inhOIDs)
-		{
-			Oid			childOID = lfirst_oid(l);
-			Relation	newrelation;
-
-			/* Open rel if needed; we already have required locks */
-			if (childOID != parentOID)
-				newrelation = heap_open(childOID, NoLock);
-			else
-				newrelation = oldrelation;
-
-			/*
-			 * It is possible that the parent table has children that are temp
-			 * tables of other backends.  We cannot safely access such tables
-			 * (because of buffering issues), and the best thing to do seems
-			 * to be to silently ignore them.
-			 */
-			if (childOID != parentOID && RELATION_IS_OTHER_TEMP(newrelation))
-			{
-				heap_close(newrelation, lockmode);
-				continue;
-			}
-
-			expand_single_inheritance_child(root, rte, rti, oldrelation, oldrc,
-											newrelation,
-											&appinfos, &childrte,
-											&childRTindex);
-
-			/* Close child relations, but keep locks */
-			if (childOID != parentOID)
-				heap_close(newrelation, NoLock);
-		}
-
-		/*
-		 * If all the children were temp tables, pretend it's a
-		 * non-inheritance situation; we don't need Append node in that case.
-		 * The duplicate RTE we added for the parent table is harmless, so we
-		 * don't bother to get rid of it; ditto for the useless PlanRowMark
-		 * node.
-		 */
-		if (list_length(appinfos) < 2)
-			rte->inh = false;
-		else
-			root->append_rel_list = list_concat(root->append_rel_list,
-												appinfos);
-
-	}
+		root->append_rel_list = list_concat(root->append_rel_list,
+											appinfos);
 
 	heap_close(oldrelation, NoLock);
 }
 
 /*
- * expand_partitioned_rtentry
- *		Recursively expand an RTE for a partitioned table.
- *
- * Note that RelationGetPartitionDispatchInfo will expand partitions in the
- * same order as this code.
- */
-static void
-expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
-						   Index parentRTindex, Relation parentrel,
-						   PlanRowMark *top_parentrc, LOCKMODE lockmode,
-						   List **appinfos)
-{
-	int			i;
-	RangeTblEntry *childrte;
-	Index		childRTindex;
-	PartitionDesc partdesc = RelationGetPartitionDesc(parentrel);
-
-	check_stack_depth();
-
-	/* A partitioned table should always have a partition descriptor. */
-	Assert(partdesc);
-
-	Assert(parentrte->inh);
-
-	/*
-	 * Note down whether any partition key cols are being updated. Though it's
-	 * the root partitioned table's updatedCols we are interested in, we
-	 * instead use parentrte to get the updatedCols. This is convenient
-	 * because parentrte already has the root partrel's updatedCols translated
-	 * to match the attribute ordering of parentrel.
-	 */
-	if (!root->partColsUpdated)
-		root->partColsUpdated =
-			has_partition_attrs(parentrel, parentrte->updatedCols, NULL);
-
-	/* First expand the partitioned table itself. */
-	expand_single_inheritance_child(root, parentrte, parentRTindex, parentrel,
-									top_parentrc, parentrel,
-									appinfos, &childrte, &childRTindex);
-
-	/*
-	 * If the partitioned table has no partitions, treat this as the
-	 * non-inheritance case.
-	 */
-	if (partdesc->nparts == 0)
-	{
-		parentrte->inh = false;
-		return;
-	}
-
-	for (i = 0; i < partdesc->nparts; i++)
-	{
-		Oid			childOID = partdesc->oids[i];
-		Relation	childrel;
-
-		/* Open rel; we already have required locks */
-		childrel = heap_open(childOID, NoLock);
-
-		/*
-		 * Temporary partitions belonging to other sessions should have been
-		 * disallowed at definition, but for paranoia's sake, let's double
-		 * check.
-		 */
-		if (RELATION_IS_OTHER_TEMP(childrel))
-			elog(ERROR, "temporary relation from another session found as partition");
-
-		expand_single_inheritance_child(root, parentrte, parentRTindex,
-										parentrel, top_parentrc, childrel,
-										appinfos, &childrte, &childRTindex);
-
-		/* If this child is itself partitioned, recurse */
-		if (childrel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
-			expand_partitioned_rtentry(root, childrte, childRTindex,
-									   childrel, top_parentrc, lockmode,
-									   appinfos);
-
-		/* Close child relation, but keep locks */
-		heap_close(childrel, NoLock);
-	}
-}
-
-/*
- * expand_single_inheritance_child
+ * add_inheritance_child_to_query
  *		Build a RangeTblEntry and an AppendRelInfo, if appropriate, plus
- *		maybe a PlanRowMark.
+ *		maybe a PlanRowMark for a child relation.
  *
  * We now expand the partition hierarchy level by level, creating a
  * corresponding hierarchy of AppendRelInfos and RelOptInfos, where each
@@ -1769,19 +1646,70 @@ expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
  * The child RangeTblEntry and its RTI are returned in "childrte_p" and
  * "childRTindex_p" resp.
  */
-static void
-expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte,
-								Index parentRTindex, Relation parentrel,
-								PlanRowMark *top_parentrc, Relation childrel,
-								List **appinfos, RangeTblEntry **childrte_p,
-								Index *childRTindex_p)
+void
+add_inheritance_child_to_query(PlannerInfo *root, RangeTblEntry *parentrte,
+							   Index parentRTindex, Oid parentRelType,
+							   TupleDesc parentDesc,
+							   PlanRowMark *top_parentrc,
+							   Oid childOID, int lockmode,
+							   AppendRelInfo **appinfo_p,
+							   RangeTblEntry **childrte_p,
+							   Index *childRTindex_p)
 {
 	Query	   *parse = root->parse;
-	Oid			parentOID = RelationGetRelid(parentrel);
-	Oid			childOID = RelationGetRelid(childrel);
+	Oid			parentOID = parentrte->relid;
 	RangeTblEntry *childrte;
 	Index		childRTindex;
 	AppendRelInfo *appinfo;
+	Relation	childrel = NULL;
+	char		child_relkind;
+	Oid			child_reltype;
+	TupleDesc	childDesc;
+
+	*appinfo_p = NULL;
+	*childrte_p = NULL;
+	*childRTindex_p = 0;
+
+	/* Open rel if needed; we already have required locks */
+	if (childOID != parentOID)
+	{
+		childrel = heap_open(childOID, lockmode);
+
+		/*
+		 * Temporary partitions belonging to other sessions should have been
+		 * disallowed at definition, but for paranoia's sake, let's double
+		 * check.
+		 */
+		if (RELATION_IS_OTHER_TEMP(childrel))
+		{
+			if (childrel->rd_rel->relispartition)
+				elog(ERROR, "temporary relation from another session found as partition");
+			heap_close(childrel, lockmode);
+			return;
+		}
+
+		child_relkind = childrel->rd_rel->relkind;
+
+		/*
+		 * No point in adding to the query a partitioned table that has no
+		 * partitions.
+		 */
+		if (child_relkind == RELKIND_PARTITIONED_TABLE &&
+			RelationGetPartitionDesc(childrel)->nparts == 0)
+		{
+			heap_close(childrel, lockmode);
+			return;
+		}
+
+		child_reltype = childrel->rd_rel->reltype;
+		childDesc = RelationGetDescr(childrel);
+	}
+	else
+	{
+		child_relkind = parentrte->relkind;
+		child_reltype =  parentRelType;
+		childDesc = parentDesc;
+	}
 
 	/*
 	 * Build an RTE for the child, and attach to query's rangetable list. We
@@ -1798,7 +1726,7 @@ expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte,
 	childrte = copyObject(parentrte);
 	*childrte_p = childrte;
 	childrte->relid = childOID;
-	childrte->relkind = childrel->rd_rel->relkind;
+	childrte->relkind = child_relkind;
 	/* A partitioned child will need to be expanded further. */
 	if (childOID != parentOID &&
 		childrte->relkind == RELKIND_PARTITIONED_TABLE)
@@ -1823,12 +1751,13 @@ expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte,
 		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->parent_reltype = parentRelType;
+		appinfo->child_reltype = child_reltype;
+		make_inh_translation_list(parentDesc, childDesc,
+								  parentrte, childrte, childRTindex,
 								  &appinfo->translated_vars);
 		appinfo->parent_reloid = parentOID;
-		*appinfos = lappend(*appinfos, appinfo);
+		*appinfo_p = appinfo;
 
 		/*
 		 * Translate the column permissions bitmaps to the child's attnums (we
@@ -1879,6 +1808,13 @@ expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte,
 
 		root->rowMarks = lappend(root->rowMarks, childrc);
 	}
+
+	/* Close child relations, but keep locks */
+	if (childOID != parentOID)
+	{
+		Assert(childrel != NULL);
+		heap_close(childrel, lockmode);
+	}
 }
 
 /*
@@ -1889,14 +1825,12 @@ expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte,
  * For paranoia's sake, we match type/collation as well as attribute name.
  */
 static void
-make_inh_translation_list(Relation oldrelation, Relation newrelation,
-						  Index newvarno,
-						  List **translated_vars)
+make_inh_translation_list(TupleDesc old_tupdesc, TupleDesc new_tupdesc,
+						  RangeTblEntry *oldrte, RangeTblEntry *newrte,
+						  Index newvarno, List **translated_vars)
 {
 	List	   *vars = NIL;
-	TupleDesc	old_tupdesc = RelationGetDescr(oldrelation);
-	TupleDesc	new_tupdesc = RelationGetDescr(newrelation);
-	Oid			new_relid = RelationGetRelid(newrelation);
+	Oid			new_relid = newrte->relid;
 	int			oldnatts = old_tupdesc->natts;
 	int			newnatts = new_tupdesc->natts;
 	int			old_attno;
@@ -1926,7 +1860,7 @@ make_inh_translation_list(Relation oldrelation, Relation newrelation,
 		 * When we are generating the "translation list" for the parent table
 		 * of an inheritance set, no need to search for matches.
 		 */
-		if (oldrelation == newrelation)
+		if (oldrte->relid == newrte->relid)
 		{
 			vars = lappend(vars, makeVar(newvarno,
 										 (AttrNumber) (old_attno + 1),
@@ -1955,7 +1889,7 @@ make_inh_translation_list(Relation oldrelation, Relation newrelation,
 			newtup = SearchSysCacheAttName(new_relid, attname);
 			if (!newtup)
 				elog(ERROR, "could not find inherited attribute \"%s\" of relation \"%s\"",
-					 attname, RelationGetRelationName(newrelation));
+					 attname, get_rel_name(newrte->relid));
 			new_attno = ((Form_pg_attribute) GETSTRUCT(newtup))->attnum - 1;
 			ReleaseSysCache(newtup);
 
@@ -1965,10 +1899,10 @@ make_inh_translation_list(Relation oldrelation, Relation newrelation,
 		/* Found it, check type and collation match */
 		if (atttypid != att->atttypid || atttypmod != att->atttypmod)
 			elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's type",
-				 attname, RelationGetRelationName(newrelation));
+				 attname, get_rel_name(newrte->relid));
 		if (attcollation != att->attcollation)
 			elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's collation",
-				 attname, RelationGetRelationName(newrelation));
+				 attname, get_rel_name(newrte->relid));
 
 		vars = lappend(vars, makeVar(newvarno,
 									 (AttrNumber) (new_attno + 1),
@@ -2121,7 +2055,7 @@ adjust_appendrel_attrs_mutator(Node *node,
 			}
 		}
 
-		if (var->varlevelsup == 0 && appinfo)
+		if (var->varlevelsup == 0 && appinfo && appinfo->translated_vars)
 		{
 			var->varno = appinfo->child_relid;
 			var->varnoold = appinfo->child_relid;
diff --git a/src/backend/optimizer/util/plancat.c b/src/backend/optimizer/util/plancat.c
index 8d67f21f42..f93cc6b90d 100644
--- a/src/backend/optimizer/util/plancat.c
+++ b/src/backend/optimizer/util/plancat.c
@@ -106,7 +106,7 @@ static void set_baserel_partition_key_exprs(Relation relation,
  */
 void
 get_relation_info(PlannerInfo *root, Oid relationObjectId, bool inhparent,
-				  RelOptInfo *rel)
+				  Bitmapset *updatedCols, RelOptInfo *rel)
 {
 	Index		varno = rel->relid;
 	Relation	relation;
@@ -449,7 +449,15 @@ get_relation_info(PlannerInfo *root, Oid relationObjectId, bool inhparent,
 	 * inheritance parents may be partitioned.
 	 */
 	if (inhparent && relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
+	{
 		set_relation_partition_info(root, rel, relation);
+		if (!root->partColsUpdated)
+			root->partColsUpdated =
+				has_partition_attrs(relation, updatedCols, NULL);
+	}
+
+	rel->tupdesc = RelationGetDescr(relation);
+	rel->reltype = RelationGetForm(relation)->reltype;
 
 	heap_close(relation, NoLock);
 
@@ -1871,18 +1879,18 @@ set_relation_partition_info(PlannerInfo *root, RelOptInfo *rel,
 							Relation relation)
 {
 	PartitionDesc partdesc;
-	PartitionKey partkey;
 
 	Assert(relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE);
 
 	partdesc = RelationGetPartitionDesc(relation);
-	partkey = RelationGetPartitionKey(relation);
 	rel->part_scheme = find_partition_scheme(root, relation);
 	Assert(partdesc != NULL && rel->part_scheme != NULL);
-	rel->boundinfo = partition_bounds_copy(partdesc->boundinfo, partkey);
+	rel->boundinfo = partdesc->boundinfo;
 	rel->nparts = partdesc->nparts;
 	set_baserel_partition_key_exprs(relation, rel);
 	rel->partition_qual = RelationGetPartitionQual(relation);
+	rel->part_oids = (Oid *) palloc(rel->nparts * sizeof(Oid));
+	memcpy(rel->part_oids, partdesc->oids, rel->nparts * sizeof(Oid));
 }
 
 /*
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index c69740eda6..46ecb52166 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -16,6 +16,7 @@
 
 #include <limits.h>
 
+#include "catalog/pg_class.h"
 #include "miscadmin.h"
 #include "optimizer/clauses.h"
 #include "optimizer/cost.h"
@@ -27,6 +28,7 @@
 #include "optimizer/restrictinfo.h"
 #include "optimizer/tlist.h"
 #include "partitioning/partbounds.h"
+#include "storage/lockdefs.h"
 #include "utils/hsearch.h"
 
 
@@ -137,6 +139,7 @@ build_simple_rel(PlannerInfo *root, int relid, RelOptInfo *parent)
 
 	/* Rel should not exist already */
 	Assert(relid > 0 && relid < root->simple_rel_array_size);
+
 	if (root->simple_rel_array[relid] != NULL)
 		elog(ERROR, "rel %d already exists", relid);
 
@@ -218,7 +221,8 @@ build_simple_rel(PlannerInfo *root, int relid, RelOptInfo *parent)
 	{
 		case RTE_RELATION:
 			/* Table --- retrieve statistics from the system catalogs */
-			get_relation_info(root, rte->relid, rte->inh, rel);
+			get_relation_info(root, rte->relid, rte->inh, rte->updatedCols,
+							  rel);
 			break;
 		case RTE_SUBQUERY:
 		case RTE_FUNCTION:
@@ -268,41 +272,30 @@ build_simple_rel(PlannerInfo *root, int relid, RelOptInfo *parent)
 	if (rte->inh)
 	{
 		ListCell   *l;
-		int			nparts = rel->nparts;
-		int			cnt_parts = 0;
 
-		if (nparts > 0)
+		/*
+		 * For partitioned tables, we just allocate space for RelOptInfo's.
+		 * pointers for all partitions and copy the partition OIDs from the
+		 * relcache.  Actual RelOptInfo is built for a partition only if it is
+		 * not pruned.
+		 */
+		if (rte->relkind == RELKIND_PARTITIONED_TABLE)
+		{
 			rel->part_rels = (RelOptInfo **)
-				palloc(sizeof(RelOptInfo *) * nparts);
+				palloc0(sizeof(RelOptInfo *) * rel->nparts);
+			return rel;
+		}
 
 		foreach(l, root->append_rel_list)
 		{
 			AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(l);
-			RelOptInfo *childrel;
 
 			/* append_rel_list contains all append rels; ignore others */
 			if (appinfo->parent_relid != relid)
 				continue;
 
-			childrel = build_simple_rel(root, appinfo->child_relid,
-										rel);
-
-			/* Nothing more to do for an unpartitioned table. */
-			if (!rel->part_scheme)
-				continue;
-
-			/*
-			 * The order of partition OIDs in append_rel_list is the same as
-			 * the order in the PartitionDesc, so the order of part_rels will
-			 * also match the PartitionDesc.  See expand_partitioned_rtentry.
-			 */
-			Assert(cnt_parts < nparts);
-			rel->part_rels[cnt_parts] = childrel;
-			cnt_parts++;
+			(void) build_simple_rel(root, appinfo->child_relid, rel);
 		}
-
-		/* We should have seen all the child partitions. */
-		Assert(cnt_parts == nparts);
 	}
 
 	return rel;
@@ -1767,4 +1760,135 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
 		joinrel->partexprs[cnt] = partexpr;
 		joinrel->nullable_partexprs[cnt] = nullable_partexpr;
 	}
+
+	/* Partitions will be added by try_partitionwise_join. */
+	joinrel->live_parts = NULL;
+}
+
+/*
+ * build_dummy_partition_rel
+ *		Build a RelOptInfo and AppendRelInfo for a pruned partition
+ *
+ * This does not result in opening the relation or a range table entry being
+ * created.  Also, the RelOptInfo thus created is not stored anywhere else
+ * beside the parent's part_rels array.
+ *
+ * The only reason this exists is because partition-wise join, in some cases,
+ * needs a RelOptInfo to represent an empty relation that's on the nullable
+ * side of an outer join, so that a Path representing the outer join can be
+ * created.
+ */
+RelOptInfo *
+build_dummy_partition_rel(PlannerInfo *root, RelOptInfo *parent, int partidx)
+{
+	RelOptInfo *rel;
+
+	Assert(parent->part_rels[partidx] == NULL);
+
+	/* Create minimally valid-looking RelOptInfo with parent's relid. */
+	rel = makeNode(RelOptInfo);
+	rel->reloptkind = RELOPT_OTHER_MEMBER_REL;
+	rel->relid = parent->relid;
+	rel->relids = bms_copy(parent->relids);
+	if (parent->top_parent_relids)
+		rel->top_parent_relids = parent->top_parent_relids;
+	else
+		rel->top_parent_relids = bms_copy(parent->relids);
+	rel->reltarget = copy_pathtarget(parent->reltarget);
+	parent->part_rels[partidx] = rel;
+	mark_dummy_rel(rel);
+
+	/*
+	 * Now we'll need a (noop) AppendRelInfo for parent, because we're setting
+	 * the dummy partition's relid to be same as the parent's.
+	 */
+	if (root->append_rel_array[parent->relid] == NULL)
+	{
+		AppendRelInfo *appinfo = makeNode(AppendRelInfo);
+
+		appinfo->parent_relid = parent->relid;
+		appinfo->child_relid = parent->relid;
+		appinfo->parent_reltype = parent->reltype;
+		appinfo->child_reltype = parent->reltype;
+		/* leaving translated_vars to NIL to mean no translation needed */
+		appinfo->parent_reloid = root->simple_rte_array[parent->relid]->relid;
+		root->append_rel_array[parent->relid] = appinfo;
+	}
+
+	return rel;
+}
+
+/*
+ * build_partition_rel
+ *		This adds a valid partition to the query by adding it to the
+ *		range table and creating planner data structures for it
+ */
+RelOptInfo *
+build_partition_rel(PlannerInfo *root, RelOptInfo *parent, Oid partoid)
+{
+	RangeTblEntry *parentrte = root->simple_rte_array[parent->relid];
+	RelOptInfo *result;
+	Index		partRTindex = 0;
+	RangeTblEntry *partrte = NULL;
+	AppendRelInfo *appinfo = NULL;
+	PlanRowMark *rootrc = NULL;
+
+	/* Locate the root partitioned table and fetch its PlanRowMark, if any. */
+	if (root->rowMarks)
+	{
+		Index		rootRTindex = 0;
+
+		/*
+		 * The root partitioned table itself might be a child of UNION ALL
+		 * parent, so we must resort to finding the root parent like this.
+		 */
+		rootRTindex = parent->relid;
+		if (root->append_rel_array[rootRTindex])
+		{
+			AppendRelInfo *tmp = root->append_rel_array[rootRTindex];
+
+			/*
+			 * Keep moving up until we each the parent rel that's not a
+			 * partitioned table.  The one before that one would be the root
+			 * parent.
+			 */
+			while(root->simple_rel_array[rootRTindex]->part_scheme)
+			{
+				tmp = root->append_rel_array[tmp->parent_relid];
+				if (tmp == NULL)
+					break;
+				rootRTindex = tmp->parent_relid;
+			}
+		}
+
+		rootrc = get_plan_rowmark(root->rowMarks, rootRTindex);
+	}
+
+	/*
+	 * expand_inherited_rtentry alreay locked all partitions, so pass
+	 * NoLock for lockmode.
+	 */
+	add_inheritance_child_to_query(root, parentrte, parent->relid,
+								   parent->reltype, parent->tupdesc,
+								   rootrc, partoid, NoLock,
+								   &appinfo, &partrte, &partRTindex);
+
+	/* Partition turned out to be a partitioned table with 0 partitions. */
+	if (partrte == NULL)
+		return NULL;
+
+	Assert(appinfo != NULL);
+	root->append_rel_list = lappend(root->append_rel_list, appinfo);
+	root->simple_rte_array[partRTindex] = partrte;
+	root->append_rel_array[partRTindex] = appinfo;
+
+	/* Build the RelOptInfo. */
+	result = build_simple_rel(root, partRTindex, parent);
+
+	/* Set the information created by create_lateral_join_info(). */
+	result->direct_lateral_relids = parent->direct_lateral_relids;
+	result->lateral_relids = parent->lateral_relids;
+	result->lateral_referencers = parent->lateral_referencers;
+
+	return result;
 }
diff --git a/src/backend/partitioning/partprune.c b/src/backend/partitioning/partprune.c
index b5c1c7d4dd..b2b76f5af3 100644
--- a/src/backend/partitioning/partprune.c
+++ b/src/backend/partitioning/partprune.c
@@ -45,7 +45,9 @@
 #include "nodes/makefuncs.h"
 #include "nodes/nodeFuncs.h"
 #include "optimizer/clauses.h"
+#include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
+#include "optimizer/planmain.h"
 #include "optimizer/planner.h"
 #include "optimizer/predtest.h"
 #include "optimizer/prep.h"
@@ -437,26 +439,26 @@ make_partitionedrel_pruneinfo(PlannerInfo *root, RelOptInfo *parentrel,
 		 * is, not pruned already).
 		 */
 		subplan_map = (int *) palloc(nparts * sizeof(int));
+		memset(subplan_map, -1, nparts * sizeof(int));
 		subpart_map = (int *) palloc(nparts * sizeof(int));
-		present_parts = NULL;
+		memset(subpart_map, -1, nparts * sizeof(int));
+		Assert(IS_SIMPLE_REL(subpart));
+		present_parts = bms_copy(subpart->live_parts);
 
-		for (i = 0; i < nparts; i++)
+		i = -1;
+		while ((i = bms_next_member(present_parts, i)) >= 0)
 		{
 			RelOptInfo *partrel = subpart->part_rels[i];
-			int			subplanidx = relid_subplan_map[partrel->relid] - 1;
-			int			subpartidx = relid_subpart_map[partrel->relid] - 1;
+			int			subplanidx;
+			int			subpartidx;
 
+			subplanidx = relid_subplan_map[partrel->relid] - 1;
+			subpartidx = relid_subpart_map[partrel->relid] - 1;
 			subplan_map[i] = subplanidx;
 			subpart_map[i] = subpartidx;
+			/* Record finding this subplan  */
 			if (subplanidx >= 0)
-			{
-				present_parts = bms_add_member(present_parts, i);
-
-				/* Record finding this subplan  */
 				subplansfound = bms_add_member(subplansfound, subplanidx);
-			}
-			else if (subpartidx >= 0)
-				present_parts = bms_add_member(present_parts, i);
 		}
 
 		rte = root->simple_rte_array[subpart->relid];
@@ -548,61 +550,68 @@ gen_partprune_steps(RelOptInfo *rel, List *clauses, bool *contradictory)
  *
  * Callers must ensure that 'rel' is a partitioned table.
  */
-Relids
-prune_append_rel_partitions(RelOptInfo *rel)
+void
+prune_append_rel_partitions(PlannerInfo *root, RelOptInfo *rel)
 {
-	Relids		result;
 	List	   *clauses = rel->baserestrictinfo;
 	List	   *pruning_steps;
-	bool		contradictory;
+	bool		contradictory,
+				scan_all_parts = false;
 	PartitionPruneContext context;
-	Bitmapset  *partindexes;
-	int			i;
+	Bitmapset  *partindexes = NULL;
 
-	Assert(clauses != NIL);
 	Assert(rel->part_scheme != NULL);
 
 	/* If there are no partitions, return the empty set */
 	if (rel->nparts == 0)
-		return NULL;
+		return;
 
-	/*
-	 * Process clauses.  If the clauses are found to be contradictory, we can
-	 * return the empty set.
-	 */
-	pruning_steps = gen_partprune_steps(rel, clauses, &contradictory);
-	if (contradictory)
-		return NULL;
-
-	/* Set up PartitionPruneContext */
-	context.strategy = rel->part_scheme->strategy;
-	context.partnatts = rel->part_scheme->partnatts;
-	context.nparts = rel->nparts;
-	context.boundinfo = rel->boundinfo;
-	context.partcollation = rel->part_scheme->partcollation;
-	context.partsupfunc = rel->part_scheme->partsupfunc;
-	context.stepcmpfuncs = (FmgrInfo *) palloc0(sizeof(FmgrInfo) *
+	if (enable_partition_pruning && clauses != NIL)
+	{
+		/*
+		 * Process clauses.  If the clauses are found to be contradictory, we
+		 * can return the empty set.
+		 */
+		pruning_steps = gen_partprune_steps(rel, clauses, &contradictory);
+		if (!contradictory)
+		{
+			context.strategy = rel->part_scheme->strategy;
+			context.partnatts = rel->part_scheme->partnatts;
+			context.nparts = rel->nparts;
+			context.boundinfo = rel->boundinfo;
+			context.partcollation = rel->part_scheme->partcollation;
+			context.partsupfunc = rel->part_scheme->partsupfunc;
+			context.stepcmpfuncs = (FmgrInfo *)
+										palloc0(sizeof(FmgrInfo) *
 												context.partnatts *
 												list_length(pruning_steps));
-	context.ppccontext = CurrentMemoryContext;
+			context.ppccontext = CurrentMemoryContext;
 
-	/* These are not valid when being called from the planner */
-	context.partrel = NULL;
-	context.planstate = NULL;
-	context.exprstates = NULL;
-	context.exprhasexecparam = NULL;
-	context.evalexecparams = false;
+			/* These are not valid when being called from the planner */
+			context.partrel = NULL;
+			context.planstate = NULL;
+			context.exprstates = NULL;
+			context.exprhasexecparam = NULL;
+			context.evalexecparams = false;
 
-	/* Actual pruning happens here. */
-	partindexes = get_matching_partitions(&context, pruning_steps);
+			/* Actual pruning happens here. */
+			partindexes = get_matching_partitions(&context, pruning_steps);
 
-	/* Add selected partitions' RT indexes to result. */
-	i = -1;
-	result = NULL;
-	while ((i = bms_next_member(partindexes, i)) >= 0)
-		result = bms_add_member(result, rel->part_rels[i]->relid);
+			/* No need to add partitions if all were pruned. */
+			if (bms_is_empty(partindexes))
+				return;
+		}
+		else
+			scan_all_parts = true;
+	}
+	else
+		scan_all_parts = true;
 
-	return result;
+	/*
+	 * Build selected partitions' range table entries, RelOptInfos, and
+	 * AppendRelInfos.
+	 */
+	add_rel_partitions_to_query(root, rel, scan_all_parts, partindexes);
 }
 
 /*
diff --git a/src/include/nodes/relation.h b/src/include/nodes/relation.h
index 41caf873fb..02c5bdc73f 100644
--- a/src/include/nodes/relation.h
+++ b/src/include/nodes/relation.h
@@ -15,6 +15,7 @@
 #define RELATION_H
 
 #include "access/sdir.h"
+#include "access/tupdesc.h"
 #include "fmgr.h"
 #include "lib/stringinfo.h"
 #include "nodes/params.h"
@@ -695,11 +696,15 @@ typedef struct RelOptInfo
 	int			nparts;			/* number of partitions */
 	struct PartitionBoundInfoData *boundinfo;	/* Partition bounds */
 	List	   *partition_qual; /* partition constraint */
+	Oid		   *part_oids;		/* partition OIDs */
 	struct RelOptInfo **part_rels;	/* Array of RelOptInfos of partitions,
 									 * stored in the same order of bounds */
+	Bitmapset  *live_parts;		/* unpruned parts; NULL if all are live */
 	List	  **partexprs;		/* Non-nullable partition key expressions. */
 	List	  **nullable_partexprs; /* Nullable partition key expressions. */
 	List	   *partitioned_child_rels; /* List of RT indexes. */
+	TupleDesc	tupdesc;
+	Oid			reltype;
 } RelOptInfo;
 
 /*
diff --git a/src/include/optimizer/pathnode.h b/src/include/optimizer/pathnode.h
index 7c5ff22650..4f567765a4 100644
--- a/src/include/optimizer/pathnode.h
+++ b/src/include/optimizer/pathnode.h
@@ -297,5 +297,11 @@ extern RelOptInfo *build_child_join_rel(PlannerInfo *root,
 					 RelOptInfo *outer_rel, RelOptInfo *inner_rel,
 					 RelOptInfo *parent_joinrel, List *restrictlist,
 					 SpecialJoinInfo *sjinfo, JoinType jointype);
+extern RelOptInfo *build_dummy_partition_rel(PlannerInfo *root,
+									RelOptInfo *parent,
+									int partidx);
+extern RelOptInfo *build_partition_rel(PlannerInfo *root,
+									   RelOptInfo *parent,
+									   Oid partoid);
 
 #endif							/* PATHNODE_H */
diff --git a/src/include/optimizer/plancat.h b/src/include/optimizer/plancat.h
index 7d53cbbb87..edaf2a3b4f 100644
--- a/src/include/optimizer/plancat.h
+++ b/src/include/optimizer/plancat.h
@@ -26,7 +26,7 @@ extern PGDLLIMPORT get_relation_info_hook_type get_relation_info_hook;
 
 
 extern void get_relation_info(PlannerInfo *root, Oid relationObjectId,
-				  bool inhparent, RelOptInfo *rel);
+				  bool inhparent, Bitmapset *updatedCols, RelOptInfo *rel);
 
 extern List *infer_arbiter_indexes(PlannerInfo *root);
 
diff --git a/src/include/optimizer/planmain.h b/src/include/optimizer/planmain.h
index c8ab0280d2..1916a33467 100644
--- a/src/include/optimizer/planmain.h
+++ b/src/include/optimizer/planmain.h
@@ -73,6 +73,9 @@ extern int	from_collapse_limit;
 extern int	join_collapse_limit;
 
 extern void add_base_rels_to_query(PlannerInfo *root, Node *jtnode);
+extern void add_rel_partitions_to_query(PlannerInfo *root, RelOptInfo *rel,
+							bool scan_all_parts,
+							Bitmapset *partindexes);
 extern void build_base_rel_tlists(PlannerInfo *root, List *final_tlist);
 extern void add_vars_to_targetlist(PlannerInfo *root, List *vars,
 					   Relids where_needed, bool create_new_ph);
diff --git a/src/include/optimizer/prep.h b/src/include/optimizer/prep.h
index 38608770a2..ca66f75544 100644
--- a/src/include/optimizer/prep.h
+++ b/src/include/optimizer/prep.h
@@ -49,6 +49,16 @@ extern RelOptInfo *plan_set_operations(PlannerInfo *root);
 
 extern void expand_inherited_tables(PlannerInfo *root);
 
+extern void add_inheritance_child_to_query(PlannerInfo *root,
+								RangeTblEntry *parentrte,
+								Index parentRTindex, Oid parentRelType,
+								TupleDesc parentDesc,
+								PlanRowMark *top_parentrc,
+								Oid childOID, int lockmode,
+								AppendRelInfo **appinfo_p,
+								RangeTblEntry **childrte_p,
+								Index *childRTindex_p);
+
 extern Node *adjust_appendrel_attrs(PlannerInfo *root, Node *node,
 					   int nappinfos, AppendRelInfo **appinfos);
 
diff --git a/src/include/partitioning/partprune.h b/src/include/partitioning/partprune.h
index b95c346bab..55a324583b 100644
--- a/src/include/partitioning/partprune.h
+++ b/src/include/partitioning/partprune.h
@@ -79,7 +79,7 @@ extern PartitionPruneInfo *make_partition_pruneinfo(PlannerInfo *root,
 						 List *subpaths,
 						 List *partitioned_rels,
 						 List *prunequal);
-extern Relids prune_append_rel_partitions(RelOptInfo *rel);
+extern void prune_append_rel_partitions(PlannerInfo *root, RelOptInfo *rel);
 extern Bitmapset *get_matching_partitions(PartitionPruneContext *context,
 						List *pruning_steps);
 
diff --git a/src/test/regress/expected/join.out b/src/test/regress/expected/join.out
index dc6262be43..5f931591a6 100644
--- a/src/test/regress/expected/join.out
+++ b/src/test/regress/expected/join.out
@@ -5533,29 +5533,29 @@ select t1.b, ss.phv from join_ut1 t1 left join lateral
               (select t2.a as t2a, t3.a t3a, least(t1.a, t2.a, t3.a) phv
 					  from join_pt1 t2 join join_ut1 t3 on t2.a = t3.b) ss
               on t1.a = ss.t2a order by t1.a;
-                            QUERY PLAN                            
-------------------------------------------------------------------
+                             QUERY PLAN                             
+--------------------------------------------------------------------
  Sort
-   Output: t1.b, (LEAST(t1.a, t2.a, t3.a)), t1.a
+   Output: t1.b, (LEAST(t1.a, t2_1.a, t3.a)), t1.a
    Sort Key: t1.a
    ->  Nested Loop Left Join
-         Output: t1.b, (LEAST(t1.a, t2.a, t3.a)), t1.a
+         Output: t1.b, (LEAST(t1.a, t2_1.a, t3.a)), t1.a
          ->  Seq Scan on public.join_ut1 t1
                Output: t1.a, t1.b, t1.c
          ->  Hash Join
-               Output: t2.a, LEAST(t1.a, t2.a, t3.a)
-               Hash Cond: (t3.b = t2.a)
+               Output: t2_1.a, LEAST(t1.a, t2_1.a, t3.a)
+               Hash Cond: (t3.b = t2_1.a)
                ->  Seq Scan on public.join_ut1 t3
                      Output: t3.a, t3.b, t3.c
                ->  Hash
-                     Output: t2.a
+                     Output: t2_1.a
                      ->  Append
-                           ->  Seq Scan on public.join_pt1p1p1 t2
-                                 Output: t2.a
-                                 Filter: (t1.a = t2.a)
-                           ->  Seq Scan on public.join_pt1p2 t2_1
+                           ->  Seq Scan on public.join_pt1p1p1 t2_1
                                  Output: t2_1.a
                                  Filter: (t1.a = t2_1.a)
+                           ->  Seq Scan on public.join_pt1p2 t2
+                                 Output: t2.a
+                                 Filter: (t1.a = t2.a)
 (21 rows)
 
 select t1.b, ss.phv from join_ut1 t1 left join lateral
diff --git a/src/test/regress/expected/partition_aggregate.out b/src/test/regress/expected/partition_aggregate.out
index d286050c9a..d1ce6ad423 100644
--- a/src/test/regress/expected/partition_aggregate.out
+++ b/src/test/regress/expected/partition_aggregate.out
@@ -144,7 +144,7 @@ SELECT c, sum(a) FROM pagg_tab WHERE 1 = 2 GROUP BY c;
            QUERY PLAN           
 --------------------------------
  HashAggregate
-   Group Key: pagg_tab.c
+   Group Key: c
    ->  Result
          One-Time Filter: false
 (4 rows)
@@ -159,7 +159,7 @@ SELECT c, sum(a) FROM pagg_tab WHERE c = 'x' GROUP BY c;
            QUERY PLAN           
 --------------------------------
  GroupAggregate
-   Group Key: pagg_tab.c
+   Group Key: c
    ->  Result
          One-Time Filter: false
 (4 rows)
-- 
2.11.0

From c768ffe75d37df9d12775a3477cab1b0f1314eb1 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Thu, 23 Aug 2018 17:30:18 +0900
Subject: [PATCH v2 3/3] Only lock partitions that will be scanned by a query

---
 src/backend/optimizer/prep/prepunion.c |  8 +++-----
 src/backend/optimizer/util/relnode.c   | 17 ++++++++++-------
 2 files changed, 13 insertions(+), 12 deletions(-)

diff --git a/src/backend/optimizer/prep/prepunion.c b/src/backend/optimizer/prep/prepunion.c
index 279f686fb0..6a2adb5f4d 100644
--- a/src/backend/optimizer/prep/prepunion.c
+++ b/src/backend/optimizer/prep/prepunion.c
@@ -1555,14 +1555,15 @@ expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti)
 		lockmode = AccessShareLock;
 
 	/* Scan for all members of inheritance set, acquire needed locks */
-	inhOIDs = find_all_inheritors(parentOID, lockmode, NULL);
+	if (rte->relkind != RELKIND_PARTITIONED_TABLE)
+		inhOIDs = find_all_inheritors(parentOID, lockmode, NULL);
 
 	/*
 	 * Check that there's at least one descendant, else treat as no-child
 	 * case.  This could happen despite above has_subclass() check, if table
 	 * once had a child but no longer does.
 	 */
-	if (list_length(inhOIDs) < 2)
+	if (rte->relkind != RELKIND_PARTITIONED_TABLE && list_length(inhOIDs) < 2)
 	{
 		/* Clear flag before returning */
 		rte->inh = false;
@@ -1579,10 +1580,7 @@ expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti)
 
 	/* Partitioned tables are expanded elsewhere. */
 	if (rte->relkind == RELKIND_PARTITIONED_TABLE)
-	{
-		list_free(inhOIDs);
 		return;
-	}
 
 	/*
 	 * Must open the parent relation to examine its tupdesc.  We need not lock
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index 46ecb52166..0a0d7bcd26 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -1828,16 +1828,16 @@ build_partition_rel(PlannerInfo *root, RelOptInfo *parent, Oid partoid)
 {
 	RangeTblEntry *parentrte = root->simple_rte_array[parent->relid];
 	RelOptInfo *result;
+	Index		rootRTindex = 0;
 	Index		partRTindex = 0;
 	RangeTblEntry *partrte = NULL;
 	AppendRelInfo *appinfo = NULL;
 	PlanRowMark *rootrc = NULL;
+	int			lockmode;
 
 	/* Locate the root partitioned table and fetch its PlanRowMark, if any. */
 	if (root->rowMarks)
 	{
-		Index		rootRTindex = 0;
-
 		/*
 		 * The root partitioned table itself might be a child of UNION ALL
 		 * parent, so we must resort to finding the root parent like this.
@@ -1864,13 +1864,16 @@ build_partition_rel(PlannerInfo *root, RelOptInfo *parent, Oid partoid)
 		rootrc = get_plan_rowmark(root->rowMarks, rootRTindex);
 	}
 
-	/*
-	 * expand_inherited_rtentry alreay locked all partitions, so pass
-	 * NoLock for lockmode.
-	 */
+	/* Determine the correct lockmode to use. */
+	if (rootRTindex == root->parse->resultRelation)
+		lockmode = RowExclusiveLock;
+	else if (rootrc && RowMarkRequiresRowShareLock(rootrc->markType))
+		lockmode = RowShareLock;
+	else
+		lockmode = AccessShareLock;
 	add_inheritance_child_to_query(root, parentrte, parent->relid,
 								   parent->reltype, parent->tupdesc,
-								   rootrc, partoid, NoLock,
+								   rootrc, partoid, lockmode,
 								   &appinfo, &partrte, &partRTindex);
 
 	/* Partition turned out to be a partitioned table with 0 partitions. */
-- 
2.11.0

From d23d4740b6a0eb533205f8c94e3509d23609991e Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Fri, 24 Aug 2018 12:39:36 +0900
Subject: [PATCH v3 1/4] Overhaul inheritance update/delete planning

Current method, inheritance_planner, applies grouping_planner and
hence query_planner to the query repeatedly with each child relation
replacing the root parent as the query's result relation. One big
drawback of this approach is that it cannot use partprune.c to
perform partition pruning when the root parent is a partitioned table,
because it can only be invoked if query_planner sees the partitioned
relation itself in the query.  That is not true with how
inheritance_planner invokes query_planner, which it does after
replacing the partitioned relation with individual leaf partitions.

While most of the work in each repitition of grouping_planner (and
query_planner) is same, a couple of things may differ from one child
relation to another -- 1. Join planning may produce different Paths
when joining against different child result partitions,
2. grouping_planner may produce different top-level target lists for
different child relations, based on their own TupleDescs.

This commit removes inheritance_planner in favor of rearranging
things such that, only the planning steps that affect 1 and 2 above
are repeated for unpruned child relations.
---
 doc/src/sgml/ddl.sgml                        |   15 +-
 src/backend/nodes/outfuncs.c                 |    1 -
 src/backend/optimizer/path/allpaths.c        |  224 +++++-
 src/backend/optimizer/plan/createplan.c      |   10 -
 src/backend/optimizer/plan/planmain.c        |    4 +-
 src/backend/optimizer/plan/planner.c         | 1018 ++++++++++----------------
 src/backend/optimizer/prep/prepjointree.c    |    1 -
 src/backend/optimizer/prep/prepunion.c       |   28 +-
 src/backend/optimizer/util/plancat.c         |   50 +-
 src/include/nodes/relation.h                 |    6 +-
 src/test/regress/expected/partition_join.out |    4 +-
 11 files changed, 631 insertions(+), 730 deletions(-)

diff --git a/doc/src/sgml/ddl.sgml b/doc/src/sgml/ddl.sgml
index b5ed1b7939..53c479fbb8 100644
--- a/doc/src/sgml/ddl.sgml
+++ b/doc/src/sgml/ddl.sgml
@@ -3933,16 +3933,6 @@ EXPLAIN SELECT count(*) FROM measurement WHERE logdate &gt;= DATE '2008-01-01';
     <xref linkend="guc-enable-partition-pruning"/> setting.
    </para>
 
-   <note>
-    <para>
-     Currently, pruning of partitions during the planning of an
-     <command>UPDATE</command> or <command>DELETE</command> command is
-     implemented using the constraint exclusion method (however, it is
-     controlled by the <literal>enable_partition_pruning</literal> rather than
-     <literal>constraint_exclusion</literal>) &mdash; see the following section
-     for details and caveats that apply.
-    </para>
-
     <para>
      Execution-time partition pruning currently occurs for the
      <literal>Append</literal> and <literal>MergeAppend</literal> node types.
@@ -3964,9 +3954,8 @@ EXPLAIN SELECT count(*) FROM measurement WHERE logdate &gt;= DATE '2008-01-01';
 
    <para>
     <firstterm>Constraint exclusion</firstterm> is a query optimization
-    technique similar to partition pruning.  While it is primarily used
-    for partitioning implemented using the legacy inheritance method, it can be
-    used for other purposes, including with declarative partitioning.
+    technique similar to partition pruning.  It is primarily used
+    for partitioning implemented using the legacy inheritance method.
    </para>
 
    <para>
diff --git a/src/backend/nodes/outfuncs.c b/src/backend/nodes/outfuncs.c
index b5af904c18..3f2339a3ea 100644
--- a/src/backend/nodes/outfuncs.c
+++ b/src/backend/nodes/outfuncs.c
@@ -2309,7 +2309,6 @@ _outPlannerInfo(StringInfo str, const PlannerInfo *node)
 	WRITE_FLOAT_FIELD(tuple_fraction, "%.4f");
 	WRITE_FLOAT_FIELD(limit_tuples, "%.0f");
 	WRITE_UINT_FIELD(qual_security_level);
-	WRITE_ENUM_FIELD(inhTargetKind, InheritanceKind);
 	WRITE_BOOL_FIELD(hasJoinRTEs);
 	WRITE_BOOL_FIELD(hasLateralRTEs);
 	WRITE_BOOL_FIELD(hasDeletedRTEs);
diff --git a/src/backend/optimizer/path/allpaths.c b/src/backend/optimizer/path/allpaths.c
index 5db1688bf0..968cac42a3 100644
--- a/src/backend/optimizer/path/allpaths.c
+++ b/src/backend/optimizer/path/allpaths.c
@@ -36,6 +36,7 @@
 #include "optimizer/pathnode.h"
 #include "optimizer/paths.h"
 #include "optimizer/plancat.h"
+#include "optimizer/planmain.h"
 #include "optimizer/planner.h"
 #include "optimizer/prep.h"
 #include "optimizer/restrictinfo.h"
@@ -119,6 +120,9 @@ static void set_namedtuplestore_pathlist(PlannerInfo *root, RelOptInfo *rel,
 static void set_worktable_pathlist(PlannerInfo *root, RelOptInfo *rel,
 					   RangeTblEntry *rte);
 static RelOptInfo *make_rel_from_joinlist(PlannerInfo *root, List *joinlist);
+static RelOptInfo *inheritance_make_rel_from_joinlist(PlannerInfo *root,
+						RelOptInfo *parent,
+						List *joinlist);
 static bool subquery_is_pushdown_safe(Query *subquery, Query *topquery,
 						  pushdown_safety_info *safetyInfo);
 static bool recurse_pushdown_safe(Node *setOp, Query *topquery,
@@ -181,13 +185,27 @@ make_one_rel(PlannerInfo *root, List *joinlist)
 
 	/*
 	 * Generate access paths for the entire join tree.
+	 *
+	 * For UPDATE/DELETE on an inheritance parent, join paths should be
+	 * generated for each child result rel separately.
 	 */
-	rel = make_rel_from_joinlist(root, joinlist);
+	if (root->parse->resultRelation &&
+		root->simple_rte_array[root->parse->resultRelation]->inh)
+	{
+		RelOptInfo *targetrel = root->simple_rel_array[root->parse->resultRelation];
 
-	/*
-	 * The result should join all and only the query's base rels.
-	 */
-	Assert(bms_equal(rel->relids, root->all_baserels));
+		rel = inheritance_make_rel_from_joinlist(root, targetrel, joinlist);
+	}
+	else
+	{
+		rel = make_rel_from_joinlist(root, joinlist);
+
+		/*
+		 * The result should join all and only the query's base rels.
+		 */
+		Assert(bms_equal(rel->relids, root->all_baserels));
+
+	}
 
 	return rel;
 }
@@ -868,7 +886,11 @@ static void
 set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 					Index rti, RangeTblEntry *rte)
 {
+	Relids		top_parent_relids = rel->top_parent_relids;
 	int			parentRTindex = rti;
+	int			rootParentRTindex = top_parent_relids ?
+									bms_singleton_member(top_parent_relids) :
+									parentRTindex;
 	bool		has_live_children;
 	double		parent_rows;
 	double		parent_size;
@@ -968,23 +990,6 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 		Assert(childrel->reloptkind == RELOPT_OTHER_MEMBER_REL);
 
 		/*
-		 * Copy/Modify targetlist. Even if this child is deemed empty, we need
-		 * its targetlist in case it falls on nullable side in a child-join
-		 * because of partitionwise join.
-		 *
-		 * NB: the resulting childrel->reltarget->exprs may contain arbitrary
-		 * expressions, which otherwise would not occur in a rel's targetlist.
-		 * Code that might be looking at an appendrel child must cope with
-		 * such.  (Normally, a rel's targetlist would only include Vars and
-		 * PlaceHolderVars.)  XXX we do not bother to update the cost or width
-		 * fields of childrel->reltarget; not clear if that would be useful.
-		 */
-		childrel->reltarget->exprs = (List *)
-			adjust_appendrel_attrs(root,
-								   (Node *) rel->reltarget->exprs,
-								   1, &appinfo);
-
-		/*
 		 * We have to make child entries in the EquivalenceClass data
 		 * structures as well.  This is needed either if the parent
 		 * participates in some eclass joins (because we will want to consider
@@ -1110,9 +1115,28 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 		childrel->baserestrictinfo = childquals;
 		childrel->baserestrict_min_security = cq_min_security;
 
-		if (have_const_false_cq)
+		/*
+		 * Mark the child as empty in certain cases, such as if a restriction
+		 * clause reduced to constant FALSE or NULL, or if the partition
+		 * of a partitioned table has been pruned, or if constaint exclusion
+		 * pruned it.
+		 */
+		if (have_const_false_cq ||
+			(did_pruning &&
+			 !bms_is_member(appinfo->child_relid, live_children)) ||
+			relation_excluded_by_constraints(root, childrel, childRTE))
 		{
 			/*
+			 * The child relation won't be scanned, but certain partitionwise
+			 * planning operations require its reltarget to contain valid
+			 * expressions, so oblige.
+			 */
+			childrel->reltarget->exprs = (List *)
+				adjust_appendrel_attrs(root,
+									   (Node *) rel->reltarget->exprs,
+									   1, &appinfo);
+
+			/*
 			 * Some restriction clause reduced to constant FALSE or NULL after
 			 * substitution, so this child need not be scanned.
 			 */
@@ -1120,22 +1144,56 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 			continue;
 		}
 
-		if (did_pruning && !bms_is_member(appinfo->child_relid, live_children))
+		/*
+		 * Copy/Modify targetlist. Even if this child is deemed empty, we need
+		 * its targetlist in case it falls on nullable side in a child-join
+		 * because of partitionwise join.
+		 *
+		 * NB: the resulting childrel->reltarget->exprs may contain arbitrary
+		 * expressions, which otherwise would not occur in a rel's targetlist.
+		 * Code that might be looking at an appendrel child must cope with
+		 * such.  (Normally, a rel's targetlist would only include Vars and
+		 * PlaceHolderVars.)  XXX we do not bother to update the cost or width
+		 * fields of childrel->reltarget; not clear if that would be useful.
+		 */
+		if (rootParentRTindex == root->parse->resultRelation)
 		{
-			/* This partition was pruned; skip it. */
-			set_dummy_rel_pathlist(childrel);
-			continue;
-		}
+			Query	   *parse,
+					   *orig_parse = root->parse;
+			List	   *tlist;
+			List	   *other_exprs;
+			ListCell   *lc2;
+
+			parse = (Query *)
+					adjust_appendrel_attrs(root,
+										   (Node *) root->parse,
+										   1, &appinfo);
+			root->parse = parse;
+			tlist = preprocess_targetlist(root);
+			build_base_rel_tlists(root, tlist);
+			root->parse = orig_parse;
 
-		if (relation_excluded_by_constraints(root, childrel, childRTE))
-		{
 			/*
-			 * This child need not be scanned, so we can omit it from the
-			 * appendrel.
+			 * Now add members of parent's reltarget->exprs, not already in
+			 * child's.
 			 */
-			set_dummy_rel_pathlist(childrel);
-			continue;
+			other_exprs = (List *)
+				adjust_appendrel_attrs(root,
+									   (Node *) rel->reltarget->exprs,
+									   1, &appinfo);
+			foreach(lc2, other_exprs)
+			{
+				if (!list_member(childrel->reltarget->exprs, lfirst(lc2)))
+					childrel->reltarget->exprs =
+								lappend(childrel->reltarget->exprs,
+										lfirst(lc2));
+			}
 		}
+		else
+			childrel->reltarget->exprs = (List *)
+				adjust_appendrel_attrs(root,
+									   (Node *) rel->reltarget->exprs,
+									   1, &appinfo);
 
 		/* CE failed, so finish copying/modifying join quals. */
 		childrel->joininfo = (List *)
@@ -2570,6 +2628,104 @@ generate_gather_paths(PlannerInfo *root, RelOptInfo *rel, bool override_rows)
 }
 
 /*
+ * inheritance_make_rel_from_joinlist
+ *		Invokes make_rel_from_joinlist for each parent's child relations
+ *
+ * This function is called recursively if a child relation is itself a
+ * partitioned table.
+ */
+static RelOptInfo *
+inheritance_make_rel_from_joinlist(PlannerInfo *root,
+								   RelOptInfo *parent,
+								   List *joinlist)
+{
+	ListCell *lc;
+
+	foreach(lc, root->append_rel_list)
+	{
+		RelOptInfo *childrel;
+		AppendRelInfo *appinfo = lfirst(lc);
+		List	   *translated_joinlist;
+		List	   *saved_join_info_list = root->join_info_list;
+
+		/* Only consider this parent's children. */
+		if (appinfo->parent_relid != parent->relid)
+			continue;
+
+		childrel = find_base_rel(root, appinfo->child_relid);
+
+		/* Ignore excluded/pruned children. */
+		if (IS_DUMMY_REL(childrel))
+			continue;
+
+		/*
+		 * Modify joinlist such that relations joined to parent rel appear to
+		 * be joined to child rel instead.
+		 */
+		translated_joinlist = (List *)
+									adjust_appendrel_attrs(root,
+														   (Node *) joinlist,
+														   1, &appinfo);
+
+		/*
+		 * Since we modified the join tree to include child rel, we can
+		 * modify it to be a "base" rel instead of an "other" rel, which
+		 * join planning code expects the callers to do anyway.
+		 */
+		childrel->reloptkind = RELOPT_BASEREL;
+		root->join_info_list = (List *)
+						adjust_appendrel_attrs(root,
+											   (Node *) root->join_info_list,
+											   1, &appinfo);
+
+		/*
+		 * Recurse if the child is itself a partitioned table.  We must,
+		 * because grandchildren can only be processed this way.
+		 */
+		if (childrel->part_scheme != NULL)
+			childrel =
+				inheritance_make_rel_from_joinlist(root, childrel,
+												   translated_joinlist);
+		else
+		{
+#ifdef USE_ASSERT_CHECKING
+			Relids	all_baserels;
+			Index	top_parent_relid;
+#endif
+
+			/* Reset interal join planning data structures. */
+			root->join_rel_list = NIL;
+			root->join_rel_hash = NULL;
+
+			/* Perform join planning and save the resulting joinrel. */
+			childrel = make_rel_from_joinlist(root, translated_joinlist);
+
+#ifdef USE_ASSERT_CHECKING
+			all_baserels = bms_copy(root->all_baserels);
+			top_parent_relid = parent->top_parent_relids ?
+							bms_singleton_member(parent->top_parent_relids) :
+							parent->relid;
+			all_baserels = bms_del_member(all_baserels, top_parent_relid);
+			all_baserels = bms_add_member(all_baserels, appinfo->child_relid);
+			Assert(bms_equal(childrel->relids, all_baserels));
+#endif
+		}
+
+		/*
+		 * Save child joinrel to be processed later in
+		 * inheritance_adjust_scanjoin_target, which adjusts its paths to
+		 * be able to emit expressions in query's top-level target list.
+		 */
+		root->inh_target_child_rels = lappend(root->inh_target_child_rels,
+											  childrel);
+
+		root->join_info_list = saved_join_info_list;
+	}
+
+	return parent;
+}
+
+/*
  * make_rel_from_joinlist
  *	  Build access paths using a "joinlist" to guide the join path search.
  *
diff --git a/src/backend/optimizer/plan/createplan.c b/src/backend/optimizer/plan/createplan.c
index ae41c9efa0..9e3b62ba1c 100644
--- a/src/backend/optimizer/plan/createplan.c
+++ b/src/backend/optimizer/plan/createplan.c
@@ -2003,12 +2003,7 @@ create_groupingsets_plan(PlannerInfo *root, GroupingSetsPath *best_path)
 	/*
 	 * During setrefs.c, we'll need the grouping_map to fix up the cols lists
 	 * in GroupingFunc nodes.  Save it for setrefs.c to use.
-	 *
-	 * This doesn't work if we're in an inheritance subtree (see notes in
-	 * create_modifytable_plan).  Fortunately we can't be because there would
-	 * never be grouping in an UPDATE/DELETE; but let's Assert that.
 	 */
-	Assert(root->inhTargetKind == INHKIND_NONE);
 	Assert(root->grouping_map == NULL);
 	root->grouping_map = grouping_map;
 
@@ -2165,12 +2160,7 @@ create_minmaxagg_plan(PlannerInfo *root, MinMaxAggPath *best_path)
 	 * with InitPlan output params.  (We can't just do that locally in the
 	 * MinMaxAgg node, because path nodes above here may have Agg references
 	 * as well.)  Save the mmaggregates list to tell setrefs.c to do that.
-	 *
-	 * This doesn't work if we're in an inheritance subtree (see notes in
-	 * create_modifytable_plan).  Fortunately we can't be because there would
-	 * never be aggregates in an UPDATE/DELETE; but let's Assert that.
 	 */
-	Assert(root->inhTargetKind == INHKIND_NONE);
 	Assert(root->minmax_aggs == NIL);
 	root->minmax_aggs = best_path->mmaggregates;
 
diff --git a/src/backend/optimizer/plan/planmain.c b/src/backend/optimizer/plan/planmain.c
index b05adc70c4..3f0d80eaa6 100644
--- a/src/backend/optimizer/plan/planmain.c
+++ b/src/backend/optimizer/plan/planmain.c
@@ -266,7 +266,9 @@ query_planner(PlannerInfo *root, List *tlist,
 
 	/* Check that we got at least one usable path */
 	if (!final_rel || !final_rel->cheapest_total_path ||
-		final_rel->cheapest_total_path->param_info != NULL)
+		final_rel->cheapest_total_path->param_info != NULL ||
+		(final_rel->relid == root->parse->resultRelation &&
+		 root->parse->commandType == CMD_INSERT))
 		elog(ERROR, "failed to construct the join relation");
 
 	return final_rel;
diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index 96bf0601a8..9636d7a4ee 100644
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -113,9 +113,7 @@ typedef struct
 /* Local functions */
 static Node *preprocess_expression(PlannerInfo *root, Node *expr, int kind);
 static void preprocess_qual_conditions(PlannerInfo *root, Node *jtnode);
-static void inheritance_planner(PlannerInfo *root);
-static void grouping_planner(PlannerInfo *root, bool inheritance_update,
-				 double tuple_fraction);
+static void grouping_planner(PlannerInfo *root, double tuple_fraction);
 static grouping_sets_data *preprocess_grouping_sets(PlannerInfo *root);
 static List *remap_to_groupclause_idx(List *groupClause, List *gsets,
 						 int *tleref_to_colnum_map);
@@ -238,6 +236,20 @@ static bool group_by_has_partkey(RelOptInfo *input_rel,
 					 List *targetList,
 					 List *groupClause);
 
+static void inheritance_adjust_scanjoin_target(PlannerInfo *root,
+									 Query *parse,
+									 RelOptInfo *parent,
+									 List **partition_subroots,
+									 Index *nominalRelation,
+									 List **partitioned_rels,
+									 List **resultRelations,
+									 List **subpaths,
+									 List **WCOLists,
+									 List **returningLists,
+									 List **rowMarks);
+static void adjust_child_reltarget(PlannerInfo *root, Relids where_needed,
+								List *tlist);
+
 
 /*****************************************************************************
  *
@@ -622,7 +634,6 @@ subquery_planner(PlannerGlobal *glob, Query *parse,
 	root->grouping_map = NULL;
 	root->minmax_aggs = NIL;
 	root->qual_security_level = 0;
-	root->inhTargetKind = INHKIND_NONE;
 	root->hasRecursion = hasRecursion;
 	if (hasRecursion)
 		root->wt_param_id = SS_assign_special_param(root);
@@ -954,15 +965,8 @@ subquery_planner(PlannerGlobal *glob, Query *parse,
 	if (hasOuterJoins)
 		reduce_outer_joins(root);
 
-	/*
-	 * Do the main planning.  If we have an inherited target relation, that
-	 * needs special processing, else go straight to grouping_planner.
-	 */
-	if (parse->resultRelation &&
-		rt_fetch(parse->resultRelation, parse->rtable)->inh)
-		inheritance_planner(root);
-	else
-		grouping_planner(root, false, tuple_fraction);
+	/* Do the main planning. */
+	grouping_planner(root, tuple_fraction);
 
 	/*
 	 * Capture the set of outer-level param IDs we have access to, for use in
@@ -1132,517 +1136,6 @@ preprocess_phv_expression(PlannerInfo *root, Expr *expr)
 	return (Expr *) preprocess_expression(root, (Node *) expr, EXPRKIND_PHV);
 }
 
-/*
- * inheritance_planner
- *	  Generate Paths in the case where the result relation is an
- *	  inheritance set.
- *
- * We have to handle this case differently from cases where a source relation
- * is an inheritance set. Source inheritance is expanded at the bottom of the
- * plan tree (see allpaths.c), but target inheritance has to be expanded at
- * the top.  The reason is that for UPDATE, each target relation needs a
- * different targetlist matching its own column set.  Fortunately,
- * the UPDATE/DELETE target can never be the nullable side of an outer join,
- * so it's OK to generate the plan this way.
- *
- * Returns nothing; the useful output is in the Paths we attach to
- * the (UPPERREL_FINAL, NULL) upperrel stored in *root.
- *
- * Note that we have not done set_cheapest() on the final rel; it's convenient
- * to leave this to the caller.
- */
-static void
-inheritance_planner(PlannerInfo *root)
-{
-	Query	   *parse = root->parse;
-	int			top_parentRTindex = parse->resultRelation;
-	Bitmapset  *subqueryRTindexes;
-	Bitmapset  *modifiableARIindexes;
-	int			nominalRelation = -1;
-	List	   *final_rtable = NIL;
-	int			save_rel_array_size = 0;
-	RelOptInfo **save_rel_array = NULL;
-	AppendRelInfo **save_append_rel_array = NULL;
-	List	   *subpaths = NIL;
-	List	   *subroots = NIL;
-	List	   *resultRelations = NIL;
-	List	   *withCheckOptionLists = NIL;
-	List	   *returningLists = NIL;
-	List	   *rowMarks;
-	RelOptInfo *final_rel;
-	ListCell   *lc;
-	Index		rti;
-	RangeTblEntry *parent_rte;
-	Relids		partitioned_relids = NULL;
-	List	   *partitioned_rels = NIL;
-	PlannerInfo *parent_root;
-	Query	   *parent_parse;
-	Bitmapset  *parent_relids = bms_make_singleton(top_parentRTindex);
-	PlannerInfo **parent_roots = NULL;
-
-	Assert(parse->commandType != CMD_INSERT);
-
-	/*
-	 * We generate a modified instance of the original Query for each target
-	 * relation, plan that, and put all the plans into a list that will be
-	 * controlled by a single ModifyTable node.  All the instances share the
-	 * same rangetable, but each instance must have its own set of subquery
-	 * RTEs within the finished rangetable because (1) they are likely to get
-	 * scribbled on during planning, and (2) it's not inconceivable that
-	 * subqueries could get planned differently in different cases.  We need
-	 * not create duplicate copies of other RTE kinds, in particular not the
-	 * target relations, because they don't have either of those issues.  Not
-	 * having to duplicate the target relations is important because doing so
-	 * (1) would result in a rangetable of length O(N^2) for N targets, with
-	 * at least O(N^3) work expended here; and (2) would greatly complicate
-	 * management of the rowMarks list.
-	 *
-	 * To begin with, generate a bitmapset of the relids of the subquery RTEs.
-	 */
-	subqueryRTindexes = NULL;
-	rti = 1;
-	foreach(lc, parse->rtable)
-	{
-		RangeTblEntry *rte = lfirst_node(RangeTblEntry, lc);
-
-		if (rte->rtekind == RTE_SUBQUERY)
-			subqueryRTindexes = bms_add_member(subqueryRTindexes, rti);
-		rti++;
-	}
-
-	/*
-	 * Next, we want to identify which AppendRelInfo items contain references
-	 * to any of the aforesaid subquery RTEs.  These items will need to be
-	 * copied and modified to adjust their subquery references; whereas the
-	 * other ones need not be touched.  It's worth being tense over this
-	 * because we can usually avoid processing most of the AppendRelInfo
-	 * items, thereby saving O(N^2) space and time when the target is a large
-	 * inheritance tree.  We can identify AppendRelInfo items by their
-	 * child_relid, since that should be unique within the list.
-	 */
-	modifiableARIindexes = NULL;
-	if (subqueryRTindexes != NULL)
-	{
-		foreach(lc, root->append_rel_list)
-		{
-			AppendRelInfo *appinfo = lfirst_node(AppendRelInfo, lc);
-
-			if (bms_is_member(appinfo->parent_relid, subqueryRTindexes) ||
-				bms_is_member(appinfo->child_relid, subqueryRTindexes) ||
-				bms_overlap(pull_varnos((Node *) appinfo->translated_vars),
-							subqueryRTindexes))
-				modifiableARIindexes = bms_add_member(modifiableARIindexes,
-													  appinfo->child_relid);
-		}
-	}
-
-	/*
-	 * If the parent RTE is a partitioned table, we should use that as the
-	 * nominal relation, because the RTEs added for partitioned tables
-	 * (including the root parent) as child members of the inheritance set do
-	 * not appear anywhere else in the plan.  The situation is exactly the
-	 * opposite in the case of non-partitioned inheritance parent as described
-	 * below. For the same reason, collect the list of descendant partitioned
-	 * tables to be saved in ModifyTable node, so that executor can lock those
-	 * as well.
-	 */
-	parent_rte = rt_fetch(top_parentRTindex, root->parse->rtable);
-	if (parent_rte->relkind == RELKIND_PARTITIONED_TABLE)
-	{
-		nominalRelation = top_parentRTindex;
-
-		/*
-		 * Root parent's RT index is always present in the partitioned_rels of
-		 * the ModifyTable node, if one is needed at all.
-		 */
-		partitioned_relids = bms_make_singleton(top_parentRTindex);
-	}
-
-	/*
-	 * The PlannerInfo for each child is obtained by translating the relevant
-	 * members of the PlannerInfo for its immediate parent, which we find
-	 * using the parent_relid in its AppendRelInfo.  We save the PlannerInfo
-	 * for each parent in an array indexed by relid for fast retrieval. Since
-	 * the maximum number of parents is limited by the number of RTEs in the
-	 * query, we use that number to allocate the array. An extra entry is
-	 * needed since relids start from 1.
-	 */
-	parent_roots = (PlannerInfo **) palloc0((list_length(parse->rtable) + 1) *
-											sizeof(PlannerInfo *));
-	parent_roots[top_parentRTindex] = root;
-
-	/*
-	 * And now we can get on with generating a plan for each child table.
-	 */
-	foreach(lc, root->append_rel_list)
-	{
-		AppendRelInfo *appinfo = lfirst_node(AppendRelInfo, lc);
-		PlannerInfo *subroot;
-		RangeTblEntry *child_rte;
-		RelOptInfo *sub_final_rel;
-		Path	   *subpath;
-
-		/* append_rel_list contains all append rels; ignore others */
-		if (!bms_is_member(appinfo->parent_relid, parent_relids))
-			continue;
-
-		/*
-		 * expand_inherited_rtentry() always processes a parent before any of
-		 * that parent's children, so the parent_root for this relation should
-		 * already be available.
-		 */
-		parent_root = parent_roots[appinfo->parent_relid];
-		Assert(parent_root != NULL);
-		parent_parse = parent_root->parse;
-
-		/*
-		 * We need a working copy of the PlannerInfo so that we can control
-		 * propagation of information back to the main copy.
-		 */
-		subroot = makeNode(PlannerInfo);
-		memcpy(subroot, parent_root, sizeof(PlannerInfo));
-
-		/*
-		 * Generate modified query with this rel as target.  We first apply
-		 * adjust_appendrel_attrs, which copies the Query and changes
-		 * references to the parent RTE to refer to the current child RTE,
-		 * then fool around with subquery RTEs.
-		 */
-		subroot->parse = (Query *)
-			adjust_appendrel_attrs(parent_root,
-								   (Node *) parent_parse,
-								   1, &appinfo);
-
-		/*
-		 * If there are securityQuals attached to the parent, move them to the
-		 * child rel (they've already been transformed properly for that).
-		 */
-		parent_rte = rt_fetch(appinfo->parent_relid, subroot->parse->rtable);
-		child_rte = rt_fetch(appinfo->child_relid, subroot->parse->rtable);
-		child_rte->securityQuals = parent_rte->securityQuals;
-		parent_rte->securityQuals = NIL;
-
-		/*
-		 * Mark whether we're planning a query to a partitioned table or an
-		 * inheritance parent.
-		 */
-		subroot->inhTargetKind =
-			partitioned_relids ? INHKIND_PARTITIONED : INHKIND_INHERITED;
-
-		/*
-		 * If this child is further partitioned, remember it as a parent.
-		 * Since a partitioned table does not have any data, we don't need to
-		 * create a plan for it, and we can stop processing it here.  We do,
-		 * however, need to remember its modified PlannerInfo for use when
-		 * processing its children, since we'll update their varnos based on
-		 * the delta from immediate parent to child, not from top to child.
-		 *
-		 * Note: a very non-obvious point is that we have not yet added
-		 * duplicate subquery RTEs to the subroot's rtable.  We mustn't,
-		 * because then its children would have two sets of duplicates,
-		 * confusing matters.
-		 */
-		if (child_rte->inh)
-		{
-			Assert(child_rte->relkind == RELKIND_PARTITIONED_TABLE);
-			parent_relids = bms_add_member(parent_relids, appinfo->child_relid);
-			parent_roots[appinfo->child_relid] = subroot;
-
-			continue;
-		}
-
-		/*
-		 * Set the nominal target relation of the ModifyTable node if not
-		 * already done.  We use the inheritance parent RTE as the nominal
-		 * target relation if it's a partitioned table (see just above this
-		 * loop).  In the non-partitioned parent case, we'll use the first
-		 * child relation (even if it's excluded) as the nominal target
-		 * relation.  Because of the way expand_inherited_rtentry works, the
-		 * latter should be the RTE representing the parent table in its role
-		 * as a simple member of the inheritance set.
-		 *
-		 * It would be logically cleaner to *always* use the inheritance
-		 * parent RTE as the nominal relation; but that RTE is not otherwise
-		 * referenced in the plan in the non-partitioned inheritance case.
-		 * Instead the duplicate child RTE created by expand_inherited_rtentry
-		 * is used elsewhere in the plan, so using the original parent RTE
-		 * would give rise to confusing use of multiple aliases in EXPLAIN
-		 * output for what the user will think is the "same" table.  OTOH,
-		 * it's not a problem in the partitioned inheritance case, because the
-		 * duplicate child RTE added for the parent does not appear anywhere
-		 * else in the plan tree.
-		 */
-		if (nominalRelation < 0)
-			nominalRelation = appinfo->child_relid;
-
-		/*
-		 * The rowMarks list might contain references to subquery RTEs, so
-		 * make a copy that we can apply ChangeVarNodes to.  (Fortunately, the
-		 * executor doesn't need to see the modified copies --- we can just
-		 * pass it the original rowMarks list.)
-		 */
-		subroot->rowMarks = copyObject(parent_root->rowMarks);
-
-		/*
-		 * The append_rel_list likewise might contain references to subquery
-		 * RTEs (if any subqueries were flattenable UNION ALLs).  So prepare
-		 * to apply ChangeVarNodes to that, too.  As explained above, we only
-		 * want to copy items that actually contain such references; the rest
-		 * can just get linked into the subroot's append_rel_list.
-		 *
-		 * If we know there are no such references, we can just use the outer
-		 * append_rel_list unmodified.
-		 */
-		if (modifiableARIindexes != NULL)
-		{
-			ListCell   *lc2;
-
-			subroot->append_rel_list = NIL;
-			foreach(lc2, parent_root->append_rel_list)
-			{
-				AppendRelInfo *appinfo2 = lfirst_node(AppendRelInfo, lc2);
-
-				if (bms_is_member(appinfo2->child_relid, modifiableARIindexes))
-					appinfo2 = copyObject(appinfo2);
-
-				subroot->append_rel_list = lappend(subroot->append_rel_list,
-												   appinfo2);
-			}
-		}
-
-		/*
-		 * Add placeholders to the child Query's rangetable list to fill the
-		 * RT indexes already reserved for subqueries in previous children.
-		 * These won't be referenced, so there's no need to make them very
-		 * valid-looking.
-		 */
-		while (list_length(subroot->parse->rtable) < list_length(final_rtable))
-			subroot->parse->rtable = lappend(subroot->parse->rtable,
-											 makeNode(RangeTblEntry));
-
-		/*
-		 * If this isn't the first child Query, generate duplicates of all
-		 * subquery RTEs, and adjust Var numbering to reference the
-		 * duplicates. To simplify the loop logic, we scan the original rtable
-		 * not the copy just made by adjust_appendrel_attrs; that should be OK
-		 * since subquery RTEs couldn't contain any references to the target
-		 * rel.
-		 */
-		if (final_rtable != NIL && subqueryRTindexes != NULL)
-		{
-			ListCell   *lr;
-
-			rti = 1;
-			foreach(lr, parent_parse->rtable)
-			{
-				RangeTblEntry *rte = lfirst_node(RangeTblEntry, lr);
-
-				if (bms_is_member(rti, subqueryRTindexes))
-				{
-					Index		newrti;
-
-					/*
-					 * The RTE can't contain any references to its own RT
-					 * index, except in its securityQuals, so we can save a
-					 * few cycles by applying ChangeVarNodes to the rest of
-					 * the rangetable before we append the RTE to it.
-					 */
-					newrti = list_length(subroot->parse->rtable) + 1;
-					ChangeVarNodes((Node *) subroot->parse, rti, newrti, 0);
-					ChangeVarNodes((Node *) subroot->rowMarks, rti, newrti, 0);
-					/* Skip processing unchanging parts of append_rel_list */
-					if (modifiableARIindexes != NULL)
-					{
-						ListCell   *lc2;
-
-						foreach(lc2, subroot->append_rel_list)
-						{
-							AppendRelInfo *appinfo2 = lfirst_node(AppendRelInfo, lc2);
-
-							if (bms_is_member(appinfo2->child_relid,
-											  modifiableARIindexes))
-								ChangeVarNodes((Node *) appinfo2, rti, newrti, 0);
-						}
-					}
-					rte = copyObject(rte);
-					ChangeVarNodes((Node *) rte->securityQuals, rti, newrti, 0);
-					subroot->parse->rtable = lappend(subroot->parse->rtable,
-													 rte);
-				}
-				rti++;
-			}
-		}
-
-		/* There shouldn't be any OJ info to translate, as yet */
-		Assert(subroot->join_info_list == NIL);
-		/* and we haven't created PlaceHolderInfos, either */
-		Assert(subroot->placeholder_list == NIL);
-
-		/* Generate Path(s) for accessing this result relation */
-		grouping_planner(subroot, true, 0.0 /* retrieve all tuples */ );
-
-		/*
-		 * Select cheapest path in case there's more than one.  We always run
-		 * modification queries to conclusion, so we care only for the
-		 * cheapest-total path.
-		 */
-		sub_final_rel = fetch_upper_rel(subroot, UPPERREL_FINAL, NULL);
-		set_cheapest(sub_final_rel);
-		subpath = sub_final_rel->cheapest_total_path;
-
-		/*
-		 * If this child rel was excluded by constraint exclusion, exclude it
-		 * from the result plan.
-		 */
-		if (IS_DUMMY_PATH(subpath))
-			continue;
-
-		/*
-		 * Add the current parent's RT index to the partitioned_relids set if
-		 * we're creating the ModifyTable path for a partitioned root table.
-		 * (We only care about parents of non-excluded children.)
-		 */
-		if (partitioned_relids)
-			partitioned_relids = bms_add_member(partitioned_relids,
-												appinfo->parent_relid);
-
-		/*
-		 * If this is the first non-excluded child, its post-planning rtable
-		 * becomes the initial contents of final_rtable; otherwise, append
-		 * just its modified subquery RTEs to final_rtable.
-		 */
-		if (final_rtable == NIL)
-			final_rtable = subroot->parse->rtable;
-		else
-			final_rtable = list_concat(final_rtable,
-									   list_copy_tail(subroot->parse->rtable,
-													  list_length(final_rtable)));
-
-		/*
-		 * We need to collect all the RelOptInfos from all child plans into
-		 * the main PlannerInfo, since setrefs.c will need them.  We use the
-		 * last child's simple_rel_array (previous ones are too short), so we
-		 * have to propagate forward the RelOptInfos that were already built
-		 * in previous children.
-		 */
-		Assert(subroot->simple_rel_array_size >= save_rel_array_size);
-		for (rti = 1; rti < save_rel_array_size; rti++)
-		{
-			RelOptInfo *brel = save_rel_array[rti];
-
-			if (brel)
-				subroot->simple_rel_array[rti] = brel;
-		}
-		save_rel_array_size = subroot->simple_rel_array_size;
-		save_rel_array = subroot->simple_rel_array;
-		save_append_rel_array = subroot->append_rel_array;
-
-		/* Make sure any initplans from this rel get into the outer list */
-		root->init_plans = subroot->init_plans;
-
-		/* Build list of sub-paths */
-		subpaths = lappend(subpaths, subpath);
-
-		/* Build list of modified subroots, too */
-		subroots = lappend(subroots, subroot);
-
-		/* Build list of target-relation RT indexes */
-		resultRelations = lappend_int(resultRelations, appinfo->child_relid);
-
-		/* Build lists of per-relation WCO and RETURNING targetlists */
-		if (parse->withCheckOptions)
-			withCheckOptionLists = lappend(withCheckOptionLists,
-										   subroot->parse->withCheckOptions);
-		if (parse->returningList)
-			returningLists = lappend(returningLists,
-									 subroot->parse->returningList);
-
-		Assert(!parse->onConflict);
-	}
-
-	/* Result path must go into outer query's FINAL upperrel */
-	final_rel = fetch_upper_rel(root, UPPERREL_FINAL, NULL);
-
-	/*
-	 * We don't currently worry about setting final_rel's consider_parallel
-	 * flag in this case, nor about allowing FDWs or create_upper_paths_hook
-	 * to get control here.
-	 */
-
-	/*
-	 * If we managed to exclude every child rel, return a dummy plan; it
-	 * doesn't even need a ModifyTable node.
-	 */
-	if (subpaths == NIL)
-	{
-		set_dummy_rel_pathlist(final_rel);
-		return;
-	}
-
-	/*
-	 * Put back the final adjusted rtable into the master copy of the Query.
-	 * (We mustn't do this if we found no non-excluded children.)
-	 */
-	parse->rtable = final_rtable;
-	root->simple_rel_array_size = save_rel_array_size;
-	root->simple_rel_array = save_rel_array;
-	root->append_rel_array = save_append_rel_array;
-
-	/* Must reconstruct master's simple_rte_array, too */
-	root->simple_rte_array = (RangeTblEntry **)
-		palloc0((list_length(final_rtable) + 1) * sizeof(RangeTblEntry *));
-	rti = 1;
-	foreach(lc, final_rtable)
-	{
-		RangeTblEntry *rte = lfirst_node(RangeTblEntry, lc);
-
-		root->simple_rte_array[rti++] = rte;
-	}
-
-	/*
-	 * If there was a FOR [KEY] UPDATE/SHARE clause, the LockRows node will
-	 * have dealt with fetching non-locked marked rows, else we need to have
-	 * ModifyTable do that.
-	 */
-	if (parse->rowMarks)
-		rowMarks = NIL;
-	else
-		rowMarks = root->rowMarks;
-
-	if (partitioned_relids)
-	{
-		int			i;
-
-		i = -1;
-		while ((i = bms_next_member(partitioned_relids, i)) >= 0)
-			partitioned_rels = lappend_int(partitioned_rels, i);
-
-		/*
-		 * If we're going to create ModifyTable at all, the list should
-		 * contain at least one member, that is, the root parent's index.
-		 */
-		Assert(list_length(partitioned_rels) >= 1);
-		partitioned_rels = list_make1(partitioned_rels);
-	}
-
-	/* Create Path representing a ModifyTable to do the UPDATE/DELETE work */
-	add_path(final_rel, (Path *)
-			 create_modifytable_path(root, final_rel,
-									 parse->commandType,
-									 parse->canSetTag,
-									 nominalRelation,
-									 partitioned_rels,
-									 root->partColsUpdated,
-									 resultRelations,
-									 subpaths,
-									 subroots,
-									 withCheckOptionLists,
-									 returningLists,
-									 rowMarks,
-									 NULL,
-									 SS_assign_special_param(root)));
-}
-
 /*--------------------
  * grouping_planner
  *	  Perform planning steps related to grouping, aggregation, etc.
@@ -1650,11 +1143,6 @@ inheritance_planner(PlannerInfo *root)
  * This function adds all required top-level processing to the scan/join
  * Path(s) produced by query_planner.
  *
- * If inheritance_update is true, we're being called from inheritance_planner
- * and should not include a ModifyTable step in the resulting Path(s).
- * (inheritance_planner will create a single ModifyTable node covering all the
- * target tables.)
- *
  * tuple_fraction is the fraction of tuples we expect will be retrieved.
  * tuple_fraction is interpreted as follows:
  *	  0: expect all tuples to be retrieved (normal case)
@@ -1672,8 +1160,7 @@ inheritance_planner(PlannerInfo *root)
  *--------------------
  */
 static void
-grouping_planner(PlannerInfo *root, bool inheritance_update,
-				 double tuple_fraction)
+grouping_planner(PlannerInfo *root, double tuple_fraction)
 {
 	Query	   *parse = root->parse;
 	List	   *tlist;
@@ -1688,6 +1175,15 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 	RelOptInfo *current_rel;
 	RelOptInfo *final_rel;
 	ListCell   *lc;
+	List	   *orig_parse_tlist = list_copy(parse->targetList);
+	Index		nominalRelation = 0;
+	List	   *partition_subroots = NIL;
+	List	   *partitioned_rels = NIL;
+	List	   *partition_resultRelations = NIL;
+	List	   *partition_subpaths = NIL;
+	List	   *partition_WCOLists = NIL;
+	List	   *partition_returningLists = NIL;
+	List	   *partition_rowMarks = NIL;
 
 	/* Tweak caller-supplied tuple_fraction if have LIMIT/OFFSET */
 	if (parse->limitCount || parse->limitOffset)
@@ -2018,13 +1514,45 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 			scanjoin_targets_contain_srfs = NIL;
 		}
 
-		/* Apply scan/join target. */
-		scanjoin_target_same_exprs = list_length(scanjoin_targets) == 1
-			&& equal(scanjoin_target->exprs, current_rel->reltarget->exprs);
-		apply_scanjoin_target_to_paths(root, current_rel, scanjoin_targets,
-									   scanjoin_targets_contain_srfs,
-									   scanjoin_target_parallel_safe,
-									   scanjoin_target_same_exprs);
+		/*
+		 * For UPDATE/DELETE on an inheritance parent, we must generate and
+		 * apply scanjoin target based on targetlist computed using each
+		 * of the child relations.
+		 */
+		if (parse->commandType != CMD_INSERT &&
+			current_rel->reloptkind == RELOPT_BASEREL &&
+			current_rel->relid == root->parse->resultRelation &&
+			root->simple_rte_array[current_rel->relid]->inh)
+		{
+			/*
+			 * scanjoin_target shouldn't have changed from final_target,
+			 * because UPDATE/DELETE doesn't support various features that
+			 * would've required modifications that are performed above.
+			 * That's important because we'll generate final_target freshly
+			 * for each partition in inheritance_adjust_scanjoin_target.
+			 */
+			Assert(scanjoin_target == final_target);
+			root->parse->targetList = orig_parse_tlist;
+			inheritance_adjust_scanjoin_target(root, root->parse, current_rel,
+											   &partition_subroots,
+											   &nominalRelation,
+											   &partitioned_rels,
+											   &partition_resultRelations,
+											   &partition_subpaths,
+											   &partition_WCOLists,
+											   &partition_returningLists,
+											   &partition_rowMarks);
+		}
+		else
+		{
+			/* Apply scan/join target. */
+			scanjoin_target_same_exprs = list_length(scanjoin_targets) == 1
+				&& equal(scanjoin_target->exprs, current_rel->reltarget->exprs);
+			apply_scanjoin_target_to_paths(root, current_rel, scanjoin_targets,
+										   scanjoin_targets_contain_srfs,
+										   scanjoin_target_parallel_safe,
+										   scanjoin_target_same_exprs);
+		}
 
 		/*
 		 * Save the various upper-rel PathTargets we just computed into
@@ -2137,92 +1665,123 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 	final_rel->fdwroutine = current_rel->fdwroutine;
 
 	/*
-	 * Generate paths for the final_rel.  Insert all surviving paths, with
-	 * LockRows, Limit, and/or ModifyTable steps added if needed.
+	 * If the table has partitions, but all of them were pruned, then
+	 * nothing to do.
 	 */
-	foreach(lc, current_rel->pathlist)
+	if (current_rel->reloptkind == RELOPT_BASEREL &&
+		current_rel->relid == root->parse->resultRelation &&
+		!IS_DUMMY_REL(current_rel) &&
+		root->simple_rte_array[current_rel->relid]->inh &&
+		parse->commandType != CMD_INSERT)
 	{
-		Path	   *path = (Path *) lfirst(lc);
-
-		/*
-		 * If there is a FOR [KEY] UPDATE/SHARE clause, add the LockRows node.
-		 * (Note: we intentionally test parse->rowMarks not root->rowMarks
-		 * here.  If there are only non-locking rowmarks, they should be
-		 * handled by the ModifyTable node instead.  However, root->rowMarks
-		 * is what goes into the LockRows node.)
-		 */
-		if (parse->rowMarks)
-		{
-			path = (Path *) create_lockrows_path(root, final_rel, path,
-												 root->rowMarks,
-												 SS_assign_special_param(root));
-		}
-
-		/*
-		 * If there is a LIMIT/OFFSET clause, add the LIMIT node.
-		 */
-		if (limit_needed(parse))
-		{
-			path = (Path *) create_limit_path(root, final_rel, path,
-											  parse->limitOffset,
-											  parse->limitCount,
-											  offset_est, count_est);
-		}
-
-		/*
-		 * If this is an INSERT/UPDATE/DELETE, and we're not being called from
-		 * inheritance_planner, add the ModifyTable node.
-		 */
-		if (parse->commandType != CMD_SELECT && !inheritance_update)
-		{
-			List	   *withCheckOptionLists;
-			List	   *returningLists;
-			List	   *rowMarks;
-
-			/*
-			 * Set up the WITH CHECK OPTION and RETURNING lists-of-lists, if
-			 * needed.
-			 */
-			if (parse->withCheckOptions)
-				withCheckOptionLists = list_make1(parse->withCheckOptions);
-			else
-				withCheckOptionLists = NIL;
-
-			if (parse->returningList)
-				returningLists = list_make1(parse->returningList);
-			else
-				returningLists = NIL;
-
-			/*
-			 * If there was a FOR [KEY] UPDATE/SHARE clause, the LockRows node
-			 * will have dealt with fetching non-locked marked rows, else we
-			 * need to have ModifyTable do that.
-			 */
-			if (parse->rowMarks)
-				rowMarks = NIL;
-			else
-				rowMarks = root->rowMarks;
-
-			path = (Path *)
+		Path *path = (Path *)
 				create_modifytable_path(root, final_rel,
 										parse->commandType,
 										parse->canSetTag,
-										parse->resultRelation,
-										NIL,
-										false,
-										list_make1_int(parse->resultRelation),
-										list_make1(path),
-										list_make1(root),
-										withCheckOptionLists,
-										returningLists,
-										rowMarks,
-										parse->onConflict,
+										nominalRelation,
+										partitioned_rels,
+										root->partColsUpdated,
+										partition_resultRelations,
+										partition_subpaths,
+										partition_subroots,
+										partition_WCOLists,
+										partition_returningLists,
+										partition_rowMarks,
+										NULL,
 										SS_assign_special_param(root));
-		}
-
-		/* And shove it into final_rel */
 		add_path(final_rel, path);
 	}
+	else
+	{
+		/*
+		 * Generate paths for the final_rel.  Insert all surviving paths, with
+		 * LockRows, Limit, and/or ModifyTable steps added if needed.
+		 */
+		foreach(lc, current_rel->pathlist)
+		{
+			Path	   *path = (Path *) lfirst(lc);
+
+			/*
+			 * If there is a FOR [KEY] UPDATE/SHARE clause, add the LockRows
+			 * node. (Note: we intentionally test parse->rowMarks not
+			 * root->rowMarks here.  If there are only non-locking rowmarks,
+			 * they should be handled by the ModifyTable node instead.
+			 * However, root->rowMarks is what goes into the LockRows node.)
+			 */
+			if (parse->rowMarks)
+			{
+				path = (Path *)
+							create_lockrows_path(root, final_rel, path,
+												 root->rowMarks,
+												 SS_assign_special_param(root));
+			}
+
+			/*
+			 * If there is a LIMIT/OFFSET clause, add the LIMIT node.
+			 */
+			if (limit_needed(parse))
+			{
+				path = (Path *) create_limit_path(root, final_rel, path,
+												  parse->limitOffset,
+												  parse->limitCount,
+												  offset_est, count_est);
+			}
+
+			/*
+			 * If this is an INSERT/UPDATE/DELETE, and we're not being called
+			 * from inheritance_planner, add the ModifyTable node.
+			 */
+			if (parse->commandType != CMD_SELECT)
+			{
+				List	   *withCheckOptionLists;
+				List	   *returningLists;
+				List	   *rowMarks;
+
+				/*
+				 * Set up the WITH CHECK OPTION and RETURNING lists-of-lists,
+				 * if needed.
+				 */
+				if (parse->withCheckOptions)
+					withCheckOptionLists = list_make1(parse->withCheckOptions);
+				else
+					withCheckOptionLists = NIL;
+
+				if (parse->returningList)
+					returningLists = list_make1(parse->returningList);
+				else
+					returningLists = NIL;
+
+				/*
+				 * If there was a FOR [KEY] UPDATE/SHARE clause, the LockRows
+				 * node will have dealt with fetching non-locked marked rows,
+				 * else we need to have ModifyTable do that.
+				 */
+				if (parse->rowMarks)
+					rowMarks = NIL;
+				else
+					rowMarks = root->rowMarks;
+
+				path = (Path *)
+					create_modifytable_path(root, final_rel,
+											parse->commandType,
+											parse->canSetTag,
+											parse->resultRelation,
+											NIL,
+											false,
+											list_make1_int(parse->resultRelation),
+											list_make1(path),
+											list_make1(root),
+											withCheckOptionLists,
+											returningLists,
+											rowMarks,
+											parse->onConflict,
+											SS_assign_special_param(root));
+			}
+
+			/* And shove it into final_rel */
+			add_path(final_rel, path);
+		}
+	}
 
 	/*
 	 * Generate partial paths for final_rel, too, if outer query levels might
@@ -2259,6 +1818,233 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 }
 
 /*
+ * inheritance_adjust_scanjoin_target
+ *		adjusts query's targetlist for each partition in the partition tree
+ *		whose root is 'parent' and apply it to their paths via
+ *		apply_scanjoin_target_to_paths
+ *
+ * Its output also consists of various pieces of information that will go
+ * into the ModifyTable node that will be created for this query.
+ */
+static void
+inheritance_adjust_scanjoin_target(PlannerInfo *root,
+								   Query *parse,
+								   RelOptInfo *parent,
+								   List **subroots,
+								   Index *nominalRelation,
+								   List **partitioned_rels,
+								   List **resultRelations,
+								   List **subpaths,
+								   List **WCOLists,
+								   List **returningLists,
+								   List **rowMarks)
+{
+	ListCell *lc;
+
+	/*
+	 * If all of child relations of parent were pruned, let
+	 * apply_scanjoin_target_to_paths finish it up with a dummy path
+	 * containing correct target list.
+	 */
+	if (IS_DUMMY_REL(parent))
+	{
+		PathTarget *scanjoin_target = create_pathtarget(root,
+														root->processed_tlist);
+		apply_scanjoin_target_to_paths(root, parent,
+									   list_make1(scanjoin_target),
+									   NIL, false, false);
+		return;
+	}
+
+	if (parent->part_scheme)
+	{
+		*partitioned_rels = lappend(*partitioned_rels,
+									list_make1_int(parent->relid));
+		if (*nominalRelation == 0)
+			*nominalRelation = parent->relid;
+	}
+
+	foreach(lc, root->inh_target_child_rels)
+	{
+		RelOptInfo *child_joinrel = lfirst(lc);
+		RelOptInfo *child_rel;
+		AppendRelInfo *appinfo;
+		int			child_base_relid;
+		bool		found;
+		List	   *tlist;
+		PathTarget *scanjoin_target;
+		bool		scanjoin_target_parallel_safe;
+		bool		scanjoin_target_same_exprs;
+		PlannerInfo *partition_subroot;
+		Query	   *partition_parse;
+
+		/*
+		 * Check if this child joinrel is a child of parent.  To do so, check
+		 * if its relids contains an index that belongs to one of parent's
+		 * child base rels.
+		 */
+		found = false;
+		child_base_relid = -1;
+		while ((child_base_relid = bms_next_member(child_joinrel->relids,
+												   child_base_relid)) >= 0)
+		{
+			AppendRelInfo *appinfo = root->append_rel_array[child_base_relid];
+
+			if (appinfo && appinfo->parent_relid == parent->relid)
+			{
+				found = true;
+				break;
+			}
+		}
+		if (!found)
+			continue;
+
+		if (*nominalRelation == 0)
+			*nominalRelation = child_base_relid;
+
+		/*
+		 * If the child was pruned, its corresponding joinrel will be empty,
+		 * which we can ignore safely.
+		 */
+		if (IS_DUMMY_REL(child_joinrel))
+			continue;
+
+		appinfo = root->append_rel_array[child_base_relid];
+		Assert(appinfo != NULL);
+		child_rel = root->simple_rel_array[child_base_relid];
+		Assert(IS_SIMPLE_REL(child_rel));
+
+		/* Translate Query structure for this partition. */
+		partition_parse = (Query *)
+						adjust_appendrel_attrs(root,
+											   (Node *) parse,
+											   1, &appinfo);
+
+		if (child_rel->part_scheme)
+		{
+			Assert(child_joinrel == child_rel);
+			inheritance_adjust_scanjoin_target(root,
+											   partition_parse,
+											   child_rel,
+											   subroots,
+											   nominalRelation,
+											   partitioned_rels,
+											   resultRelations,
+											   subpaths,
+											   WCOLists,
+											   returningLists,
+											   rowMarks);
+			/* Restore the Query for processing the next partition. */
+		}
+		else
+		{
+			/*
+			 * Generate a separate PlannerInfo for this partition.  We'll need
+			 * it when generating the ModifyTable subplan for this partition.
+			 */
+			partition_subroot = makeNode(PlannerInfo);
+			memcpy(partition_subroot, root, sizeof(PlannerInfo));
+			*subroots = lappend(*subroots, partition_subroot);
+
+			/*
+			 * Preprocess the translated targetlist and save it in the
+			 * partition's PlannerInfo for use by createplan.c.
+			 */
+			partition_subroot->parse = partition_parse;
+			tlist = preprocess_targetlist(partition_subroot);
+			partition_subroot->processed_tlist = tlist;
+
+			/*
+			 * Fix up child rel's reltarget to add Vars from the top-level
+			 * targetlist that may not have yet been added to it.  Note that
+			 * it would already contain entries for inherited attributes
+			 * (although we may still need to set their attr_needed), but
+			 * not its own attributes that preprocess_targetlist called
+			 * above would've added to the top-level tlist.
+			 */
+			adjust_child_reltarget(partition_subroot, bms_make_singleton(0),
+								   tlist);
+
+			/*
+			 * Apply the newly computed scan/join target to child_joinrel's
+			 * paths.
+			 */
+			scanjoin_target = create_pathtarget(root, tlist);
+			scanjoin_target_same_exprs =
+									equal(scanjoin_target->exprs,
+										  child_joinrel->reltarget->exprs);
+			scanjoin_target_parallel_safe =
+				is_parallel_safe(root, (Node *) scanjoin_target->exprs);
+			apply_scanjoin_target_to_paths(root, child_joinrel,
+										   list_make1(scanjoin_target),
+										   NIL,
+										   scanjoin_target_parallel_safe,
+										   scanjoin_target_same_exprs);
+
+			/* Collect information that will go into the ModifyTable */
+			*resultRelations = lappend_int(*resultRelations, child_base_relid);
+			*subpaths = lappend(*subpaths, child_joinrel->cheapest_total_path);
+			if (partition_parse->withCheckOptions)
+				*WCOLists = lappend(*WCOLists, partition_parse->withCheckOptions);
+			if (partition_parse->returningList)
+				*returningLists = lappend(*returningLists,
+										  partition_parse->returningList);
+			if (partition_parse->rowMarks)
+				*rowMarks = lappend(*rowMarks, partition_parse->rowMarks);
+		}
+	}
+}
+
+static void
+adjust_child_reltarget(PlannerInfo *root, Relids where_needed, List *tlist)
+{
+	List   *tlist_vars = pull_var_clause((Node *) tlist,
+										 PVC_RECURSE_AGGREGATES |
+										 PVC_RECURSE_WINDOWFUNCS |
+										 PVC_INCLUDE_PLACEHOLDERS);
+	ListCell *lc;
+
+	foreach(lc, tlist_vars)
+	{
+		Node *node = (Node *) lfirst(lc);
+
+		if (IsA(node, Var))
+		{
+			Var *var = (Var *) node;
+			RelOptInfo *rel = find_base_rel(root, var->varno);
+			int	attno = var->varattno;
+
+			if (bms_is_subset(where_needed, rel->relids))
+				continue;
+
+			Assert(attno >= rel->min_attr && attno <= rel->max_attr);
+			attno -= rel->min_attr;
+			if (rel->attr_needed[attno] == NULL)
+			{
+				bool	found;
+				ListCell *lc2;
+
+				rel->attr_needed[attno] =
+								bms_add_members(rel->attr_needed[attno],
+												where_needed);
+				found = false;
+				foreach(lc2, rel->reltarget->exprs)
+				{
+					if (equal(var, lfirst(lc2)))
+					{
+						found = true;
+						break;
+					}
+				}
+				if (!found)
+					rel->reltarget->exprs = lappend(rel->reltarget->exprs,
+													var);
+			}
+		}
+	}
+}
+
+/*
  * Do preprocessing for groupingSets clause and related data.  This handles the
  * preliminary steps of expanding the grouping sets, organizing them into lists
  * of rollups, and preparing annotations which will later be filled in with
diff --git a/src/backend/optimizer/prep/prepjointree.c b/src/backend/optimizer/prep/prepjointree.c
index c3f46a26c3..0d10a6b914 100644
--- a/src/backend/optimizer/prep/prepjointree.c
+++ b/src/backend/optimizer/prep/prepjointree.c
@@ -914,7 +914,6 @@ pull_up_simple_subquery(PlannerInfo *root, Node *jtnode, RangeTblEntry *rte,
 	subroot->grouping_map = NULL;
 	subroot->minmax_aggs = NIL;
 	subroot->qual_security_level = 0;
-	subroot->inhTargetKind = INHKIND_NONE;
 	subroot->hasRecursion = false;
 	subroot->wt_param_id = -1;
 	subroot->non_recursive_path = NULL;
diff --git a/src/backend/optimizer/prep/prepunion.c b/src/backend/optimizer/prep/prepunion.c
index 690b6bbab7..f4c485cdc9 100644
--- a/src/backend/optimizer/prep/prepunion.c
+++ b/src/backend/optimizer/prep/prepunion.c
@@ -2265,8 +2265,34 @@ adjust_appendrel_attrs_mutator(Node *node,
 											  context->appinfos);
 		return (Node *) phv;
 	}
+
+	if (IsA(node, SpecialJoinInfo))
+	{
+		SpecialJoinInfo *oldinfo = (SpecialJoinInfo *) node;
+		SpecialJoinInfo *newinfo = makeNode(SpecialJoinInfo);
+
+		memcpy(newinfo, oldinfo, sizeof(SpecialJoinInfo));
+		newinfo->min_lefthand = adjust_child_relids(oldinfo->min_lefthand,
+													context->nappinfos,
+													context->appinfos);
+		newinfo->min_righthand = adjust_child_relids(oldinfo->min_righthand,
+													 context->nappinfos,
+													 context->appinfos);
+		newinfo->syn_lefthand = adjust_child_relids(oldinfo->syn_lefthand,
+													context->nappinfos,
+													context->appinfos);
+		newinfo->syn_righthand = adjust_child_relids(oldinfo->syn_righthand,
+													 context->nappinfos,
+													 context->appinfos);
+		newinfo->semi_rhs_exprs =
+					(List *) expression_tree_mutator((Node *)
+													 oldinfo->semi_rhs_exprs,
+													 adjust_appendrel_attrs_mutator,
+													 (void *) context);
+		return (Node *) newinfo;
+	}
+
 	/* 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));
diff --git a/src/backend/optimizer/util/plancat.c b/src/backend/optimizer/util/plancat.c
index 8369e3ad62..5a37221780 100644
--- a/src/backend/optimizer/util/plancat.c
+++ b/src/backend/optimizer/util/plancat.c
@@ -1265,36 +1265,6 @@ get_relation_constraints(PlannerInfo *root,
 		}
 	}
 
-	/*
-	 * Append partition predicates, if any.
-	 *
-	 * For selects, partition pruning uses the parent table's partition bound
-	 * descriptor, instead of constraint exclusion which is driven by the
-	 * individual partition's partition constraint.
-	 */
-	if (enable_partition_pruning && root->parse->commandType != CMD_SELECT)
-	{
-		List	   *pcqual = RelationGetPartitionQual(relation);
-
-		if (pcqual)
-		{
-			/*
-			 * Run the partition quals through const-simplification similar to
-			 * check constraints.  We skip canonicalize_qual, though, because
-			 * partition quals should be in canonical form already; also,
-			 * since the qual is in implicit-AND format, we'd have to
-			 * explicitly convert it to explicit-AND format and back again.
-			 */
-			pcqual = (List *) eval_const_expressions(root, (Node *) pcqual);
-
-			/* Fix Vars to have the desired varno */
-			if (varno != 1)
-				ChangeVarNodes((Node *) pcqual, 1, varno, 0);
-
-			result = list_concat(result, pcqual);
-		}
-	}
-
 	heap_close(relation, NoLock);
 
 	return result;
@@ -1421,31 +1391,15 @@ relation_excluded_by_constraints(PlannerInfo *root,
 	switch (constraint_exclusion)
 	{
 		case CONSTRAINT_EXCLUSION_OFF:
-
-			/*
-			 * Don't prune if feature turned off -- except if the relation is
-			 * a partition.  While partprune.c-style partition pruning is not
-			 * yet in use for all cases (update/delete is not handled), it
-			 * would be a UI horror to use different user-visible controls
-			 * depending on such a volatile implementation detail.  Therefore,
-			 * for partitioned tables we use enable_partition_pruning to
-			 * control this behavior.
-			 */
-			if (root->inhTargetKind == INHKIND_PARTITIONED)
-				break;
 			return false;
 
 		case CONSTRAINT_EXCLUSION_PARTITION:
 
 			/*
 			 * When constraint_exclusion is set to 'partition' we only handle
-			 * OTHER_MEMBER_RELs, or BASERELs in cases where the result target
-			 * is an inheritance parent or a partitioned table.
+			 * OTHER_MEMBER_RELs.
 			 */
-			if ((rel->reloptkind != RELOPT_OTHER_MEMBER_REL) &&
-				!(rel->reloptkind == RELOPT_BASEREL &&
-				  root->inhTargetKind != INHKIND_NONE &&
-				  rel->relid == root->parse->resultRelation))
+			if (rel->reloptkind != RELOPT_OTHER_MEMBER_REL)
 				return false;
 			break;
 
diff --git a/src/include/nodes/relation.h b/src/include/nodes/relation.h
index adb4265047..c008d626a1 100644
--- a/src/include/nodes/relation.h
+++ b/src/include/nodes/relation.h
@@ -319,9 +319,6 @@ typedef struct PlannerInfo
 	Index		qual_security_level;	/* minimum security_level for quals */
 	/* Note: qual_security_level is zero if there are no securityQuals */
 
-	InheritanceKind inhTargetKind;	/* indicates if the target relation is an
-									 * inheritance child or partition or a
-									 * partitioned table */
 	bool		hasJoinRTEs;	/* true if any RTEs are RTE_JOIN kind */
 	bool		hasLateralRTEs; /* true if any RTEs are marked LATERAL */
 	bool		hasDeletedRTEs; /* true if any RTE was deleted from jointree */
@@ -343,6 +340,9 @@ typedef struct PlannerInfo
 
 	/* Does this query modify any partition key columns? */
 	bool		partColsUpdated;
+
+	/* RelOptInfo of child joinrels of an inherited update/delete operation */
+	List	   *inh_target_child_rels;
 } PlannerInfo;
 
 
diff --git a/src/test/regress/expected/partition_join.out b/src/test/regress/expected/partition_join.out
index 3ba3aaf2d8..a539280851 100644
--- a/src/test/regress/expected/partition_join.out
+++ b/src/test/regress/expected/partition_join.out
@@ -1781,7 +1781,7 @@ WHERE EXISTS (
                Filter: (c IS NULL)
          ->  Nested Loop
                ->  Seq Scan on int4_tbl
-               ->  Subquery Scan on ss_1
+               ->  Subquery Scan on ss
                      ->  Limit
                            ->  Seq Scan on int8_tbl int8_tbl_1
    ->  Nested Loop Semi Join
@@ -1789,7 +1789,7 @@ WHERE EXISTS (
                Filter: (c IS NULL)
          ->  Nested Loop
                ->  Seq Scan on int4_tbl
-               ->  Subquery Scan on ss_2
+               ->  Subquery Scan on ss
                      ->  Limit
                            ->  Seq Scan on int8_tbl int8_tbl_2
 (28 rows)
-- 
2.11.0

From 2abe3703b65caffd71068aa252b15b3d6a3c5da5 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Wed, 16 May 2018 14:35:40 +0900
Subject: [PATCH v3 2/4] Lazy creation of partition objects for planning

With the current approach, *all* partitions are opened and range
table entries are created for them in the planner's prep phase, which
is much sooner than when partition pruning is performed.  This means
that query_planner ends up spending cycles and memory on many
partitions that potentially won't be included in the plan, such
as creating RelOptInfos, AppendRelInfos.

To avoid that, add partition range table entries and other planning
data structures for only partitions that remain after applying
partition pruning.

Some code like that of partitionwise join rely on the fact that even
though partitions may have been pruned, they would still have a
RelOptInfo, albeit marked dummy to handle the outer join case where
the pruned partition appears on the nullable side of join.  So this
commit also teaches the partitionwise join code to allocate dummy
RelOptInfos for pruned partitions.

There are couple of regression test diffs caused by the fact that
we no longer allocate a duplicate RT entry for a partitioned table
in its role as child and also that the individual partition RT
entries are now created in the order in which their parent's are
processed whereas previously they'd be added to the range table
in the order of depth-first expansion of the tree.
---
 src/backend/optimizer/path/allpaths.c             |  61 +++--
 src/backend/optimizer/path/joinrels.c             |   8 +
 src/backend/optimizer/plan/initsplan.c            |  66 +++++
 src/backend/optimizer/plan/planmain.c             |  30 ---
 src/backend/optimizer/plan/planner.c              |  12 +-
 src/backend/optimizer/prep/prepunion.c            | 314 +++++++++-------------
 src/backend/optimizer/util/plancat.c              |  20 +-
 src/backend/optimizer/util/relnode.c              | 172 ++++++++++--
 src/backend/partitioning/partprune.c              | 109 ++++----
 src/include/nodes/relation.h                      |   5 +
 src/include/optimizer/pathnode.h                  |   6 +
 src/include/optimizer/plancat.h                   |   2 +-
 src/include/optimizer/planmain.h                  |   3 +
 src/include/optimizer/prep.h                      |  10 +
 src/include/partitioning/partprune.h              |   2 +-
 src/test/regress/expected/join.out                |  22 +-
 src/test/regress/expected/partition_aggregate.out |   4 +-
 17 files changed, 507 insertions(+), 339 deletions(-)

diff --git a/src/backend/optimizer/path/allpaths.c b/src/backend/optimizer/path/allpaths.c
index 968cac42a3..e54cccd077 100644
--- a/src/backend/optimizer/path/allpaths.c
+++ b/src/backend/optimizer/path/allpaths.c
@@ -151,6 +151,7 @@ make_one_rel(PlannerInfo *root, List *joinlist)
 {
 	RelOptInfo *rel;
 	Index		rti;
+	double		total_pages;
 
 	/*
 	 * Construct the all_baserels Relids set.
@@ -181,6 +182,35 @@ make_one_rel(PlannerInfo *root, List *joinlist)
 	 * then generate access paths.
 	 */
 	set_base_rel_sizes(root);
+
+	/*
+	 * We should now have size estimates for every actual table involved in
+	 * the query, and we also know which if any have been deleted from the
+	 * query by join removal; so we can compute total_table_pages.
+	 *
+	 * Note that appendrels are not double-counted here, even though we don't
+	 * bother to distinguish RelOptInfos for appendrel parents, because the
+	 * parents will still have size zero.
+	 *
+	 * XXX if a table is self-joined, we will count it once per appearance,
+	 * which perhaps is the wrong thing ... but that's not completely clear,
+	 * and detecting self-joins here is difficult, so ignore it for now.
+	 */
+	total_pages = 0;
+	for (rti = 1; rti < root->simple_rel_array_size; rti++)
+	{
+		RelOptInfo *brel = root->simple_rel_array[rti];
+
+		if (brel == NULL)
+			continue;
+
+		Assert(brel->relid == rti); /* sanity check on array */
+
+		if (IS_SIMPLE_REL(brel))
+			total_pages += (double) brel->pages;
+	}
+	root->total_table_pages = total_pages;
+
 	set_base_rel_pathlists(root);
 
 	/*
@@ -897,8 +927,6 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 	double	   *parent_attrsizes;
 	int			nattrs;
 	ListCell   *l;
-	Relids		live_children = NULL;
-	bool		did_pruning = false;
 
 	/* Guard against stack overflow due to overly deep inheritance tree. */
 	check_stack_depth();
@@ -914,21 +942,14 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 	 * partitioned table's list will contain all such indexes.
 	 */
 	if (rte->relkind == RELKIND_PARTITIONED_TABLE)
+	{
 		rel->partitioned_child_rels = list_make1_int(rti);
 
-	/*
-	 * If the partitioned relation has any baserestrictinfo quals then we
-	 * attempt to use these quals to prune away partitions that cannot
-	 * possibly contain any tuples matching these quals.  In this case we'll
-	 * store the relids of all partitions which could possibly contain a
-	 * matching tuple, and skip anything else in the loop below.
-	 */
-	if (enable_partition_pruning &&
-		rte->relkind == RELKIND_PARTITIONED_TABLE &&
-		rel->baserestrictinfo != NIL)
-	{
-		live_children = prune_append_rel_partitions(rel);
-		did_pruning = true;
+		/*
+		 * And do prunin.  Note that this adds AppendRelInfo's of only the
+		 * partitions that are not pruned.
+		 */
+		prune_append_rel_partitions(root, rel);
 	}
 
 	/*
@@ -1117,13 +1138,10 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 
 		/*
 		 * Mark the child as empty in certain cases, such as if a restriction
-		 * clause reduced to constant FALSE or NULL, or if the partition
-		 * of a partitioned table has been pruned, or if constaint exclusion
+		 * clause reduced to constant FALSE or NULL, or if constaint exclusion
 		 * pruned it.
 		 */
 		if (have_const_false_cq ||
-			(did_pruning &&
-			 !bms_is_member(appinfo->child_relid, live_children)) ||
 			relation_excluded_by_constraints(root, childrel, childRTE))
 		{
 			/*
@@ -1136,10 +1154,6 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 									   (Node *) rel->reltarget->exprs,
 									   1, &appinfo);
 
-			/*
-			 * Some restriction clause reduced to constant FALSE or NULL after
-			 * substitution, so this child need not be scanned.
-			 */
 			set_dummy_rel_pathlist(childrel);
 			continue;
 		}
@@ -2653,6 +2667,7 @@ inheritance_make_rel_from_joinlist(PlannerInfo *root,
 			continue;
 
 		childrel = find_base_rel(root, appinfo->child_relid);
+		Assert(childrel != NULL);
 
 		/* Ignore excluded/pruned children. */
 		if (IS_DUMMY_REL(childrel))
diff --git a/src/backend/optimizer/path/joinrels.c b/src/backend/optimizer/path/joinrels.c
index d3d21fed5d..8543e633c2 100644
--- a/src/backend/optimizer/path/joinrels.c
+++ b/src/backend/optimizer/path/joinrels.c
@@ -1376,6 +1376,11 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
 		AppendRelInfo **appinfos;
 		int			nappinfos;
 
+		if (child_rel1 == NULL)
+			child_rel1 = build_dummy_partition_rel(root, rel1, cnt_parts);
+		if (child_rel2 == NULL)
+			child_rel2 = build_dummy_partition_rel(root, rel2, cnt_parts);
+
 		/* We should never try to join two overlapping sets of rels. */
 		Assert(!bms_overlap(child_rel1->relids, child_rel2->relids));
 		child_joinrelids = bms_union(child_rel1->relids, child_rel2->relids);
@@ -1414,6 +1419,9 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
 		populate_joinrel_with_paths(root, child_rel1, child_rel2,
 									child_joinrel, child_sjinfo,
 									child_restrictlist);
+		if (!IS_DUMMY_REL(child_joinrel))
+			joinrel->live_parts = bms_add_member(joinrel->live_parts,
+												 cnt_parts);
 	}
 }
 
diff --git a/src/backend/optimizer/plan/initsplan.c b/src/backend/optimizer/plan/initsplan.c
index 01335db511..beb3e95101 100644
--- a/src/backend/optimizer/plan/initsplan.c
+++ b/src/backend/optimizer/plan/initsplan.c
@@ -132,6 +132,72 @@ add_base_rels_to_query(PlannerInfo *root, Node *jtnode)
 			 (int) nodeTag(jtnode));
 }
 
+/*
+ * add_rel_partitions_to_query
+ *		create range table entries and "otherrel" RelOptInfos and for the
+ *		partitions of 'rel' specified by the caller
+ *
+ * To store the objects thus created, various arrays in 'root' are expanded
+ * by repalloc'ing them.
+ */
+void
+add_rel_partitions_to_query(PlannerInfo *root, RelOptInfo *rel,
+							bool scan_all_parts,
+							Bitmapset *partindexes)
+{
+	int		new_size;
+	int		num_added_parts;
+	int		i;
+
+	Assert(partindexes != NULL || scan_all_parts);
+
+	/* Expand the PlannerInfo arrays to hold new partition objects. */
+	num_added_parts = scan_all_parts ? rel->nparts :
+						bms_num_members(partindexes);
+	new_size = root->simple_rel_array_size + num_added_parts;
+	root->simple_rte_array = (RangeTblEntry **)
+							repalloc(root->simple_rte_array,
+									 sizeof(RangeTblEntry *) * new_size);
+	root->simple_rel_array = (RelOptInfo **)
+								repalloc(root->simple_rel_array,
+										 sizeof(RelOptInfo *) * new_size);
+	if (root->append_rel_array)
+		root->append_rel_array = (AppendRelInfo **)
+									repalloc(root->append_rel_array,
+									 sizeof(AppendRelInfo *) * new_size);
+	else
+		root->append_rel_array = (AppendRelInfo **)
+									palloc0(sizeof(AppendRelInfo *) *
+											new_size);
+
+	/* Set the contents of just allocated memory to 0. */
+	MemSet(root->simple_rte_array + root->simple_rel_array_size,
+		   0, sizeof(RangeTblEntry *) * num_added_parts);
+	MemSet(root->simple_rel_array + root->simple_rel_array_size,
+		   0, sizeof(RelOptInfo *) * num_added_parts);
+	MemSet(root->append_rel_array + root->simple_rel_array_size,
+		   0, sizeof(AppendRelInfo *) * num_added_parts);
+	root->simple_rel_array_size = new_size;
+
+	/* And add the partitions. */
+	if (scan_all_parts)
+	{
+		for (i = 0; i < rel->nparts; i++)
+		{
+			rel->part_rels[i] = build_partition_rel(root, rel,
+													rel->part_oids[i]);
+			rel->live_parts = bms_add_member(rel->live_parts, i);
+		}
+	}
+	else
+	{
+		rel->live_parts = partindexes;
+		i = -1;
+		while ((i = bms_next_member(partindexes, i)) >= 0)
+			rel->part_rels[i] = build_partition_rel(root, rel,
+													rel->part_oids[i]);
+	}
+}
 
 /*****************************************************************************
  *
diff --git a/src/backend/optimizer/plan/planmain.c b/src/backend/optimizer/plan/planmain.c
index 3f0d80eaa6..1bd3f0e350 100644
--- a/src/backend/optimizer/plan/planmain.c
+++ b/src/backend/optimizer/plan/planmain.c
@@ -57,8 +57,6 @@ query_planner(PlannerInfo *root, List *tlist,
 	Query	   *parse = root->parse;
 	List	   *joinlist;
 	RelOptInfo *final_rel;
-	Index		rti;
-	double		total_pages;
 
 	/*
 	 * If the query has an empty join tree, then it's something easy like
@@ -232,34 +230,6 @@ query_planner(PlannerInfo *root, List *tlist,
 	extract_restriction_or_clauses(root);
 
 	/*
-	 * We should now have size estimates for every actual table involved in
-	 * the query, and we also know which if any have been deleted from the
-	 * query by join removal; so we can compute total_table_pages.
-	 *
-	 * Note that appendrels are not double-counted here, even though we don't
-	 * bother to distinguish RelOptInfos for appendrel parents, because the
-	 * parents will still have size zero.
-	 *
-	 * XXX if a table is self-joined, we will count it once per appearance,
-	 * which perhaps is the wrong thing ... but that's not completely clear,
-	 * and detecting self-joins here is difficult, so ignore it for now.
-	 */
-	total_pages = 0;
-	for (rti = 1; rti < root->simple_rel_array_size; rti++)
-	{
-		RelOptInfo *brel = root->simple_rel_array[rti];
-
-		if (brel == NULL)
-			continue;
-
-		Assert(brel->relid == rti); /* sanity check on array */
-
-		if (IS_SIMPLE_REL(brel))
-			total_pages += (double) brel->pages;
-	}
-	root->total_table_pages = total_pages;
-
-	/*
 	 * Ready to do the primary planning.
 	 */
 	final_rel = make_one_rel(root, joinlist);
diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index 9636d7a4ee..a757aba551 100644
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -6708,18 +6708,21 @@ apply_scanjoin_target_to_paths(PlannerInfo *root,
 	 */
 	if (rel->part_scheme && rel->part_rels)
 	{
-		int			partition_idx;
+		int			i;
 		List	   *live_children = NIL;
 
 		/* Adjust each partition. */
-		for (partition_idx = 0; partition_idx < rel->nparts; partition_idx++)
+		i = -1;
+		while ((i = bms_next_member(rel->live_parts, i)) >= 0)
 		{
-			RelOptInfo *child_rel = rel->part_rels[partition_idx];
+			RelOptInfo *child_rel = rel->part_rels[i];
 			ListCell   *lc;
 			AppendRelInfo **appinfos;
 			int			nappinfos;
 			List	   *child_scanjoin_targets = NIL;
 
+			Assert(child_rel != NULL);
+
 			/* Translate scan/join targets for this child. */
 			appinfos = find_appinfos_by_relids(root, child_rel->relids,
 											   &nappinfos);
@@ -6821,6 +6824,9 @@ create_partitionwise_grouping_paths(PlannerInfo *root,
 		RelOptInfo *child_grouped_rel;
 		RelOptInfo *child_partially_grouped_rel;
 
+		if (child_input_rel == NULL)
+			continue;
+
 		/* Input child rel must have a path */
 		Assert(child_input_rel->pathlist != NIL);
 
diff --git a/src/backend/optimizer/prep/prepunion.c b/src/backend/optimizer/prep/prepunion.c
index f4c485cdc9..279f686fb0 100644
--- a/src/backend/optimizer/prep/prepunion.c
+++ b/src/backend/optimizer/prep/prepunion.c
@@ -49,6 +49,8 @@
 #include "parser/parse_coerce.h"
 #include "parser/parsetree.h"
 #include "utils/lsyscache.h"
+#include "utils/lsyscache.h"
+#include "utils/partcache.h"
 #include "utils/rel.h"
 #include "utils/selfuncs.h"
 #include "utils/syscache.h"
@@ -101,21 +103,10 @@ static List *generate_append_tlist(List *colTypes, List *colCollations,
 static List *generate_setop_grouplist(SetOperationStmt *op, List *targetlist);
 static void expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte,
 						 Index rti);
-static void expand_partitioned_rtentry(PlannerInfo *root,
-						   RangeTblEntry *parentrte,
-						   Index parentRTindex, Relation parentrel,
-						   PlanRowMark *top_parentrc, LOCKMODE lockmode,
-						   List **appinfos);
-static void expand_single_inheritance_child(PlannerInfo *root,
-								RangeTblEntry *parentrte,
-								Index parentRTindex, Relation parentrel,
-								PlanRowMark *top_parentrc, Relation childrel,
-								List **appinfos, RangeTblEntry **childrte_p,
-								Index *childRTindex_p);
-static void make_inh_translation_list(Relation oldrelation,
-						  Relation newrelation,
-						  Index newvarno,
-						  List **translated_vars);
+static void make_inh_translation_list(TupleDesc old_tupdesc,
+						  TupleDesc new_tupdesc,
+						  RangeTblEntry *oldrte, RangeTblEntry *newrte,
+						  Index newvarno, List **translated_vars);
 static Bitmapset *translate_col_privs(const Bitmapset *parent_privs,
 					List *translated_vars);
 static Node *adjust_appendrel_attrs_mutator(Node *node,
@@ -1522,6 +1513,7 @@ expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti)
 	LOCKMODE	lockmode;
 	List	   *inhOIDs;
 	ListCell   *l;
+	List	   *appinfos = NIL;
 
 	/* Does RT entry allow inheritance? */
 	if (!rte->inh)
@@ -1585,173 +1577,58 @@ expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti)
 	if (oldrc)
 		oldrc->isParent = true;
 
+	/* Partitioned tables are expanded elsewhere. */
+	if (rte->relkind == RELKIND_PARTITIONED_TABLE)
+	{
+		list_free(inhOIDs);
+		return;
+	}
+
 	/*
 	 * Must open the parent relation to examine its tupdesc.  We need not lock
 	 * it; we assume the rewriter already did.
 	 */
 	oldrelation = heap_open(parentOID, NoLock);
 
-	/* Scan the inheritance set and expand it */
-	if (RelationGetPartitionDesc(oldrelation) != NULL)
+	foreach(l, inhOIDs)
 	{
-		Assert(rte->relkind == RELKIND_PARTITIONED_TABLE);
+		Oid			childOID = lfirst_oid(l);
+		Index		childRTindex = 0;
+		RangeTblEntry *childrte = NULL;
+		AppendRelInfo *appinfo = NULL;
 
-		/*
-		 * If this table has partitions, recursively expand them in the order
-		 * in which they appear in the PartitionDesc.  While at it, also
-		 * extract the partition key columns of all the partitioned tables.
-		 */
-		expand_partitioned_rtentry(root, rte, rti, oldrelation, oldrc,
-								   lockmode, &root->append_rel_list);
+		add_inheritance_child_to_query(root, rte, rti,
+									   oldrelation->rd_rel->reltype,
+									   RelationGetDescr(oldrelation),
+									   oldrc, childOID, NoLock,
+									   &appinfo, &childrte,
+									   &childRTindex);
+		Assert(childRTindex > 1);
+		Assert(childrte != NULL);
+		Assert(appinfo != NULL);
+		appinfos = lappend(appinfos, appinfo);
 	}
+
+	/*
+	 * If all the children were temp tables, pretend it's a
+	 * non-inheritance situation; we don't need Append node in that case.
+	 * The duplicate RTE we added for the parent table is harmless, so we
+	 * don't bother to get rid of it; ditto for the useless PlanRowMark
+	 * node.
+	 */
+	if (list_length(appinfos) < 2)
+		rte->inh = false;
 	else
-	{
-		List	   *appinfos = NIL;
-		RangeTblEntry *childrte;
-		Index		childRTindex;
-
-		/*
-		 * This table has no partitions.  Expand any plain inheritance
-		 * children in the order the OIDs were returned by
-		 * find_all_inheritors.
-		 */
-		foreach(l, inhOIDs)
-		{
-			Oid			childOID = lfirst_oid(l);
-			Relation	newrelation;
-
-			/* Open rel if needed; we already have required locks */
-			if (childOID != parentOID)
-				newrelation = heap_open(childOID, NoLock);
-			else
-				newrelation = oldrelation;
-
-			/*
-			 * It is possible that the parent table has children that are temp
-			 * tables of other backends.  We cannot safely access such tables
-			 * (because of buffering issues), and the best thing to do seems
-			 * to be to silently ignore them.
-			 */
-			if (childOID != parentOID && RELATION_IS_OTHER_TEMP(newrelation))
-			{
-				heap_close(newrelation, lockmode);
-				continue;
-			}
-
-			expand_single_inheritance_child(root, rte, rti, oldrelation, oldrc,
-											newrelation,
-											&appinfos, &childrte,
-											&childRTindex);
-
-			/* Close child relations, but keep locks */
-			if (childOID != parentOID)
-				heap_close(newrelation, NoLock);
-		}
-
-		/*
-		 * If all the children were temp tables, pretend it's a
-		 * non-inheritance situation; we don't need Append node in that case.
-		 * The duplicate RTE we added for the parent table is harmless, so we
-		 * don't bother to get rid of it; ditto for the useless PlanRowMark
-		 * node.
-		 */
-		if (list_length(appinfos) < 2)
-			rte->inh = false;
-		else
-			root->append_rel_list = list_concat(root->append_rel_list,
-												appinfos);
-
-	}
+		root->append_rel_list = list_concat(root->append_rel_list,
+											appinfos);
 
 	heap_close(oldrelation, NoLock);
 }
 
 /*
- * expand_partitioned_rtentry
- *		Recursively expand an RTE for a partitioned table.
- *
- * Note that RelationGetPartitionDispatchInfo will expand partitions in the
- * same order as this code.
- */
-static void
-expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
-						   Index parentRTindex, Relation parentrel,
-						   PlanRowMark *top_parentrc, LOCKMODE lockmode,
-						   List **appinfos)
-{
-	int			i;
-	RangeTblEntry *childrte;
-	Index		childRTindex;
-	PartitionDesc partdesc = RelationGetPartitionDesc(parentrel);
-
-	check_stack_depth();
-
-	/* A partitioned table should always have a partition descriptor. */
-	Assert(partdesc);
-
-	Assert(parentrte->inh);
-
-	/*
-	 * Note down whether any partition key cols are being updated. Though it's
-	 * the root partitioned table's updatedCols we are interested in, we
-	 * instead use parentrte to get the updatedCols. This is convenient
-	 * because parentrte already has the root partrel's updatedCols translated
-	 * to match the attribute ordering of parentrel.
-	 */
-	if (!root->partColsUpdated)
-		root->partColsUpdated =
-			has_partition_attrs(parentrel, parentrte->updatedCols, NULL);
-
-	/* First expand the partitioned table itself. */
-	expand_single_inheritance_child(root, parentrte, parentRTindex, parentrel,
-									top_parentrc, parentrel,
-									appinfos, &childrte, &childRTindex);
-
-	/*
-	 * If the partitioned table has no partitions, treat this as the
-	 * non-inheritance case.
-	 */
-	if (partdesc->nparts == 0)
-	{
-		parentrte->inh = false;
-		return;
-	}
-
-	for (i = 0; i < partdesc->nparts; i++)
-	{
-		Oid			childOID = partdesc->oids[i];
-		Relation	childrel;
-
-		/* Open rel; we already have required locks */
-		childrel = heap_open(childOID, NoLock);
-
-		/*
-		 * Temporary partitions belonging to other sessions should have been
-		 * disallowed at definition, but for paranoia's sake, let's double
-		 * check.
-		 */
-		if (RELATION_IS_OTHER_TEMP(childrel))
-			elog(ERROR, "temporary relation from another session found as partition");
-
-		expand_single_inheritance_child(root, parentrte, parentRTindex,
-										parentrel, top_parentrc, childrel,
-										appinfos, &childrte, &childRTindex);
-
-		/* If this child is itself partitioned, recurse */
-		if (childrel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
-			expand_partitioned_rtentry(root, childrte, childRTindex,
-									   childrel, top_parentrc, lockmode,
-									   appinfos);
-
-		/* Close child relation, but keep locks */
-		heap_close(childrel, NoLock);
-	}
-}
-
-/*
- * expand_single_inheritance_child
+ * add_inheritance_child_to_query
  *		Build a RangeTblEntry and an AppendRelInfo, if appropriate, plus
- *		maybe a PlanRowMark.
+ *		maybe a PlanRowMark for a child relation.
  *
  * We now expand the partition hierarchy level by level, creating a
  * corresponding hierarchy of AppendRelInfos and RelOptInfos, where each
@@ -1769,19 +1646,70 @@ expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
  * The child RangeTblEntry and its RTI are returned in "childrte_p" and
  * "childRTindex_p" resp.
  */
-static void
-expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte,
-								Index parentRTindex, Relation parentrel,
-								PlanRowMark *top_parentrc, Relation childrel,
-								List **appinfos, RangeTblEntry **childrte_p,
-								Index *childRTindex_p)
+void
+add_inheritance_child_to_query(PlannerInfo *root, RangeTblEntry *parentrte,
+							   Index parentRTindex, Oid parentRelType,
+							   TupleDesc parentDesc,
+							   PlanRowMark *top_parentrc,
+							   Oid childOID, int lockmode,
+							   AppendRelInfo **appinfo_p,
+							   RangeTblEntry **childrte_p,
+							   Index *childRTindex_p)
 {
 	Query	   *parse = root->parse;
-	Oid			parentOID = RelationGetRelid(parentrel);
-	Oid			childOID = RelationGetRelid(childrel);
+	Oid			parentOID = parentrte->relid;
 	RangeTblEntry *childrte;
 	Index		childRTindex;
 	AppendRelInfo *appinfo;
+	Relation	childrel = NULL;
+	char		child_relkind;
+	Oid			child_reltype;
+	TupleDesc	childDesc;
+
+	*appinfo_p = NULL;
+	*childrte_p = NULL;
+	*childRTindex_p = 0;
+
+	/* Open rel if needed; we already have required locks */
+	if (childOID != parentOID)
+	{
+		childrel = heap_open(childOID, lockmode);
+
+		/*
+		 * Temporary partitions belonging to other sessions should have been
+		 * disallowed at definition, but for paranoia's sake, let's double
+		 * check.
+		 */
+		if (RELATION_IS_OTHER_TEMP(childrel))
+		{
+			if (childrel->rd_rel->relispartition)
+				elog(ERROR, "temporary relation from another session found as partition");
+			heap_close(childrel, lockmode);
+			return;
+		}
+
+		child_relkind = childrel->rd_rel->relkind;
+
+		/*
+		 * No point in adding to the query a partitioned table that has no
+		 * partitions.
+		 */
+		if (child_relkind == RELKIND_PARTITIONED_TABLE &&
+			RelationGetPartitionDesc(childrel)->nparts == 0)
+		{
+			heap_close(childrel, lockmode);
+			return;
+		}
+
+		child_reltype = childrel->rd_rel->reltype;
+		childDesc = RelationGetDescr(childrel);
+	}
+	else
+	{
+		child_relkind = parentrte->relkind;
+		child_reltype =  parentRelType;
+		childDesc = parentDesc;
+	}
 
 	/*
 	 * Build an RTE for the child, and attach to query's rangetable list. We
@@ -1798,7 +1726,7 @@ expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte,
 	childrte = copyObject(parentrte);
 	*childrte_p = childrte;
 	childrte->relid = childOID;
-	childrte->relkind = childrel->rd_rel->relkind;
+	childrte->relkind = child_relkind;
 	/* A partitioned child will need to be expanded further. */
 	if (childOID != parentOID &&
 		childrte->relkind == RELKIND_PARTITIONED_TABLE)
@@ -1823,12 +1751,13 @@ expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte,
 		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->parent_reltype = parentRelType;
+		appinfo->child_reltype = child_reltype;
+		make_inh_translation_list(parentDesc, childDesc,
+								  parentrte, childrte, childRTindex,
 								  &appinfo->translated_vars);
 		appinfo->parent_reloid = parentOID;
-		*appinfos = lappend(*appinfos, appinfo);
+		*appinfo_p = appinfo;
 
 		/*
 		 * Translate the column permissions bitmaps to the child's attnums (we
@@ -1879,6 +1808,13 @@ expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte,
 
 		root->rowMarks = lappend(root->rowMarks, childrc);
 	}
+
+	/* Close child relations, but keep locks */
+	if (childOID != parentOID)
+	{
+		Assert(childrel != NULL);
+		heap_close(childrel, lockmode);
+	}
 }
 
 /*
@@ -1889,14 +1825,12 @@ expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte,
  * For paranoia's sake, we match type/collation as well as attribute name.
  */
 static void
-make_inh_translation_list(Relation oldrelation, Relation newrelation,
-						  Index newvarno,
-						  List **translated_vars)
+make_inh_translation_list(TupleDesc old_tupdesc, TupleDesc new_tupdesc,
+						  RangeTblEntry *oldrte, RangeTblEntry *newrte,
+						  Index newvarno, List **translated_vars)
 {
 	List	   *vars = NIL;
-	TupleDesc	old_tupdesc = RelationGetDescr(oldrelation);
-	TupleDesc	new_tupdesc = RelationGetDescr(newrelation);
-	Oid			new_relid = RelationGetRelid(newrelation);
+	Oid			new_relid = newrte->relid;
 	int			oldnatts = old_tupdesc->natts;
 	int			newnatts = new_tupdesc->natts;
 	int			old_attno;
@@ -1926,7 +1860,7 @@ make_inh_translation_list(Relation oldrelation, Relation newrelation,
 		 * When we are generating the "translation list" for the parent table
 		 * of an inheritance set, no need to search for matches.
 		 */
-		if (oldrelation == newrelation)
+		if (oldrte->relid == newrte->relid)
 		{
 			vars = lappend(vars, makeVar(newvarno,
 										 (AttrNumber) (old_attno + 1),
@@ -1955,7 +1889,7 @@ make_inh_translation_list(Relation oldrelation, Relation newrelation,
 			newtup = SearchSysCacheAttName(new_relid, attname);
 			if (!newtup)
 				elog(ERROR, "could not find inherited attribute \"%s\" of relation \"%s\"",
-					 attname, RelationGetRelationName(newrelation));
+					 attname, get_rel_name(newrte->relid));
 			new_attno = ((Form_pg_attribute) GETSTRUCT(newtup))->attnum - 1;
 			ReleaseSysCache(newtup);
 
@@ -1965,10 +1899,10 @@ make_inh_translation_list(Relation oldrelation, Relation newrelation,
 		/* Found it, check type and collation match */
 		if (atttypid != att->atttypid || atttypmod != att->atttypmod)
 			elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's type",
-				 attname, RelationGetRelationName(newrelation));
+				 attname, get_rel_name(newrte->relid));
 		if (attcollation != att->attcollation)
 			elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's collation",
-				 attname, RelationGetRelationName(newrelation));
+				 attname, get_rel_name(newrte->relid));
 
 		vars = lappend(vars, makeVar(newvarno,
 									 (AttrNumber) (new_attno + 1),
@@ -2121,7 +2055,7 @@ adjust_appendrel_attrs_mutator(Node *node,
 			}
 		}
 
-		if (var->varlevelsup == 0 && appinfo)
+		if (var->varlevelsup == 0 && appinfo && appinfo->translated_vars)
 		{
 			var->varno = appinfo->child_relid;
 			var->varnoold = appinfo->child_relid;
diff --git a/src/backend/optimizer/util/plancat.c b/src/backend/optimizer/util/plancat.c
index 5a37221780..77ae4b538a 100644
--- a/src/backend/optimizer/util/plancat.c
+++ b/src/backend/optimizer/util/plancat.c
@@ -106,7 +106,7 @@ static void set_baserel_partition_key_exprs(Relation relation,
  */
 void
 get_relation_info(PlannerInfo *root, Oid relationObjectId, bool inhparent,
-				  RelOptInfo *rel)
+				  Bitmapset *updatedCols, RelOptInfo *rel)
 {
 	Index		varno = rel->relid;
 	Relation	relation;
@@ -449,7 +449,15 @@ get_relation_info(PlannerInfo *root, Oid relationObjectId, bool inhparent,
 	 * inheritance parents may be partitioned.
 	 */
 	if (inhparent && relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
+	{
 		set_relation_partition_info(root, rel, relation);
+		if (!root->partColsUpdated)
+			root->partColsUpdated =
+				has_partition_attrs(relation, updatedCols, NULL);
+	}
+
+	rel->tupdesc = RelationGetDescr(relation);
+	rel->reltype = RelationGetForm(relation)->reltype;
 
 	heap_close(relation, NoLock);
 
@@ -1855,16 +1863,20 @@ set_relation_partition_info(PlannerInfo *root, RelOptInfo *rel,
 							Relation relation)
 {
 	PartitionDesc partdesc;
-	PartitionKey partkey;
 
 	Assert(relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE);
 
 	partdesc = RelationGetPartitionDesc(relation);
-	partkey = RelationGetPartitionKey(relation);
 	rel->part_scheme = find_partition_scheme(root, relation);
 	Assert(partdesc != NULL && rel->part_scheme != NULL);
-	rel->boundinfo = partition_bounds_copy(partdesc->boundinfo, partkey);
 	rel->nparts = partdesc->nparts;
+
+	/*
+	 * Since we must've taken a lock on the table, it's okay to simply copy
+	 * the pointers to relcache data here.
+	 */
+	rel->part_oids = partdesc->oids;
+	rel->boundinfo = partdesc->boundinfo;
 	set_baserel_partition_key_exprs(relation, rel);
 	rel->partition_qual = RelationGetPartitionQual(relation);
 }
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index 39f5729b91..d73b4a8499 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -16,6 +16,7 @@
 
 #include <limits.h>
 
+#include "catalog/pg_class.h"
 #include "miscadmin.h"
 #include "optimizer/clauses.h"
 #include "optimizer/cost.h"
@@ -27,6 +28,7 @@
 #include "optimizer/restrictinfo.h"
 #include "optimizer/tlist.h"
 #include "partitioning/partbounds.h"
+#include "storage/lockdefs.h"
 #include "utils/hsearch.h"
 
 
@@ -142,6 +144,7 @@ build_simple_rel(PlannerInfo *root, int relid, RelOptInfo *parent)
 
 	/* Rel should not exist already */
 	Assert(relid > 0 && relid < root->simple_rel_array_size);
+
 	if (root->simple_rel_array[relid] != NULL)
 		elog(ERROR, "rel %d already exists", relid);
 
@@ -224,7 +227,8 @@ build_simple_rel(PlannerInfo *root, int relid, RelOptInfo *parent)
 	{
 		case RTE_RELATION:
 			/* Table --- retrieve statistics from the system catalogs */
-			get_relation_info(root, rte->relid, rte->inh, rel);
+			get_relation_info(root, rte->relid, rte->inh, rte->updatedCols,
+							  rel);
 			break;
 		case RTE_SUBQUERY:
 		case RTE_FUNCTION:
@@ -274,41 +278,30 @@ build_simple_rel(PlannerInfo *root, int relid, RelOptInfo *parent)
 	if (rte->inh)
 	{
 		ListCell   *l;
-		int			nparts = rel->nparts;
-		int			cnt_parts = 0;
 
-		if (nparts > 0)
+		/*
+		 * For partitioned tables, we just allocate space for RelOptInfo's.
+		 * pointers for all partitions and copy the partition OIDs from the
+		 * relcache.  Actual RelOptInfo is built for a partition only if it is
+		 * not pruned.
+		 */
+		if (rte->relkind == RELKIND_PARTITIONED_TABLE)
+		{
 			rel->part_rels = (RelOptInfo **)
-				palloc(sizeof(RelOptInfo *) * nparts);
+				palloc0(sizeof(RelOptInfo *) * rel->nparts);
+			return rel;
+		}
 
 		foreach(l, root->append_rel_list)
 		{
 			AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(l);
-			RelOptInfo *childrel;
 
 			/* append_rel_list contains all append rels; ignore others */
 			if (appinfo->parent_relid != relid)
 				continue;
 
-			childrel = build_simple_rel(root, appinfo->child_relid,
-										rel);
-
-			/* Nothing more to do for an unpartitioned table. */
-			if (!rel->part_scheme)
-				continue;
-
-			/*
-			 * The order of partition OIDs in append_rel_list is the same as
-			 * the order in the PartitionDesc, so the order of part_rels will
-			 * also match the PartitionDesc.  See expand_partitioned_rtentry.
-			 */
-			Assert(cnt_parts < nparts);
-			rel->part_rels[cnt_parts] = childrel;
-			cnt_parts++;
+			(void) build_simple_rel(root, appinfo->child_relid, rel);
 		}
-
-		/* We should have seen all the child partitions. */
-		Assert(cnt_parts == nparts);
 	}
 
 	return rel;
@@ -1747,6 +1740,137 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
 		joinrel->partexprs[cnt] = partexpr;
 		joinrel->nullable_partexprs[cnt] = nullable_partexpr;
 	}
+
+	/* Partitions will be added by try_partitionwise_join. */
+	joinrel->live_parts = NULL;
+}
+
+/*
+ * build_dummy_partition_rel
+ *		Build a RelOptInfo and AppendRelInfo for a pruned partition
+ *
+ * This does not result in opening the relation or a range table entry being
+ * created.  Also, the RelOptInfo thus created is not stored anywhere else
+ * beside the parent's part_rels array.
+ *
+ * The only reason this exists is because partition-wise join, in some cases,
+ * needs a RelOptInfo to represent an empty relation that's on the nullable
+ * side of an outer join, so that a Path representing the outer join can be
+ * created.
+ */
+RelOptInfo *
+build_dummy_partition_rel(PlannerInfo *root, RelOptInfo *parent, int partidx)
+{
+	RelOptInfo *rel;
+
+	Assert(parent->part_rels[partidx] == NULL);
+
+	/* Create minimally valid-looking RelOptInfo with parent's relid. */
+	rel = makeNode(RelOptInfo);
+	rel->reloptkind = RELOPT_OTHER_MEMBER_REL;
+	rel->relid = parent->relid;
+	rel->relids = bms_copy(parent->relids);
+	if (parent->top_parent_relids)
+		rel->top_parent_relids = parent->top_parent_relids;
+	else
+		rel->top_parent_relids = bms_copy(parent->relids);
+	rel->reltarget = copy_pathtarget(parent->reltarget);
+	parent->part_rels[partidx] = rel;
+	mark_dummy_rel(rel);
+
+	/*
+	 * Now we'll need a (noop) AppendRelInfo for parent, because we're setting
+	 * the dummy partition's relid to be same as the parent's.
+	 */
+	if (root->append_rel_array[parent->relid] == NULL)
+	{
+		AppendRelInfo *appinfo = makeNode(AppendRelInfo);
+
+		appinfo->parent_relid = parent->relid;
+		appinfo->child_relid = parent->relid;
+		appinfo->parent_reltype = parent->reltype;
+		appinfo->child_reltype = parent->reltype;
+		/* leaving translated_vars to NIL to mean no translation needed */
+		appinfo->parent_reloid = root->simple_rte_array[parent->relid]->relid;
+		root->append_rel_array[parent->relid] = appinfo;
+	}
+
+	return rel;
+}
+
+/*
+ * build_partition_rel
+ *		This adds a valid partition to the query by adding it to the
+ *		range table and creating planner data structures for it
+ */
+RelOptInfo *
+build_partition_rel(PlannerInfo *root, RelOptInfo *parent, Oid partoid)
+{
+	RangeTblEntry *parentrte = root->simple_rte_array[parent->relid];
+	RelOptInfo *result;
+	Index		partRTindex = 0;
+	RangeTblEntry *partrte = NULL;
+	AppendRelInfo *appinfo = NULL;
+	PlanRowMark *rootrc = NULL;
+
+	/* Locate the root partitioned table and fetch its PlanRowMark, if any. */
+	if (root->rowMarks)
+	{
+		Index		rootRTindex = 0;
+
+		/*
+		 * The root partitioned table itself might be a child of UNION ALL
+		 * parent, so we must resort to finding the root parent like this.
+		 */
+		rootRTindex = parent->relid;
+		if (root->append_rel_array[rootRTindex])
+		{
+			AppendRelInfo *tmp = root->append_rel_array[rootRTindex];
+
+			/*
+			 * Keep moving up until we each the parent rel that's not a
+			 * partitioned table.  The one before that one would be the root
+			 * parent.
+			 */
+			while(root->simple_rel_array[rootRTindex]->part_scheme)
+			{
+				tmp = root->append_rel_array[tmp->parent_relid];
+				if (tmp == NULL)
+					break;
+				rootRTindex = tmp->parent_relid;
+			}
+		}
+
+		rootrc = get_plan_rowmark(root->rowMarks, rootRTindex);
+	}
+
+	/*
+	 * expand_inherited_rtentry alreay locked all partitions, so pass
+	 * NoLock for lockmode.
+	 */
+	add_inheritance_child_to_query(root, parentrte, parent->relid,
+								   parent->reltype, parent->tupdesc,
+								   rootrc, partoid, NoLock,
+								   &appinfo, &partrte, &partRTindex);
+
+	/* Partition turned out to be a partitioned table with 0 partitions. */
+	if (partrte == NULL)
+		return NULL;
+
+	Assert(appinfo != NULL);
+	root->append_rel_list = lappend(root->append_rel_list, appinfo);
+	root->simple_rte_array[partRTindex] = partrte;
+	root->append_rel_array[partRTindex] = appinfo;
+
+	/* Build the RelOptInfo. */
+	result = build_simple_rel(root, partRTindex, parent);
+
+	/* Set the information created by create_lateral_join_info(). */
+	result->direct_lateral_relids = parent->direct_lateral_relids;
+	result->lateral_relids = parent->lateral_relids;
+	result->lateral_referencers = parent->lateral_referencers;
+
+	return result;
 }
 
 /*
diff --git a/src/backend/partitioning/partprune.c b/src/backend/partitioning/partprune.c
index e1ce8b4ddc..345ab19989 100644
--- a/src/backend/partitioning/partprune.c
+++ b/src/backend/partitioning/partprune.c
@@ -45,7 +45,9 @@
 #include "nodes/makefuncs.h"
 #include "nodes/nodeFuncs.h"
 #include "optimizer/clauses.h"
+#include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
+#include "optimizer/planmain.h"
 #include "optimizer/planner.h"
 #include "optimizer/predtest.h"
 #include "optimizer/prep.h"
@@ -437,26 +439,26 @@ make_partitionedrel_pruneinfo(PlannerInfo *root, RelOptInfo *parentrel,
 		 * is, not pruned already).
 		 */
 		subplan_map = (int *) palloc(nparts * sizeof(int));
+		memset(subplan_map, -1, nparts * sizeof(int));
 		subpart_map = (int *) palloc(nparts * sizeof(int));
-		present_parts = NULL;
+		memset(subpart_map, -1, nparts * sizeof(int));
+		Assert(IS_SIMPLE_REL(subpart));
+		present_parts = bms_copy(subpart->live_parts);
 
-		for (i = 0; i < nparts; i++)
+		i = -1;
+		while ((i = bms_next_member(present_parts, i)) >= 0)
 		{
 			RelOptInfo *partrel = subpart->part_rels[i];
-			int			subplanidx = relid_subplan_map[partrel->relid] - 1;
-			int			subpartidx = relid_subpart_map[partrel->relid] - 1;
+			int			subplanidx;
+			int			subpartidx;
 
+			subplanidx = relid_subplan_map[partrel->relid] - 1;
+			subpartidx = relid_subpart_map[partrel->relid] - 1;
 			subplan_map[i] = subplanidx;
 			subpart_map[i] = subpartidx;
+			/* Record finding this subplan  */
 			if (subplanidx >= 0)
-			{
-				present_parts = bms_add_member(present_parts, i);
-
-				/* Record finding this subplan  */
 				subplansfound = bms_add_member(subplansfound, subplanidx);
-			}
-			else if (subpartidx >= 0)
-				present_parts = bms_add_member(present_parts, i);
 		}
 
 		rte = root->simple_rte_array[subpart->relid];
@@ -548,61 +550,68 @@ gen_partprune_steps(RelOptInfo *rel, List *clauses, bool *contradictory)
  *
  * Callers must ensure that 'rel' is a partitioned table.
  */
-Relids
-prune_append_rel_partitions(RelOptInfo *rel)
+void
+prune_append_rel_partitions(PlannerInfo *root, RelOptInfo *rel)
 {
-	Relids		result;
 	List	   *clauses = rel->baserestrictinfo;
 	List	   *pruning_steps;
-	bool		contradictory;
+	bool		contradictory,
+				scan_all_parts = false;
 	PartitionPruneContext context;
-	Bitmapset  *partindexes;
-	int			i;
+	Bitmapset  *partindexes = NULL;
 
-	Assert(clauses != NIL);
 	Assert(rel->part_scheme != NULL);
 
 	/* If there are no partitions, return the empty set */
 	if (rel->nparts == 0)
-		return NULL;
+		return;
 
-	/*
-	 * Process clauses.  If the clauses are found to be contradictory, we can
-	 * return the empty set.
-	 */
-	pruning_steps = gen_partprune_steps(rel, clauses, &contradictory);
-	if (contradictory)
-		return NULL;
-
-	/* Set up PartitionPruneContext */
-	context.strategy = rel->part_scheme->strategy;
-	context.partnatts = rel->part_scheme->partnatts;
-	context.nparts = rel->nparts;
-	context.boundinfo = rel->boundinfo;
-	context.partcollation = rel->part_scheme->partcollation;
-	context.partsupfunc = rel->part_scheme->partsupfunc;
-	context.stepcmpfuncs = (FmgrInfo *) palloc0(sizeof(FmgrInfo) *
+	if (enable_partition_pruning && clauses != NIL)
+	{
+		/*
+		 * Process clauses.  If the clauses are found to be contradictory, we
+		 * can return the empty set.
+		 */
+		pruning_steps = gen_partprune_steps(rel, clauses, &contradictory);
+		if (!contradictory)
+		{
+			context.strategy = rel->part_scheme->strategy;
+			context.partnatts = rel->part_scheme->partnatts;
+			context.nparts = rel->nparts;
+			context.boundinfo = rel->boundinfo;
+			context.partcollation = rel->part_scheme->partcollation;
+			context.partsupfunc = rel->part_scheme->partsupfunc;
+			context.stepcmpfuncs = (FmgrInfo *)
+										palloc0(sizeof(FmgrInfo) *
 												context.partnatts *
 												list_length(pruning_steps));
-	context.ppccontext = CurrentMemoryContext;
+			context.ppccontext = CurrentMemoryContext;
 
-	/* These are not valid when being called from the planner */
-	context.partrel = NULL;
-	context.planstate = NULL;
-	context.exprstates = NULL;
-	context.exprhasexecparam = NULL;
-	context.evalexecparams = false;
+			/* These are not valid when being called from the planner */
+			context.partrel = NULL;
+			context.planstate = NULL;
+			context.exprstates = NULL;
+			context.exprhasexecparam = NULL;
+			context.evalexecparams = false;
 
-	/* Actual pruning happens here. */
-	partindexes = get_matching_partitions(&context, pruning_steps);
+			/* Actual pruning happens here. */
+			partindexes = get_matching_partitions(&context, pruning_steps);
 
-	/* Add selected partitions' RT indexes to result. */
-	i = -1;
-	result = NULL;
-	while ((i = bms_next_member(partindexes, i)) >= 0)
-		result = bms_add_member(result, rel->part_rels[i]->relid);
+			/* No need to add partitions if all were pruned. */
+			if (bms_is_empty(partindexes))
+				return;
+		}
+		else
+			scan_all_parts = true;
+	}
+	else
+		scan_all_parts = true;
 
-	return result;
+	/*
+	 * Build selected partitions' range table entries, RelOptInfos, and
+	 * AppendRelInfos.
+	 */
+	add_rel_partitions_to_query(root, rel, scan_all_parts, partindexes);
 }
 
 /*
diff --git a/src/include/nodes/relation.h b/src/include/nodes/relation.h
index c008d626a1..051796e1f7 100644
--- a/src/include/nodes/relation.h
+++ b/src/include/nodes/relation.h
@@ -15,6 +15,7 @@
 #define RELATION_H
 
 #include "access/sdir.h"
+#include "access/tupdesc.h"
 #include "fmgr.h"
 #include "lib/stringinfo.h"
 #include "nodes/params.h"
@@ -699,11 +700,15 @@ typedef struct RelOptInfo
 	int			nparts;			/* number of partitions */
 	struct PartitionBoundInfoData *boundinfo;	/* Partition bounds */
 	List	   *partition_qual; /* partition constraint */
+	Oid		   *part_oids;		/* partition OIDs */
 	struct RelOptInfo **part_rels;	/* Array of RelOptInfos of partitions,
 									 * stored in the same order of bounds */
+	Bitmapset  *live_parts;		/* unpruned parts; NULL if all are live */
 	List	  **partexprs;		/* Non-nullable partition key expressions. */
 	List	  **nullable_partexprs; /* Nullable partition key expressions. */
 	List	   *partitioned_child_rels; /* List of RT indexes. */
+	TupleDesc	tupdesc;
+	Oid			reltype;
 } RelOptInfo;
 
 /*
diff --git a/src/include/optimizer/pathnode.h b/src/include/optimizer/pathnode.h
index 7c5ff22650..4f567765a4 100644
--- a/src/include/optimizer/pathnode.h
+++ b/src/include/optimizer/pathnode.h
@@ -297,5 +297,11 @@ extern RelOptInfo *build_child_join_rel(PlannerInfo *root,
 					 RelOptInfo *outer_rel, RelOptInfo *inner_rel,
 					 RelOptInfo *parent_joinrel, List *restrictlist,
 					 SpecialJoinInfo *sjinfo, JoinType jointype);
+extern RelOptInfo *build_dummy_partition_rel(PlannerInfo *root,
+									RelOptInfo *parent,
+									int partidx);
+extern RelOptInfo *build_partition_rel(PlannerInfo *root,
+									   RelOptInfo *parent,
+									   Oid partoid);
 
 #endif							/* PATHNODE_H */
diff --git a/src/include/optimizer/plancat.h b/src/include/optimizer/plancat.h
index 7d53cbbb87..edaf2a3b4f 100644
--- a/src/include/optimizer/plancat.h
+++ b/src/include/optimizer/plancat.h
@@ -26,7 +26,7 @@ extern PGDLLIMPORT get_relation_info_hook_type get_relation_info_hook;
 
 
 extern void get_relation_info(PlannerInfo *root, Oid relationObjectId,
-				  bool inhparent, RelOptInfo *rel);
+				  bool inhparent, Bitmapset *updatedCols, RelOptInfo *rel);
 
 extern List *infer_arbiter_indexes(PlannerInfo *root);
 
diff --git a/src/include/optimizer/planmain.h b/src/include/optimizer/planmain.h
index c8ab0280d2..1916a33467 100644
--- a/src/include/optimizer/planmain.h
+++ b/src/include/optimizer/planmain.h
@@ -73,6 +73,9 @@ extern int	from_collapse_limit;
 extern int	join_collapse_limit;
 
 extern void add_base_rels_to_query(PlannerInfo *root, Node *jtnode);
+extern void add_rel_partitions_to_query(PlannerInfo *root, RelOptInfo *rel,
+							bool scan_all_parts,
+							Bitmapset *partindexes);
 extern void build_base_rel_tlists(PlannerInfo *root, List *final_tlist);
 extern void add_vars_to_targetlist(PlannerInfo *root, List *vars,
 					   Relids where_needed, bool create_new_ph);
diff --git a/src/include/optimizer/prep.h b/src/include/optimizer/prep.h
index 38608770a2..ca66f75544 100644
--- a/src/include/optimizer/prep.h
+++ b/src/include/optimizer/prep.h
@@ -49,6 +49,16 @@ extern RelOptInfo *plan_set_operations(PlannerInfo *root);
 
 extern void expand_inherited_tables(PlannerInfo *root);
 
+extern void add_inheritance_child_to_query(PlannerInfo *root,
+								RangeTblEntry *parentrte,
+								Index parentRTindex, Oid parentRelType,
+								TupleDesc parentDesc,
+								PlanRowMark *top_parentrc,
+								Oid childOID, int lockmode,
+								AppendRelInfo **appinfo_p,
+								RangeTblEntry **childrte_p,
+								Index *childRTindex_p);
+
 extern Node *adjust_appendrel_attrs(PlannerInfo *root, Node *node,
 					   int nappinfos, AppendRelInfo **appinfos);
 
diff --git a/src/include/partitioning/partprune.h b/src/include/partitioning/partprune.h
index b95c346bab..55a324583b 100644
--- a/src/include/partitioning/partprune.h
+++ b/src/include/partitioning/partprune.h
@@ -79,7 +79,7 @@ extern PartitionPruneInfo *make_partition_pruneinfo(PlannerInfo *root,
 						 List *subpaths,
 						 List *partitioned_rels,
 						 List *prunequal);
-extern Relids prune_append_rel_partitions(RelOptInfo *rel);
+extern void prune_append_rel_partitions(PlannerInfo *root, RelOptInfo *rel);
 extern Bitmapset *get_matching_partitions(PartitionPruneContext *context,
 						List *pruning_steps);
 
diff --git a/src/test/regress/expected/join.out b/src/test/regress/expected/join.out
index dc6262be43..5f931591a6 100644
--- a/src/test/regress/expected/join.out
+++ b/src/test/regress/expected/join.out
@@ -5533,29 +5533,29 @@ select t1.b, ss.phv from join_ut1 t1 left join lateral
               (select t2.a as t2a, t3.a t3a, least(t1.a, t2.a, t3.a) phv
 					  from join_pt1 t2 join join_ut1 t3 on t2.a = t3.b) ss
               on t1.a = ss.t2a order by t1.a;
-                            QUERY PLAN                            
-------------------------------------------------------------------
+                             QUERY PLAN                             
+--------------------------------------------------------------------
  Sort
-   Output: t1.b, (LEAST(t1.a, t2.a, t3.a)), t1.a
+   Output: t1.b, (LEAST(t1.a, t2_1.a, t3.a)), t1.a
    Sort Key: t1.a
    ->  Nested Loop Left Join
-         Output: t1.b, (LEAST(t1.a, t2.a, t3.a)), t1.a
+         Output: t1.b, (LEAST(t1.a, t2_1.a, t3.a)), t1.a
          ->  Seq Scan on public.join_ut1 t1
                Output: t1.a, t1.b, t1.c
          ->  Hash Join
-               Output: t2.a, LEAST(t1.a, t2.a, t3.a)
-               Hash Cond: (t3.b = t2.a)
+               Output: t2_1.a, LEAST(t1.a, t2_1.a, t3.a)
+               Hash Cond: (t3.b = t2_1.a)
                ->  Seq Scan on public.join_ut1 t3
                      Output: t3.a, t3.b, t3.c
                ->  Hash
-                     Output: t2.a
+                     Output: t2_1.a
                      ->  Append
-                           ->  Seq Scan on public.join_pt1p1p1 t2
-                                 Output: t2.a
-                                 Filter: (t1.a = t2.a)
-                           ->  Seq Scan on public.join_pt1p2 t2_1
+                           ->  Seq Scan on public.join_pt1p1p1 t2_1
                                  Output: t2_1.a
                                  Filter: (t1.a = t2_1.a)
+                           ->  Seq Scan on public.join_pt1p2 t2
+                                 Output: t2.a
+                                 Filter: (t1.a = t2.a)
 (21 rows)
 
 select t1.b, ss.phv from join_ut1 t1 left join lateral
diff --git a/src/test/regress/expected/partition_aggregate.out b/src/test/regress/expected/partition_aggregate.out
index 6bc106831e..1450cef057 100644
--- a/src/test/regress/expected/partition_aggregate.out
+++ b/src/test/regress/expected/partition_aggregate.out
@@ -144,7 +144,7 @@ SELECT c, sum(a) FROM pagg_tab WHERE 1 = 2 GROUP BY c;
            QUERY PLAN           
 --------------------------------
  HashAggregate
-   Group Key: pagg_tab.c
+   Group Key: c
    ->  Result
          One-Time Filter: false
 (4 rows)
@@ -159,7 +159,7 @@ SELECT c, sum(a) FROM pagg_tab WHERE c = 'x' GROUP BY c;
            QUERY PLAN           
 --------------------------------
  GroupAggregate
-   Group Key: pagg_tab.c
+   Group Key: c
    ->  Result
          One-Time Filter: false
 (4 rows)
-- 
2.11.0

From 4255d72da27982934b27da9ae5268ba1d553c2d8 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Thu, 23 Aug 2018 17:30:18 +0900
Subject: [PATCH v3 3/4] Only lock partitions that will be scanned by a query

---
 src/backend/optimizer/prep/preptlist.c | 127 ++++++++++++++++++---------------
 src/backend/optimizer/prep/prepunion.c |  15 ++--
 src/backend/optimizer/util/relnode.c   |  36 +++++++---
 src/include/optimizer/prep.h           |   6 +-
 4 files changed, 111 insertions(+), 73 deletions(-)

diff --git a/src/backend/optimizer/prep/preptlist.c b/src/backend/optimizer/prep/preptlist.c
index 8603feef2b..3f93e5933e 100644
--- a/src/backend/optimizer/prep/preptlist.c
+++ b/src/backend/optimizer/prep/preptlist.c
@@ -76,7 +76,6 @@ preprocess_targetlist(PlannerInfo *root)
 	RangeTblEntry *target_rte = NULL;
 	Relation	target_relation = NULL;
 	List	   *tlist;
-	ListCell   *lc;
 
 	/*
 	 * If there is a result relation, open it so we can look for missing
@@ -118,12 +117,78 @@ preprocess_targetlist(PlannerInfo *root)
 		tlist = expand_targetlist(tlist, command_type,
 								  result_relation, target_relation);
 
+
+	tlist = add_rowmark_columns(root, tlist, root->rowMarks);
+
 	/*
-	 * Add necessary junk columns for rowmarked rels.  These values are needed
-	 * for locking of rels selected FOR UPDATE/SHARE, and to do EvalPlanQual
-	 * rechecking.  See comments for PlanRowMark in plannodes.h.
+	 * If the query has a RETURNING list, add resjunk entries for any Vars
+	 * used in RETURNING that belong to other relations.  We need to do this
+	 * to make these Vars available for the RETURNING calculation.  Vars that
+	 * belong to the result rel don't need to be added, because they will be
+	 * made to refer to the actual heap tuple.
 	 */
-	foreach(lc, root->rowMarks)
+	if (parse->returningList && list_length(parse->rtable) > 1)
+	{
+		List	   *vars;
+		ListCell   *l;
+
+		vars = pull_var_clause((Node *) parse->returningList,
+							   PVC_RECURSE_AGGREGATES |
+							   PVC_RECURSE_WINDOWFUNCS |
+							   PVC_INCLUDE_PLACEHOLDERS);
+		foreach(l, vars)
+		{
+			Var		   *var = (Var *) lfirst(l);
+			TargetEntry *tle;
+
+			if (IsA(var, Var) &&
+				var->varno == result_relation)
+				continue;		/* don't need it */
+
+			if (tlist_member((Expr *) var, tlist))
+				continue;		/* already got it */
+
+			tle = makeTargetEntry((Expr *) var,
+								  list_length(tlist) + 1,
+								  NULL,
+								  true);
+
+			tlist = lappend(tlist, tle);
+		}
+		list_free(vars);
+	}
+
+	/*
+	 * If there's an ON CONFLICT UPDATE clause, preprocess its targetlist too
+	 * while we have the relation open.
+	 */
+	if (parse->onConflict)
+		parse->onConflict->onConflictSet =
+			expand_targetlist(parse->onConflict->onConflictSet,
+							  CMD_UPDATE,
+							  result_relation,
+							  target_relation);
+
+	if (target_relation)
+		heap_close(target_relation, NoLock);
+
+	return tlist;
+}
+
+/*
+ * add_rowmark_columns
+ *
+ * Add necessary junk columns for rowmarked rels.  These values are needed
+ * for locking of rels selected FOR UPDATE/SHARE, and to do EvalPlanQual
+ * rechecking.  See comments for PlanRowMark in plannodes.h.
+ */
+List *
+add_rowmark_columns(PlannerInfo *root, List *tlist, List *rowMarks)
+{
+	List	   *range_table = root->parse->rtable;
+	ListCell   *lc;
+
+	foreach(lc, rowMarks)
 	{
 		PlanRowMark *rc = (PlanRowMark *) lfirst(lc);
 		Var		   *var;
@@ -183,58 +248,6 @@ preprocess_targetlist(PlannerInfo *root)
 		}
 	}
 
-	/*
-	 * If the query has a RETURNING list, add resjunk entries for any Vars
-	 * used in RETURNING that belong to other relations.  We need to do this
-	 * to make these Vars available for the RETURNING calculation.  Vars that
-	 * belong to the result rel don't need to be added, because they will be
-	 * made to refer to the actual heap tuple.
-	 */
-	if (parse->returningList && list_length(parse->rtable) > 1)
-	{
-		List	   *vars;
-		ListCell   *l;
-
-		vars = pull_var_clause((Node *) parse->returningList,
-							   PVC_RECURSE_AGGREGATES |
-							   PVC_RECURSE_WINDOWFUNCS |
-							   PVC_INCLUDE_PLACEHOLDERS);
-		foreach(l, vars)
-		{
-			Var		   *var = (Var *) lfirst(l);
-			TargetEntry *tle;
-
-			if (IsA(var, Var) &&
-				var->varno == result_relation)
-				continue;		/* don't need it */
-
-			if (tlist_member((Expr *) var, tlist))
-				continue;		/* already got it */
-
-			tle = makeTargetEntry((Expr *) var,
-								  list_length(tlist) + 1,
-								  NULL,
-								  true);
-
-			tlist = lappend(tlist, tle);
-		}
-		list_free(vars);
-	}
-
-	/*
-	 * If there's an ON CONFLICT UPDATE clause, preprocess its targetlist too
-	 * while we have the relation open.
-	 */
-	if (parse->onConflict)
-		parse->onConflict->onConflictSet =
-			expand_targetlist(parse->onConflict->onConflictSet,
-							  CMD_UPDATE,
-							  result_relation,
-							  target_relation);
-
-	if (target_relation)
-		heap_close(target_relation, NoLock);
-
 	return tlist;
 }
 
diff --git a/src/backend/optimizer/prep/prepunion.c b/src/backend/optimizer/prep/prepunion.c
index 279f686fb0..4d9583e63b 100644
--- a/src/backend/optimizer/prep/prepunion.c
+++ b/src/backend/optimizer/prep/prepunion.c
@@ -1555,14 +1555,15 @@ expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti)
 		lockmode = AccessShareLock;
 
 	/* Scan for all members of inheritance set, acquire needed locks */
-	inhOIDs = find_all_inheritors(parentOID, lockmode, NULL);
+	if (rte->relkind != RELKIND_PARTITIONED_TABLE)
+		inhOIDs = find_all_inheritors(parentOID, lockmode, NULL);
 
 	/*
 	 * Check that there's at least one descendant, else treat as no-child
 	 * case.  This could happen despite above has_subclass() check, if table
 	 * once had a child but no longer does.
 	 */
-	if (list_length(inhOIDs) < 2)
+	if (rte->relkind != RELKIND_PARTITIONED_TABLE && list_length(inhOIDs) < 2)
 	{
 		/* Clear flag before returning */
 		rte->inh = false;
@@ -1579,10 +1580,7 @@ expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti)
 
 	/* Partitioned tables are expanded elsewhere. */
 	if (rte->relkind == RELKIND_PARTITIONED_TABLE)
-	{
-		list_free(inhOIDs);
 		return;
-	}
 
 	/*
 	 * Must open the parent relation to examine its tupdesc.  We need not lock
@@ -1602,7 +1600,7 @@ expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti)
 									   RelationGetDescr(oldrelation),
 									   oldrc, childOID, NoLock,
 									   &appinfo, &childrte,
-									   &childRTindex);
+									   &childRTindex, NULL);
 		Assert(childRTindex > 1);
 		Assert(childrte != NULL);
 		Assert(appinfo != NULL);
@@ -1654,7 +1652,8 @@ add_inheritance_child_to_query(PlannerInfo *root, RangeTblEntry *parentrte,
 							   Oid childOID, int lockmode,
 							   AppendRelInfo **appinfo_p,
 							   RangeTblEntry **childrte_p,
-							   Index *childRTindex_p)
+							   Index *childRTindex_p,
+							   PlanRowMark **child_rowmark)
 {
 	Query	   *parse = root->parse;
 	Oid			parentOID = parentrte->relid;
@@ -1807,6 +1806,8 @@ add_inheritance_child_to_query(PlannerInfo *root, RangeTblEntry *parentrte,
 		top_parentrc->allMarkTypes |= childrc->allMarkTypes;
 
 		root->rowMarks = lappend(root->rowMarks, childrc);
+		if (child_rowmark)
+			*child_rowmark = childrc;
 	}
 
 	/* Close child relations, but keep locks */
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index d73b4a8499..e98b626395 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -1808,16 +1808,18 @@ build_partition_rel(PlannerInfo *root, RelOptInfo *parent, Oid partoid)
 {
 	RangeTblEntry *parentrte = root->simple_rte_array[parent->relid];
 	RelOptInfo *result;
+	Index		rootRTindex = 0;
 	Index		partRTindex = 0;
 	RangeTblEntry *partrte = NULL;
 	AppendRelInfo *appinfo = NULL;
 	PlanRowMark *rootrc = NULL;
+	int			orig_allMarkTypes;
+	PlanRowMark *childrc = NULL;
+	int			lockmode;
 
 	/* Locate the root partitioned table and fetch its PlanRowMark, if any. */
 	if (root->rowMarks)
 	{
-		Index		rootRTindex = 0;
-
 		/*
 		 * The root partitioned table itself might be a child of UNION ALL
 		 * parent, so we must resort to finding the root parent like this.
@@ -1842,16 +1844,27 @@ build_partition_rel(PlannerInfo *root, RelOptInfo *parent, Oid partoid)
 		}
 
 		rootrc = get_plan_rowmark(root->rowMarks, rootRTindex);
+
+		/*
+		 * Addition of certain child rowmarks will change the value, in which
+		 * case, we need to add additional columns to the query's targetlist.
+		 */
+		if (rootrc)
+			orig_allMarkTypes = rootrc->allMarkTypes;
 	}
 
-	/*
-	 * expand_inherited_rtentry alreay locked all partitions, so pass
-	 * NoLock for lockmode.
-	 */
+	/* Determine the correct lockmode to use. */
+	if (rootRTindex == root->parse->resultRelation)
+		lockmode = RowExclusiveLock;
+	else if (rootrc && RowMarkRequiresRowShareLock(rootrc->markType))
+		lockmode = RowShareLock;
+	else
+		lockmode = AccessShareLock;
 	add_inheritance_child_to_query(root, parentrte, parent->relid,
 								   parent->reltype, parent->tupdesc,
-								   rootrc, partoid, NoLock,
-								   &appinfo, &partrte, &partRTindex);
+								   rootrc, partoid, lockmode,
+								   &appinfo, &partrte, &partRTindex,
+								   &childrc);
 
 	/* Partition turned out to be a partitioned table with 0 partitions. */
 	if (partrte == NULL)
@@ -1870,6 +1883,13 @@ build_partition_rel(PlannerInfo *root, RelOptInfo *parent, Oid partoid)
 	result->lateral_relids = parent->lateral_relids;
 	result->lateral_referencers = parent->lateral_referencers;
 
+	if (rootrc && rootrc->allMarkTypes != orig_allMarkTypes)
+	{
+		List *tlist = root->parse->targetList;
+
+		tlist = add_rowmark_columns(root, tlist, list_make1(rootrc));
+	}
+
 	return result;
 }
 
diff --git a/src/include/optimizer/prep.h b/src/include/optimizer/prep.h
index ca66f75544..ee7406e4f6 100644
--- a/src/include/optimizer/prep.h
+++ b/src/include/optimizer/prep.h
@@ -39,6 +39,9 @@ extern Expr *canonicalize_qual(Expr *qual, bool is_check);
  * prototypes for preptlist.c
  */
 extern List *preprocess_targetlist(PlannerInfo *root);
+extern List *add_rowmark_columns(PlannerInfo *root,
+								 List *tlist,
+								 List *rowMarks);
 
 extern PlanRowMark *get_plan_rowmark(List *rowmarks, Index rtindex);
 
@@ -57,7 +60,8 @@ extern void add_inheritance_child_to_query(PlannerInfo *root,
 								Oid childOID, int lockmode,
 								AppendRelInfo **appinfo_p,
 								RangeTblEntry **childrte_p,
-								Index *childRTindex_p);
+								Index *childRTindex_p,
+								PlanRowMark **child_rowmark);
 
 extern Node *adjust_appendrel_attrs(PlannerInfo *root, Node *node,
 					   int nappinfos, AppendRelInfo **appinfos);
-- 
2.11.0

From 45334d7f43033adbc9682d0cbb549301d2c4366d Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Thu, 13 Sep 2018 15:11:46 +0900
Subject: [PATCH v3 4/4] WIP: generate *all* inheritance child RelOptInfos
 after pruning

---
 src/backend/optimizer/path/allpaths.c  | 209 ++++++---------
 src/backend/optimizer/plan/initsplan.c |  57 ++--
 src/backend/optimizer/plan/planner.c   |  31 ++-
 src/backend/optimizer/prep/prepunion.c | 477 ++++++++++++++++++---------------
 src/backend/optimizer/util/plancat.c   |  58 ++--
 src/backend/optimizer/util/relnode.c   | 292 +++++++++++++-------
 src/backend/partitioning/partprune.c   |   5 +-
 src/include/optimizer/pathnode.h       |   9 +-
 src/include/optimizer/plancat.h        |   9 +-
 src/include/optimizer/prep.h           |  28 +-
 10 files changed, 620 insertions(+), 555 deletions(-)

diff --git a/src/backend/optimizer/path/allpaths.c b/src/backend/optimizer/path/allpaths.c
index e54cccd077..21723e7cdc 100644
--- a/src/backend/optimizer/path/allpaths.c
+++ b/src/backend/optimizer/path/allpaths.c
@@ -367,8 +367,23 @@ static void
 set_rel_size(PlannerInfo *root, RelOptInfo *rel,
 			 Index rti, RangeTblEntry *rte)
 {
+
+	/*
+	 * Check if the relation's constraints contradict the clauses matched
+	 * to it.  Only plain relations have constraints.  In a partitioning
+	 * hierarchy, but not with regular table inheritance, it's OK to assume
+	 * that any constraints that hold for the parent also hold for every
+	 * child; for instance, table inheritance allows the parent to have
+	 * constraints marked NO INHERIT, but table partitioning does not.  We
+	 * choose to check whether the partitioning parents can be excluded here;
+	 * doing so consumes some cycles, but potentially saves us the work of
+	 * excluding each child individually.
+	 */
 	if (rel->reloptkind == RELOPT_BASEREL &&
-		relation_excluded_by_constraints(root, rel, rte))
+		rte->rtekind == RTE_RELATION &&
+		(!rte->inh || rte->relkind == RELKIND_PARTITIONED_TABLE) &&
+		relation_excluded_by_constraints(root, rel->baserestrictinfo,
+										 rti, rte->relid, false))
 	{
 		/*
 		 * We proved we don't need to scan the rel via constraint exclusion,
@@ -916,11 +931,7 @@ static void
 set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 					Index rti, RangeTblEntry *rte)
 {
-	Relids		top_parent_relids = rel->top_parent_relids;
 	int			parentRTindex = rti;
-	int			rootParentRTindex = top_parent_relids ?
-									bms_singleton_member(top_parent_relids) :
-									parentRTindex;
 	bool		has_live_children;
 	double		parent_rows;
 	double		parent_size;
@@ -951,6 +962,17 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 		 */
 		prune_append_rel_partitions(root, rel);
 	}
+	else
+	{
+		expand_inherited_rtentry(root, rel, rte, rti);
+		if (IS_DUMMY_REL(rel))
+			return;
+		if (!rte->inh)
+		{
+			set_rel_size(root, rel, rti, rte);
+			return;
+		}
+	}
 
 	/*
 	 * If this is a partitioned baserel, set the consider_partitionwise_join
@@ -989,9 +1011,9 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 		int			childRTindex;
 		RangeTblEntry *childRTE;
 		RelOptInfo *childrel;
-		List	   *childquals;
+		List	   *childquals = NIL;
+		bool		have_const_false_cq = false;
 		Index		cq_min_security;
-		bool		have_const_false_cq;
 		ListCell   *parentvars;
 		ListCell   *childvars;
 		ListCell   *lc;
@@ -1004,53 +1026,23 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 		childRTE = root->simple_rte_array[childRTindex];
 
 		/*
-		 * The child rel's RelOptInfo was already created during
-		 * add_base_rels_to_query.
+		 * The child rel's RelOptInfo may not have been created in some
+		 * cases, for example, if it is not a partition.
 		 */
-		childrel = find_base_rel(root, childRTindex);
+		childrel = root->simple_rel_array[childRTindex];
+		if (childrel == NULL)
+			childrel = build_inheritance_child_rel(root, childRTindex, rel);
 		Assert(childrel->reloptkind == RELOPT_OTHER_MEMBER_REL);
 
-		/*
-		 * We have to make child entries in the EquivalenceClass data
-		 * structures as well.  This is needed either if the parent
-		 * participates in some eclass joins (because we will want to consider
-		 * inner-indexscan joins on the individual children) or if the parent
-		 * has useful pathkeys (because we should try to build MergeAppend
-		 * paths that produce those sort orderings). Even if this child is
-		 * deemed dummy, it may fall on nullable side in a child-join, which
-		 * in turn may participate in a MergeAppend, where we will need the
-		 * EquivalenceClass data structures.
-		 */
-		if (rel->has_eclass_joins || has_useful_pathkeys(root, rel))
-			add_child_rel_equivalences(root, appinfo, rel, childrel);
-		childrel->has_eclass_joins = rel->has_eclass_joins;
-
-		/*
-		 * We have to copy the parent's quals to the child, with appropriate
-		 * substitution of variables.  However, only the baserestrictinfo
-		 * quals are needed before we can check for constraint exclusion; so
-		 * do that first and then check to see if we can disregard this child.
-		 *
-		 * The child rel's targetlist might contain non-Var expressions, which
-		 * means that substitution into the quals could produce opportunities
-		 * for const-simplification, and perhaps even pseudoconstant quals.
-		 * Therefore, transform each RestrictInfo separately to see if it
-		 * reduces to a constant or pseudoconstant.  (We must process them
-		 * separately to keep track of the security level of each qual.)
-		 */
-		childquals = NIL;
-		cq_min_security = UINT_MAX;
-		have_const_false_cq = false;
+		/* Convert parent's baserestrictinfo to store into childrel. */
 		foreach(lc, rel->baserestrictinfo)
 		{
 			RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
-			Node	   *childqual;
+			Node	   *childqual = (Node *) rinfo->clause;
 			ListCell   *lc2;
 
 			Assert(IsA(rinfo, RestrictInfo));
-			childqual = adjust_appendrel_attrs(root,
-											   (Node *) rinfo->clause,
-											   1, &appinfo);
+			childqual = adjust_appendrel_attrs(root, childqual, 1, &appinfo);
 			childqual = eval_const_expressions(root, childqual);
 			/* check for flat-out constant */
 			if (childqual && IsA(childqual, Const))
@@ -1082,13 +1074,12 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 				}
 				/* reconstitute RestrictInfo with appropriate properties */
 				childquals = lappend(childquals,
-									 make_restrictinfo((Expr *) onecq,
-													   rinfo->is_pushed_down,
-													   rinfo->outerjoin_delayed,
-													   pseudoconstant,
-													   rinfo->security_level,
-													   NULL, NULL, NULL));
-				/* track minimum security level among child quals */
+								 make_restrictinfo((Expr *) onecq,
+												   rinfo->is_pushed_down,
+												   rinfo->outerjoin_delayed,
+												   pseudoconstant,
+												   rinfo->security_level,
+												   NULL, NULL, NULL));
 				cq_min_security = Min(cq_min_security, rinfo->security_level);
 			}
 		}
@@ -1106,6 +1097,7 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 		 */
 		if (childRTE->securityQuals)
 		{
+			List	   *security_quals = NIL;
 			Index		security_level = 0;
 
 			foreach(lc, childRTE->securityQuals)
@@ -1118,16 +1110,37 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 					Expr	   *qual = (Expr *) lfirst(lc2);
 
 					/* not likely that we'd see constants here, so no check */
-					childquals = lappend(childquals,
-										 make_restrictinfo(qual,
-														   true, false, false,
-														   security_level,
-														   NULL, NULL, NULL));
+					security_quals = lappend(security_quals,
+											 make_restrictinfo(qual,
+															   true, false,
+															   false,
+															   security_level,
+															   NULL, NULL,
+															   NULL));
 					cq_min_security = Min(cq_min_security, security_level);
 				}
 				security_level++;
 			}
 			Assert(security_level <= root->qual_security_level);
+
+			/* Concatenate with parent's quals. */
+			childquals = list_concat(childquals, security_quals);
+		}
+
+		/*
+		 * Check if any of the security quals contradict table
+		 * constraints.
+		 */
+		if (have_const_false_cq ||
+			(childRTE->rtekind == RTE_RELATION &&
+			 relation_excluded_by_constraints(root, childquals,
+											  childRTindex,
+											  childRTE->relid,
+											  true)))
+		{
+			childrel->reltarget = copy_pathtarget(rel->reltarget);
+			set_dummy_rel_pathlist(childrel);
+			continue;
 		}
 
 		/*
@@ -1137,77 +1150,19 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 		childrel->baserestrict_min_security = cq_min_security;
 
 		/*
-		 * Mark the child as empty in certain cases, such as if a restriction
-		 * clause reduced to constant FALSE or NULL, or if constaint exclusion
-		 * pruned it.
+		 * We have to make child entries in the EquivalenceClass data
+		 * structures as well.  This is needed either if the parent
+		 * participates in some eclass joins (because we will want to consider
+		 * inner-indexscan joins on the individual children) or if the parent
+		 * has useful pathkeys (because we should try to build MergeAppend
+		 * paths that produce those sort orderings). Even if this child is
+		 * deemed dummy, it may fall on nullable side in a child-join, which
+		 * in turn may participate in a MergeAppend, where we will need the
+		 * EquivalenceClass data structures.
 		 */
-		if (have_const_false_cq ||
-			relation_excluded_by_constraints(root, childrel, childRTE))
-		{
-			/*
-			 * The child relation won't be scanned, but certain partitionwise
-			 * planning operations require its reltarget to contain valid
-			 * expressions, so oblige.
-			 */
-			childrel->reltarget->exprs = (List *)
-				adjust_appendrel_attrs(root,
-									   (Node *) rel->reltarget->exprs,
-									   1, &appinfo);
-
-			set_dummy_rel_pathlist(childrel);
-			continue;
-		}
-
-		/*
-		 * Copy/Modify targetlist. Even if this child is deemed empty, we need
-		 * its targetlist in case it falls on nullable side in a child-join
-		 * because of partitionwise join.
-		 *
-		 * NB: the resulting childrel->reltarget->exprs may contain arbitrary
-		 * expressions, which otherwise would not occur in a rel's targetlist.
-		 * Code that might be looking at an appendrel child must cope with
-		 * such.  (Normally, a rel's targetlist would only include Vars and
-		 * PlaceHolderVars.)  XXX we do not bother to update the cost or width
-		 * fields of childrel->reltarget; not clear if that would be useful.
-		 */
-		if (rootParentRTindex == root->parse->resultRelation)
-		{
-			Query	   *parse,
-					   *orig_parse = root->parse;
-			List	   *tlist;
-			List	   *other_exprs;
-			ListCell   *lc2;
-
-			parse = (Query *)
-					adjust_appendrel_attrs(root,
-										   (Node *) root->parse,
-										   1, &appinfo);
-			root->parse = parse;
-			tlist = preprocess_targetlist(root);
-			build_base_rel_tlists(root, tlist);
-			root->parse = orig_parse;
-
-			/*
-			 * Now add members of parent's reltarget->exprs, not already in
-			 * child's.
-			 */
-			other_exprs = (List *)
-				adjust_appendrel_attrs(root,
-									   (Node *) rel->reltarget->exprs,
-									   1, &appinfo);
-			foreach(lc2, other_exprs)
-			{
-				if (!list_member(childrel->reltarget->exprs, lfirst(lc2)))
-					childrel->reltarget->exprs =
-								lappend(childrel->reltarget->exprs,
-										lfirst(lc2));
-			}
-		}
-		else
-			childrel->reltarget->exprs = (List *)
-				adjust_appendrel_attrs(root,
-									   (Node *) rel->reltarget->exprs,
-									   1, &appinfo);
+		if (rel->has_eclass_joins || has_useful_pathkeys(root, rel))
+			add_child_rel_equivalences(root, appinfo, rel, childrel);
+		childrel->has_eclass_joins = rel->has_eclass_joins;
 
 		/* CE failed, so finish copying/modifying join quals. */
 		childrel->joininfo = (List *)
diff --git a/src/backend/optimizer/plan/initsplan.c b/src/backend/optimizer/plan/initsplan.c
index beb3e95101..e7927cc136 100644
--- a/src/backend/optimizer/plan/initsplan.c
+++ b/src/backend/optimizer/plan/initsplan.c
@@ -16,6 +16,7 @@
 
 #include "catalog/pg_type.h"
 #include "catalog/pg_class.h"
+#include "catalog/pg_inherits.h"
 #include "nodes/nodeFuncs.h"
 #include "optimizer/clauses.h"
 #include "optimizer/cost.h"
@@ -145,47 +146,29 @@ add_rel_partitions_to_query(PlannerInfo *root, RelOptInfo *rel,
 							bool scan_all_parts,
 							Bitmapset *partindexes)
 {
-	int		new_size;
-	int		num_added_parts;
-	int		i;
+	int			i;
+	Index		rootRTindex;
+	PlanRowMark *rootrc = NULL;
 
-	Assert(partindexes != NULL || scan_all_parts);
+	rootRTindex = get_inheritance_root_parent(root, rel);
+	if (root->rowMarks)
+		rootrc = get_plan_rowmark(root->rowMarks, rootRTindex);
 
-	/* Expand the PlannerInfo arrays to hold new partition objects. */
-	num_added_parts = scan_all_parts ? rel->nparts :
-						bms_num_members(partindexes);
-	new_size = root->simple_rel_array_size + num_added_parts;
-	root->simple_rte_array = (RangeTblEntry **)
-							repalloc(root->simple_rte_array,
-									 sizeof(RangeTblEntry *) * new_size);
-	root->simple_rel_array = (RelOptInfo **)
-								repalloc(root->simple_rel_array,
-										 sizeof(RelOptInfo *) * new_size);
-	if (root->append_rel_array)
-		root->append_rel_array = (AppendRelInfo **)
-									repalloc(root->append_rel_array,
-									 sizeof(AppendRelInfo *) * new_size);
-	else
-		root->append_rel_array = (AppendRelInfo **)
-									palloc0(sizeof(AppendRelInfo *) *
-											new_size);
+	expand_planner_arrays_for_inheritance(root,
+										  scan_all_parts ? rel->nparts :
+										  bms_num_members(partindexes));
 
-	/* Set the contents of just allocated memory to 0. */
-	MemSet(root->simple_rte_array + root->simple_rel_array_size,
-		   0, sizeof(RangeTblEntry *) * num_added_parts);
-	MemSet(root->simple_rel_array + root->simple_rel_array_size,
-		   0, sizeof(RelOptInfo *) * num_added_parts);
-	MemSet(root->append_rel_array + root->simple_rel_array_size,
-		   0, sizeof(AppendRelInfo *) * num_added_parts);
-	root->simple_rel_array_size = new_size;
-
-	/* And add the partitions. */
+	/* And add the partitions to the relation. */
+	rel->part_rels = (RelOptInfo **)
+				palloc0(sizeof(RelOptInfo *) * rel->nparts);
 	if (scan_all_parts)
 	{
 		for (i = 0; i < rel->nparts; i++)
 		{
 			rel->part_rels[i] = build_partition_rel(root, rel,
-													rel->part_oids[i]);
+													rel->part_oids[i],
+													rootRTindex,
+													rootrc);
 			rel->live_parts = bms_add_member(rel->live_parts, i);
 		}
 	}
@@ -195,8 +178,12 @@ add_rel_partitions_to_query(PlannerInfo *root, RelOptInfo *rel,
 		i = -1;
 		while ((i = bms_next_member(partindexes, i)) >= 0)
 			rel->part_rels[i] = build_partition_rel(root, rel,
-													rel->part_oids[i]);
+													rel->part_oids[i],
+													rootRTindex,
+													rootrc);
 	}
+
+
 }
 
 /*****************************************************************************
@@ -683,6 +670,7 @@ create_lateral_join_info(PlannerInfo *root)
 		}
 	}
 
+#ifdef NOT_USED
 	/*
 	 * Lastly, propagate lateral_relids and lateral_referencers from appendrel
 	 * parent rels to their child rels.  We intentionally give each child rel
@@ -740,6 +728,7 @@ create_lateral_join_info(PlannerInfo *root)
 			}
 		}
 	}
+#endif
 }
 
 
diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index a757aba551..556eb64ae4 100644
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -713,16 +713,6 @@ subquery_planner(PlannerGlobal *glob, Query *parse,
 	preprocess_rowmarks(root);
 
 	/*
-	 * Expand any rangetable entries that are inheritance sets into "append
-	 * relations".  This can add entries to the rangetable, but they must be
-	 * plain base relations not joins, so it's OK (and marginally more
-	 * efficient) to do it after checking for join RTEs.  We must do it after
-	 * pulling up subqueries, else we'd fail to handle inherited tables in
-	 * subqueries.
-	 */
-	expand_inherited_tables(root);
-
-	/*
 	 * Set hasHavingQual to remember if HAVING clause is present.  Needed
 	 * because preprocess_expression will reduce a constant-true condition to
 	 * an empty qual list ... but "HAVING TRUE" is not a semantic no-op.
@@ -2369,7 +2359,7 @@ preprocess_rowmarks(PlannerInfo *root)
 		newrc->allMarkTypes = (1 << newrc->markType);
 		newrc->strength = rc->strength;
 		newrc->waitPolicy = rc->waitPolicy;
-		newrc->isParent = false;
+		newrc->isParent = has_subclass(rte->relid);
 
 		prowmarks = lappend(prowmarks, newrc);
 	}
@@ -2394,7 +2384,9 @@ preprocess_rowmarks(PlannerInfo *root)
 		newrc->allMarkTypes = (1 << newrc->markType);
 		newrc->strength = LCS_NONE;
 		newrc->waitPolicy = LockWaitBlock;	/* doesn't matter */
-		newrc->isParent = false;
+		newrc->isParent = rte->rtekind == RTE_RELATION ?
+							has_subclass(rte->relid) :
+							false;
 
 		prowmarks = lappend(prowmarks, newrc);
 	}
@@ -5871,8 +5863,19 @@ plan_create_index_workers(Oid tableOid, Oid indexOid)
 	rte->inFromCl = true;
 	query->rtable = list_make1(rte);
 
-	/* Set up RTE/RelOptInfo arrays */
-	setup_simple_rel_arrays(root);
+	/* Set up RTE/RelOptInfo arrays. */
+
+	/* Arrays are accessed using RT indexes (1..N) */
+	root->simple_rel_array_size = list_length(query->rtable) + 1;
+
+	/* simple_rel_array is initialized to all NULLs */
+	root->simple_rel_array = (RelOptInfo **)
+		palloc0(root->simple_rel_array_size * sizeof(RelOptInfo *));
+
+	/* simple_rte_array is an array equivalent of the rtable list */
+	root->simple_rte_array = (RangeTblEntry **)
+		palloc0(root->simple_rel_array_size * sizeof(RangeTblEntry *));
+	root->simple_rte_array[1] = rte;
 
 	/* Build RelOptInfo */
 	rel = build_simple_rel(root, 1, NULL);
diff --git a/src/backend/optimizer/prep/prepunion.c b/src/backend/optimizer/prep/prepunion.c
index 4d9583e63b..400568a9e7 100644
--- a/src/backend/optimizer/prep/prepunion.c
+++ b/src/backend/optimizer/prep/prepunion.c
@@ -39,15 +39,20 @@
 #include "miscadmin.h"
 #include "nodes/makefuncs.h"
 #include "nodes/nodeFuncs.h"
+#include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
 #include "optimizer/paths.h"
+#include "optimizer/plancat.h"
 #include "optimizer/planmain.h"
 #include "optimizer/planner.h"
 #include "optimizer/prep.h"
+#include "optimizer/restrictinfo.h"
 #include "optimizer/tlist.h"
+#include "optimizer/var.h"
 #include "parser/parse_coerce.h"
 #include "parser/parsetree.h"
+#include "rewrite/rewriteManip.h"
 #include "utils/lsyscache.h"
 #include "utils/lsyscache.h"
 #include "utils/partcache.h"
@@ -101,12 +106,6 @@ static List *generate_append_tlist(List *colTypes, List *colCollations,
 					  List *input_tlists,
 					  List *refnames_tlist);
 static List *generate_setop_grouplist(SetOperationStmt *op, List *targetlist);
-static void expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte,
-						 Index rti);
-static void make_inh_translation_list(TupleDesc old_tupdesc,
-						  TupleDesc new_tupdesc,
-						  RangeTblEntry *oldrte, RangeTblEntry *newrte,
-						  Index newvarno, List **translated_vars);
 static Bitmapset *translate_col_privs(const Bitmapset *parent_privs,
 					List *translated_vars);
 static Node *adjust_appendrel_attrs_mutator(Node *node,
@@ -1452,37 +1451,6 @@ generate_setop_grouplist(SetOperationStmt *op, List *targetlist)
 	return grouplist;
 }
 
-
-/*
- * expand_inherited_tables
- *		Expand each rangetable entry that represents an inheritance set
- *		into an "append relation".  At the conclusion of this process,
- *		the "inh" flag is set in all and only those RTEs that are append
- *		relation parents.
- */
-void
-expand_inherited_tables(PlannerInfo *root)
-{
-	Index		nrtes;
-	Index		rti;
-	ListCell   *rl;
-
-	/*
-	 * expand_inherited_rtentry may add RTEs to parse->rtable. The function is
-	 * expected to recursively handle any RTEs that it creates with inh=true.
-	 * So just scan as far as the original end of the rtable list.
-	 */
-	nrtes = list_length(root->parse->rtable);
-	rl = list_head(root->parse->rtable);
-	for (rti = 1; rti <= nrtes; rti++)
-	{
-		RangeTblEntry *rte = (RangeTblEntry *) lfirst(rl);
-
-		expand_inherited_rtentry(root, rte, rti);
-		rl = lnext(rl);
-	}
-}
-
 /*
  * expand_inherited_rtentry
  *		Check whether a rangetable entry represents an inheritance set.
@@ -1503,30 +1471,34 @@ expand_inherited_tables(PlannerInfo *root)
  * Since a partitioned table is not scanned, it might have only one associated
  * AppendRelInfo.
  */
-static void
-expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti)
+void
+expand_inherited_rtentry(PlannerInfo *root,
+						 RelOptInfo *rel,
+						 RangeTblEntry *rte,
+						 Index rti)
 {
 	Query	   *parse = root->parse;
-	Oid			parentOID;
 	PlanRowMark *oldrc;
-	Relation	oldrelation;
 	LOCKMODE	lockmode;
 	List	   *inhOIDs;
-	ListCell   *l;
-	List	   *appinfos = NIL;
+	ListCell   *l,
+			   *l2;
+	List	   *childrtes = NIL,
+			   *appinfos = NIL;
+	int			num_children = 0;
 
-	/* Does RT entry allow inheritance? */
-	if (!rte->inh)
+	Assert(rte->inh);
+	/* Inheritance parent or UNION ALL parent query. */
+	Assert(rte->rtekind == RTE_RELATION || rte->rtekind == RTE_SUBQUERY);
+	/* No partitioned tables though. */
+	Assert(rte->relkind != RELKIND_PARTITIONED_TABLE);
+
+	/* Nothing to do for already-expanded UNION ALL nodes. */
+	if (rte->rtekind == RTE_SUBQUERY)
 		return;
-	/* Ignore any already-expanded UNION ALL nodes */
-	if (rte->rtekind != RTE_RELATION)
-	{
-		Assert(rte->rtekind == RTE_SUBQUERY);
-		return;
-	}
+
 	/* Fast path for common case of childless table */
-	parentOID = rte->relid;
-	if (!has_subclass(parentOID))
+	if (!has_subclass(rte->relid))
 	{
 		/* Clear flag before returning */
 		rte->inh = false;
@@ -1555,15 +1527,14 @@ expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti)
 		lockmode = AccessShareLock;
 
 	/* Scan for all members of inheritance set, acquire needed locks */
-	if (rte->relkind != RELKIND_PARTITIONED_TABLE)
-		inhOIDs = find_all_inheritors(parentOID, lockmode, NULL);
+	inhOIDs = find_all_inheritors(rte->relid, lockmode, NULL);
 
 	/*
 	 * Check that there's at least one descendant, else treat as no-child
 	 * case.  This could happen despite above has_subclass() check, if table
 	 * once had a child but no longer does.
 	 */
-	if (rte->relkind != RELKIND_PARTITIONED_TABLE && list_length(inhOIDs) < 2)
+	if (list_length(inhOIDs) < 2)
 	{
 		/* Clear flag before returning */
 		rte->inh = false;
@@ -1578,33 +1549,145 @@ expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti)
 	if (oldrc)
 		oldrc->isParent = true;
 
-	/* Partitioned tables are expanded elsewhere. */
-	if (rte->relkind == RELKIND_PARTITIONED_TABLE)
-		return;
-
-	/*
-	 * Must open the parent relation to examine its tupdesc.  We need not lock
-	 * it; we assume the rewriter already did.
-	 */
-	oldrelation = heap_open(parentOID, NoLock);
-
 	foreach(l, inhOIDs)
 	{
 		Oid			childOID = lfirst_oid(l);
+		Relation	childrel;
 		Index		childRTindex = 0;
 		RangeTblEntry *childrte = NULL;
-		AppendRelInfo *appinfo = NULL;
+		AppendRelInfo *appinfo;
+		List	   *childquals;
+		bool		have_const_false_cq;
+		ListCell   *lc;
 
-		add_inheritance_child_to_query(root, rte, rti,
-									   oldrelation->rd_rel->reltype,
-									   RelationGetDescr(oldrelation),
-									   oldrc, childOID, NoLock,
-									   &appinfo, &childrte,
-									   &childRTindex, NULL);
+		/* find_all_inheritors already locked. */
+		childrel = heap_open(childOID, NoLock);
+
+		/*
+		 * If childrel doesn't belong to this session, skip it, also
+		 * relinquishing the lock.
+		 */
+		if (RELATION_IS_OTHER_TEMP(childrel))
+		{
+			heap_close(childrel, lockmode);
+			continue;
+		}
+
+		/*
+		 * Initialize the AppendRelInfo that's used to map the child to its
+		 * parent in subsequent planning steps.
+		 */
+		appinfo = makeNode(AppendRelInfo);
+		appinfo->parent_relid = rti;
+
+		/*
+		 * We'll replace it with childRTindex once we're done adding the child
+		 * to the range table.
+		 */
+		appinfo->child_relid = rti;
+		appinfo->parent_reltype = rel->reltype;
+		appinfo->child_reltype = childrel->rd_rel->reltype;
+		make_inh_translation_list(rel->tupdesc,
+								  RelationGetDescr(childrel),
+								  rte->relid, childOID, rti,
+								  &appinfo->translated_vars);
+		appinfo->parent_reloid = rte->relid;
+
+		/*
+		 * Check if we don't need to include this child based on whether its
+		 * constraints contradict query's quals.  For a child that's not same
+		 * as the parent, we'll need to convert the quals' Vars so that they
+		 * contain child's attribute numbers.
+		 */
+		childquals = NIL;
+		have_const_false_cq = false;
+		foreach(lc, rel->baserestrictinfo)
+		{
+			RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
+			Node	   *childqual = (Node *) rinfo->clause;
+			ListCell   *lc2;
+
+			Assert(IsA(rinfo, RestrictInfo));
+			if (childOID != rte->relid)
+				childqual = adjust_appendrel_attrs(root, childqual,
+												   1, &appinfo);
+			childqual = eval_const_expressions(root, childqual);
+			/* check for flat-out constant */
+			if (childqual && IsA(childqual, Const))
+			{
+				if (((Const *) childqual)->constisnull ||
+					!DatumGetBool(((Const *) childqual)->constvalue))
+				{
+					/* Restriction reduces to constant FALSE or NULL */
+					have_const_false_cq = true;
+					break;
+				}
+				/* Restriction reduces to constant TRUE, so drop it */
+				continue;
+			}
+			/* might have gotten an AND clause, if so flatten it */
+			foreach(lc2, make_ands_implicit((Expr *) childqual))
+			{
+				Node	   *onecq = (Node *) lfirst(lc2);
+				bool		pseudoconstant;
+
+				/* check for pseudoconstant (no Vars or volatile functions) */
+				pseudoconstant =
+					!contain_vars_of_level(onecq, 0) &&
+					!contain_volatile_functions(onecq);
+				if (pseudoconstant)
+				{
+					/* tell createplan.c to check for gating quals */
+					root->hasPseudoConstantQuals = true;
+				}
+				/* reconstitute RestrictInfo with appropriate properties */
+				childquals = lappend(childquals,
+								 make_restrictinfo((Expr *) onecq,
+												   rinfo->is_pushed_down,
+												   rinfo->outerjoin_delayed,
+												   pseudoconstant,
+												   rinfo->security_level,
+												   NULL, NULL, NULL));
+			}
+		}
+
+		/*
+		 * Mark the child as empty in certain cases, such as if a restriction
+		 * clause reduced to constant FALSE or NULL, or if constaint exclusion
+		 * pruned it.  Note that we pass 'rti' for RT index that will be used
+		 * to initialize constraint expressions, because we haven't initialized
+		 * one for child yet.
+		 */
+		if (have_const_false_cq ||
+			relation_excluded_by_constraints(root, childquals, rti, childOID,
+											 true))
+		{
+			heap_close(childrel, NoLock);
+			continue;
+		}
+
+		childRTindex = add_inheritance_child_to_query(root, rte, childrel,
+													  appinfo, oldrc,
+													  &childrte);
+		heap_close(childrel, NoLock);
+
+		/* Fix up the AppendRelInfo using the child's actual RT index. */
 		Assert(childRTindex > 1);
-		Assert(childrte != NULL);
-		Assert(appinfo != NULL);
+		appinfo->child_relid = childRTindex;
+		ChangeVarNodes((Node *) appinfo->translated_vars, rti, childRTindex, 0);
+
+		/* Will be added to planner arrays below. */
+		childrtes = lappend(childrtes, childrte);
 		appinfos = lappend(appinfos, appinfo);
+
+		/* We'll scan this child. */
+		num_children++;
+	}
+
+	if (num_children == 0)
+	{
+		set_dummy_rel_pathlist(rel);
+		return;
 	}
 
 	/*
@@ -1620,95 +1703,28 @@ expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti)
 		root->append_rel_list = list_concat(root->append_rel_list,
 											appinfos);
 
-	heap_close(oldrelation, NoLock);
+	expand_planner_arrays_for_inheritance(root, num_children);
+	forboth(l, childrtes, l2, appinfos)
+	{
+		RangeTblEntry *childrte = lfirst(l);
+		AppendRelInfo *appinfo = lfirst(l2);
+
+		Assert(appinfo->child_relid < root->simple_rel_array_size);
+		root->simple_rte_array[appinfo->child_relid] = childrte;
+		root->append_rel_array[appinfo->child_relid] = appinfo;
+	}
 }
 
-/*
- * add_inheritance_child_to_query
- *		Build a RangeTblEntry and an AppendRelInfo, if appropriate, plus
- *		maybe a PlanRowMark for a child relation.
- *
- * We now expand the partition hierarchy level by level, creating a
- * corresponding hierarchy of AppendRelInfos and RelOptInfos, where each
- * partitioned descendant acts as a parent of its immediate partitions.
- * (This is a difference from what older versions of PostgreSQL did and what
- * is still done in the case of table inheritance for unpartitioned tables,
- * where the hierarchy is flattened during RTE expansion.)
- *
- * PlanRowMarks still carry the top-parent's RTI, and the top-parent's
- * allMarkTypes field still accumulates values from all descendents.
- *
- * "parentrte" and "parentRTindex" are immediate parent's RTE and
- * RTI. "top_parentrc" is top parent's PlanRowMark.
- *
- * The child RangeTblEntry and its RTI are returned in "childrte_p" and
- * "childRTindex_p" resp.
- */
-void
-add_inheritance_child_to_query(PlannerInfo *root, RangeTblEntry *parentrte,
-							   Index parentRTindex, Oid parentRelType,
-							   TupleDesc parentDesc,
+Index
+add_inheritance_child_to_query(PlannerInfo *root,
+							   RangeTblEntry *parentrte,
+							   Relation childrel,
+							   AppendRelInfo *appinfo,
 							   PlanRowMark *top_parentrc,
-							   Oid childOID, int lockmode,
-							   AppendRelInfo **appinfo_p,
-							   RangeTblEntry **childrte_p,
-							   Index *childRTindex_p,
-							   PlanRowMark **child_rowmark)
+							   RangeTblEntry **childrte_p)
 {
-	Query	   *parse = root->parse;
-	Oid			parentOID = parentrte->relid;
+	Query	*parse = root->parse;
 	RangeTblEntry *childrte;
-	Index		childRTindex;
-	AppendRelInfo *appinfo;
-	Relation	childrel = NULL;
-	char		child_relkind;
-	Oid			child_reltype;
-	TupleDesc	childDesc;
-
-	*appinfo_p = NULL;
-	*childrte_p = NULL;
-	*childRTindex_p = 0;
-
-	/* Open rel if needed; we already have required locks */
-	if (childOID != parentOID)
-	{
-		childrel = heap_open(childOID, lockmode);
-
-		/*
-		 * Temporary partitions belonging to other sessions should have been
-		 * disallowed at definition, but for paranoia's sake, let's double
-		 * check.
-		 */
-		if (RELATION_IS_OTHER_TEMP(childrel))
-		{
-			if (childrel->rd_rel->relispartition)
-				elog(ERROR, "temporary relation from another session found as partition");
-			heap_close(childrel, lockmode);
-			return;
-		}
-
-		child_relkind = childrel->rd_rel->relkind;
-
-		/*
-		 * No point in adding to the query a partitioned table that has no
-		 * partitions.
-		 */
-		if (child_relkind == RELKIND_PARTITIONED_TABLE &&
-			RelationGetPartitionDesc(childrel)->nparts == 0)
-		{
-			heap_close(childrel, lockmode);
-			return;
-		}
-
-		child_reltype = childrel->rd_rel->reltype;
-		childDesc = RelationGetDescr(childrel);
-	}
-	else
-	{
-		child_relkind = parentrte->relkind;
-		child_reltype =  parentRelType;
-		childDesc = parentDesc;
-	}
 
 	/*
 	 * Build an RTE for the child, and attach to query's rangetable list. We
@@ -1723,11 +1739,10 @@ add_inheritance_child_to_query(PlannerInfo *root, RangeTblEntry *parentrte,
 	 * restriction clauses, so we don't need to do it here.
 	 */
 	childrte = copyObject(parentrte);
-	*childrte_p = childrte;
-	childrte->relid = childOID;
-	childrte->relkind = child_relkind;
+	childrte->relid = RelationGetRelid(childrel);
+	childrte->relkind = RelationGetForm(childrel)->relkind;
 	/* A partitioned child will need to be expanded further. */
-	if (childOID != parentOID &&
+	if (childrte->relid != parentrte->relid &&
 		childrte->relkind == RELKIND_PARTITIONED_TABLE)
 		childrte->inh = true;
 	else
@@ -1735,62 +1750,36 @@ add_inheritance_child_to_query(PlannerInfo *root, RangeTblEntry *parentrte,
 	childrte->requiredPerms = 0;
 	childrte->securityQuals = NIL;
 	parse->rtable = lappend(parse->rtable, childrte);
-	childRTindex = list_length(parse->rtable);
-	*childRTindex_p = childRTindex;
 
 	/*
-	 * We need an AppendRelInfo if paths will be built for the child RTE. If
-	 * childrte->inh is true, then we'll always need to generate append paths
-	 * for it.  If childrte->inh is false, we must scan it if it's not a
-	 * partitioned table; but if it is a partitioned table, then it never has
-	 * any data of its own and need not be scanned.
+	 * Translate the column permissions bitmaps to the child's attnums (we
+	 * have to build the translated_vars list before we can do this). But
+	 * if this is the parent table, leave copyObject's result alone.
+	 *
+	 * Note: we need to do this even though the executor won't run any
+	 * permissions checks on the child RTE.  The insertedCols/updatedCols
+	 * bitmaps may be examined for trigger-firing purposes.
 	 */
-	if (childrte->relkind != RELKIND_PARTITIONED_TABLE || childrte->inh)
+	if (childrte->relid != parentrte->relid)
 	{
-		appinfo = makeNode(AppendRelInfo);
-		appinfo->parent_relid = parentRTindex;
-		appinfo->child_relid = childRTindex;
-		appinfo->parent_reltype = parentRelType;
-		appinfo->child_reltype = child_reltype;
-		make_inh_translation_list(parentDesc, childDesc,
-								  parentrte, childrte, childRTindex,
-								  &appinfo->translated_vars);
-		appinfo->parent_reloid = parentOID;
-		*appinfo_p = appinfo;
-
-		/*
-		 * Translate the column permissions bitmaps to the child's attnums (we
-		 * have to build the translated_vars list before we can do this). But
-		 * if this is the parent table, leave copyObject's result alone.
-		 *
-		 * Note: we need to do this even though the executor won't run any
-		 * permissions checks on the child RTE.  The insertedCols/updatedCols
-		 * bitmaps may be examined for trigger-firing purposes.
-		 */
-		if (childOID != parentOID)
-		{
-			childrte->selectedCols = translate_col_privs(parentrte->selectedCols,
-														 appinfo->translated_vars);
-			childrte->insertedCols = translate_col_privs(parentrte->insertedCols,
-														 appinfo->translated_vars);
-			childrte->updatedCols = translate_col_privs(parentrte->updatedCols,
-														appinfo->translated_vars);
-		}
+		childrte->selectedCols = translate_col_privs(parentrte->selectedCols,
+													 appinfo->translated_vars);
+		childrte->insertedCols = translate_col_privs(parentrte->insertedCols,
+													 appinfo->translated_vars);
+		childrte->updatedCols = translate_col_privs(parentrte->updatedCols,
+													appinfo->translated_vars);
 	}
 
-	/*
-	 * Build a PlanRowMark if parent is marked FOR UPDATE/SHARE.
-	 */
 	if (top_parentrc)
 	{
 		PlanRowMark *childrc = makeNode(PlanRowMark);
+		int		orig_allMarkTypes = top_parentrc->allMarkTypes;
 
-		childrc->rti = childRTindex;
+		childrc->rti = list_length(parse->rtable);
 		childrc->prti = top_parentrc->rti;
 		childrc->rowmarkId = top_parentrc->rowmarkId;
 		/* Reselect rowmark type, because relkind might not match parent */
-		childrc->markType = select_rowmark_type(childrte,
-												top_parentrc->strength);
+		childrc->markType = select_rowmark_type(childrte, top_parentrc->strength);
 		childrc->allMarkTypes = (1 << childrc->markType);
 		childrc->strength = top_parentrc->strength;
 		childrc->waitPolicy = top_parentrc->waitPolicy;
@@ -1804,18 +1793,65 @@ add_inheritance_child_to_query(PlannerInfo *root, RangeTblEntry *parentrte,
 
 		/* Include child's rowmark type in top parent's allMarkTypes */
 		top_parentrc->allMarkTypes |= childrc->allMarkTypes;
-
 		root->rowMarks = lappend(root->rowMarks, childrc);
-		if (child_rowmark)
-			*child_rowmark = childrc;
+
+		/*
+		 * Update query's targetlist if the newly added child row mark requires
+		 * additional columns and also add the relevant expressions to root
+		 * parent's reltarget.
+		 */
+		if (top_parentrc->allMarkTypes != orig_allMarkTypes)
+		{
+			List *tlist = root->parse->targetList;
+
+			tlist = add_rowmark_columns(root, tlist, list_make1(top_parentrc));
+			build_base_rel_tlists(root, tlist);
+		}
 	}
 
-	/* Close child relations, but keep locks */
-	if (childOID != parentOID)
+	*childrte_p = childrte;
+	return list_length(parse->rtable);
+}
+
+/*
+ * Starting with 'rel', find the root inheritance parent's RT index.
+ */
+Index
+get_inheritance_root_parent(PlannerInfo *root, RelOptInfo *rel)
+{
+	Index	rootRTindex = 0;
+
+	/* No AppendRelInfo array yet. */
+	if (root->append_rel_array == NULL)
+		return rel->relid;
+
+	/*
+	 * The inheritance root itself might be a child of UNION ALL subquery,
+	 * so we must resort to finding it like this.
+	 */
+	rootRTindex = rel->relid;
+	if (root->append_rel_array[rootRTindex])
 	{
-		Assert(childrel != NULL);
-		heap_close(childrel, lockmode);
+		AppendRelInfo *appinfo = root->append_rel_array[rootRTindex];
+		RangeTblEntry *parent = root->simple_rte_array[rootRTindex];
+
+		/*
+		 * Keep moving up until we reach the parent RTE that's not a
+		 * RTE_RELATION.  The last RTE_RELATION entry would be the
+		 * inheritance root's.
+		 */
+		while(parent->rtekind == RTE_RELATION)
+		{
+			appinfo = root->append_rel_array[appinfo->parent_relid];
+			if (appinfo == NULL)
+				break;
+			rootRTindex = appinfo->parent_relid;
+			parent = root->simple_rte_array[rootRTindex];
+		}
 	}
+
+	Assert(rootRTindex > 0);
+	return rootRTindex;
 }
 
 /*
@@ -1825,13 +1861,12 @@ add_inheritance_child_to_query(PlannerInfo *root, RangeTblEntry *parentrte,
  *
  * For paranoia's sake, we match type/collation as well as attribute name.
  */
-static void
+void
 make_inh_translation_list(TupleDesc old_tupdesc, TupleDesc new_tupdesc,
-						  RangeTblEntry *oldrte, RangeTblEntry *newrte,
+						  Oid from_rel, Oid to_rel,
 						  Index newvarno, List **translated_vars)
 {
 	List	   *vars = NIL;
-	Oid			new_relid = newrte->relid;
 	int			oldnatts = old_tupdesc->natts;
 	int			newnatts = new_tupdesc->natts;
 	int			old_attno;
@@ -1861,7 +1896,7 @@ make_inh_translation_list(TupleDesc old_tupdesc, TupleDesc new_tupdesc,
 		 * When we are generating the "translation list" for the parent table
 		 * of an inheritance set, no need to search for matches.
 		 */
-		if (oldrte->relid == newrte->relid)
+		if (from_rel == to_rel)
 		{
 			vars = lappend(vars, makeVar(newvarno,
 										 (AttrNumber) (old_attno + 1),
@@ -1887,10 +1922,10 @@ make_inh_translation_list(TupleDesc old_tupdesc, TupleDesc new_tupdesc,
 		{
 			HeapTuple	newtup;
 
-			newtup = SearchSysCacheAttName(new_relid, attname);
+			newtup = SearchSysCacheAttName(to_rel, attname);
 			if (!newtup)
 				elog(ERROR, "could not find inherited attribute \"%s\" of relation \"%s\"",
-					 attname, get_rel_name(newrte->relid));
+					 attname, get_rel_name(to_rel));
 			new_attno = ((Form_pg_attribute) GETSTRUCT(newtup))->attnum - 1;
 			ReleaseSysCache(newtup);
 
@@ -1900,10 +1935,10 @@ make_inh_translation_list(TupleDesc old_tupdesc, TupleDesc new_tupdesc,
 		/* Found it, check type and collation match */
 		if (atttypid != att->atttypid || atttypmod != att->atttypmod)
 			elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's type",
-				 attname, get_rel_name(newrte->relid));
+				 attname, get_rel_name(to_rel));
 		if (attcollation != att->attcollation)
 			elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's collation",
-				 attname, get_rel_name(newrte->relid));
+				 attname, get_rel_name(to_rel));
 
 		vars = lappend(vars, makeVar(newvarno,
 									 (AttrNumber) (new_attno + 1),
diff --git a/src/backend/optimizer/util/plancat.c b/src/backend/optimizer/util/plancat.c
index 77ae4b538a..c4a485af91 100644
--- a/src/backend/optimizer/util/plancat.c
+++ b/src/backend/optimizer/util/plancat.c
@@ -65,7 +65,7 @@ static bool infer_collation_opclass_match(InferenceElem *elem, Relation idxRel,
 							  List *idxExprs);
 static int32 get_rel_data_width(Relation rel, int32 *attr_widths);
 static List *get_relation_constraints(PlannerInfo *root,
-						 Oid relationObjectId, RelOptInfo *rel,
+						 Oid relationObjectId, Index varno,
 						 bool include_notnull);
 static List *build_index_tlist(PlannerInfo *root, IndexOptInfo *index,
 				  Relation heapRelation);
@@ -99,14 +99,13 @@ static void set_baserel_partition_key_exprs(Relation relation,
  * cases these are left as zeroes, but sometimes we need to compute attr
  * widths here, and we may as well cache the results for costsize.c.
  *
- * If inhparent is true, all we need to do is set up the attr arrays:
+ * If rte->inh is true, all we need to do is set up the attr arrays:
  * the RelOptInfo actually represents the appendrel formed by an inheritance
  * tree, and so the parent rel's physical size and index information isn't
  * important for it.
  */
 void
-get_relation_info(PlannerInfo *root, Oid relationObjectId, bool inhparent,
-				  Bitmapset *updatedCols, RelOptInfo *rel)
+get_relation_info(PlannerInfo *root, RangeTblEntry *rte, RelOptInfo *rel)
 {
 	Index		varno = rel->relid;
 	Relation	relation;
@@ -118,7 +117,7 @@ get_relation_info(PlannerInfo *root, Oid relationObjectId, bool inhparent,
 	 * the rewriter or when expand_inherited_rtentry() added it to the query's
 	 * rangetable.
 	 */
-	relation = heap_open(relationObjectId, NoLock);
+	relation = heap_open(rte->relid, NoLock);
 
 	/* Temporary and unlogged relations are inaccessible during recovery. */
 	if (!RelationNeedsWAL(relation) && RecoveryInProgress())
@@ -142,7 +141,7 @@ get_relation_info(PlannerInfo *root, Oid relationObjectId, bool inhparent,
 	 * must leave it zero for now to avoid bollixing the total_table_pages
 	 * calculation.
 	 */
-	if (!inhparent)
+	if (!rte->inh)
 		estimate_rel_size(relation, rel->attr_widths - rel->min_attr,
 						  &rel->pages, &rel->tuples, &rel->allvisfrac);
 
@@ -153,7 +152,7 @@ get_relation_info(PlannerInfo *root, Oid relationObjectId, bool inhparent,
 	 * Make list of indexes.  Ignore indexes on system catalogs if told to.
 	 * Don't bother with indexes for an inheritance parent, either.
 	 */
-	if (inhparent ||
+	if (rte->inh ||
 		(IgnoreSystemIndexes && IsSystemRelation(relation)))
 		hasindex = false;
 	else
@@ -442,18 +441,18 @@ get_relation_info(PlannerInfo *root, Oid relationObjectId, bool inhparent,
 	}
 
 	/* Collect info about relation's foreign keys, if relevant */
-	get_relation_foreign_keys(root, rel, relation, inhparent);
+	get_relation_foreign_keys(root, rel, relation, rte->inh);
 
 	/*
 	 * Collect info about relation's partitioning scheme, if any. Only
 	 * inheritance parents may be partitioned.
 	 */
-	if (inhparent && relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
+	if (rte->inh && relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
 	{
 		set_relation_partition_info(root, rel, relation);
 		if (!root->partColsUpdated)
 			root->partColsUpdated =
-				has_partition_attrs(relation, updatedCols, NULL);
+				has_partition_attrs(relation, rte->updatedCols, NULL);
 	}
 
 	rel->tupdesc = RelationGetDescr(relation);
@@ -467,7 +466,7 @@ get_relation_info(PlannerInfo *root, Oid relationObjectId, bool inhparent,
 	 * removing an index, or adding a hypothetical index to the indexlist.
 	 */
 	if (get_relation_info_hook)
-		(*get_relation_info_hook) (root, relationObjectId, inhparent, rel);
+		(*get_relation_info_hook) (root, rte->relid, rte->inh, rel);
 }
 
 /*
@@ -1181,11 +1180,10 @@ get_relation_data_width(Oid relid, int32 *attr_widths)
  */
 static List *
 get_relation_constraints(PlannerInfo *root,
-						 Oid relationObjectId, RelOptInfo *rel,
+						 Oid relationObjectId, Index varno,
 						 bool include_notnull)
 {
 	List	   *result = NIL;
-	Index		varno = rel->relid;
 	Relation	relation;
 	TupleConstr *constr;
 
@@ -1363,16 +1361,16 @@ get_relation_statistics(RelOptInfo *rel, Relation relation)
  */
 bool
 relation_excluded_by_constraints(PlannerInfo *root,
-								 RelOptInfo *rel, RangeTblEntry *rte)
+								 List *baserestrictinfo,
+								 Index varno,
+								 Oid table_oid,
+								 bool is_child)
 {
 	List	   *safe_restrictions;
 	List	   *constraint_pred;
 	List	   *safe_constraints;
 	ListCell   *lc;
 
-	/* As of now, constraint exclusion works only with simple relations. */
-	Assert(IS_SIMPLE_REL(rel));
-
 	/*
 	 * Regardless of the setting of constraint_exclusion, detect
 	 * constant-FALSE-or-NULL restriction clauses.  Because const-folding will
@@ -1382,9 +1380,9 @@ relation_excluded_by_constraints(PlannerInfo *root,
 	 * this, we'd miss some optimizations that 9.5 and earlier found via much
 	 * more roundabout methods.)
 	 */
-	if (list_length(rel->baserestrictinfo) == 1)
+	if (list_length(baserestrictinfo) == 1)
 	{
-		RestrictInfo *rinfo = (RestrictInfo *) linitial(rel->baserestrictinfo);
+		RestrictInfo *rinfo = (RestrictInfo *) linitial(baserestrictinfo);
 		Expr	   *clause = rinfo->clause;
 
 		if (clause && IsA(clause, Const) &&
@@ -1407,7 +1405,7 @@ relation_excluded_by_constraints(PlannerInfo *root,
 			 * When constraint_exclusion is set to 'partition' we only handle
 			 * OTHER_MEMBER_RELs.
 			 */
-			if (rel->reloptkind != RELOPT_OTHER_MEMBER_REL)
+			if (!is_child)
 				return false;
 			break;
 
@@ -1424,7 +1422,7 @@ relation_excluded_by_constraints(PlannerInfo *root,
 	 * expecting to see any in its predicate argument.
 	 */
 	safe_restrictions = NIL;
-	foreach(lc, rel->baserestrictinfo)
+	foreach(lc, baserestrictinfo)
 	{
 		RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
 
@@ -1440,24 +1438,10 @@ relation_excluded_by_constraints(PlannerInfo *root,
 		return true;
 
 	/*
-	 * Only plain relations have constraints.  In a partitioning hierarchy,
-	 * but not with regular table inheritance, it's OK to assume that any
-	 * constraints that hold for the parent also hold for every child; for
-	 * instance, table inheritance allows the parent to have constraints
-	 * marked NO INHERIT, but table partitioning does not.  We choose to check
-	 * whether the partitioning parents can be excluded here; doing so
-	 * consumes some cycles, but potentially saves us the work of excluding
-	 * each child individually.
-	 */
-	if (rte->rtekind != RTE_RELATION ||
-		(rte->inh && rte->relkind != RELKIND_PARTITIONED_TABLE))
-		return false;
-
-	/*
 	 * OK to fetch the constraint expressions.  Include "col IS NOT NULL"
 	 * expressions for attnotnull columns, in case we can refute those.
 	 */
-	constraint_pred = get_relation_constraints(root, rte->relid, rel, true);
+	constraint_pred = get_relation_constraints(root, table_oid, varno, true);
 
 	/*
 	 * We do not currently enforce that CHECK constraints contain only
@@ -1488,7 +1472,7 @@ relation_excluded_by_constraints(PlannerInfo *root,
 	 * We need strong refutation because we have to prove that the constraints
 	 * would yield false, not just NULL.
 	 */
-	if (predicate_refuted_by(safe_constraints, rel->baserestrictinfo, false))
+	if (predicate_refuted_by(safe_constraints, baserestrictinfo, false))
 		return true;
 
 	return false;
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index e98b626395..f87283e261 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -16,7 +16,10 @@
 
 #include <limits.h>
 
+#include "access/heapam.h"
+#include "catalog/partition.h"
 #include "catalog/pg_class.h"
+#include "catalog/pg_inherits.h"
 #include "miscadmin.h"
 #include "optimizer/clauses.h"
 #include "optimizer/cost.h"
@@ -24,12 +27,15 @@
 #include "optimizer/paths.h"
 #include "optimizer/placeholder.h"
 #include "optimizer/plancat.h"
+#include "optimizer/planmain.h"
 #include "optimizer/prep.h"
 #include "optimizer/restrictinfo.h"
 #include "optimizer/tlist.h"
 #include "partitioning/partbounds.h"
+#include "rewrite/rewriteManip.h"
 #include "storage/lockdefs.h"
 #include "utils/hsearch.h"
+#include "utils/rel.h"
 
 
 typedef struct JoinHashEntry
@@ -91,6 +97,13 @@ setup_simple_rel_arrays(PlannerInfo *root)
 	{
 		RangeTblEntry *rte = (RangeTblEntry *) lfirst(lc);
 
+		/*
+		 * If a table has no inheritance children, then turn off
+		 * inheritance so that further plannig steps process it as a
+		 * regular table.
+		 */
+		if (rte->rtekind == RTE_RELATION && !has_subclass(rte->relid))
+			rte->inh = false;
 		root->simple_rte_array[rti++] = rte;
 	}
 }
@@ -227,8 +240,7 @@ build_simple_rel(PlannerInfo *root, int relid, RelOptInfo *parent)
 	{
 		case RTE_RELATION:
 			/* Table --- retrieve statistics from the system catalogs */
-			get_relation_info(root, rte->relid, rte->inh, rte->updatedCols,
-							  rel);
+			get_relation_info(root, rte, rel);
 			break;
 		case RTE_SUBQUERY:
 		case RTE_FUNCTION:
@@ -269,29 +281,17 @@ build_simple_rel(PlannerInfo *root, int relid, RelOptInfo *parent)
 		root->qual_security_level = Max(root->qual_security_level,
 										list_length(rte->securityQuals));
 
+#ifdef NOT_USED
 	/*
 	 * If this rel is an appendrel parent, recurse to build "other rel"
 	 * RelOptInfos for its children.  They are "other rels" because they are
 	 * not in the main join tree, but we will need RelOptInfos to plan access
 	 * to them.
 	 */
-	if (rte->inh)
+	if (rte->inh && rte->rtekind == RTE_SUBQUERY)
 	{
 		ListCell   *l;
 
-		/*
-		 * For partitioned tables, we just allocate space for RelOptInfo's.
-		 * pointers for all partitions and copy the partition OIDs from the
-		 * relcache.  Actual RelOptInfo is built for a partition only if it is
-		 * not pruned.
-		 */
-		if (rte->relkind == RELKIND_PARTITIONED_TABLE)
-		{
-			rel->part_rels = (RelOptInfo **)
-				palloc0(sizeof(RelOptInfo *) * rel->nparts);
-			return rel;
-		}
-
 		foreach(l, root->append_rel_list)
 		{
 			AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(l);
@@ -303,6 +303,7 @@ build_simple_rel(PlannerInfo *root, int relid, RelOptInfo *parent)
 			(void) build_simple_rel(root, appinfo->child_relid, rel);
 		}
 	}
+#endif
 
 	return rel;
 }
@@ -1746,6 +1747,60 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
 }
 
 /*
+ * build_child_join_reltarget
+ *	  Set up a child-join relation's reltarget from a parent-join relation.
+ */
+static void
+build_child_join_reltarget(PlannerInfo *root,
+						   RelOptInfo *parentrel,
+						   RelOptInfo *childrel,
+						   int nappinfos,
+						   AppendRelInfo **appinfos)
+{
+	/* Build the targetlist */
+	childrel->reltarget->exprs = (List *)
+		adjust_appendrel_attrs(root,
+							   (Node *) parentrel->reltarget->exprs,
+							   nappinfos, appinfos);
+
+	/* Set the cost and width fields */
+	childrel->reltarget->cost.startup = parentrel->reltarget->cost.startup;
+	childrel->reltarget->cost.per_tuple = parentrel->reltarget->cost.per_tuple;
+	childrel->reltarget->width = parentrel->reltarget->width;
+}
+
+/* Expand the PlannerInfo arrays to hold new inheritance children objects. */
+void
+expand_planner_arrays_for_inheritance(PlannerInfo *root, int num_children)
+{
+	int		new_size = root->simple_rel_array_size + num_children;
+
+	root->simple_rte_array = (RangeTblEntry **)
+							repalloc(root->simple_rte_array,
+									 sizeof(RangeTblEntry *) * new_size);
+	root->simple_rel_array = (RelOptInfo **)
+								repalloc(root->simple_rel_array,
+										 sizeof(RelOptInfo *) * new_size);
+	if (root->append_rel_array)
+		root->append_rel_array = (AppendRelInfo **)
+									repalloc(root->append_rel_array,
+									 sizeof(AppendRelInfo *) * new_size);
+	else
+		root->append_rel_array = (AppendRelInfo **)
+									palloc0(sizeof(AppendRelInfo *) *
+											new_size);
+
+	/* Set the contents of just allocated memory to 0. */
+	MemSet(root->simple_rte_array + root->simple_rel_array_size,
+		   0, sizeof(RangeTblEntry *) * num_children);
+	MemSet(root->simple_rel_array + root->simple_rel_array_size,
+		   0, sizeof(RelOptInfo *) * num_children);
+	MemSet(root->append_rel_array + root->simple_rel_array_size,
+		   0, sizeof(AppendRelInfo *) * num_children);
+	root->simple_rel_array_size = new_size;
+}
+
+/*
  * build_dummy_partition_rel
  *		Build a RelOptInfo and AppendRelInfo for a pruned partition
  *
@@ -1804,55 +1859,20 @@ build_dummy_partition_rel(PlannerInfo *root, RelOptInfo *parent, int partidx)
  *		range table and creating planner data structures for it
  */
 RelOptInfo *
-build_partition_rel(PlannerInfo *root, RelOptInfo *parent, Oid partoid)
+build_partition_rel(PlannerInfo *root,
+					RelOptInfo *parent,
+					Oid partoid,
+					Index rootRTindex,
+					PlanRowMark *rootrc)
 {
 	RangeTblEntry *parentrte = root->simple_rte_array[parent->relid];
-	RelOptInfo *result;
-	Index		rootRTindex = 0;
+	RangeTblEntry *partrte;
+	Relation	partrel;
+	PartitionDesc partdesc;
 	Index		partRTindex = 0;
-	RangeTblEntry *partrte = NULL;
-	AppendRelInfo *appinfo = NULL;
-	PlanRowMark *rootrc = NULL;
-	int			orig_allMarkTypes;
-	PlanRowMark *childrc = NULL;
+	AppendRelInfo *appinfo;
 	int			lockmode;
 
-	/* Locate the root partitioned table and fetch its PlanRowMark, if any. */
-	if (root->rowMarks)
-	{
-		/*
-		 * The root partitioned table itself might be a child of UNION ALL
-		 * parent, so we must resort to finding the root parent like this.
-		 */
-		rootRTindex = parent->relid;
-		if (root->append_rel_array[rootRTindex])
-		{
-			AppendRelInfo *tmp = root->append_rel_array[rootRTindex];
-
-			/*
-			 * Keep moving up until we each the parent rel that's not a
-			 * partitioned table.  The one before that one would be the root
-			 * parent.
-			 */
-			while(root->simple_rel_array[rootRTindex]->part_scheme)
-			{
-				tmp = root->append_rel_array[tmp->parent_relid];
-				if (tmp == NULL)
-					break;
-				rootRTindex = tmp->parent_relid;
-			}
-		}
-
-		rootrc = get_plan_rowmark(root->rowMarks, rootRTindex);
-
-		/*
-		 * Addition of certain child rowmarks will change the value, in which
-		 * case, we need to add additional columns to the query's targetlist.
-		 */
-		if (rootrc)
-			orig_allMarkTypes = rootrc->allMarkTypes;
-	}
-
 	/* Determine the correct lockmode to use. */
 	if (rootRTindex == root->parse->resultRelation)
 		lockmode = RowExclusiveLock;
@@ -1860,58 +1880,124 @@ build_partition_rel(PlannerInfo *root, RelOptInfo *parent, Oid partoid)
 		lockmode = RowShareLock;
 	else
 		lockmode = AccessShareLock;
-	add_inheritance_child_to_query(root, parentrte, parent->relid,
-								   parent->reltype, parent->tupdesc,
-								   rootrc, partoid, lockmode,
-								   &appinfo, &partrte, &partRTindex,
-								   &childrc);
 
-	/* Partition turned out to be a partitioned table with 0 partitions. */
-	if (partrte == NULL)
+	partrel = heap_open(partoid, lockmode);
+	Assert(!RELATION_IS_OTHER_TEMP(partrel));
+	partdesc = RelationGetPartitionDesc(partrel);
+	if (partdesc && partdesc->nparts == 0)
+	{
+		heap_close(partrel, NoLock);
 		return NULL;
+	}
+
+	appinfo = makeNode(AppendRelInfo);
+	appinfo->parent_relid = parent->relid;
+	appinfo->child_relid = 0;	/* Set to correct value below. */
+	appinfo->parent_reltype = parent->reltype;
+	appinfo->child_reltype = partrel->rd_rel->reltype;
+	make_inh_translation_list(parent->tupdesc,
+							  RelationGetDescr(partrel),
+							  parentrte->relid, partoid,
+							  parent->relid,
+							  &appinfo->translated_vars);
+	appinfo->parent_reloid = parentrte->relid;
+
+	partRTindex = add_inheritance_child_to_query(root, parentrte, partrel,
+												 appinfo, rootrc, &partrte);
+	heap_close(partrel, NoLock);
+
+	Assert(partrte != NULL);
+
+	/* Fix up the AppendRelInfo with correct child RT index. */
+	appinfo->child_relid = partRTindex;
+	ChangeVarNodes((Node *) appinfo->translated_vars, parent->relid,
+				   partRTindex, 0);
 
-	Assert(appinfo != NULL);
 	root->append_rel_list = lappend(root->append_rel_list, appinfo);
 	root->simple_rte_array[partRTindex] = partrte;
 	root->append_rel_array[partRTindex] = appinfo;
 
-	/* Build the RelOptInfo. */
-	result = build_simple_rel(root, partRTindex, parent);
-
-	/* Set the information created by create_lateral_join_info(). */
-	result->direct_lateral_relids = parent->direct_lateral_relids;
-	result->lateral_relids = parent->lateral_relids;
-	result->lateral_referencers = parent->lateral_referencers;
-
-	if (rootrc && rootrc->allMarkTypes != orig_allMarkTypes)
-	{
-		List *tlist = root->parse->targetList;
-
-		tlist = add_rowmark_columns(root, tlist, list_make1(rootrc));
-	}
-
-	return result;
+	return build_inheritance_child_rel(root, partRTindex, parent);
 }
 
-/*
- * build_child_join_reltarget
- *	  Set up a child-join relation's reltarget from a parent-join relation.
- */
-static void
-build_child_join_reltarget(PlannerInfo *root,
-						   RelOptInfo *parentrel,
-						   RelOptInfo *childrel,
-						   int nappinfos,
-						   AppendRelInfo **appinfos)
+RelOptInfo *
+build_inheritance_child_rel(PlannerInfo *root, Index childRTindex,
+							RelOptInfo *parent)
 {
-	/* Build the targetlist */
-	childrel->reltarget->exprs = (List *)
-		adjust_appendrel_attrs(root,
-							   (Node *) parentrel->reltarget->exprs,
-							   nappinfos, appinfos);
+	Relids		top_parent_relids = parent->top_parent_relids;
+	int			rootParentRTindex = top_parent_relids ?
+									bms_singleton_member(top_parent_relids) :
+									parent->relid;
+	AppendRelInfo *appinfo = root->append_rel_array[childRTindex];
+	/* Build the RelOptInfo. */
+	RelOptInfo *childrel = build_simple_rel(root, childRTindex, parent);
 
-	/* Set the cost and width fields */
-	childrel->reltarget->cost.startup = parentrel->reltarget->cost.startup;
-	childrel->reltarget->cost.per_tuple = parentrel->reltarget->cost.per_tuple;
-	childrel->reltarget->width = parentrel->reltarget->width;
+	/*
+	 * Propagate lateral_relids and lateral_referencers from appendrel
+	 * parent rels to their child rels.  We intentionally give each child rel
+	 * the same minimum parameterization, even though it's quite possible that
+	 * some don't reference all the lateral rels.  This is because any append
+	 * path for the parent will have to have the same parameterization for
+	 * every child anyway, and there's no value in forcing extra
+	 * reparameterize_path() calls.  Similarly, a lateral reference to the
+	 * parent prevents use of otherwise-movable join rels for each child.
+	 */
+	childrel->direct_lateral_relids = parent->direct_lateral_relids;
+	childrel->lateral_relids = parent->lateral_relids;
+	childrel->lateral_referencers = parent->lateral_referencers;
+
+		/*
+		 * Copy/Modify targetlist. Even if this child is deemed empty, we need
+		 * its targetlist in case it falls on nullable side in a child-join
+		 * because of partitionwise join.
+		 *
+		 * NB: the resulting childrel->reltarget->exprs may contain arbitrary
+		 * expressions, which otherwise would not occur in a rel's targetlist.
+		 * Code that might be looking at an appendrel child must cope with
+		 * such.  (Normally, a rel's targetlist would only include Vars and
+		 * PlaceHolderVars.)  XXX we do not bother to update the cost or width
+		 * fields of childrel->reltarget; not clear if that would be useful.
+		 */
+		if (rootParentRTindex == root->parse->resultRelation)
+		{
+			Query	   *parse,
+					   *orig_parse = root->parse;
+			List	   *tlist;
+			List	   *other_exprs;
+			ListCell   *lc2;
+
+			parse = (Query *)
+					adjust_appendrel_attrs(root,
+										   (Node *) root->parse,
+										   1, &appinfo);
+			root->parse = parse;
+			tlist = preprocess_targetlist(root);
+			build_base_rel_tlists(root, tlist);
+			root->parse = orig_parse;
+
+			/*
+			 * Now add members of parent's reltarget->exprs, not already in
+			 * child's.
+			 */
+			other_exprs = (List *)
+				adjust_appendrel_attrs(root,
+									   (Node *) parent->reltarget->exprs,
+									   1, &appinfo);
+			foreach(lc2, other_exprs)
+			{
+				if (!list_member(childrel->reltarget->exprs, lfirst(lc2)))
+					childrel->reltarget->exprs =
+								lappend(childrel->reltarget->exprs,
+										lfirst(lc2));
+			}
+		}
+		else
+		{
+			childrel->reltarget->exprs = (List *)
+				adjust_appendrel_attrs(root,
+									   (Node *) parent->reltarget->exprs,
+									   1, &appinfo);
+		}
+
+	return childrel;
 }
diff --git a/src/backend/partitioning/partprune.c b/src/backend/partitioning/partprune.c
index 345ab19989..d5dad5a1e9 100644
--- a/src/backend/partitioning/partprune.c
+++ b/src/backend/partitioning/partprune.c
@@ -601,8 +601,6 @@ prune_append_rel_partitions(PlannerInfo *root, RelOptInfo *rel)
 			if (bms_is_empty(partindexes))
 				return;
 		}
-		else
-			scan_all_parts = true;
 	}
 	else
 		scan_all_parts = true;
@@ -611,7 +609,8 @@ prune_append_rel_partitions(PlannerInfo *root, RelOptInfo *rel)
 	 * Build selected partitions' range table entries, RelOptInfos, and
 	 * AppendRelInfos.
 	 */
-	add_rel_partitions_to_query(root, rel, scan_all_parts, partindexes);
+	if (scan_all_parts || !bms_is_empty(partindexes))
+		add_rel_partitions_to_query(root, rel, scan_all_parts, partindexes);
 }
 
 /*
diff --git a/src/include/optimizer/pathnode.h b/src/include/optimizer/pathnode.h
index 4f567765a4..bf5a025b69 100644
--- a/src/include/optimizer/pathnode.h
+++ b/src/include/optimizer/pathnode.h
@@ -15,6 +15,7 @@
 #define PATHNODE_H
 
 #include "nodes/bitmapset.h"
+#include "nodes/plannodes.h"
 #include "nodes/relation.h"
 
 
@@ -261,6 +262,8 @@ extern Path *reparameterize_path_by_child(PlannerInfo *root, Path *path,
  */
 extern void setup_simple_rel_arrays(PlannerInfo *root);
 extern void setup_append_rel_array(PlannerInfo *root);
+extern void expand_planner_arrays_for_inheritance(PlannerInfo *root,
+										   int num_children);
 extern RelOptInfo *build_simple_rel(PlannerInfo *root, int relid,
 				 RelOptInfo *parent);
 extern RelOptInfo *find_base_rel(PlannerInfo *root, int relid);
@@ -300,8 +303,12 @@ extern RelOptInfo *build_child_join_rel(PlannerInfo *root,
 extern RelOptInfo *build_dummy_partition_rel(PlannerInfo *root,
 									RelOptInfo *parent,
 									int partidx);
+RelOptInfo *build_inheritance_child_rel(PlannerInfo *root, Index childRTindex,
+							RelOptInfo *parent);
 extern RelOptInfo *build_partition_rel(PlannerInfo *root,
 									   RelOptInfo *parent,
-									   Oid partoid);
+									   Oid partoid,
+									   Index rootRTindex,
+									   PlanRowMark *rootrc);
 
 #endif							/* PATHNODE_H */
diff --git a/src/include/optimizer/plancat.h b/src/include/optimizer/plancat.h
index edaf2a3b4f..5e1e7478bf 100644
--- a/src/include/optimizer/plancat.h
+++ b/src/include/optimizer/plancat.h
@@ -25,8 +25,8 @@ typedef void (*get_relation_info_hook_type) (PlannerInfo *root,
 extern PGDLLIMPORT get_relation_info_hook_type get_relation_info_hook;
 
 
-extern void get_relation_info(PlannerInfo *root, Oid relationObjectId,
-				  bool inhparent, Bitmapset *updatedCols, RelOptInfo *rel);
+extern void get_relation_info(PlannerInfo *root, RangeTblEntry *rte,
+						RelOptInfo *rel);
 
 extern List *infer_arbiter_indexes(PlannerInfo *root);
 
@@ -36,7 +36,10 @@ extern void estimate_rel_size(Relation rel, int32 *attr_widths,
 extern int32 get_relation_data_width(Oid relid, int32 *attr_widths);
 
 extern bool relation_excluded_by_constraints(PlannerInfo *root,
-								 RelOptInfo *rel, RangeTblEntry *rte);
+								 List *baserestrictinfo,
+								 Index varno,
+								 Oid table_oid,
+								 bool is_child);
 
 extern List *build_physical_tlist(PlannerInfo *root, RelOptInfo *rel);
 
diff --git a/src/include/optimizer/prep.h b/src/include/optimizer/prep.h
index ee7406e4f6..1462e7b92f 100644
--- a/src/include/optimizer/prep.h
+++ b/src/include/optimizer/prep.h
@@ -16,6 +16,7 @@
 
 #include "nodes/plannodes.h"
 #include "nodes/relation.h"
+#include "utils/relcache.h"
 
 
 /*
@@ -50,18 +51,21 @@ extern PlanRowMark *get_plan_rowmark(List *rowmarks, Index rtindex);
  */
 extern RelOptInfo *plan_set_operations(PlannerInfo *root);
 
-extern void expand_inherited_tables(PlannerInfo *root);
-
-extern void add_inheritance_child_to_query(PlannerInfo *root,
-								RangeTblEntry *parentrte,
-								Index parentRTindex, Oid parentRelType,
-								TupleDesc parentDesc,
-								PlanRowMark *top_parentrc,
-								Oid childOID, int lockmode,
-								AppendRelInfo **appinfo_p,
-								RangeTblEntry **childrte_p,
-								Index *childRTindex_p,
-								PlanRowMark **child_rowmark);
+extern void expand_inherited_rtentry(PlannerInfo *root,
+						 RelOptInfo *rel,
+						 RangeTblEntry *rte,
+						 Index rti);
+extern Index add_inheritance_child_to_query(PlannerInfo *root,
+							   RangeTblEntry *parentrte,
+							   Relation childrel,
+							   AppendRelInfo *appinfo,
+							   PlanRowMark *top_parentrc,
+							   RangeTblEntry **childrte_p);
+extern Index get_inheritance_root_parent(PlannerInfo *root, RelOptInfo *rel);
+extern void make_inh_translation_list(TupleDesc old_tupdesc,
+						  TupleDesc new_tupdesc,
+						  Oid from_rel, Oid to_rel,
+						  Index newvarno, List **translated_vars);
 
 extern Node *adjust_appendrel_attrs(PlannerInfo *root, Node *node,
 					   int nappinfos, AppendRelInfo **appinfos);
-- 
2.11.0

From 59d57e19ee99bf63c4a4663738eae591da911d67 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Fri, 26 Oct 2018 16:45:59 +0900
Subject: [PATCH 1/6] Store inheritance root parent index in otherrel's
 RelOptInfo

Although it's set by build_simple_rel, it's not being used by any
code yet.
---
 src/backend/nodes/outfuncs.c         |  1 +
 src/backend/optimizer/util/relnode.c | 14 ++++++++++++++
 src/include/nodes/relation.h         |  4 ++++
 3 files changed, 19 insertions(+)

diff --git a/src/backend/nodes/outfuncs.c b/src/backend/nodes/outfuncs.c
index 69731ccdea..53a657c0ae 100644
--- a/src/backend/nodes/outfuncs.c
+++ b/src/backend/nodes/outfuncs.c
@@ -2371,6 +2371,7 @@ _outRelOptInfo(StringInfo str, const RelOptInfo *node)
 	WRITE_BOOL_FIELD(consider_partitionwise_join);
 	WRITE_BITMAPSET_FIELD(top_parent_relids);
 	WRITE_NODE_FIELD(partitioned_child_rels);
+	WRITE_UINT_FIELD(inh_root_parent);
 }
 
 static void
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index 39f5729b91..29ba19349f 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -215,9 +215,23 @@ build_simple_rel(PlannerInfo *root, int relid, RelOptInfo *parent)
 			rel->top_parent_relids = parent->top_parent_relids;
 		else
 			rel->top_parent_relids = bms_copy(parent->relids);
+
+		/*
+		 * For inheritance child relations, we also set inh_root_parent.
+		 * Note that 'parent' might itself be a child (a sub-partitioned
+		 * partition), in which case we simply use its value of
+		 * inh_root_parent.
+		 */
+		if (parent->rtekind == RTE_RELATION)
+			rel->inh_root_parent = parent->inh_root_parent > 0 ?
+										parent->inh_root_parent :
+										parent->relid;
 	}
 	else
+	{
 		rel->top_parent_relids = NULL;
+		rel->inh_root_parent = 0;
+	}
 
 	/* Check type of rtable entry */
 	switch (rte->rtekind)
diff --git a/src/include/nodes/relation.h b/src/include/nodes/relation.h
index 88d37236f7..bbc1408d05 100644
--- a/src/include/nodes/relation.h
+++ b/src/include/nodes/relation.h
@@ -703,6 +703,10 @@ typedef struct RelOptInfo
 	List	  **partexprs;		/* Non-nullable partition key expressions. */
 	List	  **nullable_partexprs; /* Nullable partition key expressions. */
 	List	   *partitioned_child_rels; /* List of RT indexes. */
+
+	Index		inh_root_parent;	/* For otherrels, this is the RT index of
+									 * inheritance table mentioned in the query
+									 * from which this relation originated */
 } RelOptInfo;
 
 /*
-- 
2.11.0

From 1dbca70ccf6ba8d94c5d4b9b52bc2bde2078d695 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Wed, 17 Oct 2018 11:18:12 +0900
Subject: [PATCH 2/6] Overhaul inheritance update/delete planning

With the current method, inheritance_planner, which handles the
planning for update/delete commands targeting inheritance trees,
performs the *whole* planning for each child table.  That involves
translating the query tree to set a given child table in place of
the original inheritance root table as the query's target table,
followed by calling grouping_planner on the translated query.

That's inefficient for two reasons:

 1. partprune.c cannot be used to perform partition pruning, because
    it can only be invoked from query_planner.  With the current
    approach, query_planner only sees the individual partitions in
    the query tree it receives, not the parent partitioned table.
    This leaves each partition to be pruned using constraint
    exclusion.

 2. Repeated invocation of query_planner results in allocating large
    amounts of memory, especially if there are many child tables.
    Also, it involves repeatedly performing the same processing,
    such jointree processing.

This commit addresses both of the issues by rewriting portions of
inheritance_planner and adding some supporting functionality to
allpath.c.

With the new implementation, inheritance_planner calls query_planner
only once at the beginning with the original unmodified query, which
creates the access paths of individual relations after pruning any
unnecessary partitions.  If the query involves join against the target
relation, join paths are created for each target child relation by
replacing the original target table in the join tree by a given child
table.  Join relations (RelOptInfos thereof) for all target child
relations are collected in a global list in PlannerInfo.

After creating the join paths for all target child relations, it
calls grouping_planner() on each child join relation to finish up the
paths such that they produce query's top-level target list expanded
per a given child relation's descriptor.  grouping_planner()'s
interface is modified so that we can pass it what's called a
'planned_rel', a RelOptInfo that already contains the necessary
paths needed to produce its output.

This removes some existing code in inheritance_planner that dealt
with any subquery RTEs in the query.  The rationale of that code
was that the subquery RTEs may change during each iteration of
planning (that is, for different children), so different iterations
better use different copies of those RTEs.  That was handled by
making fresh copies of those RTEs for each iteration of planning
which were appended to the range table, accompanied by modifying all
expressions and auxiliary structures that referenced the original
subquery RTEs to instead reference the copies (that is, change the
varnos).  This copying meant we would end up adding S * N new entries
to the original range table by the time we got to the last unpruned
child, where S is the number of subquery RTEs in the original query
and N the number of unpruned children.  Since with the new code
we perform planning just once, I think we don't need this special
handling.  Actually, there is a regression test output change due
to no longer having copies of subquery RTEs (see the diff of
partition_join.out file.)

Also we no longer need the hack in relation_excluded_by_constraints()
involving setting PlannerInfo.inhTargetKind to enable constraint
exclusion for target child relation is no longer needed.

This commit removes inheritance_planner in favor of rearranging
things such that, only the planning steps that affect 1 and 2 above
are repeated for unpruned child relations.
---
 doc/src/sgml/ddl.sgml                        |  14 +-
 src/backend/nodes/outfuncs.c                 |   1 -
 src/backend/optimizer/path/allpaths.c        | 212 +++++++++++++-
 src/backend/optimizer/plan/createplan.c      |  10 -
 src/backend/optimizer/plan/planner.c         | 400 +++++++--------------------
 src/backend/optimizer/prep/prepjointree.c    |   1 -
 src/backend/optimizer/prep/prepunion.c       |  33 ++-
 src/backend/optimizer/util/plancat.c         |  50 +---
 src/include/nodes/relation.h                 |  18 +-
 src/test/regress/expected/partition_join.out |   4 +-
 10 files changed, 356 insertions(+), 387 deletions(-)

diff --git a/doc/src/sgml/ddl.sgml b/doc/src/sgml/ddl.sgml
index b5ed1b7939..8cb69b1a47 100644
--- a/doc/src/sgml/ddl.sgml
+++ b/doc/src/sgml/ddl.sgml
@@ -3935,15 +3935,6 @@ EXPLAIN SELECT count(*) FROM measurement WHERE logdate &gt;= DATE '2008-01-01';
 
    <note>
     <para>
-     Currently, pruning of partitions during the planning of an
-     <command>UPDATE</command> or <command>DELETE</command> command is
-     implemented using the constraint exclusion method (however, it is
-     controlled by the <literal>enable_partition_pruning</literal> rather than
-     <literal>constraint_exclusion</literal>) &mdash; see the following section
-     for details and caveats that apply.
-    </para>
-
-    <para>
      Execution-time partition pruning currently occurs for the
      <literal>Append</literal> and <literal>MergeAppend</literal> node types.
     </para>
@@ -3964,9 +3955,8 @@ EXPLAIN SELECT count(*) FROM measurement WHERE logdate &gt;= DATE '2008-01-01';
 
    <para>
     <firstterm>Constraint exclusion</firstterm> is a query optimization
-    technique similar to partition pruning.  While it is primarily used
-    for partitioning implemented using the legacy inheritance method, it can be
-    used for other purposes, including with declarative partitioning.
+    technique similar to partition pruning.  It is primarily used
+    for partitioning implemented using the legacy inheritance method.
    </para>
 
    <para>
diff --git a/src/backend/nodes/outfuncs.c b/src/backend/nodes/outfuncs.c
index 53a657c0ae..a95153fea7 100644
--- a/src/backend/nodes/outfuncs.c
+++ b/src/backend/nodes/outfuncs.c
@@ -2309,7 +2309,6 @@ _outPlannerInfo(StringInfo str, const PlannerInfo *node)
 	WRITE_FLOAT_FIELD(tuple_fraction, "%.4f");
 	WRITE_FLOAT_FIELD(limit_tuples, "%.0f");
 	WRITE_UINT_FIELD(qual_security_level);
-	WRITE_ENUM_FIELD(inhTargetKind, InheritanceKind);
 	WRITE_BOOL_FIELD(hasJoinRTEs);
 	WRITE_BOOL_FIELD(hasLateralRTEs);
 	WRITE_BOOL_FIELD(hasDeletedRTEs);
diff --git a/src/backend/optimizer/path/allpaths.c b/src/backend/optimizer/path/allpaths.c
index 5f74d3b36d..aa678eac82 100644
--- a/src/backend/optimizer/path/allpaths.c
+++ b/src/backend/optimizer/path/allpaths.c
@@ -36,6 +36,7 @@
 #include "optimizer/pathnode.h"
 #include "optimizer/paths.h"
 #include "optimizer/plancat.h"
+#include "optimizer/planmain.h"
 #include "optimizer/planner.h"
 #include "optimizer/prep.h"
 #include "optimizer/restrictinfo.h"
@@ -119,6 +120,9 @@ static void set_namedtuplestore_pathlist(PlannerInfo *root, RelOptInfo *rel,
 static void set_worktable_pathlist(PlannerInfo *root, RelOptInfo *rel,
 					   RangeTblEntry *rte);
 static RelOptInfo *make_rel_from_joinlist(PlannerInfo *root, List *joinlist);
+static void inheritance_make_rel_from_joinlist(PlannerInfo *root,
+						RelOptInfo *parent,
+						List *joinlist);
 static bool subquery_is_pushdown_safe(Query *subquery, Query *topquery,
 						  pushdown_safety_info *safetyInfo);
 static bool recurse_pushdown_safe(Node *setOp, Query *topquery,
@@ -181,13 +185,28 @@ make_one_rel(PlannerInfo *root, List *joinlist)
 
 	/*
 	 * Generate access paths for the entire join tree.
+	 *
+	 * For UPDATE/DELETE on an inheritance parent, join paths should be
+	 * generated for each child result rel separately.
 	 */
-	rel = make_rel_from_joinlist(root, joinlist);
+	if (root->parse->resultRelation &&
+		root->simple_rte_array[root->parse->resultRelation]->inh)
+	{
+		rel = root->simple_rel_array[root->parse->resultRelation];
+		inheritance_make_rel_from_joinlist(root, rel, joinlist);
+		Assert(list_length(root->inh_target_child_rels) ==
+			   list_length(root->inh_target_child_joinrels));
+	}
+	else
+	{
+		rel = make_rel_from_joinlist(root, joinlist);
 
-	/*
-	 * The result should join all and only the query's base rels.
-	 */
-	Assert(bms_equal(rel->relids, root->all_baserels));
+		/*
+		 * The result should join all and only the query's base rels.
+		 */
+		Assert(bms_equal(rel->relids, root->all_baserels));
+
+	}
 
 	return rel;
 }
@@ -1183,6 +1202,63 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 			set_rel_consider_parallel(root, childrel, childRTE);
 
 		/*
+		 * If the root parent is the result relation, we need a reltarget
+		 * for the child that will be suitable to use the child as
+		 * target relation.
+		 */
+		if (childrel->inh_root_parent > 0 &&
+			childrel->inh_root_parent == root->parse->resultRelation)
+		{
+			Query	   *parse,
+					   *orig_parse = root->parse;
+			List	   *tlist;
+			List	   *other_exprs;
+			ListCell   *lc2;
+			Relids		child_relids,
+						top_parent_relids;
+
+			/*
+			 * We'd like to build the reltarget afresh; save the translated
+			 * version of parent's expressions aside.
+			 */
+			other_exprs = childrel->reltarget->exprs;
+			childrel->reltarget->exprs = NIL;
+
+			/*
+			 * Translate the original query's expressions to this child,
+			 * mainly for updating the childrel's reltarget so that it
+			 * contains necessary expressions for using childrel as target
+			 * relation correctly.  We need to use multilevel translation
+			 * as we can only access the original version of the query.
+			 */
+			child_relids = bms_make_singleton(appinfo->child_relid);
+			top_parent_relids = bms_make_singleton(childrel->inh_root_parent);
+			parse = (Query *)
+					adjust_appendrel_attrs_multilevel(root,
+													  (Node *) root->parse,
+													  child_relids,
+													  top_parent_relids);
+			root->parse = parse;
+			tlist = preprocess_targetlist(root);
+			build_base_rel_tlists(root, tlist);
+			root->parse = orig_parse;
+
+			/*
+			 * Some of the expressions in parent's reltarget might not be
+			 * in child's just built expressions.  Check to add any that are
+			 * missing.
+			 */
+			foreach(lc2, other_exprs)
+			{
+				Expr *expr = lfirst(lc2);
+
+				if (!list_member(childrel->reltarget->exprs, expr))
+					childrel->reltarget->exprs =
+								lappend(childrel->reltarget->exprs, expr);
+			}
+		}
+
+		/*
 		 * Compute the child's size.
 		 */
 		set_rel_size(root, childrel, childRTindex, childRTE);
@@ -2583,6 +2659,132 @@ generate_gather_paths(PlannerInfo *root, RelOptInfo *rel, bool override_rows)
 }
 
 /*
+ * inheritance_make_rel_from_joinlist
+ *		Perform join planning for all non-dummy leaf inheritance chilren
+ *		in their role as query's target relation
+ *
+ * If a child relation is a partitioned table, its children are processed in
+ * turn by recursively calling this function.
+ */
+static void
+inheritance_make_rel_from_joinlist(PlannerInfo *root,
+								   RelOptInfo *parent,
+								   List *joinlist)
+{
+	List	   *join_info_list = root->join_info_list;
+	ListCell   *lc;
+#ifdef USE_ASSERT_CHECKING
+	int		top_parent_relid = parent->inh_root_parent > 0 ?
+							   parent->inh_root_parent :
+							   parent->relid;
+	Relids	all_baserels;
+#endif
+
+	/*
+	 * For UPDATE/DELETE queries, the top parent can only ever be a table.
+	 * As a contrast, it could be a UNION ALL subquery in the case of SELECT.
+	 */
+	Assert(planner_rt_fetch(top_parent_relid, root)->rtekind == RTE_RELATION);
+
+	/* Nothing to do. */
+	if (IS_DUMMY_REL(parent))
+		return;
+
+	foreach(lc, root->append_rel_list)
+	{
+		RelOptInfo *childrel;
+		AppendRelInfo *appinfo = lfirst(lc);
+		List	   *translated_joinlist;
+		Relids		child_relids,
+					top_parent_relids;
+
+		/* Only consider this parent's children. */
+		if (appinfo->parent_relid != parent->relid)
+			continue;
+
+		childrel = find_base_rel(root, appinfo->child_relid);
+
+		/* Ignore excluded/pruned children. */
+		if (IS_DUMMY_REL(childrel))
+			continue;
+
+		/*
+		 * Sub-partitions have to be processed recursively, because
+		 * AppendRelInfoss link sub-partitions to their immediate parents, not
+		 * the root partitioned table.
+		 */
+		if (childrel->part_scheme != NULL)
+		{
+			inheritance_make_rel_from_joinlist(root, childrel, joinlist);
+			continue;
+		}
+
+		/*
+		 * Modify joinlist such that relations joined to the top parent rel
+		 * appear to be joined to the child rel instead.  Do the same for
+		 * any SpecialJoinInfo structs.
+		 */
+		child_relids = bms_make_singleton(appinfo->child_relid);
+		Assert(childrel->inh_root_parent > 0);
+		top_parent_relids = bms_make_singleton(childrel->inh_root_parent);
+		translated_joinlist = (List *)
+						adjust_appendrel_attrs_multilevel(root,
+														  (Node *) joinlist,
+														  child_relids,
+														  top_parent_relids);
+		root->join_info_list = (List *)
+				adjust_appendrel_attrs_multilevel(root,
+												  (Node *) join_info_list,
+												  child_relids,
+												  top_parent_relids);
+
+		/*
+		 * Since we added the child rel directly into the join tree, we must
+		 * modify it to be a "base" rel instead of an "other" rel, which the
+		 * join planning code expects the relations being joined to be.
+		 *
+		 * NB: Do we need to change the child EC members to be marked
+		 * as non-child somehow?
+		 */
+		childrel->reloptkind = RELOPT_BASEREL;
+
+		/* Reset interal join planning data structures. */
+		root->join_rel_list = NIL;
+		root->join_rel_hash = NULL;
+
+		/* Perform join planning and save the resulting RelOptInfo. */
+		childrel = make_rel_from_joinlist(root, translated_joinlist);
+
+		/*
+		 * Remember this child target rel.  inheritance_planner will perform
+		 * the remaining steps of planning for each child relation separately.
+		 * Specifically, it will call grouping_planner on every
+		 * RelOptInfo contained in the inh_target_child_joinrels list, each
+		 * of which represents the source of tuples to be modified for a given
+		 * target child rel.
+		 */
+		root->inh_target_child_rels = lappend_int(root->inh_target_child_rels,
+												  appinfo->child_relid);
+		root->inh_target_child_joinrels =
+						lappend(root->inh_target_child_joinrels, childrel);
+
+#ifdef USE_ASSERT_CHECKING
+		/*
+		 * The following implements essentially the same Assert as in
+		 * make_one_rel, our caller.
+		 */
+		all_baserels = bms_copy(root->all_baserels);
+		all_baserels = bms_del_member(all_baserels, top_parent_relid);
+		all_baserels = bms_add_member(all_baserels, appinfo->child_relid);
+		Assert(bms_equal(childrel->relids, all_baserels));
+#endif
+
+		/* Restore the original for processing the next child. */
+		root->join_info_list = join_info_list;
+	}
+}
+
+/*
  * make_rel_from_joinlist
  *	  Build access paths using a "joinlist" to guide the join path search.
  *
diff --git a/src/backend/optimizer/plan/createplan.c b/src/backend/optimizer/plan/createplan.c
index ae46b0140e..08ee0cf7c6 100644
--- a/src/backend/optimizer/plan/createplan.c
+++ b/src/backend/optimizer/plan/createplan.c
@@ -1998,12 +1998,7 @@ create_groupingsets_plan(PlannerInfo *root, GroupingSetsPath *best_path)
 	/*
 	 * During setrefs.c, we'll need the grouping_map to fix up the cols lists
 	 * in GroupingFunc nodes.  Save it for setrefs.c to use.
-	 *
-	 * This doesn't work if we're in an inheritance subtree (see notes in
-	 * create_modifytable_plan).  Fortunately we can't be because there would
-	 * never be grouping in an UPDATE/DELETE; but let's Assert that.
 	 */
-	Assert(root->inhTargetKind == INHKIND_NONE);
 	Assert(root->grouping_map == NULL);
 	root->grouping_map = grouping_map;
 
@@ -2160,12 +2155,7 @@ create_minmaxagg_plan(PlannerInfo *root, MinMaxAggPath *best_path)
 	 * with InitPlan output params.  (We can't just do that locally in the
 	 * MinMaxAgg node, because path nodes above here may have Agg references
 	 * as well.)  Save the mmaggregates list to tell setrefs.c to do that.
-	 *
-	 * This doesn't work if we're in an inheritance subtree (see notes in
-	 * create_modifytable_plan).  Fortunately we can't be because there would
-	 * never be aggregates in an UPDATE/DELETE; but let's Assert that.
 	 */
-	Assert(root->inhTargetKind == INHKIND_NONE);
 	Assert(root->minmax_aggs == NIL);
 	root->minmax_aggs = best_path->mmaggregates;
 
diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index c729a99f8b..93b8c761c2 100644
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -37,6 +37,7 @@
 #ifdef OPTIMIZER_DEBUG
 #include "nodes/print.h"
 #endif
+#include "nodes/relation.h"
 #include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
@@ -126,7 +127,7 @@ static Node *preprocess_expression(PlannerInfo *root, Node *expr, int kind);
 static void preprocess_qual_conditions(PlannerInfo *root, Node *jtnode);
 static void inheritance_planner(PlannerInfo *root);
 static void grouping_planner(PlannerInfo *root, bool inheritance_update,
-				 double tuple_fraction);
+				 RelOptInfo *planned_rel, double tuple_fraction);
 static grouping_sets_data *preprocess_grouping_sets(PlannerInfo *root);
 static List *remap_to_groupclause_idx(List *groupClause, List *gsets,
 						 int *tleref_to_colnum_map);
@@ -630,7 +631,6 @@ subquery_planner(PlannerGlobal *glob, Query *parse,
 	root->grouping_map = NULL;
 	root->minmax_aggs = NIL;
 	root->qual_security_level = 0;
-	root->inhTargetKind = INHKIND_NONE;
 	root->hasRecursion = hasRecursion;
 	if (hasRecursion)
 		root->wt_param_id = SS_assign_special_param(root);
@@ -970,7 +970,7 @@ subquery_planner(PlannerGlobal *glob, Query *parse,
 		rt_fetch(parse->resultRelation, parse->rtable)->inh)
 		inheritance_planner(root);
 	else
-		grouping_planner(root, false, tuple_fraction);
+		grouping_planner(root, false, NULL, tuple_fraction);
 
 	/*
 	 * Capture the set of outer-level param IDs we have access to, for use in
@@ -1146,12 +1146,19 @@ preprocess_phv_expression(PlannerInfo *root, Expr *expr)
  *	  inheritance set.
  *
  * We have to handle this case differently from cases where a source relation
- * is an inheritance set. Source inheritance is expanded at the bottom of the
- * plan tree (see allpaths.c), but target inheritance has to be expanded at
- * the top.  The reason is that for UPDATE, each target relation needs a
- * different targetlist matching its own column set.  Fortunately,
- * the UPDATE/DELETE target can never be the nullable side of an outer join,
- * so it's OK to generate the plan this way.
+ * is an inheritance set.  That's mainly because for UPDATE, each target
+ * relation needs a different targetlist matching its own column set.  So, we
+ * must modify the source scan/join path for each target relation such that it
+ * produces the desired target list.
+ *
+ * The source scan/join paths for individual target relations are still
+ * created in allpaths.c by first expanding the inheritance in the usual way
+ * by set_append_rel_size, followed by join planning for each target relation
+ * separately in make_one_rel.  Finally, we apply grouping_planner here to each
+ * child scan/join path so that it produces the desired targetlist.
+ *
+ * Fortunately, the UPDATE/DELETE target can never be the nullable side of an
+ * outer join, so it's OK to generate the plan this way.
  *
  * Returns nothing; the useful output is in the Paths we attach to
  * the (UPPERREL_FINAL, NULL) upperrel stored in *root.
@@ -1164,14 +1171,8 @@ inheritance_planner(PlannerInfo *root)
 {
 	Query	   *parse = root->parse;
 	int			top_parentRTindex = parse->resultRelation;
-	Bitmapset  *subqueryRTindexes;
-	Bitmapset  *modifiableARIindexes;
 	int			nominalRelation = -1;
 	Index		rootRelation = 0;
-	List	   *final_rtable = NIL;
-	int			save_rel_array_size = 0;
-	RelOptInfo **save_rel_array = NULL;
-	AppendRelInfo **save_append_rel_array = NULL;
 	List	   *subpaths = NIL;
 	List	   *subroots = NIL;
 	List	   *resultRelations = NIL;
@@ -1179,70 +1180,60 @@ inheritance_planner(PlannerInfo *root)
 	List	   *returningLists = NIL;
 	List	   *rowMarks;
 	RelOptInfo *final_rel;
-	ListCell   *lc;
-	Index		rti;
+	ListCell   *lc1,
+			   *lc2;
 	RangeTblEntry *parent_rte;
-	PlannerInfo *parent_root;
-	Query	   *parent_parse;
-	Bitmapset  *parent_relids = bms_make_singleton(top_parentRTindex);
-	PlannerInfo **parent_roots = NULL;
+	List	   *tlist,
+			   *orig_tlist;
+	standard_qp_extra qp_extra;
+	RelOptInfo *planned_rel;
+	List	   *partitioned_rels = NIL;
 
+	/* Inheritance is never used for insert. */
 	Assert(parse->commandType != CMD_INSERT);
+	parent_rte = planner_rt_fetch(top_parentRTindex, root);
 
 	/*
-	 * We generate a modified instance of the original Query for each target
-	 * relation, plan that, and put all the plans into a list that will be
-	 * controlled by a single ModifyTable node.  All the instances share the
-	 * same rangetable, but each instance must have its own set of subquery
-	 * RTEs within the finished rangetable because (1) they are likely to get
-	 * scribbled on during planning, and (2) it's not inconceivable that
-	 * subqueries could get planned differently in different cases.  We need
-	 * not create duplicate copies of other RTE kinds, in particular not the
-	 * target relations, because they don't have either of those issues.  Not
-	 * having to duplicate the target relations is important because doing so
-	 * (1) would result in a rangetable of length O(N^2) for N targets, with
-	 * at least O(N^3) work expended here; and (2) would greatly complicate
-	 * management of the rowMarks list.
+	 * Generate the access paths for all relations mentioned in the query,
+	 * including the target inheritance set.  When doing the join planning,
+	 * references in the join tree to the original target relation that's the
+	 * root parent of the inheritance tree is replaced by each of its
+	 * inheritance children and the resulting joinrel RelOptInfo's are
+	 * added to root->inh_target_child_joinrels.
 	 *
-	 * To begin with, generate a bitmapset of the relids of the subquery RTEs.
+	 * Final planning steps (grouping_planner) are applied to the best path
+	 * of each of those child joinrels using a modified instance of the
+	 * original query for a given child target rel.  All the paths so generated
+	 * are put into  a list that will be controlled by a single ModifyTable
+	 * node.  All the instances share the same rangetable.
 	 */
-	subqueryRTindexes = NULL;
-	rti = 1;
-	foreach(lc, parse->rtable)
-	{
-		RangeTblEntry *rte = lfirst_node(RangeTblEntry, lc);
-
-		if (rte->rtekind == RTE_SUBQUERY)
-			subqueryRTindexes = bms_add_member(subqueryRTindexes, rti);
-		rti++;
-	}
 
 	/*
-	 * Next, we want to identify which AppendRelInfo items contain references
-	 * to any of the aforesaid subquery RTEs.  These items will need to be
-	 * copied and modified to adjust their subquery references; whereas the
-	 * other ones need not be touched.  It's worth being tense over this
-	 * because we can usually avoid processing most of the AppendRelInfo
-	 * items, thereby saving O(N^2) space and time when the target is a large
-	 * inheritance tree.  We can identify AppendRelInfo items by their
-	 * child_relid, since that should be unique within the list.
+	 * Save the unmodified version of the query's targetlist to be used below
+	 * for passing to grouping_planner for each child target relation.
 	 */
-	modifiableARIindexes = NULL;
-	if (subqueryRTindexes != NULL)
-	{
-		foreach(lc, root->append_rel_list)
-		{
-			AppendRelInfo *appinfo = lfirst_node(AppendRelInfo, lc);
+	orig_tlist = list_copy(root->parse->targetList);
 
-			if (bms_is_member(appinfo->parent_relid, subqueryRTindexes) ||
-				bms_is_member(appinfo->child_relid, subqueryRTindexes) ||
-				bms_overlap(pull_varnos((Node *) appinfo->translated_vars),
-							subqueryRTindexes))
-				modifiableARIindexes = bms_add_member(modifiableARIindexes,
-													  appinfo->child_relid);
-		}
+	/* Do the scan/join planning. */
+	tlist = preprocess_targetlist(root);
+	qp_extra.tlist = tlist;
+	qp_extra.activeWindows = qp_extra.groupClause = NIL;
+	planned_rel = query_planner(root, tlist, standard_qp_callback, &qp_extra);
+
+	/*
+	 * If it turned out during query planning that all the children are dummy
+	 * (pruned or excluded by constraints), no need to do the steps below.
+	 * Let grouping_planner finish up the final path.
+	 */
+	if (IS_DUMMY_REL(planned_rel))
+	{
+		grouping_planner(root, false, planned_rel, 0.0);
+		return;
 	}
 
+	Assert(planned_rel->relid == top_parentRTindex);
+	Assert(planned_rel->reloptkind == RELOPT_BASEREL);
+
 	/*
 	 * If the parent RTE is a partitioned table, we should use that as the
 	 * nominal target relation, because the RTEs added for partitioned tables
@@ -1250,67 +1241,50 @@ inheritance_planner(PlannerInfo *root)
 	 * not appear anywhere else in the plan, so the confusion explained below
 	 * for non-partitioning inheritance cases is not possible.
 	 */
-	parent_rte = rt_fetch(top_parentRTindex, root->parse->rtable);
 	if (parent_rte->relkind == RELKIND_PARTITIONED_TABLE)
 	{
 		nominalRelation = top_parentRTindex;
 		rootRelation = top_parentRTindex;
+		partitioned_rels = lappend(partitioned_rels,
+								   list_make1_int(top_parentRTindex));
 	}
 
 	/*
-	 * The PlannerInfo for each child is obtained by translating the relevant
-	 * members of the PlannerInfo for its immediate parent, which we find
-	 * using the parent_relid in its AppendRelInfo.  We save the PlannerInfo
-	 * for each parent in an array indexed by relid for fast retrieval. Since
-	 * the maximum number of parents is limited by the number of RTEs in the
-	 * query, we use that number to allocate the array. An extra entry is
-	 * needed since relids start from 1.
+	 * Get on with finalizing the path for each child target relation by
+	 * calling grouping_planner on its joinrel.  Note that we're restoring
+	 * the query's targetlist to the original one for grouping_planner's
+	 * targetlist expansion steps to perform the expansion with individual
+	 * child descriptors.
 	 */
-	parent_roots = (PlannerInfo **) palloc0((list_length(parse->rtable) + 1) *
-											sizeof(PlannerInfo *));
-	parent_roots[top_parentRTindex] = root;
-
-	/*
-	 * And now we can get on with generating a plan for each child table.
-	 */
-	foreach(lc, root->append_rel_list)
+	parse->targetList = orig_tlist;
+	forboth(lc1, root->inh_target_child_rels,
+			lc2, root->inh_target_child_joinrels)
 	{
-		AppendRelInfo *appinfo = lfirst_node(AppendRelInfo, lc);
+		AppendRelInfo *appinfo = root->append_rel_array[lfirst_int(lc1)];
+		RelOptInfo *child_joinrel = lfirst(lc2);
 		PlannerInfo *subroot;
 		RangeTblEntry *child_rte;
 		RelOptInfo *sub_final_rel;
 		Path	   *subpath;
-
-		/* append_rel_list contains all append rels; ignore others */
-		if (!bms_is_member(appinfo->parent_relid, parent_relids))
-			continue;
-
-		/*
-		 * expand_inherited_rtentry() always processes a parent before any of
-		 * that parent's children, so the parent_root for this relation should
-		 * already be available.
-		 */
-		parent_root = parent_roots[appinfo->parent_relid];
-		Assert(parent_root != NULL);
-		parent_parse = parent_root->parse;
+		Relids		child_relids = bms_make_singleton(appinfo->child_relid),
+					top_parent_relids = bms_make_singleton(top_parentRTindex);
 
 		/*
 		 * We need a working copy of the PlannerInfo so that we can control
 		 * propagation of information back to the main copy.
 		 */
 		subroot = makeNode(PlannerInfo);
-		memcpy(subroot, parent_root, sizeof(PlannerInfo));
+		memcpy(subroot, root, sizeof(PlannerInfo));
 
 		/*
 		 * Generate modified query with this rel as target.  We first apply
 		 * adjust_appendrel_attrs, which copies the Query and changes
-		 * references to the parent RTE to refer to the current child RTE,
-		 * then fool around with subquery RTEs.
+		 * references to the parent RTE to refer to the current child RTE.
 		 */
 		subroot->parse = (Query *)
-			adjust_appendrel_attrs(parent_root,
-								   (Node *) parent_parse,
-								   1, &appinfo);
+					adjust_appendrel_attrs_multilevel(root, (Node *) parse,
+													  child_relids,
+													  top_parent_relids);
 
 		/*
 		 * If there are securityQuals attached to the parent, move them to the
@@ -1322,33 +1296,10 @@ inheritance_planner(PlannerInfo *root)
 		parent_rte->securityQuals = NIL;
 
 		/*
-		 * Mark whether we're planning a query to a partitioned table or an
-		 * inheritance parent.
+		 * inheritance_make_rel_from_joinlist only adds the leaf partitions to
+		 * PlannerInfo.
 		 */
-		subroot->inhTargetKind =
-			(rootRelation != 0) ? INHKIND_PARTITIONED : INHKIND_INHERITED;
-
-		/*
-		 * If this child is further partitioned, remember it as a parent.
-		 * Since a partitioned table does not have any data, we don't need to
-		 * create a plan for it, and we can stop processing it here.  We do,
-		 * however, need to remember its modified PlannerInfo for use when
-		 * processing its children, since we'll update their varnos based on
-		 * the delta from immediate parent to child, not from top to child.
-		 *
-		 * Note: a very non-obvious point is that we have not yet added
-		 * duplicate subquery RTEs to the subroot's rtable.  We mustn't,
-		 * because then its children would have two sets of duplicates,
-		 * confusing matters.
-		 */
-		if (child_rte->inh)
-		{
-			Assert(child_rte->relkind == RELKIND_PARTITIONED_TABLE);
-			parent_relids = bms_add_member(parent_relids, appinfo->child_relid);
-			parent_roots[appinfo->child_relid] = subroot;
-
-			continue;
-		}
+		Assert(!child_rte->inh);
 
 		/*
 		 * Set the nominal target relation of the ModifyTable node if not
@@ -1374,111 +1325,8 @@ inheritance_planner(PlannerInfo *root)
 		if (nominalRelation < 0)
 			nominalRelation = appinfo->child_relid;
 
-		/*
-		 * The rowMarks list might contain references to subquery RTEs, so
-		 * make a copy that we can apply ChangeVarNodes to.  (Fortunately, the
-		 * executor doesn't need to see the modified copies --- we can just
-		 * pass it the original rowMarks list.)
-		 */
-		subroot->rowMarks = copyObject(parent_root->rowMarks);
-
-		/*
-		 * The append_rel_list likewise might contain references to subquery
-		 * RTEs (if any subqueries were flattenable UNION ALLs).  So prepare
-		 * to apply ChangeVarNodes to that, too.  As explained above, we only
-		 * want to copy items that actually contain such references; the rest
-		 * can just get linked into the subroot's append_rel_list.
-		 *
-		 * If we know there are no such references, we can just use the outer
-		 * append_rel_list unmodified.
-		 */
-		if (modifiableARIindexes != NULL)
-		{
-			ListCell   *lc2;
-
-			subroot->append_rel_list = NIL;
-			foreach(lc2, parent_root->append_rel_list)
-			{
-				AppendRelInfo *appinfo2 = lfirst_node(AppendRelInfo, lc2);
-
-				if (bms_is_member(appinfo2->child_relid, modifiableARIindexes))
-					appinfo2 = copyObject(appinfo2);
-
-				subroot->append_rel_list = lappend(subroot->append_rel_list,
-												   appinfo2);
-			}
-		}
-
-		/*
-		 * Add placeholders to the child Query's rangetable list to fill the
-		 * RT indexes already reserved for subqueries in previous children.
-		 * These won't be referenced, so there's no need to make them very
-		 * valid-looking.
-		 */
-		while (list_length(subroot->parse->rtable) < list_length(final_rtable))
-			subroot->parse->rtable = lappend(subroot->parse->rtable,
-											 makeNode(RangeTblEntry));
-
-		/*
-		 * If this isn't the first child Query, generate duplicates of all
-		 * subquery RTEs, and adjust Var numbering to reference the
-		 * duplicates. To simplify the loop logic, we scan the original rtable
-		 * not the copy just made by adjust_appendrel_attrs; that should be OK
-		 * since subquery RTEs couldn't contain any references to the target
-		 * rel.
-		 */
-		if (final_rtable != NIL && subqueryRTindexes != NULL)
-		{
-			ListCell   *lr;
-
-			rti = 1;
-			foreach(lr, parent_parse->rtable)
-			{
-				RangeTblEntry *rte = lfirst_node(RangeTblEntry, lr);
-
-				if (bms_is_member(rti, subqueryRTindexes))
-				{
-					Index		newrti;
-
-					/*
-					 * The RTE can't contain any references to its own RT
-					 * index, except in its securityQuals, so we can save a
-					 * few cycles by applying ChangeVarNodes to the rest of
-					 * the rangetable before we append the RTE to it.
-					 */
-					newrti = list_length(subroot->parse->rtable) + 1;
-					ChangeVarNodes((Node *) subroot->parse, rti, newrti, 0);
-					ChangeVarNodes((Node *) subroot->rowMarks, rti, newrti, 0);
-					/* Skip processing unchanging parts of append_rel_list */
-					if (modifiableARIindexes != NULL)
-					{
-						ListCell   *lc2;
-
-						foreach(lc2, subroot->append_rel_list)
-						{
-							AppendRelInfo *appinfo2 = lfirst_node(AppendRelInfo, lc2);
-
-							if (bms_is_member(appinfo2->child_relid,
-											  modifiableARIindexes))
-								ChangeVarNodes((Node *) appinfo2, rti, newrti, 0);
-						}
-					}
-					rte = copyObject(rte);
-					ChangeVarNodes((Node *) rte->securityQuals, rti, newrti, 0);
-					subroot->parse->rtable = lappend(subroot->parse->rtable,
-													 rte);
-				}
-				rti++;
-			}
-		}
-
-		/* There shouldn't be any OJ info to translate, as yet */
-		Assert(subroot->join_info_list == NIL);
-		/* and we haven't created PlaceHolderInfos, either */
-		Assert(subroot->placeholder_list == NIL);
-
-		/* Generate Path(s) for accessing this result relation */
-		grouping_planner(subroot, true, 0.0 /* retrieve all tuples */ );
+		/* Apply the top-level targetlist to child_joinrel's path. */
+		grouping_planner(subroot, true, child_joinrel, 0.0);
 
 		/*
 		 * Select cheapest path in case there's more than one.  We always run
@@ -1490,45 +1338,10 @@ inheritance_planner(PlannerInfo *root)
 		subpath = sub_final_rel->cheapest_total_path;
 
 		/*
-		 * If this child rel was excluded by constraint exclusion, exclude it
-		 * from the result plan.
+		 * child rel cannot be empty, or inheritance_make_rel_from_joinlist
+		 * wouldn't have put it in the list to begin with.
 		 */
-		if (IS_DUMMY_PATH(subpath))
-			continue;
-
-		/*
-		 * If this is the first non-excluded child, its post-planning rtable
-		 * becomes the initial contents of final_rtable; otherwise, append
-		 * just its modified subquery RTEs to final_rtable.
-		 */
-		if (final_rtable == NIL)
-			final_rtable = subroot->parse->rtable;
-		else
-			final_rtable = list_concat(final_rtable,
-									   list_copy_tail(subroot->parse->rtable,
-													  list_length(final_rtable)));
-
-		/*
-		 * We need to collect all the RelOptInfos from all child plans into
-		 * the main PlannerInfo, since setrefs.c will need them.  We use the
-		 * last child's simple_rel_array (previous ones are too short), so we
-		 * have to propagate forward the RelOptInfos that were already built
-		 * in previous children.
-		 */
-		Assert(subroot->simple_rel_array_size >= save_rel_array_size);
-		for (rti = 1; rti < save_rel_array_size; rti++)
-		{
-			RelOptInfo *brel = save_rel_array[rti];
-
-			if (brel)
-				subroot->simple_rel_array[rti] = brel;
-		}
-		save_rel_array_size = subroot->simple_rel_array_size;
-		save_rel_array = subroot->simple_rel_array;
-		save_append_rel_array = subroot->append_rel_array;
-
-		/* Make sure any initplans from this rel get into the outer list */
-		root->init_plans = subroot->init_plans;
+		Assert(!IS_DUMMY_PATH(subpath));
 
 		/* Build list of sub-paths */
 		subpaths = lappend(subpaths, subpath);
@@ -1560,36 +1373,6 @@ inheritance_planner(PlannerInfo *root)
 	 */
 
 	/*
-	 * If we managed to exclude every child rel, return a dummy plan; it
-	 * doesn't even need a ModifyTable node.
-	 */
-	if (subpaths == NIL)
-	{
-		set_dummy_rel_pathlist(final_rel);
-		return;
-	}
-
-	/*
-	 * Put back the final adjusted rtable into the master copy of the Query.
-	 * (We mustn't do this if we found no non-excluded children.)
-	 */
-	parse->rtable = final_rtable;
-	root->simple_rel_array_size = save_rel_array_size;
-	root->simple_rel_array = save_rel_array;
-	root->append_rel_array = save_append_rel_array;
-
-	/* Must reconstruct master's simple_rte_array, too */
-	root->simple_rte_array = (RangeTblEntry **)
-		palloc0((list_length(final_rtable) + 1) * sizeof(RangeTblEntry *));
-	rti = 1;
-	foreach(lc, final_rtable)
-	{
-		RangeTblEntry *rte = lfirst_node(RangeTblEntry, lc);
-
-		root->simple_rte_array[rti++] = rte;
-	}
-
-	/*
 	 * If there was a FOR [KEY] UPDATE/SHARE clause, the LockRows node will
 	 * have dealt with fetching non-locked marked rows, else we need to have
 	 * ModifyTable do that.
@@ -1629,6 +1412,12 @@ inheritance_planner(PlannerInfo *root)
  * (inheritance_planner will create a single ModifyTable node covering all the
  * target tables.)
  *
+ * If non-NULL, planned_rel is a RelOptInfo containing paths for the query's
+ * top-level joinrel, which the caller produced by itself.  In that case, this
+ * function only needs to adjust the targetlist of its cheapest_total_path.
+ * The only caller that may pass such a RelOptInfo currently is
+ * inheritance_planner.
+ *
  * tuple_fraction is the fraction of tuples we expect will be retrieved.
  * tuple_fraction is interpreted as follows:
  *	  0: expect all tuples to be retrieved (normal case)
@@ -1647,6 +1436,7 @@ inheritance_planner(PlannerInfo *root)
  */
 static void
 grouping_planner(PlannerInfo *root, bool inheritance_update,
+				 RelOptInfo *planned_rel,
 				 double tuple_fraction)
 {
 	Query	   *parse = root->parse;
@@ -1659,7 +1449,7 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 	List	   *final_targets;
 	List	   *final_targets_contain_srfs;
 	bool		final_target_parallel_safe;
-	RelOptInfo *current_rel;
+	RelOptInfo *current_rel = planned_rel;
 	RelOptInfo *final_rel;
 	ListCell   *lc;
 
@@ -1699,6 +1489,7 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 		 * special work for recursive unions is the responsibility of
 		 * plan_set_operations.
 		 */
+		Assert(current_rel == NULL);
 		current_rel = plan_set_operations(root);
 
 		/*
@@ -1878,8 +1669,9 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 		 * We also generate (in standard_qp_callback) pathkey representations
 		 * of the query's sort clause, distinct clause, etc.
 		 */
-		current_rel = query_planner(root, tlist,
-									standard_qp_callback, &qp_extra);
+		if (current_rel == NULL)
+			current_rel = query_planner(root, tlist,
+										standard_qp_callback, &qp_extra);
 
 		/*
 		 * Convert the query's result tlist into PathTarget format.
diff --git a/src/backend/optimizer/prep/prepjointree.c b/src/backend/optimizer/prep/prepjointree.c
index cd6e11904e..78baec00dc 100644
--- a/src/backend/optimizer/prep/prepjointree.c
+++ b/src/backend/optimizer/prep/prepjointree.c
@@ -917,7 +917,6 @@ pull_up_simple_subquery(PlannerInfo *root, Node *jtnode, RangeTblEntry *rte,
 	subroot->grouping_map = NULL;
 	subroot->minmax_aggs = NIL;
 	subroot->qual_security_level = 0;
-	subroot->inhTargetKind = INHKIND_NONE;
 	subroot->hasRecursion = false;
 	subroot->wt_param_id = -1;
 	subroot->non_recursive_path = NULL;
diff --git a/src/backend/optimizer/prep/prepunion.c b/src/backend/optimizer/prep/prepunion.c
index d5720518a8..ef1f978889 100644
--- a/src/backend/optimizer/prep/prepunion.c
+++ b/src/backend/optimizer/prep/prepunion.c
@@ -2253,8 +2253,39 @@ adjust_appendrel_attrs_mutator(Node *node,
 											  context->appinfos);
 		return (Node *) phv;
 	}
+
+	/*
+	 * This is needed, because inheritance_make_rel_from_joinlist needs to
+	 * translate root->join_info_list executing make_rel_from_joinlist for a
+	 * given child.
+	 */
+	if (IsA(node, SpecialJoinInfo))
+	{
+		SpecialJoinInfo *oldinfo = (SpecialJoinInfo *) node;
+		SpecialJoinInfo *newinfo = makeNode(SpecialJoinInfo);
+
+		memcpy(newinfo, oldinfo, sizeof(SpecialJoinInfo));
+		newinfo->min_lefthand = adjust_child_relids(oldinfo->min_lefthand,
+													context->nappinfos,
+													context->appinfos);
+		newinfo->min_righthand = adjust_child_relids(oldinfo->min_righthand,
+													 context->nappinfos,
+													 context->appinfos);
+		newinfo->syn_lefthand = adjust_child_relids(oldinfo->syn_lefthand,
+													context->nappinfos,
+													context->appinfos);
+		newinfo->syn_righthand = adjust_child_relids(oldinfo->syn_righthand,
+													 context->nappinfos,
+													 context->appinfos);
+		newinfo->semi_rhs_exprs =
+					(List *) expression_tree_mutator((Node *)
+													 oldinfo->semi_rhs_exprs,
+													 adjust_appendrel_attrs_mutator,
+													 (void *) context);
+		return (Node *) newinfo;
+	}
+
 	/* 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));
diff --git a/src/backend/optimizer/util/plancat.c b/src/backend/optimizer/util/plancat.c
index 46de00460d..e7b4965337 100644
--- a/src/backend/optimizer/util/plancat.c
+++ b/src/backend/optimizer/util/plancat.c
@@ -1265,36 +1265,6 @@ get_relation_constraints(PlannerInfo *root,
 		}
 	}
 
-	/*
-	 * Append partition predicates, if any.
-	 *
-	 * For selects, partition pruning uses the parent table's partition bound
-	 * descriptor, instead of constraint exclusion which is driven by the
-	 * individual partition's partition constraint.
-	 */
-	if (enable_partition_pruning && root->parse->commandType != CMD_SELECT)
-	{
-		List	   *pcqual = RelationGetPartitionQual(relation);
-
-		if (pcqual)
-		{
-			/*
-			 * Run the partition quals through const-simplification similar to
-			 * check constraints.  We skip canonicalize_qual, though, because
-			 * partition quals should be in canonical form already; also,
-			 * since the qual is in implicit-AND format, we'd have to
-			 * explicitly convert it to explicit-AND format and back again.
-			 */
-			pcqual = (List *) eval_const_expressions(root, (Node *) pcqual);
-
-			/* Fix Vars to have the desired varno */
-			if (varno != 1)
-				ChangeVarNodes((Node *) pcqual, 1, varno, 0);
-
-			result = list_concat(result, pcqual);
-		}
-	}
-
 	heap_close(relation, NoLock);
 
 	return result;
@@ -1421,31 +1391,15 @@ relation_excluded_by_constraints(PlannerInfo *root,
 	switch (constraint_exclusion)
 	{
 		case CONSTRAINT_EXCLUSION_OFF:
-
-			/*
-			 * Don't prune if feature turned off -- except if the relation is
-			 * a partition.  While partprune.c-style partition pruning is not
-			 * yet in use for all cases (update/delete is not handled), it
-			 * would be a UI horror to use different user-visible controls
-			 * depending on such a volatile implementation detail.  Therefore,
-			 * for partitioned tables we use enable_partition_pruning to
-			 * control this behavior.
-			 */
-			if (root->inhTargetKind == INHKIND_PARTITIONED)
-				break;
 			return false;
 
 		case CONSTRAINT_EXCLUSION_PARTITION:
 
 			/*
 			 * When constraint_exclusion is set to 'partition' we only handle
-			 * OTHER_MEMBER_RELs, or BASERELs in cases where the result target
-			 * is an inheritance parent or a partitioned table.
+			 * OTHER_MEMBER_RELs.
 			 */
-			if ((rel->reloptkind != RELOPT_OTHER_MEMBER_REL) &&
-				!(rel->reloptkind == RELOPT_BASEREL &&
-				  root->inhTargetKind != INHKIND_NONE &&
-				  rel->relid == root->parse->resultRelation))
+			if (rel->reloptkind != RELOPT_OTHER_MEMBER_REL)
 				return false;
 			break;
 
diff --git a/src/include/nodes/relation.h b/src/include/nodes/relation.h
index bbc1408d05..21f1e4e6e6 100644
--- a/src/include/nodes/relation.h
+++ b/src/include/nodes/relation.h
@@ -318,9 +318,6 @@ typedef struct PlannerInfo
 	Index		qual_security_level;	/* minimum security_level for quals */
 	/* Note: qual_security_level is zero if there are no securityQuals */
 
-	InheritanceKind inhTargetKind;	/* indicates if the target relation is an
-									 * inheritance child or partition or a
-									 * partitioned table */
 	bool		hasJoinRTEs;	/* true if any RTEs are RTE_JOIN kind */
 	bool		hasLateralRTEs; /* true if any RTEs are marked LATERAL */
 	bool		hasDeletedRTEs; /* true if any RTE was deleted from jointree */
@@ -342,6 +339,21 @@ typedef struct PlannerInfo
 
 	/* Does this query modify any partition key columns? */
 	bool		partColsUpdated;
+
+	/*
+	 * The following fields are set during query planning portion of an
+	 * inherited UPDATE/DEELETE operation.
+	 */
+
+	/* RT indexes of child target rels */
+	List	   *inh_target_child_rels;
+
+	/*
+	 * RelOptInfos representing the output of make_rel_from_joinlist() for
+	 * a each child rel in the above list, acting as the target relation in
+	 * place of the original parent target relation.
+	 */
+	List	   *inh_target_child_joinrels;
 } PlannerInfo;
 
 
diff --git a/src/test/regress/expected/partition_join.out b/src/test/regress/expected/partition_join.out
index 3ba3aaf2d8..a539280851 100644
--- a/src/test/regress/expected/partition_join.out
+++ b/src/test/regress/expected/partition_join.out
@@ -1781,7 +1781,7 @@ WHERE EXISTS (
                Filter: (c IS NULL)
          ->  Nested Loop
                ->  Seq Scan on int4_tbl
-               ->  Subquery Scan on ss_1
+               ->  Subquery Scan on ss
                      ->  Limit
                            ->  Seq Scan on int8_tbl int8_tbl_1
    ->  Nested Loop Semi Join
@@ -1789,7 +1789,7 @@ WHERE EXISTS (
                Filter: (c IS NULL)
          ->  Nested Loop
                ->  Seq Scan on int4_tbl
-               ->  Subquery Scan on ss_2
+               ->  Subquery Scan on ss
                      ->  Limit
                            ->  Seq Scan on int8_tbl int8_tbl_2
 (28 rows)
-- 
2.11.0

From 1339a8c782f941d213300f6bb7067a79956b3280 Mon Sep 17 00:00:00 2001
From: "dgrowley@gmail.com" <dgrowley@gmail.com>
Date: Mon, 6 Aug 2018 19:50:11 +1200
Subject: [PATCH 3/6] Calculate total_table_pages after set_base_rel_sizes

Previously we did this before we attempted to prune partitions or
eliminate append children with constraint exclusion.  This could lead to
incorrectly applying random_page_cost to more pages in an index scan,
which could result in other scan types being preferred incorrectly.

Author: David Rowley
---
 src/backend/optimizer/path/allpaths.c | 39 +++++++++++++++++++++++++++++++++--
 src/backend/optimizer/plan/planmain.c | 30 ---------------------------
 src/include/nodes/relation.h          |  3 ++-
 3 files changed, 39 insertions(+), 33 deletions(-)

diff --git a/src/backend/optimizer/path/allpaths.c b/src/backend/optimizer/path/allpaths.c
index aa678eac82..051e4a8e74 100644
--- a/src/backend/optimizer/path/allpaths.c
+++ b/src/backend/optimizer/path/allpaths.c
@@ -151,6 +151,7 @@ make_one_rel(PlannerInfo *root, List *joinlist)
 {
 	RelOptInfo *rel;
 	Index		rti;
+	double		total_pages;
 
 	/*
 	 * Construct the all_baserels Relids set.
@@ -177,10 +178,44 @@ make_one_rel(PlannerInfo *root, List *joinlist)
 	set_base_rel_consider_startup(root);
 
 	/*
-	 * Compute size estimates and consider_parallel flags for each base rel,
-	 * then generate access paths.
+	 * Compute size estimates and consider_parallel flags for each base rel.
 	 */
 	set_base_rel_sizes(root);
+
+	/*
+	 * We should now have size estimates for every actual table involved in
+	 * the query, and we also know which if any have been deleted from the
+	 * query by join removal, pruned by partition pruning, and eliminated by
+	 * constraint exclusion.  We can now compute total_table_pages.
+	 *
+	 * Note that appendrels are not double-counted here, even though we don't
+	 * bother to distinguish RelOptInfos for appendrel parents, because the
+	 * parents will still have size zero.
+	 *
+	 * XXX if a table is self-joined, we will count it once per appearance,
+	 * which perhaps is the wrong thing ... but that's not completely clear,
+	 * and detecting self-joins here is difficult, so ignore it for now.
+	 */
+	total_pages = 0;
+	for (rti = 1; rti < root->simple_rel_array_size; rti++)
+	{
+		RelOptInfo *rel = root->simple_rel_array[rti];
+
+		if (rel == NULL)
+			continue;
+
+		Assert(rel->relid == rti); /* sanity check on array */
+
+		if (IS_DUMMY_REL(rel))
+			continue;
+
+		if (IS_SIMPLE_REL(rel))
+			total_pages += (double) rel->pages;
+	}
+
+	root->total_table_pages = total_pages;
+
+	/* Generate access paths. */
 	set_base_rel_pathlists(root);
 
 	/*
diff --git a/src/backend/optimizer/plan/planmain.c b/src/backend/optimizer/plan/planmain.c
index b05adc70c4..9b6cc9e10f 100644
--- a/src/backend/optimizer/plan/planmain.c
+++ b/src/backend/optimizer/plan/planmain.c
@@ -57,8 +57,6 @@ query_planner(PlannerInfo *root, List *tlist,
 	Query	   *parse = root->parse;
 	List	   *joinlist;
 	RelOptInfo *final_rel;
-	Index		rti;
-	double		total_pages;
 
 	/*
 	 * If the query has an empty join tree, then it's something easy like
@@ -232,34 +230,6 @@ query_planner(PlannerInfo *root, List *tlist,
 	extract_restriction_or_clauses(root);
 
 	/*
-	 * We should now have size estimates for every actual table involved in
-	 * the query, and we also know which if any have been deleted from the
-	 * query by join removal; so we can compute total_table_pages.
-	 *
-	 * Note that appendrels are not double-counted here, even though we don't
-	 * bother to distinguish RelOptInfos for appendrel parents, because the
-	 * parents will still have size zero.
-	 *
-	 * XXX if a table is self-joined, we will count it once per appearance,
-	 * which perhaps is the wrong thing ... but that's not completely clear,
-	 * and detecting self-joins here is difficult, so ignore it for now.
-	 */
-	total_pages = 0;
-	for (rti = 1; rti < root->simple_rel_array_size; rti++)
-	{
-		RelOptInfo *brel = root->simple_rel_array[rti];
-
-		if (brel == NULL)
-			continue;
-
-		Assert(brel->relid == rti); /* sanity check on array */
-
-		if (IS_SIMPLE_REL(brel))
-			total_pages += (double) brel->pages;
-	}
-	root->total_table_pages = total_pages;
-
-	/*
 	 * Ready to do the primary planning.
 	 */
 	final_rel = make_one_rel(root, joinlist);
diff --git a/src/include/nodes/relation.h b/src/include/nodes/relation.h
index 21f1e4e6e6..06212ce382 100644
--- a/src/include/nodes/relation.h
+++ b/src/include/nodes/relation.h
@@ -310,7 +310,8 @@ typedef struct PlannerInfo
 
 	MemoryContext planner_cxt;	/* context holding PlannerInfo */
 
-	double		total_table_pages;	/* # of pages in all tables of query */
+	double		total_table_pages;	/* # of pages in all non-dummy tables of
+									 * query */
 
 	double		tuple_fraction; /* tuple_fraction passed to query_planner */
 	double		limit_tuples;	/* limit_tuples passed to query_planner */
-- 
2.11.0

From 0454ee1969ac49ef056e9fc8896332c2cada54ef Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Wed, 17 Oct 2018 18:14:13 +0900
Subject: [PATCH 4/6] Lazy creation of RTEs for inheritance children

Currently, they're created in the planner's prep's phase, at which
point, it's too early to perform partition pruning or constraint
exclusion, which results in *all* partitions being opened and range
table entries being created for them.  With large number of children,
that can be pretty inefficient overall if most queries would only
access one or few of them.

This commit moves the processing that's currently done in
expand_inherited_table called from subquery_planner to a new
function that's called from set_append_rel_size, which is late enough
during query planning that we're able to perform partition pruning
(and constraint exclusion).  This also enables us to open the relation
and initialize planner objects for only the unpruned partitions.
For non-partition children, we still need to open them before we
could perform constraint exclusion.

Although the late initialization approach described above only
benefits the partitioning case as far as the number of child relations
that need to be opened is concerned, it seems undesirable to make a
special case of it.  Instead, this moves the inheritance expansion
code into a new module named append.c whose functionality is invoked
from set_append_rel_size, which contains the new code for inheritance
child initialization.  The only way partitioning is special in the
new module is that it performs pruning before any child relations
are initialized and only the unpruned children are initialized.  A
related new module named appendinfo.c contains the code related
to inheritance translation of expressions.

For partitioning, although we don't create planner data structures
for pruned partitions, partitionwise join code relies on the fact
fact that even though partitions may have been pruned, they'd still
own a RelOptInfo to handle the outer join case where the pruned
partition appears on the nullable side of join.  Partitionwise join
code deals with that by allocating dummy RelOptInfos for pruned
partitions.

There are some regression test diffs:

 1. Caused by the fact that we no longer allocate a duplicate RT
    entry for a partitioned table in its role as child and also that
    the individual partition RT entries are now created in the order
    in which their parent's are processed, whereas previously they'd
    be added to the range table in the order of depth-first expansion
    of inheritance tree.

 2. Those in postgres_fdw.out are caused by the fact that junk columns
    required for row marking are added to reltarget->exprs later than
    user columns, because the row marking junk columns arent added
    until after the inheritance is expanded which as of this commit
    is later than it used to be.
---
 contrib/postgres_fdw/expected/postgres_fdw.out    |   32 +-
 src/backend/optimizer/path/allpaths.c             |  206 +---
 src/backend/optimizer/path/equivclass.c           |    1 +
 src/backend/optimizer/path/joinrels.c             |   63 ++
 src/backend/optimizer/plan/initsplan.c            |   58 -
 src/backend/optimizer/plan/planner.c              |   55 +-
 src/backend/optimizer/plan/setrefs.c              |    6 +
 src/backend/optimizer/prep/preptlist.c            |   11 +-
 src/backend/optimizer/prep/prepunion.c            | 1236 ---------------------
 src/backend/optimizer/util/Makefile               |    5 +-
 src/backend/optimizer/util/append.c               |  679 +++++++++++
 src/backend/optimizer/util/appendinfo.c           |  851 ++++++++++++++
 src/backend/optimizer/util/pathnode.c             |    1 +
 src/backend/optimizer/util/plancat.c              |   41 +-
 src/backend/optimizer/util/relnode.c              |   81 +-
 src/backend/partitioning/partprune.c              |   44 +-
 src/include/nodes/relation.h                      |    8 +
 src/include/optimizer/append.h                    |   28 +
 src/include/optimizer/appendinfo.h                |   43 +
 src/include/optimizer/pathnode.h                  |    1 +
 src/include/optimizer/plancat.h                   |    2 +-
 src/include/optimizer/prep.h                      |   20 +-
 src/include/partitioning/partprune.h              |    2 +-
 src/test/regress/expected/join.out                |   22 +-
 src/test/regress/expected/partition_aggregate.out |    4 +-
 25 files changed, 1888 insertions(+), 1612 deletions(-)
 create mode 100644 src/backend/optimizer/util/append.c
 create mode 100644 src/backend/optimizer/util/appendinfo.c
 create mode 100644 src/include/optimizer/append.h
 create mode 100644 src/include/optimizer/appendinfo.h

diff --git a/contrib/postgres_fdw/expected/postgres_fdw.out b/contrib/postgres_fdw/expected/postgres_fdw.out
index 21a2ef5ad3..c930bf7bab 100644
--- a/contrib/postgres_fdw/expected/postgres_fdw.out
+++ b/contrib/postgres_fdw/expected/postgres_fdw.out
@@ -7085,15 +7085,15 @@ select * from bar where f1 in (select f1 from foo) for update;
                      Output: bar2.f1, bar2.f2, bar2.ctid, bar2.*, bar2.tableoid
                      Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct2 FOR UPDATE
          ->  Hash
-               Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+               Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                ->  HashAggregate
-                     Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                     Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                      Group Key: foo.f1
                      ->  Append
                            ->  Seq Scan on public.foo
-                                 Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                                 Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                            ->  Foreign Scan on public.foo2
-                                 Output: foo2.ctid, foo2.*, foo2.tableoid, foo2.f1
+                                 Output: foo2.f1, foo2.ctid, foo2.*, foo2.tableoid
                                  Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct1
 (23 rows)
 
@@ -7123,15 +7123,15 @@ select * from bar where f1 in (select f1 from foo) for share;
                      Output: bar2.f1, bar2.f2, bar2.ctid, bar2.*, bar2.tableoid
                      Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct2 FOR SHARE
          ->  Hash
-               Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+               Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                ->  HashAggregate
-                     Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                     Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                      Group Key: foo.f1
                      ->  Append
                            ->  Seq Scan on public.foo
-                                 Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                                 Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                            ->  Foreign Scan on public.foo2
-                                 Output: foo2.ctid, foo2.*, foo2.tableoid, foo2.f1
+                                 Output: foo2.f1, foo2.ctid, foo2.*, foo2.tableoid
                                  Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct1
 (23 rows)
 
@@ -7160,15 +7160,15 @@ update bar set f2 = f2 + 100 where f1 in (select f1 from foo);
          ->  Seq Scan on public.bar
                Output: bar.f1, bar.f2, bar.ctid
          ->  Hash
-               Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+               Output: foo.f1, foo.ctid, foo.tableoid, foo.*
                ->  HashAggregate
-                     Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                     Output: foo.f1, foo.ctid, foo.tableoid, foo.*
                      Group Key: foo.f1
                      ->  Append
                            ->  Seq Scan on public.foo
-                                 Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                                 Output: foo.f1, foo.ctid, foo.tableoid, foo.*
                            ->  Foreign Scan on public.foo2
-                                 Output: foo2.ctid, foo2.*, foo2.tableoid, foo2.f1
+                                 Output: foo2.f1, foo2.ctid, foo2.tableoid, foo2.*
                                  Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct1
    ->  Hash Join
          Output: bar2.f1, (bar2.f2 + 100), bar2.f3, bar2.ctid, foo.ctid, foo.*, foo.tableoid
@@ -7178,15 +7178,15 @@ update bar set f2 = f2 + 100 where f1 in (select f1 from foo);
                Output: bar2.f1, bar2.f2, bar2.f3, bar2.ctid
                Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct2 FOR UPDATE
          ->  Hash
-               Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+               Output: foo.f1, foo.ctid, foo.tableoid, foo.*
                ->  HashAggregate
-                     Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                     Output: foo.f1, foo.ctid, foo.tableoid, foo.*
                      Group Key: foo.f1
                      ->  Append
                            ->  Seq Scan on public.foo
-                                 Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                                 Output: foo.f1, foo.ctid, foo.tableoid, foo.*
                            ->  Foreign Scan on public.foo2
-                                 Output: foo2.ctid, foo2.*, foo2.tableoid, foo2.f1
+                                 Output: foo2.f1, foo2.ctid, foo2.tableoid, foo2.*
                                  Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct1
 (39 rows)
 
diff --git a/src/backend/optimizer/path/allpaths.c b/src/backend/optimizer/path/allpaths.c
index 051e4a8e74..971da18c1d 100644
--- a/src/backend/optimizer/path/allpaths.c
+++ b/src/backend/optimizer/path/allpaths.c
@@ -30,6 +30,8 @@
 #ifdef OPTIMIZER_DEBUG
 #include "nodes/print.h"
 #endif
+#include "optimizer/append.h"
+#include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/geqo.h"
@@ -44,7 +46,6 @@
 #include "optimizer/var.h"
 #include "parser/parse_clause.h"
 #include "parser/parsetree.h"
-#include "partitioning/partprune.h"
 #include "rewrite/rewriteManip.h"
 #include "utils/lsyscache.h"
 
@@ -942,8 +943,6 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 	double	   *parent_attrsizes;
 	int			nattrs;
 	ListCell   *l;
-	Relids		live_children = NULL;
-	bool		did_pruning = false;
 
 	/* Guard against stack overflow due to overly deep inheritance tree. */
 	check_stack_depth();
@@ -951,29 +950,22 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 	Assert(IS_SIMPLE_REL(rel));
 
 	/*
-	 * Initialize partitioned_child_rels to contain this RT index.
-	 *
-	 * Note that during the set_append_rel_pathlist() phase, we will bubble up
-	 * the indexes of partitioned relations that appear down in the tree, so
-	 * that when we've created Paths for all the children, the root
-	 * partitioned table's list will contain all such indexes.
+	 * Add append children to the PlannerInfo.
 	 */
-	if (rte->relkind == RELKIND_PARTITIONED_TABLE)
-		rel->partitioned_child_rels = list_make1_int(rti);
+	expand_append_rel(root, rel, rte, rti);
+
+	/* Did we find out that none of the children produce any output? */
+	if (IS_DUMMY_REL(rel))
+		return;
 
 	/*
-	 * If the partitioned relation has any baserestrictinfo quals then we
-	 * attempt to use these quals to prune away partitions that cannot
-	 * possibly contain any tuples matching these quals.  In this case we'll
-	 * store the relids of all partitions which could possibly contain a
-	 * matching tuple, and skip anything else in the loop below.
+	 * If we only need to scan the parent because all of the children are
+	 * either pruned or excluded, do so right away and return.
 	 */
-	if (enable_partition_pruning &&
-		rte->relkind == RELKIND_PARTITIONED_TABLE &&
-		rel->baserestrictinfo != NIL)
+	if (!rte->inh)
 	{
-		live_children = prune_append_rel_partitions(rel);
-		did_pruning = true;
+		set_rel_size(root, rel, rti, rte);
+		return;
 	}
 
 	/*
@@ -1013,12 +1005,8 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 		int			childRTindex;
 		RangeTblEntry *childRTE;
 		RelOptInfo *childrel;
-		List	   *childquals;
-		Index		cq_min_security;
-		bool		have_const_false_cq;
 		ListCell   *parentvars;
 		ListCell   *childvars;
-		ListCell   *lc;
 
 		/* append_rel_list contains all append rels; ignore others */
 		if (appinfo->parent_relid != parentRTindex)
@@ -1026,18 +1014,31 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 
 		childRTindex = appinfo->child_relid;
 		childRTE = root->simple_rte_array[childRTindex];
+		Assert(childRTE != NULL);
 
-		/*
-		 * The child rel's RelOptInfo was already created during
-		 * add_base_rels_to_query.
-		 */
+		/* The child rel's RelOptInfo is created during expand_append_rel */
 		childrel = find_base_rel(root, childRTindex);
 		Assert(childrel->reloptkind == RELOPT_OTHER_MEMBER_REL);
 
 		/*
-		 * Copy/Modify targetlist. Even if this child is deemed empty, we need
-		 * its targetlist in case it falls on nullable side in a child-join
-		 * because of partitionwise join.
+		 * Child relation may have be marked dummy if build_append_child_rel
+		 * found self-contradictory quals.
+		 */
+		if (IS_DUMMY_REL(childrel))
+			continue;
+
+		if (relation_excluded_by_constraints(root, childrel, childRTE))
+		{
+			/*
+			 * This child need not be scanned, so we can omit it from the
+			 * appendrel.
+			 */
+			set_dummy_rel_pathlist(childrel);
+			continue;
+		}
+
+		/*
+		 * Copy/Modify targetlist.
 		 *
 		 * NB: the resulting childrel->reltarget->exprs may contain arbitrary
 		 * expressions, which otherwise would not occur in a rel's targetlist.
@@ -1066,144 +1067,6 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 			add_child_rel_equivalences(root, appinfo, rel, childrel);
 		childrel->has_eclass_joins = rel->has_eclass_joins;
 
-		/*
-		 * We have to copy the parent's quals to the child, with appropriate
-		 * substitution of variables.  However, only the baserestrictinfo
-		 * quals are needed before we can check for constraint exclusion; so
-		 * do that first and then check to see if we can disregard this child.
-		 *
-		 * The child rel's targetlist might contain non-Var expressions, which
-		 * means that substitution into the quals could produce opportunities
-		 * for const-simplification, and perhaps even pseudoconstant quals.
-		 * Therefore, transform each RestrictInfo separately to see if it
-		 * reduces to a constant or pseudoconstant.  (We must process them
-		 * separately to keep track of the security level of each qual.)
-		 */
-		childquals = NIL;
-		cq_min_security = UINT_MAX;
-		have_const_false_cq = false;
-		foreach(lc, rel->baserestrictinfo)
-		{
-			RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
-			Node	   *childqual;
-			ListCell   *lc2;
-
-			Assert(IsA(rinfo, RestrictInfo));
-			childqual = adjust_appendrel_attrs(root,
-											   (Node *) rinfo->clause,
-											   1, &appinfo);
-			childqual = eval_const_expressions(root, childqual);
-			/* check for flat-out constant */
-			if (childqual && IsA(childqual, Const))
-			{
-				if (((Const *) childqual)->constisnull ||
-					!DatumGetBool(((Const *) childqual)->constvalue))
-				{
-					/* Restriction reduces to constant FALSE or NULL */
-					have_const_false_cq = true;
-					break;
-				}
-				/* Restriction reduces to constant TRUE, so drop it */
-				continue;
-			}
-			/* might have gotten an AND clause, if so flatten it */
-			foreach(lc2, make_ands_implicit((Expr *) childqual))
-			{
-				Node	   *onecq = (Node *) lfirst(lc2);
-				bool		pseudoconstant;
-
-				/* check for pseudoconstant (no Vars or volatile functions) */
-				pseudoconstant =
-					!contain_vars_of_level(onecq, 0) &&
-					!contain_volatile_functions(onecq);
-				if (pseudoconstant)
-				{
-					/* tell createplan.c to check for gating quals */
-					root->hasPseudoConstantQuals = true;
-				}
-				/* reconstitute RestrictInfo with appropriate properties */
-				childquals = lappend(childquals,
-									 make_restrictinfo((Expr *) onecq,
-													   rinfo->is_pushed_down,
-													   rinfo->outerjoin_delayed,
-													   pseudoconstant,
-													   rinfo->security_level,
-													   NULL, NULL, NULL));
-				/* track minimum security level among child quals */
-				cq_min_security = Min(cq_min_security, rinfo->security_level);
-			}
-		}
-
-		/*
-		 * In addition to the quals inherited from the parent, we might have
-		 * securityQuals associated with this particular child node.
-		 * (Currently this can only happen in appendrels originating from
-		 * UNION ALL; inheritance child tables don't have their own
-		 * securityQuals, see expand_inherited_rtentry().)	Pull any such
-		 * securityQuals up into the baserestrictinfo for the child.  This is
-		 * similar to process_security_barrier_quals() for the parent rel,
-		 * except that we can't make any general deductions from such quals,
-		 * since they don't hold for the whole appendrel.
-		 */
-		if (childRTE->securityQuals)
-		{
-			Index		security_level = 0;
-
-			foreach(lc, childRTE->securityQuals)
-			{
-				List	   *qualset = (List *) lfirst(lc);
-				ListCell   *lc2;
-
-				foreach(lc2, qualset)
-				{
-					Expr	   *qual = (Expr *) lfirst(lc2);
-
-					/* not likely that we'd see constants here, so no check */
-					childquals = lappend(childquals,
-										 make_restrictinfo(qual,
-														   true, false, false,
-														   security_level,
-														   NULL, NULL, NULL));
-					cq_min_security = Min(cq_min_security, security_level);
-				}
-				security_level++;
-			}
-			Assert(security_level <= root->qual_security_level);
-		}
-
-		/*
-		 * OK, we've got all the baserestrictinfo quals for this child.
-		 */
-		childrel->baserestrictinfo = childquals;
-		childrel->baserestrict_min_security = cq_min_security;
-
-		if (have_const_false_cq)
-		{
-			/*
-			 * Some restriction clause reduced to constant FALSE or NULL after
-			 * substitution, so this child need not be scanned.
-			 */
-			set_dummy_rel_pathlist(childrel);
-			continue;
-		}
-
-		if (did_pruning && !bms_is_member(appinfo->child_relid, live_children))
-		{
-			/* This partition was pruned; skip it. */
-			set_dummy_rel_pathlist(childrel);
-			continue;
-		}
-
-		if (relation_excluded_by_constraints(root, childrel, childRTE))
-		{
-			/*
-			 * This child need not be scanned, so we can omit it from the
-			 * appendrel.
-			 */
-			set_dummy_rel_pathlist(childrel);
-			continue;
-		}
-
 		/* CE failed, so finish copying/modifying join quals. */
 		childrel->joininfo = (List *)
 			adjust_appendrel_attrs(root,
@@ -1274,7 +1137,7 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 													  child_relids,
 													  top_parent_relids);
 			root->parse = parse;
-			tlist = preprocess_targetlist(root);
+			tlist = preprocess_targetlist(root, true);
 			build_base_rel_tlists(root, tlist);
 			root->parse = orig_parse;
 
@@ -2738,6 +2601,7 @@ inheritance_make_rel_from_joinlist(PlannerInfo *root,
 			continue;
 
 		childrel = find_base_rel(root, appinfo->child_relid);
+		Assert(childrel != NULL);
 
 		/* Ignore excluded/pruned children. */
 		if (IS_DUMMY_REL(childrel))
diff --git a/src/backend/optimizer/path/equivclass.c b/src/backend/optimizer/path/equivclass.c
index b22b36ec0e..5ace28eab0 100644
--- a/src/backend/optimizer/path/equivclass.c
+++ b/src/backend/optimizer/path/equivclass.c
@@ -22,6 +22,7 @@
 #include "catalog/pg_type.h"
 #include "nodes/makefuncs.h"
 #include "nodes/nodeFuncs.h"
+#include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
 #include "optimizer/pathnode.h"
 #include "optimizer/paths.h"
diff --git a/src/backend/optimizer/path/joinrels.c b/src/backend/optimizer/path/joinrels.c
index d3d21fed5d..6e321ec9e7 100644
--- a/src/backend/optimizer/path/joinrels.c
+++ b/src/backend/optimizer/path/joinrels.c
@@ -15,11 +15,13 @@
 #include "postgres.h"
 
 #include "miscadmin.h"
+#include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
 #include "optimizer/joininfo.h"
 #include "optimizer/pathnode.h"
 #include "optimizer/paths.h"
 #include "optimizer/prep.h"
+#include "optimizer/tlist.h"
 #include "partitioning/partbounds.h"
 #include "utils/lsyscache.h"
 #include "utils/memutils.h"
@@ -46,6 +48,9 @@ static void try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1,
 					   List *parent_restrictlist);
 static int match_expr_to_partition_keys(Expr *expr, RelOptInfo *rel,
 							 bool strict_op);
+static RelOptInfo *build_dummy_partition_rel(PlannerInfo *root,
+									RelOptInfo *parent,
+									int partidx);
 
 
 /*
@@ -1376,6 +1381,11 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
 		AppendRelInfo **appinfos;
 		int			nappinfos;
 
+		if (child_rel1 == NULL)
+			child_rel1 = build_dummy_partition_rel(root, rel1, cnt_parts);
+		if (child_rel2 == NULL)
+			child_rel2 = build_dummy_partition_rel(root, rel2, cnt_parts);
+
 		/* We should never try to join two overlapping sets of rels. */
 		Assert(!bms_overlap(child_rel1->relids, child_rel2->relids));
 		child_joinrelids = bms_union(child_rel1->relids, child_rel2->relids);
@@ -1582,3 +1592,56 @@ match_expr_to_partition_keys(Expr *expr, RelOptInfo *rel, bool strict_op)
 
 	return -1;
 }
+
+/*
+ * build_dummy_partition_rel
+ *		Build a RelOptInfo and AppendRelInfo for a pruned partition
+ *
+ * This does not result in opening the relation or a range table entry being
+ * created.  Also, the RelOptInfo thus created is not stored anywhere else
+ * beside the parent's part_rels array.
+ *
+ * The only reason this exists is because partition-wise join, in some cases,
+ * needs a RelOptInfo to represent an empty relation that's on the nullable
+ * side of an outer join, so that a Path representing the outer join can be
+ * created.
+ */
+RelOptInfo *
+build_dummy_partition_rel(PlannerInfo *root, RelOptInfo *parent, int partidx)
+{
+	RangeTblEntry *parentrte = root->simple_rte_array[parent->relid];
+	RelOptInfo *rel;
+
+	Assert(parent->part_rels[partidx] == NULL);
+
+	/* Create minimally valid-looking RelOptInfo with parent's relid. */
+	rel = makeNode(RelOptInfo);
+	rel->reloptkind = RELOPT_OTHER_MEMBER_REL;
+	rel->relid = parent->relid;
+	rel->relids = bms_copy(parent->relids);
+	if (parent->top_parent_relids)
+		rel->top_parent_relids = parent->top_parent_relids;
+	else
+		rel->top_parent_relids = bms_copy(parent->relids);
+	rel->reltarget = copy_pathtarget(parent->reltarget);
+	parent->part_rels[partidx] = rel;
+	mark_dummy_rel(rel);
+
+	/*
+	 * Now we'll need a (no-op) AppendRelInfo for parent, because we're
+	 * setting the dummy partition's relid to be same as the parent's.
+	 */
+	if (root->append_rel_array[parent->relid] == NULL)
+	{
+		/* Pass parent's info as for both the parent rel and child rel. */
+		AppendRelInfo *appinfo = make_append_rel_info(parent, parentrte,
+													  parent->tupdesc,
+													  parentrte->relid,
+													  parent->reltype,
+													  parent->relid);
+
+		root->append_rel_array[parent->relid] = appinfo;
+	}
+
+	return rel;
+}
diff --git a/src/backend/optimizer/plan/initsplan.c b/src/backend/optimizer/plan/initsplan.c
index 01335db511..7636aa82c4 100644
--- a/src/backend/optimizer/plan/initsplan.c
+++ b/src/backend/optimizer/plan/initsplan.c
@@ -616,64 +616,6 @@ create_lateral_join_info(PlannerInfo *root)
 				bms_add_member(brel2->lateral_referencers, rti);
 		}
 	}
-
-	/*
-	 * Lastly, propagate lateral_relids and lateral_referencers from appendrel
-	 * parent rels to their child rels.  We intentionally give each child rel
-	 * the same minimum parameterization, even though it's quite possible that
-	 * some don't reference all the lateral rels.  This is because any append
-	 * path for the parent will have to have the same parameterization for
-	 * every child anyway, and there's no value in forcing extra
-	 * reparameterize_path() calls.  Similarly, a lateral reference to the
-	 * parent prevents use of otherwise-movable join rels for each child.
-	 */
-	for (rti = 1; rti < root->simple_rel_array_size; rti++)
-	{
-		RelOptInfo *brel = root->simple_rel_array[rti];
-		RangeTblEntry *brte = root->simple_rte_array[rti];
-
-		/*
-		 * Skip empty slots. Also skip non-simple relations i.e. dead
-		 * relations.
-		 */
-		if (brel == NULL || !IS_SIMPLE_REL(brel))
-			continue;
-
-		/*
-		 * In the case of table inheritance, the parent RTE is directly linked
-		 * to every child table via an AppendRelInfo.  In the case of table
-		 * partitioning, the inheritance hierarchy is expanded one level at a
-		 * time rather than flattened.  Therefore, an other member rel that is
-		 * a partitioned table may have children of its own, and must
-		 * therefore be marked with the appropriate lateral info so that those
-		 * children eventually get marked also.
-		 */
-		Assert(brte);
-		if (brel->reloptkind == RELOPT_OTHER_MEMBER_REL &&
-			(brte->rtekind != RTE_RELATION ||
-			 brte->relkind != RELKIND_PARTITIONED_TABLE))
-			continue;
-
-		if (brte->inh)
-		{
-			foreach(lc, root->append_rel_list)
-			{
-				AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(lc);
-				RelOptInfo *childrel;
-
-				if (appinfo->parent_relid != rti)
-					continue;
-				childrel = root->simple_rel_array[appinfo->child_relid];
-				Assert(childrel->reloptkind == RELOPT_OTHER_MEMBER_REL);
-				Assert(childrel->direct_lateral_relids == NULL);
-				childrel->direct_lateral_relids = brel->direct_lateral_relids;
-				Assert(childrel->lateral_relids == NULL);
-				childrel->lateral_relids = brel->lateral_relids;
-				Assert(childrel->lateral_referencers == NULL);
-				childrel->lateral_referencers = brel->lateral_referencers;
-			}
-		}
-	}
 }
 
 
diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index 93b8c761c2..b54dc6c38e 100644
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -23,6 +23,7 @@
 #include "access/sysattr.h"
 #include "access/xact.h"
 #include "catalog/pg_constraint.h"
+#include "catalog/pg_inherits.h"
 #include "catalog/pg_proc.h"
 #include "catalog/pg_type.h"
 #include "executor/executor.h"
@@ -38,6 +39,7 @@
 #include "nodes/print.h"
 #endif
 #include "nodes/relation.h"
+#include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
@@ -699,27 +701,24 @@ subquery_planner(PlannerGlobal *glob, Query *parse,
 		}
 		if (rte->lateral)
 			root->hasLateralRTEs = true;
+
+		/*
+		 * While at it, also update the inh status.  If the relation doesn't
+		 * or can't have any children, there is no point in letting inh be set
+		 * to true.  Note that we do this before processing rowmarks, so that
+		 * the correct information for setting isParent field of PlanRowMarks.
+		 */
+		if (rte->rtekind == RTE_RELATION)
+			rte->inh = rte->inh && has_subclass(rte->relid);
 	}
 
 	/*
 	 * Preprocess RowMark information.  We need to do this after subquery
-	 * pullup (so that all non-inherited RTEs are present) and before
-	 * inheritance expansion (so that the info is available for
-	 * expand_inherited_tables to examine and modify).
+	 * pullup (so that all non-inherited RTEs are present).
 	 */
 	preprocess_rowmarks(root);
 
 	/*
-	 * Expand any rangetable entries that are inheritance sets into "append
-	 * relations".  This can add entries to the rangetable, but they must be
-	 * plain base relations not joins, so it's OK (and marginally more
-	 * efficient) to do it after checking for join RTEs.  We must do it after
-	 * pulling up subqueries, else we'd fail to handle inherited tables in
-	 * subqueries.
-	 */
-	expand_inherited_tables(root);
-
-	/*
 	 * Set hasHavingQual to remember if HAVING clause is present.  Needed
 	 * because preprocess_expression will reduce a constant-true condition to
 	 * an empty qual list ... but "HAVING TRUE" is not a semantic no-op.
@@ -1215,7 +1214,7 @@ inheritance_planner(PlannerInfo *root)
 	orig_tlist = list_copy(root->parse->targetList);
 
 	/* Do the scan/join planning. */
-	tlist = preprocess_targetlist(root);
+	tlist = preprocess_targetlist(root, false);
 	qp_extra.tlist = tlist;
 	qp_extra.activeWindows = qp_extra.groupClause = NIL;
 	planned_rel = query_planner(root, tlist, standard_qp_callback, &qp_extra);
@@ -1223,9 +1222,10 @@ inheritance_planner(PlannerInfo *root)
 	/*
 	 * If it turned out during query planning that all the children are dummy
 	 * (pruned or excluded by constraints), no need to do the steps below.
-	 * Let grouping_planner finish up the final path.
+	 * For regular inheritance case, it's possible that we only need to modify
+	 * the parent table.  Let grouping_planner finish up the final path.
 	 */
-	if (IS_DUMMY_REL(planned_rel))
+	if (!parent_rte->inh || IS_DUMMY_REL(planned_rel))
 	{
 		grouping_planner(root, false, planned_rel, 0.0);
 		return;
@@ -1580,7 +1580,7 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 		}
 
 		/* Preprocess targetlist */
-		tlist = preprocess_targetlist(root);
+		tlist = preprocess_targetlist(root, inheritance_update);
 
 		/*
 		 * We are now done hacking up the query's targetlist.  Most of the
@@ -1674,6 +1674,15 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 										standard_qp_callback, &qp_extra);
 
 		/*
+		 * Query planning may have added some columns to the top-level tlist,
+		 * which happens when there row marks applied to inheritance parent
+		 * relations (additional junk columns needed for applying row marks
+		 * are added after expanding inheritance.)
+		 */
+		if (list_length(tlist) < list_length(root->processed_tlist))
+			tlist = root->processed_tlist;
+
+		/*
 		 * Convert the query's result tlist into PathTarget format.
 		 *
 		 * Note: it's desirable to not do this till after query_planner(),
@@ -2360,7 +2369,7 @@ preprocess_rowmarks(PlannerInfo *root)
 		newrc->allMarkTypes = (1 << newrc->markType);
 		newrc->strength = rc->strength;
 		newrc->waitPolicy = rc->waitPolicy;
-		newrc->isParent = false;
+		newrc->isParent = rte->inh;
 
 		prowmarks = lappend(prowmarks, newrc);
 	}
@@ -2385,7 +2394,7 @@ preprocess_rowmarks(PlannerInfo *root)
 		newrc->allMarkTypes = (1 << newrc->markType);
 		newrc->strength = LCS_NONE;
 		newrc->waitPolicy = LockWaitBlock;	/* doesn't matter */
-		newrc->isParent = false;
+		newrc->isParent = rte->rtekind == RTE_RELATION ? rte->inh : false;
 
 		prowmarks = lappend(prowmarks, newrc);
 	}
@@ -6765,6 +6774,10 @@ apply_scanjoin_target_to_paths(PlannerInfo *root,
 			int			nappinfos;
 			List	   *child_scanjoin_targets = NIL;
 
+			/* Skip processing pruned partitions. */
+			if (child_rel == NULL)
+				continue;
+
 			/* Translate scan/join targets for this child. */
 			appinfos = find_appinfos_by_relids(root, child_rel->relids,
 											   &nappinfos);
@@ -6866,6 +6879,10 @@ create_partitionwise_grouping_paths(PlannerInfo *root,
 		RelOptInfo *child_grouped_rel;
 		RelOptInfo *child_partially_grouped_rel;
 
+		/* Skip processing pruned partitions. */
+		if (child_input_rel == NULL)
+			continue;
+
 		/* Input child rel must have a path */
 		Assert(child_input_rel->pathlist != NIL);
 
diff --git a/src/backend/optimizer/plan/setrefs.c b/src/backend/optimizer/plan/setrefs.c
index 6d6ef1c376..454870609a 100644
--- a/src/backend/optimizer/plan/setrefs.c
+++ b/src/backend/optimizer/plan/setrefs.c
@@ -326,6 +326,12 @@ add_rtes_to_flat_rtable(PlannerInfo *root, bool recursing)
 													  UPPERREL_FINAL, NULL)))
 					add_rtes_to_flat_rtable(rel->subroot, true);
 			}
+			/*
+			 * A NULL rel also means an unplanned subquery rte, so apply
+			 * flatten_unplanned_rtes.
+			 */
+			else
+				flatten_unplanned_rtes(glob, rte);
 		}
 		rti++;
 	}
diff --git a/src/backend/optimizer/prep/preptlist.c b/src/backend/optimizer/prep/preptlist.c
index 8603feef2b..9c0a1c1b1c 100644
--- a/src/backend/optimizer/prep/preptlist.c
+++ b/src/backend/optimizer/prep/preptlist.c
@@ -67,7 +67,7 @@ static List *expand_targetlist(List *tlist, int command_type,
  * is also preprocessed (and updated in-place).
  */
 List *
-preprocess_targetlist(PlannerInfo *root)
+preprocess_targetlist(PlannerInfo *root, bool inheritance_update)
 {
 	Query	   *parse = root->parse;
 	int			result_relation = parse->resultRelation;
@@ -134,6 +134,15 @@ preprocess_targetlist(PlannerInfo *root)
 		if (rc->rti != rc->prti)
 			continue;
 
+		/*
+		 * For inheritance parent row marks, we defer adding junk columns
+		 * until we've added child row marks, because some children might
+		 * require different row mark types which affects which junk columns
+		 * are needed in the top-level tlist.
+		 */
+		if (rc->isParent && !inheritance_update)
+			continue;
+
 		if (rc->allMarkTypes & ~(1 << ROW_MARK_COPY))
 		{
 			/* Need to fetch TID */
diff --git a/src/backend/optimizer/prep/prepunion.c b/src/backend/optimizer/prep/prepunion.c
index ef1f978889..70f37c593f 100644
--- a/src/backend/optimizer/prep/prepunion.c
+++ b/src/backend/optimizer/prep/prepunion.c
@@ -12,11 +12,6 @@
  * case, but most of the heavy lifting for that is done elsewhere,
  * notably in prepjointree.c and allpaths.c.
  *
- * There is also some code here to support planning of queries that use
- * inheritance (SELECT FROM foo*).  Inheritance trees are converted into
- * append relations, and thenceforth share code with the UNION ALL case.
- *
- *
  * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
@@ -54,13 +49,6 @@
 #include "utils/syscache.h"
 
 
-typedef struct
-{
-	PlannerInfo *root;
-	int			nappinfos;
-	AppendRelInfo **appinfos;
-} adjust_appendrel_attrs_context;
-
 static RelOptInfo *recurse_set_operations(Node *setOp, PlannerInfo *root,
 					   List *colTypes, List *colCollations,
 					   bool junkOK,
@@ -99,31 +87,6 @@ static List *generate_append_tlist(List *colTypes, List *colCollations,
 					  List *input_tlists,
 					  List *refnames_tlist);
 static List *generate_setop_grouplist(SetOperationStmt *op, List *targetlist);
-static void expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte,
-						 Index rti);
-static void expand_partitioned_rtentry(PlannerInfo *root,
-						   RangeTblEntry *parentrte,
-						   Index parentRTindex, Relation parentrel,
-						   PlanRowMark *top_parentrc, LOCKMODE lockmode,
-						   List **appinfos);
-static void expand_single_inheritance_child(PlannerInfo *root,
-								RangeTblEntry *parentrte,
-								Index parentRTindex, Relation parentrel,
-								PlanRowMark *top_parentrc, Relation childrel,
-								List **appinfos, RangeTblEntry **childrte_p,
-								Index *childRTindex_p);
-static void make_inh_translation_list(Relation oldrelation,
-						  Relation newrelation,
-						  Index newvarno,
-						  List **translated_vars);
-static Bitmapset *translate_col_privs(const Bitmapset *parent_privs,
-					List *translated_vars);
-static Node *adjust_appendrel_attrs_mutator(Node *node,
-							   adjust_appendrel_attrs_context *context);
-static Relids adjust_child_relids(Relids relids, int nappinfos,
-					AppendRelInfo **appinfos);
-static List *adjust_inherited_tlist(List *tlist,
-					   AppendRelInfo *context);
 
 
 /*
@@ -1460,1202 +1423,3 @@ generate_setop_grouplist(SetOperationStmt *op, List *targetlist)
 	Assert(lg == NULL);
 	return grouplist;
 }
-
-
-/*
- * expand_inherited_tables
- *		Expand each rangetable entry that represents an inheritance set
- *		into an "append relation".  At the conclusion of this process,
- *		the "inh" flag is set in all and only those RTEs that are append
- *		relation parents.
- */
-void
-expand_inherited_tables(PlannerInfo *root)
-{
-	Index		nrtes;
-	Index		rti;
-	ListCell   *rl;
-
-	/*
-	 * expand_inherited_rtentry may add RTEs to parse->rtable. The function is
-	 * expected to recursively handle any RTEs that it creates with inh=true.
-	 * So just scan as far as the original end of the rtable list.
-	 */
-	nrtes = list_length(root->parse->rtable);
-	rl = list_head(root->parse->rtable);
-	for (rti = 1; rti <= nrtes; rti++)
-	{
-		RangeTblEntry *rte = (RangeTblEntry *) lfirst(rl);
-
-		expand_inherited_rtentry(root, rte, rti);
-		rl = lnext(rl);
-	}
-}
-
-/*
- * expand_inherited_rtentry
- *		Check whether a rangetable entry represents an inheritance set.
- *		If so, add entries for all the child tables to the query's
- *		rangetable, and build AppendRelInfo nodes for all the child tables
- *		and add them to root->append_rel_list.  If not, clear the entry's
- *		"inh" flag to prevent later code from looking for AppendRelInfos.
- *
- * Note that the original RTE is considered to represent the whole
- * inheritance set.  The first of the generated RTEs is an RTE for the same
- * table, but with inh = false, to represent the parent table in its role
- * as a simple member of the inheritance set.
- *
- * A childless table is never considered to be an inheritance set. For
- * regular inheritance, a parent RTE must always have at least two associated
- * AppendRelInfos: one corresponding to the parent table as a simple member of
- * inheritance set and one or more corresponding to the actual children.
- * Since a partitioned table is not scanned, it might have only one associated
- * AppendRelInfo.
- */
-static void
-expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti)
-{
-	Oid			parentOID;
-	PlanRowMark *oldrc;
-	Relation	oldrelation;
-	LOCKMODE	lockmode;
-	List	   *inhOIDs;
-	ListCell   *l;
-
-	/* Does RT entry allow inheritance? */
-	if (!rte->inh)
-		return;
-	/* Ignore any already-expanded UNION ALL nodes */
-	if (rte->rtekind != RTE_RELATION)
-	{
-		Assert(rte->rtekind == RTE_SUBQUERY);
-		return;
-	}
-	/* Fast path for common case of childless table */
-	parentOID = rte->relid;
-	if (!has_subclass(parentOID))
-	{
-		/* Clear flag before returning */
-		rte->inh = false;
-		return;
-	}
-
-	/*
-	 * The rewriter should already have obtained an appropriate lock on each
-	 * relation named in the query.  However, for each child relation we add
-	 * to the query, we must obtain an appropriate lock, because this will be
-	 * the first use of those relations in the parse/rewrite/plan pipeline.
-	 * Child rels should use the same lockmode as their parent.
-	 */
-	lockmode = rte->rellockmode;
-
-	/* Scan for all members of inheritance set, acquire needed locks */
-	inhOIDs = find_all_inheritors(parentOID, lockmode, NULL);
-
-	/*
-	 * Check that there's at least one descendant, else treat as no-child
-	 * case.  This could happen despite above has_subclass() check, if table
-	 * once had a child but no longer does.
-	 */
-	if (list_length(inhOIDs) < 2)
-	{
-		/* Clear flag before returning */
-		rte->inh = false;
-		return;
-	}
-
-	/*
-	 * If parent relation is selected FOR UPDATE/SHARE, we need to mark its
-	 * PlanRowMark as isParent = true, and generate a new PlanRowMark for each
-	 * child.
-	 */
-	oldrc = get_plan_rowmark(root->rowMarks, rti);
-	if (oldrc)
-		oldrc->isParent = true;
-
-	/*
-	 * Must open the parent relation to examine its tupdesc.  We need not lock
-	 * it; we assume the rewriter already did.
-	 */
-	oldrelation = heap_open(parentOID, NoLock);
-
-	/* Scan the inheritance set and expand it */
-	if (RelationGetPartitionDesc(oldrelation) != NULL)
-	{
-		Assert(rte->relkind == RELKIND_PARTITIONED_TABLE);
-
-		/*
-		 * If this table has partitions, recursively expand them in the order
-		 * in which they appear in the PartitionDesc.  While at it, also
-		 * extract the partition key columns of all the partitioned tables.
-		 */
-		expand_partitioned_rtentry(root, rte, rti, oldrelation, oldrc,
-								   lockmode, &root->append_rel_list);
-	}
-	else
-	{
-		List	   *appinfos = NIL;
-		RangeTblEntry *childrte;
-		Index		childRTindex;
-
-		/*
-		 * This table has no partitions.  Expand any plain inheritance
-		 * children in the order the OIDs were returned by
-		 * find_all_inheritors.
-		 */
-		foreach(l, inhOIDs)
-		{
-			Oid			childOID = lfirst_oid(l);
-			Relation	newrelation;
-
-			/* Open rel if needed; we already have required locks */
-			if (childOID != parentOID)
-				newrelation = heap_open(childOID, NoLock);
-			else
-				newrelation = oldrelation;
-
-			/*
-			 * It is possible that the parent table has children that are temp
-			 * tables of other backends.  We cannot safely access such tables
-			 * (because of buffering issues), and the best thing to do seems
-			 * to be to silently ignore them.
-			 */
-			if (childOID != parentOID && RELATION_IS_OTHER_TEMP(newrelation))
-			{
-				heap_close(newrelation, lockmode);
-				continue;
-			}
-
-			expand_single_inheritance_child(root, rte, rti, oldrelation, oldrc,
-											newrelation,
-											&appinfos, &childrte,
-											&childRTindex);
-
-			/* Close child relations, but keep locks */
-			if (childOID != parentOID)
-				heap_close(newrelation, NoLock);
-		}
-
-		/*
-		 * If all the children were temp tables, pretend it's a
-		 * non-inheritance situation; we don't need Append node in that case.
-		 * The duplicate RTE we added for the parent table is harmless, so we
-		 * don't bother to get rid of it; ditto for the useless PlanRowMark
-		 * node.
-		 */
-		if (list_length(appinfos) < 2)
-			rte->inh = false;
-		else
-			root->append_rel_list = list_concat(root->append_rel_list,
-												appinfos);
-
-	}
-
-	heap_close(oldrelation, NoLock);
-}
-
-/*
- * expand_partitioned_rtentry
- *		Recursively expand an RTE for a partitioned table.
- *
- * Note that RelationGetPartitionDispatchInfo will expand partitions in the
- * same order as this code.
- */
-static void
-expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
-						   Index parentRTindex, Relation parentrel,
-						   PlanRowMark *top_parentrc, LOCKMODE lockmode,
-						   List **appinfos)
-{
-	int			i;
-	RangeTblEntry *childrte;
-	Index		childRTindex;
-	PartitionDesc partdesc = RelationGetPartitionDesc(parentrel);
-
-	check_stack_depth();
-
-	/* A partitioned table should always have a partition descriptor. */
-	Assert(partdesc);
-
-	Assert(parentrte->inh);
-
-	/*
-	 * Note down whether any partition key cols are being updated. Though it's
-	 * the root partitioned table's updatedCols we are interested in, we
-	 * instead use parentrte to get the updatedCols. This is convenient
-	 * because parentrte already has the root partrel's updatedCols translated
-	 * to match the attribute ordering of parentrel.
-	 */
-	if (!root->partColsUpdated)
-		root->partColsUpdated =
-			has_partition_attrs(parentrel, parentrte->updatedCols, NULL);
-
-	/* First expand the partitioned table itself. */
-	expand_single_inheritance_child(root, parentrte, parentRTindex, parentrel,
-									top_parentrc, parentrel,
-									appinfos, &childrte, &childRTindex);
-
-	/*
-	 * If the partitioned table has no partitions, treat this as the
-	 * non-inheritance case.
-	 */
-	if (partdesc->nparts == 0)
-	{
-		parentrte->inh = false;
-		return;
-	}
-
-	for (i = 0; i < partdesc->nparts; i++)
-	{
-		Oid			childOID = partdesc->oids[i];
-		Relation	childrel;
-
-		/* Open rel; we already have required locks */
-		childrel = heap_open(childOID, NoLock);
-
-		/*
-		 * Temporary partitions belonging to other sessions should have been
-		 * disallowed at definition, but for paranoia's sake, let's double
-		 * check.
-		 */
-		if (RELATION_IS_OTHER_TEMP(childrel))
-			elog(ERROR, "temporary relation from another session found as partition");
-
-		expand_single_inheritance_child(root, parentrte, parentRTindex,
-										parentrel, top_parentrc, childrel,
-										appinfos, &childrte, &childRTindex);
-
-		/* If this child is itself partitioned, recurse */
-		if (childrel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
-			expand_partitioned_rtentry(root, childrte, childRTindex,
-									   childrel, top_parentrc, lockmode,
-									   appinfos);
-
-		/* Close child relation, but keep locks */
-		heap_close(childrel, NoLock);
-	}
-}
-
-/*
- * expand_single_inheritance_child
- *		Build a RangeTblEntry and an AppendRelInfo, if appropriate, plus
- *		maybe a PlanRowMark.
- *
- * We now expand the partition hierarchy level by level, creating a
- * corresponding hierarchy of AppendRelInfos and RelOptInfos, where each
- * partitioned descendant acts as a parent of its immediate partitions.
- * (This is a difference from what older versions of PostgreSQL did and what
- * is still done in the case of table inheritance for unpartitioned tables,
- * where the hierarchy is flattened during RTE expansion.)
- *
- * PlanRowMarks still carry the top-parent's RTI, and the top-parent's
- * allMarkTypes field still accumulates values from all descendents.
- *
- * "parentrte" and "parentRTindex" are immediate parent's RTE and
- * RTI. "top_parentrc" is top parent's PlanRowMark.
- *
- * The child RangeTblEntry and its RTI are returned in "childrte_p" and
- * "childRTindex_p" resp.
- */
-static void
-expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte,
-								Index parentRTindex, Relation parentrel,
-								PlanRowMark *top_parentrc, Relation childrel,
-								List **appinfos, RangeTblEntry **childrte_p,
-								Index *childRTindex_p)
-{
-	Query	   *parse = root->parse;
-	Oid			parentOID = RelationGetRelid(parentrel);
-	Oid			childOID = RelationGetRelid(childrel);
-	RangeTblEntry *childrte;
-	Index		childRTindex;
-	AppendRelInfo *appinfo;
-
-	/*
-	 * Build an RTE for the child, and attach to query's rangetable list. We
-	 * copy most fields of the parent's RTE, but replace relation OID and
-	 * relkind, and set inh = false.  Also, set requiredPerms to zero since
-	 * all required permissions checks are done on the original RTE. Likewise,
-	 * set the child's securityQuals to empty, because we only want to apply
-	 * the parent's RLS conditions regardless of what RLS properties
-	 * individual children may have.  (This is an intentional choice to make
-	 * inherited RLS work like regular permissions checks.) The parent
-	 * securityQuals will be propagated to children along with other base
-	 * restriction clauses, so we don't need to do it here.
-	 */
-	childrte = copyObject(parentrte);
-	*childrte_p = childrte;
-	childrte->relid = childOID;
-	childrte->relkind = childrel->rd_rel->relkind;
-	/* A partitioned child will need to be expanded further. */
-	if (childOID != parentOID &&
-		childrte->relkind == RELKIND_PARTITIONED_TABLE)
-		childrte->inh = true;
-	else
-		childrte->inh = false;
-	childrte->requiredPerms = 0;
-	childrte->securityQuals = NIL;
-	parse->rtable = lappend(parse->rtable, childrte);
-	childRTindex = list_length(parse->rtable);
-	*childRTindex_p = childRTindex;
-
-	/*
-	 * We need an AppendRelInfo if paths will be built for the child RTE. If
-	 * childrte->inh is true, then we'll always need to generate append paths
-	 * for it.  If childrte->inh is false, we must scan it if it's not a
-	 * partitioned table; but if it is a partitioned table, then it never has
-	 * any data of its own and need not be scanned.
-	 */
-	if (childrte->relkind != RELKIND_PARTITIONED_TABLE || childrte->inh)
-	{
-		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->translated_vars);
-		appinfo->parent_reloid = parentOID;
-		*appinfos = lappend(*appinfos, appinfo);
-
-		/*
-		 * Translate the column permissions bitmaps to the child's attnums (we
-		 * have to build the translated_vars list before we can do this). But
-		 * if this is the parent table, leave copyObject's result alone.
-		 *
-		 * Note: we need to do this even though the executor won't run any
-		 * permissions checks on the child RTE.  The insertedCols/updatedCols
-		 * bitmaps may be examined for trigger-firing purposes.
-		 */
-		if (childOID != parentOID)
-		{
-			childrte->selectedCols = translate_col_privs(parentrte->selectedCols,
-														 appinfo->translated_vars);
-			childrte->insertedCols = translate_col_privs(parentrte->insertedCols,
-														 appinfo->translated_vars);
-			childrte->updatedCols = translate_col_privs(parentrte->updatedCols,
-														appinfo->translated_vars);
-		}
-	}
-
-	/*
-	 * Build a PlanRowMark if parent is marked FOR UPDATE/SHARE.
-	 */
-	if (top_parentrc)
-	{
-		PlanRowMark *childrc = makeNode(PlanRowMark);
-
-		childrc->rti = childRTindex;
-		childrc->prti = top_parentrc->rti;
-		childrc->rowmarkId = top_parentrc->rowmarkId;
-		/* Reselect rowmark type, because relkind might not match parent */
-		childrc->markType = select_rowmark_type(childrte,
-												top_parentrc->strength);
-		childrc->allMarkTypes = (1 << childrc->markType);
-		childrc->strength = top_parentrc->strength;
-		childrc->waitPolicy = top_parentrc->waitPolicy;
-
-		/*
-		 * We mark RowMarks for partitioned child tables as parent RowMarks so
-		 * that the executor ignores them (except their existence means that
-		 * the child tables be locked using appropriate mode).
-		 */
-		childrc->isParent = (childrte->relkind == RELKIND_PARTITIONED_TABLE);
-
-		/* Include child's rowmark type in top parent's allMarkTypes */
-		top_parentrc->allMarkTypes |= childrc->allMarkTypes;
-
-		root->rowMarks = lappend(root->rowMarks, childrc);
-	}
-}
-
-/*
- * make_inh_translation_list
- *	  Build the list of translations from parent Vars to child Vars for
- *	  an inheritance child.
- *
- * For paranoia's sake, we match type/collation as well as attribute name.
- */
-static void
-make_inh_translation_list(Relation oldrelation, Relation newrelation,
-						  Index newvarno,
-						  List **translated_vars)
-{
-	List	   *vars = NIL;
-	TupleDesc	old_tupdesc = RelationGetDescr(oldrelation);
-	TupleDesc	new_tupdesc = RelationGetDescr(newrelation);
-	Oid			new_relid = RelationGetRelid(newrelation);
-	int			oldnatts = old_tupdesc->natts;
-	int			newnatts = new_tupdesc->natts;
-	int			old_attno;
-	int			new_attno = 0;
-
-	for (old_attno = 0; old_attno < oldnatts; old_attno++)
-	{
-		Form_pg_attribute att;
-		char	   *attname;
-		Oid			atttypid;
-		int32		atttypmod;
-		Oid			attcollation;
-
-		att = TupleDescAttr(old_tupdesc, old_attno);
-		if (att->attisdropped)
-		{
-			/* Just put NULL into this list entry */
-			vars = lappend(vars, NULL);
-			continue;
-		}
-		attname = NameStr(att->attname);
-		atttypid = att->atttypid;
-		atttypmod = att->atttypmod;
-		attcollation = att->attcollation;
-
-		/*
-		 * When we are generating the "translation list" for the parent table
-		 * of an inheritance set, no need to search for matches.
-		 */
-		if (oldrelation == newrelation)
-		{
-			vars = lappend(vars, makeVar(newvarno,
-										 (AttrNumber) (old_attno + 1),
-										 atttypid,
-										 atttypmod,
-										 attcollation,
-										 0));
-			continue;
-		}
-
-		/*
-		 * Otherwise we have to search for the matching column by name.
-		 * There's no guarantee it'll have the same column position, because
-		 * of cases like ALTER TABLE ADD COLUMN and multiple inheritance.
-		 * However, in simple cases, the relative order of columns is mostly
-		 * the same in both relations, so try the column of newrelation that
-		 * follows immediately after the one that we just found, and if that
-		 * fails, let syscache handle it.
-		 */
-		if (new_attno >= newnatts ||
-			(att = TupleDescAttr(new_tupdesc, new_attno))->attisdropped ||
-			strcmp(attname, NameStr(att->attname)) != 0)
-		{
-			HeapTuple	newtup;
-
-			newtup = SearchSysCacheAttName(new_relid, attname);
-			if (!newtup)
-				elog(ERROR, "could not find inherited attribute \"%s\" of relation \"%s\"",
-					 attname, RelationGetRelationName(newrelation));
-			new_attno = ((Form_pg_attribute) GETSTRUCT(newtup))->attnum - 1;
-			ReleaseSysCache(newtup);
-
-			att = TupleDescAttr(new_tupdesc, new_attno);
-		}
-
-		/* Found it, check type and collation match */
-		if (atttypid != att->atttypid || atttypmod != att->atttypmod)
-			elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's type",
-				 attname, RelationGetRelationName(newrelation));
-		if (attcollation != att->attcollation)
-			elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's collation",
-				 attname, RelationGetRelationName(newrelation));
-
-		vars = lappend(vars, makeVar(newvarno,
-									 (AttrNumber) (new_attno + 1),
-									 atttypid,
-									 atttypmod,
-									 attcollation,
-									 0));
-		new_attno++;
-	}
-
-	*translated_vars = vars;
-}
-
-/*
- * translate_col_privs
- *	  Translate a bitmapset representing per-column privileges from the
- *	  parent rel's attribute numbering to the child's.
- *
- * The only surprise here is that we don't translate a parent whole-row
- * reference into a child whole-row reference.  That would mean requiring
- * permissions on all child columns, which is overly strict, since the
- * query is really only going to reference the inherited columns.  Instead
- * we set the per-column bits for all inherited columns.
- */
-static Bitmapset *
-translate_col_privs(const Bitmapset *parent_privs,
-					List *translated_vars)
-{
-	Bitmapset  *child_privs = NULL;
-	bool		whole_row;
-	int			attno;
-	ListCell   *lc;
-
-	/* System attributes have the same numbers in all tables */
-	for (attno = FirstLowInvalidHeapAttributeNumber + 1; attno < 0; attno++)
-	{
-		if (bms_is_member(attno - FirstLowInvalidHeapAttributeNumber,
-						  parent_privs))
-			child_privs = bms_add_member(child_privs,
-										 attno - FirstLowInvalidHeapAttributeNumber);
-	}
-
-	/* Check if parent has whole-row reference */
-	whole_row = bms_is_member(InvalidAttrNumber - FirstLowInvalidHeapAttributeNumber,
-							  parent_privs);
-
-	/* And now translate the regular user attributes, using the vars list */
-	attno = InvalidAttrNumber;
-	foreach(lc, translated_vars)
-	{
-		Var		   *var = lfirst_node(Var, lc);
-
-		attno++;
-		if (var == NULL)		/* ignore dropped columns */
-			continue;
-		if (whole_row ||
-			bms_is_member(attno - FirstLowInvalidHeapAttributeNumber,
-						  parent_privs))
-			child_privs = bms_add_member(child_privs,
-										 var->varattno - FirstLowInvalidHeapAttributeNumber);
-	}
-
-	return child_privs;
-}
-
-/*
- * adjust_appendrel_attrs
- *	  Copy the specified query or expression and translate Vars referring to a
- *	  parent rel to refer to the corresponding child rel instead.  We also
- *	  update rtindexes appearing outside Vars, such as resultRelation and
- *	  jointree relids.
- *
- * Note: this is only applied after conversion of sublinks to subplans,
- * so we don't need to cope with recursion into sub-queries.
- *
- * Note: this is not hugely different from what pullup_replace_vars() does;
- * maybe we should try to fold the two routines together.
- */
-Node *
-adjust_appendrel_attrs(PlannerInfo *root, Node *node, int nappinfos,
-					   AppendRelInfo **appinfos)
-{
-	Node	   *result;
-	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);
-
-	/*
-	 * Must be prepared to start with a Query or a bare expression tree.
-	 */
-	if (node && IsA(node, Query))
-	{
-		Query	   *newnode;
-		int			cnt;
-
-		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;
-}
-
-static Node *
-adjust_appendrel_attrs_mutator(Node *node,
-							   adjust_appendrel_attrs_context *context)
-{
-	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;
-
-		for (cnt = 0; cnt < nappinfos; cnt++)
-		{
-			if (var->varno == appinfos[cnt]->parent_relid)
-			{
-				appinfo = appinfos[cnt];
-				break;
-			}
-		}
-
-		if (var->varlevelsup == 0 && appinfo)
-		{
-			var->varno = appinfo->child_relid;
-			var->varnoold = appinfo->child_relid;
-			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));
-				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;
-
-					return (Node *) rowexpr;
-				}
-			}
-			/* system attributes don't need any other translation */
-		}
-		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, 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 */
-		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, context->nappinfos,
-											  context->appinfos);
-		return (Node *) phv;
-	}
-
-	/*
-	 * This is needed, because inheritance_make_rel_from_joinlist needs to
-	 * translate root->join_info_list executing make_rel_from_joinlist for a
-	 * given child.
-	 */
-	if (IsA(node, SpecialJoinInfo))
-	{
-		SpecialJoinInfo *oldinfo = (SpecialJoinInfo *) node;
-		SpecialJoinInfo *newinfo = makeNode(SpecialJoinInfo);
-
-		memcpy(newinfo, oldinfo, sizeof(SpecialJoinInfo));
-		newinfo->min_lefthand = adjust_child_relids(oldinfo->min_lefthand,
-													context->nappinfos,
-													context->appinfos);
-		newinfo->min_righthand = adjust_child_relids(oldinfo->min_righthand,
-													 context->nappinfos,
-													 context->appinfos);
-		newinfo->syn_lefthand = adjust_child_relids(oldinfo->syn_lefthand,
-													context->nappinfos,
-													context->appinfos);
-		newinfo->syn_righthand = adjust_child_relids(oldinfo->syn_righthand,
-													 context->nappinfos,
-													 context->appinfos);
-		newinfo->semi_rhs_exprs =
-					(List *) expression_tree_mutator((Node *)
-													 oldinfo->semi_rhs_exprs,
-													 adjust_appendrel_attrs_mutator,
-													 (void *) context);
-		return (Node *) newinfo;
-	}
-
-	/* Shouldn't need to handle planner auxiliary nodes here */
-	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 */
-		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->nullable_relids = adjust_child_relids(oldinfo->nullable_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));
-
-	return expression_tree_mutator(node, adjust_appendrel_attrs_mutator,
-								   (void *) context);
-}
-
-/*
- * Substitute child relids for parent relids in a Relid set.  The array of
- * appinfos specifies the substitutions to be performed.
- */
-static Relids
-adjust_child_relids(Relids relids, int nappinfos, AppendRelInfo **appinfos)
-{
-	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;
-}
-
-/*
- * Replace any relid present in top_parent_relids with its child in
- * child_relids. Members of child_relids can be multiple levels below top
- * parent in the partition hierarchy.
- */
-Relids
-adjust_child_relids_multilevel(PlannerInfo *root, Relids relids,
-							   Relids child_relids, Relids top_parent_relids)
-{
-	AppendRelInfo **appinfos;
-	int			nappinfos;
-	Relids		parent_relids = NULL;
-	Relids		result;
-	Relids		tmp_result = NULL;
-	int			cnt;
-
-	/*
-	 * If the given relids set doesn't contain any of the top parent relids,
-	 * it will remain unchanged.
-	 */
-	if (!bms_overlap(relids, top_parent_relids))
-		return relids;
-
-	appinfos = find_appinfos_by_relids(root, child_relids, &nappinfos);
-
-	/* Construct relids set for the immediate parent of the given child. */
-	for (cnt = 0; cnt < nappinfos; cnt++)
-	{
-		AppendRelInfo *appinfo = appinfos[cnt];
-
-		parent_relids = bms_add_member(parent_relids, appinfo->parent_relid);
-	}
-
-	/* Recurse if immediate parent is not the top parent. */
-	if (!bms_equal(parent_relids, top_parent_relids))
-	{
-		tmp_result = adjust_child_relids_multilevel(root, relids,
-													parent_relids,
-													top_parent_relids);
-		relids = tmp_result;
-	}
-
-	result = adjust_child_relids(relids, nappinfos, appinfos);
-
-	/* Free memory consumed by any intermediate result. */
-	if (tmp_result)
-		bms_free(tmp_result);
-	bms_free(parent_relids);
-	pfree(appinfos);
-
-	return result;
-}
-
-/*
- * 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.
- */
-static List *
-adjust_inherited_tlist(List *tlist, AppendRelInfo *context)
-{
-	bool		changed_it = false;
-	ListCell   *tl;
-	List	   *new_tlist;
-	bool		more;
-	int			attrno;
-
-	/* 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)
-	{
-		TargetEntry *tle = (TargetEntry *) lfirst(tl);
-		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))
-			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);
-		if (childvar == NULL || !IsA(childvar, Var))
-			elog(ERROR, "attribute %d of relation \"%s\" does not exist",
-				 tle->resno, get_rel_name(context->parent_reloid));
-
-		if (tle->resno != childvar->varattno)
-		{
-			tle->resno = childvar->varattno;
-			changed_it = true;
-		}
-	}
-
-	/*
-	 * 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;
-
-	new_tlist = NIL;
-	more = true;
-	for (attrno = 1; more; attrno++)
-	{
-		more = false;
-		foreach(tl, tlist)
-		{
-			TargetEntry *tle = (TargetEntry *) lfirst(tl);
-
-			if (tle->resjunk)
-				continue;		/* ignore junk items */
-
-			if (tle->resno == attrno)
-				new_tlist = lappend(new_tlist, tle);
-			else if (tle->resno > attrno)
-				more = true;
-		}
-	}
-
-	foreach(tl, tlist)
-	{
-		TargetEntry *tle = (TargetEntry *) lfirst(tl);
-
-		if (!tle->resjunk)
-			continue;			/* here, ignore non-junk items */
-
-		tle->resno = attrno;
-		new_tlist = lappend(new_tlist, tle);
-		attrno++;
-	}
-
-	return new_tlist;
-}
-
-/*
- * adjust_appendrel_attrs_multilevel
- *	  Apply Var translations from a toplevel appendrel parent down to a child.
- *
- * In some cases we need to translate expressions referencing a parent relation
- * to reference an appendrel child that's multiple levels removed from it.
- */
-Node *
-adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node,
-								  Relids child_relids,
-								  Relids top_parent_relids)
-{
-	AppendRelInfo **appinfos;
-	Bitmapset  *parent_relids = NULL;
-	int			nappinfos;
-	int			cnt;
-
-	Assert(bms_num_members(child_relids) == bms_num_members(top_parent_relids));
-
-	appinfos = find_appinfos_by_relids(root, child_relids, &nappinfos);
-
-	/* Construct relids set for the immediate parent of given child. */
-	for (cnt = 0; cnt < nappinfos; cnt++)
-	{
-		AppendRelInfo *appinfo = appinfos[cnt];
-
-		parent_relids = bms_add_member(parent_relids, appinfo->parent_relid);
-	}
-
-	/* Recurse if immediate parent is not the top parent. */
-	if (!bms_equal(parent_relids, top_parent_relids))
-		node = adjust_appendrel_attrs_multilevel(root, node, parent_relids,
-												 top_parent_relids);
-
-	/* Now translate for this child */
-	node = adjust_appendrel_attrs(root, node, nappinfos, appinfos);
-
-	pfree(appinfos);
-
-	return node;
-}
-
-/*
- * Construct the SpecialJoinInfo for a child-join by translating
- * SpecialJoinInfo for the join between parents. left_relids and right_relids
- * are the relids of left and right side of the join respectively.
- */
-SpecialJoinInfo *
-build_child_join_sjinfo(PlannerInfo *root, SpecialJoinInfo *parent_sjinfo,
-						Relids left_relids, Relids right_relids)
-{
-	SpecialJoinInfo *sjinfo = makeNode(SpecialJoinInfo);
-	AppendRelInfo **left_appinfos;
-	int			left_nappinfos;
-	AppendRelInfo **right_appinfos;
-	int			right_nappinfos;
-
-	memcpy(sjinfo, parent_sjinfo, sizeof(SpecialJoinInfo));
-	left_appinfos = find_appinfos_by_relids(root, left_relids,
-											&left_nappinfos);
-	right_appinfos = find_appinfos_by_relids(root, right_relids,
-											 &right_nappinfos);
-
-	sjinfo->min_lefthand = adjust_child_relids(sjinfo->min_lefthand,
-											   left_nappinfos, left_appinfos);
-	sjinfo->min_righthand = adjust_child_relids(sjinfo->min_righthand,
-												right_nappinfos,
-												right_appinfos);
-	sjinfo->syn_lefthand = adjust_child_relids(sjinfo->syn_lefthand,
-											   left_nappinfos, left_appinfos);
-	sjinfo->syn_righthand = adjust_child_relids(sjinfo->syn_righthand,
-												right_nappinfos,
-												right_appinfos);
-	sjinfo->semi_rhs_exprs = (List *) adjust_appendrel_attrs(root,
-															 (Node *) sjinfo->semi_rhs_exprs,
-															 right_nappinfos,
-															 right_appinfos);
-
-	pfree(left_appinfos);
-	pfree(right_appinfos);
-
-	return sjinfo;
-}
-
-/*
- * find_appinfos_by_relids
- * 		Find AppendRelInfo structures for all relations specified by relids.
- *
- * The AppendRelInfos are returned in an array, which can be pfree'd by the
- * caller. *nappinfos is set to the number of entries in the array.
- */
-AppendRelInfo **
-find_appinfos_by_relids(PlannerInfo *root, Relids relids, int *nappinfos)
-{
-	AppendRelInfo **appinfos;
-	int			cnt = 0;
-	int			i;
-
-	*nappinfos = bms_num_members(relids);
-	appinfos = (AppendRelInfo **) palloc(sizeof(AppendRelInfo *) * *nappinfos);
-
-	i = -1;
-	while ((i = bms_next_member(relids, i)) >= 0)
-	{
-		AppendRelInfo *appinfo = root->append_rel_array[i];
-
-		if (!appinfo)
-			elog(ERROR, "child rel %d not found in append_rel_array", i);
-
-		appinfos[cnt++] = appinfo;
-	}
-	return appinfos;
-}
diff --git a/src/backend/optimizer/util/Makefile b/src/backend/optimizer/util/Makefile
index c54d0a690d..d166030a10 100644
--- a/src/backend/optimizer/util/Makefile
+++ b/src/backend/optimizer/util/Makefile
@@ -12,7 +12,8 @@ subdir = src/backend/optimizer/util
 top_builddir = ../../../..
 include $(top_builddir)/src/Makefile.global
 
-OBJS = clauses.o joininfo.o orclauses.o pathnode.o placeholder.o \
-       plancat.o predtest.o relnode.o restrictinfo.o tlist.o var.o
+OBJS = append.o appendinfo.o clauses.o joininfo.o orclauses.o pathnode.o \
+	   placeholder.o plancat.o predtest.o relnode.o restrictinfo.o tlist.o \
+	   var.o
 
 include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/optimizer/util/append.c b/src/backend/optimizer/util/append.c
new file mode 100644
index 0000000000..76d9246d5f
--- /dev/null
+++ b/src/backend/optimizer/util/append.c
@@ -0,0 +1,679 @@
+/*-------------------------------------------------------------------------
+ *
+ * append.c
+ *	  Routines to process children of an appendrel parent
+ *
+ * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/optimizer/path/append.c
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include <limits.h>
+
+#include "access/sysattr.h"
+#include "catalog/partition.h"
+#include "catalog/pg_class.h"
+#include "catalog/pg_inherits.h"
+#include "catalog/pg_type.h"
+#include "nodes/makefuncs.h"
+#include "optimizer/append.h"
+#include "optimizer/appendinfo.h"
+#include "optimizer/clauses.h"
+#include "optimizer/pathnode.h"
+#include "optimizer/paths.h"
+#include "optimizer/plancat.h"
+#include "optimizer/planmain.h"
+#include "optimizer/planner.h"
+#include "optimizer/prep.h"
+#include "optimizer/restrictinfo.h"
+#include "optimizer/tlist.h"
+#include "optimizer/var.h"
+#include "partitioning/partprune.h"
+#include "utils/rel.h"
+
+static RelOptInfo *add_inheritance_child_rel(PlannerInfo *root,
+						  RelOptInfo *rel,
+						  RangeTblEntry *rte,
+						  Oid childOID,
+						  LOCKMODE lockmode,
+						  PlanRowMark *top_parentrc);
+static RelOptInfo *build_append_child_rel(PlannerInfo *root,
+					   RelOptInfo *parent,
+					   Index childRTindex);
+static List *add_rowmark_junk_columns(PlannerInfo *root, PlanRowMark *rc);
+
+/*
+ * expand_append_rel
+ *		This initializes RelOptInfos for an appendrel's child relations.
+ *
+ * 'rel' is the appendrel parent, whose range table entry ('rte') has been
+ * marked to require adding children.  An appendrel parent could either
+ * be a subquery (if we flattened UNION ALL query) or a table that's known
+ * to have inheritance children.  The latter consists of both regular
+ * inheritance parents and partitioned tables.
+ *
+ * For a subquery parent, there is not much to be done here because the
+ * children's RTEs are already present in the query, so we just initialize
+ * RelOptInfos for them.  Also, the AppendRelInfos for child subqueries
+ * have already been added.
+ *
+ * For tables, we need to add the children to the range table and initialize
+ * AppendRelInfos, RelOptInfos, and PlanRowMarks (if any) for them.  For
+ * a partitioned parent, we only add the children remaining after pruning.
+ * For regular inheritance parents, we find the children using
+ * find_all_inheritors and add all of them.
+ *
+ * If it turns out that there are no children, then we set rte->inh to false
+ * to let the caller know that only the parent table needs to be scanned.  The
+ * caller can accordingly switch to a non-Append path.  For a partitioned
+ * parent, that means an empty relation because parents themselves contain no
+ * data.
+ *
+ * For the regular inheritance case, the parent also gets another RTE with
+ * inh = false to represent it as an appendrel child.  The original RTE is
+ * considered to represent the whole inheritance set.
+ */
+void
+expand_append_rel(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte,
+				  Index rti)
+{
+	LOCKMODE	lockmode;
+	ListCell   *l;
+
+	Assert(rte->inh);
+	/* Inheritance parent (partitioned or not) or UNION ALL parent subquery. */
+	Assert(rte->rtekind == RTE_RELATION || rte->rtekind == RTE_SUBQUERY);
+
+	/*
+	 * The rewriter should already have obtained an appropriate lock on
+	 * each relation named in the query.  However, for each child relation
+	 * we add to the query, we must obtain an appropriate lock, because
+	 * this will be the first use of those relations in the
+	 * parse/rewrite/plan pipeline.  Child rels should use the same
+	 * lockmode as their parent.
+	 */
+	if (rte->rtekind == RTE_RELATION)
+	{
+		lockmode = rte->rellockmode;
+		Assert(has_subclass(rte->relid));
+	}
+
+	/*
+	 * UNION ALL children already got RTEs and AppendRelInfos, so just build
+	 * RelOptInfos and return.
+	 *
+	 * It might be a bit odd that this code is in this, because there is
+	 * nothing to expand really.
+	 */
+	if (rte->rtekind == RTE_SUBQUERY)
+	{
+		/*
+		 * We don't need to use expand_planner_arrays in this case, because
+		 * no new child RTEs are created.  setup_simple_rel_arrays() and
+		 * setup_append_rel_array would've considered these child RTEs when
+		 * allocating space for various arrays.
+		 */
+		foreach(l, root->append_rel_list)
+		{
+			AppendRelInfo *appinfo = lfirst(l);
+			Index		childRTindex = appinfo->child_relid;
+
+			if (appinfo->parent_relid != rti)
+				continue;
+
+			Assert(childRTindex < root->simple_rel_array_size);
+			Assert(root->simple_rte_array[childRTindex] != NULL);
+
+			/*
+			 * We set the correct value of baserestricinfo and
+			 * baserestrict_min_security below.
+			 */
+			root->simple_rel_array[childRTindex] =
+				build_append_child_rel(root, rel, appinfo->child_relid);
+		}
+	}
+	else if (rte->relkind == RELKIND_PARTITIONED_TABLE)
+	{
+		Index		root_parent = rel->inh_root_parent > 0 ?
+								  rel->inh_root_parent :
+								  rel->relid;
+		PlanRowMark *rootrc = NULL;
+		int			i;
+		Bitmapset  *partindexes;
+
+		Assert(rte->rtekind == RTE_RELATION);
+		Assert(lockmode != NoLock);
+
+		/* If root partitioned table, lock *all* partitions in the tree. */
+		if (rel->relid == root_parent)
+			(void) find_all_inheritors(rte->relid, lockmode, NULL);
+
+		/*
+		 * Initialize partitioned_child_rels to contain this RT index.
+		 *
+		 * Note that during the set_append_rel_pathlist() phase, we will bubble
+		 * up the indexes of partitioned relations that appear down in the
+		 * tree, so that when we've created Paths for all the children, the
+		 * root partitioned table's list will contain all such indexes.
+		 */
+		rel->partitioned_child_rels = list_make1_int(rti);
+
+		/* Perform pruning. */
+		partindexes = prune_append_rel_partitions(rel);
+
+		/* Must expand PlannerInfo arrays before we can add children. */
+		expand_planner_arrays(root, bms_num_members(partindexes));
+
+		/*
+		 * For partitioned tables, we also store the partition RelOptInfo
+		 * pointers in the parent's RelOptInfo.
+		 */
+		rel->part_rels = (RelOptInfo **) palloc0(sizeof(RelOptInfo *) *
+												 rel->nparts);
+
+		rootrc = get_plan_rowmark(root->rowMarks, root_parent);
+		Assert(rootrc == NULL || rootrc->isParent);
+
+		i = -1;
+		while ((i = bms_next_member(partindexes, i)) >= 0)
+		{
+			Oid		childOID = rel->part_oids[i];
+			RelOptInfo *childrel;
+
+			/* Already locked, so pass NoLock. */
+			childrel = add_inheritance_child_rel(root, rel, rte,
+												 childOID,
+												 NoLock,
+												 rootrc);
+			rel->part_rels[i] = childrel;
+		}
+
+		/*
+		 * Add junk columns needed by the row mark if any and also add the
+		 * relevant expressions to the root parent's reltarget.
+		 */
+		if (rootrc)
+		{
+			List   *tlist = add_rowmark_junk_columns(root, rootrc);
+
+			build_base_rel_tlists(root, tlist);
+		}
+
+	}
+	else
+	{
+		/*
+		 * Regular inheritance case, where each child must be opened and
+		 * checked if it can be excluded.
+		 */
+		PlanRowMark *oldrc;
+		List	   *inhOIDs;
+		int			num_children;
+		int			num_children_added = 0;
+
+		Assert(rte->rtekind == RTE_RELATION);
+		Assert(lockmode != NoLock);
+
+		/* Scan for all members of inheritance set, acquire needed locks */
+		inhOIDs = find_all_inheritors(rte->relid, lockmode, NULL);
+		num_children = list_length(inhOIDs);
+
+		/*
+		 * Check that there's at least one descendant, else treat as no-child
+		 * case.  This could happen despite the has_subclass() check passing,
+		 * if table once had a child but no longer does (relhassubclass is
+		 * only opportunistically reset).
+		 */
+		if (num_children < 2)
+		{
+			/* Clear flag before returning */
+			rte->inh = false;
+			return;
+		}
+
+		/*
+		 * If parent relation is selected FOR UPDATE/SHARE, we need to mark
+		 * its PlanRowMark as isParent = true, and generate a new PlanRowMark
+		 * for each child.
+		 */
+		oldrc = get_plan_rowmark(root->rowMarks, rti);
+		Assert(oldrc == NULL || oldrc->isParent);
+
+		/*
+		 * Must expand PlannerInfo arrays by num_children before we can add
+		 * children.
+		 */
+		expand_planner_arrays(root, num_children);
+
+		foreach(l, inhOIDs)
+		{
+			Oid			childOID = lfirst_oid(l);
+
+			/*
+			 * We pass NoLock here, because find_all_inheritors already got
+			 * the lock.
+			 */
+			if (add_inheritance_child_rel(root, rel, rte, childOID, NoLock,
+										  oldrc) != NULL)
+				num_children_added++;
+		}
+
+		/*
+		 * If all children, including the parent (as child rel), were
+		 * excluded, mark the parent rel as empty.
+		 */
+		if (num_children_added == 0)
+			mark_dummy_rel(rel);
+		/*
+		 * If all the children were temp tables, pretend it's a
+		 * non-inheritance situation; we don't need Append node in that case.
+		 * The duplicate RTE we added for the parent table is harmless, so we
+		 * don't bother to get rid of it; ditto for the useless PlanRowMark
+		 * node.
+		 */
+		else if (num_children_added == 1)
+			rte->inh = false;
+
+		/*
+		 * Add junk columns needed by the row mark if any and also add the
+		 * relevant expressions to the root parent's reltarget.
+		 */
+		if (oldrc)
+		{
+			List   *tlist = add_rowmark_junk_columns(root, oldrc);
+
+			build_base_rel_tlists(root, tlist);
+		}
+	}
+}
+
+/*
+ * add_inheritance_child_rel
+ *		This conditionally adds various objects needed for planning an
+ *		inheritance child table
+ *
+ * The added objects include a RangeTblEntry, an AppendRelInfo, a PlanRowMark,
+ * and finally a RelOptInfo.  Return value is the RelOptInfo if one is added,
+ * NULL otherwise.
+ *
+ * If the child is a partitioned table with 0 partitions or if it's a
+ * temporary table from another session, we cannot get any data from it,
+ * so we don't add anything in that case.
+ */
+static RelOptInfo *
+add_inheritance_child_rel(PlannerInfo *root,
+						  RelOptInfo *parent,
+						  RangeTblEntry *rte,
+						  Oid childOID,
+						  LOCKMODE lockmode,
+						  PlanRowMark *top_parentrc)
+{
+	Query	   *parse = root->parse;
+	Relation	childrel;
+	Index		childRTindex;
+	RangeTblEntry *childrte;
+	AppendRelInfo *appinfo;
+	RelOptInfo *childrelopt;
+
+	childrel = heap_open(childOID, lockmode);
+
+	/*
+	 * A partitioned child table with 0 children is a dummy rel, so don't
+	 * bother creating planner objects for it.
+	 */
+	if (childrel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
+	{
+		PartitionDesc partdesc = RelationGetPartitionDesc(childrel);
+
+		Assert(!RELATION_IS_OTHER_TEMP(childrel));
+		if (partdesc->nparts == 0)
+		{
+			heap_close(childrel, NoLock);
+			return NULL;
+		}
+	}
+
+	/*
+	 * If childrel doesn't belong to this session, skip it, also relinquishing
+	 * the lock.
+	 */
+	if (RELATION_IS_OTHER_TEMP(childrel))
+	{
+		heap_close(childrel, lockmode);
+		return NULL;
+	}
+
+	/*
+	 * Build an RTE for the child, and attach to query's rangetable list. We
+	 * copy most fields of the parent's RTE, but replace relation OID and
+	 * relkind, and set inh appropriately.  Also, set requiredPerms to zero
+	 * since all required permissions checks are done on the original RTE.
+	 * Likewise, set the child's securityQuals to empty, because we only want
+	 * to apply the parent's RLS conditions regardless of what RLS properties
+	 * individual children may have.  (This is an intentional choice to make
+	 * inherited RLS work like regular permissions checks.) The parent
+	 * securityQuals will be propagated to children along with other base
+	 * restriction clauses, so we don't need to do it here.
+	 */
+	childrte = copyObject(rte);
+	childrte->relid = RelationGetRelid(childrel);
+	childrte->relkind = RelationGetForm(childrel)->relkind;
+	/*
+	 * A partitioned child will need to be expanded as an append parent
+	 * itself, so set its inh to true.
+	 */
+	childrte->inh = (childrte->relkind == RELKIND_PARTITIONED_TABLE);
+	childrte->requiredPerms = 0;
+	childrte->securityQuals = NIL;
+	parse->rtable = lappend(parse->rtable, childrte);
+	childRTindex = list_length(parse->rtable);
+
+	/* Create an AppendRelInfo and add it to planner's global list. */
+	appinfo = make_append_rel_info(parent, rte,
+								   RelationGetDescr(childrel),
+								   RelationGetRelid(childrel),
+								   RelationGetForm(childrel)->reltype,
+								   childRTindex);
+	root->append_rel_list = lappend(root->append_rel_list, appinfo);
+
+	/* Close the child relation, but keep the lock. */
+	heap_close(childrel, NoLock);
+
+	/*
+	 * Translate the column permissions bitmaps to the child's attnums (we
+	 * have to build the translated_vars list before we can do this). But
+	 * if this is the parent table, leave copyObject's result alone.
+	 *
+	 * Note: we need to do this even though the executor won't run any
+	 * permissions checks on the child RTE.  The insertedCols/updatedCols
+	 * bitmaps may be examined for trigger-firing purposes.
+	 */
+	if (childrte->relid != rte->relid)
+	{
+		childrte->selectedCols = translate_col_privs(rte->selectedCols,
+													 appinfo->translated_vars);
+		childrte->insertedCols = translate_col_privs(rte->insertedCols,
+													 appinfo->translated_vars);
+		childrte->updatedCols = translate_col_privs(rte->updatedCols,
+													appinfo->translated_vars);
+	}
+
+	/* Add child PlanRowMark. */
+	if (top_parentrc)
+	{
+		PlanRowMark *childrc = makeNode(PlanRowMark);
+
+		childrc->rti = list_length(parse->rtable);
+		childrc->prti = top_parentrc->rti;
+		childrc->rowmarkId = top_parentrc->rowmarkId;
+		/* Reselect rowmark type, because relkind might not match parent */
+		childrc->markType = select_rowmark_type(childrte, top_parentrc->strength);
+		childrc->allMarkTypes = (1 << childrc->markType);
+		childrc->strength = top_parentrc->strength;
+		childrc->waitPolicy = top_parentrc->waitPolicy;
+
+		/*
+		 * We mark RowMarks for partitioned child tables as parent RowMarks so
+		 * that the executor ignores them (except their existence means that
+		 * the child tables be locked using appropriate mode).
+		 */
+		childrc->isParent = (childrte->relkind == RELKIND_PARTITIONED_TABLE);
+
+		/* Include child's rowmark type in top parent's allMarkTypes */
+		top_parentrc->allMarkTypes |= childrc->allMarkTypes;
+		root->rowMarks = lappend(root->rowMarks, childrc);
+	}
+
+	/*
+	 * Add the RelOptInfo.  Even though we may not really scan this relation
+	 * for reasons such as contradictory quals, we still need need to create
+	 * one, because for every RTE in the query's range table, there must be an
+	 * accompanying RelOptInfo.
+	 */
+
+	/* First, store the RTE and appinfos into planner arrays. */
+	Assert(root->simple_rte_array[childRTindex] == NULL);
+	root->simple_rte_array[childRTindex] = childrte;
+	Assert(root->append_rel_array[childRTindex] == NULL);
+	root->append_rel_array[childRTindex] = appinfo;
+
+	childrelopt = build_append_child_rel(root, parent, childRTindex);
+	Assert(childrelopt != NULL);
+
+	return childrelopt;
+}
+
+/*
+ *	build_append_child_rel
+ *		Build a RelOptInfo for child relation of an append rel
+ *
+ * After creating the RelOptInfo for the given child RT index, it goes on to
+ * initialize some of its fields base on the parent RelOptInfo.
+ *
+ * If the quals in baserestrictinfo turns out to be self-contradictory, the
+ * RelOptInfo is marked dummy before returning.
+ */
+static RelOptInfo *
+build_append_child_rel(PlannerInfo *root,
+					   RelOptInfo *parent,
+					   Index childRTindex)
+{
+	RelOptInfo *childrel;
+	RangeTblEntry *childRTE = root->simple_rte_array[childRTindex];
+	AppendRelInfo *appinfo = root->append_rel_array[childRTindex];
+	List	   *childquals;
+	ListCell   *lc;
+	bool		have_const_false_cq;
+	Index		cq_min_security;
+
+	/* Build the RelOptInfo. */
+	childrel = build_simple_rel(root, childRTindex, parent);
+
+	/*
+	 * Propagate lateral_relids and lateral_referencers from appendrel
+	 * parent rels to their child rels.  We intentionally give each child rel
+	 * the same minimum parameterization, even though it's quite possible that
+	 * some don't reference all the lateral rels.  This is because any append
+	 * path for the parent will have to have the same parameterization for
+	 * every child anyway, and there's no value in forcing extra
+	 * reparameterize_path() calls.  Similarly, a lateral reference to the
+	 * parent prevents use of otherwise-movable join rels for each child.
+	 */
+	childrel->direct_lateral_relids = parent->direct_lateral_relids;
+	childrel->lateral_relids = parent->lateral_relids;
+	childrel->lateral_referencers = parent->lateral_referencers;
+
+	/*
+	 * We have to copy the parent's quals to the child, with appropriate
+	 * substitution of variables.  However, only the baserestrictinfo
+	 * quals are needed before we can check for constraint exclusion; so
+	 * do that first and then check to see if we can disregard this child.
+	 *
+	 * The child rel's targetlist might contain non-Var expressions, which
+	 * means that substitution into the quals could produce opportunities
+	 * for const-simplification, and perhaps even pseudoconstant quals.
+	 * Therefore, transform each RestrictInfo separately to see if it
+	 * reduces to a constant or pseudoconstant.  (We must process them
+	 * separately to keep track of the security level of each qual.)
+	 */
+	childquals = false;
+	cq_min_security = UINT_MAX;
+	have_const_false_cq = false;
+	foreach(lc, parent->baserestrictinfo)
+	{
+		RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
+		Node	   *childqual = (Node *) rinfo->clause;
+		ListCell   *lc2;
+
+		Assert(IsA(rinfo, RestrictInfo));
+		childqual = adjust_appendrel_attrs(root, childqual,
+										   1, &appinfo);
+		childqual = eval_const_expressions(root, childqual);
+		/* check for flat-out constant */
+		if (childqual && IsA(childqual, Const))
+		{
+			if (((Const *) childqual)->constisnull ||
+				!DatumGetBool(((Const *) childqual)->constvalue))
+			{
+				/* Restriction reduces to constant FALSE or NULL */
+				have_const_false_cq = true;
+				break;
+			}
+			/* Restriction reduces to constant TRUE, so drop it */
+			continue;
+		}
+		/* might have gotten an AND clause, if so flatten it */
+		foreach(lc2, make_ands_implicit((Expr *) childqual))
+		{
+			Node	   *onecq = (Node *) lfirst(lc2);
+			bool		pseudoconstant;
+
+			/* check for pseudoconstant (no Vars or volatile functions) */
+			pseudoconstant =
+					!contain_vars_of_level(onecq, 0) &&
+					!contain_volatile_functions(onecq);
+			if (pseudoconstant)
+			{
+				/* tell createplan.c to check for gating quals */
+				root->hasPseudoConstantQuals = true;
+			}
+			/* reconstitute RestrictInfo with appropriate properties */
+			childquals = lappend(childquals,
+								 make_restrictinfo((Expr *) onecq,
+												   rinfo->is_pushed_down,
+												   rinfo->outerjoin_delayed,
+												   pseudoconstant,
+												   rinfo->security_level,
+												   NULL, NULL, NULL));
+			cq_min_security = Min(cq_min_security, rinfo->security_level);
+		}
+	}
+
+	/*
+	 * In addition to the quals inherited from the parent, we might
+	 * have securityQuals associated with this particular child node.
+	 * (Currently this can only happen in appendrels originating from
+	 * UNION ALL; inheritance child tables don't have their own
+	 * securityQuals.)	Pull any such securityQuals up into the
+	 * baserestrictinfo for the child.  This is similar to
+	 * process_security_barrier_quals() for the parent rel, except
+	 * that we can't make any general deductions from such quals,
+	 * since they don't hold for the whole appendrel.
+	 */
+	if (childRTE->securityQuals)
+	{
+		Index		security_level = 0;
+
+		foreach(lc, childRTE->securityQuals)
+		{
+			List	   *qualset = (List *) lfirst(lc);
+			ListCell   *lc2;
+
+			foreach(lc2, qualset)
+			{
+				Expr	   *qual = (Expr *) lfirst(lc2);
+
+				/*
+				 * not likely that we'd see constants here, so no
+				 * check
+				 */
+				childquals = lappend(childquals,
+									 make_restrictinfo(qual,
+													   true,
+													   false,
+													   false,
+													   security_level,
+													   NULL, NULL,
+													   NULL));
+				cq_min_security = Min(cq_min_security, security_level);
+			}
+			security_level++;
+		}
+		Assert(security_level <= root->qual_security_level);
+	}
+
+	/* Set child's version of baserestrictinfo. */
+	childrel->baserestrictinfo = childquals;
+	childrel->baserestrict_min_security = cq_min_security;
+
+	if (have_const_false_cq)
+	{
+		/*
+		 * Some restriction clause reduced to constant FALSE or NULL after
+		 * substitution, so this child need not be scanned.
+		 */
+		set_dummy_rel_pathlist(childrel);
+	}
+
+	return childrel;
+}
+
+/*
+ * add_rowmark_junk_columns
+ * 		Add necessary junk columns for rowmarked inheritance parent rel.
+ *
+ * These values are needed for locking of rels selected FOR UPDATE/SHARE, and
+ * to do EvalPlanQual rechecking.  See comments for PlanRowMark in
+ * plannodes.h.
+ */
+static List *
+add_rowmark_junk_columns(PlannerInfo *root, PlanRowMark *rc)
+{
+	List   *tlist = root->processed_tlist;
+	Var		   *var;
+	char		resname[32];
+	TargetEntry *tle;
+
+	if (rc->allMarkTypes & ~(1 << ROW_MARK_COPY))
+	{
+		/* Need to fetch TID */
+		var = makeVar(rc->rti,
+					  SelfItemPointerAttributeNumber,
+					  TIDOID,
+					  -1,
+					  InvalidOid,
+					  0);
+		snprintf(resname, sizeof(resname), "ctid%u", rc->rowmarkId);
+		tle = makeTargetEntry((Expr *) var,
+							  list_length(tlist) + 1,
+							  pstrdup(resname),
+							  true);
+		tlist = lappend(tlist, tle);
+	}
+	if (rc->allMarkTypes & (1 << ROW_MARK_COPY))
+	{
+		/* Need the whole row as a junk var */
+		var = makeWholeRowVar(root->simple_rte_array[rc->rti],
+							  rc->rti,
+							  0,
+							  false);
+		snprintf(resname, sizeof(resname), "wholerow%u", rc->rowmarkId);
+		tle = makeTargetEntry((Expr *) var,
+							  list_length(tlist) + 1,
+							  pstrdup(resname),
+							  true);
+		tlist = lappend(tlist, tle);
+	}
+
+	/* For inheritance cases, always fetch the tableoid too. */
+	var = makeVar(rc->rti,
+				  TableOidAttributeNumber,
+				  OIDOID,
+				  -1,
+				  InvalidOid,
+				  0);
+	snprintf(resname, sizeof(resname), "tableoid%u", rc->rowmarkId);
+	tle = makeTargetEntry((Expr *) var,
+						  list_length(tlist) + 1,
+						  pstrdup(resname),
+						  true);
+	tlist = lappend(tlist, tle);
+
+	return tlist;
+}
diff --git a/src/backend/optimizer/util/appendinfo.c b/src/backend/optimizer/util/appendinfo.c
new file mode 100644
index 0000000000..24d1e15cf9
--- /dev/null
+++ b/src/backend/optimizer/util/appendinfo.c
@@ -0,0 +1,851 @@
+/*-------------------------------------------------------------------------
+ *
+ * appendinfo.c
+ *	  Routines for mapping between append parent(s) and children
+ *
+ * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/optimizer/path/appendinfo.c
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include "access/htup_details.h"
+#include "access/sysattr.h"
+#include "nodes/makefuncs.h"
+#include "nodes/nodeFuncs.h"
+#include "optimizer/appendinfo.h"
+#include "parser/parsetree.h"
+#include "utils/rel.h"
+#include "utils/lsyscache.h"
+#include "utils/syscache.h"
+
+typedef struct
+{
+	PlannerInfo *root;
+	int			nappinfos;
+	AppendRelInfo **appinfos;
+} adjust_appendrel_attrs_context;
+
+static void make_inh_translation_list(TupleDesc old_tupdesc,
+						  TupleDesc new_tupdesc,
+						  Oid from_rel, Oid to_rel,
+						  Index newvarno, List **translated_vars);
+static Node *adjust_appendrel_attrs_mutator(Node *node,
+							   adjust_appendrel_attrs_context *context);
+static Relids adjust_child_relids(Relids relids, int nappinfos,
+					AppendRelInfo **appinfos);
+static List *adjust_inherited_tlist(List *tlist,
+					   AppendRelInfo *context);
+
+AppendRelInfo *
+make_append_rel_info(RelOptInfo *parentrel, RangeTblEntry *parentrte,
+					 TupleDesc childdesc, Oid childoid, Oid childreltype,
+					 Index childRTindex)
+{
+	AppendRelInfo  *appinfo = makeNode(AppendRelInfo);
+
+	appinfo->parent_relid = parentrel->relid;
+	appinfo->child_relid = childRTindex;
+	appinfo->parent_reltype = parentrel->reltype;
+	appinfo->child_reltype = childreltype;
+	make_inh_translation_list(parentrel->tupdesc, childdesc,
+							  parentrte->relid, childoid,
+							  childRTindex,
+							  &appinfo->translated_vars);
+	appinfo->parent_reloid = parentrte->relid;
+
+	return appinfo;
+}
+
+/*
+ * translate_col_privs
+ *	  Translate a bitmapset representing per-column privileges from the
+ *	  parent rel's attribute numbering to the child's.
+ *
+ * The only surprise here is that we don't translate a parent whole-row
+ * reference into a child whole-row reference.  That would mean requiring
+ * permissions on all child columns, which is overly strict, since the
+ * query is really only going to reference the inherited columns.  Instead
+ * we set the per-column bits for all inherited columns.
+ */
+Bitmapset *
+translate_col_privs(const Bitmapset *parent_privs,
+					List *translated_vars)
+{
+	Bitmapset  *child_privs = NULL;
+	bool		whole_row;
+	int			attno;
+	ListCell   *lc;
+
+	/* System attributes have the same numbers in all tables */
+	for (attno = FirstLowInvalidHeapAttributeNumber + 1; attno < 0; attno++)
+	{
+		if (bms_is_member(attno - FirstLowInvalidHeapAttributeNumber,
+						  parent_privs))
+			child_privs = bms_add_member(child_privs,
+										 attno - FirstLowInvalidHeapAttributeNumber);
+	}
+
+	/* Check if parent has whole-row reference */
+	whole_row = bms_is_member(InvalidAttrNumber - FirstLowInvalidHeapAttributeNumber,
+							  parent_privs);
+
+	/* And now translate the regular user attributes, using the vars list */
+	attno = InvalidAttrNumber;
+	foreach(lc, translated_vars)
+	{
+		Var		   *var = lfirst_node(Var, lc);
+
+		attno++;
+		if (var == NULL)		/* ignore dropped columns */
+			continue;
+		if (whole_row ||
+			bms_is_member(attno - FirstLowInvalidHeapAttributeNumber,
+						  parent_privs))
+			child_privs = bms_add_member(child_privs,
+										 var->varattno - FirstLowInvalidHeapAttributeNumber);
+	}
+
+	return child_privs;
+}
+
+/*
+ * adjust_appendrel_attrs
+ *	  Copy the specified query or expression and translate Vars referring to a
+ *	  parent rel to refer to the corresponding child rel instead.  We also
+ *	  update rtindexes appearing outside Vars, such as resultRelation and
+ *	  jointree relids.
+ *
+ * Note: this is only applied after conversion of sublinks to subplans,
+ * so we don't need to cope with recursion into sub-queries.
+ *
+ * Note: this is not hugely different from what pullup_replace_vars() does;
+ * maybe we should try to fold the two routines together.
+ */
+Node *
+adjust_appendrel_attrs(PlannerInfo *root, Node *node, int nappinfos,
+					   AppendRelInfo **appinfos)
+{
+	Node	   *result;
+	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);
+
+	/*
+	 * Must be prepared to start with a Query or a bare expression tree.
+	 */
+	if (node && IsA(node, Query))
+	{
+		Query	   *newnode;
+		int			cnt;
+
+		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;
+}
+
+static Node *
+adjust_appendrel_attrs_mutator(Node *node,
+							   adjust_appendrel_attrs_context *context)
+{
+	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;
+
+		for (cnt = 0; cnt < nappinfos; cnt++)
+		{
+			if (var->varno == appinfos[cnt]->parent_relid)
+			{
+				appinfo = appinfos[cnt];
+				break;
+			}
+		}
+
+		if (var->varlevelsup == 0 && appinfo)
+		{
+			var->varno = appinfo->child_relid;
+			var->varnoold = appinfo->child_relid;
+			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));
+				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;
+
+					return (Node *) rowexpr;
+				}
+			}
+			/* system attributes don't need any other translation */
+		}
+		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, 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 */
+		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, context->nappinfos,
+											  context->appinfos);
+		return (Node *) phv;
+	}
+
+	/*
+	 * This is needed, because inheritance_make_rel_from_joinlist needs to
+	 * translate root->join_info_list executing make_rel_from_joinlist for a
+	 * given child.
+	 */
+	if (IsA(node, SpecialJoinInfo))
+	{
+		SpecialJoinInfo *oldinfo = (SpecialJoinInfo *) node;
+		SpecialJoinInfo *newinfo = makeNode(SpecialJoinInfo);
+
+		memcpy(newinfo, oldinfo, sizeof(SpecialJoinInfo));
+		newinfo->min_lefthand = adjust_child_relids(oldinfo->min_lefthand,
+													context->nappinfos,
+													context->appinfos);
+		newinfo->min_righthand = adjust_child_relids(oldinfo->min_righthand,
+													 context->nappinfos,
+													 context->appinfos);
+		newinfo->syn_lefthand = adjust_child_relids(oldinfo->syn_lefthand,
+													context->nappinfos,
+													context->appinfos);
+		newinfo->syn_righthand = adjust_child_relids(oldinfo->syn_righthand,
+													 context->nappinfos,
+													 context->appinfos);
+		newinfo->semi_rhs_exprs =
+					(List *) expression_tree_mutator((Node *)
+													 oldinfo->semi_rhs_exprs,
+													 adjust_appendrel_attrs_mutator,
+													 (void *) context);
+		return (Node *) newinfo;
+	}
+
+	/* Shouldn't need to handle planner auxiliary nodes here */
+	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 */
+		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->nullable_relids = adjust_child_relids(oldinfo->nullable_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));
+
+	return expression_tree_mutator(node, adjust_appendrel_attrs_mutator,
+								   (void *) context);
+}
+
+/*
+ * Substitute child relids for parent relids in a Relid set.  The array of
+ * appinfos specifies the substitutions to be performed.
+ */
+static Relids
+adjust_child_relids(Relids relids, int nappinfos, AppendRelInfo **appinfos)
+{
+	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;
+}
+
+/*
+ * Replace any relid present in top_parent_relids with its child in
+ * child_relids. Members of child_relids can be multiple levels below top
+ * parent in the partition hierarchy.
+ */
+Relids
+adjust_child_relids_multilevel(PlannerInfo *root, Relids relids,
+							   Relids child_relids, Relids top_parent_relids)
+{
+	AppendRelInfo **appinfos;
+	int			nappinfos;
+	Relids		parent_relids = NULL;
+	Relids		result;
+	Relids		tmp_result = NULL;
+	int			cnt;
+
+	/*
+	 * If the given relids set doesn't contain any of the top parent relids,
+	 * it will remain unchanged.
+	 */
+	if (!bms_overlap(relids, top_parent_relids))
+		return relids;
+
+	appinfos = find_appinfos_by_relids(root, child_relids, &nappinfos);
+
+	/* Construct relids set for the immediate parent of the given child. */
+	for (cnt = 0; cnt < nappinfos; cnt++)
+	{
+		AppendRelInfo *appinfo = appinfos[cnt];
+
+		parent_relids = bms_add_member(parent_relids, appinfo->parent_relid);
+	}
+
+	/* Recurse if immediate parent is not the top parent. */
+	if (!bms_equal(parent_relids, top_parent_relids))
+	{
+		tmp_result = adjust_child_relids_multilevel(root, relids,
+													parent_relids,
+													top_parent_relids);
+		relids = tmp_result;
+	}
+
+	result = adjust_child_relids(relids, nappinfos, appinfos);
+
+	/* Free memory consumed by any intermediate result. */
+	if (tmp_result)
+		bms_free(tmp_result);
+	bms_free(parent_relids);
+	pfree(appinfos);
+
+	return result;
+}
+
+/*
+ * adjust_appendrel_attrs_multilevel
+ *	  Apply Var translations from a toplevel appendrel parent down to a child.
+ *
+ * In some cases we need to translate expressions referencing a parent relation
+ * to reference an appendrel child that's multiple levels removed from it.
+ */
+Node *
+adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node,
+								  Relids child_relids,
+								  Relids top_parent_relids)
+{
+	AppendRelInfo **appinfos;
+	Bitmapset  *parent_relids = NULL;
+	int			nappinfos;
+	int			cnt;
+
+	Assert(bms_num_members(child_relids) == bms_num_members(top_parent_relids));
+
+	appinfos = find_appinfos_by_relids(root, child_relids, &nappinfos);
+
+	/* Construct relids set for the immediate parent of given child. */
+	for (cnt = 0; cnt < nappinfos; cnt++)
+	{
+		AppendRelInfo *appinfo = appinfos[cnt];
+
+		parent_relids = bms_add_member(parent_relids, appinfo->parent_relid);
+	}
+
+	/* Recurse if immediate parent is not the top parent. */
+	if (!bms_equal(parent_relids, top_parent_relids))
+		node = adjust_appendrel_attrs_multilevel(root, node, parent_relids,
+												 top_parent_relids);
+
+	/* Now translate for this child */
+	node = adjust_appendrel_attrs(root, node, nappinfos, appinfos);
+
+	pfree(appinfos);
+
+	return node;
+}
+
+/*
+ * Construct the SpecialJoinInfo for a child-join by translating
+ * SpecialJoinInfo for the join between parents. left_relids and right_relids
+ * are the relids of left and right side of the join respectively.
+ */
+SpecialJoinInfo *
+build_child_join_sjinfo(PlannerInfo *root, SpecialJoinInfo *parent_sjinfo,
+						Relids left_relids, Relids right_relids)
+{
+	SpecialJoinInfo *sjinfo = makeNode(SpecialJoinInfo);
+	AppendRelInfo **left_appinfos;
+	int			left_nappinfos;
+	AppendRelInfo **right_appinfos;
+	int			right_nappinfos;
+
+	memcpy(sjinfo, parent_sjinfo, sizeof(SpecialJoinInfo));
+	left_appinfos = find_appinfos_by_relids(root, left_relids,
+											&left_nappinfos);
+	right_appinfos = find_appinfos_by_relids(root, right_relids,
+											 &right_nappinfos);
+
+	sjinfo->min_lefthand = adjust_child_relids(sjinfo->min_lefthand,
+											   left_nappinfos, left_appinfos);
+	sjinfo->min_righthand = adjust_child_relids(sjinfo->min_righthand,
+												right_nappinfos,
+												right_appinfos);
+	sjinfo->syn_lefthand = adjust_child_relids(sjinfo->syn_lefthand,
+											   left_nappinfos, left_appinfos);
+	sjinfo->syn_righthand = adjust_child_relids(sjinfo->syn_righthand,
+												right_nappinfos,
+												right_appinfos);
+	sjinfo->semi_rhs_exprs = (List *) adjust_appendrel_attrs(root,
+															 (Node *) sjinfo->semi_rhs_exprs,
+															 right_nappinfos,
+															 right_appinfos);
+
+	pfree(left_appinfos);
+	pfree(right_appinfos);
+
+	return sjinfo;
+}
+
+/*
+ * find_appinfos_by_relids
+ * 		Find AppendRelInfo structures for all relations specified by relids.
+ *
+ * The AppendRelInfos are returned in an array, which can be pfree'd by the
+ * caller. *nappinfos is set to the number of entries in the array.
+ */
+AppendRelInfo **
+find_appinfos_by_relids(PlannerInfo *root, Relids relids, int *nappinfos)
+{
+	AppendRelInfo **appinfos;
+	int			cnt = 0;
+	int			i;
+
+	*nappinfos = bms_num_members(relids);
+	appinfos = (AppendRelInfo **) palloc(sizeof(AppendRelInfo *) * *nappinfos);
+
+	i = -1;
+	while ((i = bms_next_member(relids, i)) >= 0)
+	{
+		AppendRelInfo *appinfo = root->append_rel_array[i];
+
+		if (!appinfo)
+			elog(ERROR, "child rel %d not found in append_rel_array", i);
+
+		appinfos[cnt++] = appinfo;
+	}
+	return appinfos;
+}
+
+/*
+ * make_inh_translation_list
+ *	  Build the list of translations from parent Vars to child Vars for
+ *	  an inheritance child.
+ *
+ * For paranoia's sake, we match type/collation as well as attribute name.
+ */
+static void
+make_inh_translation_list(TupleDesc old_tupdesc, TupleDesc new_tupdesc,
+						  Oid from_rel, Oid to_rel,
+						  Index newvarno, List **translated_vars)
+{
+	List	   *vars = NIL;
+	int			oldnatts = old_tupdesc->natts;
+	int			newnatts = new_tupdesc->natts;
+	int			old_attno;
+	int			new_attno = 0;
+
+	for (old_attno = 0; old_attno < oldnatts; old_attno++)
+	{
+		Form_pg_attribute att;
+		char	   *attname;
+		Oid			atttypid;
+		int32		atttypmod;
+		Oid			attcollation;
+
+		att = TupleDescAttr(old_tupdesc, old_attno);
+		if (att->attisdropped)
+		{
+			/* Just put NULL into this list entry */
+			vars = lappend(vars, NULL);
+			continue;
+		}
+		attname = NameStr(att->attname);
+		atttypid = att->atttypid;
+		atttypmod = att->atttypmod;
+		attcollation = att->attcollation;
+
+		/*
+		 * When we are generating the "translation list" for the parent table
+		 * of an inheritance set, no need to search for matches.
+		 */
+		if (from_rel == to_rel)
+		{
+			vars = lappend(vars, makeVar(newvarno,
+										 (AttrNumber) (old_attno + 1),
+										 atttypid,
+										 atttypmod,
+										 attcollation,
+										 0));
+			continue;
+		}
+
+		/*
+		 * Otherwise we have to search for the matching column by name.
+		 * There's no guarantee it'll have the same column position, because
+		 * of cases like ALTER TABLE ADD COLUMN and multiple inheritance.
+		 * However, in simple cases, the relative order of columns is mostly
+		 * the same in both relations, so try the column of newrelation that
+		 * follows immediately after the one that we just found, and if that
+		 * fails, let syscache handle it.
+		 */
+		if (new_attno >= newnatts ||
+			(att = TupleDescAttr(new_tupdesc, new_attno))->attisdropped ||
+			strcmp(attname, NameStr(att->attname)) != 0)
+		{
+			HeapTuple	newtup;
+
+			newtup = SearchSysCacheAttName(to_rel, attname);
+			if (!newtup)
+				elog(ERROR, "could not find inherited attribute \"%s\" of relation \"%s\"",
+					 attname, get_rel_name(to_rel));
+			new_attno = ((Form_pg_attribute) GETSTRUCT(newtup))->attnum - 1;
+			ReleaseSysCache(newtup);
+
+			att = TupleDescAttr(new_tupdesc, new_attno);
+		}
+
+		/* Found it, check type and collation match */
+		if (atttypid != att->atttypid || atttypmod != att->atttypmod)
+			elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's type",
+				 attname, get_rel_name(to_rel));
+		if (attcollation != att->attcollation)
+			elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's collation",
+				 attname, get_rel_name(to_rel));
+
+		vars = lappend(vars, makeVar(newvarno,
+									 (AttrNumber) (new_attno + 1),
+									 atttypid,
+									 atttypmod,
+									 attcollation,
+									 0));
+		new_attno++;
+	}
+
+	*translated_vars = vars;
+}
+
+/*
+ * 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.
+ */
+static List *
+adjust_inherited_tlist(List *tlist, AppendRelInfo *context)
+{
+	bool		changed_it = false;
+	ListCell   *tl;
+	List	   *new_tlist;
+	bool		more;
+	int			attrno;
+
+	/* 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)
+	{
+		TargetEntry *tle = (TargetEntry *) lfirst(tl);
+		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))
+			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);
+		if (childvar == NULL || !IsA(childvar, Var))
+			elog(ERROR, "attribute %d of relation \"%s\" does not exist",
+				 tle->resno, get_rel_name(context->parent_reloid));
+
+		if (tle->resno != childvar->varattno)
+		{
+			tle->resno = childvar->varattno;
+			changed_it = true;
+		}
+	}
+
+	/*
+	 * 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;
+
+	new_tlist = NIL;
+	more = true;
+	for (attrno = 1; more; attrno++)
+	{
+		more = false;
+		foreach(tl, tlist)
+		{
+			TargetEntry *tle = (TargetEntry *) lfirst(tl);
+
+			if (tle->resjunk)
+				continue;		/* ignore junk items */
+
+			if (tle->resno == attrno)
+				new_tlist = lappend(new_tlist, tle);
+			else if (tle->resno > attrno)
+				more = true;
+		}
+	}
+
+	foreach(tl, tlist)
+	{
+		TargetEntry *tle = (TargetEntry *) lfirst(tl);
+
+		if (!tle->resjunk)
+			continue;			/* here, ignore non-junk items */
+
+		tle->resno = attrno;
+		new_tlist = lappend(new_tlist, tle);
+		attrno++;
+	}
+
+	return new_tlist;
+}
diff --git a/src/backend/optimizer/util/pathnode.c b/src/backend/optimizer/util/pathnode.c
index d50d86b252..8ce88876c4 100644
--- a/src/backend/optimizer/util/pathnode.c
+++ b/src/backend/optimizer/util/pathnode.c
@@ -20,6 +20,7 @@
 #include "foreign/fdwapi.h"
 #include "nodes/extensible.h"
 #include "nodes/nodeFuncs.h"
+#include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
diff --git a/src/backend/optimizer/util/plancat.c b/src/backend/optimizer/util/plancat.c
index e7b4965337..12d8feb409 100644
--- a/src/backend/optimizer/util/plancat.c
+++ b/src/backend/optimizer/util/plancat.c
@@ -106,7 +106,7 @@ static void set_baserel_partition_key_exprs(Relation relation,
  */
 void
 get_relation_info(PlannerInfo *root, Oid relationObjectId, bool inhparent,
-				  RelOptInfo *rel)
+				  Bitmapset *updatedCols, RelOptInfo *rel)
 {
 	Index		varno = rel->relid;
 	Relation	relation;
@@ -445,11 +445,32 @@ get_relation_info(PlannerInfo *root, Oid relationObjectId, bool inhparent,
 	get_relation_foreign_keys(root, rel, relation, inhparent);
 
 	/*
-	 * Collect info about relation's partitioning scheme, if any. Only
-	 * inheritance parents may be partitioned.
+	 * Collect some additional information for inheritance parents.
 	 */
-	if (inhparent && relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
-		set_relation_partition_info(root, rel, relation);
+	if (inhparent)
+	{
+		/*
+		 * We'll need the TupleDesc when initializing the child relation.
+		 * A copy is being made because concurrent changes might drop
+		 * the relcache entry.  That's possible because ALTER TABLE
+		 * child_table NO INHERIT parent_table only requires an
+		 * AccessShareLock on parent_table.
+		 */
+		rel->tupdesc = CreateTupleDescCopy(RelationGetDescr(relation));
+		rel->reltype = RelationGetForm(relation)->reltype;
+
+		/*
+		 * If partitioned, also save the information of partitioning scheme,
+		 * and whether the query updates any of the partition key columns.
+		 */
+		if (relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
+		{
+			set_relation_partition_info(root, rel, relation);
+			if (!root->partColsUpdated)
+				root->partColsUpdated =
+					has_partition_attrs(relation, updatedCols, NULL);
+		}
+	}
 
 	heap_close(relation, NoLock);
 
@@ -1855,16 +1876,20 @@ set_relation_partition_info(PlannerInfo *root, RelOptInfo *rel,
 							Relation relation)
 {
 	PartitionDesc partdesc;
-	PartitionKey partkey;
 
 	Assert(relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE);
 
 	partdesc = RelationGetPartitionDesc(relation);
-	partkey = RelationGetPartitionKey(relation);
 	rel->part_scheme = find_partition_scheme(root, relation);
 	Assert(partdesc != NULL && rel->part_scheme != NULL);
-	rel->boundinfo = partition_bounds_copy(partdesc->boundinfo, partkey);
 	rel->nparts = partdesc->nparts;
+
+	/*
+	 * Since we must've taken a lock on the table, it's okay to simply copy
+	 * the pointers to relcache data here.
+	 */
+	rel->part_oids = partdesc->oids;
+	rel->boundinfo = partdesc->boundinfo;
 	set_baserel_partition_key_exprs(relation, rel);
 	rel->partition_qual = RelationGetPartitionQual(relation);
 }
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index 29ba19349f..52a11f434f 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -17,6 +17,7 @@
 #include <limits.h>
 
 #include "miscadmin.h"
+#include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
@@ -130,6 +131,37 @@ setup_append_rel_array(PlannerInfo *root)
 	}
 }
 
+/* Expand the PlannerInfo arrays by add_size members and zero-init it. */
+void
+expand_planner_arrays(PlannerInfo *root, int add_size)
+{
+	int		new_size = root->simple_rel_array_size + add_size;
+
+	root->simple_rte_array = (RangeTblEntry **)
+							repalloc(root->simple_rte_array,
+									 sizeof(RangeTblEntry *) * new_size);
+	root->simple_rel_array = (RelOptInfo **)
+								repalloc(root->simple_rel_array,
+										 sizeof(RelOptInfo *) * new_size);
+	if (root->append_rel_array)
+		root->append_rel_array = (AppendRelInfo **)
+									repalloc(root->append_rel_array,
+									 sizeof(AppendRelInfo *) * new_size);
+	else
+		root->append_rel_array = (AppendRelInfo **)
+									palloc0(sizeof(AppendRelInfo *) *
+											new_size);
+
+	/* Set the contents of just allocated memory to 0. */
+	MemSet(root->simple_rte_array + root->simple_rel_array_size,
+		   0, sizeof(RangeTblEntry *) * add_size);
+	MemSet(root->simple_rel_array + root->simple_rel_array_size,
+		   0, sizeof(RelOptInfo *) * add_size);
+	MemSet(root->append_rel_array + root->simple_rel_array_size,
+		   0, sizeof(AppendRelInfo *) * add_size);
+	root->simple_rel_array_size = new_size;
+}
+
 /*
  * build_simple_rel
  *	  Construct a new RelOptInfo for a base relation or 'other' relation.
@@ -238,7 +270,8 @@ build_simple_rel(PlannerInfo *root, int relid, RelOptInfo *parent)
 	{
 		case RTE_RELATION:
 			/* Table --- retrieve statistics from the system catalogs */
-			get_relation_info(root, rte->relid, rte->inh, rel);
+			get_relation_info(root, rte->relid, rte->inh, rte->updatedCols,
+							  rel);
 			break;
 		case RTE_SUBQUERY:
 		case RTE_FUNCTION:
@@ -279,52 +312,6 @@ build_simple_rel(PlannerInfo *root, int relid, RelOptInfo *parent)
 		root->qual_security_level = Max(root->qual_security_level,
 										list_length(rte->securityQuals));
 
-	/*
-	 * If this rel is an appendrel parent, recurse to build "other rel"
-	 * RelOptInfos for its children.  They are "other rels" because they are
-	 * not in the main join tree, but we will need RelOptInfos to plan access
-	 * to them.
-	 */
-	if (rte->inh)
-	{
-		ListCell   *l;
-		int			nparts = rel->nparts;
-		int			cnt_parts = 0;
-
-		if (nparts > 0)
-			rel->part_rels = (RelOptInfo **)
-				palloc(sizeof(RelOptInfo *) * nparts);
-
-		foreach(l, root->append_rel_list)
-		{
-			AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(l);
-			RelOptInfo *childrel;
-
-			/* append_rel_list contains all append rels; ignore others */
-			if (appinfo->parent_relid != relid)
-				continue;
-
-			childrel = build_simple_rel(root, appinfo->child_relid,
-										rel);
-
-			/* Nothing more to do for an unpartitioned table. */
-			if (!rel->part_scheme)
-				continue;
-
-			/*
-			 * The order of partition OIDs in append_rel_list is the same as
-			 * the order in the PartitionDesc, so the order of part_rels will
-			 * also match the PartitionDesc.  See expand_partitioned_rtentry.
-			 */
-			Assert(cnt_parts < nparts);
-			rel->part_rels[cnt_parts] = childrel;
-			cnt_parts++;
-		}
-
-		/* We should have seen all the child partitions. */
-		Assert(cnt_parts == nparts);
-	}
-
 	return rel;
 }
 
diff --git a/src/backend/partitioning/partprune.c b/src/backend/partitioning/partprune.c
index d6ca03de4a..9120fcb0d3 100644
--- a/src/backend/partitioning/partprune.c
+++ b/src/backend/partitioning/partprune.c
@@ -44,7 +44,9 @@
 #include "miscadmin.h"
 #include "nodes/makefuncs.h"
 #include "nodes/nodeFuncs.h"
+#include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
+#include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
 #include "optimizer/planner.h"
 #include "optimizer/predtest.h"
@@ -436,17 +438,23 @@ make_partitionedrel_pruneinfo(PlannerInfo *root, RelOptInfo *parentrel,
 		 * is, not pruned already).
 		 */
 		subplan_map = (int *) palloc(nparts * sizeof(int));
+		memset(subplan_map, -1, nparts * sizeof(int));
 		subpart_map = (int *) palloc(nparts * sizeof(int));
+		memset(subpart_map, -1, nparts * sizeof(int));
 		present_parts = NULL;
 
 		for (i = 0; i < nparts; i++)
 		{
 			RelOptInfo *partrel = subpart->part_rels[i];
-			int			subplanidx = relid_subplan_map[partrel->relid] - 1;
-			int			subpartidx = relid_subpart_map[partrel->relid] - 1;
+			int			subplanidx;
+			int			subpartidx;
 
-			subplan_map[i] = subplanidx;
-			subpart_map[i] = subpartidx;
+			/* Skip processing pruned partitions. */
+			if (partrel == NULL)
+				continue;
+
+			subplan_map[i] = subplanidx = relid_subplan_map[partrel->relid] - 1;
+			subpart_map[i] = subpartidx = relid_subpart_map[partrel->relid] - 1;
 			if (subplanidx >= 0)
 			{
 				present_parts = bms_add_member(present_parts, i);
@@ -540,23 +548,20 @@ gen_partprune_steps(RelOptInfo *rel, List *clauses, bool *contradictory)
 
 /*
  * prune_append_rel_partitions
- *		Returns RT indexes of the minimum set of child partitions which must
- *		be scanned to satisfy rel's baserestrictinfo quals.
+ *		Returns indexes into rel->part_rels of the minimum set of child
+ *		partitions which must be scanned to satisfy rel's baserestrictinfo
+ *		quals.
  *
  * Callers must ensure that 'rel' is a partitioned table.
  */
-Relids
+Bitmapset *
 prune_append_rel_partitions(RelOptInfo *rel)
 {
-	Relids		result;
 	List	   *clauses = rel->baserestrictinfo;
 	List	   *pruning_steps;
 	bool		contradictory;
 	PartitionPruneContext context;
-	Bitmapset  *partindexes;
-	int			i;
 
-	Assert(clauses != NIL);
 	Assert(rel->part_scheme != NULL);
 
 	/* If there are no partitions, return the empty set */
@@ -564,6 +569,13 @@ prune_append_rel_partitions(RelOptInfo *rel)
 		return NULL;
 
 	/*
+	 * If pruning is disabled or if there are no clauses to prune with,
+	 * return all partitions.
+	 */
+	if (!enable_partition_pruning || clauses == NIL)
+		return bms_add_range(NULL, 0, rel->nparts - 1);
+
+	/*
 	 * Process clauses.  If the clauses are found to be contradictory, we can
 	 * return the empty set.
 	 */
@@ -590,15 +602,7 @@ prune_append_rel_partitions(RelOptInfo *rel)
 	context.evalexecparams = false;
 
 	/* Actual pruning happens here. */
-	partindexes = get_matching_partitions(&context, pruning_steps);
-
-	/* Add selected partitions' RT indexes to result. */
-	i = -1;
-	result = NULL;
-	while ((i = bms_next_member(partindexes, i)) >= 0)
-		result = bms_add_member(result, rel->part_rels[i]->relid);
-
-	return result;
+	return get_matching_partitions(&context, pruning_steps);
 }
 
 /*
diff --git a/src/include/nodes/relation.h b/src/include/nodes/relation.h
index 06212ce382..572efff742 100644
--- a/src/include/nodes/relation.h
+++ b/src/include/nodes/relation.h
@@ -15,6 +15,7 @@
 #define RELATION_H
 
 #include "access/sdir.h"
+#include "access/tupdesc.h"
 #include "fmgr.h"
 #include "lib/stringinfo.h"
 #include "nodes/params.h"
@@ -711,6 +712,7 @@ typedef struct RelOptInfo
 	int			nparts;			/* number of partitions */
 	struct PartitionBoundInfoData *boundinfo;	/* Partition bounds */
 	List	   *partition_qual; /* partition constraint */
+	Oid		   *part_oids;		/* partition OIDs */
 	struct RelOptInfo **part_rels;	/* Array of RelOptInfos of partitions,
 									 * stored in the same order of bounds */
 	List	  **partexprs;		/* Non-nullable partition key expressions. */
@@ -720,6 +722,12 @@ typedef struct RelOptInfo
 	Index		inh_root_parent;	/* For otherrels, this is the RT index of
 									 * inheritance table mentioned in the query
 									 * from which this relation originated */
+	/*
+	 * Set only if this is an inheritance parent relation.  This information
+	 * is needed when initializing the planning info for children.
+	 */
+	TupleDesc	tupdesc;		/* A "copy" of the table's tuple desriptor */
+	Oid			reltype;		/* Table's reltype */
 } RelOptInfo;
 
 /*
diff --git a/src/include/optimizer/append.h b/src/include/optimizer/append.h
new file mode 100644
index 0000000000..5b44530279
--- /dev/null
+++ b/src/include/optimizer/append.h
@@ -0,0 +1,28 @@
+/*-------------------------------------------------------------------------
+ *
+ * append.h
+ *	  prototypes for append.c.
+ *
+ *
+ * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/optimizer/append.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef APPEND_H
+#define APPEND_H
+
+#include "nodes/relation.h"
+
+/*
+ * append.c
+ *	  utilities for dealing with append relations
+ */
+extern void expand_append_rel(PlannerInfo *root,
+						 RelOptInfo *rel,
+						 RangeTblEntry *rte,
+						 Index rti);
+
+#endif							/* APPEND_H */
diff --git a/src/include/optimizer/appendinfo.h b/src/include/optimizer/appendinfo.h
new file mode 100644
index 0000000000..e205e78e6d
--- /dev/null
+++ b/src/include/optimizer/appendinfo.h
@@ -0,0 +1,43 @@
+/*-------------------------------------------------------------------------
+ *
+ * appendinfo.h
+ *	  Routines for mapping expressions between append rel parent(s) and
+ *	  children
+ *
+ * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/optimizer/appendinfo.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef APPENDINFO_H
+#define APPENDINFO_H
+
+#include "nodes/plannodes.h"
+#include "nodes/relation.h"
+#include "utils/relcache.h"
+
+extern AppendRelInfo *make_append_rel_info(RelOptInfo *parentrel,
+					 RangeTblEntry *parentrte,
+					 TupleDesc childdesc, Oid childoid, Oid childreltype,
+					 Index childRTindex);
+extern Bitmapset *translate_col_privs(const Bitmapset *parent_privs,
+					List *translated_vars);
+extern Node *adjust_appendrel_attrs(PlannerInfo *root, Node *node,
+					   int nappinfos, AppendRelInfo **appinfos);
+
+extern Node *adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node,
+								  Relids child_relids,
+								  Relids top_parent_relids);
+
+extern AppendRelInfo **find_appinfos_by_relids(PlannerInfo *root,
+						Relids relids, int *nappinfos);
+
+extern SpecialJoinInfo *build_child_join_sjinfo(PlannerInfo *root,
+						SpecialJoinInfo *parent_sjinfo,
+						Relids left_relids, Relids right_relids);
+extern Relids adjust_child_relids_multilevel(PlannerInfo *root, Relids relids,
+							   Relids child_relids, Relids top_parent_relids);
+
+#endif							/* APPENDINFO_H */
diff --git a/src/include/optimizer/pathnode.h b/src/include/optimizer/pathnode.h
index 81abcf53a8..b1baa3117a 100644
--- a/src/include/optimizer/pathnode.h
+++ b/src/include/optimizer/pathnode.h
@@ -261,6 +261,7 @@ extern Path *reparameterize_path_by_child(PlannerInfo *root, Path *path,
  */
 extern void setup_simple_rel_arrays(PlannerInfo *root);
 extern void setup_append_rel_array(PlannerInfo *root);
+extern void expand_planner_arrays(PlannerInfo *root, int add_size);
 extern RelOptInfo *build_simple_rel(PlannerInfo *root, int relid,
 				 RelOptInfo *parent);
 extern RelOptInfo *find_base_rel(PlannerInfo *root, int relid);
diff --git a/src/include/optimizer/plancat.h b/src/include/optimizer/plancat.h
index 7d53cbbb87..edaf2a3b4f 100644
--- a/src/include/optimizer/plancat.h
+++ b/src/include/optimizer/plancat.h
@@ -26,7 +26,7 @@ extern PGDLLIMPORT get_relation_info_hook_type get_relation_info_hook;
 
 
 extern void get_relation_info(PlannerInfo *root, Oid relationObjectId,
-				  bool inhparent, RelOptInfo *rel);
+				  bool inhparent, Bitmapset *updatedCols, RelOptInfo *rel);
 
 extern List *infer_arbiter_indexes(PlannerInfo *root);
 
diff --git a/src/include/optimizer/prep.h b/src/include/optimizer/prep.h
index 38608770a2..0e2cdbc539 100644
--- a/src/include/optimizer/prep.h
+++ b/src/include/optimizer/prep.h
@@ -38,7 +38,7 @@ extern Expr *canonicalize_qual(Expr *qual, bool is_check);
 /*
  * prototypes for preptlist.c
  */
-extern List *preprocess_targetlist(PlannerInfo *root);
+extern List *preprocess_targetlist(PlannerInfo *root, bool inheritance_update);
 
 extern PlanRowMark *get_plan_rowmark(List *rowmarks, Index rtindex);
 
@@ -47,22 +47,4 @@ extern PlanRowMark *get_plan_rowmark(List *rowmarks, Index rtindex);
  */
 extern RelOptInfo *plan_set_operations(PlannerInfo *root);
 
-extern void expand_inherited_tables(PlannerInfo *root);
-
-extern Node *adjust_appendrel_attrs(PlannerInfo *root, Node *node,
-					   int nappinfos, AppendRelInfo **appinfos);
-
-extern Node *adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node,
-								  Relids child_relids,
-								  Relids top_parent_relids);
-
-extern AppendRelInfo **find_appinfos_by_relids(PlannerInfo *root,
-						Relids relids, int *nappinfos);
-
-extern SpecialJoinInfo *build_child_join_sjinfo(PlannerInfo *root,
-						SpecialJoinInfo *parent_sjinfo,
-						Relids left_relids, Relids right_relids);
-extern Relids adjust_child_relids_multilevel(PlannerInfo *root, Relids relids,
-							   Relids child_relids, Relids top_parent_relids);
-
 #endif							/* PREP_H */
diff --git a/src/include/partitioning/partprune.h b/src/include/partitioning/partprune.h
index e07aaaf798..ac0a979010 100644
--- a/src/include/partitioning/partprune.h
+++ b/src/include/partitioning/partprune.h
@@ -76,7 +76,7 @@ extern PartitionPruneInfo *make_partition_pruneinfo(PlannerInfo *root,
 						 List *subpaths,
 						 List *partitioned_rels,
 						 List *prunequal);
-extern Relids prune_append_rel_partitions(RelOptInfo *rel);
+extern Bitmapset *prune_append_rel_partitions(RelOptInfo *rel);
 extern Bitmapset *get_matching_partitions(PartitionPruneContext *context,
 						List *pruning_steps);
 
diff --git a/src/test/regress/expected/join.out b/src/test/regress/expected/join.out
index 1f5378080d..73f684f992 100644
--- a/src/test/regress/expected/join.out
+++ b/src/test/regress/expected/join.out
@@ -5547,29 +5547,29 @@ select t1.b, ss.phv from join_ut1 t1 left join lateral
               (select t2.a as t2a, t3.a t3a, least(t1.a, t2.a, t3.a) phv
 					  from join_pt1 t2 join join_ut1 t3 on t2.a = t3.b) ss
               on t1.a = ss.t2a order by t1.a;
-                            QUERY PLAN                            
-------------------------------------------------------------------
+                             QUERY PLAN                             
+--------------------------------------------------------------------
  Sort
-   Output: t1.b, (LEAST(t1.a, t2.a, t3.a)), t1.a
+   Output: t1.b, (LEAST(t1.a, t2_1.a, t3.a)), t1.a
    Sort Key: t1.a
    ->  Nested Loop Left Join
-         Output: t1.b, (LEAST(t1.a, t2.a, t3.a)), t1.a
+         Output: t1.b, (LEAST(t1.a, t2_1.a, t3.a)), t1.a
          ->  Seq Scan on public.join_ut1 t1
                Output: t1.a, t1.b, t1.c
          ->  Hash Join
-               Output: t2.a, LEAST(t1.a, t2.a, t3.a)
-               Hash Cond: (t3.b = t2.a)
+               Output: t2_1.a, LEAST(t1.a, t2_1.a, t3.a)
+               Hash Cond: (t3.b = t2_1.a)
                ->  Seq Scan on public.join_ut1 t3
                      Output: t3.a, t3.b, t3.c
                ->  Hash
-                     Output: t2.a
+                     Output: t2_1.a
                      ->  Append
-                           ->  Seq Scan on public.join_pt1p1p1 t2
-                                 Output: t2.a
-                                 Filter: (t1.a = t2.a)
-                           ->  Seq Scan on public.join_pt1p2 t2_1
+                           ->  Seq Scan on public.join_pt1p1p1 t2_1
                                  Output: t2_1.a
                                  Filter: (t1.a = t2_1.a)
+                           ->  Seq Scan on public.join_pt1p2 t2
+                                 Output: t2.a
+                                 Filter: (t1.a = t2.a)
 (21 rows)
 
 select t1.b, ss.phv from join_ut1 t1 left join lateral
diff --git a/src/test/regress/expected/partition_aggregate.out b/src/test/regress/expected/partition_aggregate.out
index 6bc106831e..1450cef057 100644
--- a/src/test/regress/expected/partition_aggregate.out
+++ b/src/test/regress/expected/partition_aggregate.out
@@ -144,7 +144,7 @@ SELECT c, sum(a) FROM pagg_tab WHERE 1 = 2 GROUP BY c;
            QUERY PLAN           
 --------------------------------
  HashAggregate
-   Group Key: pagg_tab.c
+   Group Key: c
    ->  Result
          One-Time Filter: false
 (4 rows)
@@ -159,7 +159,7 @@ SELECT c, sum(a) FROM pagg_tab WHERE c = 'x' GROUP BY c;
            QUERY PLAN           
 --------------------------------
  GroupAggregate
-   Group Key: pagg_tab.c
+   Group Key: c
    ->  Result
          One-Time Filter: false
 (4 rows)
-- 
2.11.0

From 0a4bc18f85831e43bc572c42d33aaf1869861ae8 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Mon, 15 Oct 2018 10:59:24 +0900
Subject: [PATCH 5/6] Teach planner to only process unpruned partitions

This adds a bitmapset field live_parts to RelOptInfo and stores
the partition indexes of non-dummy partitions in it, meaning it
contains indexes of only those partitions that have a non-NULL
RelOptInfo present in its parent's RelOptInfo's part_rels array.

This speeds up processing partitioned table's partitions compared
to going through the whole part_rels array in a number of places.
---
 src/backend/optimizer/path/joinrels.c |  3 +++
 src/backend/optimizer/plan/planner.c  | 18 +++++++++---------
 src/backend/optimizer/util/append.c   |  8 ++++++++
 src/backend/optimizer/util/relnode.c  |  3 +++
 src/backend/partitioning/partprune.c  | 18 +++++-------------
 src/include/nodes/relation.h          |  2 ++
 6 files changed, 30 insertions(+), 22 deletions(-)

diff --git a/src/backend/optimizer/path/joinrels.c b/src/backend/optimizer/path/joinrels.c
index 6e321ec9e7..76531a05cf 100644
--- a/src/backend/optimizer/path/joinrels.c
+++ b/src/backend/optimizer/path/joinrels.c
@@ -1424,6 +1424,9 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
 		populate_joinrel_with_paths(root, child_rel1, child_rel2,
 									child_joinrel, child_sjinfo,
 									child_restrictlist);
+		if (!IS_DUMMY_REL(child_joinrel))
+			joinrel->live_parts = bms_add_member(joinrel->live_parts,
+												 cnt_parts);
 	}
 }
 
diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index b54dc6c38e..6950636b3e 100644
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -6766,7 +6766,9 @@ apply_scanjoin_target_to_paths(PlannerInfo *root,
 		List	   *live_children = NIL;
 
 		/* Adjust each partition. */
-		for (partition_idx = 0; partition_idx < rel->nparts; partition_idx++)
+		partition_idx = -1;
+		while ((partition_idx = bms_next_member(rel->live_parts,
+												partition_idx)) >= 0)
 		{
 			RelOptInfo *child_rel = rel->part_rels[partition_idx];
 			ListCell   *lc;
@@ -6774,9 +6776,7 @@ apply_scanjoin_target_to_paths(PlannerInfo *root,
 			int			nappinfos;
 			List	   *child_scanjoin_targets = NIL;
 
-			/* Skip processing pruned partitions. */
-			if (child_rel == NULL)
-				continue;
+			Assert(child_rel != NULL);
 
 			/* Translate scan/join targets for this child. */
 			appinfos = find_appinfos_by_relids(root, child_rel->relids,
@@ -6857,7 +6857,6 @@ create_partitionwise_grouping_paths(PlannerInfo *root,
 									PartitionwiseAggregateType patype,
 									GroupPathExtraData *extra)
 {
-	int			nparts = input_rel->nparts;
 	int			cnt_parts;
 	List	   *grouped_live_children = NIL;
 	List	   *partially_grouped_live_children = NIL;
@@ -6869,7 +6868,9 @@ create_partitionwise_grouping_paths(PlannerInfo *root,
 		   partially_grouped_rel != NULL);
 
 	/* Add paths for partitionwise aggregation/grouping. */
-	for (cnt_parts = 0; cnt_parts < nparts; cnt_parts++)
+	cnt_parts = -1;
+	while ((cnt_parts = bms_next_member(input_rel->live_parts,
+										cnt_parts)) >= 0)
 	{
 		RelOptInfo *child_input_rel = input_rel->part_rels[cnt_parts];
 		PathTarget *child_target = copy_pathtarget(target);
@@ -6879,9 +6880,8 @@ create_partitionwise_grouping_paths(PlannerInfo *root,
 		RelOptInfo *child_grouped_rel;
 		RelOptInfo *child_partially_grouped_rel;
 
-		/* Skip processing pruned partitions. */
-		if (child_input_rel == NULL)
-			continue;
+		/* A live partition must have a RelOptInfo. */
+		Assert(child_input_rel != NULL);
 
 		/* Input child rel must have a path */
 		Assert(child_input_rel->pathlist != NIL);
diff --git a/src/backend/optimizer/util/append.c b/src/backend/optimizer/util/append.c
index 76d9246d5f..4202a4e00d 100644
--- a/src/backend/optimizer/util/append.c
+++ b/src/backend/optimizer/util/append.c
@@ -166,6 +166,7 @@ expand_append_rel(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte,
 
 		/* Perform pruning. */
 		partindexes = prune_append_rel_partitions(rel);
+		rel->live_parts = partindexes;
 
 		/* Must expand PlannerInfo arrays before we can add children. */
 		expand_planner_arrays(root, bms_num_members(partindexes));
@@ -192,6 +193,13 @@ expand_append_rel(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte,
 												 NoLock,
 												 rootrc);
 			rel->part_rels[i] = childrel;
+
+			/*
+			 * If partition is excluded by constraints, remove it from
+			 * live_parts, too.
+			 */
+			if (childrel && IS_DUMMY_REL(childrel))
+				rel->live_parts = bms_del_member(rel->live_parts, i);
 		}
 
 		/*
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index 52a11f434f..6c7eafe6db 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -1748,6 +1748,9 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
 		joinrel->partexprs[cnt] = partexpr;
 		joinrel->nullable_partexprs[cnt] = nullable_partexpr;
 	}
+
+	/* Partitions will be added by try_partitionwise_join. */
+	joinrel->live_parts = NULL;
 }
 
 /*
diff --git a/src/backend/partitioning/partprune.c b/src/backend/partitioning/partprune.c
index 9120fcb0d3..2ed5c9e8dd 100644
--- a/src/backend/partitioning/partprune.c
+++ b/src/backend/partitioning/partprune.c
@@ -441,29 +441,21 @@ make_partitionedrel_pruneinfo(PlannerInfo *root, RelOptInfo *parentrel,
 		memset(subplan_map, -1, nparts * sizeof(int));
 		subpart_map = (int *) palloc(nparts * sizeof(int));
 		memset(subpart_map, -1, nparts * sizeof(int));
-		present_parts = NULL;
+		present_parts = bms_copy(subpart->live_parts);
 
-		for (i = 0; i < nparts; i++)
+		i = -1;
+		while ((i = bms_next_member(present_parts, i)) >= 0)
 		{
 			RelOptInfo *partrel = subpart->part_rels[i];
 			int			subplanidx;
 			int			subpartidx;
 
-			/* Skip processing pruned partitions. */
-			if (partrel == NULL)
-				continue;
-
+			Assert(partrel != NULL);
 			subplan_map[i] = subplanidx = relid_subplan_map[partrel->relid] - 1;
 			subpart_map[i] = subpartidx = relid_subpart_map[partrel->relid] - 1;
+			/* Record finding this subplan */
 			if (subplanidx >= 0)
-			{
-				present_parts = bms_add_member(present_parts, i);
-
-				/* Record finding this subplan  */
 				subplansfound = bms_add_member(subplansfound, subplanidx);
-			}
-			else if (subpartidx >= 0)
-				present_parts = bms_add_member(present_parts, i);
 		}
 
 		pinfo = makeNode(PartitionedRelPruneInfo);
diff --git a/src/include/nodes/relation.h b/src/include/nodes/relation.h
index 572efff742..4a2e096e84 100644
--- a/src/include/nodes/relation.h
+++ b/src/include/nodes/relation.h
@@ -715,6 +715,8 @@ typedef struct RelOptInfo
 	Oid		   *part_oids;		/* partition OIDs */
 	struct RelOptInfo **part_rels;	/* Array of RelOptInfos of partitions,
 									 * stored in the same order of bounds */
+	Bitmapset  *live_parts;		/* Set of live partitions; contains indexes
+								 * into part_rels array */
 	List	  **partexprs;		/* Non-nullable partition key expressions. */
 	List	  **nullable_partexprs; /* Nullable partition key expressions. */
 	List	   *partitioned_child_rels; /* List of RT indexes. */
-- 
2.11.0

From 90d20b1adf71ae3a335687d97fe7c51426095968 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Fri, 12 Oct 2018 19:12:53 +0900
Subject: [PATCH 6/6] Do not lock all partitions at the beginning

---
 src/backend/optimizer/util/append.c | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

diff --git a/src/backend/optimizer/util/append.c b/src/backend/optimizer/util/append.c
index 4202a4e00d..4080dea041 100644
--- a/src/backend/optimizer/util/append.c
+++ b/src/backend/optimizer/util/append.c
@@ -150,10 +150,6 @@ expand_append_rel(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte,
 		Assert(rte->rtekind == RTE_RELATION);
 		Assert(lockmode != NoLock);
 
-		/* If root partitioned table, lock *all* partitions in the tree. */
-		if (rel->relid == root_parent)
-			(void) find_all_inheritors(rte->relid, lockmode, NULL);
-
 		/*
 		 * Initialize partitioned_child_rels to contain this RT index.
 		 *
@@ -187,10 +183,9 @@ expand_append_rel(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte,
 			Oid		childOID = rel->part_oids[i];
 			RelOptInfo *childrel;
 
-			/* Already locked, so pass NoLock. */
 			childrel = add_inheritance_child_rel(root, rel, rte,
 												 childOID,
-												 NoLock,
+												 lockmode,
 												 rootrc);
 			rel->part_rels[i] = childrel;
 
-- 
2.11.0

diff --git a/src/backend/optimizer/path/allpaths.c b/src/backend/optimizer/path/allpaths.c
index 971da18..ab5c02d 100644
--- a/src/backend/optimizer/path/allpaths.c
+++ b/src/backend/optimizer/path/allpaths.c
@@ -2593,8 +2593,6 @@ inheritance_make_rel_from_joinlist(PlannerInfo *root,
 		RelOptInfo *childrel;
 		AppendRelInfo *appinfo = lfirst(lc);
 		List	   *translated_joinlist;
-		Relids		child_relids,
-					top_parent_relids;
 
 		/* Only consider this parent's children. */
 		if (appinfo->parent_relid != parent->relid)
@@ -2608,36 +2606,35 @@ inheritance_make_rel_from_joinlist(PlannerInfo *root,
 			continue;
 
 		/*
+		 * Modify joinlist such that relations joined to the top parent rel
+		 * appear to be joined to the child rel instead.  Do the same for
+		 * any SpecialJoinInfo structs.
+		 */
+		Assert(childrel->inh_root_parent > 0);
+		translated_joinlist = (List *)
+						adjust_appendrel_attrs(root, (Node *) joinlist,
+											   1, &appinfo);
+
+		root->join_info_list = (List *)
+						adjust_appendrel_attrs(root, (Node *) join_info_list,
+											   1, &appinfo);
+
+		/*
 		 * Sub-partitions have to be processed recursively, because
 		 * AppendRelInfoss link sub-partitions to their immediate parents, not
 		 * the root partitioned table.
 		 */
 		if (childrel->part_scheme != NULL)
 		{
-			inheritance_make_rel_from_joinlist(root, childrel, joinlist);
+			inheritance_make_rel_from_joinlist(root, childrel,
+											   translated_joinlist);
+
+			/* Restore the original for processing the next child. */
+			root->join_info_list = join_info_list;
 			continue;
 		}
 
 		/*
-		 * Modify joinlist such that relations joined to the top parent rel
-		 * appear to be joined to the child rel instead.  Do the same for
-		 * any SpecialJoinInfo structs.
-		 */
-		child_relids = bms_make_singleton(appinfo->child_relid);
-		Assert(childrel->inh_root_parent > 0);
-		top_parent_relids = bms_make_singleton(childrel->inh_root_parent);
-		translated_joinlist = (List *)
-						adjust_appendrel_attrs_multilevel(root,
-														  (Node *) joinlist,
-														  child_relids,
-														  top_parent_relids);
-		root->join_info_list = (List *)
-				adjust_appendrel_attrs_multilevel(root,
-												  (Node *) join_info_list,
-												  child_relids,
-												  top_parent_relids);
-
-		/*
 		 * Since we added the child rel directly into the join tree, we must
 		 * modify it to be a "base" rel instead of an "other" rel, which the
 		 * join planning code expects the relations being joined to be.

From 0f66b82a6ab998c4d790a4e2a6437950edf7de18 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Fri, 26 Oct 2018 16:45:59 +0900
Subject: [PATCH v5 1/6] Store inheritance root parent index in otherrel's
 RelOptInfo

Although it's set by build_simple_rel, it's not being used by any
code yet.
---
 src/backend/nodes/outfuncs.c         |  1 +
 src/backend/optimizer/util/relnode.c | 14 ++++++++++++++
 src/include/nodes/relation.h         |  4 ++++
 3 files changed, 19 insertions(+)

diff --git a/src/backend/nodes/outfuncs.c b/src/backend/nodes/outfuncs.c
index 69731ccdea..53a657c0ae 100644
--- a/src/backend/nodes/outfuncs.c
+++ b/src/backend/nodes/outfuncs.c
@@ -2371,6 +2371,7 @@ _outRelOptInfo(StringInfo str, const RelOptInfo *node)
 	WRITE_BOOL_FIELD(consider_partitionwise_join);
 	WRITE_BITMAPSET_FIELD(top_parent_relids);
 	WRITE_NODE_FIELD(partitioned_child_rels);
+	WRITE_UINT_FIELD(inh_root_parent);
 }
 
 static void
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index 39f5729b91..29ba19349f 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -215,9 +215,23 @@ build_simple_rel(PlannerInfo *root, int relid, RelOptInfo *parent)
 			rel->top_parent_relids = parent->top_parent_relids;
 		else
 			rel->top_parent_relids = bms_copy(parent->relids);
+
+		/*
+		 * For inheritance child relations, we also set inh_root_parent.
+		 * Note that 'parent' might itself be a child (a sub-partitioned
+		 * partition), in which case we simply use its value of
+		 * inh_root_parent.
+		 */
+		if (parent->rtekind == RTE_RELATION)
+			rel->inh_root_parent = parent->inh_root_parent > 0 ?
+										parent->inh_root_parent :
+										parent->relid;
 	}
 	else
+	{
 		rel->top_parent_relids = NULL;
+		rel->inh_root_parent = 0;
+	}
 
 	/* Check type of rtable entry */
 	switch (rte->rtekind)
diff --git a/src/include/nodes/relation.h b/src/include/nodes/relation.h
index 6fd24203dd..32ac3315a4 100644
--- a/src/include/nodes/relation.h
+++ b/src/include/nodes/relation.h
@@ -703,6 +703,10 @@ typedef struct RelOptInfo
 	List	  **partexprs;		/* Non-nullable partition key expressions. */
 	List	  **nullable_partexprs; /* Nullable partition key expressions. */
 	List	   *partitioned_child_rels; /* List of RT indexes. */
+
+	Index		inh_root_parent;	/* For otherrels, this is the RT index of
+									 * inheritance table mentioned in the query
+									 * from which this relation originated */
 } RelOptInfo;
 
 /*
-- 
2.11.0

From f14e09f119ce85c344b581af6b1623982d7cc2b1 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Wed, 17 Oct 2018 11:18:12 +0900
Subject: [PATCH v5 2/6] Overhaul inheritance update/delete planning

With the current method, inheritance_planner, which handles the
planning for update/delete commands targeting inheritance trees,
performs the *whole* planning for each child table.  That involves
translating the query tree to set a given child table in place of
the original inheritance root table as the query's target table,
followed by calling grouping_planner on the translated query.

That's inefficient for two reasons:

 1. partprune.c cannot be used to perform partition pruning, because
    it can only be invoked from query_planner.  With the current
    approach, query_planner only sees the individual partitions in
    the query tree it receives, not the parent partitioned table.
    This leaves each partition to be pruned using constraint
    exclusion.

 2. Repeated invocation of query_planner results in allocating large
    amounts of memory, especially if there are many child tables.
    Also, it involves repeatedly performing the same processing,
    such jointree processing.

This commit addresses both of the issues by rewriting portions of
inheritance_planner and adding some supporting functionality to
allpath.c.

With the new implementation, inheritance_planner calls query_planner
only once at the beginning with the original unmodified query, which
creates the access paths of individual relations after pruning any
unnecessary partitions.  If the query involves join against the target
relation, join paths are created for each target child relation by
replacing the original target table in the join tree by a given child
table.  Join relations (RelOptInfos thereof) for all target child
relations are collected in a global list in PlannerInfo.

After creating the join paths for all target child relations, it
calls grouping_planner() on each child join relation to finish up the
paths such that they produce query's top-level target list expanded
per a given child relation's descriptor.  grouping_planner()'s
interface is modified so that we can pass it what's called a
'planned_rel', a RelOptInfo that already contains the necessary
paths needed to produce its output.

This removes some existing code in inheritance_planner that dealt
with any subquery RTEs in the query.  The rationale of that code
was that the subquery RTEs may change during each iteration of
planning (that is, for different children), so different iterations
better use different copies of those RTEs.  That was handled by
making fresh copies of those RTEs for each iteration of planning
which were appended to the range table, accompanied by modifying all
expressions and auxiliary structures that referenced the original
subquery RTEs to instead reference the copies (that is, change the
varnos).  This copying meant we would end up adding S * N new entries
to the original range table by the time we got to the last unpruned
child, where S is the number of subquery RTEs in the original query
and N the number of unpruned children.  Since with the new code
we perform planning just once, I think we don't need this special
handling.  Actually, there is a regression test output change due
to no longer having copies of subquery RTEs (see the diff of
partition_join.out file.)

Also we no longer need the hack in relation_excluded_by_constraints()
involving setting PlannerInfo.inhTargetKind to enable constraint
exclusion for target child relation is no longer needed.

This commit removes inheritance_planner in favor of rearranging
things such that, only the planning steps that affect 1 and 2 above
are repeated for unpruned child relations.
---
 doc/src/sgml/ddl.sgml                        |  14 +-
 src/backend/nodes/outfuncs.c                 |   1 -
 src/backend/optimizer/path/allpaths.c        | 212 +++++++++++++-
 src/backend/optimizer/plan/createplan.c      |  10 -
 src/backend/optimizer/plan/planner.c         | 400 +++++++--------------------
 src/backend/optimizer/prep/prepjointree.c    |   1 -
 src/backend/optimizer/prep/prepunion.c       |  33 ++-
 src/backend/optimizer/util/plancat.c         |  50 +---
 src/include/nodes/relation.h                 |  18 +-
 src/test/regress/expected/partition_join.out |   4 +-
 10 files changed, 356 insertions(+), 387 deletions(-)

diff --git a/doc/src/sgml/ddl.sgml b/doc/src/sgml/ddl.sgml
index b5ed1b7939..8cb69b1a47 100644
--- a/doc/src/sgml/ddl.sgml
+++ b/doc/src/sgml/ddl.sgml
@@ -3935,15 +3935,6 @@ EXPLAIN SELECT count(*) FROM measurement WHERE logdate &gt;= DATE '2008-01-01';
 
    <note>
     <para>
-     Currently, pruning of partitions during the planning of an
-     <command>UPDATE</command> or <command>DELETE</command> command is
-     implemented using the constraint exclusion method (however, it is
-     controlled by the <literal>enable_partition_pruning</literal> rather than
-     <literal>constraint_exclusion</literal>) &mdash; see the following section
-     for details and caveats that apply.
-    </para>
-
-    <para>
      Execution-time partition pruning currently occurs for the
      <literal>Append</literal> and <literal>MergeAppend</literal> node types.
     </para>
@@ -3964,9 +3955,8 @@ EXPLAIN SELECT count(*) FROM measurement WHERE logdate &gt;= DATE '2008-01-01';
 
    <para>
     <firstterm>Constraint exclusion</firstterm> is a query optimization
-    technique similar to partition pruning.  While it is primarily used
-    for partitioning implemented using the legacy inheritance method, it can be
-    used for other purposes, including with declarative partitioning.
+    technique similar to partition pruning.  It is primarily used
+    for partitioning implemented using the legacy inheritance method.
    </para>
 
    <para>
diff --git a/src/backend/nodes/outfuncs.c b/src/backend/nodes/outfuncs.c
index 53a657c0ae..a95153fea7 100644
--- a/src/backend/nodes/outfuncs.c
+++ b/src/backend/nodes/outfuncs.c
@@ -2309,7 +2309,6 @@ _outPlannerInfo(StringInfo str, const PlannerInfo *node)
 	WRITE_FLOAT_FIELD(tuple_fraction, "%.4f");
 	WRITE_FLOAT_FIELD(limit_tuples, "%.0f");
 	WRITE_UINT_FIELD(qual_security_level);
-	WRITE_ENUM_FIELD(inhTargetKind, InheritanceKind);
 	WRITE_BOOL_FIELD(hasJoinRTEs);
 	WRITE_BOOL_FIELD(hasLateralRTEs);
 	WRITE_BOOL_FIELD(hasDeletedRTEs);
diff --git a/src/backend/optimizer/path/allpaths.c b/src/backend/optimizer/path/allpaths.c
index 738bb30848..8de8d383f9 100644
--- a/src/backend/optimizer/path/allpaths.c
+++ b/src/backend/optimizer/path/allpaths.c
@@ -36,6 +36,7 @@
 #include "optimizer/pathnode.h"
 #include "optimizer/paths.h"
 #include "optimizer/plancat.h"
+#include "optimizer/planmain.h"
 #include "optimizer/planner.h"
 #include "optimizer/prep.h"
 #include "optimizer/restrictinfo.h"
@@ -119,6 +120,9 @@ static void set_namedtuplestore_pathlist(PlannerInfo *root, RelOptInfo *rel,
 static void set_worktable_pathlist(PlannerInfo *root, RelOptInfo *rel,
 					   RangeTblEntry *rte);
 static RelOptInfo *make_rel_from_joinlist(PlannerInfo *root, List *joinlist);
+static void inheritance_make_rel_from_joinlist(PlannerInfo *root,
+						RelOptInfo *parent,
+						List *joinlist);
 static bool subquery_is_pushdown_safe(Query *subquery, Query *topquery,
 						  pushdown_safety_info *safetyInfo);
 static bool recurse_pushdown_safe(Node *setOp, Query *topquery,
@@ -217,13 +221,28 @@ make_one_rel(PlannerInfo *root, List *joinlist)
 
 	/*
 	 * Generate access paths for the entire join tree.
+	 *
+	 * For UPDATE/DELETE on an inheritance parent, join paths should be
+	 * generated for each child result rel separately.
 	 */
-	rel = make_rel_from_joinlist(root, joinlist);
+	if (root->parse->resultRelation &&
+		root->simple_rte_array[root->parse->resultRelation]->inh)
+	{
+		rel = root->simple_rel_array[root->parse->resultRelation];
+		inheritance_make_rel_from_joinlist(root, rel, joinlist);
+		Assert(list_length(root->inh_target_child_rels) ==
+			   list_length(root->inh_target_child_joinrels));
+	}
+	else
+	{
+		rel = make_rel_from_joinlist(root, joinlist);
 
-	/*
-	 * The result should join all and only the query's base rels.
-	 */
-	Assert(bms_equal(rel->relids, root->all_baserels));
+		/*
+		 * The result should join all and only the query's base rels.
+		 */
+		Assert(bms_equal(rel->relids, root->all_baserels));
+
+	}
 
 	return rel;
 }
@@ -1219,6 +1238,63 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 			set_rel_consider_parallel(root, childrel, childRTE);
 
 		/*
+		 * If the root parent is the result relation, we need a reltarget
+		 * for the child that will be suitable to use the child as
+		 * target relation.
+		 */
+		if (childrel->inh_root_parent > 0 &&
+			childrel->inh_root_parent == root->parse->resultRelation)
+		{
+			Query	   *parse,
+					   *orig_parse = root->parse;
+			List	   *tlist;
+			List	   *other_exprs;
+			ListCell   *lc2;
+			Relids		child_relids,
+						top_parent_relids;
+
+			/*
+			 * We'd like to build the reltarget afresh; save the translated
+			 * version of parent's expressions aside.
+			 */
+			other_exprs = childrel->reltarget->exprs;
+			childrel->reltarget->exprs = NIL;
+
+			/*
+			 * Translate the original query's expressions to this child,
+			 * mainly for updating the childrel's reltarget so that it
+			 * contains necessary expressions for using childrel as target
+			 * relation correctly.  We need to use multilevel translation
+			 * as we can only access the original version of the query.
+			 */
+			child_relids = bms_make_singleton(appinfo->child_relid);
+			top_parent_relids = bms_make_singleton(childrel->inh_root_parent);
+			parse = (Query *)
+					adjust_appendrel_attrs_multilevel(root,
+													  (Node *) root->parse,
+													  child_relids,
+													  top_parent_relids);
+			root->parse = parse;
+			tlist = preprocess_targetlist(root);
+			build_base_rel_tlists(root, tlist);
+			root->parse = orig_parse;
+
+			/*
+			 * Some of the expressions in parent's reltarget might not be
+			 * in child's just built expressions.  Check to add any that are
+			 * missing.
+			 */
+			foreach(lc2, other_exprs)
+			{
+				Expr *expr = lfirst(lc2);
+
+				if (!list_member(childrel->reltarget->exprs, expr))
+					childrel->reltarget->exprs =
+								lappend(childrel->reltarget->exprs, expr);
+			}
+		}
+
+		/*
 		 * Compute the child's size.
 		 */
 		set_rel_size(root, childrel, childRTindex, childRTE);
@@ -2624,6 +2700,132 @@ generate_gather_paths(PlannerInfo *root, RelOptInfo *rel, bool override_rows)
 }
 
 /*
+ * inheritance_make_rel_from_joinlist
+ *		Perform join planning for all non-dummy leaf inheritance children
+ *		in their role as query's target relation
+ *
+ * If a child relation is a partitioned table, its children are processed in
+ * turn by recursively calling this function.
+ */
+static void
+inheritance_make_rel_from_joinlist(PlannerInfo *root,
+								   RelOptInfo *parent,
+								   List *joinlist)
+{
+	List	   *join_info_list = root->join_info_list;
+	ListCell   *lc;
+#ifdef USE_ASSERT_CHECKING
+	int		top_parent_relid = parent->inh_root_parent > 0 ?
+							   parent->inh_root_parent :
+							   parent->relid;
+	Relids	all_baserels;
+#endif
+
+	/*
+	 * For UPDATE/DELETE queries, the top parent can only ever be a table.
+	 * As a contrast, it could be a UNION ALL subquery in the case of SELECT.
+	 */
+	Assert(planner_rt_fetch(top_parent_relid, root)->rtekind == RTE_RELATION);
+
+	/* Nothing to do. */
+	if (IS_DUMMY_REL(parent))
+		return;
+
+	foreach(lc, root->append_rel_list)
+	{
+		RelOptInfo *childrel;
+		AppendRelInfo *appinfo = lfirst(lc);
+		List	   *translated_joinlist;
+		Relids		child_relids,
+					top_parent_relids;
+
+		/* Only consider this parent's children. */
+		if (appinfo->parent_relid != parent->relid)
+			continue;
+
+		childrel = find_base_rel(root, appinfo->child_relid);
+
+		/* Ignore excluded/pruned children. */
+		if (IS_DUMMY_REL(childrel))
+			continue;
+
+		/*
+		 * Sub-partitions have to be processed recursively, because
+		 * AppendRelInfos link sub-partitions to their immediate parents, not
+		 * the root partitioned table.
+		 */
+		if (childrel->part_scheme != NULL)
+		{
+			inheritance_make_rel_from_joinlist(root, childrel, joinlist);
+			continue;
+		}
+
+		/*
+		 * Modify joinlist such that relations joined to the top parent rel
+		 * appear to be joined to the child rel instead.  Do the same for
+		 * any SpecialJoinInfo structs.
+		 */
+		child_relids = bms_make_singleton(appinfo->child_relid);
+		Assert(childrel->inh_root_parent > 0);
+		top_parent_relids = bms_make_singleton(childrel->inh_root_parent);
+		translated_joinlist = (List *)
+						adjust_appendrel_attrs_multilevel(root,
+														  (Node *) joinlist,
+														  child_relids,
+														  top_parent_relids);
+		root->join_info_list = (List *)
+				adjust_appendrel_attrs_multilevel(root,
+												  (Node *) join_info_list,
+												  child_relids,
+												  top_parent_relids);
+
+		/*
+		 * Since we added the child rel directly into the join tree, we must
+		 * modify it to be a "base" rel instead of an "other" rel, which the
+		 * join planning code expects the relations being joined to be.
+		 *
+		 * NB: Do we need to change the child EC members to be marked
+		 * as non-child somehow?
+		 */
+		childrel->reloptkind = RELOPT_BASEREL;
+
+		/* Reset join planning specific data structures. */
+		root->join_rel_list = NIL;
+		root->join_rel_hash = NULL;
+
+		/* Perform join planning and save the resulting RelOptInfo. */
+		childrel = make_rel_from_joinlist(root, translated_joinlist);
+
+		/*
+		 * Remember this child target rel.  inheritance_planner will perform
+		 * the remaining steps of planning for each child relation separately.
+		 * Specifically, it will call grouping_planner on every
+		 * RelOptInfo contained in the inh_target_child_joinrels list, each
+		 * of which represents the source of tuples to be modified for a given
+		 * target child rel.
+		 */
+		root->inh_target_child_rels = lappend_int(root->inh_target_child_rels,
+												  appinfo->child_relid);
+		root->inh_target_child_joinrels =
+						lappend(root->inh_target_child_joinrels, childrel);
+
+#ifdef USE_ASSERT_CHECKING
+		/*
+		 * The following implements essentially the same Assert as in
+		 * make_one_rel, our caller.
+		 */
+		all_baserels = bms_copy(root->all_baserels);
+		all_baserels = bms_del_member(all_baserels, top_parent_relid);
+		all_baserels = bms_add_member(all_baserels, appinfo->child_relid);
+		Assert(bms_equal(childrel->relids, all_baserels));
+#endif
+
+		/* Restore the original for processing the next child. */
+		root->join_info_list = join_info_list;
+	}
+}
+
+/*
  * make_rel_from_joinlist
  *	  Build access paths using a "joinlist" to guide the join path search.
  *
diff --git a/src/backend/optimizer/plan/createplan.c b/src/backend/optimizer/plan/createplan.c
index da7a92081a..28c4b53fea 100644
--- a/src/backend/optimizer/plan/createplan.c
+++ b/src/backend/optimizer/plan/createplan.c
@@ -1998,12 +1998,7 @@ create_groupingsets_plan(PlannerInfo *root, GroupingSetsPath *best_path)
 	/*
 	 * During setrefs.c, we'll need the grouping_map to fix up the cols lists
 	 * in GroupingFunc nodes.  Save it for setrefs.c to use.
-	 *
-	 * This doesn't work if we're in an inheritance subtree (see notes in
-	 * create_modifytable_plan).  Fortunately we can't be because there would
-	 * never be grouping in an UPDATE/DELETE; but let's Assert that.
 	 */
-	Assert(root->inhTargetKind == INHKIND_NONE);
 	Assert(root->grouping_map == NULL);
 	root->grouping_map = grouping_map;
 
@@ -2160,12 +2155,7 @@ create_minmaxagg_plan(PlannerInfo *root, MinMaxAggPath *best_path)
 	 * with InitPlan output params.  (We can't just do that locally in the
 	 * MinMaxAgg node, because path nodes above here may have Agg references
 	 * as well.)  Save the mmaggregates list to tell setrefs.c to do that.
-	 *
-	 * This doesn't work if we're in an inheritance subtree (see notes in
-	 * create_modifytable_plan).  Fortunately we can't be because there would
-	 * never be aggregates in an UPDATE/DELETE; but let's Assert that.
 	 */
-	Assert(root->inhTargetKind == INHKIND_NONE);
 	Assert(root->minmax_aggs == NIL);
 	root->minmax_aggs = best_path->mmaggregates;
 
diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index c729a99f8b..93b8c761c2 100644
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -37,6 +37,7 @@
 #ifdef OPTIMIZER_DEBUG
 #include "nodes/print.h"
 #endif
+#include "nodes/relation.h"
 #include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
@@ -126,7 +127,7 @@ static Node *preprocess_expression(PlannerInfo *root, Node *expr, int kind);
 static void preprocess_qual_conditions(PlannerInfo *root, Node *jtnode);
 static void inheritance_planner(PlannerInfo *root);
 static void grouping_planner(PlannerInfo *root, bool inheritance_update,
-				 double tuple_fraction);
+				 RelOptInfo *planned_rel, double tuple_fraction);
 static grouping_sets_data *preprocess_grouping_sets(PlannerInfo *root);
 static List *remap_to_groupclause_idx(List *groupClause, List *gsets,
 						 int *tleref_to_colnum_map);
@@ -630,7 +631,6 @@ subquery_planner(PlannerGlobal *glob, Query *parse,
 	root->grouping_map = NULL;
 	root->minmax_aggs = NIL;
 	root->qual_security_level = 0;
-	root->inhTargetKind = INHKIND_NONE;
 	root->hasRecursion = hasRecursion;
 	if (hasRecursion)
 		root->wt_param_id = SS_assign_special_param(root);
@@ -970,7 +970,7 @@ subquery_planner(PlannerGlobal *glob, Query *parse,
 		rt_fetch(parse->resultRelation, parse->rtable)->inh)
 		inheritance_planner(root);
 	else
-		grouping_planner(root, false, tuple_fraction);
+		grouping_planner(root, false, NULL, tuple_fraction);
 
 	/*
 	 * Capture the set of outer-level param IDs we have access to, for use in
@@ -1146,12 +1146,19 @@ preprocess_phv_expression(PlannerInfo *root, Expr *expr)
  *	  inheritance set.
  *
  * We have to handle this case differently from cases where a source relation
- * is an inheritance set. Source inheritance is expanded at the bottom of the
- * plan tree (see allpaths.c), but target inheritance has to be expanded at
- * the top.  The reason is that for UPDATE, each target relation needs a
- * different targetlist matching its own column set.  Fortunately,
- * the UPDATE/DELETE target can never be the nullable side of an outer join,
- * so it's OK to generate the plan this way.
+ * is an inheritance set.  That's mainly because for UPDATE, each target
+ * relation needs a different targetlist matching its own column set.  So, we
+ * must modify the source scan/join path for each target relation such that it
+ * produces the desired target list.
+ *
+ * The source scan/join paths for individual target relations are still
+ * created in allpaths.c by first expanding the inheritance in the usual way
+ * by set_append_rel_size, followed by join planning for each target relation
+ * separately in make_one_rel.  Finally, we apply grouping_planner here to each
+ * child scan/join path so that it produces the desired targetlist.
+ *
+ * Fortunately, the UPDATE/DELETE target can never be the nullable side of an
+ * outer join, so it's OK to generate the plan this way.
  *
  * Returns nothing; the useful output is in the Paths we attach to
  * the (UPPERREL_FINAL, NULL) upperrel stored in *root.
@@ -1164,14 +1171,8 @@ inheritance_planner(PlannerInfo *root)
 {
 	Query	   *parse = root->parse;
 	int			top_parentRTindex = parse->resultRelation;
-	Bitmapset  *subqueryRTindexes;
-	Bitmapset  *modifiableARIindexes;
 	int			nominalRelation = -1;
 	Index		rootRelation = 0;
-	List	   *final_rtable = NIL;
-	int			save_rel_array_size = 0;
-	RelOptInfo **save_rel_array = NULL;
-	AppendRelInfo **save_append_rel_array = NULL;
 	List	   *subpaths = NIL;
 	List	   *subroots = NIL;
 	List	   *resultRelations = NIL;
@@ -1179,70 +1180,60 @@ inheritance_planner(PlannerInfo *root)
 	List	   *returningLists = NIL;
 	List	   *rowMarks;
 	RelOptInfo *final_rel;
-	ListCell   *lc;
-	Index		rti;
+	ListCell   *lc1,
+			   *lc2;
 	RangeTblEntry *parent_rte;
-	PlannerInfo *parent_root;
-	Query	   *parent_parse;
-	Bitmapset  *parent_relids = bms_make_singleton(top_parentRTindex);
-	PlannerInfo **parent_roots = NULL;
+	List	   *tlist,
+			   *orig_tlist;
+	standard_qp_extra qp_extra;
+	RelOptInfo *planned_rel;
+	List	   *partitioned_rels = NIL;
 
+	/* Inheritance is never used for insert. */
 	Assert(parse->commandType != CMD_INSERT);
+	parent_rte = planner_rt_fetch(top_parentRTindex, root);
 
 	/*
-	 * We generate a modified instance of the original Query for each target
-	 * relation, plan that, and put all the plans into a list that will be
-	 * controlled by a single ModifyTable node.  All the instances share the
-	 * same rangetable, but each instance must have its own set of subquery
-	 * RTEs within the finished rangetable because (1) they are likely to get
-	 * scribbled on during planning, and (2) it's not inconceivable that
-	 * subqueries could get planned differently in different cases.  We need
-	 * not create duplicate copies of other RTE kinds, in particular not the
-	 * target relations, because they don't have either of those issues.  Not
-	 * having to duplicate the target relations is important because doing so
-	 * (1) would result in a rangetable of length O(N^2) for N targets, with
-	 * at least O(N^3) work expended here; and (2) would greatly complicate
-	 * management of the rowMarks list.
+	 * Generate the access paths for all relations mentioned in the query,
+	 * including the target inheritance set.  When doing the join planning,
+	 * references in the join tree to the original target relation that's the
+	 * root parent of the inheritance tree is replaced by each of its
+	 * inheritance children and the resulting joinrel RelOptInfo's are
+	 * added to root->inh_target_child_joinrels.
 	 *
-	 * To begin with, generate a bitmapset of the relids of the subquery RTEs.
+	 * Final planning steps (grouping_planner) are applied to the best path
+	 * of each of those child joinrels using a modified instance of the
+	 * original query for a given child target rel.  All the paths so generated
+	 * are put into  a list that will be controlled by a single ModifyTable
+	 * node.  All the instances share the same rangetable.
 	 */
-	subqueryRTindexes = NULL;
-	rti = 1;
-	foreach(lc, parse->rtable)
-	{
-		RangeTblEntry *rte = lfirst_node(RangeTblEntry, lc);
-
-		if (rte->rtekind == RTE_SUBQUERY)
-			subqueryRTindexes = bms_add_member(subqueryRTindexes, rti);
-		rti++;
-	}
 
 	/*
-	 * Next, we want to identify which AppendRelInfo items contain references
-	 * to any of the aforesaid subquery RTEs.  These items will need to be
-	 * copied and modified to adjust their subquery references; whereas the
-	 * other ones need not be touched.  It's worth being tense over this
-	 * because we can usually avoid processing most of the AppendRelInfo
-	 * items, thereby saving O(N^2) space and time when the target is a large
-	 * inheritance tree.  We can identify AppendRelInfo items by their
-	 * child_relid, since that should be unique within the list.
+	 * Save the unmodified version of the query's targetlist to be used below
+	 * for passing to grouping_planner for each child target relation.
 	 */
-	modifiableARIindexes = NULL;
-	if (subqueryRTindexes != NULL)
-	{
-		foreach(lc, root->append_rel_list)
-		{
-			AppendRelInfo *appinfo = lfirst_node(AppendRelInfo, lc);
+	orig_tlist = list_copy(root->parse->targetList);
 
-			if (bms_is_member(appinfo->parent_relid, subqueryRTindexes) ||
-				bms_is_member(appinfo->child_relid, subqueryRTindexes) ||
-				bms_overlap(pull_varnos((Node *) appinfo->translated_vars),
-							subqueryRTindexes))
-				modifiableARIindexes = bms_add_member(modifiableARIindexes,
-													  appinfo->child_relid);
-		}
+	/* Do the scan/join planning. */
+	tlist = preprocess_targetlist(root);
+	qp_extra.tlist = tlist;
+	qp_extra.activeWindows = qp_extra.groupClause = NIL;
+	planned_rel = query_planner(root, tlist, standard_qp_callback, &qp_extra);
+
+	/*
+	 * If it turned out during query planning that all the children are dummy
+	 * (pruned or excluded by constraints), no need to do the steps below.
+	 * Let grouping_planner finish up the final path.
+	 */
+	if (IS_DUMMY_REL(planned_rel))
+	{
+		grouping_planner(root, false, planned_rel, 0.0);
+		return;
 	}
 
+	Assert(planned_rel->relid == top_parentRTindex);
+	Assert(planned_rel->reloptkind == RELOPT_BASEREL);
+
 	/*
 	 * If the parent RTE is a partitioned table, we should use that as the
 	 * nominal target relation, because the RTEs added for partitioned tables
@@ -1250,67 +1241,50 @@ inheritance_planner(PlannerInfo *root)
 	 * not appear anywhere else in the plan, so the confusion explained below
 	 * for non-partitioning inheritance cases is not possible.
 	 */
-	parent_rte = rt_fetch(top_parentRTindex, root->parse->rtable);
 	if (parent_rte->relkind == RELKIND_PARTITIONED_TABLE)
 	{
 		nominalRelation = top_parentRTindex;
 		rootRelation = top_parentRTindex;
+		partitioned_rels = lappend(partitioned_rels,
+								   list_make1_int(top_parentRTindex));
 	}
 
 	/*
-	 * The PlannerInfo for each child is obtained by translating the relevant
-	 * members of the PlannerInfo for its immediate parent, which we find
-	 * using the parent_relid in its AppendRelInfo.  We save the PlannerInfo
-	 * for each parent in an array indexed by relid for fast retrieval. Since
-	 * the maximum number of parents is limited by the number of RTEs in the
-	 * query, we use that number to allocate the array. An extra entry is
-	 * needed since relids start from 1.
+	 * Get on with finalizing the path for each child target relation by
+	 * calling grouping_planner on its joinrel.  Note that we're restoring
+	 * the query's targetlist to the original one for grouping_planner's
+	 * targetlist expansion steps to perform the expansion with individual
+	 * child descriptors.
 	 */
-	parent_roots = (PlannerInfo **) palloc0((list_length(parse->rtable) + 1) *
-											sizeof(PlannerInfo *));
-	parent_roots[top_parentRTindex] = root;
-
-	/*
-	 * And now we can get on with generating a plan for each child table.
-	 */
-	foreach(lc, root->append_rel_list)
+	parse->targetList = orig_tlist;
+	forboth(lc1, root->inh_target_child_rels,
+			lc2, root->inh_target_child_joinrels)
 	{
-		AppendRelInfo *appinfo = lfirst_node(AppendRelInfo, lc);
+		AppendRelInfo *appinfo = root->append_rel_array[lfirst_int(lc1)];
+		RelOptInfo *child_joinrel = lfirst(lc2);
 		PlannerInfo *subroot;
 		RangeTblEntry *child_rte;
 		RelOptInfo *sub_final_rel;
 		Path	   *subpath;
-
-		/* append_rel_list contains all append rels; ignore others */
-		if (!bms_is_member(appinfo->parent_relid, parent_relids))
-			continue;
-
-		/*
-		 * expand_inherited_rtentry() always processes a parent before any of
-		 * that parent's children, so the parent_root for this relation should
-		 * already be available.
-		 */
-		parent_root = parent_roots[appinfo->parent_relid];
-		Assert(parent_root != NULL);
-		parent_parse = parent_root->parse;
+		Relids		child_relids = bms_make_singleton(appinfo->child_relid),
+					top_parent_relids = bms_make_singleton(top_parentRTindex);
 
 		/*
 		 * We need a working copy of the PlannerInfo so that we can control
 		 * propagation of information back to the main copy.
 		 */
 		subroot = makeNode(PlannerInfo);
-		memcpy(subroot, parent_root, sizeof(PlannerInfo));
+		memcpy(subroot, root, sizeof(PlannerInfo));
 
 		/*
 		 * Generate modified query with this rel as target.  We first apply
 		 * adjust_appendrel_attrs, which copies the Query and changes
-		 * references to the parent RTE to refer to the current child RTE,
-		 * then fool around with subquery RTEs.
+		 * references to the parent RTE to refer to the current child RTE.
 		 */
 		subroot->parse = (Query *)
-			adjust_appendrel_attrs(parent_root,
-								   (Node *) parent_parse,
-								   1, &appinfo);
+					adjust_appendrel_attrs_multilevel(root, (Node *) parse,
+													  child_relids,
+													  top_parent_relids);
 
 		/*
 		 * If there are securityQuals attached to the parent, move them to the
@@ -1322,33 +1296,10 @@ inheritance_planner(PlannerInfo *root)
 		parent_rte->securityQuals = NIL;
 
 		/*
-		 * Mark whether we're planning a query to a partitioned table or an
-		 * inheritance parent.
+		 * inheritance_make_rel_from_joinlist only adds the leaf partitions to
+		 * PlannerInfo.
 		 */
-		subroot->inhTargetKind =
-			(rootRelation != 0) ? INHKIND_PARTITIONED : INHKIND_INHERITED;
-
-		/*
-		 * If this child is further partitioned, remember it as a parent.
-		 * Since a partitioned table does not have any data, we don't need to
-		 * create a plan for it, and we can stop processing it here.  We do,
-		 * however, need to remember its modified PlannerInfo for use when
-		 * processing its children, since we'll update their varnos based on
-		 * the delta from immediate parent to child, not from top to child.
-		 *
-		 * Note: a very non-obvious point is that we have not yet added
-		 * duplicate subquery RTEs to the subroot's rtable.  We mustn't,
-		 * because then its children would have two sets of duplicates,
-		 * confusing matters.
-		 */
-		if (child_rte->inh)
-		{
-			Assert(child_rte->relkind == RELKIND_PARTITIONED_TABLE);
-			parent_relids = bms_add_member(parent_relids, appinfo->child_relid);
-			parent_roots[appinfo->child_relid] = subroot;
-
-			continue;
-		}
+		Assert(!child_rte->inh);
 
 		/*
 		 * Set the nominal target relation of the ModifyTable node if not
@@ -1374,111 +1325,8 @@ inheritance_planner(PlannerInfo *root)
 		if (nominalRelation < 0)
 			nominalRelation = appinfo->child_relid;
 
-		/*
-		 * The rowMarks list might contain references to subquery RTEs, so
-		 * make a copy that we can apply ChangeVarNodes to.  (Fortunately, the
-		 * executor doesn't need to see the modified copies --- we can just
-		 * pass it the original rowMarks list.)
-		 */
-		subroot->rowMarks = copyObject(parent_root->rowMarks);
-
-		/*
-		 * The append_rel_list likewise might contain references to subquery
-		 * RTEs (if any subqueries were flattenable UNION ALLs).  So prepare
-		 * to apply ChangeVarNodes to that, too.  As explained above, we only
-		 * want to copy items that actually contain such references; the rest
-		 * can just get linked into the subroot's append_rel_list.
-		 *
-		 * If we know there are no such references, we can just use the outer
-		 * append_rel_list unmodified.
-		 */
-		if (modifiableARIindexes != NULL)
-		{
-			ListCell   *lc2;
-
-			subroot->append_rel_list = NIL;
-			foreach(lc2, parent_root->append_rel_list)
-			{
-				AppendRelInfo *appinfo2 = lfirst_node(AppendRelInfo, lc2);
-
-				if (bms_is_member(appinfo2->child_relid, modifiableARIindexes))
-					appinfo2 = copyObject(appinfo2);
-
-				subroot->append_rel_list = lappend(subroot->append_rel_list,
-												   appinfo2);
-			}
-		}
-
-		/*
-		 * Add placeholders to the child Query's rangetable list to fill the
-		 * RT indexes already reserved for subqueries in previous children.
-		 * These won't be referenced, so there's no need to make them very
-		 * valid-looking.
-		 */
-		while (list_length(subroot->parse->rtable) < list_length(final_rtable))
-			subroot->parse->rtable = lappend(subroot->parse->rtable,
-											 makeNode(RangeTblEntry));
-
-		/*
-		 * If this isn't the first child Query, generate duplicates of all
-		 * subquery RTEs, and adjust Var numbering to reference the
-		 * duplicates. To simplify the loop logic, we scan the original rtable
-		 * not the copy just made by adjust_appendrel_attrs; that should be OK
-		 * since subquery RTEs couldn't contain any references to the target
-		 * rel.
-		 */
-		if (final_rtable != NIL && subqueryRTindexes != NULL)
-		{
-			ListCell   *lr;
-
-			rti = 1;
-			foreach(lr, parent_parse->rtable)
-			{
-				RangeTblEntry *rte = lfirst_node(RangeTblEntry, lr);
-
-				if (bms_is_member(rti, subqueryRTindexes))
-				{
-					Index		newrti;
-
-					/*
-					 * The RTE can't contain any references to its own RT
-					 * index, except in its securityQuals, so we can save a
-					 * few cycles by applying ChangeVarNodes to the rest of
-					 * the rangetable before we append the RTE to it.
-					 */
-					newrti = list_length(subroot->parse->rtable) + 1;
-					ChangeVarNodes((Node *) subroot->parse, rti, newrti, 0);
-					ChangeVarNodes((Node *) subroot->rowMarks, rti, newrti, 0);
-					/* Skip processing unchanging parts of append_rel_list */
-					if (modifiableARIindexes != NULL)
-					{
-						ListCell   *lc2;
-
-						foreach(lc2, subroot->append_rel_list)
-						{
-							AppendRelInfo *appinfo2 = lfirst_node(AppendRelInfo, lc2);
-
-							if (bms_is_member(appinfo2->child_relid,
-											  modifiableARIindexes))
-								ChangeVarNodes((Node *) appinfo2, rti, newrti, 0);
-						}
-					}
-					rte = copyObject(rte);
-					ChangeVarNodes((Node *) rte->securityQuals, rti, newrti, 0);
-					subroot->parse->rtable = lappend(subroot->parse->rtable,
-													 rte);
-				}
-				rti++;
-			}
-		}
-
-		/* There shouldn't be any OJ info to translate, as yet */
-		Assert(subroot->join_info_list == NIL);
-		/* and we haven't created PlaceHolderInfos, either */
-		Assert(subroot->placeholder_list == NIL);
-
-		/* Generate Path(s) for accessing this result relation */
-		grouping_planner(subroot, true, 0.0 /* retrieve all tuples */ );
+		/* Apply the top-level targetlist to child_joinrel's path. */
+		grouping_planner(subroot, true, child_joinrel, 0.0);
 
 		/*
 		 * Select cheapest path in case there's more than one.  We always run
@@ -1490,45 +1338,10 @@ inheritance_planner(PlannerInfo *root)
 		subpath = sub_final_rel->cheapest_total_path;
 
 		/*
-		 * If this child rel was excluded by constraint exclusion, exclude it
-		 * from the result plan.
+		 * child rel cannot be empty, or inheritance_make_rel_from_joinlist
+		 * wouldn't have put it in the list to begin with.
 		 */
-		if (IS_DUMMY_PATH(subpath))
-			continue;
-
-		/*
-		 * If this is the first non-excluded child, its post-planning rtable
-		 * becomes the initial contents of final_rtable; otherwise, append
-		 * just its modified subquery RTEs to final_rtable.
-		 */
-		if (final_rtable == NIL)
-			final_rtable = subroot->parse->rtable;
-		else
-			final_rtable = list_concat(final_rtable,
-									   list_copy_tail(subroot->parse->rtable,
-													  list_length(final_rtable)));
-
-		/*
-		 * We need to collect all the RelOptInfos from all child plans into
-		 * the main PlannerInfo, since setrefs.c will need them.  We use the
-		 * last child's simple_rel_array (previous ones are too short), so we
-		 * have to propagate forward the RelOptInfos that were already built
-		 * in previous children.
-		 */
-		Assert(subroot->simple_rel_array_size >= save_rel_array_size);
-		for (rti = 1; rti < save_rel_array_size; rti++)
-		{
-			RelOptInfo *brel = save_rel_array[rti];
-
-			if (brel)
-				subroot->simple_rel_array[rti] = brel;
-		}
-		save_rel_array_size = subroot->simple_rel_array_size;
-		save_rel_array = subroot->simple_rel_array;
-		save_append_rel_array = subroot->append_rel_array;
-
-		/* Make sure any initplans from this rel get into the outer list */
-		root->init_plans = subroot->init_plans;
+		Assert(!IS_DUMMY_PATH(subpath));
 
 		/* Build list of sub-paths */
 		subpaths = lappend(subpaths, subpath);
@@ -1560,36 +1373,6 @@ inheritance_planner(PlannerInfo *root)
 	 */
 
 	/*
-	 * If we managed to exclude every child rel, return a dummy plan; it
-	 * doesn't even need a ModifyTable node.
-	 */
-	if (subpaths == NIL)
-	{
-		set_dummy_rel_pathlist(final_rel);
-		return;
-	}
-
-	/*
-	 * Put back the final adjusted rtable into the master copy of the Query.
-	 * (We mustn't do this if we found no non-excluded children.)
-	 */
-	parse->rtable = final_rtable;
-	root->simple_rel_array_size = save_rel_array_size;
-	root->simple_rel_array = save_rel_array;
-	root->append_rel_array = save_append_rel_array;
-
-	/* Must reconstruct master's simple_rte_array, too */
-	root->simple_rte_array = (RangeTblEntry **)
-		palloc0((list_length(final_rtable) + 1) * sizeof(RangeTblEntry *));
-	rti = 1;
-	foreach(lc, final_rtable)
-	{
-		RangeTblEntry *rte = lfirst_node(RangeTblEntry, lc);
-
-		root->simple_rte_array[rti++] = rte;
-	}
-
-	/*
 	 * If there was a FOR [KEY] UPDATE/SHARE clause, the LockRows node will
 	 * have dealt with fetching non-locked marked rows, else we need to have
 	 * ModifyTable do that.
@@ -1629,6 +1412,12 @@ inheritance_planner(PlannerInfo *root)
  * (inheritance_planner will create a single ModifyTable node covering all the
  * target tables.)
  *
+ * If non-NULL, planned_rel is a RelOptInfo containing paths for the query's
+ * top-level joinrel, which the caller produced by itself.  In that case, this
+ * function only needs to adjust the targetlist of its cheapest_total_path.
+ * The only caller that may pass such a RelOptInfo currently is
+ * inheritance_planner.
+ *
  * tuple_fraction is the fraction of tuples we expect will be retrieved.
  * tuple_fraction is interpreted as follows:
  *	  0: expect all tuples to be retrieved (normal case)
@@ -1647,6 +1436,7 @@ inheritance_planner(PlannerInfo *root)
  */
 static void
 grouping_planner(PlannerInfo *root, bool inheritance_update,
+				 RelOptInfo *planned_rel,
 				 double tuple_fraction)
 {
 	Query	   *parse = root->parse;
@@ -1659,7 +1449,7 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 	List	   *final_targets;
 	List	   *final_targets_contain_srfs;
 	bool		final_target_parallel_safe;
-	RelOptInfo *current_rel;
+	RelOptInfo *current_rel = planned_rel;
 	RelOptInfo *final_rel;
 	ListCell   *lc;
 
@@ -1699,6 +1489,7 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 		 * special work for recursive unions is the responsibility of
 		 * plan_set_operations.
 		 */
+		Assert(current_rel == NULL);
 		current_rel = plan_set_operations(root);
 
 		/*
@@ -1878,8 +1669,9 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 		 * We also generate (in standard_qp_callback) pathkey representations
 		 * of the query's sort clause, distinct clause, etc.
 		 */
-		current_rel = query_planner(root, tlist,
-									standard_qp_callback, &qp_extra);
+		if (current_rel == NULL)
+			current_rel = query_planner(root, tlist,
+										standard_qp_callback, &qp_extra);
 
 		/*
 		 * Convert the query's result tlist into PathTarget format.
diff --git a/src/backend/optimizer/prep/prepjointree.c b/src/backend/optimizer/prep/prepjointree.c
index cd6e11904e..78baec00dc 100644
--- a/src/backend/optimizer/prep/prepjointree.c
+++ b/src/backend/optimizer/prep/prepjointree.c
@@ -917,7 +917,6 @@ pull_up_simple_subquery(PlannerInfo *root, Node *jtnode, RangeTblEntry *rte,
 	subroot->grouping_map = NULL;
 	subroot->minmax_aggs = NIL;
 	subroot->qual_security_level = 0;
-	subroot->inhTargetKind = INHKIND_NONE;
 	subroot->hasRecursion = false;
 	subroot->wt_param_id = -1;
 	subroot->non_recursive_path = NULL;
diff --git a/src/backend/optimizer/prep/prepunion.c b/src/backend/optimizer/prep/prepunion.c
index d5720518a8..ef1f978889 100644
--- a/src/backend/optimizer/prep/prepunion.c
+++ b/src/backend/optimizer/prep/prepunion.c
@@ -2253,8 +2253,39 @@ adjust_appendrel_attrs_mutator(Node *node,
 											  context->appinfos);
 		return (Node *) phv;
 	}
+
+	/*
+	 * This is needed, because inheritance_make_rel_from_joinlist needs to
+	 * translate root->join_info_list executing make_rel_from_joinlist for a
+	 * given child.
+	 */
+	if (IsA(node, SpecialJoinInfo))
+	{
+		SpecialJoinInfo *oldinfo = (SpecialJoinInfo *) node;
+		SpecialJoinInfo *newinfo = makeNode(SpecialJoinInfo);
+
+		memcpy(newinfo, oldinfo, sizeof(SpecialJoinInfo));
+		newinfo->min_lefthand = adjust_child_relids(oldinfo->min_lefthand,
+													context->nappinfos,
+													context->appinfos);
+		newinfo->min_righthand = adjust_child_relids(oldinfo->min_righthand,
+													 context->nappinfos,
+													 context->appinfos);
+		newinfo->syn_lefthand = adjust_child_relids(oldinfo->syn_lefthand,
+													context->nappinfos,
+													context->appinfos);
+		newinfo->syn_righthand = adjust_child_relids(oldinfo->syn_righthand,
+													 context->nappinfos,
+													 context->appinfos);
+		newinfo->semi_rhs_exprs =
+					(List *) expression_tree_mutator((Node *)
+													 oldinfo->semi_rhs_exprs,
+													 adjust_appendrel_attrs_mutator,
+													 (void *) context);
+		return (Node *) newinfo;
+	}
+
 	/* 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));
diff --git a/src/backend/optimizer/util/plancat.c b/src/backend/optimizer/util/plancat.c
index 0c88c90de4..ed0953f9e1 100644
--- a/src/backend/optimizer/util/plancat.c
+++ b/src/backend/optimizer/util/plancat.c
@@ -1264,36 +1264,6 @@ get_relation_constraints(PlannerInfo *root,
 		}
 	}
 
-	/*
-	 * Append partition predicates, if any.
-	 *
-	 * For selects, partition pruning uses the parent table's partition bound
-	 * descriptor, instead of constraint exclusion which is driven by the
-	 * individual partition's partition constraint.
-	 */
-	if (enable_partition_pruning && root->parse->commandType != CMD_SELECT)
-	{
-		List	   *pcqual = RelationGetPartitionQual(relation);
-
-		if (pcqual)
-		{
-			/*
-			 * Run the partition quals through const-simplification similar to
-			 * check constraints.  We skip canonicalize_qual, though, because
-			 * partition quals should be in canonical form already; also,
-			 * since the qual is in implicit-AND format, we'd have to
-			 * explicitly convert it to explicit-AND format and back again.
-			 */
-			pcqual = (List *) eval_const_expressions(root, (Node *) pcqual);
-
-			/* Fix Vars to have the desired varno */
-			if (varno != 1)
-				ChangeVarNodes((Node *) pcqual, 1, varno, 0);
-
-			result = list_concat(result, pcqual);
-		}
-	}
-
 	heap_close(relation, NoLock);
 
 	return result;
@@ -1420,31 +1390,15 @@ relation_excluded_by_constraints(PlannerInfo *root,
 	switch (constraint_exclusion)
 	{
 		case CONSTRAINT_EXCLUSION_OFF:
-
-			/*
-			 * Don't prune if feature turned off -- except if the relation is
-			 * a partition.  While partprune.c-style partition pruning is not
-			 * yet in use for all cases (update/delete is not handled), it
-			 * would be a UI horror to use different user-visible controls
-			 * depending on such a volatile implementation detail.  Therefore,
-			 * for partitioned tables we use enable_partition_pruning to
-			 * control this behavior.
-			 */
-			if (root->inhTargetKind == INHKIND_PARTITIONED)
-				break;
 			return false;
 
 		case CONSTRAINT_EXCLUSION_PARTITION:
 
 			/*
 			 * When constraint_exclusion is set to 'partition' we only handle
-			 * OTHER_MEMBER_RELs, or BASERELs in cases where the result target
-			 * is an inheritance parent or a partitioned table.
+			 * OTHER_MEMBER_RELs.
 			 */
-			if ((rel->reloptkind != RELOPT_OTHER_MEMBER_REL) &&
-				!(rel->reloptkind == RELOPT_BASEREL &&
-				  root->inhTargetKind != INHKIND_NONE &&
-				  rel->relid == root->parse->resultRelation))
+			if (rel->reloptkind != RELOPT_OTHER_MEMBER_REL)
 				return false;
 			break;
 
diff --git a/src/include/nodes/relation.h b/src/include/nodes/relation.h
index 32ac3315a4..29339d6c72 100644
--- a/src/include/nodes/relation.h
+++ b/src/include/nodes/relation.h
@@ -319,9 +319,6 @@ typedef struct PlannerInfo
 	Index		qual_security_level;	/* minimum security_level for quals */
 	/* Note: qual_security_level is zero if there are no securityQuals */
 
-	InheritanceKind inhTargetKind;	/* indicates if the target relation is an
-									 * inheritance child or partition or a
-									 * partitioned table */
 	bool		hasJoinRTEs;	/* true if any RTEs are RTE_JOIN kind */
 	bool		hasLateralRTEs; /* true if any RTEs are marked LATERAL */
 	bool		hasDeletedRTEs; /* true if any RTE was deleted from jointree */
@@ -343,6 +340,21 @@ typedef struct PlannerInfo
 
 	/* Does this query modify any partition key columns? */
 	bool		partColsUpdated;
+
+	/*
+	 * The following fields are set during query planning portion of an
+	 * inherited UPDATE/DEELETE operation.
+	 */
+
+	/* RT indexes of child target rels */
+	List	   *inh_target_child_rels;
+
+	/*
+	 * RelOptInfos representing the output of make_rel_from_joinlist() for
+	 * a each child rel in the above list, acting as the target relation in
+	 * place of the original parent target relation.
+	 */
+	List	   *inh_target_child_joinrels;
 } PlannerInfo;
 
 
diff --git a/src/test/regress/expected/partition_join.out b/src/test/regress/expected/partition_join.out
index 3ba3aaf2d8..a539280851 100644
--- a/src/test/regress/expected/partition_join.out
+++ b/src/test/regress/expected/partition_join.out
@@ -1781,7 +1781,7 @@ WHERE EXISTS (
                Filter: (c IS NULL)
          ->  Nested Loop
                ->  Seq Scan on int4_tbl
-               ->  Subquery Scan on ss_1
+               ->  Subquery Scan on ss
                      ->  Limit
                            ->  Seq Scan on int8_tbl int8_tbl_1
    ->  Nested Loop Semi Join
@@ -1789,7 +1789,7 @@ WHERE EXISTS (
                Filter: (c IS NULL)
          ->  Nested Loop
                ->  Seq Scan on int4_tbl
-               ->  Subquery Scan on ss_2
+               ->  Subquery Scan on ss
                      ->  Limit
                            ->  Seq Scan on int8_tbl int8_tbl_2
 (28 rows)
-- 
2.11.0

From 42c9c879f1793ea1fb5a6328e853139a40cfcc8d Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Wed, 17 Oct 2018 18:14:13 +0900
Subject: [PATCH v5 3/6] Lazy creation of RTEs for inheritance children

Currently, expand_inherited_tables called from subquery_planner opens
all inheritance child tables and adds them to the query's range
table and PlannerInfo in the form of AppendRelInfo's initially and
later RelOptInfo's.  For partitioning, that's pretty wasteful, because
it's possible to determine only the partitions that will need to be
scanned using partition pruning, which doesn't require opening the
partitions themselves.  However, the point at which the above
processing happens is too early to perform partition pruning.

This commit rearranges things within the planner so that inheritance
child relations can be added to the Query and PlannerInfo when
peforming set_append_rel_size on the parent table.  Although the late
initialization approach only benefits the partitioning case, it seems
undesirable to do it only for partitioned tables, because it means
adding code to handle partitions specially at various places within
the planner.  So, *all* inheritance parent tables are expanded at
set_append_rel_size.  All unpruned partitions are added to Query
in the form of their RangeTblEntry's added to the range table and to
PlannerInfo in the form of an AppendRelInfo and a RelOptInfo for each.

For partitioning, although we don't create a RangeTblEntry and
RelOptInfo for pruned partitions at set_append_rel_size time,
partitionwise join code relies on the fact that even though partitions
may have been pruned, they'd still own a RelOptInfo to handle the
outer join case where the pruned partition appears on the nullable
side of join.  Partitionwise join code deals with that by allocating
dummy RelOptInfos for pruned partitions that are based mostly on
their parent's properties.

There are some regression test diffs:

 1. Caused by the fact that we no longer allocate a duplicate RT
    entry for a partitioned table in its role as child and also that
    the individual partition RT entries are now created in the order
    in which their parent's are processed, whereas previously they'd
    be added to the range table in the order of depth-first expansion
    of inheritance tree.

 2. Those in postgres_fdw.out are caused by the fact that junk columns
    required for row marking are added to reltarget->exprs later than
    user columns, because the row marking junk columns arent added
    until after the inheritance is expanded which as of this commit
    is later than it used to be.
---
 contrib/postgres_fdw/expected/postgres_fdw.out    |  32 +-
 src/backend/optimizer/path/allpaths.c             | 204 +-----
 src/backend/optimizer/path/joinrels.c             |  62 ++
 src/backend/optimizer/plan/initsplan.c            |  58 --
 src/backend/optimizer/plan/planner.c              |  54 +-
 src/backend/optimizer/plan/setrefs.c              |   6 +
 src/backend/optimizer/prep/preptlist.c            |  11 +-
 src/backend/optimizer/prep/prepunion.c            | 818 +++++++++++++++-------
 src/backend/optimizer/util/Makefile               |   2 +-
 src/backend/optimizer/util/plancat.c              |  41 +-
 src/backend/optimizer/util/relnode.c              |  80 +--
 src/backend/partitioning/partprune.c              |  43 +-
 src/include/nodes/relation.h                      |   8 +
 src/include/optimizer/pathnode.h                  |   1 +
 src/include/optimizer/plancat.h                   |   2 +-
 src/include/optimizer/prep.h                      |  15 +-
 src/include/partitioning/partprune.h              |   2 +-
 src/test/regress/expected/join.out                |  22 +-
 src/test/regress/expected/partition_aggregate.out |   4 +-
 19 files changed, 834 insertions(+), 631 deletions(-)

diff --git a/contrib/postgres_fdw/expected/postgres_fdw.out b/contrib/postgres_fdw/expected/postgres_fdw.out
index 21a2ef5ad3..c930bf7bab 100644
--- a/contrib/postgres_fdw/expected/postgres_fdw.out
+++ b/contrib/postgres_fdw/expected/postgres_fdw.out
@@ -7085,15 +7085,15 @@ select * from bar where f1 in (select f1 from foo) for update;
                      Output: bar2.f1, bar2.f2, bar2.ctid, bar2.*, bar2.tableoid
                      Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct2 FOR UPDATE
          ->  Hash
-               Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+               Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                ->  HashAggregate
-                     Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                     Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                      Group Key: foo.f1
                      ->  Append
                            ->  Seq Scan on public.foo
-                                 Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                                 Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                            ->  Foreign Scan on public.foo2
-                                 Output: foo2.ctid, foo2.*, foo2.tableoid, foo2.f1
+                                 Output: foo2.f1, foo2.ctid, foo2.*, foo2.tableoid
                                  Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct1
 (23 rows)
 
@@ -7123,15 +7123,15 @@ select * from bar where f1 in (select f1 from foo) for share;
                      Output: bar2.f1, bar2.f2, bar2.ctid, bar2.*, bar2.tableoid
                      Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct2 FOR SHARE
          ->  Hash
-               Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+               Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                ->  HashAggregate
-                     Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                     Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                      Group Key: foo.f1
                      ->  Append
                            ->  Seq Scan on public.foo
-                                 Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                                 Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                            ->  Foreign Scan on public.foo2
-                                 Output: foo2.ctid, foo2.*, foo2.tableoid, foo2.f1
+                                 Output: foo2.f1, foo2.ctid, foo2.*, foo2.tableoid
                                  Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct1
 (23 rows)
 
@@ -7160,15 +7160,15 @@ update bar set f2 = f2 + 100 where f1 in (select f1 from foo);
          ->  Seq Scan on public.bar
                Output: bar.f1, bar.f2, bar.ctid
          ->  Hash
-               Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+               Output: foo.f1, foo.ctid, foo.tableoid, foo.*
                ->  HashAggregate
-                     Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                     Output: foo.f1, foo.ctid, foo.tableoid, foo.*
                      Group Key: foo.f1
                      ->  Append
                            ->  Seq Scan on public.foo
-                                 Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                                 Output: foo.f1, foo.ctid, foo.tableoid, foo.*
                            ->  Foreign Scan on public.foo2
-                                 Output: foo2.ctid, foo2.*, foo2.tableoid, foo2.f1
+                                 Output: foo2.f1, foo2.ctid, foo2.tableoid, foo2.*
                                  Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct1
    ->  Hash Join
          Output: bar2.f1, (bar2.f2 + 100), bar2.f3, bar2.ctid, foo.ctid, foo.*, foo.tableoid
@@ -7178,15 +7178,15 @@ update bar set f2 = f2 + 100 where f1 in (select f1 from foo);
                Output: bar2.f1, bar2.f2, bar2.f3, bar2.ctid
                Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct2 FOR UPDATE
          ->  Hash
-               Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+               Output: foo.f1, foo.ctid, foo.tableoid, foo.*
                ->  HashAggregate
-                     Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                     Output: foo.f1, foo.ctid, foo.tableoid, foo.*
                      Group Key: foo.f1
                      ->  Append
                            ->  Seq Scan on public.foo
-                                 Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                                 Output: foo.f1, foo.ctid, foo.tableoid, foo.*
                            ->  Foreign Scan on public.foo2
-                                 Output: foo2.ctid, foo2.*, foo2.tableoid, foo2.f1
+                                 Output: foo2.f1, foo2.ctid, foo2.tableoid, foo2.*
                                  Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct1
 (39 rows)
 
diff --git a/src/backend/optimizer/path/allpaths.c b/src/backend/optimizer/path/allpaths.c
index 8de8d383f9..6ee800d84a 100644
--- a/src/backend/optimizer/path/allpaths.c
+++ b/src/backend/optimizer/path/allpaths.c
@@ -44,7 +44,6 @@
 #include "optimizer/var.h"
 #include "parser/parse_clause.h"
 #include "parser/parsetree.h"
-#include "partitioning/partprune.h"
 #include "rewrite/rewriteManip.h"
 #include "utils/lsyscache.h"
 
@@ -943,8 +942,6 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 	double	   *parent_attrsizes;
 	int			nattrs;
 	ListCell   *l;
-	Relids		live_children = NULL;
-	bool		did_pruning = false;
 
 	/* Guard against stack overflow due to overly deep inheritance tree. */
 	check_stack_depth();
@@ -952,29 +949,22 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 	Assert(IS_SIMPLE_REL(rel));
 
 	/*
-	 * Initialize partitioned_child_rels to contain this RT index.
-	 *
-	 * Note that during the set_append_rel_pathlist() phase, we will bubble up
-	 * the indexes of partitioned relations that appear down in the tree, so
-	 * that when we've created Paths for all the children, the root
-	 * partitioned table's list will contain all such indexes.
+	 * Add append children to the PlannerInfo.
 	 */
-	if (rte->relkind == RELKIND_PARTITIONED_TABLE)
-		rel->partitioned_child_rels = list_make1_int(rti);
+	expand_append_rel(root, rel, rte, rti);
+
+	/* Did we find out that none of the children produce any output? */
+	if (IS_DUMMY_REL(rel))
+		return;
 
 	/*
-	 * If the partitioned relation has any baserestrictinfo quals then we
-	 * attempt to use these quals to prune away partitions that cannot
-	 * possibly contain any tuples matching these quals.  In this case we'll
-	 * store the relids of all partitions which could possibly contain a
-	 * matching tuple, and skip anything else in the loop below.
+	 * If we only need to scan the parent because all of the children are
+	 * either pruned or excluded, do so right away and return.
 	 */
-	if (enable_partition_pruning &&
-		rte->relkind == RELKIND_PARTITIONED_TABLE &&
-		rel->baserestrictinfo != NIL)
+	if (!rte->inh)
 	{
-		live_children = prune_append_rel_partitions(rel);
-		did_pruning = true;
+		set_rel_size(root, rel, rti, rte);
+		return;
 	}
 
 	/*
@@ -1014,12 +1004,8 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 		int			childRTindex;
 		RangeTblEntry *childRTE;
 		RelOptInfo *childrel;
-		List	   *childquals;
-		Index		cq_min_security;
-		bool		have_const_false_cq;
 		ListCell   *parentvars;
 		ListCell   *childvars;
-		ListCell   *lc;
 
 		/* append_rel_list contains all append rels; ignore others */
 		if (appinfo->parent_relid != parentRTindex)
@@ -1027,18 +1013,31 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 
 		childRTindex = appinfo->child_relid;
 		childRTE = root->simple_rte_array[childRTindex];
+		Assert(childRTE != NULL);
 
-		/*
-		 * The child rel's RelOptInfo was already created during
-		 * add_base_rels_to_query.
-		 */
+		/* The child rel's RelOptInfo is created during expand_append_rel */
 		childrel = find_base_rel(root, childRTindex);
 		Assert(childrel->reloptkind == RELOPT_OTHER_MEMBER_REL);
 
 		/*
-		 * Copy/Modify targetlist. Even if this child is deemed empty, we need
-		 * its targetlist in case it falls on nullable side in a child-join
-		 * because of partitionwise join.
+		 * Child relation may have be marked dummy if build_append_child_rel
+		 * found self-contradictory quals.
+		 */
+		if (IS_DUMMY_REL(childrel))
+			continue;
+
+		if (relation_excluded_by_constraints(root, childrel, childRTE))
+		{
+			/*
+			 * This child need not be scanned, so we can omit it from the
+			 * appendrel.
+			 */
+			set_dummy_rel_pathlist(childrel);
+			continue;
+		}
+
+		/*
+		 * Copy/Modify targetlist.
 		 *
 		 * NB: the resulting childrel->reltarget->exprs may contain arbitrary
 		 * expressions, which otherwise would not occur in a rel's targetlist.
@@ -1067,144 +1066,6 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 			add_child_rel_equivalences(root, appinfo, rel, childrel);
 		childrel->has_eclass_joins = rel->has_eclass_joins;
 
-		/*
-		 * We have to copy the parent's quals to the child, with appropriate
-		 * substitution of variables.  However, only the baserestrictinfo
-		 * quals are needed before we can check for constraint exclusion; so
-		 * do that first and then check to see if we can disregard this child.
-		 *
-		 * The child rel's targetlist might contain non-Var expressions, which
-		 * means that substitution into the quals could produce opportunities
-		 * for const-simplification, and perhaps even pseudoconstant quals.
-		 * Therefore, transform each RestrictInfo separately to see if it
-		 * reduces to a constant or pseudoconstant.  (We must process them
-		 * separately to keep track of the security level of each qual.)
-		 */
-		childquals = NIL;
-		cq_min_security = UINT_MAX;
-		have_const_false_cq = false;
-		foreach(lc, rel->baserestrictinfo)
-		{
-			RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
-			Node	   *childqual;
-			ListCell   *lc2;
-
-			Assert(IsA(rinfo, RestrictInfo));
-			childqual = adjust_appendrel_attrs(root,
-											   (Node *) rinfo->clause,
-											   1, &appinfo);
-			childqual = eval_const_expressions(root, childqual);
-			/* check for flat-out constant */
-			if (childqual && IsA(childqual, Const))
-			{
-				if (((Const *) childqual)->constisnull ||
-					!DatumGetBool(((Const *) childqual)->constvalue))
-				{
-					/* Restriction reduces to constant FALSE or NULL */
-					have_const_false_cq = true;
-					break;
-				}
-				/* Restriction reduces to constant TRUE, so drop it */
-				continue;
-			}
-			/* might have gotten an AND clause, if so flatten it */
-			foreach(lc2, make_ands_implicit((Expr *) childqual))
-			{
-				Node	   *onecq = (Node *) lfirst(lc2);
-				bool		pseudoconstant;
-
-				/* check for pseudoconstant (no Vars or volatile functions) */
-				pseudoconstant =
-					!contain_vars_of_level(onecq, 0) &&
-					!contain_volatile_functions(onecq);
-				if (pseudoconstant)
-				{
-					/* tell createplan.c to check for gating quals */
-					root->hasPseudoConstantQuals = true;
-				}
-				/* reconstitute RestrictInfo with appropriate properties */
-				childquals = lappend(childquals,
-									 make_restrictinfo((Expr *) onecq,
-													   rinfo->is_pushed_down,
-													   rinfo->outerjoin_delayed,
-													   pseudoconstant,
-													   rinfo->security_level,
-													   NULL, NULL, NULL));
-				/* track minimum security level among child quals */
-				cq_min_security = Min(cq_min_security, rinfo->security_level);
-			}
-		}
-
-		/*
-		 * In addition to the quals inherited from the parent, we might have
-		 * securityQuals associated with this particular child node.
-		 * (Currently this can only happen in appendrels originating from
-		 * UNION ALL; inheritance child tables don't have their own
-		 * securityQuals, see expand_inherited_rtentry().)	Pull any such
-		 * securityQuals up into the baserestrictinfo for the child.  This is
-		 * similar to process_security_barrier_quals() for the parent rel,
-		 * except that we can't make any general deductions from such quals,
-		 * since they don't hold for the whole appendrel.
-		 */
-		if (childRTE->securityQuals)
-		{
-			Index		security_level = 0;
-
-			foreach(lc, childRTE->securityQuals)
-			{
-				List	   *qualset = (List *) lfirst(lc);
-				ListCell   *lc2;
-
-				foreach(lc2, qualset)
-				{
-					Expr	   *qual = (Expr *) lfirst(lc2);
-
-					/* not likely that we'd see constants here, so no check */
-					childquals = lappend(childquals,
-										 make_restrictinfo(qual,
-														   true, false, false,
-														   security_level,
-														   NULL, NULL, NULL));
-					cq_min_security = Min(cq_min_security, security_level);
-				}
-				security_level++;
-			}
-			Assert(security_level <= root->qual_security_level);
-		}
-
-		/*
-		 * OK, we've got all the baserestrictinfo quals for this child.
-		 */
-		childrel->baserestrictinfo = childquals;
-		childrel->baserestrict_min_security = cq_min_security;
-
-		if (have_const_false_cq)
-		{
-			/*
-			 * Some restriction clause reduced to constant FALSE or NULL after
-			 * substitution, so this child need not be scanned.
-			 */
-			set_dummy_rel_pathlist(childrel);
-			continue;
-		}
-
-		if (did_pruning && !bms_is_member(appinfo->child_relid, live_children))
-		{
-			/* This partition was pruned; skip it. */
-			set_dummy_rel_pathlist(childrel);
-			continue;
-		}
-
-		if (relation_excluded_by_constraints(root, childrel, childRTE))
-		{
-			/*
-			 * This child need not be scanned, so we can omit it from the
-			 * appendrel.
-			 */
-			set_dummy_rel_pathlist(childrel);
-			continue;
-		}
-
 		/* CE failed, so finish copying/modifying join quals. */
 		childrel->joininfo = (List *)
 			adjust_appendrel_attrs(root,
@@ -1275,7 +1136,7 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 													  child_relids,
 													  top_parent_relids);
 			root->parse = parse;
-			tlist = preprocess_targetlist(root);
+			tlist = preprocess_targetlist(root, true);
 			build_base_rel_tlists(root, tlist);
 			root->parse = orig_parse;
 
@@ -2744,6 +2605,7 @@ inheritance_make_rel_from_joinlist(PlannerInfo *root,
 			continue;
 
 		childrel = find_base_rel(root, appinfo->child_relid);
+		Assert(childrel != NULL);
 
 		/* Ignore excluded/pruned children. */
 		if (IS_DUMMY_REL(childrel))
diff --git a/src/backend/optimizer/path/joinrels.c b/src/backend/optimizer/path/joinrels.c
index d3d21fed5d..da0831de4e 100644
--- a/src/backend/optimizer/path/joinrels.c
+++ b/src/backend/optimizer/path/joinrels.c
@@ -20,6 +20,7 @@
 #include "optimizer/pathnode.h"
 #include "optimizer/paths.h"
 #include "optimizer/prep.h"
+#include "optimizer/tlist.h"
 #include "partitioning/partbounds.h"
 #include "utils/lsyscache.h"
 #include "utils/memutils.h"
@@ -46,6 +47,9 @@ static void try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1,
 					   List *parent_restrictlist);
 static int match_expr_to_partition_keys(Expr *expr, RelOptInfo *rel,
 							 bool strict_op);
+static RelOptInfo *build_dummy_partition_rel(PlannerInfo *root,
+									RelOptInfo *parent,
+									int partidx);
 
 
 /*
@@ -1376,6 +1380,11 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
 		AppendRelInfo **appinfos;
 		int			nappinfos;
 
+		if (child_rel1 == NULL)
+			child_rel1 = build_dummy_partition_rel(root, rel1, cnt_parts);
+		if (child_rel2 == NULL)
+			child_rel2 = build_dummy_partition_rel(root, rel2, cnt_parts);
+
 		/* We should never try to join two overlapping sets of rels. */
 		Assert(!bms_overlap(child_rel1->relids, child_rel2->relids));
 		child_joinrelids = bms_union(child_rel1->relids, child_rel2->relids);
@@ -1582,3 +1591,56 @@ match_expr_to_partition_keys(Expr *expr, RelOptInfo *rel, bool strict_op)
 
 	return -1;
 }
+
+/*
+ * build_dummy_partition_rel
+ *		Build a RelOptInfo and AppendRelInfo for a pruned partition
+ *
+ * This does not result in opening the relation or a range table entry being
+ * created.  Also, the RelOptInfo thus created is not stored anywhere else
+ * beside the parent's part_rels array.
+ *
+ * The only reason this exists is because partition-wise join, in some cases,
+ * needs a RelOptInfo to represent an empty relation that's on the nullable
+ * side of an outer join, so that a Path representing the outer join can be
+ * created.
+ */
+RelOptInfo *
+build_dummy_partition_rel(PlannerInfo *root, RelOptInfo *parent, int partidx)
+{
+	RangeTblEntry *parentrte = root->simple_rte_array[parent->relid];
+	RelOptInfo *rel;
+
+	Assert(parent->part_rels[partidx] == NULL);
+
+	/* Create minimally valid-looking RelOptInfo with parent's relid. */
+	rel = makeNode(RelOptInfo);
+	rel->reloptkind = RELOPT_OTHER_MEMBER_REL;
+	rel->relid = parent->relid;
+	rel->relids = bms_copy(parent->relids);
+	if (parent->top_parent_relids)
+		rel->top_parent_relids = parent->top_parent_relids;
+	else
+		rel->top_parent_relids = bms_copy(parent->relids);
+	rel->reltarget = copy_pathtarget(parent->reltarget);
+	parent->part_rels[partidx] = rel;
+	mark_dummy_rel(rel);
+
+	/*
+	 * Now we'll need a (no-op) AppendRelInfo for parent, because we're
+	 * setting the dummy partition's relid to be same as the parent's.
+	 */
+	if (root->append_rel_array[parent->relid] == NULL)
+	{
+		/* Pass parent's info as for both the parent rel and child rel. */
+		AppendRelInfo *appinfo = make_append_rel_info(parent, parentrte,
+													  parent->tupdesc,
+													  parentrte->relid,
+													  parent->reltype,
+													  parent->relid);
+
+		root->append_rel_array[parent->relid] = appinfo;
+	}
+
+	return rel;
+}
diff --git a/src/backend/optimizer/plan/initsplan.c b/src/backend/optimizer/plan/initsplan.c
index 01335db511..7636aa82c4 100644
--- a/src/backend/optimizer/plan/initsplan.c
+++ b/src/backend/optimizer/plan/initsplan.c
@@ -616,64 +616,6 @@ create_lateral_join_info(PlannerInfo *root)
 				bms_add_member(brel2->lateral_referencers, rti);
 		}
 	}
-
-	/*
-	 * Lastly, propagate lateral_relids and lateral_referencers from appendrel
-	 * parent rels to their child rels.  We intentionally give each child rel
-	 * the same minimum parameterization, even though it's quite possible that
-	 * some don't reference all the lateral rels.  This is because any append
-	 * path for the parent will have to have the same parameterization for
-	 * every child anyway, and there's no value in forcing extra
-	 * reparameterize_path() calls.  Similarly, a lateral reference to the
-	 * parent prevents use of otherwise-movable join rels for each child.
-	 */
-	for (rti = 1; rti < root->simple_rel_array_size; rti++)
-	{
-		RelOptInfo *brel = root->simple_rel_array[rti];
-		RangeTblEntry *brte = root->simple_rte_array[rti];
-
-		/*
-		 * Skip empty slots. Also skip non-simple relations i.e. dead
-		 * relations.
-		 */
-		if (brel == NULL || !IS_SIMPLE_REL(brel))
-			continue;
-
-		/*
-		 * In the case of table inheritance, the parent RTE is directly linked
-		 * to every child table via an AppendRelInfo.  In the case of table
-		 * partitioning, the inheritance hierarchy is expanded one level at a
-		 * time rather than flattened.  Therefore, an other member rel that is
-		 * a partitioned table may have children of its own, and must
-		 * therefore be marked with the appropriate lateral info so that those
-		 * children eventually get marked also.
-		 */
-		Assert(brte);
-		if (brel->reloptkind == RELOPT_OTHER_MEMBER_REL &&
-			(brte->rtekind != RTE_RELATION ||
-			 brte->relkind != RELKIND_PARTITIONED_TABLE))
-			continue;
-
-		if (brte->inh)
-		{
-			foreach(lc, root->append_rel_list)
-			{
-				AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(lc);
-				RelOptInfo *childrel;
-
-				if (appinfo->parent_relid != rti)
-					continue;
-				childrel = root->simple_rel_array[appinfo->child_relid];
-				Assert(childrel->reloptkind == RELOPT_OTHER_MEMBER_REL);
-				Assert(childrel->direct_lateral_relids == NULL);
-				childrel->direct_lateral_relids = brel->direct_lateral_relids;
-				Assert(childrel->lateral_relids == NULL);
-				childrel->lateral_relids = brel->lateral_relids;
-				Assert(childrel->lateral_referencers == NULL);
-				childrel->lateral_referencers = brel->lateral_referencers;
-			}
-		}
-	}
 }
 
 
diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index 93b8c761c2..84746a9bc9 100644
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -23,6 +23,7 @@
 #include "access/sysattr.h"
 #include "access/xact.h"
 #include "catalog/pg_constraint.h"
+#include "catalog/pg_inherits.h"
 #include "catalog/pg_proc.h"
 #include "catalog/pg_type.h"
 #include "executor/executor.h"
@@ -699,27 +700,24 @@ subquery_planner(PlannerGlobal *glob, Query *parse,
 		}
 		if (rte->lateral)
 			root->hasLateralRTEs = true;
+
+		/*
+		 * While at it, also update the inh status.  If the relation doesn't
+		 * or can't have any children, there is no point in letting inh be set
+		 * to true.  Note that we do this before processing rowmarks, so that
+		 * the correct information for setting isParent field of PlanRowMarks.
+		 */
+		if (rte->rtekind == RTE_RELATION)
+			rte->inh = rte->inh && has_subclass(rte->relid);
 	}
 
 	/*
 	 * Preprocess RowMark information.  We need to do this after subquery
-	 * pullup (so that all non-inherited RTEs are present) and before
-	 * inheritance expansion (so that the info is available for
-	 * expand_inherited_tables to examine and modify).
+	 * pullup (so that all non-inherited RTEs are present).
 	 */
 	preprocess_rowmarks(root);
 
 	/*
-	 * Expand any rangetable entries that are inheritance sets into "append
-	 * relations".  This can add entries to the rangetable, but they must be
-	 * plain base relations not joins, so it's OK (and marginally more
-	 * efficient) to do it after checking for join RTEs.  We must do it after
-	 * pulling up subqueries, else we'd fail to handle inherited tables in
-	 * subqueries.
-	 */
-	expand_inherited_tables(root);
-
-	/*
 	 * Set hasHavingQual to remember if HAVING clause is present.  Needed
 	 * because preprocess_expression will reduce a constant-true condition to
 	 * an empty qual list ... but "HAVING TRUE" is not a semantic no-op.
@@ -1215,7 +1213,7 @@ inheritance_planner(PlannerInfo *root)
 	orig_tlist = list_copy(root->parse->targetList);
 
 	/* Do the scan/join planning. */
-	tlist = preprocess_targetlist(root);
+	tlist = preprocess_targetlist(root, false);
 	qp_extra.tlist = tlist;
 	qp_extra.activeWindows = qp_extra.groupClause = NIL;
 	planned_rel = query_planner(root, tlist, standard_qp_callback, &qp_extra);
@@ -1223,9 +1221,10 @@ inheritance_planner(PlannerInfo *root)
 	/*
 	 * If it turned out during query planning that all the children are dummy
 	 * (pruned or excluded by constraints), no need to do the steps below.
-	 * Let grouping_planner finish up the final path.
+	 * For regular inheritance case, it's possible that we only need to modify
+	 * the parent table.  Let grouping_planner finish up the final path.
 	 */
-	if (IS_DUMMY_REL(planned_rel))
+	if (!parent_rte->inh || IS_DUMMY_REL(planned_rel))
 	{
 		grouping_planner(root, false, planned_rel, 0.0);
 		return;
@@ -1580,7 +1579,7 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 		}
 
 		/* Preprocess targetlist */
-		tlist = preprocess_targetlist(root);
+		tlist = preprocess_targetlist(root, inheritance_update);
 
 		/*
 		 * We are now done hacking up the query's targetlist.  Most of the
@@ -1674,6 +1673,15 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 										standard_qp_callback, &qp_extra);
 
 		/*
+		 * Query planning may have added some columns to the top-level tlist,
+		 * which happens when there are row marks applied to inheritance
+		 * parent relations (additional junk columns needed for applying row
+		 * marks are added after expanding inheritance.)
+		 */
+		if (list_length(tlist) < list_length(root->processed_tlist))
+			tlist = root->processed_tlist;
+
+		/*
 		 * Convert the query's result tlist into PathTarget format.
 		 *
 		 * Note: it's desirable to not do this till after query_planner(),
@@ -2360,7 +2368,7 @@ preprocess_rowmarks(PlannerInfo *root)
 		newrc->allMarkTypes = (1 << newrc->markType);
 		newrc->strength = rc->strength;
 		newrc->waitPolicy = rc->waitPolicy;
-		newrc->isParent = false;
+		newrc->isParent = rte->inh;
 
 		prowmarks = lappend(prowmarks, newrc);
 	}
@@ -2385,7 +2393,7 @@ preprocess_rowmarks(PlannerInfo *root)
 		newrc->allMarkTypes = (1 << newrc->markType);
 		newrc->strength = LCS_NONE;
 		newrc->waitPolicy = LockWaitBlock;	/* doesn't matter */
-		newrc->isParent = false;
+		newrc->isParent = rte->rtekind == RTE_RELATION ? rte->inh : false;
 
 		prowmarks = lappend(prowmarks, newrc);
 	}
@@ -6765,6 +6773,10 @@ apply_scanjoin_target_to_paths(PlannerInfo *root,
 			int			nappinfos;
 			List	   *child_scanjoin_targets = NIL;
 
+			/* Skip processing pruned partitions. */
+			if (child_rel == NULL)
+				continue;
+
 			/* Translate scan/join targets for this child. */
 			appinfos = find_appinfos_by_relids(root, child_rel->relids,
 											   &nappinfos);
@@ -6866,6 +6878,10 @@ create_partitionwise_grouping_paths(PlannerInfo *root,
 		RelOptInfo *child_grouped_rel;
 		RelOptInfo *child_partially_grouped_rel;
 
+		/* Skip processing pruned partitions. */
+		if (child_input_rel == NULL)
+			continue;
+
 		/* Input child rel must have a path */
 		Assert(child_input_rel->pathlist != NIL);
 
diff --git a/src/backend/optimizer/plan/setrefs.c b/src/backend/optimizer/plan/setrefs.c
index 6d6ef1c376..454870609a 100644
--- a/src/backend/optimizer/plan/setrefs.c
+++ b/src/backend/optimizer/plan/setrefs.c
@@ -326,6 +326,12 @@ add_rtes_to_flat_rtable(PlannerInfo *root, bool recursing)
 													  UPPERREL_FINAL, NULL)))
 					add_rtes_to_flat_rtable(rel->subroot, true);
 			}
+			/*
+			 * A NULL rel also means an unplanned subquery rte, so apply
+			 * flatten_unplanned_rtes.
+			 */
+			else
+				flatten_unplanned_rtes(glob, rte);
 		}
 		rti++;
 	}
diff --git a/src/backend/optimizer/prep/preptlist.c b/src/backend/optimizer/prep/preptlist.c
index 8603feef2b..9c0a1c1b1c 100644
--- a/src/backend/optimizer/prep/preptlist.c
+++ b/src/backend/optimizer/prep/preptlist.c
@@ -67,7 +67,7 @@ static List *expand_targetlist(List *tlist, int command_type,
  * is also preprocessed (and updated in-place).
  */
 List *
-preprocess_targetlist(PlannerInfo *root)
+preprocess_targetlist(PlannerInfo *root, bool inheritance_update)
 {
 	Query	   *parse = root->parse;
 	int			result_relation = parse->resultRelation;
@@ -134,6 +134,15 @@ preprocess_targetlist(PlannerInfo *root)
 		if (rc->rti != rc->prti)
 			continue;
 
+		/*
+		 * For inheritance parent row marks, we defer adding junk columns
+		 * until we've added child row marks, because some children might
+		 * require different row mark types which affects which junk columns
+		 * are needed in the top-level tlist.
+		 */
+		if (rc->isParent && !inheritance_update)
+			continue;
+
 		if (rc->allMarkTypes & ~(1 << ROW_MARK_COPY))
 		{
 			/* Need to fetch TID */
diff --git a/src/backend/optimizer/prep/prepunion.c b/src/backend/optimizer/prep/prepunion.c
index ef1f978889..c6817757e7 100644
--- a/src/backend/optimizer/prep/prepunion.c
+++ b/src/backend/optimizer/prep/prepunion.c
@@ -39,15 +39,19 @@
 #include "miscadmin.h"
 #include "nodes/makefuncs.h"
 #include "nodes/nodeFuncs.h"
+#include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
 #include "optimizer/paths.h"
 #include "optimizer/planmain.h"
 #include "optimizer/planner.h"
 #include "optimizer/prep.h"
+#include "optimizer/restrictinfo.h"
 #include "optimizer/tlist.h"
+#include "optimizer/var.h"
 #include "parser/parse_coerce.h"
 #include "parser/parsetree.h"
+#include "partitioning/partprune.h"
 #include "utils/lsyscache.h"
 #include "utils/rel.h"
 #include "utils/selfuncs.h"
@@ -100,22 +104,22 @@ static List *generate_append_tlist(List *colTypes, List *colCollations,
 					  List *refnames_tlist);
 static List *generate_setop_grouplist(SetOperationStmt *op, List *targetlist);
 static void expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte,
-						 Index rti);
+						 Index rti, RelOptInfo *rel);
 static void expand_partitioned_rtentry(PlannerInfo *root,
 						   RangeTblEntry *parentrte,
-						   Index parentRTindex, Relation parentrel,
-						   PlanRowMark *top_parentrc, LOCKMODE lockmode,
-						   List **appinfos);
-static void expand_single_inheritance_child(PlannerInfo *root,
-								RangeTblEntry *parentrte,
-								Index parentRTindex, Relation parentrel,
-								PlanRowMark *top_parentrc, Relation childrel,
-								List **appinfos, RangeTblEntry **childrte_p,
-								Index *childRTindex_p);
-static void make_inh_translation_list(Relation oldrelation,
-						  Relation newrelation,
-						  Index newvarno,
-						  List **translated_vars);
+						   Index parentRTindex, RelOptInfo *parentrel);
+static RelOptInfo *add_inheritance_child_rel(PlannerInfo *root,
+						  RangeTblEntry *parentrte,
+						  Index parentRTindex, RelOptInfo *parentrel,
+						  PlanRowMark *top_parentrc, Relation childrel);
+static void make_inh_translation_list(TupleDesc old_tupdesc,
+						  TupleDesc new_tupdesc,
+						  Oid from_rel, Oid to_rel,
+						  Index newvarno, List **translated_vars);
+static RelOptInfo *build_append_child_rel(PlannerInfo *root,
+					   RelOptInfo *parent,
+					   Index childRTindex);
+static List *add_rowmark_junk_columns(PlannerInfo *root, PlanRowMark *rc);
 static Bitmapset *translate_col_privs(const Bitmapset *parent_privs,
 					List *translated_vars);
 static Node *adjust_appendrel_attrs_mutator(Node *node,
@@ -1463,42 +1467,107 @@ generate_setop_grouplist(SetOperationStmt *op, List *targetlist)
 
 
 /*
- * expand_inherited_tables
- *		Expand each rangetable entry that represents an inheritance set
- *		into an "append relation".  At the conclusion of this process,
- *		the "inh" flag is set in all and only those RTEs that are append
- *		relation parents.
+ * expand_append_rel
+ *		This initializes RelOptInfos for an appendrel's child relations.
+ *
+ * 'rel' is the appendrel parent, whose range table entry ('rte') has been
+ * marked to require adding children.  An appendrel parent could either
+ * be a subquery (if we flattened UNION ALL query) or a table that's known
+ * to have inheritance children.  The latter consists of both regular
+ * inheritance parents and partitioned tables.
+ *
+ * For a subquery parent, there is not much to be done here because the
+ * children's RTEs are already present in the query, so we just initialize
+ * RelOptInfos for them.  Also, the AppendRelInfos for child subqueries
+ * have already been added.
+ *
+ * For tables, we need to add the children to the range table and initialize
+ * AppendRelInfos, RelOptInfos, and PlanRowMarks (if any) for them.  For
+ * a partitioned parent, we only add the children remaining after pruning.
+ * For regular inheritance parents, we find the children using
+ * find_all_inheritors and add all of them.
+ *
+ * If it turns out that there are no children, then we set rte->inh to false
+ * to let the caller know that only the parent table needs to be scanned.  The
+ * caller can accordingly switch to a non-Append path.  For a partitioned
+ * parent, that means an empty relation because parents themselves contain no
+ * data.
+ *
+ * For the regular inheritance case, the parent also gets another RTE with
+ * inh = false to represent it as an appendrel child.  The original RTE is
+ * considered to represent the whole inheritance set.
  */
 void
-expand_inherited_tables(PlannerInfo *root)
+expand_append_rel(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte,
+				  Index rti)
 {
-	Index		nrtes;
-	Index		rti;
-	ListCell   *rl;
+	Assert(rte->inh);
+	/* Inheritance parent (partitioned or not) or UNION ALL parent subquery. */
+	Assert(rte->rtekind == RTE_RELATION || rte->rtekind == RTE_SUBQUERY);
 
 	/*
-	 * expand_inherited_rtentry may add RTEs to parse->rtable. The function is
-	 * expected to recursively handle any RTEs that it creates with inh=true.
-	 * So just scan as far as the original end of the rtable list.
+	 * UNION ALL children already got RTEs and AppendRelInfos, so just build
+	 * RelOptInfos and return.
+	 *
+	 * It might be a bit odd that this code is in this, because there is
+	 * nothing to expand really.
 	 */
-	nrtes = list_length(root->parse->rtable);
-	rl = list_head(root->parse->rtable);
-	for (rti = 1; rti <= nrtes; rti++)
+	if (rte->rtekind == RTE_SUBQUERY)
 	{
-		RangeTblEntry *rte = (RangeTblEntry *) lfirst(rl);
+		ListCell   *l;
 
-		expand_inherited_rtentry(root, rte, rti);
-		rl = lnext(rl);
+		/*
+		 * We don't need to use expand_planner_arrays in this case, because
+		 * no new child RTEs are created.  setup_simple_rel_arrays() and
+		 * setup_append_rel_array would've considered these child RTEs when
+		 * allocating space for various arrays.
+		 */
+		foreach(l, root->append_rel_list)
+		{
+			AppendRelInfo *appinfo = lfirst(l);
+			Index		childRTindex = appinfo->child_relid;
+
+			if (appinfo->parent_relid != rti)
+				continue;
+
+			Assert(childRTindex < root->simple_rel_array_size);
+			Assert(root->simple_rte_array[childRTindex] != NULL);
+
+			/*
+			 * We set the correct value of baserestricinfo and
+			 * baserestrict_min_security below.
+			 */
+			root->simple_rel_array[childRTindex] =
+				build_append_child_rel(root, rel, appinfo->child_relid);
+		}
+	}
+	else
+	{
+		Assert(rte->rtekind == RTE_RELATION);
+		Assert(has_subclass(rte->relid));
+
+		/*
+		 * The rewriter should already have obtained an appropriate lock on
+		 * each relation named in the query.  However, for each child relation
+		 * we add to the query, we must obtain an appropriate lock, because
+		 * this will be the first use of those relations in the
+		 * parse/rewrite/plan pipeline.  Child rels should use the same
+		 * lockmode as their parent.
+		 */
+		Assert(rte->rellockmode != NoLock);
+
+		if (rte->relkind == RELKIND_PARTITIONED_TABLE)
+			expand_partitioned_rtentry(root, rte, rti, rel);
+		else
+			expand_inherited_rtentry(root, rte, rti, rel);
 	}
 }
 
 /*
  * expand_inherited_rtentry
- *		Check whether a rangetable entry represents an inheritance set.
- *		If so, add entries for all the child tables to the query's
- *		rangetable, and build AppendRelInfo nodes for all the child tables
- *		and add them to root->append_rel_list.  If not, clear the entry's
- *		"inh" flag to prevent later code from looking for AppendRelInfos.
+ *		Add entries for all the child tables to the query's rangetable, and
+ *		build AppendRelInfo nodes for all the child tables and add them to
+ *		root->append_rel_list.
  *
  * Note that the original RTE is considered to represent the whole
  * inheritance set.  The first of the generated RTEs is an RTE for the same
@@ -1509,45 +1578,22 @@ expand_inherited_tables(PlannerInfo *root)
  * regular inheritance, a parent RTE must always have at least two associated
  * AppendRelInfos: one corresponding to the parent table as a simple member of
  * inheritance set and one or more corresponding to the actual children.
- * Since a partitioned table is not scanned, it might have only one associated
- * AppendRelInfo.
  */
 static void
-expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti)
+expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti,
+						 RelOptInfo *rel)
 {
 	Oid			parentOID;
 	PlanRowMark *oldrc;
-	Relation	oldrelation;
-	LOCKMODE	lockmode;
+	LOCKMODE	lockmode = rte->rellockmode;
 	List	   *inhOIDs;
 	ListCell   *l;
+	int			num_children;
+	int			num_children_added = 0;
 
-	/* Does RT entry allow inheritance? */
-	if (!rte->inh)
-		return;
-	/* Ignore any already-expanded UNION ALL nodes */
-	if (rte->rtekind != RTE_RELATION)
-	{
-		Assert(rte->rtekind == RTE_SUBQUERY);
-		return;
-	}
-	/* Fast path for common case of childless table */
+	Assert(rte->rtekind == RTE_RELATION);
+	Assert(lockmode != NoLock);
 	parentOID = rte->relid;
-	if (!has_subclass(parentOID))
-	{
-		/* Clear flag before returning */
-		rte->inh = false;
-		return;
-	}
-
-	/*
-	 * The rewriter should already have obtained an appropriate lock on each
-	 * relation named in the query.  However, for each child relation we add
-	 * to the query, we must obtain an appropriate lock, because this will be
-	 * the first use of those relations in the parse/rewrite/plan pipeline.
-	 * Child rels should use the same lockmode as their parent.
-	 */
-	lockmode = rte->rellockmode;
 
 	/* Scan for all members of inheritance set, acquire needed locks */
 	inhOIDs = find_all_inheritors(parentOID, lockmode, NULL);
@@ -1557,7 +1603,8 @@ expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti)
 	 * case.  This could happen despite above has_subclass() check, if table
 	 * once had a child but no longer does.
 	 */
-	if (list_length(inhOIDs) < 2)
+	num_children = list_length(inhOIDs);
+	if (num_children < 2)
 	{
 		/* Clear flag before returning */
 		rte->inh = false;
@@ -1565,277 +1612,246 @@ expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti)
 	}
 
 	/*
-	 * If parent relation is selected FOR UPDATE/SHARE, we need to mark its
-	 * PlanRowMark as isParent = true, and generate a new PlanRowMark for each
-	 * child.
+	 * If parent relation is selected FOR UPDATE/SHARE, preprocess_rowmarks
+	 * should've set isParent = true.  We'll generate a new PlanRowMark for
+	 * each child.
 	 */
 	oldrc = get_plan_rowmark(root->rowMarks, rti);
-	if (oldrc)
-		oldrc->isParent = true;
+	Assert(oldrc == NULL || oldrc->isParent);
 
 	/*
-	 * Must open the parent relation to examine its tupdesc.  We need not lock
-	 * it; we assume the rewriter already did.
+	 * Must expand PlannerInfo arrays by num_children before we can add
+	 * children.
 	 */
-	oldrelation = heap_open(parentOID, NoLock);
+	expand_planner_arrays(root, num_children);
 
-	/* Scan the inheritance set and expand it */
-	if (RelationGetPartitionDesc(oldrelation) != NULL)
+	foreach(l, inhOIDs)
 	{
-		Assert(rte->relkind == RELKIND_PARTITIONED_TABLE);
+		Oid			childOID = lfirst_oid(l);
+		Relation	newrelation;
+		RelOptInfo *childrel;
+
+		/* Already locked above. */
+		newrelation = heap_open(childOID, NoLock);
 
 		/*
-		 * If this table has partitions, recursively expand them in the order
-		 * in which they appear in the PartitionDesc.  While at it, also
-		 * extract the partition key columns of all the partitioned tables.
+		 * It is possible that the parent table has children that are temp
+		 * tables of other backends.  We cannot safely access such tables
+		 * (because of buffering issues), and the best thing to do seems
+		 * to be to silently ignore them.
 		 */
-		expand_partitioned_rtentry(root, rte, rti, oldrelation, oldrc,
-								   lockmode, &root->append_rel_list);
-	}
-	else
-	{
-		List	   *appinfos = NIL;
-		RangeTblEntry *childrte;
-		Index		childRTindex;
-
-		/*
-		 * This table has no partitions.  Expand any plain inheritance
-		 * children in the order the OIDs were returned by
-		 * find_all_inheritors.
-		 */
-		foreach(l, inhOIDs)
+		if (RELATION_IS_OTHER_TEMP(newrelation))
 		{
-			Oid			childOID = lfirst_oid(l);
-			Relation	newrelation;
-
-			/* Open rel if needed; we already have required locks */
-			if (childOID != parentOID)
-				newrelation = heap_open(childOID, NoLock);
-			else
-				newrelation = oldrelation;
-
-			/*
-			 * It is possible that the parent table has children that are temp
-			 * tables of other backends.  We cannot safely access such tables
-			 * (because of buffering issues), and the best thing to do seems
-			 * to be to silently ignore them.
-			 */
-			if (childOID != parentOID && RELATION_IS_OTHER_TEMP(newrelation))
-			{
-				heap_close(newrelation, lockmode);
-				continue;
-			}
-
-			expand_single_inheritance_child(root, rte, rti, oldrelation, oldrc,
-											newrelation,
-											&appinfos, &childrte,
-											&childRTindex);
-
-			/* Close child relations, but keep locks */
-			if (childOID != parentOID)
-				heap_close(newrelation, NoLock);
+			heap_close(newrelation, lockmode);
+			continue;
 		}
 
-		/*
-		 * If all the children were temp tables, pretend it's a
-		 * non-inheritance situation; we don't need Append node in that case.
-		 * The duplicate RTE we added for the parent table is harmless, so we
-		 * don't bother to get rid of it; ditto for the useless PlanRowMark
-		 * node.
-		 */
-		if (list_length(appinfos) < 2)
-			rte->inh = false;
-		else
-			root->append_rel_list = list_concat(root->append_rel_list,
-												appinfos);
+		childrel = add_inheritance_child_rel(root, rte, rti, rel, oldrc,
+											 newrelation);
+		Assert(childrel != NULL);
 
+		/* Close child relations, but keep locks */
+		heap_close(newrelation, NoLock);
+		num_children_added++;
 	}
 
-	heap_close(oldrelation, NoLock);
+	/*
+	 * If all children, including the parent (as child rel), were
+	 * excluded, mark the parent rel as empty.  If all the children were temp
+	 * tables, pretend it's a non-inheritance situation; we don't need Append
+	 * node in that case.  The duplicate RTE we added for the parent table is
+	 * harmless, so we don't bother to get rid of it; ditto for the useless
+	 * PlanRowMark node.
+	 */
+	if (num_children_added == 0)
+		mark_dummy_rel(rel);
+	else if (num_children_added == 1)
+		rte->inh = false;
+
+	/*
+	 * Add junk columns needed by the row mark if any and also add the
+	 * relevant expressions to the root parent's reltarget.
+	 */
+	if (oldrc)
+	{
+		List   *tlist = add_rowmark_junk_columns(root, oldrc);
+
+		build_base_rel_tlists(root, tlist);
+	}
 }
 
 /*
  * expand_partitioned_rtentry
- *		Recursively expand an RTE for a partitioned table.
+ *		Prunes unnecessary partitions of a partitioned table and adds
+ *		remaining ones to the Query and the PlannerInfo
  *
- * Note that RelationGetPartitionDispatchInfo will expand partitions in the
- * same order as this code.
+ * Partitions are added to the query in order in which they are found in
+ * the parent's PartitionDesc.
+ *
+ * Note: even though only the unpruned partitions will be added to the
+ * resulting plan, this still locks *all* partitions via find_all_inheritors
+ * in order to avoid partitions being locked in a different order than other
+ * places in the backend that may lock partitions.
  */
 static void
 expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
-						   Index parentRTindex, Relation parentrel,
-						   PlanRowMark *top_parentrc, LOCKMODE lockmode,
-						   List **appinfos)
+						   Index parentRTindex, RelOptInfo *parentrel)
 {
+	LOCKMODE	lockmode = parentrte->rellockmode;
+	PlanRowMark *rootrc = NULL;
 	int			i;
-	RangeTblEntry *childrte;
-	Index		childRTindex;
-	PartitionDesc partdesc = RelationGetPartitionDesc(parentrel);
+	Bitmapset  *partindexes;
+	Index		rootParentRTindex = parentrel->inh_root_parent > 0 ?
+									parentrel->inh_root_parent :
+									parentRTindex;
 
-	check_stack_depth();
-
-	/* A partitioned table should always have a partition descriptor. */
-	Assert(partdesc);
-
-	Assert(parentrte->inh);
+	/* If root partitioned table, lock *all* partitions in the tree. */
+	if (parentRTindex == rootParentRTindex)
+		(void) find_all_inheritors(parentrte->relid, lockmode, NULL);
 
 	/*
-	 * Note down whether any partition key cols are being updated. Though it's
-	 * the root partitioned table's updatedCols we are interested in, we
-	 * instead use parentrte to get the updatedCols. This is convenient
-	 * because parentrte already has the root partrel's updatedCols translated
-	 * to match the attribute ordering of parentrel.
+	 * Initialize partitioned_child_rels to contain this RT index.
+	 *
+	 * Note that during the set_append_rel_pathlist() phase, values of the
+	 * indexes of partitioned relations that appear down in the tree will be
+	 * bubbled up into root parent's list so that when we've created Paths for
+	 * all the children, the root table's list will contain all such indexes.
 	 */
-	if (!root->partColsUpdated)
-		root->partColsUpdated =
-			has_partition_attrs(parentrel, parentrte->updatedCols, NULL);
+	parentrel->partitioned_child_rels = list_make1_int(parentRTindex);
 
-	/* First expand the partitioned table itself. */
-	expand_single_inheritance_child(root, parentrte, parentRTindex, parentrel,
-									top_parentrc, parentrel,
-									appinfos, &childrte, &childRTindex);
+	/* Perform pruning. */
+	partindexes = prune_append_rel_partitions(parentrel);
+
+	/* Must expand PlannerInfo arrays before we can add children. */
+	expand_planner_arrays(root, bms_num_members(partindexes));
 
 	/*
-	 * If the partitioned table has no partitions, treat this as the
-	 * non-inheritance case.
+	 * For partitioned tables, we also store the partition RelOptInfo
+	 * pointers in the parent's RelOptInfo.
 	 */
-	if (partdesc->nparts == 0)
-	{
-		parentrte->inh = false;
-		return;
-	}
+	parentrel->part_rels = (RelOptInfo **) palloc0(sizeof(RelOptInfo *) *
+												   parentrel->nparts);
 
-	for (i = 0; i < partdesc->nparts; i++)
+	rootrc = get_plan_rowmark(root->rowMarks, rootParentRTindex);
+	Assert(rootrc == NULL || rootrc->isParent);
+	i = -1;
+	while ((i = bms_next_member(partindexes, i)) >= 0)
 	{
-		Oid			childOID = partdesc->oids[i];
-		Relation	childrel;
+		Oid		childOID = parentrel->part_oids[i];
+		Relation	newrelation;
+		RelOptInfo *childrel;
 
-		/* Open rel; we already have required locks */
-		childrel = heap_open(childOID, NoLock);
+		/* Already locked above. */
+		newrelation = heap_open(childOID, NoLock);
+		Assert(!RELATION_IS_OTHER_TEMP(newrelation));
 
 		/*
-		 * Temporary partitions belonging to other sessions should have been
-		 * disallowed at definition, but for paranoia's sake, let's double
-		 * check.
+		 * A partitioned child table with 0 children is a dummy rel, so don't
+		 * bother creating planner objects for it.
 		 */
-		if (RELATION_IS_OTHER_TEMP(childrel))
-			elog(ERROR, "temporary relation from another session found as partition");
+		if (newrelation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE &&
+			RelationGetPartitionDesc(newrelation)->nparts == 0)
+		{
+			heap_close(newrelation, NoLock);
+			continue;
+		}
 
-		expand_single_inheritance_child(root, parentrte, parentRTindex,
-										parentrel, top_parentrc, childrel,
-										appinfos, &childrte, &childRTindex);
+		childrel = add_inheritance_child_rel(root, parentrte, parentRTindex,
+											 parentrel, rootrc, newrelation);
+		Assert(childrel != NULL);
+		parentrel->part_rels[i] = childrel;
 
-		/* If this child is itself partitioned, recurse */
-		if (childrel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
-			expand_partitioned_rtentry(root, childrte, childRTindex,
-									   childrel, top_parentrc, lockmode,
-									   appinfos);
+		/* Close child relations, but keep locks */
+		heap_close(newrelation, NoLock);
+	}
 
-		/* Close child relation, but keep locks */
-		heap_close(childrel, NoLock);
+	/*
+	 * Add junk columns needed by the row mark if any and also add the
+	 * relevant expressions to the root parent's reltarget.
+	 */
+	if (rootrc)
+	{
+		List   *tlist = add_rowmark_junk_columns(root, rootrc);
+
+		build_base_rel_tlists(root, tlist);
 	}
 }
 
 /*
- * expand_single_inheritance_child
- *		Build a RangeTblEntry and an AppendRelInfo, if appropriate, plus
- *		maybe a PlanRowMark.
+ * add_inheritance_child_rel
+ *		Build a RangeTblEntry, an AppendRelInfo, a PlanRowMark, and finally
+ *		a RelOptInfo for an inheritance child relation.
  *
- * We now expand the partition hierarchy level by level, creating a
- * corresponding hierarchy of AppendRelInfos and RelOptInfos, where each
- * partitioned descendant acts as a parent of its immediate partitions.
- * (This is a difference from what older versions of PostgreSQL did and what
- * is still done in the case of table inheritance for unpartitioned tables,
- * where the hierarchy is flattened during RTE expansion.)
+ * The return value is the RelOptInfo that's added.
  *
  * PlanRowMarks still carry the top-parent's RTI, and the top-parent's
  * allMarkTypes field still accumulates values from all descendents.
  *
  * "parentrte" and "parentRTindex" are immediate parent's RTE and
  * RTI. "top_parentrc" is top parent's PlanRowMark.
- *
- * The child RangeTblEntry and its RTI are returned in "childrte_p" and
- * "childRTindex_p" resp.
  */
-static void
-expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte,
-								Index parentRTindex, Relation parentrel,
-								PlanRowMark *top_parentrc, Relation childrel,
-								List **appinfos, RangeTblEntry **childrte_p,
-								Index *childRTindex_p)
+static RelOptInfo *
+add_inheritance_child_rel(PlannerInfo *root, RangeTblEntry *parentrte,
+						  Index parentRTindex, RelOptInfo *parentrel,
+						  PlanRowMark *top_parentrc, Relation childrel)
 {
 	Query	   *parse = root->parse;
-	Oid			parentOID = RelationGetRelid(parentrel);
 	Oid			childOID = RelationGetRelid(childrel);
 	RangeTblEntry *childrte;
 	Index		childRTindex;
 	AppendRelInfo *appinfo;
+	RelOptInfo *childrelopt;
 
 	/*
 	 * Build an RTE for the child, and attach to query's rangetable list. We
 	 * copy most fields of the parent's RTE, but replace relation OID and
-	 * relkind, and set inh = false.  Also, set requiredPerms to zero since
-	 * all required permissions checks are done on the original RTE. Likewise,
-	 * set the child's securityQuals to empty, because we only want to apply
-	 * the parent's RLS conditions regardless of what RLS properties
+	 * relkind, and set inh appropriately.  Also, set requiredPerms to zero
+	 * since all required permissions checks are done on the original RTE.
+	 * Likewise, set the child's securityQuals to empty, because we only want
+	 * to apply the parent's RLS conditions regardless of what RLS properties
 	 * individual children may have.  (This is an intentional choice to make
 	 * inherited RLS work like regular permissions checks.) The parent
 	 * securityQuals will be propagated to children along with other base
 	 * restriction clauses, so we don't need to do it here.
 	 */
 	childrte = copyObject(parentrte);
-	*childrte_p = childrte;
 	childrte->relid = childOID;
 	childrte->relkind = childrel->rd_rel->relkind;
-	/* A partitioned child will need to be expanded further. */
-	if (childOID != parentOID &&
-		childrte->relkind == RELKIND_PARTITIONED_TABLE)
-		childrte->inh = true;
-	else
-		childrte->inh = false;
+	/*
+	 * A partitioned child will need to be expanded as an append parent
+	 * itself, so set its inh to true.
+	 */
+	childrte->inh = (childrte->relkind == RELKIND_PARTITIONED_TABLE);
 	childrte->requiredPerms = 0;
 	childrte->securityQuals = NIL;
 	parse->rtable = lappend(parse->rtable, childrte);
 	childRTindex = list_length(parse->rtable);
-	*childRTindex_p = childRTindex;
+
+	/* Create an AppendRelInfo and add it to planner's global list. */
+	appinfo = make_append_rel_info(parentrel, parentrte,
+								   childrel->rd_att,
+								   childOID,
+								   childrel->rd_rel->reltype,
+								   childRTindex);
+	root->append_rel_list = lappend(root->append_rel_list, appinfo);
 
 	/*
-	 * We need an AppendRelInfo if paths will be built for the child RTE. If
-	 * childrte->inh is true, then we'll always need to generate append paths
-	 * for it.  If childrte->inh is false, we must scan it if it's not a
-	 * partitioned table; but if it is a partitioned table, then it never has
-	 * any data of its own and need not be scanned.
+	 * Translate the column permissions bitmaps to the child's attnums (we
+	 * have to build the translated_vars list before we can do this). But
+	 * if this is the parent table, leave copyObject's result alone.
+	 *
+	 * Note: we need to do this even though the executor won't run any
+	 * permissions checks on the child RTE.  The insertedCols/updatedCols
+	 * bitmaps may be examined for trigger-firing purposes.
 	 */
-	if (childrte->relkind != RELKIND_PARTITIONED_TABLE || childrte->inh)
+	if (childrte->relid != parentrte->relid)
 	{
-		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->translated_vars);
-		appinfo->parent_reloid = parentOID;
-		*appinfos = lappend(*appinfos, appinfo);
-
-		/*
-		 * Translate the column permissions bitmaps to the child's attnums (we
-		 * have to build the translated_vars list before we can do this). But
-		 * if this is the parent table, leave copyObject's result alone.
-		 *
-		 * Note: we need to do this even though the executor won't run any
-		 * permissions checks on the child RTE.  The insertedCols/updatedCols
-		 * bitmaps may be examined for trigger-firing purposes.
-		 */
-		if (childOID != parentOID)
-		{
-			childrte->selectedCols = translate_col_privs(parentrte->selectedCols,
-														 appinfo->translated_vars);
-			childrte->insertedCols = translate_col_privs(parentrte->insertedCols,
-														 appinfo->translated_vars);
-			childrte->updatedCols = translate_col_privs(parentrte->updatedCols,
-														appinfo->translated_vars);
-		}
+		childrte->selectedCols = translate_col_privs(parentrte->selectedCols,
+													 appinfo->translated_vars);
+		childrte->insertedCols = translate_col_privs(parentrte->insertedCols,
+													 appinfo->translated_vars);
+		childrte->updatedCols = translate_col_privs(parentrte->updatedCols,
+													appinfo->translated_vars);
 	}
 
 	/*
@@ -1867,6 +1883,24 @@ expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte,
 
 		root->rowMarks = lappend(root->rowMarks, childrc);
 	}
+
+	/*
+	 * Add the RelOptInfo.  Even though we may not really scan this relation
+	 * for reasons such as contradictory quals, we still need need to create
+	 * one, because for every RTE in the query's range table, there must be an
+	 * accompanying RelOptInfo.
+	 */
+
+	/* First, store the RTE and appinfos into planner arrays. */
+	Assert(root->simple_rte_array[childRTindex] == NULL);
+	root->simple_rte_array[childRTindex] = childrte;
+	Assert(root->append_rel_array[childRTindex] == NULL);
+	root->append_rel_array[childRTindex] = appinfo;
+
+	childrelopt = build_append_child_rel(root, parentrel, childRTindex);
+	Assert(childrelopt != NULL);
+
+	return childrelopt;
 }
 
 /*
@@ -1877,14 +1911,11 @@ expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte,
  * For paranoia's sake, we match type/collation as well as attribute name.
  */
 static void
-make_inh_translation_list(Relation oldrelation, Relation newrelation,
-						  Index newvarno,
-						  List **translated_vars)
+make_inh_translation_list(TupleDesc old_tupdesc, TupleDesc new_tupdesc,
+						  Oid from_rel, Oid to_rel,
+						  Index newvarno, List **translated_vars)
 {
 	List	   *vars = NIL;
-	TupleDesc	old_tupdesc = RelationGetDescr(oldrelation);
-	TupleDesc	new_tupdesc = RelationGetDescr(newrelation);
-	Oid			new_relid = RelationGetRelid(newrelation);
 	int			oldnatts = old_tupdesc->natts;
 	int			newnatts = new_tupdesc->natts;
 	int			old_attno;
@@ -1914,7 +1945,7 @@ make_inh_translation_list(Relation oldrelation, Relation newrelation,
 		 * When we are generating the "translation list" for the parent table
 		 * of an inheritance set, no need to search for matches.
 		 */
-		if (oldrelation == newrelation)
+		if (from_rel == to_rel)
 		{
 			vars = lappend(vars, makeVar(newvarno,
 										 (AttrNumber) (old_attno + 1),
@@ -1940,10 +1971,10 @@ make_inh_translation_list(Relation oldrelation, Relation newrelation,
 		{
 			HeapTuple	newtup;
 
-			newtup = SearchSysCacheAttName(new_relid, attname);
+			newtup = SearchSysCacheAttName(to_rel, attname);
 			if (!newtup)
 				elog(ERROR, "could not find inherited attribute \"%s\" of relation \"%s\"",
-					 attname, RelationGetRelationName(newrelation));
+					 attname, get_rel_name(to_rel));
 			new_attno = ((Form_pg_attribute) GETSTRUCT(newtup))->attnum - 1;
 			ReleaseSysCache(newtup);
 
@@ -1953,10 +1984,10 @@ make_inh_translation_list(Relation oldrelation, Relation newrelation,
 		/* Found it, check type and collation match */
 		if (atttypid != att->atttypid || atttypmod != att->atttypmod)
 			elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's type",
-				 attname, RelationGetRelationName(newrelation));
+				 attname, get_rel_name(to_rel));
 		if (attcollation != att->attcollation)
 			elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's collation",
-				 attname, RelationGetRelationName(newrelation));
+				 attname, get_rel_name(to_rel));
 
 		vars = lappend(vars, makeVar(newvarno,
 									 (AttrNumber) (new_attno + 1),
@@ -2023,6 +2054,255 @@ translate_col_privs(const Bitmapset *parent_privs,
 }
 
 /*
+ *	build_append_child_rel
+ *		Build a RelOptInfo for child relation of an append rel
+ *
+ * After creating the RelOptInfo for the given child RT index, it goes on to
+ * initialize some of its fields base on the parent RelOptInfo.
+ *
+ * If the quals in baserestrictinfo turns out to be self-contradictory, the
+ * RelOptInfo is marked dummy before returning.
+ */
+static RelOptInfo *
+build_append_child_rel(PlannerInfo *root,
+					   RelOptInfo *parent,
+					   Index childRTindex)
+{
+	RelOptInfo *childrel;
+	RangeTblEntry *childRTE = root->simple_rte_array[childRTindex];
+	AppendRelInfo *appinfo = root->append_rel_array[childRTindex];
+	List	   *childquals;
+	ListCell   *lc;
+	bool		have_const_false_cq;
+	Index		cq_min_security;
+
+	/* Build the RelOptInfo. */
+	childrel = build_simple_rel(root, childRTindex, parent);
+
+	/*
+	 * Propagate lateral_relids and lateral_referencers from appendrel
+	 * parent rels to their child rels.  We intentionally give each child rel
+	 * the same minimum parameterization, even though it's quite possible that
+	 * some don't reference all the lateral rels.  This is because any append
+	 * path for the parent will have to have the same parameterization for
+	 * every child anyway, and there's no value in forcing extra
+	 * reparameterize_path() calls.  Similarly, a lateral reference to the
+	 * parent prevents use of otherwise-movable join rels for each child.
+	 */
+	childrel->direct_lateral_relids = parent->direct_lateral_relids;
+	childrel->lateral_relids = parent->lateral_relids;
+	childrel->lateral_referencers = parent->lateral_referencers;
+
+	/*
+	 * We have to copy the parent's quals to the child, with appropriate
+	 * substitution of variables.  However, only the baserestrictinfo
+	 * quals are needed before we can check for constraint exclusion; so
+	 * do that first and then check to see if we can disregard this child.
+	 *
+	 * The child rel's targetlist might contain non-Var expressions, which
+	 * means that substitution into the quals could produce opportunities
+	 * for const-simplification, and perhaps even pseudoconstant quals.
+	 * Therefore, transform each RestrictInfo separately to see if it
+	 * reduces to a constant or pseudoconstant.  (We must process them
+	 * separately to keep track of the security level of each qual.)
+	 */
+	childquals = false;
+	cq_min_security = UINT_MAX;
+	have_const_false_cq = false;
+	foreach(lc, parent->baserestrictinfo)
+	{
+		RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
+		Node	   *childqual = (Node *) rinfo->clause;
+		ListCell   *lc2;
+
+		Assert(IsA(rinfo, RestrictInfo));
+		childqual = adjust_appendrel_attrs(root, childqual,
+										   1, &appinfo);
+		childqual = eval_const_expressions(root, childqual);
+		/* check for flat-out constant */
+		if (childqual && IsA(childqual, Const))
+		{
+			if (((Const *) childqual)->constisnull ||
+				!DatumGetBool(((Const *) childqual)->constvalue))
+			{
+				/* Restriction reduces to constant FALSE or NULL */
+				have_const_false_cq = true;
+				break;
+			}
+			/* Restriction reduces to constant TRUE, so drop it */
+			continue;
+		}
+		/* might have gotten an AND clause, if so flatten it */
+		foreach(lc2, make_ands_implicit((Expr *) childqual))
+		{
+			Node	   *onecq = (Node *) lfirst(lc2);
+			bool		pseudoconstant;
+
+			/* check for pseudoconstant (no Vars or volatile functions) */
+			pseudoconstant =
+					!contain_vars_of_level(onecq, 0) &&
+					!contain_volatile_functions(onecq);
+			if (pseudoconstant)
+			{
+				/* tell createplan.c to check for gating quals */
+				root->hasPseudoConstantQuals = true;
+			}
+			/* reconstitute RestrictInfo with appropriate properties */
+			childquals = lappend(childquals,
+								 make_restrictinfo((Expr *) onecq,
+												   rinfo->is_pushed_down,
+												   rinfo->outerjoin_delayed,
+												   pseudoconstant,
+												   rinfo->security_level,
+												   NULL, NULL, NULL));
+			cq_min_security = Min(cq_min_security, rinfo->security_level);
+		}
+	}
+
+	/*
+	 * In addition to the quals inherited from the parent, we might
+	 * have securityQuals associated with this particular child node.
+	 * (Currently this can only happen in appendrels originating from
+	 * UNION ALL; inheritance child tables don't have their own
+	 * securityQuals.)	Pull any such securityQuals up into the
+	 * baserestrictinfo for the child.  This is similar to
+	 * process_security_barrier_quals() for the parent rel, except
+	 * that we can't make any general deductions from such quals,
+	 * since they don't hold for the whole appendrel.
+	 */
+	if (childRTE->securityQuals)
+	{
+		Index		security_level = 0;
+
+		foreach(lc, childRTE->securityQuals)
+		{
+			List	   *qualset = (List *) lfirst(lc);
+			ListCell   *lc2;
+
+			foreach(lc2, qualset)
+			{
+				Expr	   *qual = (Expr *) lfirst(lc2);
+
+				/*
+				 * not likely that we'd see constants here, so no
+				 * check
+				 */
+				childquals = lappend(childquals,
+									 make_restrictinfo(qual,
+													   true,
+													   false,
+													   false,
+													   security_level,
+													   NULL, NULL,
+													   NULL));
+				cq_min_security = Min(cq_min_security, security_level);
+			}
+			security_level++;
+		}
+		Assert(security_level <= root->qual_security_level);
+	}
+
+	/* Set child's version of baserestrictinfo. */
+	childrel->baserestrictinfo = childquals;
+	childrel->baserestrict_min_security = cq_min_security;
+
+	if (have_const_false_cq)
+	{
+		/*
+		 * Some restriction clause reduced to constant FALSE or NULL after
+		 * substitution, so this child need not be scanned.
+		 */
+		set_dummy_rel_pathlist(childrel);
+	}
+
+	return childrel;
+}
+
+/*
+ * add_rowmark_junk_columns
+ * 		Add necessary junk columns for rowmarked inheritance parent rel.
+ *
+ * These values are needed for locking of rels selected FOR UPDATE/SHARE, and
+ * to do EvalPlanQual rechecking.  See comments for PlanRowMark in
+ * plannodes.h.
+ */
+static List *
+add_rowmark_junk_columns(PlannerInfo *root, PlanRowMark *rc)
+{
+	List   *tlist = root->processed_tlist;
+	Var		   *var;
+	char		resname[32];
+	TargetEntry *tle;
+
+	if (rc->allMarkTypes & ~(1 << ROW_MARK_COPY))
+	{
+		/* Need to fetch TID */
+		var = makeVar(rc->rti,
+					  SelfItemPointerAttributeNumber,
+					  TIDOID,
+					  -1,
+					  InvalidOid,
+					  0);
+		snprintf(resname, sizeof(resname), "ctid%u", rc->rowmarkId);
+		tle = makeTargetEntry((Expr *) var,
+							  list_length(tlist) + 1,
+							  pstrdup(resname),
+							  true);
+		tlist = lappend(tlist, tle);
+	}
+	if (rc->allMarkTypes & (1 << ROW_MARK_COPY))
+	{
+		/* Need the whole row as a junk var */
+		var = makeWholeRowVar(root->simple_rte_array[rc->rti],
+							  rc->rti,
+							  0,
+							  false);
+		snprintf(resname, sizeof(resname), "wholerow%u", rc->rowmarkId);
+		tle = makeTargetEntry((Expr *) var,
+							  list_length(tlist) + 1,
+							  pstrdup(resname),
+							  true);
+		tlist = lappend(tlist, tle);
+	}
+
+	/* For inheritance cases, always fetch the tableoid too. */
+	var = makeVar(rc->rti,
+				  TableOidAttributeNumber,
+				  OIDOID,
+				  -1,
+				  InvalidOid,
+				  0);
+	snprintf(resname, sizeof(resname), "tableoid%u", rc->rowmarkId);
+	tle = makeTargetEntry((Expr *) var,
+						  list_length(tlist) + 1,
+						  pstrdup(resname),
+						  true);
+	tlist = lappend(tlist, tle);
+
+	return tlist;
+}
+
+AppendRelInfo *
+make_append_rel_info(RelOptInfo *parentrel, RangeTblEntry *parentrte,
+					 TupleDesc childdesc, Oid childoid, Oid childreltype,
+					 Index childRTindex)
+{
+	AppendRelInfo  *appinfo = makeNode(AppendRelInfo);
+
+	appinfo->parent_relid = parentrel->relid;
+	appinfo->child_relid = childRTindex;
+	appinfo->parent_reltype = parentrel->reltype;
+	appinfo->child_reltype = childreltype;
+	make_inh_translation_list(parentrel->tupdesc, childdesc,
+							  parentrte->relid, childoid,
+							  childRTindex,
+							  &appinfo->translated_vars);
+	appinfo->parent_reloid = parentrte->relid;
+
+	return appinfo;
+}
+
+/*
  * adjust_appendrel_attrs
  *	  Copy the specified query or expression and translate Vars referring to a
  *	  parent rel to refer to the corresponding child rel instead.  We also
diff --git a/src/backend/optimizer/util/Makefile b/src/backend/optimizer/util/Makefile
index c54d0a690d..da9ccf32b4 100644
--- a/src/backend/optimizer/util/Makefile
+++ b/src/backend/optimizer/util/Makefile
@@ -13,6 +13,6 @@ top_builddir = ../../../..
 include $(top_builddir)/src/Makefile.global
 
 OBJS = clauses.o joininfo.o orclauses.o pathnode.o placeholder.o \
-       plancat.o predtest.o relnode.o restrictinfo.o tlist.o var.o
+	   plancat.o predtest.o relnode.o restrictinfo.o tlist.o var.o
 
 include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/optimizer/util/plancat.c b/src/backend/optimizer/util/plancat.c
index ed0953f9e1..ce8a8fb78e 100644
--- a/src/backend/optimizer/util/plancat.c
+++ b/src/backend/optimizer/util/plancat.c
@@ -106,7 +106,7 @@ static void set_baserel_partition_key_exprs(Relation relation,
  */
 void
 get_relation_info(PlannerInfo *root, Oid relationObjectId, bool inhparent,
-				  RelOptInfo *rel)
+				  Bitmapset *updatedCols, RelOptInfo *rel)
 {
 	Index		varno = rel->relid;
 	Relation	relation;
@@ -444,11 +444,32 @@ get_relation_info(PlannerInfo *root, Oid relationObjectId, bool inhparent,
 	get_relation_foreign_keys(root, rel, relation, inhparent);
 
 	/*
-	 * Collect info about relation's partitioning scheme, if any. Only
-	 * inheritance parents may be partitioned.
+	 * Collect some additional information for inheritance parents.
 	 */
-	if (inhparent && relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
-		set_relation_partition_info(root, rel, relation);
+	if (inhparent)
+	{
+		/*
+		 * We'll need the TupleDesc when initializing the child relation.
+		 * A copy is being made because concurrent changes might drop
+		 * the relcache entry.  That's possible because ALTER TABLE
+		 * child_table NO INHERIT parent_table only requires an
+		 * AccessShareLock on parent_table.
+		 */
+		rel->tupdesc = CreateTupleDescCopy(RelationGetDescr(relation));
+		rel->reltype = RelationGetForm(relation)->reltype;
+
+		/*
+		 * If partitioned, also save the information of partitioning scheme,
+		 * and whether the query updates any of the partition key columns.
+		 */
+		if (relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
+		{
+			set_relation_partition_info(root, rel, relation);
+			if (!root->partColsUpdated)
+				root->partColsUpdated =
+					has_partition_attrs(relation, updatedCols, NULL);
+		}
+	}
 
 	heap_close(relation, NoLock);
 
@@ -1854,16 +1875,20 @@ set_relation_partition_info(PlannerInfo *root, RelOptInfo *rel,
 							Relation relation)
 {
 	PartitionDesc partdesc;
-	PartitionKey partkey;
 
 	Assert(relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE);
 
 	partdesc = RelationGetPartitionDesc(relation);
-	partkey = RelationGetPartitionKey(relation);
 	rel->part_scheme = find_partition_scheme(root, relation);
 	Assert(partdesc != NULL && rel->part_scheme != NULL);
-	rel->boundinfo = partition_bounds_copy(partdesc->boundinfo, partkey);
 	rel->nparts = partdesc->nparts;
+
+	/*
+	 * Since we must've taken a lock on the table, it's okay to simply copy
+	 * the pointers to relcache data here.
+	 */
+	rel->part_oids = partdesc->oids;
+	rel->boundinfo = partdesc->boundinfo;
 	set_baserel_partition_key_exprs(relation, rel);
 	rel->partition_qual = RelationGetPartitionQual(relation);
 }
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index 29ba19349f..c23db9d78d 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -130,6 +130,37 @@ setup_append_rel_array(PlannerInfo *root)
 	}
 }
 
+/* Expand the PlannerInfo arrays by add_size members and zero-init it. */
+void
+expand_planner_arrays(PlannerInfo *root, int add_size)
+{
+	int		new_size = root->simple_rel_array_size + add_size;
+
+	root->simple_rte_array = (RangeTblEntry **)
+							repalloc(root->simple_rte_array,
+									 sizeof(RangeTblEntry *) * new_size);
+	root->simple_rel_array = (RelOptInfo **)
+								repalloc(root->simple_rel_array,
+										 sizeof(RelOptInfo *) * new_size);
+	if (root->append_rel_array)
+		root->append_rel_array = (AppendRelInfo **)
+									repalloc(root->append_rel_array,
+									 sizeof(AppendRelInfo *) * new_size);
+	else
+		root->append_rel_array = (AppendRelInfo **)
+									palloc0(sizeof(AppendRelInfo *) *
+											new_size);
+
+	/* Set the contents of just allocated memory to 0. */
+	MemSet(root->simple_rte_array + root->simple_rel_array_size,
+		   0, sizeof(RangeTblEntry *) * add_size);
+	MemSet(root->simple_rel_array + root->simple_rel_array_size,
+		   0, sizeof(RelOptInfo *) * add_size);
+	MemSet(root->append_rel_array + root->simple_rel_array_size,
+		   0, sizeof(AppendRelInfo *) * add_size);
+	root->simple_rel_array_size = new_size;
+}
+
 /*
  * build_simple_rel
  *	  Construct a new RelOptInfo for a base relation or 'other' relation.
@@ -238,7 +269,8 @@ build_simple_rel(PlannerInfo *root, int relid, RelOptInfo *parent)
 	{
 		case RTE_RELATION:
 			/* Table --- retrieve statistics from the system catalogs */
-			get_relation_info(root, rte->relid, rte->inh, rel);
+			get_relation_info(root, rte->relid, rte->inh, rte->updatedCols,
+							  rel);
 			break;
 		case RTE_SUBQUERY:
 		case RTE_FUNCTION:
@@ -279,52 +311,6 @@ build_simple_rel(PlannerInfo *root, int relid, RelOptInfo *parent)
 		root->qual_security_level = Max(root->qual_security_level,
 										list_length(rte->securityQuals));
 
-	/*
-	 * If this rel is an appendrel parent, recurse to build "other rel"
-	 * RelOptInfos for its children.  They are "other rels" because they are
-	 * not in the main join tree, but we will need RelOptInfos to plan access
-	 * to them.
-	 */
-	if (rte->inh)
-	{
-		ListCell   *l;
-		int			nparts = rel->nparts;
-		int			cnt_parts = 0;
-
-		if (nparts > 0)
-			rel->part_rels = (RelOptInfo **)
-				palloc(sizeof(RelOptInfo *) * nparts);
-
-		foreach(l, root->append_rel_list)
-		{
-			AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(l);
-			RelOptInfo *childrel;
-
-			/* append_rel_list contains all append rels; ignore others */
-			if (appinfo->parent_relid != relid)
-				continue;
-
-			childrel = build_simple_rel(root, appinfo->child_relid,
-										rel);
-
-			/* Nothing more to do for an unpartitioned table. */
-			if (!rel->part_scheme)
-				continue;
-
-			/*
-			 * The order of partition OIDs in append_rel_list is the same as
-			 * the order in the PartitionDesc, so the order of part_rels will
-			 * also match the PartitionDesc.  See expand_partitioned_rtentry.
-			 */
-			Assert(cnt_parts < nparts);
-			rel->part_rels[cnt_parts] = childrel;
-			cnt_parts++;
-		}
-
-		/* We should have seen all the child partitions. */
-		Assert(cnt_parts == nparts);
-	}
-
 	return rel;
 }
 
diff --git a/src/backend/partitioning/partprune.c b/src/backend/partitioning/partprune.c
index d6ca03de4a..bf17ae22ba 100644
--- a/src/backend/partitioning/partprune.c
+++ b/src/backend/partitioning/partprune.c
@@ -45,6 +45,7 @@
 #include "nodes/makefuncs.h"
 #include "nodes/nodeFuncs.h"
 #include "optimizer/clauses.h"
+#include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
 #include "optimizer/planner.h"
 #include "optimizer/predtest.h"
@@ -436,17 +437,23 @@ make_partitionedrel_pruneinfo(PlannerInfo *root, RelOptInfo *parentrel,
 		 * is, not pruned already).
 		 */
 		subplan_map = (int *) palloc(nparts * sizeof(int));
+		memset(subplan_map, -1, nparts * sizeof(int));
 		subpart_map = (int *) palloc(nparts * sizeof(int));
+		memset(subpart_map, -1, nparts * sizeof(int));
 		present_parts = NULL;
 
 		for (i = 0; i < nparts; i++)
 		{
 			RelOptInfo *partrel = subpart->part_rels[i];
-			int			subplanidx = relid_subplan_map[partrel->relid] - 1;
-			int			subpartidx = relid_subpart_map[partrel->relid] - 1;
+			int			subplanidx;
+			int			subpartidx;
 
-			subplan_map[i] = subplanidx;
-			subpart_map[i] = subpartidx;
+			/* Skip processing pruned partitions. */
+			if (partrel == NULL)
+				continue;
+
+			subplan_map[i] = subplanidx = relid_subplan_map[partrel->relid] - 1;
+			subpart_map[i] = subpartidx = relid_subpart_map[partrel->relid] - 1;
 			if (subplanidx >= 0)
 			{
 				present_parts = bms_add_member(present_parts, i);
@@ -540,23 +547,20 @@ gen_partprune_steps(RelOptInfo *rel, List *clauses, bool *contradictory)
 
 /*
  * prune_append_rel_partitions
- *		Returns RT indexes of the minimum set of child partitions which must
- *		be scanned to satisfy rel's baserestrictinfo quals.
+ *		Returns indexes into rel->part_rels of the minimum set of child
+ *		partitions which must be scanned to satisfy rel's baserestrictinfo
+ *		quals.
  *
  * Callers must ensure that 'rel' is a partitioned table.
  */
-Relids
+Bitmapset *
 prune_append_rel_partitions(RelOptInfo *rel)
 {
-	Relids		result;
 	List	   *clauses = rel->baserestrictinfo;
 	List	   *pruning_steps;
 	bool		contradictory;
 	PartitionPruneContext context;
-	Bitmapset  *partindexes;
-	int			i;
 
-	Assert(clauses != NIL);
 	Assert(rel->part_scheme != NULL);
 
 	/* If there are no partitions, return the empty set */
@@ -564,6 +568,13 @@ prune_append_rel_partitions(RelOptInfo *rel)
 		return NULL;
 
 	/*
+	 * If pruning is disabled or if there are no clauses to prune with,
+	 * return all partitions.
+	 */
+	if (!enable_partition_pruning || clauses == NIL)
+		return bms_add_range(NULL, 0, rel->nparts - 1);
+
+	/*
 	 * Process clauses.  If the clauses are found to be contradictory, we can
 	 * return the empty set.
 	 */
@@ -590,15 +601,7 @@ prune_append_rel_partitions(RelOptInfo *rel)
 	context.evalexecparams = false;
 
 	/* Actual pruning happens here. */
-	partindexes = get_matching_partitions(&context, pruning_steps);
-
-	/* Add selected partitions' RT indexes to result. */
-	i = -1;
-	result = NULL;
-	while ((i = bms_next_member(partindexes, i)) >= 0)
-		result = bms_add_member(result, rel->part_rels[i]->relid);
-
-	return result;
+	return get_matching_partitions(&context, pruning_steps);
 }
 
 /*
diff --git a/src/include/nodes/relation.h b/src/include/nodes/relation.h
index 29339d6c72..6b614e4794 100644
--- a/src/include/nodes/relation.h
+++ b/src/include/nodes/relation.h
@@ -15,6 +15,7 @@
 #define RELATION_H
 
 #include "access/sdir.h"
+#include "access/tupdesc.h"
 #include "fmgr.h"
 #include "lib/stringinfo.h"
 #include "nodes/params.h"
@@ -710,6 +711,7 @@ typedef struct RelOptInfo
 	int			nparts;			/* number of partitions */
 	struct PartitionBoundInfoData *boundinfo;	/* Partition bounds */
 	List	   *partition_qual; /* partition constraint */
+	Oid		   *part_oids;		/* partition OIDs */
 	struct RelOptInfo **part_rels;	/* Array of RelOptInfos of partitions,
 									 * stored in the same order of bounds */
 	List	  **partexprs;		/* Non-nullable partition key expressions. */
@@ -719,6 +721,12 @@ typedef struct RelOptInfo
 	Index		inh_root_parent;	/* For otherrels, this is the RT index of
 									 * inheritance table mentioned in the query
 									 * from which this relation originated */
+	/*
+	 * Set only if this is an inheritance parent relation.  This information
+	 * is needed when initializing the planning info for children.
+	 */
+	TupleDesc	tupdesc;		/* A "copy" of the table's tuple desriptor */
+	Oid			reltype;		/* Table's reltype */
 } RelOptInfo;
 
 /*
diff --git a/src/include/optimizer/pathnode.h b/src/include/optimizer/pathnode.h
index 81abcf53a8..b1baa3117a 100644
--- a/src/include/optimizer/pathnode.h
+++ b/src/include/optimizer/pathnode.h
@@ -261,6 +261,7 @@ extern Path *reparameterize_path_by_child(PlannerInfo *root, Path *path,
  */
 extern void setup_simple_rel_arrays(PlannerInfo *root);
 extern void setup_append_rel_array(PlannerInfo *root);
+extern void expand_planner_arrays(PlannerInfo *root, int add_size);
 extern RelOptInfo *build_simple_rel(PlannerInfo *root, int relid,
 				 RelOptInfo *parent);
 extern RelOptInfo *find_base_rel(PlannerInfo *root, int relid);
diff --git a/src/include/optimizer/plancat.h b/src/include/optimizer/plancat.h
index 7d53cbbb87..edaf2a3b4f 100644
--- a/src/include/optimizer/plancat.h
+++ b/src/include/optimizer/plancat.h
@@ -26,7 +26,7 @@ extern PGDLLIMPORT get_relation_info_hook_type get_relation_info_hook;
 
 
 extern void get_relation_info(PlannerInfo *root, Oid relationObjectId,
-				  bool inhparent, RelOptInfo *rel);
+				  bool inhparent, Bitmapset *updatedCols, RelOptInfo *rel);
 
 extern List *infer_arbiter_indexes(PlannerInfo *root);
 
diff --git a/src/include/optimizer/prep.h b/src/include/optimizer/prep.h
index 38608770a2..e8e21e2ed5 100644
--- a/src/include/optimizer/prep.h
+++ b/src/include/optimizer/prep.h
@@ -38,7 +38,7 @@ extern Expr *canonicalize_qual(Expr *qual, bool is_check);
 /*
  * prototypes for preptlist.c
  */
-extern List *preprocess_targetlist(PlannerInfo *root);
+extern List *preprocess_targetlist(PlannerInfo *root, bool inheritance_update);
 
 extern PlanRowMark *get_plan_rowmark(List *rowmarks, Index rtindex);
 
@@ -46,12 +46,16 @@ extern PlanRowMark *get_plan_rowmark(List *rowmarks, Index rtindex);
  * prototypes for prepunion.c
  */
 extern RelOptInfo *plan_set_operations(PlannerInfo *root);
-
-extern void expand_inherited_tables(PlannerInfo *root);
-
+extern void expand_append_rel(PlannerInfo *root,
+						 RelOptInfo *rel,
+						 RangeTblEntry *rte,
+						 Index rti);
 extern Node *adjust_appendrel_attrs(PlannerInfo *root, Node *node,
 					   int nappinfos, AppendRelInfo **appinfos);
-
+extern AppendRelInfo *make_append_rel_info(RelOptInfo *parentrel,
+					 RangeTblEntry *parentrte,
+					 TupleDesc childdesc, Oid childoid, Oid childreltype,
+					 Index childRTindex);
 extern Node *adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node,
 								  Relids child_relids,
 								  Relids top_parent_relids);
@@ -64,5 +68,4 @@ extern SpecialJoinInfo *build_child_join_sjinfo(PlannerInfo *root,
 						Relids left_relids, Relids right_relids);
 extern Relids adjust_child_relids_multilevel(PlannerInfo *root, Relids relids,
 							   Relids child_relids, Relids top_parent_relids);
-
 #endif							/* PREP_H */
diff --git a/src/include/partitioning/partprune.h b/src/include/partitioning/partprune.h
index e07aaaf798..ac0a979010 100644
--- a/src/include/partitioning/partprune.h
+++ b/src/include/partitioning/partprune.h
@@ -76,7 +76,7 @@ extern PartitionPruneInfo *make_partition_pruneinfo(PlannerInfo *root,
 						 List *subpaths,
 						 List *partitioned_rels,
 						 List *prunequal);
-extern Relids prune_append_rel_partitions(RelOptInfo *rel);
+extern Bitmapset *prune_append_rel_partitions(RelOptInfo *rel);
 extern Bitmapset *get_matching_partitions(PartitionPruneContext *context,
 						List *pruning_steps);
 
diff --git a/src/test/regress/expected/join.out b/src/test/regress/expected/join.out
index 1f5378080d..73f684f992 100644
--- a/src/test/regress/expected/join.out
+++ b/src/test/regress/expected/join.out
@@ -5547,29 +5547,29 @@ select t1.b, ss.phv from join_ut1 t1 left join lateral
               (select t2.a as t2a, t3.a t3a, least(t1.a, t2.a, t3.a) phv
 					  from join_pt1 t2 join join_ut1 t3 on t2.a = t3.b) ss
               on t1.a = ss.t2a order by t1.a;
-                            QUERY PLAN                            
-------------------------------------------------------------------
+                             QUERY PLAN                             
+--------------------------------------------------------------------
  Sort
-   Output: t1.b, (LEAST(t1.a, t2.a, t3.a)), t1.a
+   Output: t1.b, (LEAST(t1.a, t2_1.a, t3.a)), t1.a
    Sort Key: t1.a
    ->  Nested Loop Left Join
-         Output: t1.b, (LEAST(t1.a, t2.a, t3.a)), t1.a
+         Output: t1.b, (LEAST(t1.a, t2_1.a, t3.a)), t1.a
          ->  Seq Scan on public.join_ut1 t1
                Output: t1.a, t1.b, t1.c
          ->  Hash Join
-               Output: t2.a, LEAST(t1.a, t2.a, t3.a)
-               Hash Cond: (t3.b = t2.a)
+               Output: t2_1.a, LEAST(t1.a, t2_1.a, t3.a)
+               Hash Cond: (t3.b = t2_1.a)
                ->  Seq Scan on public.join_ut1 t3
                      Output: t3.a, t3.b, t3.c
                ->  Hash
-                     Output: t2.a
+                     Output: t2_1.a
                      ->  Append
-                           ->  Seq Scan on public.join_pt1p1p1 t2
-                                 Output: t2.a
-                                 Filter: (t1.a = t2.a)
-                           ->  Seq Scan on public.join_pt1p2 t2_1
+                           ->  Seq Scan on public.join_pt1p1p1 t2_1
                                  Output: t2_1.a
                                  Filter: (t1.a = t2_1.a)
+                           ->  Seq Scan on public.join_pt1p2 t2
+                                 Output: t2.a
+                                 Filter: (t1.a = t2.a)
 (21 rows)
 
 select t1.b, ss.phv from join_ut1 t1 left join lateral
diff --git a/src/test/regress/expected/partition_aggregate.out b/src/test/regress/expected/partition_aggregate.out
index 6bc106831e..1450cef057 100644
--- a/src/test/regress/expected/partition_aggregate.out
+++ b/src/test/regress/expected/partition_aggregate.out
@@ -144,7 +144,7 @@ SELECT c, sum(a) FROM pagg_tab WHERE 1 = 2 GROUP BY c;
            QUERY PLAN           
 --------------------------------
  HashAggregate
-   Group Key: pagg_tab.c
+   Group Key: c
    ->  Result
          One-Time Filter: false
 (4 rows)
@@ -159,7 +159,7 @@ SELECT c, sum(a) FROM pagg_tab WHERE c = 'x' GROUP BY c;
            QUERY PLAN           
 --------------------------------
  GroupAggregate
-   Group Key: pagg_tab.c
+   Group Key: c
    ->  Result
          One-Time Filter: false
 (4 rows)
-- 
2.11.0

From 68c565448b11e4c1294411b1841a6d527bdb9726 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Wed, 7 Nov 2018 16:51:31 +0900
Subject: [PATCH v5 4/6] Move append expansion code into its own file

This commit moves expand_append_rel and underlings to
optimizer/utils/append.c.

Also, all of the AppendRelInfo based
expression manipulation routines are moved to
optimizer/utils/appendinfo.c.

This commit only moves the code and contains no functional changes.
---
 src/backend/optimizer/path/allpaths.c   |    2 +
 src/backend/optimizer/path/equivclass.c |    1 +
 src/backend/optimizer/path/joinrels.c   |    1 +
 src/backend/optimizer/plan/planner.c    |    1 +
 src/backend/optimizer/prep/prepunion.c  | 1516 -------------------------------
 src/backend/optimizer/util/Makefile     |    5 +-
 src/backend/optimizer/util/append.c     |  719 +++++++++++++++
 src/backend/optimizer/util/appendinfo.c |  851 +++++++++++++++++
 src/backend/optimizer/util/pathnode.c   |    1 +
 src/backend/optimizer/util/relnode.c    |    1 +
 src/backend/partitioning/partprune.c    |    1 +
 src/include/optimizer/append.h          |   28 +
 src/include/optimizer/appendinfo.h      |   43 +
 src/include/optimizer/prep.h            |   21 -
 14 files changed, 1652 insertions(+), 1539 deletions(-)
 create mode 100644 src/backend/optimizer/util/append.c
 create mode 100644 src/backend/optimizer/util/appendinfo.c
 create mode 100644 src/include/optimizer/append.h
 create mode 100644 src/include/optimizer/appendinfo.h

diff --git a/src/backend/optimizer/path/allpaths.c b/src/backend/optimizer/path/allpaths.c
index 6ee800d84a..0d051681e6 100644
--- a/src/backend/optimizer/path/allpaths.c
+++ b/src/backend/optimizer/path/allpaths.c
@@ -30,6 +30,8 @@
 #ifdef OPTIMIZER_DEBUG
 #include "nodes/print.h"
 #endif
+#include "optimizer/append.h"
+#include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/geqo.h"
diff --git a/src/backend/optimizer/path/equivclass.c b/src/backend/optimizer/path/equivclass.c
index b22b36ec0e..5ace28eab0 100644
--- a/src/backend/optimizer/path/equivclass.c
+++ b/src/backend/optimizer/path/equivclass.c
@@ -22,6 +22,7 @@
 #include "catalog/pg_type.h"
 #include "nodes/makefuncs.h"
 #include "nodes/nodeFuncs.h"
+#include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
 #include "optimizer/pathnode.h"
 #include "optimizer/paths.h"
diff --git a/src/backend/optimizer/path/joinrels.c b/src/backend/optimizer/path/joinrels.c
index da0831de4e..6e321ec9e7 100644
--- a/src/backend/optimizer/path/joinrels.c
+++ b/src/backend/optimizer/path/joinrels.c
@@ -15,6 +15,7 @@
 #include "postgres.h"
 
 #include "miscadmin.h"
+#include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
 #include "optimizer/joininfo.h"
 #include "optimizer/pathnode.h"
diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index 84746a9bc9..216cadfba9 100644
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -39,6 +39,7 @@
 #include "nodes/print.h"
 #endif
 #include "nodes/relation.h"
+#include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
diff --git a/src/backend/optimizer/prep/prepunion.c b/src/backend/optimizer/prep/prepunion.c
index c6817757e7..70f37c593f 100644
--- a/src/backend/optimizer/prep/prepunion.c
+++ b/src/backend/optimizer/prep/prepunion.c
@@ -12,11 +12,6 @@
  * case, but most of the heavy lifting for that is done elsewhere,
  * notably in prepjointree.c and allpaths.c.
  *
- * There is also some code here to support planning of queries that use
- * inheritance (SELECT FROM foo*).  Inheritance trees are converted into
- * append relations, and thenceforth share code with the UNION ALL case.
- *
- *
  * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
@@ -39,32 +34,21 @@
 #include "miscadmin.h"
 #include "nodes/makefuncs.h"
 #include "nodes/nodeFuncs.h"
-#include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
 #include "optimizer/paths.h"
 #include "optimizer/planmain.h"
 #include "optimizer/planner.h"
 #include "optimizer/prep.h"
-#include "optimizer/restrictinfo.h"
 #include "optimizer/tlist.h"
-#include "optimizer/var.h"
 #include "parser/parse_coerce.h"
 #include "parser/parsetree.h"
-#include "partitioning/partprune.h"
 #include "utils/lsyscache.h"
 #include "utils/rel.h"
 #include "utils/selfuncs.h"
 #include "utils/syscache.h"
 
 
-typedef struct
-{
-	PlannerInfo *root;
-	int			nappinfos;
-	AppendRelInfo **appinfos;
-} adjust_appendrel_attrs_context;
-
 static RelOptInfo *recurse_set_operations(Node *setOp, PlannerInfo *root,
 					   List *colTypes, List *colCollations,
 					   bool junkOK,
@@ -103,31 +87,6 @@ static List *generate_append_tlist(List *colTypes, List *colCollations,
 					  List *input_tlists,
 					  List *refnames_tlist);
 static List *generate_setop_grouplist(SetOperationStmt *op, List *targetlist);
-static void expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte,
-						 Index rti, RelOptInfo *rel);
-static void expand_partitioned_rtentry(PlannerInfo *root,
-						   RangeTblEntry *parentrte,
-						   Index parentRTindex, RelOptInfo *parentrel);
-static RelOptInfo *add_inheritance_child_rel(PlannerInfo *root,
-						  RangeTblEntry *parentrte,
-						  Index parentRTindex, RelOptInfo *parentrel,
-						  PlanRowMark *top_parentrc, Relation childrel);
-static void make_inh_translation_list(TupleDesc old_tupdesc,
-						  TupleDesc new_tupdesc,
-						  Oid from_rel, Oid to_rel,
-						  Index newvarno, List **translated_vars);
-static RelOptInfo *build_append_child_rel(PlannerInfo *root,
-					   RelOptInfo *parent,
-					   Index childRTindex);
-static List *add_rowmark_junk_columns(PlannerInfo *root, PlanRowMark *rc);
-static Bitmapset *translate_col_privs(const Bitmapset *parent_privs,
-					List *translated_vars);
-static Node *adjust_appendrel_attrs_mutator(Node *node,
-							   adjust_appendrel_attrs_context *context);
-static Relids adjust_child_relids(Relids relids, int nappinfos,
-					AppendRelInfo **appinfos);
-static List *adjust_inherited_tlist(List *tlist,
-					   AppendRelInfo *context);
 
 
 /*
@@ -1464,1478 +1423,3 @@ generate_setop_grouplist(SetOperationStmt *op, List *targetlist)
 	Assert(lg == NULL);
 	return grouplist;
 }
-
-
-/*
- * expand_append_rel
- *		This initializes RelOptInfos for an appendrel's child relations.
- *
- * 'rel' is the appendrel parent, whose range table entry ('rte') has been
- * marked to require adding children.  An appendrel parent could either
- * be a subquery (if we flattened UNION ALL query) or a table that's known
- * to have inheritance children.  The latter consists of both regular
- * inheritance parents and partitioned tables.
- *
- * For a subquery parent, there is not much to be done here because the
- * children's RTEs are already present in the query, so we just initialize
- * RelOptInfos for them.  Also, the AppendRelInfos for child subqueries
- * have already been added.
- *
- * For tables, we need to add the children to the range table and initialize
- * AppendRelInfos, RelOptInfos, and PlanRowMarks (if any) for them.  For
- * a partitioned parent, we only add the children remaining after pruning.
- * For regular inheritance parents, we find the children using
- * find_all_inheritors and add all of them.
- *
- * If it turns out that there are no children, then we set rte->inh to false
- * to let the caller know that only the parent table needs to be scanned.  The
- * caller can accordingly switch to a non-Append path.  For a partitioned
- * parent, that means an empty relation because parents themselves contain no
- * data.
- *
- * For the regular inheritance case, the parent also gets another RTE with
- * inh = false to represent it as an appendrel child.  The original RTE is
- * considered to represent the whole inheritance set.
- */
-void
-expand_append_rel(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte,
-				  Index rti)
-{
-	Assert(rte->inh);
-	/* Inheritance parent (partitioned or not) or UNION ALL parent subquery. */
-	Assert(rte->rtekind == RTE_RELATION || rte->rtekind == RTE_SUBQUERY);
-
-	/*
-	 * UNION ALL children already got RTEs and AppendRelInfos, so just build
-	 * RelOptInfos and return.
-	 *
-	 * It might be a bit odd that this code is in this, because there is
-	 * nothing to expand really.
-	 */
-	if (rte->rtekind == RTE_SUBQUERY)
-	{
-		ListCell   *l;
-
-		/*
-		 * We don't need to use expand_planner_arrays in this case, because
-		 * no new child RTEs are created.  setup_simple_rel_arrays() and
-		 * setup_append_rel_array would've considered these child RTEs when
-		 * allocating space for various arrays.
-		 */
-		foreach(l, root->append_rel_list)
-		{
-			AppendRelInfo *appinfo = lfirst(l);
-			Index		childRTindex = appinfo->child_relid;
-
-			if (appinfo->parent_relid != rti)
-				continue;
-
-			Assert(childRTindex < root->simple_rel_array_size);
-			Assert(root->simple_rte_array[childRTindex] != NULL);
-
-			/*
-			 * We set the correct value of baserestricinfo and
-			 * baserestrict_min_security below.
-			 */
-			root->simple_rel_array[childRTindex] =
-				build_append_child_rel(root, rel, appinfo->child_relid);
-		}
-	}
-	else
-	{
-		Assert(rte->rtekind == RTE_RELATION);
-		Assert(has_subclass(rte->relid));
-
-		/*
-		 * The rewriter should already have obtained an appropriate lock on
-		 * each relation named in the query.  However, for each child relation
-		 * we add to the query, we must obtain an appropriate lock, because
-		 * this will be the first use of those relations in the
-		 * parse/rewrite/plan pipeline.  Child rels should use the same
-		 * lockmode as their parent.
-		 */
-		Assert(rte->rellockmode != NoLock);
-
-		if (rte->relkind == RELKIND_PARTITIONED_TABLE)
-			expand_partitioned_rtentry(root, rte, rti, rel);
-		else
-			expand_inherited_rtentry(root, rte, rti, rel);
-	}
-}
-
-/*
- * expand_inherited_rtentry
- *		Add entries for all the child tables to the query's rangetable, and
- *		build AppendRelInfo nodes for all the child tables and add them to
- *		root->append_rel_list.
- *
- * Note that the original RTE is considered to represent the whole
- * inheritance set.  The first of the generated RTEs is an RTE for the same
- * table, but with inh = false, to represent the parent table in its role
- * as a simple member of the inheritance set.
- *
- * A childless table is never considered to be an inheritance set. For
- * regular inheritance, a parent RTE must always have at least two associated
- * AppendRelInfos: one corresponding to the parent table as a simple member of
- * inheritance set and one or more corresponding to the actual children.
- */
-static void
-expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti,
-						 RelOptInfo *rel)
-{
-	Oid			parentOID;
-	PlanRowMark *oldrc;
-	LOCKMODE	lockmode = rte->rellockmode;
-	List	   *inhOIDs;
-	ListCell   *l;
-	int			num_children;
-	int			num_children_added = 0;
-
-	Assert(rte->rtekind == RTE_RELATION);
-	Assert(lockmode != NoLock);
-	parentOID = rte->relid;
-
-	/* Scan for all members of inheritance set, acquire needed locks */
-	inhOIDs = find_all_inheritors(parentOID, lockmode, NULL);
-
-	/*
-	 * Check that there's at least one descendant, else treat as no-child
-	 * case.  This could happen despite above has_subclass() check, if table
-	 * once had a child but no longer does.
-	 */
-	num_children = list_length(inhOIDs);
-	if (num_children < 2)
-	{
-		/* Clear flag before returning */
-		rte->inh = false;
-		return;
-	}
-
-	/*
-	 * If parent relation is selected FOR UPDATE/SHARE, preprocess_rowmarks
-	 * should've set isParent = true.  We'll generate a new PlanRowMark for
-	 * each child.
-	 */
-	oldrc = get_plan_rowmark(root->rowMarks, rti);
-	Assert(oldrc == NULL || oldrc->isParent);
-
-	/*
-	 * Must expand PlannerInfo arrays by num_children before we can add
-	 * children.
-	 */
-	expand_planner_arrays(root, num_children);
-
-	foreach(l, inhOIDs)
-	{
-		Oid			childOID = lfirst_oid(l);
-		Relation	newrelation;
-		RelOptInfo *childrel;
-
-		/* Already locked above. */
-		newrelation = heap_open(childOID, NoLock);
-
-		/*
-		 * It is possible that the parent table has children that are temp
-		 * tables of other backends.  We cannot safely access such tables
-		 * (because of buffering issues), and the best thing to do seems
-		 * to be to silently ignore them.
-		 */
-		if (RELATION_IS_OTHER_TEMP(newrelation))
-		{
-			heap_close(newrelation, lockmode);
-			continue;
-		}
-
-		childrel = add_inheritance_child_rel(root, rte, rti, rel, oldrc,
-											 newrelation);
-		Assert(childrel != NULL);
-
-		/* Close child relations, but keep locks */
-		heap_close(newrelation, NoLock);
-		num_children_added++;
-	}
-
-	/*
-	 * If all children, including the parent (as child rel), were
-	 * excluded, mark the parent rel as empty.  If all the children were temp
-	 * tables, pretend it's a non-inheritance situation; we don't need Append
-	 * node in that case.  The duplicate RTE we added for the parent table is
-	 * harmless, so we don't bother to get rid of it; ditto for the useless
-	 * PlanRowMark node.
-	 */
-	if (num_children_added == 0)
-		mark_dummy_rel(rel);
-	else if (num_children_added == 1)
-		rte->inh = false;
-
-	/*
-	 * Add junk columns needed by the row mark if any and also add the
-	 * relevant expressions to the root parent's reltarget.
-	 */
-	if (oldrc)
-	{
-		List   *tlist = add_rowmark_junk_columns(root, oldrc);
-
-		build_base_rel_tlists(root, tlist);
-	}
-}
-
-/*
- * expand_partitioned_rtentry
- *		Prunes unnecessary partitions of a partitioned table and adds
- *		remaining ones to the Query and the PlannerInfo
- *
- * Partitions are added to the query in order in which they are found in
- * the parent's PartitionDesc.
- *
- * Note: even though only the unpruned partitions will be added to the
- * resulting plan, this still locks *all* partitions via find_all_inheritors
- * in order to avoid partitions being locked in a different order than other
- * places in the backend that may lock partitions.
- */
-static void
-expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
-						   Index parentRTindex, RelOptInfo *parentrel)
-{
-	LOCKMODE	lockmode = parentrte->rellockmode;
-	PlanRowMark *rootrc = NULL;
-	int			i;
-	Bitmapset  *partindexes;
-	Index		rootParentRTindex = parentrel->inh_root_parent > 0 ?
-									parentrel->inh_root_parent :
-									parentRTindex;
-
-	/* If root partitioned table, lock *all* partitions in the tree. */
-	if (parentRTindex == rootParentRTindex)
-		(void) find_all_inheritors(parentrte->relid, lockmode, NULL);
-
-	/*
-	 * Initialize partitioned_child_rels to contain this RT index.
-	 *
-	 * Note that during the set_append_rel_pathlist() phase, values of the
-	 * indexes of partitioned relations that appear down in the tree will be
-	 * bubbled up into root parent's list so that when we've created Paths for
-	 * all the children, the root table's list will contain all such indexes.
-	 */
-	parentrel->partitioned_child_rels = list_make1_int(parentRTindex);
-
-	/* Perform pruning. */
-	partindexes = prune_append_rel_partitions(parentrel);
-
-	/* Must expand PlannerInfo arrays before we can add children. */
-	expand_planner_arrays(root, bms_num_members(partindexes));
-
-	/*
-	 * For partitioned tables, we also store the partition RelOptInfo
-	 * pointers in the parent's RelOptInfo.
-	 */
-	parentrel->part_rels = (RelOptInfo **) palloc0(sizeof(RelOptInfo *) *
-												   parentrel->nparts);
-
-	rootrc = get_plan_rowmark(root->rowMarks, rootParentRTindex);
-	Assert(rootrc == NULL || rootrc->isParent);
-	i = -1;
-	while ((i = bms_next_member(partindexes, i)) >= 0)
-	{
-		Oid		childOID = parentrel->part_oids[i];
-		Relation	newrelation;
-		RelOptInfo *childrel;
-
-		/* Already locked above. */
-		newrelation = heap_open(childOID, NoLock);
-		Assert(!RELATION_IS_OTHER_TEMP(newrelation));
-
-		/*
-		 * A partitioned child table with 0 children is a dummy rel, so don't
-		 * bother creating planner objects for it.
-		 */
-		if (newrelation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE &&
-			RelationGetPartitionDesc(newrelation)->nparts == 0)
-		{
-			heap_close(newrelation, NoLock);
-			continue;
-		}
-
-		childrel = add_inheritance_child_rel(root, parentrte, parentRTindex,
-											 parentrel, rootrc, newrelation);
-		Assert(childrel != NULL);
-		parentrel->part_rels[i] = childrel;
-
-		/* Close child relations, but keep locks */
-		heap_close(newrelation, NoLock);
-	}
-
-	/*
-	 * Add junk columns needed by the row mark if any and also add the
-	 * relevant expressions to the root parent's reltarget.
-	 */
-	if (rootrc)
-	{
-		List   *tlist = add_rowmark_junk_columns(root, rootrc);
-
-		build_base_rel_tlists(root, tlist);
-	}
-}
-
-/*
- * add_inheritance_child_rel
- *		Build a RangeTblEntry, an AppendRelInfo, a PlanRowMark, and finally
- *		a RelOptInfo for an inheritance child relation.
- *
- * The return value is the RelOptInfo that's added.
- *
- * PlanRowMarks still carry the top-parent's RTI, and the top-parent's
- * allMarkTypes field still accumulates values from all descendents.
- *
- * "parentrte" and "parentRTindex" are immediate parent's RTE and
- * RTI. "top_parentrc" is top parent's PlanRowMark.
- */
-static RelOptInfo *
-add_inheritance_child_rel(PlannerInfo *root, RangeTblEntry *parentrte,
-						  Index parentRTindex, RelOptInfo *parentrel,
-						  PlanRowMark *top_parentrc, Relation childrel)
-{
-	Query	   *parse = root->parse;
-	Oid			childOID = RelationGetRelid(childrel);
-	RangeTblEntry *childrte;
-	Index		childRTindex;
-	AppendRelInfo *appinfo;
-	RelOptInfo *childrelopt;
-
-	/*
-	 * Build an RTE for the child, and attach to query's rangetable list. We
-	 * copy most fields of the parent's RTE, but replace relation OID and
-	 * relkind, and set inh appropriately.  Also, set requiredPerms to zero
-	 * since all required permissions checks are done on the original RTE.
-	 * Likewise, set the child's securityQuals to empty, because we only want
-	 * to apply the parent's RLS conditions regardless of what RLS properties
-	 * individual children may have.  (This is an intentional choice to make
-	 * inherited RLS work like regular permissions checks.) The parent
-	 * securityQuals will be propagated to children along with other base
-	 * restriction clauses, so we don't need to do it here.
-	 */
-	childrte = copyObject(parentrte);
-	childrte->relid = childOID;
-	childrte->relkind = childrel->rd_rel->relkind;
-	/*
-	 * A partitioned child will need to be expanded as an append parent
-	 * itself, so set its inh to true.
-	 */
-	childrte->inh = (childrte->relkind == RELKIND_PARTITIONED_TABLE);
-	childrte->requiredPerms = 0;
-	childrte->securityQuals = NIL;
-	parse->rtable = lappend(parse->rtable, childrte);
-	childRTindex = list_length(parse->rtable);
-
-	/* Create an AppendRelInfo and add it to planner's global list. */
-	appinfo = make_append_rel_info(parentrel, parentrte,
-								   childrel->rd_att,
-								   childOID,
-								   childrel->rd_rel->reltype,
-								   childRTindex);
-	root->append_rel_list = lappend(root->append_rel_list, appinfo);
-
-	/*
-	 * Translate the column permissions bitmaps to the child's attnums (we
-	 * have to build the translated_vars list before we can do this). But
-	 * if this is the parent table, leave copyObject's result alone.
-	 *
-	 * Note: we need to do this even though the executor won't run any
-	 * permissions checks on the child RTE.  The insertedCols/updatedCols
-	 * bitmaps may be examined for trigger-firing purposes.
-	 */
-	if (childrte->relid != parentrte->relid)
-	{
-		childrte->selectedCols = translate_col_privs(parentrte->selectedCols,
-													 appinfo->translated_vars);
-		childrte->insertedCols = translate_col_privs(parentrte->insertedCols,
-													 appinfo->translated_vars);
-		childrte->updatedCols = translate_col_privs(parentrte->updatedCols,
-													appinfo->translated_vars);
-	}
-
-	/*
-	 * Build a PlanRowMark if parent is marked FOR UPDATE/SHARE.
-	 */
-	if (top_parentrc)
-	{
-		PlanRowMark *childrc = makeNode(PlanRowMark);
-
-		childrc->rti = childRTindex;
-		childrc->prti = top_parentrc->rti;
-		childrc->rowmarkId = top_parentrc->rowmarkId;
-		/* Reselect rowmark type, because relkind might not match parent */
-		childrc->markType = select_rowmark_type(childrte,
-												top_parentrc->strength);
-		childrc->allMarkTypes = (1 << childrc->markType);
-		childrc->strength = top_parentrc->strength;
-		childrc->waitPolicy = top_parentrc->waitPolicy;
-
-		/*
-		 * We mark RowMarks for partitioned child tables as parent RowMarks so
-		 * that the executor ignores them (except their existence means that
-		 * the child tables be locked using appropriate mode).
-		 */
-		childrc->isParent = (childrte->relkind == RELKIND_PARTITIONED_TABLE);
-
-		/* Include child's rowmark type in top parent's allMarkTypes */
-		top_parentrc->allMarkTypes |= childrc->allMarkTypes;
-
-		root->rowMarks = lappend(root->rowMarks, childrc);
-	}
-
-	/*
-	 * Add the RelOptInfo.  Even though we may not really scan this relation
-	 * for reasons such as contradictory quals, we still need need to create
-	 * one, because for every RTE in the query's range table, there must be an
-	 * accompanying RelOptInfo.
-	 */
-
-	/* First, store the RTE and appinfos into planner arrays. */
-	Assert(root->simple_rte_array[childRTindex] == NULL);
-	root->simple_rte_array[childRTindex] = childrte;
-	Assert(root->append_rel_array[childRTindex] == NULL);
-	root->append_rel_array[childRTindex] = appinfo;
-
-	childrelopt = build_append_child_rel(root, parentrel, childRTindex);
-	Assert(childrelopt != NULL);
-
-	return childrelopt;
-}
-
-/*
- * make_inh_translation_list
- *	  Build the list of translations from parent Vars to child Vars for
- *	  an inheritance child.
- *
- * For paranoia's sake, we match type/collation as well as attribute name.
- */
-static void
-make_inh_translation_list(TupleDesc old_tupdesc, TupleDesc new_tupdesc,
-						  Oid from_rel, Oid to_rel,
-						  Index newvarno, List **translated_vars)
-{
-	List	   *vars = NIL;
-	int			oldnatts = old_tupdesc->natts;
-	int			newnatts = new_tupdesc->natts;
-	int			old_attno;
-	int			new_attno = 0;
-
-	for (old_attno = 0; old_attno < oldnatts; old_attno++)
-	{
-		Form_pg_attribute att;
-		char	   *attname;
-		Oid			atttypid;
-		int32		atttypmod;
-		Oid			attcollation;
-
-		att = TupleDescAttr(old_tupdesc, old_attno);
-		if (att->attisdropped)
-		{
-			/* Just put NULL into this list entry */
-			vars = lappend(vars, NULL);
-			continue;
-		}
-		attname = NameStr(att->attname);
-		atttypid = att->atttypid;
-		atttypmod = att->atttypmod;
-		attcollation = att->attcollation;
-
-		/*
-		 * When we are generating the "translation list" for the parent table
-		 * of an inheritance set, no need to search for matches.
-		 */
-		if (from_rel == to_rel)
-		{
-			vars = lappend(vars, makeVar(newvarno,
-										 (AttrNumber) (old_attno + 1),
-										 atttypid,
-										 atttypmod,
-										 attcollation,
-										 0));
-			continue;
-		}
-
-		/*
-		 * Otherwise we have to search for the matching column by name.
-		 * There's no guarantee it'll have the same column position, because
-		 * of cases like ALTER TABLE ADD COLUMN and multiple inheritance.
-		 * However, in simple cases, the relative order of columns is mostly
-		 * the same in both relations, so try the column of newrelation that
-		 * follows immediately after the one that we just found, and if that
-		 * fails, let syscache handle it.
-		 */
-		if (new_attno >= newnatts ||
-			(att = TupleDescAttr(new_tupdesc, new_attno))->attisdropped ||
-			strcmp(attname, NameStr(att->attname)) != 0)
-		{
-			HeapTuple	newtup;
-
-			newtup = SearchSysCacheAttName(to_rel, attname);
-			if (!newtup)
-				elog(ERROR, "could not find inherited attribute \"%s\" of relation \"%s\"",
-					 attname, get_rel_name(to_rel));
-			new_attno = ((Form_pg_attribute) GETSTRUCT(newtup))->attnum - 1;
-			ReleaseSysCache(newtup);
-
-			att = TupleDescAttr(new_tupdesc, new_attno);
-		}
-
-		/* Found it, check type and collation match */
-		if (atttypid != att->atttypid || atttypmod != att->atttypmod)
-			elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's type",
-				 attname, get_rel_name(to_rel));
-		if (attcollation != att->attcollation)
-			elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's collation",
-				 attname, get_rel_name(to_rel));
-
-		vars = lappend(vars, makeVar(newvarno,
-									 (AttrNumber) (new_attno + 1),
-									 atttypid,
-									 atttypmod,
-									 attcollation,
-									 0));
-		new_attno++;
-	}
-
-	*translated_vars = vars;
-}
-
-/*
- * translate_col_privs
- *	  Translate a bitmapset representing per-column privileges from the
- *	  parent rel's attribute numbering to the child's.
- *
- * The only surprise here is that we don't translate a parent whole-row
- * reference into a child whole-row reference.  That would mean requiring
- * permissions on all child columns, which is overly strict, since the
- * query is really only going to reference the inherited columns.  Instead
- * we set the per-column bits for all inherited columns.
- */
-static Bitmapset *
-translate_col_privs(const Bitmapset *parent_privs,
-					List *translated_vars)
-{
-	Bitmapset  *child_privs = NULL;
-	bool		whole_row;
-	int			attno;
-	ListCell   *lc;
-
-	/* System attributes have the same numbers in all tables */
-	for (attno = FirstLowInvalidHeapAttributeNumber + 1; attno < 0; attno++)
-	{
-		if (bms_is_member(attno - FirstLowInvalidHeapAttributeNumber,
-						  parent_privs))
-			child_privs = bms_add_member(child_privs,
-										 attno - FirstLowInvalidHeapAttributeNumber);
-	}
-
-	/* Check if parent has whole-row reference */
-	whole_row = bms_is_member(InvalidAttrNumber - FirstLowInvalidHeapAttributeNumber,
-							  parent_privs);
-
-	/* And now translate the regular user attributes, using the vars list */
-	attno = InvalidAttrNumber;
-	foreach(lc, translated_vars)
-	{
-		Var		   *var = lfirst_node(Var, lc);
-
-		attno++;
-		if (var == NULL)		/* ignore dropped columns */
-			continue;
-		if (whole_row ||
-			bms_is_member(attno - FirstLowInvalidHeapAttributeNumber,
-						  parent_privs))
-			child_privs = bms_add_member(child_privs,
-										 var->varattno - FirstLowInvalidHeapAttributeNumber);
-	}
-
-	return child_privs;
-}
-
-/*
- *	build_append_child_rel
- *		Build a RelOptInfo for child relation of an append rel
- *
- * After creating the RelOptInfo for the given child RT index, it goes on to
- * initialize some of its fields base on the parent RelOptInfo.
- *
- * If the quals in baserestrictinfo turns out to be self-contradictory, the
- * RelOptInfo is marked dummy before returning.
- */
-static RelOptInfo *
-build_append_child_rel(PlannerInfo *root,
-					   RelOptInfo *parent,
-					   Index childRTindex)
-{
-	RelOptInfo *childrel;
-	RangeTblEntry *childRTE = root->simple_rte_array[childRTindex];
-	AppendRelInfo *appinfo = root->append_rel_array[childRTindex];
-	List	   *childquals;
-	ListCell   *lc;
-	bool		have_const_false_cq;
-	Index		cq_min_security;
-
-	/* Build the RelOptInfo. */
-	childrel = build_simple_rel(root, childRTindex, parent);
-
-	/*
-	 * Propagate lateral_relids and lateral_referencers from appendrel
-	 * parent rels to their child rels.  We intentionally give each child rel
-	 * the same minimum parameterization, even though it's quite possible that
-	 * some don't reference all the lateral rels.  This is because any append
-	 * path for the parent will have to have the same parameterization for
-	 * every child anyway, and there's no value in forcing extra
-	 * reparameterize_path() calls.  Similarly, a lateral reference to the
-	 * parent prevents use of otherwise-movable join rels for each child.
-	 */
-	childrel->direct_lateral_relids = parent->direct_lateral_relids;
-	childrel->lateral_relids = parent->lateral_relids;
-	childrel->lateral_referencers = parent->lateral_referencers;
-
-	/*
-	 * We have to copy the parent's quals to the child, with appropriate
-	 * substitution of variables.  However, only the baserestrictinfo
-	 * quals are needed before we can check for constraint exclusion; so
-	 * do that first and then check to see if we can disregard this child.
-	 *
-	 * The child rel's targetlist might contain non-Var expressions, which
-	 * means that substitution into the quals could produce opportunities
-	 * for const-simplification, and perhaps even pseudoconstant quals.
-	 * Therefore, transform each RestrictInfo separately to see if it
-	 * reduces to a constant or pseudoconstant.  (We must process them
-	 * separately to keep track of the security level of each qual.)
-	 */
-	childquals = false;
-	cq_min_security = UINT_MAX;
-	have_const_false_cq = false;
-	foreach(lc, parent->baserestrictinfo)
-	{
-		RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
-		Node	   *childqual = (Node *) rinfo->clause;
-		ListCell   *lc2;
-
-		Assert(IsA(rinfo, RestrictInfo));
-		childqual = adjust_appendrel_attrs(root, childqual,
-										   1, &appinfo);
-		childqual = eval_const_expressions(root, childqual);
-		/* check for flat-out constant */
-		if (childqual && IsA(childqual, Const))
-		{
-			if (((Const *) childqual)->constisnull ||
-				!DatumGetBool(((Const *) childqual)->constvalue))
-			{
-				/* Restriction reduces to constant FALSE or NULL */
-				have_const_false_cq = true;
-				break;
-			}
-			/* Restriction reduces to constant TRUE, so drop it */
-			continue;
-		}
-		/* might have gotten an AND clause, if so flatten it */
-		foreach(lc2, make_ands_implicit((Expr *) childqual))
-		{
-			Node	   *onecq = (Node *) lfirst(lc2);
-			bool		pseudoconstant;
-
-			/* check for pseudoconstant (no Vars or volatile functions) */
-			pseudoconstant =
-					!contain_vars_of_level(onecq, 0) &&
-					!contain_volatile_functions(onecq);
-			if (pseudoconstant)
-			{
-				/* tell createplan.c to check for gating quals */
-				root->hasPseudoConstantQuals = true;
-			}
-			/* reconstitute RestrictInfo with appropriate properties */
-			childquals = lappend(childquals,
-								 make_restrictinfo((Expr *) onecq,
-												   rinfo->is_pushed_down,
-												   rinfo->outerjoin_delayed,
-												   pseudoconstant,
-												   rinfo->security_level,
-												   NULL, NULL, NULL));
-			cq_min_security = Min(cq_min_security, rinfo->security_level);
-		}
-	}
-
-	/*
-	 * In addition to the quals inherited from the parent, we might
-	 * have securityQuals associated with this particular child node.
-	 * (Currently this can only happen in appendrels originating from
-	 * UNION ALL; inheritance child tables don't have their own
-	 * securityQuals.)	Pull any such securityQuals up into the
-	 * baserestrictinfo for the child.  This is similar to
-	 * process_security_barrier_quals() for the parent rel, except
-	 * that we can't make any general deductions from such quals,
-	 * since they don't hold for the whole appendrel.
-	 */
-	if (childRTE->securityQuals)
-	{
-		Index		security_level = 0;
-
-		foreach(lc, childRTE->securityQuals)
-		{
-			List	   *qualset = (List *) lfirst(lc);
-			ListCell   *lc2;
-
-			foreach(lc2, qualset)
-			{
-				Expr	   *qual = (Expr *) lfirst(lc2);
-
-				/*
-				 * not likely that we'd see constants here, so no
-				 * check
-				 */
-				childquals = lappend(childquals,
-									 make_restrictinfo(qual,
-													   true,
-													   false,
-													   false,
-													   security_level,
-													   NULL, NULL,
-													   NULL));
-				cq_min_security = Min(cq_min_security, security_level);
-			}
-			security_level++;
-		}
-		Assert(security_level <= root->qual_security_level);
-	}
-
-	/* Set child's version of baserestrictinfo. */
-	childrel->baserestrictinfo = childquals;
-	childrel->baserestrict_min_security = cq_min_security;
-
-	if (have_const_false_cq)
-	{
-		/*
-		 * Some restriction clause reduced to constant FALSE or NULL after
-		 * substitution, so this child need not be scanned.
-		 */
-		set_dummy_rel_pathlist(childrel);
-	}
-
-	return childrel;
-}
-
-/*
- * add_rowmark_junk_columns
- * 		Add necessary junk columns for rowmarked inheritance parent rel.
- *
- * These values are needed for locking of rels selected FOR UPDATE/SHARE, and
- * to do EvalPlanQual rechecking.  See comments for PlanRowMark in
- * plannodes.h.
- */
-static List *
-add_rowmark_junk_columns(PlannerInfo *root, PlanRowMark *rc)
-{
-	List   *tlist = root->processed_tlist;
-	Var		   *var;
-	char		resname[32];
-	TargetEntry *tle;
-
-	if (rc->allMarkTypes & ~(1 << ROW_MARK_COPY))
-	{
-		/* Need to fetch TID */
-		var = makeVar(rc->rti,
-					  SelfItemPointerAttributeNumber,
-					  TIDOID,
-					  -1,
-					  InvalidOid,
-					  0);
-		snprintf(resname, sizeof(resname), "ctid%u", rc->rowmarkId);
-		tle = makeTargetEntry((Expr *) var,
-							  list_length(tlist) + 1,
-							  pstrdup(resname),
-							  true);
-		tlist = lappend(tlist, tle);
-	}
-	if (rc->allMarkTypes & (1 << ROW_MARK_COPY))
-	{
-		/* Need the whole row as a junk var */
-		var = makeWholeRowVar(root->simple_rte_array[rc->rti],
-							  rc->rti,
-							  0,
-							  false);
-		snprintf(resname, sizeof(resname), "wholerow%u", rc->rowmarkId);
-		tle = makeTargetEntry((Expr *) var,
-							  list_length(tlist) + 1,
-							  pstrdup(resname),
-							  true);
-		tlist = lappend(tlist, tle);
-	}
-
-	/* For inheritance cases, always fetch the tableoid too. */
-	var = makeVar(rc->rti,
-				  TableOidAttributeNumber,
-				  OIDOID,
-				  -1,
-				  InvalidOid,
-				  0);
-	snprintf(resname, sizeof(resname), "tableoid%u", rc->rowmarkId);
-	tle = makeTargetEntry((Expr *) var,
-						  list_length(tlist) + 1,
-						  pstrdup(resname),
-						  true);
-	tlist = lappend(tlist, tle);
-
-	return tlist;
-}
-
-AppendRelInfo *
-make_append_rel_info(RelOptInfo *parentrel, RangeTblEntry *parentrte,
-					 TupleDesc childdesc, Oid childoid, Oid childreltype,
-					 Index childRTindex)
-{
-	AppendRelInfo  *appinfo = makeNode(AppendRelInfo);
-
-	appinfo->parent_relid = parentrel->relid;
-	appinfo->child_relid = childRTindex;
-	appinfo->parent_reltype = parentrel->reltype;
-	appinfo->child_reltype = childreltype;
-	make_inh_translation_list(parentrel->tupdesc, childdesc,
-							  parentrte->relid, childoid,
-							  childRTindex,
-							  &appinfo->translated_vars);
-	appinfo->parent_reloid = parentrte->relid;
-
-	return appinfo;
-}
-
-/*
- * adjust_appendrel_attrs
- *	  Copy the specified query or expression and translate Vars referring to a
- *	  parent rel to refer to the corresponding child rel instead.  We also
- *	  update rtindexes appearing outside Vars, such as resultRelation and
- *	  jointree relids.
- *
- * Note: this is only applied after conversion of sublinks to subplans,
- * so we don't need to cope with recursion into sub-queries.
- *
- * Note: this is not hugely different from what pullup_replace_vars() does;
- * maybe we should try to fold the two routines together.
- */
-Node *
-adjust_appendrel_attrs(PlannerInfo *root, Node *node, int nappinfos,
-					   AppendRelInfo **appinfos)
-{
-	Node	   *result;
-	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);
-
-	/*
-	 * Must be prepared to start with a Query or a bare expression tree.
-	 */
-	if (node && IsA(node, Query))
-	{
-		Query	   *newnode;
-		int			cnt;
-
-		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;
-}
-
-static Node *
-adjust_appendrel_attrs_mutator(Node *node,
-							   adjust_appendrel_attrs_context *context)
-{
-	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;
-
-		for (cnt = 0; cnt < nappinfos; cnt++)
-		{
-			if (var->varno == appinfos[cnt]->parent_relid)
-			{
-				appinfo = appinfos[cnt];
-				break;
-			}
-		}
-
-		if (var->varlevelsup == 0 && appinfo)
-		{
-			var->varno = appinfo->child_relid;
-			var->varnoold = appinfo->child_relid;
-			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));
-				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;
-
-					return (Node *) rowexpr;
-				}
-			}
-			/* system attributes don't need any other translation */
-		}
-		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, 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 */
-		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, context->nappinfos,
-											  context->appinfos);
-		return (Node *) phv;
-	}
-
-	/*
-	 * This is needed, because inheritance_make_rel_from_joinlist needs to
-	 * translate root->join_info_list executing make_rel_from_joinlist for a
-	 * given child.
-	 */
-	if (IsA(node, SpecialJoinInfo))
-	{
-		SpecialJoinInfo *oldinfo = (SpecialJoinInfo *) node;
-		SpecialJoinInfo *newinfo = makeNode(SpecialJoinInfo);
-
-		memcpy(newinfo, oldinfo, sizeof(SpecialJoinInfo));
-		newinfo->min_lefthand = adjust_child_relids(oldinfo->min_lefthand,
-													context->nappinfos,
-													context->appinfos);
-		newinfo->min_righthand = adjust_child_relids(oldinfo->min_righthand,
-													 context->nappinfos,
-													 context->appinfos);
-		newinfo->syn_lefthand = adjust_child_relids(oldinfo->syn_lefthand,
-													context->nappinfos,
-													context->appinfos);
-		newinfo->syn_righthand = adjust_child_relids(oldinfo->syn_righthand,
-													 context->nappinfos,
-													 context->appinfos);
-		newinfo->semi_rhs_exprs =
-					(List *) expression_tree_mutator((Node *)
-													 oldinfo->semi_rhs_exprs,
-													 adjust_appendrel_attrs_mutator,
-													 (void *) context);
-		return (Node *) newinfo;
-	}
-
-	/* Shouldn't need to handle planner auxiliary nodes here */
-	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 */
-		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->nullable_relids = adjust_child_relids(oldinfo->nullable_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));
-
-	return expression_tree_mutator(node, adjust_appendrel_attrs_mutator,
-								   (void *) context);
-}
-
-/*
- * Substitute child relids for parent relids in a Relid set.  The array of
- * appinfos specifies the substitutions to be performed.
- */
-static Relids
-adjust_child_relids(Relids relids, int nappinfos, AppendRelInfo **appinfos)
-{
-	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;
-}
-
-/*
- * Replace any relid present in top_parent_relids with its child in
- * child_relids. Members of child_relids can be multiple levels below top
- * parent in the partition hierarchy.
- */
-Relids
-adjust_child_relids_multilevel(PlannerInfo *root, Relids relids,
-							   Relids child_relids, Relids top_parent_relids)
-{
-	AppendRelInfo **appinfos;
-	int			nappinfos;
-	Relids		parent_relids = NULL;
-	Relids		result;
-	Relids		tmp_result = NULL;
-	int			cnt;
-
-	/*
-	 * If the given relids set doesn't contain any of the top parent relids,
-	 * it will remain unchanged.
-	 */
-	if (!bms_overlap(relids, top_parent_relids))
-		return relids;
-
-	appinfos = find_appinfos_by_relids(root, child_relids, &nappinfos);
-
-	/* Construct relids set for the immediate parent of the given child. */
-	for (cnt = 0; cnt < nappinfos; cnt++)
-	{
-		AppendRelInfo *appinfo = appinfos[cnt];
-
-		parent_relids = bms_add_member(parent_relids, appinfo->parent_relid);
-	}
-
-	/* Recurse if immediate parent is not the top parent. */
-	if (!bms_equal(parent_relids, top_parent_relids))
-	{
-		tmp_result = adjust_child_relids_multilevel(root, relids,
-													parent_relids,
-													top_parent_relids);
-		relids = tmp_result;
-	}
-
-	result = adjust_child_relids(relids, nappinfos, appinfos);
-
-	/* Free memory consumed by any intermediate result. */
-	if (tmp_result)
-		bms_free(tmp_result);
-	bms_free(parent_relids);
-	pfree(appinfos);
-
-	return result;
-}
-
-/*
- * 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.
- */
-static List *
-adjust_inherited_tlist(List *tlist, AppendRelInfo *context)
-{
-	bool		changed_it = false;
-	ListCell   *tl;
-	List	   *new_tlist;
-	bool		more;
-	int			attrno;
-
-	/* 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)
-	{
-		TargetEntry *tle = (TargetEntry *) lfirst(tl);
-		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))
-			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);
-		if (childvar == NULL || !IsA(childvar, Var))
-			elog(ERROR, "attribute %d of relation \"%s\" does not exist",
-				 tle->resno, get_rel_name(context->parent_reloid));
-
-		if (tle->resno != childvar->varattno)
-		{
-			tle->resno = childvar->varattno;
-			changed_it = true;
-		}
-	}
-
-	/*
-	 * 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;
-
-	new_tlist = NIL;
-	more = true;
-	for (attrno = 1; more; attrno++)
-	{
-		more = false;
-		foreach(tl, tlist)
-		{
-			TargetEntry *tle = (TargetEntry *) lfirst(tl);
-
-			if (tle->resjunk)
-				continue;		/* ignore junk items */
-
-			if (tle->resno == attrno)
-				new_tlist = lappend(new_tlist, tle);
-			else if (tle->resno > attrno)
-				more = true;
-		}
-	}
-
-	foreach(tl, tlist)
-	{
-		TargetEntry *tle = (TargetEntry *) lfirst(tl);
-
-		if (!tle->resjunk)
-			continue;			/* here, ignore non-junk items */
-
-		tle->resno = attrno;
-		new_tlist = lappend(new_tlist, tle);
-		attrno++;
-	}
-
-	return new_tlist;
-}
-
-/*
- * adjust_appendrel_attrs_multilevel
- *	  Apply Var translations from a toplevel appendrel parent down to a child.
- *
- * In some cases we need to translate expressions referencing a parent relation
- * to reference an appendrel child that's multiple levels removed from it.
- */
-Node *
-adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node,
-								  Relids child_relids,
-								  Relids top_parent_relids)
-{
-	AppendRelInfo **appinfos;
-	Bitmapset  *parent_relids = NULL;
-	int			nappinfos;
-	int			cnt;
-
-	Assert(bms_num_members(child_relids) == bms_num_members(top_parent_relids));
-
-	appinfos = find_appinfos_by_relids(root, child_relids, &nappinfos);
-
-	/* Construct relids set for the immediate parent of given child. */
-	for (cnt = 0; cnt < nappinfos; cnt++)
-	{
-		AppendRelInfo *appinfo = appinfos[cnt];
-
-		parent_relids = bms_add_member(parent_relids, appinfo->parent_relid);
-	}
-
-	/* Recurse if immediate parent is not the top parent. */
-	if (!bms_equal(parent_relids, top_parent_relids))
-		node = adjust_appendrel_attrs_multilevel(root, node, parent_relids,
-												 top_parent_relids);
-
-	/* Now translate for this child */
-	node = adjust_appendrel_attrs(root, node, nappinfos, appinfos);
-
-	pfree(appinfos);
-
-	return node;
-}
-
-/*
- * Construct the SpecialJoinInfo for a child-join by translating
- * SpecialJoinInfo for the join between parents. left_relids and right_relids
- * are the relids of left and right side of the join respectively.
- */
-SpecialJoinInfo *
-build_child_join_sjinfo(PlannerInfo *root, SpecialJoinInfo *parent_sjinfo,
-						Relids left_relids, Relids right_relids)
-{
-	SpecialJoinInfo *sjinfo = makeNode(SpecialJoinInfo);
-	AppendRelInfo **left_appinfos;
-	int			left_nappinfos;
-	AppendRelInfo **right_appinfos;
-	int			right_nappinfos;
-
-	memcpy(sjinfo, parent_sjinfo, sizeof(SpecialJoinInfo));
-	left_appinfos = find_appinfos_by_relids(root, left_relids,
-											&left_nappinfos);
-	right_appinfos = find_appinfos_by_relids(root, right_relids,
-											 &right_nappinfos);
-
-	sjinfo->min_lefthand = adjust_child_relids(sjinfo->min_lefthand,
-											   left_nappinfos, left_appinfos);
-	sjinfo->min_righthand = adjust_child_relids(sjinfo->min_righthand,
-												right_nappinfos,
-												right_appinfos);
-	sjinfo->syn_lefthand = adjust_child_relids(sjinfo->syn_lefthand,
-											   left_nappinfos, left_appinfos);
-	sjinfo->syn_righthand = adjust_child_relids(sjinfo->syn_righthand,
-												right_nappinfos,
-												right_appinfos);
-	sjinfo->semi_rhs_exprs = (List *) adjust_appendrel_attrs(root,
-															 (Node *) sjinfo->semi_rhs_exprs,
-															 right_nappinfos,
-															 right_appinfos);
-
-	pfree(left_appinfos);
-	pfree(right_appinfos);
-
-	return sjinfo;
-}
-
-/*
- * find_appinfos_by_relids
- * 		Find AppendRelInfo structures for all relations specified by relids.
- *
- * The AppendRelInfos are returned in an array, which can be pfree'd by the
- * caller. *nappinfos is set to the number of entries in the array.
- */
-AppendRelInfo **
-find_appinfos_by_relids(PlannerInfo *root, Relids relids, int *nappinfos)
-{
-	AppendRelInfo **appinfos;
-	int			cnt = 0;
-	int			i;
-
-	*nappinfos = bms_num_members(relids);
-	appinfos = (AppendRelInfo **) palloc(sizeof(AppendRelInfo *) * *nappinfos);
-
-	i = -1;
-	while ((i = bms_next_member(relids, i)) >= 0)
-	{
-		AppendRelInfo *appinfo = root->append_rel_array[i];
-
-		if (!appinfo)
-			elog(ERROR, "child rel %d not found in append_rel_array", i);
-
-		appinfos[cnt++] = appinfo;
-	}
-	return appinfos;
-}
diff --git a/src/backend/optimizer/util/Makefile b/src/backend/optimizer/util/Makefile
index da9ccf32b4..d166030a10 100644
--- a/src/backend/optimizer/util/Makefile
+++ b/src/backend/optimizer/util/Makefile
@@ -12,7 +12,8 @@ subdir = src/backend/optimizer/util
 top_builddir = ../../../..
 include $(top_builddir)/src/Makefile.global
 
-OBJS = clauses.o joininfo.o orclauses.o pathnode.o placeholder.o \
-	   plancat.o predtest.o relnode.o restrictinfo.o tlist.o var.o
+OBJS = append.o appendinfo.o clauses.o joininfo.o orclauses.o pathnode.o \
+	   placeholder.o plancat.o predtest.o relnode.o restrictinfo.o tlist.o \
+	   var.o
 
 include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/optimizer/util/append.c b/src/backend/optimizer/util/append.c
new file mode 100644
index 0000000000..bbc579817a
--- /dev/null
+++ b/src/backend/optimizer/util/append.c
@@ -0,0 +1,719 @@
+/*-------------------------------------------------------------------------
+ *
+ * append.c
+ *	  Routines to process children of an appendrel parent
+ *
+ * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/optimizer/path/append.c
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include <limits.h>
+
+#include "access/sysattr.h"
+#include "catalog/partition.h"
+#include "catalog/pg_class.h"
+#include "catalog/pg_inherits.h"
+#include "catalog/pg_type.h"
+#include "nodes/makefuncs.h"
+#include "optimizer/append.h"
+#include "optimizer/appendinfo.h"
+#include "optimizer/clauses.h"
+#include "optimizer/pathnode.h"
+#include "optimizer/paths.h"
+#include "optimizer/plancat.h"
+#include "optimizer/planmain.h"
+#include "optimizer/planner.h"
+#include "optimizer/prep.h"
+#include "optimizer/restrictinfo.h"
+#include "optimizer/tlist.h"
+#include "optimizer/var.h"
+#include "partitioning/partprune.h"
+#include "utils/rel.h"
+
+static void expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte,
+						 Index rti, RelOptInfo *rel);
+static void expand_partitioned_rtentry(PlannerInfo *root,
+						   RangeTblEntry *parentrte,
+						   Index parentRTindex, RelOptInfo *parentrel);
+static RelOptInfo *add_inheritance_child_rel(PlannerInfo *root,
+						  RangeTblEntry *parentrte,
+						  Index parentRTindex, RelOptInfo *parentrel,
+						  PlanRowMark *top_parentrc, Relation childrel);
+static RelOptInfo *build_append_child_rel(PlannerInfo *root,
+					   RelOptInfo *parent,
+					   Index childRTindex);
+static List *add_rowmark_junk_columns(PlannerInfo *root, PlanRowMark *rc);
+
+
+/*
+ * expand_append_rel
+ *		This initializes RelOptInfos for an appendrel's child relations.
+ *
+ * 'rel' is the appendrel parent, whose range table entry ('rte') has been
+ * marked to require adding children.  An appendrel parent could either
+ * be a subquery (if we flattened UNION ALL query) or a table that's known
+ * to have inheritance children.  The latter consists of both regular
+ * inheritance parents and partitioned tables.
+ *
+ * For a subquery parent, there is not much to be done here because the
+ * children's RTEs are already present in the query, so we just initialize
+ * RelOptInfos for them.  Also, the AppendRelInfos for child subqueries
+ * have already been added.
+ *
+ * For tables, we need to add the children to the range table and initialize
+ * AppendRelInfos, RelOptInfos, and PlanRowMarks (if any) for them.  For
+ * a partitioned parent, we only add the children remaining after pruning.
+ * For regular inheritance parents, we find the children using
+ * find_all_inheritors and add all of them.
+ *
+ * If it turns out that there are no children, then we set rte->inh to false
+ * to let the caller know that only the parent table needs to be scanned.  The
+ * caller can accordingly switch to a non-Append path.  For a partitioned
+ * parent, that means an empty relation because parents themselves contain no
+ * data.
+ *
+ * For the regular inheritance case, the parent also gets another RTE with
+ * inh = false to represent it as an appendrel child.  The original RTE is
+ * considered to represent the whole inheritance set.
+ */
+void
+expand_append_rel(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte,
+				  Index rti)
+{
+	Assert(rte->inh);
+	/* Inheritance parent (partitioned or not) or UNION ALL parent subquery. */
+	Assert(rte->rtekind == RTE_RELATION || rte->rtekind == RTE_SUBQUERY);
+
+	/*
+	 * UNION ALL children already got RTEs and AppendRelInfos, so just build
+	 * RelOptInfos and return.
+	 *
+	 * It might be a bit odd that this code is in this, because there is
+	 * nothing to expand really.
+	 */
+	if (rte->rtekind == RTE_SUBQUERY)
+	{
+		ListCell   *l;
+
+		/*
+		 * We don't need to use expand_planner_arrays in this case, because
+		 * no new child RTEs are created.  setup_simple_rel_arrays() and
+		 * setup_append_rel_array would've considered these child RTEs when
+		 * allocating space for various arrays.
+		 */
+		foreach(l, root->append_rel_list)
+		{
+			AppendRelInfo *appinfo = lfirst(l);
+			Index		childRTindex = appinfo->child_relid;
+
+			if (appinfo->parent_relid != rti)
+				continue;
+
+			Assert(childRTindex < root->simple_rel_array_size);
+			Assert(root->simple_rte_array[childRTindex] != NULL);
+
+			/*
+			 * We set the correct value of baserestricinfo and
+			 * baserestrict_min_security below.
+			 */
+			root->simple_rel_array[childRTindex] =
+				build_append_child_rel(root, rel, appinfo->child_relid);
+		}
+	}
+	else
+	{
+		Assert(rte->rtekind == RTE_RELATION);
+		Assert(has_subclass(rte->relid));
+
+		/*
+		 * The rewriter should already have obtained an appropriate lock on
+		 * each relation named in the query.  However, for each child relation
+		 * we add to the query, we must obtain an appropriate lock, because
+		 * this will be the first use of those relations in the
+		 * parse/rewrite/plan pipeline.  Child rels should use the same
+		 * lockmode as their parent.
+		 */
+		Assert(rte->rellockmode != NoLock);
+
+		if (rte->relkind == RELKIND_PARTITIONED_TABLE)
+			expand_partitioned_rtentry(root, rte, rti, rel);
+		else
+			expand_inherited_rtentry(root, rte, rti, rel);
+	}
+}
+
+/*
+ * expand_inherited_rtentry
+ *		Add entries for all the child tables to the query's rangetable, and
+ *		build AppendRelInfo nodes for all the child tables and add them to
+ *		root->append_rel_list.
+ *
+ * Note that the original RTE is considered to represent the whole
+ * inheritance set.  The first of the generated RTEs is an RTE for the same
+ * table, but with inh = false, to represent the parent table in its role
+ * as a simple member of the inheritance set.
+ *
+ * A childless table is never considered to be an inheritance set. For
+ * regular inheritance, a parent RTE must always have at least two associated
+ * AppendRelInfos: one corresponding to the parent table as a simple member of
+ * inheritance set and one or more corresponding to the actual children.
+ */
+static void
+expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti,
+						 RelOptInfo *rel)
+{
+	Oid			parentOID;
+	PlanRowMark *oldrc;
+	LOCKMODE	lockmode = rte->rellockmode;
+	List	   *inhOIDs;
+	ListCell   *l;
+	int			num_children;
+	int			num_children_added = 0;
+
+	Assert(rte->rtekind == RTE_RELATION);
+	Assert(lockmode != NoLock);
+	parentOID = rte->relid;
+
+	/* Scan for all members of inheritance set, acquire needed locks */
+	inhOIDs = find_all_inheritors(parentOID, lockmode, NULL);
+
+	/*
+	 * Check that there's at least one descendant, else treat as no-child
+	 * case.  This could happen despite above has_subclass() check, if table
+	 * once had a child but no longer does.
+	 */
+	num_children = list_length(inhOIDs);
+	if (num_children < 2)
+	{
+		/* Clear flag before returning */
+		rte->inh = false;
+		return;
+	}
+
+	/*
+	 * If parent relation is selected FOR UPDATE/SHARE, preprocess_rowmarks
+	 * should've set isParent = true.  We'll generate a new PlanRowMark for
+	 * each child.
+	 */
+	oldrc = get_plan_rowmark(root->rowMarks, rti);
+	Assert(oldrc == NULL || oldrc->isParent);
+
+	/*
+	 * Must expand PlannerInfo arrays by num_children before we can add
+	 * children.
+	 */
+	expand_planner_arrays(root, num_children);
+
+	foreach(l, inhOIDs)
+	{
+		Oid			childOID = lfirst_oid(l);
+		Relation	newrelation;
+		RelOptInfo *childrel;
+
+		/* Already locked above. */
+		newrelation = heap_open(childOID, NoLock);
+
+		/*
+		 * It is possible that the parent table has children that are temp
+		 * tables of other backends.  We cannot safely access such tables
+		 * (because of buffering issues), and the best thing to do seems
+		 * to be to silently ignore them.
+		 */
+		if (RELATION_IS_OTHER_TEMP(newrelation))
+		{
+			heap_close(newrelation, lockmode);
+			continue;
+		}
+
+		childrel = add_inheritance_child_rel(root, rte, rti, rel, oldrc,
+											 newrelation);
+		Assert(childrel != NULL);
+
+		/* Close child relations, but keep locks */
+		heap_close(newrelation, NoLock);
+		num_children_added++;
+	}
+
+	/*
+	 * If all children, including the parent (as child rel), were
+	 * excluded, mark the parent rel as empty.  If all the children were temp
+	 * tables, pretend it's a non-inheritance situation; we don't need Append
+	 * node in that case.  The duplicate RTE we added for the parent table is
+	 * harmless, so we don't bother to get rid of it; ditto for the useless
+	 * PlanRowMark node.
+	 */
+	if (num_children_added == 0)
+		mark_dummy_rel(rel);
+	else if (num_children_added == 1)
+		rte->inh = false;
+
+	/*
+	 * Add junk columns needed by the row mark if any and also add the
+	 * relevant expressions to the root parent's reltarget.
+	 */
+	if (oldrc)
+	{
+		List   *tlist = add_rowmark_junk_columns(root, oldrc);
+
+		build_base_rel_tlists(root, tlist);
+	}
+}
+
+/*
+ * expand_partitioned_rtentry
+ *		Prunes unnecessary partitions of a partitioned table and adds
+ *		remaining ones to the Query and the PlannerInfo
+ *
+ * Partitions are added to the query in order in which they are found in
+ * the parent's PartitionDesc.
+ *
+ * Note: even though only the unpruned partitions will be added to the
+ * resulting plan, this still locks *all* partitions via find_all_inheritors
+ * in order to avoid partitions being locked in a different order than other
+ * places in the backend that may lock partitions.
+ */
+static void
+expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
+						   Index parentRTindex, RelOptInfo *parentrel)
+{
+	LOCKMODE	lockmode = parentrte->rellockmode;
+	PlanRowMark *rootrc = NULL;
+	int			i;
+	Bitmapset  *partindexes;
+	Index		rootParentRTindex = parentrel->inh_root_parent > 0 ?
+									parentrel->inh_root_parent :
+									parentRTindex;
+
+	/* If root partitioned table, lock *all* partitions in the tree. */
+	if (parentRTindex == rootParentRTindex)
+		(void) find_all_inheritors(parentrte->relid, lockmode, NULL);
+
+	/*
+	 * Initialize partitioned_child_rels to contain this RT index.
+	 *
+	 * Note that during the set_append_rel_pathlist() phase, values of the
+	 * indexes of partitioned relations that appear down in the tree will be
+	 * bubbled up into root parent's list so that when we've created Paths for
+	 * all the children, the root table's list will contain all such indexes.
+	 */
+	parentrel->partitioned_child_rels = list_make1_int(parentRTindex);
+
+	/* Perform pruning. */
+	partindexes = prune_append_rel_partitions(parentrel);
+
+	/* Must expand PlannerInfo arrays before we can add children. */
+	expand_planner_arrays(root, bms_num_members(partindexes));
+
+	/*
+	 * For partitioned tables, we also store the partition RelOptInfo
+	 * pointers in the parent's RelOptInfo.
+	 */
+	parentrel->part_rels = (RelOptInfo **) palloc0(sizeof(RelOptInfo *) *
+												   parentrel->nparts);
+
+	rootrc = get_plan_rowmark(root->rowMarks, rootParentRTindex);
+	Assert(rootrc == NULL || rootrc->isParent);
+	i = -1;
+	while ((i = bms_next_member(partindexes, i)) >= 0)
+	{
+		Oid		childOID = parentrel->part_oids[i];
+		Relation	newrelation;
+		RelOptInfo *childrel;
+
+		/* Already locked above. */
+		newrelation = heap_open(childOID, NoLock);
+		Assert(!RELATION_IS_OTHER_TEMP(newrelation));
+
+		/*
+		 * A partitioned child table with 0 children is a dummy rel, so don't
+		 * bother creating planner objects for it.
+		 */
+		if (newrelation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE &&
+			RelationGetPartitionDesc(newrelation)->nparts == 0)
+		{
+			heap_close(newrelation, NoLock);
+			continue;
+		}
+
+		childrel = add_inheritance_child_rel(root, parentrte, parentRTindex,
+											 parentrel, rootrc, newrelation);
+		Assert(childrel != NULL);
+		parentrel->part_rels[i] = childrel;
+
+		/* Close child relations, but keep locks */
+		heap_close(newrelation, NoLock);
+	}
+
+	/*
+	 * Add junk columns needed by the row mark if any and also add the
+	 * relevant expressions to the root parent's reltarget.
+	 */
+	if (rootrc)
+	{
+		List   *tlist = add_rowmark_junk_columns(root, rootrc);
+
+		build_base_rel_tlists(root, tlist);
+	}
+}
+
+/*
+ * add_inheritance_child_rel
+ *		Build a RangeTblEntry, an AppendRelInfo, a PlanRowMark, and finally
+ *		a RelOptInfo for an inheritance child relation.
+ *
+ * The return value is the RelOptInfo that's added.
+ *
+ * PlanRowMarks still carry the top-parent's RTI, and the top-parent's
+ * allMarkTypes field still accumulates values from all descendents.
+ *
+ * "parentrte" and "parentRTindex" are immediate parent's RTE and
+ * RTI. "top_parentrc" is top parent's PlanRowMark.
+ */
+static RelOptInfo *
+add_inheritance_child_rel(PlannerInfo *root, RangeTblEntry *parentrte,
+						  Index parentRTindex, RelOptInfo *parentrel,
+						  PlanRowMark *top_parentrc, Relation childrel)
+{
+	Query	   *parse = root->parse;
+	Oid			childOID = RelationGetRelid(childrel);
+	RangeTblEntry *childrte;
+	Index		childRTindex;
+	AppendRelInfo *appinfo;
+	RelOptInfo *childrelopt;
+
+	/*
+	 * Build an RTE for the child, and attach to query's rangetable list. We
+	 * copy most fields of the parent's RTE, but replace relation OID and
+	 * relkind, and set inh appropriately.  Also, set requiredPerms to zero
+	 * since all required permissions checks are done on the original RTE.
+	 * Likewise, set the child's securityQuals to empty, because we only want
+	 * to apply the parent's RLS conditions regardless of what RLS properties
+	 * individual children may have.  (This is an intentional choice to make
+	 * inherited RLS work like regular permissions checks.) The parent
+	 * securityQuals will be propagated to children along with other base
+	 * restriction clauses, so we don't need to do it here.
+	 */
+	childrte = copyObject(parentrte);
+	childrte->relid = childOID;
+	childrte->relkind = childrel->rd_rel->relkind;
+	/*
+	 * A partitioned child will need to be expanded as an append parent
+	 * itself, so set its inh to true.
+	 */
+	childrte->inh = (childrte->relkind == RELKIND_PARTITIONED_TABLE);
+	childrte->requiredPerms = 0;
+	childrte->securityQuals = NIL;
+	parse->rtable = lappend(parse->rtable, childrte);
+	childRTindex = list_length(parse->rtable);
+
+	/* Create an AppendRelInfo and add it to planner's global list. */
+	appinfo = make_append_rel_info(parentrel, parentrte,
+								   childrel->rd_att,
+								   childOID,
+								   childrel->rd_rel->reltype,
+								   childRTindex);
+	root->append_rel_list = lappend(root->append_rel_list, appinfo);
+
+	/*
+	 * Translate the column permissions bitmaps to the child's attnums (we
+	 * have to build the translated_vars list before we can do this). But
+	 * if this is the parent table, leave copyObject's result alone.
+	 *
+	 * Note: we need to do this even though the executor won't run any
+	 * permissions checks on the child RTE.  The insertedCols/updatedCols
+	 * bitmaps may be examined for trigger-firing purposes.
+	 */
+	if (childrte->relid != parentrte->relid)
+	{
+		childrte->selectedCols = translate_col_privs(parentrte->selectedCols,
+													 appinfo->translated_vars);
+		childrte->insertedCols = translate_col_privs(parentrte->insertedCols,
+													 appinfo->translated_vars);
+		childrte->updatedCols = translate_col_privs(parentrte->updatedCols,
+													appinfo->translated_vars);
+	}
+
+	/*
+	 * Build a PlanRowMark if parent is marked FOR UPDATE/SHARE.
+	 */
+	if (top_parentrc)
+	{
+		PlanRowMark *childrc = makeNode(PlanRowMark);
+
+		childrc->rti = childRTindex;
+		childrc->prti = top_parentrc->rti;
+		childrc->rowmarkId = top_parentrc->rowmarkId;
+		/* Reselect rowmark type, because relkind might not match parent */
+		childrc->markType = select_rowmark_type(childrte,
+												top_parentrc->strength);
+		childrc->allMarkTypes = (1 << childrc->markType);
+		childrc->strength = top_parentrc->strength;
+		childrc->waitPolicy = top_parentrc->waitPolicy;
+
+		/*
+		 * We mark RowMarks for partitioned child tables as parent RowMarks so
+		 * that the executor ignores them (except their existence means that
+		 * the child tables be locked using appropriate mode).
+		 */
+		childrc->isParent = (childrte->relkind == RELKIND_PARTITIONED_TABLE);
+
+		/* Include child's rowmark type in top parent's allMarkTypes */
+		top_parentrc->allMarkTypes |= childrc->allMarkTypes;
+
+		root->rowMarks = lappend(root->rowMarks, childrc);
+	}
+
+	/*
+	 * Add the RelOptInfo.  Even though we may not really scan this relation
+	 * for reasons such as contradictory quals, we still need need to create
+	 * one, because for every RTE in the query's range table, there must be an
+	 * accompanying RelOptInfo.
+	 */
+
+	/* First, store the RTE and appinfos into planner arrays. */
+	Assert(root->simple_rte_array[childRTindex] == NULL);
+	root->simple_rte_array[childRTindex] = childrte;
+	Assert(root->append_rel_array[childRTindex] == NULL);
+	root->append_rel_array[childRTindex] = appinfo;
+
+	childrelopt = build_append_child_rel(root, parentrel, childRTindex);
+	Assert(childrelopt != NULL);
+
+	return childrelopt;
+}
+
+/*
+ *	build_append_child_rel
+ *		Build a RelOptInfo for child relation of an append rel
+ *
+ * After creating the RelOptInfo for the given child RT index, it goes on to
+ * initialize some of its fields base on the parent RelOptInfo.
+ *
+ * If the quals in baserestrictinfo turns out to be self-contradictory, the
+ * RelOptInfo is marked dummy before returning.
+ */
+static RelOptInfo *
+build_append_child_rel(PlannerInfo *root,
+					   RelOptInfo *parent,
+					   Index childRTindex)
+{
+	RelOptInfo *childrel;
+	RangeTblEntry *childRTE = root->simple_rte_array[childRTindex];
+	AppendRelInfo *appinfo = root->append_rel_array[childRTindex];
+	List	   *childquals;
+	ListCell   *lc;
+	bool		have_const_false_cq;
+	Index		cq_min_security;
+
+	/* Build the RelOptInfo. */
+	childrel = build_simple_rel(root, childRTindex, parent);
+
+	/*
+	 * Propagate lateral_relids and lateral_referencers from appendrel
+	 * parent rels to their child rels.  We intentionally give each child rel
+	 * the same minimum parameterization, even though it's quite possible that
+	 * some don't reference all the lateral rels.  This is because any append
+	 * path for the parent will have to have the same parameterization for
+	 * every child anyway, and there's no value in forcing extra
+	 * reparameterize_path() calls.  Similarly, a lateral reference to the
+	 * parent prevents use of otherwise-movable join rels for each child.
+	 */
+	childrel->direct_lateral_relids = parent->direct_lateral_relids;
+	childrel->lateral_relids = parent->lateral_relids;
+	childrel->lateral_referencers = parent->lateral_referencers;
+
+	/*
+	 * We have to copy the parent's quals to the child, with appropriate
+	 * substitution of variables.  However, only the baserestrictinfo
+	 * quals are needed before we can check for constraint exclusion; so
+	 * do that first and then check to see if we can disregard this child.
+	 *
+	 * The child rel's targetlist might contain non-Var expressions, which
+	 * means that substitution into the quals could produce opportunities
+	 * for const-simplification, and perhaps even pseudoconstant quals.
+	 * Therefore, transform each RestrictInfo separately to see if it
+	 * reduces to a constant or pseudoconstant.  (We must process them
+	 * separately to keep track of the security level of each qual.)
+	 */
+	childquals = false;
+	cq_min_security = UINT_MAX;
+	have_const_false_cq = false;
+	foreach(lc, parent->baserestrictinfo)
+	{
+		RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
+		Node	   *childqual = (Node *) rinfo->clause;
+		ListCell   *lc2;
+
+		Assert(IsA(rinfo, RestrictInfo));
+		childqual = adjust_appendrel_attrs(root, childqual,
+										   1, &appinfo);
+		childqual = eval_const_expressions(root, childqual);
+		/* check for flat-out constant */
+		if (childqual && IsA(childqual, Const))
+		{
+			if (((Const *) childqual)->constisnull ||
+				!DatumGetBool(((Const *) childqual)->constvalue))
+			{
+				/* Restriction reduces to constant FALSE or NULL */
+				have_const_false_cq = true;
+				break;
+			}
+			/* Restriction reduces to constant TRUE, so drop it */
+			continue;
+		}
+		/* might have gotten an AND clause, if so flatten it */
+		foreach(lc2, make_ands_implicit((Expr *) childqual))
+		{
+			Node	   *onecq = (Node *) lfirst(lc2);
+			bool		pseudoconstant;
+
+			/* check for pseudoconstant (no Vars or volatile functions) */
+			pseudoconstant =
+					!contain_vars_of_level(onecq, 0) &&
+					!contain_volatile_functions(onecq);
+			if (pseudoconstant)
+			{
+				/* tell createplan.c to check for gating quals */
+				root->hasPseudoConstantQuals = true;
+			}
+			/* reconstitute RestrictInfo with appropriate properties */
+			childquals = lappend(childquals,
+								 make_restrictinfo((Expr *) onecq,
+												   rinfo->is_pushed_down,
+												   rinfo->outerjoin_delayed,
+												   pseudoconstant,
+												   rinfo->security_level,
+												   NULL, NULL, NULL));
+			cq_min_security = Min(cq_min_security, rinfo->security_level);
+		}
+	}
+
+	/*
+	 * In addition to the quals inherited from the parent, we might
+	 * have securityQuals associated with this particular child node.
+	 * (Currently this can only happen in appendrels originating from
+	 * UNION ALL; inheritance child tables don't have their own
+	 * securityQuals.)	Pull any such securityQuals up into the
+	 * baserestrictinfo for the child.  This is similar to
+	 * process_security_barrier_quals() for the parent rel, except
+	 * that we can't make any general deductions from such quals,
+	 * since they don't hold for the whole appendrel.
+	 */
+	if (childRTE->securityQuals)
+	{
+		Index		security_level = 0;
+
+		foreach(lc, childRTE->securityQuals)
+		{
+			List	   *qualset = (List *) lfirst(lc);
+			ListCell   *lc2;
+
+			foreach(lc2, qualset)
+			{
+				Expr	   *qual = (Expr *) lfirst(lc2);
+
+				/*
+				 * not likely that we'd see constants here, so no
+				 * check
+				 */
+				childquals = lappend(childquals,
+									 make_restrictinfo(qual,
+													   true,
+													   false,
+													   false,
+													   security_level,
+													   NULL, NULL,
+													   NULL));
+				cq_min_security = Min(cq_min_security, security_level);
+			}
+			security_level++;
+		}
+		Assert(security_level <= root->qual_security_level);
+	}
+
+	/* Set child's version of baserestrictinfo. */
+	childrel->baserestrictinfo = childquals;
+	childrel->baserestrict_min_security = cq_min_security;
+
+	if (have_const_false_cq)
+	{
+		/*
+		 * Some restriction clause reduced to constant FALSE or NULL after
+		 * substitution, so this child need not be scanned.
+		 */
+		set_dummy_rel_pathlist(childrel);
+	}
+
+	return childrel;
+}
+
+/*
+ * add_rowmark_junk_columns
+ * 		Add necessary junk columns for rowmarked inheritance parent rel.
+ *
+ * These values are needed for locking of rels selected FOR UPDATE/SHARE, and
+ * to do EvalPlanQual rechecking.  See comments for PlanRowMark in
+ * plannodes.h.
+ */
+static List *
+add_rowmark_junk_columns(PlannerInfo *root, PlanRowMark *rc)
+{
+	List   *tlist = root->processed_tlist;
+	Var		   *var;
+	char		resname[32];
+	TargetEntry *tle;
+
+	if (rc->allMarkTypes & ~(1 << ROW_MARK_COPY))
+	{
+		/* Need to fetch TID */
+		var = makeVar(rc->rti,
+					  SelfItemPointerAttributeNumber,
+					  TIDOID,
+					  -1,
+					  InvalidOid,
+					  0);
+		snprintf(resname, sizeof(resname), "ctid%u", rc->rowmarkId);
+		tle = makeTargetEntry((Expr *) var,
+							  list_length(tlist) + 1,
+							  pstrdup(resname),
+							  true);
+		tlist = lappend(tlist, tle);
+	}
+	if (rc->allMarkTypes & (1 << ROW_MARK_COPY))
+	{
+		/* Need the whole row as a junk var */
+		var = makeWholeRowVar(root->simple_rte_array[rc->rti],
+							  rc->rti,
+							  0,
+							  false);
+		snprintf(resname, sizeof(resname), "wholerow%u", rc->rowmarkId);
+		tle = makeTargetEntry((Expr *) var,
+							  list_length(tlist) + 1,
+							  pstrdup(resname),
+							  true);
+		tlist = lappend(tlist, tle);
+	}
+
+	/* For inheritance cases, always fetch the tableoid too. */
+	var = makeVar(rc->rti,
+				  TableOidAttributeNumber,
+				  OIDOID,
+				  -1,
+				  InvalidOid,
+				  0);
+	snprintf(resname, sizeof(resname), "tableoid%u", rc->rowmarkId);
+	tle = makeTargetEntry((Expr *) var,
+						  list_length(tlist) + 1,
+						  pstrdup(resname),
+						  true);
+	tlist = lappend(tlist, tle);
+
+	return tlist;
+}
diff --git a/src/backend/optimizer/util/appendinfo.c b/src/backend/optimizer/util/appendinfo.c
new file mode 100644
index 0000000000..9502535e53
--- /dev/null
+++ b/src/backend/optimizer/util/appendinfo.c
@@ -0,0 +1,851 @@
+/*-------------------------------------------------------------------------
+ *
+ * appendinfo.c
+ *	  Routines for mapping between append parent(s) and children
+ *
+ * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/optimizer/path/appendinfo.c
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include "access/htup_details.h"
+#include "access/sysattr.h"
+#include "nodes/makefuncs.h"
+#include "nodes/nodeFuncs.h"
+#include "optimizer/appendinfo.h"
+#include "parser/parsetree.h"
+#include "utils/rel.h"
+#include "utils/lsyscache.h"
+#include "utils/syscache.h"
+
+typedef struct
+{
+	PlannerInfo *root;
+	int			nappinfos;
+	AppendRelInfo **appinfos;
+} adjust_appendrel_attrs_context;
+
+static void make_inh_translation_list(TupleDesc old_tupdesc,
+						  TupleDesc new_tupdesc,
+						  Oid from_rel, Oid to_rel,
+						  Index newvarno, List **translated_vars);
+static Node *adjust_appendrel_attrs_mutator(Node *node,
+							   adjust_appendrel_attrs_context *context);
+static Relids adjust_child_relids(Relids relids, int nappinfos,
+					AppendRelInfo **appinfos);
+static List *adjust_inherited_tlist(List *tlist,
+					   AppendRelInfo *context);
+
+AppendRelInfo *
+make_append_rel_info(RelOptInfo *parentrel, RangeTblEntry *parentrte,
+					 TupleDesc childdesc, Oid childoid, Oid childreltype,
+					 Index childRTindex)
+{
+	AppendRelInfo  *appinfo = makeNode(AppendRelInfo);
+
+	appinfo->parent_relid = parentrel->relid;
+	appinfo->child_relid = childRTindex;
+	appinfo->parent_reltype = parentrel->reltype;
+	appinfo->child_reltype = childreltype;
+	make_inh_translation_list(parentrel->tupdesc, childdesc,
+							  parentrte->relid, childoid,
+							  childRTindex,
+							  &appinfo->translated_vars);
+	appinfo->parent_reloid = parentrte->relid;
+
+	return appinfo;
+}
+
+/*
+ * adjust_appendrel_attrs
+ *	  Copy the specified query or expression and translate Vars referring to a
+ *	  parent rel to refer to the corresponding child rel instead.  We also
+ *	  update rtindexes appearing outside Vars, such as resultRelation and
+ *	  jointree relids.
+ *
+ * Note: this is only applied after conversion of sublinks to subplans,
+ * so we don't need to cope with recursion into sub-queries.
+ *
+ * Note: this is not hugely different from what pullup_replace_vars() does;
+ * maybe we should try to fold the two routines together.
+ */
+Node *
+adjust_appendrel_attrs(PlannerInfo *root, Node *node, int nappinfos,
+					   AppendRelInfo **appinfos)
+{
+	Node	   *result;
+	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);
+
+	/*
+	 * Must be prepared to start with a Query or a bare expression tree.
+	 */
+	if (node && IsA(node, Query))
+	{
+		Query	   *newnode;
+		int			cnt;
+
+		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;
+}
+
+static Node *
+adjust_appendrel_attrs_mutator(Node *node,
+							   adjust_appendrel_attrs_context *context)
+{
+	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;
+
+		for (cnt = 0; cnt < nappinfos; cnt++)
+		{
+			if (var->varno == appinfos[cnt]->parent_relid)
+			{
+				appinfo = appinfos[cnt];
+				break;
+			}
+		}
+
+		if (var->varlevelsup == 0 && appinfo)
+		{
+			var->varno = appinfo->child_relid;
+			var->varnoold = appinfo->child_relid;
+			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));
+				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;
+
+					return (Node *) rowexpr;
+				}
+			}
+			/* system attributes don't need any other translation */
+		}
+		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, 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 */
+		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, context->nappinfos,
+											  context->appinfos);
+		return (Node *) phv;
+	}
+
+	/*
+	 * This is needed, because inheritance_make_rel_from_joinlist needs to
+	 * translate root->join_info_list executing make_rel_from_joinlist for a
+	 * given child.
+	 */
+	if (IsA(node, SpecialJoinInfo))
+	{
+		SpecialJoinInfo *oldinfo = (SpecialJoinInfo *) node;
+		SpecialJoinInfo *newinfo = makeNode(SpecialJoinInfo);
+
+		memcpy(newinfo, oldinfo, sizeof(SpecialJoinInfo));
+		newinfo->min_lefthand = adjust_child_relids(oldinfo->min_lefthand,
+													context->nappinfos,
+													context->appinfos);
+		newinfo->min_righthand = adjust_child_relids(oldinfo->min_righthand,
+													 context->nappinfos,
+													 context->appinfos);
+		newinfo->syn_lefthand = adjust_child_relids(oldinfo->syn_lefthand,
+													context->nappinfos,
+													context->appinfos);
+		newinfo->syn_righthand = adjust_child_relids(oldinfo->syn_righthand,
+													 context->nappinfos,
+													 context->appinfos);
+		newinfo->semi_rhs_exprs =
+					(List *) expression_tree_mutator((Node *)
+													 oldinfo->semi_rhs_exprs,
+													 adjust_appendrel_attrs_mutator,
+													 (void *) context);
+		return (Node *) newinfo;
+	}
+
+	/* Shouldn't need to handle planner auxiliary nodes here */
+	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 */
+		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->nullable_relids = adjust_child_relids(oldinfo->nullable_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));
+
+	return expression_tree_mutator(node, adjust_appendrel_attrs_mutator,
+								   (void *) context);
+}
+
+/*
+ * Substitute child relids for parent relids in a Relid set.  The array of
+ * appinfos specifies the substitutions to be performed.
+ */
+static Relids
+adjust_child_relids(Relids relids, int nappinfos, AppendRelInfo **appinfos)
+{
+	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;
+}
+
+/*
+ * Replace any relid present in top_parent_relids with its child in
+ * child_relids. Members of child_relids can be multiple levels below top
+ * parent in the partition hierarchy.
+ */
+Relids
+adjust_child_relids_multilevel(PlannerInfo *root, Relids relids,
+							   Relids child_relids, Relids top_parent_relids)
+{
+	AppendRelInfo **appinfos;
+	int			nappinfos;
+	Relids		parent_relids = NULL;
+	Relids		result;
+	Relids		tmp_result = NULL;
+	int			cnt;
+
+	/*
+	 * If the given relids set doesn't contain any of the top parent relids,
+	 * it will remain unchanged.
+	 */
+	if (!bms_overlap(relids, top_parent_relids))
+		return relids;
+
+	appinfos = find_appinfos_by_relids(root, child_relids, &nappinfos);
+
+	/* Construct relids set for the immediate parent of the given child. */
+	for (cnt = 0; cnt < nappinfos; cnt++)
+	{
+		AppendRelInfo *appinfo = appinfos[cnt];
+
+		parent_relids = bms_add_member(parent_relids, appinfo->parent_relid);
+	}
+
+	/* Recurse if immediate parent is not the top parent. */
+	if (!bms_equal(parent_relids, top_parent_relids))
+	{
+		tmp_result = adjust_child_relids_multilevel(root, relids,
+													parent_relids,
+													top_parent_relids);
+		relids = tmp_result;
+	}
+
+	result = adjust_child_relids(relids, nappinfos, appinfos);
+
+	/* Free memory consumed by any intermediate result. */
+	if (tmp_result)
+		bms_free(tmp_result);
+	bms_free(parent_relids);
+	pfree(appinfos);
+
+	return result;
+}
+
+/*
+ * adjust_appendrel_attrs_multilevel
+ *	  Apply Var translations from a toplevel appendrel parent down to a child.
+ *
+ * In some cases we need to translate expressions referencing a parent relation
+ * to reference an appendrel child that's multiple levels removed from it.
+ */
+Node *
+adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node,
+								  Relids child_relids,
+								  Relids top_parent_relids)
+{
+	AppendRelInfo **appinfos;
+	Bitmapset  *parent_relids = NULL;
+	int			nappinfos;
+	int			cnt;
+
+	Assert(bms_num_members(child_relids) == bms_num_members(top_parent_relids));
+
+	appinfos = find_appinfos_by_relids(root, child_relids, &nappinfos);
+
+	/* Construct relids set for the immediate parent of given child. */
+	for (cnt = 0; cnt < nappinfos; cnt++)
+	{
+		AppendRelInfo *appinfo = appinfos[cnt];
+
+		parent_relids = bms_add_member(parent_relids, appinfo->parent_relid);
+	}
+
+	/* Recurse if immediate parent is not the top parent. */
+	if (!bms_equal(parent_relids, top_parent_relids))
+		node = adjust_appendrel_attrs_multilevel(root, node, parent_relids,
+												 top_parent_relids);
+
+	/* Now translate for this child */
+	node = adjust_appendrel_attrs(root, node, nappinfos, appinfos);
+
+	pfree(appinfos);
+
+	return node;
+}
+
+/*
+ * Construct the SpecialJoinInfo for a child-join by translating
+ * SpecialJoinInfo for the join between parents. left_relids and right_relids
+ * are the relids of left and right side of the join respectively.
+ */
+SpecialJoinInfo *
+build_child_join_sjinfo(PlannerInfo *root, SpecialJoinInfo *parent_sjinfo,
+						Relids left_relids, Relids right_relids)
+{
+	SpecialJoinInfo *sjinfo = makeNode(SpecialJoinInfo);
+	AppendRelInfo **left_appinfos;
+	int			left_nappinfos;
+	AppendRelInfo **right_appinfos;
+	int			right_nappinfos;
+
+	memcpy(sjinfo, parent_sjinfo, sizeof(SpecialJoinInfo));
+	left_appinfos = find_appinfos_by_relids(root, left_relids,
+											&left_nappinfos);
+	right_appinfos = find_appinfos_by_relids(root, right_relids,
+											 &right_nappinfos);
+
+	sjinfo->min_lefthand = adjust_child_relids(sjinfo->min_lefthand,
+											   left_nappinfos, left_appinfos);
+	sjinfo->min_righthand = adjust_child_relids(sjinfo->min_righthand,
+												right_nappinfos,
+												right_appinfos);
+	sjinfo->syn_lefthand = adjust_child_relids(sjinfo->syn_lefthand,
+											   left_nappinfos, left_appinfos);
+	sjinfo->syn_righthand = adjust_child_relids(sjinfo->syn_righthand,
+												right_nappinfos,
+												right_appinfos);
+	sjinfo->semi_rhs_exprs = (List *) adjust_appendrel_attrs(root,
+															 (Node *) sjinfo->semi_rhs_exprs,
+															 right_nappinfos,
+															 right_appinfos);
+
+	pfree(left_appinfos);
+	pfree(right_appinfos);
+
+	return sjinfo;
+}
+
+/*
+ * find_appinfos_by_relids
+ * 		Find AppendRelInfo structures for all relations specified by relids.
+ *
+ * The AppendRelInfos are returned in an array, which can be pfree'd by the
+ * caller. *nappinfos is set to the number of entries in the array.
+ */
+AppendRelInfo **
+find_appinfos_by_relids(PlannerInfo *root, Relids relids, int *nappinfos)
+{
+	AppendRelInfo **appinfos;
+	int			cnt = 0;
+	int			i;
+
+	*nappinfos = bms_num_members(relids);
+	appinfos = (AppendRelInfo **) palloc(sizeof(AppendRelInfo *) * *nappinfos);
+
+	i = -1;
+	while ((i = bms_next_member(relids, i)) >= 0)
+	{
+		AppendRelInfo *appinfo = root->append_rel_array[i];
+
+		if (!appinfo)
+			elog(ERROR, "child rel %d not found in append_rel_array", i);
+
+		appinfos[cnt++] = appinfo;
+	}
+	return appinfos;
+}
+
+/*
+ * make_inh_translation_list
+ *	  Build the list of translations from parent Vars to child Vars for
+ *	  an inheritance child.
+ *
+ * For paranoia's sake, we match type/collation as well as attribute name.
+ */
+static void
+make_inh_translation_list(TupleDesc old_tupdesc, TupleDesc new_tupdesc,
+						  Oid from_rel, Oid to_rel,
+						  Index newvarno, List **translated_vars)
+{
+	List	   *vars = NIL;
+	int			oldnatts = old_tupdesc->natts;
+	int			newnatts = new_tupdesc->natts;
+	int			old_attno;
+	int			new_attno = 0;
+
+	for (old_attno = 0; old_attno < oldnatts; old_attno++)
+	{
+		Form_pg_attribute att;
+		char	   *attname;
+		Oid			atttypid;
+		int32		atttypmod;
+		Oid			attcollation;
+
+		att = TupleDescAttr(old_tupdesc, old_attno);
+		if (att->attisdropped)
+		{
+			/* Just put NULL into this list entry */
+			vars = lappend(vars, NULL);
+			continue;
+		}
+		attname = NameStr(att->attname);
+		atttypid = att->atttypid;
+		atttypmod = att->atttypmod;
+		attcollation = att->attcollation;
+
+		/*
+		 * When we are generating the "translation list" for the parent table
+		 * of an inheritance set, no need to search for matches.
+		 */
+		if (from_rel == to_rel)
+		{
+			vars = lappend(vars, makeVar(newvarno,
+										 (AttrNumber) (old_attno + 1),
+										 atttypid,
+										 atttypmod,
+										 attcollation,
+										 0));
+			continue;
+		}
+
+		/*
+		 * Otherwise we have to search for the matching column by name.
+		 * There's no guarantee it'll have the same column position, because
+		 * of cases like ALTER TABLE ADD COLUMN and multiple inheritance.
+		 * However, in simple cases, the relative order of columns is mostly
+		 * the same in both relations, so try the column of newrelation that
+		 * follows immediately after the one that we just found, and if that
+		 * fails, let syscache handle it.
+		 */
+		if (new_attno >= newnatts ||
+			(att = TupleDescAttr(new_tupdesc, new_attno))->attisdropped ||
+			strcmp(attname, NameStr(att->attname)) != 0)
+		{
+			HeapTuple	newtup;
+
+			newtup = SearchSysCacheAttName(to_rel, attname);
+			if (!newtup)
+				elog(ERROR, "could not find inherited attribute \"%s\" of relation \"%s\"",
+					 attname, get_rel_name(to_rel));
+			new_attno = ((Form_pg_attribute) GETSTRUCT(newtup))->attnum - 1;
+			ReleaseSysCache(newtup);
+
+			att = TupleDescAttr(new_tupdesc, new_attno);
+		}
+
+		/* Found it, check type and collation match */
+		if (atttypid != att->atttypid || atttypmod != att->atttypmod)
+			elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's type",
+				 attname, get_rel_name(to_rel));
+		if (attcollation != att->attcollation)
+			elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's collation",
+				 attname, get_rel_name(to_rel));
+
+		vars = lappend(vars, makeVar(newvarno,
+									 (AttrNumber) (new_attno + 1),
+									 atttypid,
+									 atttypmod,
+									 attcollation,
+									 0));
+		new_attno++;
+	}
+
+	*translated_vars = vars;
+}
+
+/*
+ * translate_col_privs
+ *	  Translate a bitmapset representing per-column privileges from the
+ *	  parent rel's attribute numbering to the child's.
+ *
+ * The only surprise here is that we don't translate a parent whole-row
+ * reference into a child whole-row reference.  That would mean requiring
+ * permissions on all child columns, which is overly strict, since the
+ * query is really only going to reference the inherited columns.  Instead
+ * we set the per-column bits for all inherited columns.
+ */
+Bitmapset *
+translate_col_privs(const Bitmapset *parent_privs,
+					List *translated_vars)
+{
+	Bitmapset  *child_privs = NULL;
+	bool		whole_row;
+	int			attno;
+	ListCell   *lc;
+
+	/* System attributes have the same numbers in all tables */
+	for (attno = FirstLowInvalidHeapAttributeNumber + 1; attno < 0; attno++)
+	{
+		if (bms_is_member(attno - FirstLowInvalidHeapAttributeNumber,
+						  parent_privs))
+			child_privs = bms_add_member(child_privs,
+										 attno - FirstLowInvalidHeapAttributeNumber);
+	}
+
+	/* Check if parent has whole-row reference */
+	whole_row = bms_is_member(InvalidAttrNumber - FirstLowInvalidHeapAttributeNumber,
+							  parent_privs);
+
+	/* And now translate the regular user attributes, using the vars list */
+	attno = InvalidAttrNumber;
+	foreach(lc, translated_vars)
+	{
+		Var		   *var = lfirst_node(Var, lc);
+
+		attno++;
+		if (var == NULL)		/* ignore dropped columns */
+			continue;
+		if (whole_row ||
+			bms_is_member(attno - FirstLowInvalidHeapAttributeNumber,
+						  parent_privs))
+			child_privs = bms_add_member(child_privs,
+										 var->varattno - FirstLowInvalidHeapAttributeNumber);
+	}
+
+	return child_privs;
+}
+
+/*
+ * 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.
+ */
+static List *
+adjust_inherited_tlist(List *tlist, AppendRelInfo *context)
+{
+	bool		changed_it = false;
+	ListCell   *tl;
+	List	   *new_tlist;
+	bool		more;
+	int			attrno;
+
+	/* 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)
+	{
+		TargetEntry *tle = (TargetEntry *) lfirst(tl);
+		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))
+			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);
+		if (childvar == NULL || !IsA(childvar, Var))
+			elog(ERROR, "attribute %d of relation \"%s\" does not exist",
+				 tle->resno, get_rel_name(context->parent_reloid));
+
+		if (tle->resno != childvar->varattno)
+		{
+			tle->resno = childvar->varattno;
+			changed_it = true;
+		}
+	}
+
+	/*
+	 * 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;
+
+	new_tlist = NIL;
+	more = true;
+	for (attrno = 1; more; attrno++)
+	{
+		more = false;
+		foreach(tl, tlist)
+		{
+			TargetEntry *tle = (TargetEntry *) lfirst(tl);
+
+			if (tle->resjunk)
+				continue;		/* ignore junk items */
+
+			if (tle->resno == attrno)
+				new_tlist = lappend(new_tlist, tle);
+			else if (tle->resno > attrno)
+				more = true;
+		}
+	}
+
+	foreach(tl, tlist)
+	{
+		TargetEntry *tle = (TargetEntry *) lfirst(tl);
+
+		if (!tle->resjunk)
+			continue;			/* here, ignore non-junk items */
+
+		tle->resno = attrno;
+		new_tlist = lappend(new_tlist, tle);
+		attrno++;
+	}
+
+	return new_tlist;
+}
diff --git a/src/backend/optimizer/util/pathnode.c b/src/backend/optimizer/util/pathnode.c
index d50d86b252..8ce88876c4 100644
--- a/src/backend/optimizer/util/pathnode.c
+++ b/src/backend/optimizer/util/pathnode.c
@@ -20,6 +20,7 @@
 #include "foreign/fdwapi.h"
 #include "nodes/extensible.h"
 #include "nodes/nodeFuncs.h"
+#include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index c23db9d78d..52a11f434f 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -17,6 +17,7 @@
 #include <limits.h>
 
 #include "miscadmin.h"
+#include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
diff --git a/src/backend/partitioning/partprune.c b/src/backend/partitioning/partprune.c
index bf17ae22ba..9120fcb0d3 100644
--- a/src/backend/partitioning/partprune.c
+++ b/src/backend/partitioning/partprune.c
@@ -44,6 +44,7 @@
 #include "miscadmin.h"
 #include "nodes/makefuncs.h"
 #include "nodes/nodeFuncs.h"
+#include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
diff --git a/src/include/optimizer/append.h b/src/include/optimizer/append.h
new file mode 100644
index 0000000000..5b44530279
--- /dev/null
+++ b/src/include/optimizer/append.h
@@ -0,0 +1,28 @@
+/*-------------------------------------------------------------------------
+ *
+ * append.h
+ *	  prototypes for append.c.
+ *
+ *
+ * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/optimizer/append.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef APPEND_H
+#define APPEND_H
+
+#include "nodes/relation.h"
+
+/*
+ * append.c
+ *	  utilities for dealing with append relations
+ */
+extern void expand_append_rel(PlannerInfo *root,
+						 RelOptInfo *rel,
+						 RangeTblEntry *rte,
+						 Index rti);
+
+#endif							/* APPEND_H */
diff --git a/src/include/optimizer/appendinfo.h b/src/include/optimizer/appendinfo.h
new file mode 100644
index 0000000000..e205e78e6d
--- /dev/null
+++ b/src/include/optimizer/appendinfo.h
@@ -0,0 +1,43 @@
+/*-------------------------------------------------------------------------
+ *
+ * appendinfo.h
+ *	  Routines for mapping expressions between append rel parent(s) and
+ *	  children
+ *
+ * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/optimizer/appendinfo.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef APPENDINFO_H
+#define APPENDINFO_H
+
+#include "nodes/plannodes.h"
+#include "nodes/relation.h"
+#include "utils/relcache.h"
+
+extern AppendRelInfo *make_append_rel_info(RelOptInfo *parentrel,
+					 RangeTblEntry *parentrte,
+					 TupleDesc childdesc, Oid childoid, Oid childreltype,
+					 Index childRTindex);
+extern Bitmapset *translate_col_privs(const Bitmapset *parent_privs,
+					List *translated_vars);
+extern Node *adjust_appendrel_attrs(PlannerInfo *root, Node *node,
+					   int nappinfos, AppendRelInfo **appinfos);
+
+extern Node *adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node,
+								  Relids child_relids,
+								  Relids top_parent_relids);
+
+extern AppendRelInfo **find_appinfos_by_relids(PlannerInfo *root,
+						Relids relids, int *nappinfos);
+
+extern SpecialJoinInfo *build_child_join_sjinfo(PlannerInfo *root,
+						SpecialJoinInfo *parent_sjinfo,
+						Relids left_relids, Relids right_relids);
+extern Relids adjust_child_relids_multilevel(PlannerInfo *root, Relids relids,
+							   Relids child_relids, Relids top_parent_relids);
+
+#endif							/* APPENDINFO_H */
diff --git a/src/include/optimizer/prep.h b/src/include/optimizer/prep.h
index e8e21e2ed5..0e2cdbc539 100644
--- a/src/include/optimizer/prep.h
+++ b/src/include/optimizer/prep.h
@@ -46,26 +46,5 @@ extern PlanRowMark *get_plan_rowmark(List *rowmarks, Index rtindex);
  * prototypes for prepunion.c
  */
 extern RelOptInfo *plan_set_operations(PlannerInfo *root);
-extern void expand_append_rel(PlannerInfo *root,
-						 RelOptInfo *rel,
-						 RangeTblEntry *rte,
-						 Index rti);
-extern Node *adjust_appendrel_attrs(PlannerInfo *root, Node *node,
-					   int nappinfos, AppendRelInfo **appinfos);
-extern AppendRelInfo *make_append_rel_info(RelOptInfo *parentrel,
-					 RangeTblEntry *parentrte,
-					 TupleDesc childdesc, Oid childoid, Oid childreltype,
-					 Index childRTindex);
-extern Node *adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node,
-								  Relids child_relids,
-								  Relids top_parent_relids);
 
-extern AppendRelInfo **find_appinfos_by_relids(PlannerInfo *root,
-						Relids relids, int *nappinfos);
-
-extern SpecialJoinInfo *build_child_join_sjinfo(PlannerInfo *root,
-						SpecialJoinInfo *parent_sjinfo,
-						Relids left_relids, Relids right_relids);
-extern Relids adjust_child_relids_multilevel(PlannerInfo *root, Relids relids,
-							   Relids child_relids, Relids top_parent_relids);
 #endif							/* PREP_H */
-- 
2.11.0

From b869df16ad56eb7970085fe6cbf20cd0d5ab3be8 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Mon, 15 Oct 2018 10:59:24 +0900
Subject: [PATCH v5 5/6] Teach planner to only process unpruned partitions

This adds a bitmapset field live_parts to RelOptInfo and stores
the partition indexes of non-dummy partitions in it, meaning it
contains indexes of only those partitions that have a non-NULL
RelOptInfo present in its parent's RelOptInfo's part_rels array.

This speeds up processing partitioned table's partitions compared
to going through the whole part_rels array in a number of places.
---
 src/backend/optimizer/path/joinrels.c |  3 +++
 src/backend/optimizer/plan/planner.c  | 18 +++++++++---------
 src/backend/optimizer/util/append.c   |  8 ++++++++
 src/backend/optimizer/util/relnode.c  |  3 +++
 src/backend/partitioning/partprune.c  | 18 +++++-------------
 src/include/nodes/relation.h          |  2 ++
 6 files changed, 30 insertions(+), 22 deletions(-)

diff --git a/src/backend/optimizer/path/joinrels.c b/src/backend/optimizer/path/joinrels.c
index 6e321ec9e7..76531a05cf 100644
--- a/src/backend/optimizer/path/joinrels.c
+++ b/src/backend/optimizer/path/joinrels.c
@@ -1424,6 +1424,9 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
 		populate_joinrel_with_paths(root, child_rel1, child_rel2,
 									child_joinrel, child_sjinfo,
 									child_restrictlist);
+		if (!IS_DUMMY_REL(child_joinrel))
+			joinrel->live_parts = bms_add_member(joinrel->live_parts,
+												 cnt_parts);
 	}
 }
 
diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index 216cadfba9..c60c491b61 100644
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -6766,7 +6766,9 @@ apply_scanjoin_target_to_paths(PlannerInfo *root,
 		List	   *live_children = NIL;
 
 		/* Adjust each partition. */
-		for (partition_idx = 0; partition_idx < rel->nparts; partition_idx++)
+		partition_idx = -1;
+		while ((partition_idx = bms_next_member(rel->live_parts,
+												partition_idx)) >= 0)
 		{
 			RelOptInfo *child_rel = rel->part_rels[partition_idx];
 			ListCell   *lc;
@@ -6774,9 +6776,7 @@ apply_scanjoin_target_to_paths(PlannerInfo *root,
 			int			nappinfos;
 			List	   *child_scanjoin_targets = NIL;
 
-			/* Skip processing pruned partitions. */
-			if (child_rel == NULL)
-				continue;
+			Assert(child_rel != NULL);
 
 			/* Translate scan/join targets for this child. */
 			appinfos = find_appinfos_by_relids(root, child_rel->relids,
@@ -6857,7 +6857,6 @@ create_partitionwise_grouping_paths(PlannerInfo *root,
 									PartitionwiseAggregateType patype,
 									GroupPathExtraData *extra)
 {
-	int			nparts = input_rel->nparts;
 	int			cnt_parts;
 	List	   *grouped_live_children = NIL;
 	List	   *partially_grouped_live_children = NIL;
@@ -6869,7 +6868,9 @@ create_partitionwise_grouping_paths(PlannerInfo *root,
 		   partially_grouped_rel != NULL);
 
 	/* Add paths for partitionwise aggregation/grouping. */
-	for (cnt_parts = 0; cnt_parts < nparts; cnt_parts++)
+	cnt_parts = -1;
+	while ((cnt_parts = bms_next_member(input_rel->live_parts,
+										cnt_parts)) >= 0)
 	{
 		RelOptInfo *child_input_rel = input_rel->part_rels[cnt_parts];
 		PathTarget *child_target = copy_pathtarget(target);
@@ -6879,9 +6880,8 @@ create_partitionwise_grouping_paths(PlannerInfo *root,
 		RelOptInfo *child_grouped_rel;
 		RelOptInfo *child_partially_grouped_rel;
 
-		/* Skip processing pruned partitions. */
-		if (child_input_rel == NULL)
-			continue;
+		/* A live partition must have a RelOptInfo. */
+		Assert(child_input_rel != NULL);
 
 		/* Input child rel must have a path */
 		Assert(child_input_rel->pathlist != NIL);
diff --git a/src/backend/optimizer/util/append.c b/src/backend/optimizer/util/append.c
index bbc579817a..2ca8e8d0ff 100644
--- a/src/backend/optimizer/util/append.c
+++ b/src/backend/optimizer/util/append.c
@@ -307,6 +307,7 @@ expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
 
 	/* Perform pruning. */
 	partindexes = prune_append_rel_partitions(parentrel);
+	parentrel->live_parts = partindexes;
 
 	/* Must expand PlannerInfo arrays before we can add children. */
 	expand_planner_arrays(root, bms_num_members(partindexes));
@@ -347,6 +348,13 @@ expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
 		Assert(childrel != NULL);
 		parentrel->part_rels[i] = childrel;
 
+		/*
+		 * If partition is excluded by constraints, remove it from
+		 * live_parts, too.
+		 */
+		if (IS_DUMMY_REL(childrel))
+			parentrel->live_parts = bms_del_member(parentrel->live_parts, i);
+
 		/* Close child relations, but keep locks */
 		heap_close(newrelation, NoLock);
 	}
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index 52a11f434f..6c7eafe6db 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -1748,6 +1748,9 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
 		joinrel->partexprs[cnt] = partexpr;
 		joinrel->nullable_partexprs[cnt] = nullable_partexpr;
 	}
+
+	/* Partitions will be added by try_partitionwise_join. */
+	joinrel->live_parts = NULL;
 }
 
 /*
diff --git a/src/backend/partitioning/partprune.c b/src/backend/partitioning/partprune.c
index 9120fcb0d3..2ed5c9e8dd 100644
--- a/src/backend/partitioning/partprune.c
+++ b/src/backend/partitioning/partprune.c
@@ -441,29 +441,21 @@ make_partitionedrel_pruneinfo(PlannerInfo *root, RelOptInfo *parentrel,
 		memset(subplan_map, -1, nparts * sizeof(int));
 		subpart_map = (int *) palloc(nparts * sizeof(int));
 		memset(subpart_map, -1, nparts * sizeof(int));
-		present_parts = NULL;
+		present_parts = bms_copy(subpart->live_parts);
 
-		for (i = 0; i < nparts; i++)
+		i = -1;
+		while ((i = bms_next_member(present_parts, i)) >= 0)
 		{
 			RelOptInfo *partrel = subpart->part_rels[i];
 			int			subplanidx;
 			int			subpartidx;
 
-			/* Skip processing pruned partitions. */
-			if (partrel == NULL)
-				continue;
-
+			Assert(partrel != NULL);
 			subplan_map[i] = subplanidx = relid_subplan_map[partrel->relid] - 1;
 			subpart_map[i] = subpartidx = relid_subpart_map[partrel->relid] - 1;
+			/* Record finding this subplan */
 			if (subplanidx >= 0)
-			{
-				present_parts = bms_add_member(present_parts, i);
-
-				/* Record finding this subplan  */
 				subplansfound = bms_add_member(subplansfound, subplanidx);
-			}
-			else if (subpartidx >= 0)
-				present_parts = bms_add_member(present_parts, i);
 		}
 
 		pinfo = makeNode(PartitionedRelPruneInfo);
diff --git a/src/include/nodes/relation.h b/src/include/nodes/relation.h
index 6b614e4794..7e5e4e2c6a 100644
--- a/src/include/nodes/relation.h
+++ b/src/include/nodes/relation.h
@@ -714,6 +714,8 @@ typedef struct RelOptInfo
 	Oid		   *part_oids;		/* partition OIDs */
 	struct RelOptInfo **part_rels;	/* Array of RelOptInfos of partitions,
 									 * stored in the same order of bounds */
+	Bitmapset  *live_parts;		/* Set of live partitions; contains indexes
+								 * into part_rels array */
 	List	  **partexprs;		/* Non-nullable partition key expressions. */
 	List	  **nullable_partexprs; /* Nullable partition key expressions. */
 	List	   *partitioned_child_rels; /* List of RT indexes. */
-- 
2.11.0

From 289fff1a50deead4b2b743d62056b613a916c221 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Fri, 12 Oct 2018 19:12:53 +0900
Subject: [PATCH v5 6/6] Do not lock all partitions at the beginning

---
 src/backend/optimizer/util/append.c | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

diff --git a/src/backend/optimizer/util/append.c b/src/backend/optimizer/util/append.c
index 2ca8e8d0ff..f1627aef33 100644
--- a/src/backend/optimizer/util/append.c
+++ b/src/backend/optimizer/util/append.c
@@ -291,10 +291,6 @@ expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
 									parentrel->inh_root_parent :
 									parentRTindex;
 
-	/* If root partitioned table, lock *all* partitions in the tree. */
-	if (parentRTindex == rootParentRTindex)
-		(void) find_all_inheritors(parentrte->relid, lockmode, NULL);
-
 	/*
 	 * Initialize partitioned_child_rels to contain this RT index.
 	 *
@@ -328,8 +324,7 @@ expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
 		Relation	newrelation;
 		RelOptInfo *childrel;
 
-		/* Already locked above. */
-		newrelation = heap_open(childOID, NoLock);
+		newrelation = heap_open(childOID, lockmode);
 		Assert(!RELATION_IS_OTHER_TEMP(newrelation));
 
 		/*
-- 
2.11.0

diff --git a/src/backend/optimizer/path/equivclass.c b/src/backend/optimizer/path/equivclass.c
index 5ace28eab0..7212f2d3bc 100644
--- a/src/backend/optimizer/path/equivclass.c
+++ b/src/backend/optimizer/path/equivclass.c
@@ -675,7 +675,10 @@ get_eclass_for_sort_expr(PlannerInfo *root,
 			 */
 			if (cur_em->em_is_child &&
 				!bms_equal(cur_em->em_relids, rel))
+			{
+				verify_em_child(root, cur_em);
 				continue;
+			}
 
 			/*
 			 * If below an outer join, don't match constants: they're not as
@@ -2002,7 +2005,10 @@ exprs_known_equal(PlannerInfo *root, Node *item1, Node *item2)
 			EquivalenceMember *em = (EquivalenceMember *) lfirst(lc2);
 
 			if (em->em_is_child)
+			{
+				verify_em_child(root, em);
 				continue;		/* ignore children here */
+			}
 			if (equal(item1, em->em_expr))
 				item1member = true;
 			else if (equal(item2, em->em_expr))
@@ -2059,7 +2065,10 @@ match_eclasses_to_foreign_key_col(PlannerInfo *root,
 			Var		   *var;
 
 			if (em->em_is_child)
+			{
+				verify_em_child(root, em);
 				continue;		/* ignore children here */
+			}
 
 			/* EM must be a Var, possibly with RelabelType */
 			var = (Var *) em->em_expr;
@@ -2286,7 +2295,10 @@ generate_implied_equalities_for_column(PlannerInfo *root,
 			RestrictInfo *rinfo;
 
 			if (other_em->em_is_child)
+			{
+				verify_em_child(root, other_em);
 				continue;		/* ignore children here */
+			}
 
 			/* Make sure it'll be a join to a different rel */
 			if (other_em == cur_em ||
@@ -2386,6 +2398,21 @@ have_relevant_eclass_joinclause(PlannerInfo *root,
 	return false;
 }
 
+void
+verify_em_child(PlannerInfo *root, EquivalenceMember *em)
+{
+	int relid;
+	Assert(em->em_is_child);
+
+	relid = -1;
+	while ((relid = bms_next_member(em->em_relids, relid)) >= 0)
+	{
+		if (root->simple_rel_array[relid]->reloptkind == RELOPT_BASEREL)
+			elog(WARNING, "child EquivalenceMember skipped: %s", nodeToString(em->em_expr));
+	}
+}
+
+
 
 /*
  * has_relevant_eclass_joinclause
@@ -2476,7 +2503,10 @@ eclass_useful_for_merging(PlannerInfo *root,
 		EquivalenceMember *cur_em = (EquivalenceMember *) lfirst(lc);
 
 		if (cur_em->em_is_child)
+		{
+			verify_em_child(root, cur_em);
 			continue;			/* ignore children here */
+		}
 
 		if (!bms_overlap(cur_em->em_relids, relids))
 			return true;
diff --git a/src/backend/optimizer/path/pathkeys.c b/src/backend/optimizer/path/pathkeys.c
index ec66cb9c3c..27bff4a56d 100644
--- a/src/backend/optimizer/path/pathkeys.c
+++ b/src/backend/optimizer/path/pathkeys.c
@@ -717,7 +717,10 @@ convert_subquery_pathkeys(PlannerInfo *root, RelOptInfo *rel,
 				ListCell   *k;
 
 				if (sub_member->em_is_child)
+				{
+					verify_em_child(rel->subroot, sub_member);
 					continue;	/* ignore children here */
+				}
 
 				foreach(k, subquery_tlist)
 				{
@@ -1179,6 +1182,8 @@ select_outer_pathkeys_for_merge(PlannerInfo *root,
 			if (!em->em_is_const && !em->em_is_child &&
 				!bms_overlap(em->em_relids, joinrel->relids))
 				score++;
+			else if (em->em_is_child)
+				verify_em_child(root, em);
 		}
 
 		ecs[necs] = oeclass;
diff --git a/src/backend/optimizer/plan/createplan.c b/src/backend/optimizer/plan/createplan.c
index 28c4b53fea..56a7c69775 100644
--- a/src/backend/optimizer/plan/createplan.c
+++ b/src/backend/optimizer/plan/createplan.c
@@ -237,7 +237,7 @@ static MergeJoin *make_mergejoin(List *tlist,
 static Sort *make_sort(Plan *lefttree, int numCols,
 		  AttrNumber *sortColIdx, Oid *sortOperators,
 		  Oid *collations, bool *nullsFirst);
-static Plan *prepare_sort_from_pathkeys(Plan *lefttree, List *pathkeys,
+static Plan *prepare_sort_from_pathkeys(PlannerInfo *root, Plan *lefttree, List *pathkeys,
 						   Relids relids,
 						   const AttrNumber *reqColIdx,
 						   bool adjust_tlist_in_place,
@@ -246,10 +246,10 @@ static Plan *prepare_sort_from_pathkeys(Plan *lefttree, List *pathkeys,
 						   Oid **p_sortOperators,
 						   Oid **p_collations,
 						   bool **p_nullsFirst);
-static EquivalenceMember *find_ec_member_for_tle(EquivalenceClass *ec,
+static EquivalenceMember *find_ec_member_for_tle(PlannerInfo *root,EquivalenceClass *ec,
 					   TargetEntry *tle,
 					   Relids relids);
-static Sort *make_sort_from_pathkeys(Plan *lefttree, List *pathkeys,
+static Sort *make_sort_from_pathkeys(PlannerInfo *root, Plan *lefttree, List *pathkeys,
 						Relids relids);
 static Sort *make_sort_from_groupcols(List *groupcls,
 						 AttrNumber *grpColIdx,
@@ -266,7 +266,7 @@ static Group *make_group(List *tlist, List *qual, int numGroupCols,
 		   AttrNumber *grpColIdx, Oid *grpOperators,
 		   Plan *lefttree);
 static Unique *make_unique_from_sortclauses(Plan *lefttree, List *distinctList);
-static Unique *make_unique_from_pathkeys(Plan *lefttree,
+static Unique *make_unique_from_pathkeys(PlannerInfo *root, Plan *lefttree,
 						  List *pathkeys, int numCols);
 static Gather *make_gather(List *qptlist, List *qpqual,
 			int nworkers, int rescan_param, bool single_copy, Plan *subplan);
@@ -1147,7 +1147,7 @@ create_merge_append_plan(PlannerInfo *root, MergeAppendPath *best_path)
 	plan->righttree = NULL;
 
 	/* Compute sort column info, and adjust MergeAppend's tlist as needed */
-	(void) prepare_sort_from_pathkeys(plan, pathkeys,
+	(void) prepare_sort_from_pathkeys(root, plan, pathkeys,
 									  best_path->path.parent->relids,
 									  NULL,
 									  true,
@@ -1177,7 +1177,7 @@ create_merge_append_plan(PlannerInfo *root, MergeAppendPath *best_path)
 		subplan = create_plan_recurse(root, subpath, CP_EXACT_TLIST);
 
 		/* Compute sort column info, and adjust subplan's tlist as needed */
-		subplan = prepare_sort_from_pathkeys(subplan, pathkeys,
+		subplan = prepare_sort_from_pathkeys(root, subplan, pathkeys,
 											 subpath->parent->relids,
 											 node->sortColIdx,
 											 false,
@@ -1606,7 +1606,7 @@ create_gather_merge_plan(PlannerInfo *root, GatherMergePath *best_path)
 	Assert(pathkeys != NIL);
 
 	/* Compute sort column info, and adjust subplan's tlist as needed */
-	subplan = prepare_sort_from_pathkeys(subplan, pathkeys,
+	subplan = prepare_sort_from_pathkeys(root, subplan, pathkeys,
 										 best_path->subpath->parent->relids,
 										 gm_plan->sortColIdx,
 										 false,
@@ -1788,7 +1788,7 @@ create_sort_plan(PlannerInfo *root, SortPath *best_path, int flags)
 	 * relids. Thus, if this sort path is based on a child relation, we must
 	 * pass its relids.
 	 */
-	plan = make_sort_from_pathkeys(subplan, best_path->path.pathkeys,
+	plan = make_sort_from_pathkeys(root, subplan, best_path->path.pathkeys,
 								   IS_OTHER_REL(best_path->subpath->parent) ?
 								   best_path->path.parent->relids : NULL);
 
@@ -1853,7 +1853,7 @@ create_upper_unique_plan(PlannerInfo *root, UpperUniquePath *best_path, int flag
 	subplan = create_plan_recurse(root, best_path->subpath,
 								  flags | CP_LABEL_TLIST);
 
-	plan = make_unique_from_pathkeys(subplan,
+	plan = make_unique_from_pathkeys(root, subplan,
 									 best_path->path.pathkeys,
 									 best_path->numkeys);
 
@@ -3879,7 +3879,7 @@ create_mergejoin_plan(PlannerInfo *root,
 	if (best_path->outersortkeys)
 	{
 		Relids		outer_relids = outer_path->parent->relids;
-		Sort	   *sort = make_sort_from_pathkeys(outer_plan,
+		Sort	   *sort = make_sort_from_pathkeys(root, outer_plan,
 												   best_path->outersortkeys,
 												   outer_relids);
 
@@ -3893,7 +3893,7 @@ create_mergejoin_plan(PlannerInfo *root,
 	if (best_path->innersortkeys)
 	{
 		Relids		inner_relids = inner_path->parent->relids;
-		Sort	   *sort = make_sort_from_pathkeys(inner_plan,
+		Sort	   *sort = make_sort_from_pathkeys(root, inner_plan,
 												   best_path->innersortkeys,
 												   inner_relids);
 
@@ -5604,7 +5604,7 @@ make_sort(Plan *lefttree, int numCols,
  * or a Result stacked atop lefttree).
  */
 static Plan *
-prepare_sort_from_pathkeys(Plan *lefttree, List *pathkeys,
+prepare_sort_from_pathkeys(PlannerInfo *root, Plan *lefttree, List *pathkeys,
 						   Relids relids,
 						   const AttrNumber *reqColIdx,
 						   bool adjust_tlist_in_place,
@@ -5671,7 +5671,7 @@ prepare_sort_from_pathkeys(Plan *lefttree, List *pathkeys,
 			tle = get_tle_by_resno(tlist, reqColIdx[numsortkeys]);
 			if (tle)
 			{
-				em = find_ec_member_for_tle(ec, tle, relids);
+				em = find_ec_member_for_tle(root, ec, tle, relids);
 				if (em)
 				{
 					/* found expr at right place in tlist */
@@ -5702,7 +5702,7 @@ prepare_sort_from_pathkeys(Plan *lefttree, List *pathkeys,
 			foreach(j, tlist)
 			{
 				tle = (TargetEntry *) lfirst(j);
-				em = find_ec_member_for_tle(ec, tle, relids);
+				em = find_ec_member_for_tle(root, ec, tle, relids);
 				if (em)
 				{
 					/* found expr already in tlist */
@@ -5745,7 +5745,10 @@ prepare_sort_from_pathkeys(Plan *lefttree, List *pathkeys,
 				 */
 				if (em->em_is_child &&
 					!bms_is_subset(em->em_relids, relids))
+				{
+					verify_em_child(root, em);
 					continue;
+				}
 
 				sortexpr = em->em_expr;
 				exprvars = pull_var_clause((Node *) sortexpr,
@@ -5831,7 +5834,7 @@ prepare_sort_from_pathkeys(Plan *lefttree, List *pathkeys,
  * Child EC members are ignored unless they belong to given 'relids'.
  */
 static EquivalenceMember *
-find_ec_member_for_tle(EquivalenceClass *ec,
+find_ec_member_for_tle(PlannerInfo *root, EquivalenceClass *ec,
 					   TargetEntry *tle,
 					   Relids relids)
 {
@@ -5860,7 +5863,10 @@ find_ec_member_for_tle(EquivalenceClass *ec,
 		 */
 		if (em->em_is_child &&
 			!bms_is_subset(em->em_relids, relids))
+		{
+			verify_em_child(root, em);
 			continue;
+		}
 
 		/* Match if same expression (after stripping relabel) */
 		emexpr = em->em_expr;
@@ -5883,7 +5889,7 @@ find_ec_member_for_tle(EquivalenceClass *ec,
  *	  'relids' is the set of relations required by prepare_sort_from_pathkeys()
  */
 static Sort *
-make_sort_from_pathkeys(Plan *lefttree, List *pathkeys, Relids relids)
+make_sort_from_pathkeys(PlannerInfo *root, Plan *lefttree, List *pathkeys, Relids relids)
 {
 	int			numsortkeys;
 	AttrNumber *sortColIdx;
@@ -5892,7 +5898,7 @@ make_sort_from_pathkeys(Plan *lefttree, List *pathkeys, Relids relids)
 	bool	   *nullsFirst;
 
 	/* Compute sort column info, and adjust lefttree as needed */
-	lefttree = prepare_sort_from_pathkeys(lefttree, pathkeys,
+	lefttree = prepare_sort_from_pathkeys(root, lefttree, pathkeys,
 										  relids,
 										  NULL,
 										  false,
@@ -6204,7 +6210,7 @@ make_unique_from_sortclauses(Plan *lefttree, List *distinctList)
  * as above, but use pathkeys to identify the sort columns and semantics
  */
 static Unique *
-make_unique_from_pathkeys(Plan *lefttree, List *pathkeys, int numCols)
+make_unique_from_pathkeys(PlannerInfo *root, Plan *lefttree, List *pathkeys, int numCols)
 {
 	Unique	   *node = makeNode(Unique);
 	Plan	   *plan = &node->plan;
@@ -6265,7 +6271,7 @@ make_unique_from_pathkeys(Plan *lefttree, List *pathkeys, int numCols)
 			foreach(j, plan->targetlist)
 			{
 				tle = (TargetEntry *) lfirst(j);
-				em = find_ec_member_for_tle(ec, tle, NULL);
+				em = find_ec_member_for_tle(root, ec, tle, NULL);
 				if (em)
 				{
 					/* found expr already in tlist */
diff --git a/src/include/optimizer/paths.h b/src/include/optimizer/paths.h
index cafde307ad..a3f34a5c8c 100644
--- a/src/include/optimizer/paths.h
+++ b/src/include/optimizer/paths.h
@@ -169,6 +169,7 @@ extern List *generate_implied_equalities_for_column(PlannerInfo *root,
 									   Relids prohibited_rels);
 extern bool have_relevant_eclass_joinclause(PlannerInfo *root,
 								RelOptInfo *rel1, RelOptInfo *rel2);
+extern void verify_em_child(PlannerInfo *root, EquivalenceMember *em);
 extern bool has_relevant_eclass_joinclause(PlannerInfo *root,
 							   RelOptInfo *rel1);
 extern bool eclass_useful_for_merging(PlannerInfo *root,

From 495e3b0b8ff1373c3653e5f7b7e3095a4b54e315 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Wed, 17 Oct 2018 11:18:12 +0900
Subject: [PATCH v6 1/6] Overhaul inheritance update/delete planning

With the current method, inheritance_planner, which handles the
planning for update/delete commands targeting inheritance trees,
performs the *whole* planning for each child table.  That involves
translating the query tree to set a given child table in place of
the original inheritance root table as the query's target table,
followed by calling grouping_planner on the translated query, which
performs query planning and additional steps needed to apply correct
target list based on the child target table.

That's inefficient for two reasons:

 1. partprune.c cannot be used to perform partition pruning, because
    it can only be invoked from query_planner.  With the current
    approach, query_planner only sees the individual partitions in
    the query tree it receives, not the parent partitioned table.
    This leaves each partition to be pruned using constraint
    exclusion.  (constraint exclusion cannon prune hash partitions
    which means UPDATE/DELETE don't support hash partition pruning.)

 2. Repeated invocation of query_planner results in allocating large
    amounts of memory, especially if there are many child tables.
    Also, it involves repeatedly performing the same processing,
    such as jointree processing.

This commit addresses both of the issues by rewriting portions of
inheritance_planner and adding some supporting functionality to
allpath.c.

With the new implementation, inheritance_planner calls query_planner
only once at the beginning with the original unmodified query, which
creates the access paths of individual relations after pruning any
unnecessary partitions.  For each target child relation, it also
creates a sub-PartitionInfo containing translated version of the
query and a targetlist suitable for the child.  Child PlannerInfos
are saved in the top PlannerInfo for using later.  If the query
involves join against the target relation, join paths are created
for each target child relation by  replacing the original target
table in the join tree by a given child table.  Join relations
(RelOptInfos thereof) for all target child relations are collected
in a global list in the top PlannerInfo.

After creating the join paths for all target child relations,
inheritance_planner calls grouping_planner() on each child join
relation using the previously created child PlannerInfo to finish up
the paths such that they produce query's top-level target list
expanded according to a given child relation's descriptor.
grouping_planner()'s interface is modified so that we can pass it
what's called a 'planned_rel', a RelOptInfo that already contains
the necessary paths needed to produce its output.

This removes some existing code in inheritance_planner that dealt
with any subquery RTEs in the query.  The rationale of that code
was that the subquery RTEs may change during each iteration of
planning (that is, for different children), so different iterations
better use different copies of those RTEs.  That was handled by
making fresh copies of those RTEs for each iteration of planning
which were appended to the range table, accompanied by modifying all
expressions and auxiliary structures that referenced the original
subquery RTEs to instead reference the copies (that is, change the
varnos).  This copying meant we would end up adding S * N new entries
to the original range table by the time we got to the last unpruned
child, where S is the number of subquery RTEs in the original query
and N the number of unpruned children.  Since with the new code
we perform planning just once, I think we don't need this special
handling.  Actually, there is a regression test output change due
to no longer having copies of subquery RTEs (see the diff of
partition_join.out file.)

Also we no longer need the hack in relation_excluded_by_constraints()
involving setting PlannerInfo.inhTargetKind to enable constraint
exclusion for target child relation, which is no longer
is no longer needed.  Constraint exclusion runs during query_planner
step described above.

Regression test output change in partition_join.out is due to the fact
that we no longer create duplicates of subquery RTEs in child range
tables.
---
 doc/src/sgml/ddl.sgml                        |  14 +-
 src/backend/nodes/outfuncs.c                 |   1 -
 src/backend/optimizer/path/allpaths.c        | 307 ++++++++++++++++++-
 src/backend/optimizer/plan/createplan.c      |  10 -
 src/backend/optimizer/plan/planner.c         | 431 +++++++--------------------
 src/backend/optimizer/prep/prepjointree.c    |   1 -
 src/backend/optimizer/prep/prepunion.c       |  33 +-
 src/backend/optimizer/util/plancat.c         |  50 +---
 src/include/nodes/relation.h                 |  31 +-
 src/test/regress/expected/partition_join.out |   4 +-
 10 files changed, 475 insertions(+), 407 deletions(-)

diff --git a/doc/src/sgml/ddl.sgml b/doc/src/sgml/ddl.sgml
index c8268222af..ca7359c4a4 100644
--- a/doc/src/sgml/ddl.sgml
+++ b/doc/src/sgml/ddl.sgml
@@ -3935,15 +3935,6 @@ EXPLAIN SELECT count(*) FROM measurement WHERE logdate &gt;= DATE '2008-01-01';
 
    <note>
     <para>
-     Currently, pruning of partitions during the planning of an
-     <command>UPDATE</command> or <command>DELETE</command> command is
-     implemented using the constraint exclusion method (however, it is
-     controlled by the <literal>enable_partition_pruning</literal> rather than
-     <literal>constraint_exclusion</literal>) &mdash; see the following section
-     for details and caveats that apply.
-    </para>
-
-    <para>
      Execution-time partition pruning currently only occurs for the
      <literal>Append</literal> and <literal>MergeAppend</literal> node types.
      It is not yet implemented for the <literal>ModifyTable</literal> node
@@ -3966,9 +3957,8 @@ EXPLAIN SELECT count(*) FROM measurement WHERE logdate &gt;= DATE '2008-01-01';
 
    <para>
     <firstterm>Constraint exclusion</firstterm> is a query optimization
-    technique similar to partition pruning.  While it is primarily used
-    for partitioning implemented using the legacy inheritance method, it can be
-    used for other purposes, including with declarative partitioning.
+    technique similar to partition pruning.  It is primarily used
+    for partitioning implemented using the legacy inheritance method.
    </para>
 
    <para>
diff --git a/src/backend/nodes/outfuncs.c b/src/backend/nodes/outfuncs.c
index f0c396530d..08657fcfd9 100644
--- a/src/backend/nodes/outfuncs.c
+++ b/src/backend/nodes/outfuncs.c
@@ -2309,7 +2309,6 @@ _outPlannerInfo(StringInfo str, const PlannerInfo *node)
 	WRITE_FLOAT_FIELD(tuple_fraction, "%.4f");
 	WRITE_FLOAT_FIELD(limit_tuples, "%.0f");
 	WRITE_UINT_FIELD(qual_security_level);
-	WRITE_ENUM_FIELD(inhTargetKind, InheritanceKind);
 	WRITE_BOOL_FIELD(hasJoinRTEs);
 	WRITE_BOOL_FIELD(hasLateralRTEs);
 	WRITE_BOOL_FIELD(hasDeletedRTEs);
diff --git a/src/backend/optimizer/path/allpaths.c b/src/backend/optimizer/path/allpaths.c
index 738bb30848..7787592870 100644
--- a/src/backend/optimizer/path/allpaths.c
+++ b/src/backend/optimizer/path/allpaths.c
@@ -36,6 +36,7 @@
 #include "optimizer/pathnode.h"
 #include "optimizer/paths.h"
 #include "optimizer/plancat.h"
+#include "optimizer/planmain.h"
 #include "optimizer/planner.h"
 #include "optimizer/prep.h"
 #include "optimizer/restrictinfo.h"
@@ -93,6 +94,9 @@ static void set_foreign_pathlist(PlannerInfo *root, RelOptInfo *rel,
 					 RangeTblEntry *rte);
 static void set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 					Index rti, RangeTblEntry *rte);
+static PlannerInfo *adjust_inherit_target_child(PlannerInfo *root,
+							RelOptInfo *childrel,
+							AppendRelInfo *appinfo);
 static void set_append_rel_pathlist(PlannerInfo *root, RelOptInfo *rel,
 						Index rti, RangeTblEntry *rte);
 static void generate_mergeappend_paths(PlannerInfo *root, RelOptInfo *rel,
@@ -119,6 +123,8 @@ static void set_namedtuplestore_pathlist(PlannerInfo *root, RelOptInfo *rel,
 static void set_worktable_pathlist(PlannerInfo *root, RelOptInfo *rel,
 					   RangeTblEntry *rte);
 static RelOptInfo *make_rel_from_joinlist(PlannerInfo *root, List *joinlist);
+static void inheritance_make_rel_from_joinlist(PlannerInfo *root,
+						List *joinlist);
 static bool subquery_is_pushdown_safe(Query *subquery, Query *topquery,
 						  pushdown_safety_info *safetyInfo);
 static bool recurse_pushdown_safe(Node *setOp, Query *topquery,
@@ -217,13 +223,40 @@ make_one_rel(PlannerInfo *root, List *joinlist)
 
 	/*
 	 * Generate access paths for the entire join tree.
+	 *
+	 * For UPDATE/DELETE on an inheritance parent, join paths should be
+	 * generated for each child result rel separately.
 	 */
-	rel = make_rel_from_joinlist(root, joinlist);
+	if (root->parse->resultRelation &&
+		root->simple_rte_array[root->parse->resultRelation]->inh)
+	{
+		inheritance_make_rel_from_joinlist(root, joinlist);
 
-	/*
-	 * The result should join all and only the query's base rels.
-	 */
-	Assert(bms_equal(rel->relids, root->all_baserels));
+		/*
+		 * There should be as many child source rels as there are child
+		 * subroots.
+		 */
+		Assert(list_length(root->inh_target_child_roots) ==
+			   list_length(root->inh_target_child_rels));
+
+		/*
+		 * Return the RelOptInfo of original target relation, although this
+		 * doesn't really contain the final path.  inheritance_planner
+		 * from where we got here will generate the final path, but not
+		 * through this RelOptInfo.
+		 */
+		rel = find_base_rel(root, root->parse->resultRelation);
+	}
+	else
+	{
+		rel = make_rel_from_joinlist(root, joinlist);
+
+		/*
+		 * The result should join all and only the query's base rels.
+		 */
+		Assert(bms_equal(rel->relids, root->all_baserels));
+
+	}
 
 	return rel;
 }
@@ -1001,6 +1034,7 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 		ListCell   *parentvars;
 		ListCell   *childvars;
 		ListCell   *lc;
+		PlannerInfo *subroot = root;
 
 		/* append_rel_list contains all append rels; ignore others */
 		if (appinfo->parent_relid != parentRTindex)
@@ -1219,9 +1253,17 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 			set_rel_consider_parallel(root, childrel, childRTE);
 
 		/*
-		 * Compute the child's size.
+		 * If the parent is the result relation, we need a reltarget for the
+		 * child relation that will be suitable to use the child also as the
+		 * target relation.
 		 */
-		set_rel_size(root, childrel, childRTindex, childRTE);
+		if (appinfo->parent_relid == root->parse->resultRelation)
+			subroot = adjust_inherit_target_child(root, childrel, appinfo);
+
+		/*
+		 * Compute the child's size using possibly modified subroot.
+		 */
+		set_rel_size(subroot, childrel, childRTindex, childRTE);
 
 		/*
 		 * It is possible that constraint exclusion detected a contradiction
@@ -1231,6 +1273,26 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 		if (IS_DUMMY_REL(childrel))
 			continue;
 
+		/*
+		 * If we modified subroot for the target inheritance case, add it
+		 * to root->inh_target_child_roots.
+		 */
+		if (subroot != root)
+		{
+			root->inh_target_child_roots =
+							lappend(root->inh_target_child_roots, subroot);
+
+			/*
+			 * If the childrel itself was a partitioned table, its children
+			 * would've been added into subroot.  Copy relevant fields
+			 * into the parent root.
+			 */
+			if (subroot->inh_target_child_roots != NIL)
+				root->inh_target_child_roots =
+							list_concat(root->inh_target_child_roots,
+										subroot->inh_target_child_roots);
+		}
+
 		/* We have at least one live child. */
 		has_live_children = true;
 
@@ -1327,6 +1389,109 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 }
 
 /*
+ * adjust_inherit_target_child
+ *		For an inheritance target child relation, this adjusts its
+ *		reltarget so that it contains expressions suitable for processing as
+ *		a target relation, creates a child PlannerInfo containing translated
+ *		copy of the query and returns it.
+ *
+ * The child PlannerInfo reuses most of the parent PlannerInfo's fields
+ * unchanged, except unexpanded_tlist and processed_tlist are based on the
+ * child relation.
+ */
+static PlannerInfo *
+adjust_inherit_target_child(PlannerInfo *root, RelOptInfo *childrel,
+							AppendRelInfo *appinfo)
+{
+	PlannerInfo *subroot;
+	List	   *tlist;
+	List	   *translated_exprs;
+	ListCell   *lc2;
+
+	Assert(root->parse->commandType == CMD_UPDATE ||
+		   root->parse->commandType == CMD_DELETE);
+
+	/*
+	 * We'd like to build the reltarget afresh; save the translated
+	 * version of parent's expressions aside.
+	 */
+	translated_exprs = childrel->reltarget->exprs;
+	childrel->reltarget->exprs = NIL;
+
+	/* Translate the original query's expressions to this child. */
+	subroot = makeNode(PlannerInfo);
+	memcpy(subroot, root, sizeof(PlannerInfo));
+
+	/*
+	 * Restore the unexpanded tlist for translation, so that child's
+	 * query contains targetList numbered (resnos) per its own
+	 * TupleDesc, which adjust_inherited_tlist ensures.
+	 */
+	root->parse->targetList = root->unexpanded_tlist;
+	subroot->parse = (Query *) adjust_appendrel_attrs(root,
+													  (Node *) root->parse,
+													  1, &appinfo);
+
+	/*
+	 * Save subroot's targetlist so that childrel's own children can use it as
+	 * unexpanded tlist.  Must copy because subroot->parse->targetList will
+	 * be modified soon.
+	 */
+	subroot->unexpanded_tlist = list_copy(subroot->parse->targetList);
+
+	/*
+	 * Apply planner's expansion of targetlist, such as adding various junk
+	 * column, filling placeholder entries for dropped columns, etc., all of
+	 * which occurs with the child's TupleDesc.
+	 */
+	tlist = preprocess_targetlist(subroot);
+	subroot->processed_tlist = tlist;
+	build_base_rel_tlists(subroot, tlist);
+
+	/*
+	 * Some of the expressions in parent's reltarget might not be in the
+	 * child's freshly built reltarget expressions, because the latter only
+	 * contains those attributes that are needed to be present in the top-
+	 * level tlist (or ones that preprocess_targetlist thinks are needed to
+	 * be in the tlist.)  We may need other attributes such as those that
+	 * are required for computing WHERE clauses, which are already computed
+	 * for the parent during deconstruct_jointree processing of the original
+	 * query.  We've already got a translated copy of those attributes, from
+	 * which pick only those that are not already present.
+	 */
+	foreach(lc2, translated_exprs)
+	{
+		Expr *expr = lfirst(lc2);
+
+		if (!list_member(childrel->reltarget->exprs, expr))
+			childrel->reltarget->exprs = lappend(childrel->reltarget->exprs,
+												 expr);
+	}
+
+	/*
+	 * Set a few other fields of subroot.
+	 *
+	 * Reset inh_target_child_roots to not be same as parent root's so that
+	 * the subroots for this child's own children (if any) don't end up in
+	 * root parent's list.  We'll eventually merge all entries into one list,
+	 * but that's now now.
+	 */
+	subroot->inh_target_child_roots = NIL;
+
+	/*
+	 * Adjust all_baserels to replace the original target relation with the
+	 * child target relation.  Copy it before modifying though.
+	 */
+	subroot->all_baserels = bms_copy(root->all_baserels);
+	subroot->all_baserels = bms_del_member(subroot->all_baserels,
+										   root->parse->resultRelation);
+	subroot->all_baserels = bms_add_member(subroot->all_baserels,
+										   subroot->parse->resultRelation);
+
+	return subroot;
+}
+
+/*
  * set_append_rel_pathlist
  *	  Build access paths for an "append relation"
  */
@@ -2624,6 +2789,134 @@ generate_gather_paths(PlannerInfo *root, RelOptInfo *rel, bool override_rows)
 }
 
 /*
+ * inheritance_make_rel_from_joinlist
+ *		Perform join planning for all non-dummy leaf inheritance children
+ *		in their role as an UPDATE/DELETE query's target relation
+ *
+ * If a child relation is a partitioned table, its children are processed in
+ * turn by recursively calling this function.
+ */
+static void
+inheritance_make_rel_from_joinlist(PlannerInfo *root, List *joinlist)
+{
+	Index		resultRelation = root->parse->resultRelation;
+	ListCell   *lc;
+#ifdef USE_ASSERT_CHECKING
+	Relids	all_baserels;
+#endif
+
+	/*
+	 * For UPDATE/DELETE queries, the top parent can only ever be a table.
+	 * As a contrast, it could be a UNION ALL subquery in the case of SELECT.
+	 */
+	Assert(root->parse->commandType == CMD_UPDATE ||
+		   root->parse->commandType == CMD_DELETE);
+	Assert(planner_rt_fetch(resultRelation, root)->rtekind == RTE_RELATION);
+
+	/* Nothing to do. */
+	if (IS_DUMMY_REL(find_base_rel(root, resultRelation )))
+		return;
+
+	foreach(lc, root->inh_target_child_roots)
+	{
+		PlannerInfo *subroot = lfirst(lc);
+		RelOptInfo *childrel;
+		AppendRelInfo *appinfo;
+		List	   *translated_joinlist;
+
+		Assert(subroot->parse->resultRelation > 0);
+		childrel = find_base_rel(root, subroot->parse->resultRelation);
+		appinfo = root->append_rel_array[subroot->parse->resultRelation];
+
+		if (appinfo->parent_relid != root->parse->resultRelation)
+			continue;
+
+		/* Ignore excluded/pruned children. */
+		if (IS_DUMMY_REL(childrel))
+			continue;
+
+		/*
+		 * Modify joinlist such that relations joined to the top parent rel
+		 * appear to be joined to the child rel instead.  Do the same for
+		 * any SpecialJoinInfo structs.
+		 */
+		translated_joinlist = (List *)
+						adjust_appendrel_attrs(subroot,
+											   (Node *) joinlist,
+											   1, &appinfo);
+		subroot->join_info_list = (List *)
+						adjust_appendrel_attrs(subroot,
+											   (Node *) root->join_info_list,
+											   1, &appinfo);
+
+		/*
+		 * Sub-partitioned tables have to be processed recursively using the
+		 * translated subroot as the parent, because AppendRelInfos link
+		 * sub-partitions to their immediate parents, not the root partitioned
+		 * table.
+		 */
+		if (childrel->part_scheme != NULL)
+		{
+			inheritance_make_rel_from_joinlist(subroot, translated_joinlist);
+
+			/*
+			 * Add this child relation as a placeholder in the parent root's
+			 * inh_target_child_rels so that inheritance_planner see same
+			 * number of entries as inh_target_child_roots.
+			 */
+			root->inh_target_child_rels =
+					lappend(root->inh_target_child_rels, childrel);
+
+			/* Also propagate this child's own children into parent's list. */
+			if (subroot->inh_target_child_rels != NIL)
+				root->inh_target_child_rels =
+					list_concat(root->inh_target_child_rels,
+								subroot->inh_target_child_rels);
+			continue;
+		}
+
+		/*
+		 * Since we added the child rel directly into the join tree, we must
+		 * modify it to be a "base" rel instead of an "other" rel, which the
+		 * join planning code expects the relations being joined to be.
+		 *
+		 * NB: Do we need to change the child EC members to be marked
+		 * as non-child somehow?
+		 */
+		childrel->reloptkind = RELOPT_BASEREL;
+
+		Assert(subroot->join_rel_list == NIL);
+		Assert(subroot->join_rel_hash == NULL);
+
+		/* Perform join planning and save the resulting RelOptInfo. */
+		childrel = make_rel_from_joinlist(subroot, translated_joinlist);
+
+		/*
+		 * Remember this child target rel.  inheritance_planner will perform
+		 * the remaining steps of planning for each child relation separately.
+		 * Specifically, it will call grouping_planner on every
+		 * RelOptInfo contained in the inh_target_child_rels list, each of
+		 * which represents the source of tuples to be modified for a given
+		 * target child rel.
+		 */
+		root->inh_target_child_rels =
+						lappend(root->inh_target_child_rels, childrel);
+#ifdef USE_ASSERT_CHECKING
+		/*
+		 * The following implements essentially the same Assert as in
+		 * make_one_rel, our caller.
+		 */
+		all_baserels = bms_copy(root->all_baserels);
+		all_baserels = bms_del_member(all_baserels,
+									  root->parse->resultRelation);
+		all_baserels = bms_add_member(all_baserels,
+									  subroot->parse->resultRelation);
+		Assert(bms_equal(childrel->relids, all_baserels));
+#endif
+	}
+}
+
+/*
  * make_rel_from_joinlist
  *	  Build access paths using a "joinlist" to guide the join path search.
  *
diff --git a/src/backend/optimizer/plan/createplan.c b/src/backend/optimizer/plan/createplan.c
index da7a92081a..28c4b53fea 100644
--- a/src/backend/optimizer/plan/createplan.c
+++ b/src/backend/optimizer/plan/createplan.c
@@ -1998,12 +1998,7 @@ create_groupingsets_plan(PlannerInfo *root, GroupingSetsPath *best_path)
 	/*
 	 * During setrefs.c, we'll need the grouping_map to fix up the cols lists
 	 * in GroupingFunc nodes.  Save it for setrefs.c to use.
-	 *
-	 * This doesn't work if we're in an inheritance subtree (see notes in
-	 * create_modifytable_plan).  Fortunately we can't be because there would
-	 * never be grouping in an UPDATE/DELETE; but let's Assert that.
 	 */
-	Assert(root->inhTargetKind == INHKIND_NONE);
 	Assert(root->grouping_map == NULL);
 	root->grouping_map = grouping_map;
 
@@ -2160,12 +2155,7 @@ create_minmaxagg_plan(PlannerInfo *root, MinMaxAggPath *best_path)
 	 * with InitPlan output params.  (We can't just do that locally in the
 	 * MinMaxAgg node, because path nodes above here may have Agg references
 	 * as well.)  Save the mmaggregates list to tell setrefs.c to do that.
-	 *
-	 * This doesn't work if we're in an inheritance subtree (see notes in
-	 * create_modifytable_plan).  Fortunately we can't be because there would
-	 * never be aggregates in an UPDATE/DELETE; but let's Assert that.
 	 */
-	Assert(root->inhTargetKind == INHKIND_NONE);
 	Assert(root->minmax_aggs == NIL);
 	root->minmax_aggs = best_path->mmaggregates;
 
diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index c729a99f8b..14e59188cd 100644
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -37,6 +37,7 @@
 #ifdef OPTIMIZER_DEBUG
 #include "nodes/print.h"
 #endif
+#include "nodes/relation.h"
 #include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
@@ -126,7 +127,7 @@ static Node *preprocess_expression(PlannerInfo *root, Node *expr, int kind);
 static void preprocess_qual_conditions(PlannerInfo *root, Node *jtnode);
 static void inheritance_planner(PlannerInfo *root);
 static void grouping_planner(PlannerInfo *root, bool inheritance_update,
-				 double tuple_fraction);
+				 RelOptInfo *planned_rel, double tuple_fraction);
 static grouping_sets_data *preprocess_grouping_sets(PlannerInfo *root);
 static List *remap_to_groupclause_idx(List *groupClause, List *gsets,
 						 int *tleref_to_colnum_map);
@@ -630,7 +631,6 @@ subquery_planner(PlannerGlobal *glob, Query *parse,
 	root->grouping_map = NULL;
 	root->minmax_aggs = NIL;
 	root->qual_security_level = 0;
-	root->inhTargetKind = INHKIND_NONE;
 	root->hasRecursion = hasRecursion;
 	if (hasRecursion)
 		root->wt_param_id = SS_assign_special_param(root);
@@ -970,7 +970,7 @@ subquery_planner(PlannerGlobal *glob, Query *parse,
 		rt_fetch(parse->resultRelation, parse->rtable)->inh)
 		inheritance_planner(root);
 	else
-		grouping_planner(root, false, tuple_fraction);
+		grouping_planner(root, false, NULL, tuple_fraction);
 
 	/*
 	 * Capture the set of outer-level param IDs we have access to, for use in
@@ -1146,12 +1146,19 @@ preprocess_phv_expression(PlannerInfo *root, Expr *expr)
  *	  inheritance set.
  *
  * We have to handle this case differently from cases where a source relation
- * is an inheritance set. Source inheritance is expanded at the bottom of the
- * plan tree (see allpaths.c), but target inheritance has to be expanded at
- * the top.  The reason is that for UPDATE, each target relation needs a
- * different targetlist matching its own column set.  Fortunately,
- * the UPDATE/DELETE target can never be the nullable side of an outer join,
- * so it's OK to generate the plan this way.
+ * is an inheritance set.  That's mainly because for UPDATE, each target
+ * relation needs a different targetlist matching its own column set.  So, we
+ * must modify the source scan/join path for each target relation such that it
+ * produces the desired target list.
+ *
+ * The source scan/join paths for individual target relations are still
+ * created in allpaths.c by first expanding the inheritance in the usual way
+ * by set_append_rel_size, followed by join planning for each target relation
+ * separately in make_one_rel.  Finally, we apply grouping_planner here to each
+ * child scan/join path so that it produces the desired targetlist.
+ *
+ * Fortunately, the UPDATE/DELETE target can never be the nullable side of an
+ * outer join, so it's OK to generate the plan this way.
  *
  * Returns nothing; the useful output is in the Paths we attach to
  * the (UPPERREL_FINAL, NULL) upperrel stored in *root.
@@ -1164,14 +1171,8 @@ inheritance_planner(PlannerInfo *root)
 {
 	Query	   *parse = root->parse;
 	int			top_parentRTindex = parse->resultRelation;
-	Bitmapset  *subqueryRTindexes;
-	Bitmapset  *modifiableARIindexes;
 	int			nominalRelation = -1;
 	Index		rootRelation = 0;
-	List	   *final_rtable = NIL;
-	int			save_rel_array_size = 0;
-	RelOptInfo **save_rel_array = NULL;
-	AppendRelInfo **save_append_rel_array = NULL;
 	List	   *subpaths = NIL;
 	List	   *subroots = NIL;
 	List	   *resultRelations = NIL;
@@ -1179,70 +1180,59 @@ inheritance_planner(PlannerInfo *root)
 	List	   *returningLists = NIL;
 	List	   *rowMarks;
 	RelOptInfo *final_rel;
-	ListCell   *lc;
-	Index		rti;
+	ListCell   *lc1,
+			   *lc2;
 	RangeTblEntry *parent_rte;
-	PlannerInfo *parent_root;
-	Query	   *parent_parse;
-	Bitmapset  *parent_relids = bms_make_singleton(top_parentRTindex);
-	PlannerInfo **parent_roots = NULL;
+	List	   *tlist;
+	standard_qp_extra qp_extra;
+	RelOptInfo *planned_rel;
 
+	/* Inheritance is never used for insert. */
 	Assert(parse->commandType != CMD_INSERT);
+	parent_rte = planner_rt_fetch(top_parentRTindex, root);
 
 	/*
-	 * We generate a modified instance of the original Query for each target
-	 * relation, plan that, and put all the plans into a list that will be
-	 * controlled by a single ModifyTable node.  All the instances share the
-	 * same rangetable, but each instance must have its own set of subquery
-	 * RTEs within the finished rangetable because (1) they are likely to get
-	 * scribbled on during planning, and (2) it's not inconceivable that
-	 * subqueries could get planned differently in different cases.  We need
-	 * not create duplicate copies of other RTE kinds, in particular not the
-	 * target relations, because they don't have either of those issues.  Not
-	 * having to duplicate the target relations is important because doing so
-	 * (1) would result in a rangetable of length O(N^2) for N targets, with
-	 * at least O(N^3) work expended here; and (2) would greatly complicate
-	 * management of the rowMarks list.
+	 * Generate the access paths for all relations mentioned in the query,
+	 * including the target inheritance set.  When doing the join planning,
+	 * references in the join tree to the original target relation that's the
+	 * root parent of the inheritance tree is replaced by each of its
+	 * inheritance children and the resulting joinrel RelOptInfo's are
+	 * added to root->inh_target_child_rels.
 	 *
-	 * To begin with, generate a bitmapset of the relids of the subquery RTEs.
+	 * Final planning steps (grouping_planner) are applied to the best path
+	 * of each of those child joinrels using a modified instance of the
+	 * original query for a given child target rel.  All the paths so generated
+	 * are put into  a list that will be controlled by a single ModifyTable
+	 * node.  All the instances share the same rangetable.
 	 */
-	subqueryRTindexes = NULL;
-	rti = 1;
-	foreach(lc, parse->rtable)
-	{
-		RangeTblEntry *rte = lfirst_node(RangeTblEntry, lc);
-
-		if (rte->rtekind == RTE_SUBQUERY)
-			subqueryRTindexes = bms_add_member(subqueryRTindexes, rti);
-		rti++;
-	}
 
 	/*
-	 * Next, we want to identify which AppendRelInfo items contain references
-	 * to any of the aforesaid subquery RTEs.  These items will need to be
-	 * copied and modified to adjust their subquery references; whereas the
-	 * other ones need not be touched.  It's worth being tense over this
-	 * because we can usually avoid processing most of the AppendRelInfo
-	 * items, thereby saving O(N^2) space and time when the target is a large
-	 * inheritance tree.  We can identify AppendRelInfo items by their
-	 * child_relid, since that should be unique within the list.
+	 * Save the unexpanded version of the query's targetlist to be used below
+	 * for passing to grouping_planner for each child target relation.
 	 */
-	modifiableARIindexes = NULL;
-	if (subqueryRTindexes != NULL)
-	{
-		foreach(lc, root->append_rel_list)
-		{
-			AppendRelInfo *appinfo = lfirst_node(AppendRelInfo, lc);
+	root->unexpanded_tlist = list_copy(root->parse->targetList);
 
-			if (bms_is_member(appinfo->parent_relid, subqueryRTindexes) ||
-				bms_is_member(appinfo->child_relid, subqueryRTindexes) ||
-				bms_overlap(pull_varnos((Node *) appinfo->translated_vars),
-							subqueryRTindexes))
-				modifiableARIindexes = bms_add_member(modifiableARIindexes,
-													  appinfo->child_relid);
-		}
+	/* Do the scan/join planning. */
+	tlist = preprocess_targetlist(root);
+	root->processed_tlist = tlist;
+	qp_extra.tlist = tlist;
+	qp_extra.activeWindows = qp_extra.groupClause = NIL;
+	planned_rel = query_planner(root, tlist, standard_qp_callback, &qp_extra);
+
+	/*
+	 * If it turned out during query planning that all the children are dummy
+	 * (pruned or excluded by constraints), no need to do the steps below.
+	 * Let grouping_planner finish up the final path.
+	 */
+	if (IS_DUMMY_REL(planned_rel))
+	{
+		grouping_planner(root, false, planned_rel, 0.0);
+		return;
 	}
 
+	Assert(planned_rel->relid == top_parentRTindex);
+	Assert(planned_rel->reloptkind == RELOPT_BASEREL);
+
 	/*
 	 * If the parent RTE is a partitioned table, we should use that as the
 	 * nominal target relation, because the RTEs added for partitioned tables
@@ -1250,7 +1240,6 @@ inheritance_planner(PlannerInfo *root)
 	 * not appear anywhere else in the plan, so the confusion explained below
 	 * for non-partitioning inheritance cases is not possible.
 	 */
-	parent_rte = rt_fetch(top_parentRTindex, root->parse->rtable);
 	if (parent_rte->relkind == RELKIND_PARTITIONED_TABLE)
 	{
 		nominalRelation = top_parentRTindex;
@@ -1258,59 +1247,23 @@ inheritance_planner(PlannerInfo *root)
 	}
 
 	/*
-	 * The PlannerInfo for each child is obtained by translating the relevant
-	 * members of the PlannerInfo for its immediate parent, which we find
-	 * using the parent_relid in its AppendRelInfo.  We save the PlannerInfo
-	 * for each parent in an array indexed by relid for fast retrieval. Since
-	 * the maximum number of parents is limited by the number of RTEs in the
-	 * query, we use that number to allocate the array. An extra entry is
-	 * needed since relids start from 1.
+	 * Get on with finalizing the path for each child target relation by
+	 * calling grouping_planner on its joinrel.  Note that we're restoring
+	 * the query's targetlist to the original one for grouping_planner's
+	 * targetlist expansion steps to perform the expansion with individual
+	 * child descriptors.
 	 */
-	parent_roots = (PlannerInfo **) palloc0((list_length(parse->rtable) + 1) *
-											sizeof(PlannerInfo *));
-	parent_roots[top_parentRTindex] = root;
-
-	/*
-	 * And now we can get on with generating a plan for each child table.
-	 */
-	foreach(lc, root->append_rel_list)
+	forboth(lc1, root->inh_target_child_roots,
+			lc2, root->inh_target_child_rels)
 	{
-		AppendRelInfo *appinfo = lfirst_node(AppendRelInfo, lc);
-		PlannerInfo *subroot;
+		PlannerInfo *subroot = lfirst(lc1);
+		RelOptInfo *childrel = lfirst(lc2);
+		AppendRelInfo *appinfo;
 		RangeTblEntry *child_rte;
 		RelOptInfo *sub_final_rel;
 		Path	   *subpath;
 
-		/* append_rel_list contains all append rels; ignore others */
-		if (!bms_is_member(appinfo->parent_relid, parent_relids))
-			continue;
-
-		/*
-		 * expand_inherited_rtentry() always processes a parent before any of
-		 * that parent's children, so the parent_root for this relation should
-		 * already be available.
-		 */
-		parent_root = parent_roots[appinfo->parent_relid];
-		Assert(parent_root != NULL);
-		parent_parse = parent_root->parse;
-
-		/*
-		 * We need a working copy of the PlannerInfo so that we can control
-		 * propagation of information back to the main copy.
-		 */
-		subroot = makeNode(PlannerInfo);
-		memcpy(subroot, parent_root, sizeof(PlannerInfo));
-
-		/*
-		 * Generate modified query with this rel as target.  We first apply
-		 * adjust_appendrel_attrs, which copies the Query and changes
-		 * references to the parent RTE to refer to the current child RTE,
-		 * then fool around with subquery RTEs.
-		 */
-		subroot->parse = (Query *)
-			adjust_appendrel_attrs(parent_root,
-								   (Node *) parent_parse,
-								   1, &appinfo);
+		appinfo = root->append_rel_array[subroot->parse->resultRelation];
 
 		/*
 		 * If there are securityQuals attached to the parent, move them to the
@@ -1322,31 +1275,12 @@ inheritance_planner(PlannerInfo *root)
 		parent_rte->securityQuals = NIL;
 
 		/*
-		 * Mark whether we're planning a query to a partitioned table or an
-		 * inheritance parent.
+		 * Ignore a partitioned child.  Instead, the paths of its children will
+		 * be added to subpaths.
 		 */
-		subroot->inhTargetKind =
-			(rootRelation != 0) ? INHKIND_PARTITIONED : INHKIND_INHERITED;
-
-		/*
-		 * If this child is further partitioned, remember it as a parent.
-		 * Since a partitioned table does not have any data, we don't need to
-		 * create a plan for it, and we can stop processing it here.  We do,
-		 * however, need to remember its modified PlannerInfo for use when
-		 * processing its children, since we'll update their varnos based on
-		 * the delta from immediate parent to child, not from top to child.
-		 *
-		 * Note: a very non-obvious point is that we have not yet added
-		 * duplicate subquery RTEs to the subroot's rtable.  We mustn't,
-		 * because then its children would have two sets of duplicates,
-		 * confusing matters.
-		 */
-		if (child_rte->inh)
+		if (childrel->part_scheme)
 		{
-			Assert(child_rte->relkind == RELKIND_PARTITIONED_TABLE);
-			parent_relids = bms_add_member(parent_relids, appinfo->child_relid);
-			parent_roots[appinfo->child_relid] = subroot;
-
+			Assert(child_rte->inh);
 			continue;
 		}
 
@@ -1374,111 +1308,8 @@ inheritance_planner(PlannerInfo *root)
 		if (nominalRelation < 0)
 			nominalRelation = appinfo->child_relid;
 
-		/*
-		 * The rowMarks list might contain references to subquery RTEs, so
-		 * make a copy that we can apply ChangeVarNodes to.  (Fortunately, the
-		 * executor doesn't need to see the modified copies --- we can just
-		 * pass it the original rowMarks list.)
-		 */
-		subroot->rowMarks = copyObject(parent_root->rowMarks);
-
-		/*
-		 * The append_rel_list likewise might contain references to subquery
-		 * RTEs (if any subqueries were flattenable UNION ALLs).  So prepare
-		 * to apply ChangeVarNodes to that, too.  As explained above, we only
-		 * want to copy items that actually contain such references; the rest
-		 * can just get linked into the subroot's append_rel_list.
-		 *
-		 * If we know there are no such references, we can just use the outer
-		 * append_rel_list unmodified.
-		 */
-		if (modifiableARIindexes != NULL)
-		{
-			ListCell   *lc2;
-
-			subroot->append_rel_list = NIL;
-			foreach(lc2, parent_root->append_rel_list)
-			{
-				AppendRelInfo *appinfo2 = lfirst_node(AppendRelInfo, lc2);
-
-				if (bms_is_member(appinfo2->child_relid, modifiableARIindexes))
-					appinfo2 = copyObject(appinfo2);
-
-				subroot->append_rel_list = lappend(subroot->append_rel_list,
-												   appinfo2);
-			}
-		}
-
-		/*
-		 * Add placeholders to the child Query's rangetable list to fill the
-		 * RT indexes already reserved for subqueries in previous children.
-		 * These won't be referenced, so there's no need to make them very
-		 * valid-looking.
-		 */
-		while (list_length(subroot->parse->rtable) < list_length(final_rtable))
-			subroot->parse->rtable = lappend(subroot->parse->rtable,
-											 makeNode(RangeTblEntry));
-
-		/*
-		 * If this isn't the first child Query, generate duplicates of all
-		 * subquery RTEs, and adjust Var numbering to reference the
-		 * duplicates. To simplify the loop logic, we scan the original rtable
-		 * not the copy just made by adjust_appendrel_attrs; that should be OK
-		 * since subquery RTEs couldn't contain any references to the target
-		 * rel.
-		 */
-		if (final_rtable != NIL && subqueryRTindexes != NULL)
-		{
-			ListCell   *lr;
-
-			rti = 1;
-			foreach(lr, parent_parse->rtable)
-			{
-				RangeTblEntry *rte = lfirst_node(RangeTblEntry, lr);
-
-				if (bms_is_member(rti, subqueryRTindexes))
-				{
-					Index		newrti;
-
-					/*
-					 * The RTE can't contain any references to its own RT
-					 * index, except in its securityQuals, so we can save a
-					 * few cycles by applying ChangeVarNodes to the rest of
-					 * the rangetable before we append the RTE to it.
-					 */
-					newrti = list_length(subroot->parse->rtable) + 1;
-					ChangeVarNodes((Node *) subroot->parse, rti, newrti, 0);
-					ChangeVarNodes((Node *) subroot->rowMarks, rti, newrti, 0);
-					/* Skip processing unchanging parts of append_rel_list */
-					if (modifiableARIindexes != NULL)
-					{
-						ListCell   *lc2;
-
-						foreach(lc2, subroot->append_rel_list)
-						{
-							AppendRelInfo *appinfo2 = lfirst_node(AppendRelInfo, lc2);
-
-							if (bms_is_member(appinfo2->child_relid,
-											  modifiableARIindexes))
-								ChangeVarNodes((Node *) appinfo2, rti, newrti, 0);
-						}
-					}
-					rte = copyObject(rte);
-					ChangeVarNodes((Node *) rte->securityQuals, rti, newrti, 0);
-					subroot->parse->rtable = lappend(subroot->parse->rtable,
-													 rte);
-				}
-				rti++;
-			}
-		}
-
-		/* There shouldn't be any OJ info to translate, as yet */
-		Assert(subroot->join_info_list == NIL);
-		/* and we haven't created PlaceHolderInfos, either */
-		Assert(subroot->placeholder_list == NIL);
-
-		/* Generate Path(s) for accessing this result relation */
-		grouping_planner(subroot, true, 0.0 /* retrieve all tuples */ );
+		/* Apply the top-level targetlist to childrel's path. */
+		grouping_planner(subroot, true, childrel, 0.0);
 
 		/*
 		 * Select cheapest path in case there's more than one.  We always run
@@ -1490,45 +1321,10 @@ inheritance_planner(PlannerInfo *root)
 		subpath = sub_final_rel->cheapest_total_path;
 
 		/*
-		 * If this child rel was excluded by constraint exclusion, exclude it
-		 * from the result plan.
+		 * child rel cannot be empty, or inheritance_make_rel_from_joinlist
+		 * wouldn't have put it in the list to begin with.
 		 */
-		if (IS_DUMMY_PATH(subpath))
-			continue;
-
-		/*
-		 * If this is the first non-excluded child, its post-planning rtable
-		 * becomes the initial contents of final_rtable; otherwise, append
-		 * just its modified subquery RTEs to final_rtable.
-		 */
-		if (final_rtable == NIL)
-			final_rtable = subroot->parse->rtable;
-		else
-			final_rtable = list_concat(final_rtable,
-									   list_copy_tail(subroot->parse->rtable,
-													  list_length(final_rtable)));
-
-		/*
-		 * We need to collect all the RelOptInfos from all child plans into
-		 * the main PlannerInfo, since setrefs.c will need them.  We use the
-		 * last child's simple_rel_array (previous ones are too short), so we
-		 * have to propagate forward the RelOptInfos that were already built
-		 * in previous children.
-		 */
-		Assert(subroot->simple_rel_array_size >= save_rel_array_size);
-		for (rti = 1; rti < save_rel_array_size; rti++)
-		{
-			RelOptInfo *brel = save_rel_array[rti];
-
-			if (brel)
-				subroot->simple_rel_array[rti] = brel;
-		}
-		save_rel_array_size = subroot->simple_rel_array_size;
-		save_rel_array = subroot->simple_rel_array;
-		save_append_rel_array = subroot->append_rel_array;
-
-		/* Make sure any initplans from this rel get into the outer list */
-		root->init_plans = subroot->init_plans;
+		Assert(!IS_DUMMY_PATH(subpath));
 
 		/* Build list of sub-paths */
 		subpaths = lappend(subpaths, subpath);
@@ -1560,36 +1356,6 @@ inheritance_planner(PlannerInfo *root)
 	 */
 
 	/*
-	 * If we managed to exclude every child rel, return a dummy plan; it
-	 * doesn't even need a ModifyTable node.
-	 */
-	if (subpaths == NIL)
-	{
-		set_dummy_rel_pathlist(final_rel);
-		return;
-	}
-
-	/*
-	 * Put back the final adjusted rtable into the master copy of the Query.
-	 * (We mustn't do this if we found no non-excluded children.)
-	 */
-	parse->rtable = final_rtable;
-	root->simple_rel_array_size = save_rel_array_size;
-	root->simple_rel_array = save_rel_array;
-	root->append_rel_array = save_append_rel_array;
-
-	/* Must reconstruct master's simple_rte_array, too */
-	root->simple_rte_array = (RangeTblEntry **)
-		palloc0((list_length(final_rtable) + 1) * sizeof(RangeTblEntry *));
-	rti = 1;
-	foreach(lc, final_rtable)
-	{
-		RangeTblEntry *rte = lfirst_node(RangeTblEntry, lc);
-
-		root->simple_rte_array[rti++] = rte;
-	}
-
-	/*
 	 * If there was a FOR [KEY] UPDATE/SHARE clause, the LockRows node will
 	 * have dealt with fetching non-locked marked rows, else we need to have
 	 * ModifyTable do that.
@@ -1629,6 +1395,12 @@ inheritance_planner(PlannerInfo *root)
  * (inheritance_planner will create a single ModifyTable node covering all the
  * target tables.)
  *
+ * If non-NULL, planned_rel is a RelOptInfo containing paths for the query's
+ * top-level joinrel, which the caller produced by itself.  In that case, this
+ * function only needs to adjust the targetlist of its cheapest_total_path.
+ * The only caller that may pass such a RelOptInfo currently is
+ * inheritance_planner.
+ *
  * tuple_fraction is the fraction of tuples we expect will be retrieved.
  * tuple_fraction is interpreted as follows:
  *	  0: expect all tuples to be retrieved (normal case)
@@ -1647,6 +1419,7 @@ inheritance_planner(PlannerInfo *root)
  */
 static void
 grouping_planner(PlannerInfo *root, bool inheritance_update,
+				 RelOptInfo *planned_rel,
 				 double tuple_fraction)
 {
 	Query	   *parse = root->parse;
@@ -1659,7 +1432,7 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 	List	   *final_targets;
 	List	   *final_targets_contain_srfs;
 	bool		final_target_parallel_safe;
-	RelOptInfo *current_rel;
+	RelOptInfo *current_rel = planned_rel;
 	RelOptInfo *final_rel;
 	ListCell   *lc;
 
@@ -1699,6 +1472,7 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 		 * special work for recursive unions is the responsibility of
 		 * plan_set_operations.
 		 */
+		Assert(current_rel == NULL);
 		current_rel = plan_set_operations(root);
 
 		/*
@@ -1788,17 +1562,29 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 				parse->groupClause = preprocess_groupclause(root, NIL);
 		}
 
-		/* Preprocess targetlist */
-		tlist = preprocess_targetlist(root);
-
 		/*
-		 * We are now done hacking up the query's targetlist.  Most of the
-		 * remaining planning work will be done with the PathTarget
-		 * representation of tlists, but save aside the full representation so
-		 * that we can transfer its decoration (resnames etc) to the topmost
-		 * tlist of the finished Plan.
+		 * Preprocess targetlist, if needed.  If the caller has already done
+		 * query planning, root->processed_tlist already contain the desired
+		 * targetlist.
 		 */
-		root->processed_tlist = tlist;
+		if (planned_rel == NULL)
+		{
+			tlist = preprocess_targetlist(root);
+
+			/*
+			 * We are now done hacking up the query's targetlist.  Most of the
+			 * remaining planning work will be done with the PathTarget
+			 * representation of tlists, but save aside the full representation
+			 * so that we can transfer its decoration (resnames etc) to the
+			 * topmost tlist of the finished Plan.
+			 */
+			root->processed_tlist = tlist;
+		}
+		else
+		{
+			Assert(root->processed_tlist != NIL);
+			tlist = root->processed_tlist;
+		}
 
 		/*
 		 * Collect statistics about aggregates for estimating costs, and mark
@@ -1878,8 +1664,9 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 		 * We also generate (in standard_qp_callback) pathkey representations
 		 * of the query's sort clause, distinct clause, etc.
 		 */
-		current_rel = query_planner(root, tlist,
-									standard_qp_callback, &qp_extra);
+		if (current_rel == NULL)
+			current_rel = query_planner(root, tlist,
+										standard_qp_callback, &qp_extra);
 
 		/*
 		 * Convert the query's result tlist into PathTarget format.
diff --git a/src/backend/optimizer/prep/prepjointree.c b/src/backend/optimizer/prep/prepjointree.c
index cd6e11904e..78baec00dc 100644
--- a/src/backend/optimizer/prep/prepjointree.c
+++ b/src/backend/optimizer/prep/prepjointree.c
@@ -917,7 +917,6 @@ pull_up_simple_subquery(PlannerInfo *root, Node *jtnode, RangeTblEntry *rte,
 	subroot->grouping_map = NULL;
 	subroot->minmax_aggs = NIL;
 	subroot->qual_security_level = 0;
-	subroot->inhTargetKind = INHKIND_NONE;
 	subroot->hasRecursion = false;
 	subroot->wt_param_id = -1;
 	subroot->non_recursive_path = NULL;
diff --git a/src/backend/optimizer/prep/prepunion.c b/src/backend/optimizer/prep/prepunion.c
index d5720518a8..ef1f978889 100644
--- a/src/backend/optimizer/prep/prepunion.c
+++ b/src/backend/optimizer/prep/prepunion.c
@@ -2253,8 +2253,39 @@ adjust_appendrel_attrs_mutator(Node *node,
 											  context->appinfos);
 		return (Node *) phv;
 	}
+
+	/*
+	 * This is needed, because inheritance_make_rel_from_joinlist needs to
+	 * translate root->join_info_list executing make_rel_from_joinlist for a
+	 * given child.
+	 */
+	if (IsA(node, SpecialJoinInfo))
+	{
+		SpecialJoinInfo *oldinfo = (SpecialJoinInfo *) node;
+		SpecialJoinInfo *newinfo = makeNode(SpecialJoinInfo);
+
+		memcpy(newinfo, oldinfo, sizeof(SpecialJoinInfo));
+		newinfo->min_lefthand = adjust_child_relids(oldinfo->min_lefthand,
+													context->nappinfos,
+													context->appinfos);
+		newinfo->min_righthand = adjust_child_relids(oldinfo->min_righthand,
+													 context->nappinfos,
+													 context->appinfos);
+		newinfo->syn_lefthand = adjust_child_relids(oldinfo->syn_lefthand,
+													context->nappinfos,
+													context->appinfos);
+		newinfo->syn_righthand = adjust_child_relids(oldinfo->syn_righthand,
+													 context->nappinfos,
+													 context->appinfos);
+		newinfo->semi_rhs_exprs =
+					(List *) expression_tree_mutator((Node *)
+													 oldinfo->semi_rhs_exprs,
+													 adjust_appendrel_attrs_mutator,
+													 (void *) context);
+		return (Node *) newinfo;
+	}
+
 	/* 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));
diff --git a/src/backend/optimizer/util/plancat.c b/src/backend/optimizer/util/plancat.c
index 0c88c90de4..ed0953f9e1 100644
--- a/src/backend/optimizer/util/plancat.c
+++ b/src/backend/optimizer/util/plancat.c
@@ -1264,36 +1264,6 @@ get_relation_constraints(PlannerInfo *root,
 		}
 	}
 
-	/*
-	 * Append partition predicates, if any.
-	 *
-	 * For selects, partition pruning uses the parent table's partition bound
-	 * descriptor, instead of constraint exclusion which is driven by the
-	 * individual partition's partition constraint.
-	 */
-	if (enable_partition_pruning && root->parse->commandType != CMD_SELECT)
-	{
-		List	   *pcqual = RelationGetPartitionQual(relation);
-
-		if (pcqual)
-		{
-			/*
-			 * Run the partition quals through const-simplification similar to
-			 * check constraints.  We skip canonicalize_qual, though, because
-			 * partition quals should be in canonical form already; also,
-			 * since the qual is in implicit-AND format, we'd have to
-			 * explicitly convert it to explicit-AND format and back again.
-			 */
-			pcqual = (List *) eval_const_expressions(root, (Node *) pcqual);
-
-			/* Fix Vars to have the desired varno */
-			if (varno != 1)
-				ChangeVarNodes((Node *) pcqual, 1, varno, 0);
-
-			result = list_concat(result, pcqual);
-		}
-	}
-
 	heap_close(relation, NoLock);
 
 	return result;
@@ -1420,31 +1390,15 @@ relation_excluded_by_constraints(PlannerInfo *root,
 	switch (constraint_exclusion)
 	{
 		case CONSTRAINT_EXCLUSION_OFF:
-
-			/*
-			 * Don't prune if feature turned off -- except if the relation is
-			 * a partition.  While partprune.c-style partition pruning is not
-			 * yet in use for all cases (update/delete is not handled), it
-			 * would be a UI horror to use different user-visible controls
-			 * depending on such a volatile implementation detail.  Therefore,
-			 * for partitioned tables we use enable_partition_pruning to
-			 * control this behavior.
-			 */
-			if (root->inhTargetKind == INHKIND_PARTITIONED)
-				break;
 			return false;
 
 		case CONSTRAINT_EXCLUSION_PARTITION:
 
 			/*
 			 * When constraint_exclusion is set to 'partition' we only handle
-			 * OTHER_MEMBER_RELs, or BASERELs in cases where the result target
-			 * is an inheritance parent or a partitioned table.
+			 * OTHER_MEMBER_RELs.
 			 */
-			if ((rel->reloptkind != RELOPT_OTHER_MEMBER_REL) &&
-				!(rel->reloptkind == RELOPT_BASEREL &&
-				  root->inhTargetKind != INHKIND_NONE &&
-				  rel->relid == root->parse->resultRelation))
+			if (rel->reloptkind != RELOPT_OTHER_MEMBER_REL)
 				return false;
 			break;
 
diff --git a/src/include/nodes/relation.h b/src/include/nodes/relation.h
index 6fd24203dd..2ad3dc4711 100644
--- a/src/include/nodes/relation.h
+++ b/src/include/nodes/relation.h
@@ -319,9 +319,6 @@ typedef struct PlannerInfo
 	Index		qual_security_level;	/* minimum security_level for quals */
 	/* Note: qual_security_level is zero if there are no securityQuals */
 
-	InheritanceKind inhTargetKind;	/* indicates if the target relation is an
-									 * inheritance child or partition or a
-									 * partitioned table */
 	bool		hasJoinRTEs;	/* true if any RTEs are RTE_JOIN kind */
 	bool		hasLateralRTEs; /* true if any RTEs are marked LATERAL */
 	bool		hasDeletedRTEs; /* true if any RTE was deleted from jointree */
@@ -343,6 +340,34 @@ typedef struct PlannerInfo
 
 	/* Does this query modify any partition key columns? */
 	bool		partColsUpdated;
+
+	/*
+	 * The following fields are set during query planning portion of an
+	 * inherited UPDATE/DEELETE operation.
+	 */
+
+	/*
+	 * This stores the original version of the query's targetlist that's
+	 * not modified by the planner.
+	 */
+	List	   *unexpanded_tlist;
+
+	/*
+	 * List containing a PlannerInfo corresponding to each child target rel.
+	 * Content of each PlannerInfo is same as the parent PlannerInfo, except
+	 * for the parse tree which is a translated copy of the parent's parse
+	 * tree.
+	 */
+	List	   *inh_target_child_roots;
+
+	/*
+	 * RelOptInfos corresponding to each child target rel.  For leaf children,
+	 * it's the RelOptInfo representing the output of make_rel_from_joinlist()
+	 * called with the parent rel in the original join tree replaced by a
+	 * given leaf child.  For non-leaf children, it's the baserel RelOptInfo
+	 * itself, left as a placeholder.
+	 */
+	List	   *inh_target_child_rels;
 } PlannerInfo;
 
 
diff --git a/src/test/regress/expected/partition_join.out b/src/test/regress/expected/partition_join.out
index 3ba3aaf2d8..a539280851 100644
--- a/src/test/regress/expected/partition_join.out
+++ b/src/test/regress/expected/partition_join.out
@@ -1781,7 +1781,7 @@ WHERE EXISTS (
                Filter: (c IS NULL)
          ->  Nested Loop
                ->  Seq Scan on int4_tbl
-               ->  Subquery Scan on ss_1
+               ->  Subquery Scan on ss
                      ->  Limit
                            ->  Seq Scan on int8_tbl int8_tbl_1
    ->  Nested Loop Semi Join
@@ -1789,7 +1789,7 @@ WHERE EXISTS (
                Filter: (c IS NULL)
          ->  Nested Loop
                ->  Seq Scan on int4_tbl
-               ->  Subquery Scan on ss_2
+               ->  Subquery Scan on ss
                      ->  Limit
                            ->  Seq Scan on int8_tbl int8_tbl_2
 (28 rows)
-- 
2.11.0

From 26c8691391ee149c317c03f2a99a671d068fd926 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Fri, 26 Oct 2018 16:45:59 +0900
Subject: [PATCH v6 2/6] Store inheritance root parent index in otherrel's
 RelOptInfo

Although it's set by build_simple_rel, it's not being used by any
code yet.
---
 src/backend/nodes/outfuncs.c         |  1 +
 src/backend/optimizer/util/relnode.c | 14 ++++++++++++++
 src/include/nodes/relation.h         |  4 ++++
 3 files changed, 19 insertions(+)

diff --git a/src/backend/nodes/outfuncs.c b/src/backend/nodes/outfuncs.c
index 08657fcfd9..1d7c420e75 100644
--- a/src/backend/nodes/outfuncs.c
+++ b/src/backend/nodes/outfuncs.c
@@ -2370,6 +2370,7 @@ _outRelOptInfo(StringInfo str, const RelOptInfo *node)
 	WRITE_BOOL_FIELD(consider_partitionwise_join);
 	WRITE_BITMAPSET_FIELD(top_parent_relids);
 	WRITE_NODE_FIELD(partitioned_child_rels);
+	WRITE_UINT_FIELD(inh_root_parent);
 }
 
 static void
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index 39f5729b91..29ba19349f 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -215,9 +215,23 @@ build_simple_rel(PlannerInfo *root, int relid, RelOptInfo *parent)
 			rel->top_parent_relids = parent->top_parent_relids;
 		else
 			rel->top_parent_relids = bms_copy(parent->relids);
+
+		/*
+		 * For inheritance child relations, we also set inh_root_parent.
+		 * Note that 'parent' might itself be a child (a sub-partitioned
+		 * partition), in which case we simply use its value of
+		 * inh_root_parent.
+		 */
+		if (parent->rtekind == RTE_RELATION)
+			rel->inh_root_parent = parent->inh_root_parent > 0 ?
+										parent->inh_root_parent :
+										parent->relid;
 	}
 	else
+	{
 		rel->top_parent_relids = NULL;
+		rel->inh_root_parent = 0;
+	}
 
 	/* Check type of rtable entry */
 	switch (rte->rtekind)
diff --git a/src/include/nodes/relation.h b/src/include/nodes/relation.h
index 2ad3dc4711..94f14019bd 100644
--- a/src/include/nodes/relation.h
+++ b/src/include/nodes/relation.h
@@ -728,6 +728,10 @@ typedef struct RelOptInfo
 	List	  **partexprs;		/* Non-nullable partition key expressions. */
 	List	  **nullable_partexprs; /* Nullable partition key expressions. */
 	List	   *partitioned_child_rels; /* List of RT indexes. */
+
+	Index		inh_root_parent;	/* For otherrels, this is the RT index of
+									 * inheritance table mentioned in the query
+									 * from which this relation originated */
 } RelOptInfo;
 
 /*
-- 
2.11.0

From 540557dba91fc10087b05f356a2f7e2caf376897 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Wed, 17 Oct 2018 18:14:13 +0900
Subject: [PATCH v6 3/6] Lazy creation of RTEs for inheritance children

Currently, expand_inherited_tables called from subquery_planner opens
all inheritance child tables and adds them to the query's range
table and PlannerInfo in the form of AppendRelInfo's initially and
later RelOptInfo's.  For partitioning, that's pretty wasteful, because
it's possible to determine only the partitions that will need to be
scanned using partition pruning, which doesn't require opening the
partitions themselves.  However, the point at which the above
processing happens is too early to perform partition pruning.

This commit rearranges things within the planner so that inheritance
child relations can be added to the Query and PlannerInfo during
make_one_rel, just before set_base_rel_sizes is called.  Although the
late initialization approach only benefits the partitioning case, it
seems undesirable to do it only for partitioned tables, because it
means adding code to handle partitions specially at various places
within the planner.  So, *all* inheritance parent tables are expanded
in make_one_rel.  All unpruned partitions are added to Query in the
form of their RangeTblEntry's being added to the range table and to
PlannerInfo in the form of an AppendRelInfo and a RelOptInfo for each.

For partitioning, although we don't create a RangeTblEntry and
RelOptInfo for pruned partitions at make_one_rel time, partitionwise
join code relies on the fact that even though partitions may have
been pruned, they'd still own a RelOptInfo to handle the outer join
case where the pruned partition appears on the nullable side of join.
Partitionwise join code deals with that by allocating dummy
RelOptInfos for pruned partitions that are based mostly on their
parent's properties.

There are some regression test diffs:

 1. Caused by the fact that we no longer allocate a duplicate RT
    entry for a partitioned table in its role as child, as seen in
    the partition_aggregate.out test output.

 2. Those in postgres_fdw.out are caused by the fact that junk columns
    required for row marking are added to reltarget->exprs later than
    user columns, because the row marking junk columns arent added
    until after the inheritance is expanded which as of this commit
    is later than it used to be.
---
 contrib/postgres_fdw/expected/postgres_fdw.out    |  32 +-
 src/backend/optimizer/path/allpaths.c             | 222 ++----
 src/backend/optimizer/path/joinrels.c             |  62 ++
 src/backend/optimizer/plan/initsplan.c            |  58 --
 src/backend/optimizer/plan/planner.c              |  60 +-
 src/backend/optimizer/plan/setrefs.c              |   6 +
 src/backend/optimizer/prep/preptlist.c            |  15 +-
 src/backend/optimizer/prep/prepunion.c            | 852 +++++++++++++++-------
 src/backend/optimizer/util/Makefile               |   2 +-
 src/backend/optimizer/util/plancat.c              |  40 +-
 src/backend/optimizer/util/relnode.c              |  80 +-
 src/backend/partitioning/partprune.c              |  43 +-
 src/include/nodes/relation.h                      |   8 +
 src/include/optimizer/pathnode.h                  |   1 +
 src/include/optimizer/plancat.h                   |   2 +-
 src/include/optimizer/prep.h                      |   9 +-
 src/include/partitioning/partprune.h              |   2 +-
 src/test/regress/expected/partition_aggregate.out |   4 +-
 18 files changed, 882 insertions(+), 616 deletions(-)

diff --git a/contrib/postgres_fdw/expected/postgres_fdw.out b/contrib/postgres_fdw/expected/postgres_fdw.out
index 21a2ef5ad3..f546260af8 100644
--- a/contrib/postgres_fdw/expected/postgres_fdw.out
+++ b/contrib/postgres_fdw/expected/postgres_fdw.out
@@ -7085,15 +7085,15 @@ select * from bar where f1 in (select f1 from foo) for update;
                      Output: bar2.f1, bar2.f2, bar2.ctid, bar2.*, bar2.tableoid
                      Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct2 FOR UPDATE
          ->  Hash
-               Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+               Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                ->  HashAggregate
-                     Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                     Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                      Group Key: foo.f1
                      ->  Append
                            ->  Seq Scan on public.foo
-                                 Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                                 Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                            ->  Foreign Scan on public.foo2
-                                 Output: foo2.ctid, foo2.*, foo2.tableoid, foo2.f1
+                                 Output: foo2.f1, foo2.ctid, foo2.*, foo2.tableoid
                                  Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct1
 (23 rows)
 
@@ -7123,15 +7123,15 @@ select * from bar where f1 in (select f1 from foo) for share;
                      Output: bar2.f1, bar2.f2, bar2.ctid, bar2.*, bar2.tableoid
                      Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct2 FOR SHARE
          ->  Hash
-               Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+               Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                ->  HashAggregate
-                     Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                     Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                      Group Key: foo.f1
                      ->  Append
                            ->  Seq Scan on public.foo
-                                 Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                                 Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                            ->  Foreign Scan on public.foo2
-                                 Output: foo2.ctid, foo2.*, foo2.tableoid, foo2.f1
+                                 Output: foo2.f1, foo2.ctid, foo2.*, foo2.tableoid
                                  Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct1
 (23 rows)
 
@@ -7160,15 +7160,15 @@ update bar set f2 = f2 + 100 where f1 in (select f1 from foo);
          ->  Seq Scan on public.bar
                Output: bar.f1, bar.f2, bar.ctid
          ->  Hash
-               Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+               Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                ->  HashAggregate
-                     Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                     Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                      Group Key: foo.f1
                      ->  Append
                            ->  Seq Scan on public.foo
-                                 Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                                 Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                            ->  Foreign Scan on public.foo2
-                                 Output: foo2.ctid, foo2.*, foo2.tableoid, foo2.f1
+                                 Output: foo2.f1, foo2.ctid, foo2.*, foo2.tableoid
                                  Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct1
    ->  Hash Join
          Output: bar2.f1, (bar2.f2 + 100), bar2.f3, bar2.ctid, foo.ctid, foo.*, foo.tableoid
@@ -7178,15 +7178,15 @@ update bar set f2 = f2 + 100 where f1 in (select f1 from foo);
                Output: bar2.f1, bar2.f2, bar2.f3, bar2.ctid
                Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct2 FOR UPDATE
          ->  Hash
-               Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+               Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                ->  HashAggregate
-                     Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                     Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                      Group Key: foo.f1
                      ->  Append
                            ->  Seq Scan on public.foo
-                                 Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                                 Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                            ->  Foreign Scan on public.foo2
-                                 Output: foo2.ctid, foo2.*, foo2.tableoid, foo2.f1
+                                 Output: foo2.f1, foo2.ctid, foo2.*, foo2.tableoid
                                  Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct1
 (39 rows)
 
diff --git a/src/backend/optimizer/path/allpaths.c b/src/backend/optimizer/path/allpaths.c
index 7787592870..a4dd34f2cd 100644
--- a/src/backend/optimizer/path/allpaths.c
+++ b/src/backend/optimizer/path/allpaths.c
@@ -44,7 +44,6 @@
 #include "optimizer/var.h"
 #include "parser/parse_clause.h"
 #include "parser/parsetree.h"
-#include "partitioning/partprune.h"
 #include "rewrite/rewriteManip.h"
 #include "utils/lsyscache.h"
 
@@ -180,6 +179,16 @@ make_one_rel(PlannerInfo *root, List *joinlist)
 	set_base_rel_consider_startup(root);
 
 	/*
+	 * Expand RT entries that represent inherited or partitioned tables.
+	 * This will perform partition pruning on partitioned tables in the
+	 * original range table and also recursively on any child partitioned
+	 * tables that were added by the expansion of the original parent(s).
+	 * As new entries are added to the range table, various arrays in the
+	 * PlannerInfo will be expanded accordingly.
+	 */
+	expand_inherited_tables(root);
+
+	/*
 	 * Compute size estimates and consider_parallel flags for each base rel.
 	 */
 	set_base_rel_sizes(root);
@@ -404,7 +413,11 @@ set_rel_size(PlannerInfo *root, RelOptInfo *rel,
 		 */
 		set_dummy_rel_pathlist(rel);
 	}
-	else if (rte->inh)
+	/*
+	 * expand_inherited_tables may have proved that the relation is empty, so
+	 * check if it's so.
+	 */
+	else if (rte->inh && !IS_DUMMY_REL(rel))
 	{
 		/* It's an "append relation", process accordingly */
 		set_append_rel_size(root, rel, rti, rte);
@@ -957,8 +970,6 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 	double	   *parent_attrsizes;
 	int			nattrs;
 	ListCell   *l;
-	Relids		live_children = NULL;
-	bool		did_pruning = false;
 
 	/* Guard against stack overflow due to overly deep inheritance tree. */
 	check_stack_depth();
@@ -966,32 +977,6 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 	Assert(IS_SIMPLE_REL(rel));
 
 	/*
-	 * Initialize partitioned_child_rels to contain this RT index.
-	 *
-	 * Note that during the set_append_rel_pathlist() phase, we will bubble up
-	 * the indexes of partitioned relations that appear down in the tree, so
-	 * that when we've created Paths for all the children, the root
-	 * partitioned table's list will contain all such indexes.
-	 */
-	if (rte->relkind == RELKIND_PARTITIONED_TABLE)
-		rel->partitioned_child_rels = list_make1_int(rti);
-
-	/*
-	 * If the partitioned relation has any baserestrictinfo quals then we
-	 * attempt to use these quals to prune away partitions that cannot
-	 * possibly contain any tuples matching these quals.  In this case we'll
-	 * store the relids of all partitions which could possibly contain a
-	 * matching tuple, and skip anything else in the loop below.
-	 */
-	if (enable_partition_pruning &&
-		rte->relkind == RELKIND_PARTITIONED_TABLE &&
-		rel->baserestrictinfo != NIL)
-	{
-		live_children = prune_append_rel_partitions(rel);
-		did_pruning = true;
-	}
-
-	/*
 	 * If this is a partitioned baserel, set the consider_partitionwise_join
 	 * flag; currently, we only consider partitionwise joins with the baserel
 	 * if its targetlist doesn't contain a whole-row Var.
@@ -1028,12 +1013,8 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 		int			childRTindex;
 		RangeTblEntry *childRTE;
 		RelOptInfo *childrel;
-		List	   *childquals;
-		Index		cq_min_security;
-		bool		have_const_false_cq;
 		ListCell   *parentvars;
 		ListCell   *childvars;
-		ListCell   *lc;
 		PlannerInfo *subroot = root;
 
 		/* append_rel_list contains all append rels; ignore others */
@@ -1042,18 +1023,34 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 
 		childRTindex = appinfo->child_relid;
 		childRTE = root->simple_rte_array[childRTindex];
+		Assert(childRTE != NULL);
 
 		/*
-		 * The child rel's RelOptInfo was already created during
-		 * add_base_rels_to_query.
+		 * The child rel's RelOptInfo is created during
+		 * expand_inherited_tables().
 		 */
 		childrel = find_base_rel(root, childRTindex);
 		Assert(childrel->reloptkind == RELOPT_OTHER_MEMBER_REL);
 
 		/*
-		 * Copy/Modify targetlist. Even if this child is deemed empty, we need
-		 * its targetlist in case it falls on nullable side in a child-join
-		 * because of partitionwise join.
+		 * Child relation may have be marked dummy if build_append_child_rel
+		 * found self-contradictory quals.
+		 */
+		if (IS_DUMMY_REL(childrel))
+			continue;
+
+		if (relation_excluded_by_constraints(root, childrel, childRTE))
+		{
+			/*
+			 * This child need not be scanned, so we can omit it from the
+			 * appendrel.
+			 */
+			set_dummy_rel_pathlist(childrel);
+			continue;
+		}
+
+		/*
+		 * Copy/Modify targetlist.
 		 *
 		 * NB: the resulting childrel->reltarget->exprs may contain arbitrary
 		 * expressions, which otherwise would not occur in a rel's targetlist.
@@ -1082,144 +1079,6 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 			add_child_rel_equivalences(root, appinfo, rel, childrel);
 		childrel->has_eclass_joins = rel->has_eclass_joins;
 
-		/*
-		 * We have to copy the parent's quals to the child, with appropriate
-		 * substitution of variables.  However, only the baserestrictinfo
-		 * quals are needed before we can check for constraint exclusion; so
-		 * do that first and then check to see if we can disregard this child.
-		 *
-		 * The child rel's targetlist might contain non-Var expressions, which
-		 * means that substitution into the quals could produce opportunities
-		 * for const-simplification, and perhaps even pseudoconstant quals.
-		 * Therefore, transform each RestrictInfo separately to see if it
-		 * reduces to a constant or pseudoconstant.  (We must process them
-		 * separately to keep track of the security level of each qual.)
-		 */
-		childquals = NIL;
-		cq_min_security = UINT_MAX;
-		have_const_false_cq = false;
-		foreach(lc, rel->baserestrictinfo)
-		{
-			RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
-			Node	   *childqual;
-			ListCell   *lc2;
-
-			Assert(IsA(rinfo, RestrictInfo));
-			childqual = adjust_appendrel_attrs(root,
-											   (Node *) rinfo->clause,
-											   1, &appinfo);
-			childqual = eval_const_expressions(root, childqual);
-			/* check for flat-out constant */
-			if (childqual && IsA(childqual, Const))
-			{
-				if (((Const *) childqual)->constisnull ||
-					!DatumGetBool(((Const *) childqual)->constvalue))
-				{
-					/* Restriction reduces to constant FALSE or NULL */
-					have_const_false_cq = true;
-					break;
-				}
-				/* Restriction reduces to constant TRUE, so drop it */
-				continue;
-			}
-			/* might have gotten an AND clause, if so flatten it */
-			foreach(lc2, make_ands_implicit((Expr *) childqual))
-			{
-				Node	   *onecq = (Node *) lfirst(lc2);
-				bool		pseudoconstant;
-
-				/* check for pseudoconstant (no Vars or volatile functions) */
-				pseudoconstant =
-					!contain_vars_of_level(onecq, 0) &&
-					!contain_volatile_functions(onecq);
-				if (pseudoconstant)
-				{
-					/* tell createplan.c to check for gating quals */
-					root->hasPseudoConstantQuals = true;
-				}
-				/* reconstitute RestrictInfo with appropriate properties */
-				childquals = lappend(childquals,
-									 make_restrictinfo((Expr *) onecq,
-													   rinfo->is_pushed_down,
-													   rinfo->outerjoin_delayed,
-													   pseudoconstant,
-													   rinfo->security_level,
-													   NULL, NULL, NULL));
-				/* track minimum security level among child quals */
-				cq_min_security = Min(cq_min_security, rinfo->security_level);
-			}
-		}
-
-		/*
-		 * In addition to the quals inherited from the parent, we might have
-		 * securityQuals associated with this particular child node.
-		 * (Currently this can only happen in appendrels originating from
-		 * UNION ALL; inheritance child tables don't have their own
-		 * securityQuals, see expand_inherited_rtentry().)	Pull any such
-		 * securityQuals up into the baserestrictinfo for the child.  This is
-		 * similar to process_security_barrier_quals() for the parent rel,
-		 * except that we can't make any general deductions from such quals,
-		 * since they don't hold for the whole appendrel.
-		 */
-		if (childRTE->securityQuals)
-		{
-			Index		security_level = 0;
-
-			foreach(lc, childRTE->securityQuals)
-			{
-				List	   *qualset = (List *) lfirst(lc);
-				ListCell   *lc2;
-
-				foreach(lc2, qualset)
-				{
-					Expr	   *qual = (Expr *) lfirst(lc2);
-
-					/* not likely that we'd see constants here, so no check */
-					childquals = lappend(childquals,
-										 make_restrictinfo(qual,
-														   true, false, false,
-														   security_level,
-														   NULL, NULL, NULL));
-					cq_min_security = Min(cq_min_security, security_level);
-				}
-				security_level++;
-			}
-			Assert(security_level <= root->qual_security_level);
-		}
-
-		/*
-		 * OK, we've got all the baserestrictinfo quals for this child.
-		 */
-		childrel->baserestrictinfo = childquals;
-		childrel->baserestrict_min_security = cq_min_security;
-
-		if (have_const_false_cq)
-		{
-			/*
-			 * Some restriction clause reduced to constant FALSE or NULL after
-			 * substitution, so this child need not be scanned.
-			 */
-			set_dummy_rel_pathlist(childrel);
-			continue;
-		}
-
-		if (did_pruning && !bms_is_member(appinfo->child_relid, live_children))
-		{
-			/* This partition was pruned; skip it. */
-			set_dummy_rel_pathlist(childrel);
-			continue;
-		}
-
-		if (relation_excluded_by_constraints(root, childrel, childRTE))
-		{
-			/*
-			 * This child need not be scanned, so we can omit it from the
-			 * appendrel.
-			 */
-			set_dummy_rel_pathlist(childrel);
-			continue;
-		}
-
 		/* CE failed, so finish copying/modifying join quals. */
 		childrel->joininfo = (List *)
 			adjust_appendrel_attrs(root,
@@ -1284,8 +1143,7 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 
 			/*
 			 * If the childrel itself was a partitioned table, its children
-			 * would've been added into subroot.  Copy relevant fields
-			 * into the parent root.
+			 * would've been added into subroot.
 			 */
 			if (subroot->inh_target_child_roots != NIL)
 				root->inh_target_child_roots =
@@ -1442,9 +1300,10 @@ adjust_inherit_target_child(PlannerInfo *root, RelOptInfo *childrel,
 	/*
 	 * Apply planner's expansion of targetlist, such as adding various junk
 	 * column, filling placeholder entries for dropped columns, etc., all of
-	 * which occurs with the child's TupleDesc.
+	 * which occurs with the child's TupleDesc.  Since inheritance has already
+	 * been expanded (we wouldn't be here otherwise), pass true.
 	 */
-	tlist = preprocess_targetlist(subroot);
+	tlist = preprocess_targetlist(subroot, true);
 	subroot->processed_tlist = tlist;
 	build_base_rel_tlists(subroot, tlist);
 
@@ -2826,6 +2685,7 @@ inheritance_make_rel_from_joinlist(PlannerInfo *root, List *joinlist)
 
 		Assert(subroot->parse->resultRelation > 0);
 		childrel = find_base_rel(root, subroot->parse->resultRelation);
+		Assert(childrel != NULL);
 		appinfo = root->append_rel_array[subroot->parse->resultRelation];
 
 		if (appinfo->parent_relid != root->parse->resultRelation)
diff --git a/src/backend/optimizer/path/joinrels.c b/src/backend/optimizer/path/joinrels.c
index d3d21fed5d..da0831de4e 100644
--- a/src/backend/optimizer/path/joinrels.c
+++ b/src/backend/optimizer/path/joinrels.c
@@ -20,6 +20,7 @@
 #include "optimizer/pathnode.h"
 #include "optimizer/paths.h"
 #include "optimizer/prep.h"
+#include "optimizer/tlist.h"
 #include "partitioning/partbounds.h"
 #include "utils/lsyscache.h"
 #include "utils/memutils.h"
@@ -46,6 +47,9 @@ static void try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1,
 					   List *parent_restrictlist);
 static int match_expr_to_partition_keys(Expr *expr, RelOptInfo *rel,
 							 bool strict_op);
+static RelOptInfo *build_dummy_partition_rel(PlannerInfo *root,
+									RelOptInfo *parent,
+									int partidx);
 
 
 /*
@@ -1376,6 +1380,11 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
 		AppendRelInfo **appinfos;
 		int			nappinfos;
 
+		if (child_rel1 == NULL)
+			child_rel1 = build_dummy_partition_rel(root, rel1, cnt_parts);
+		if (child_rel2 == NULL)
+			child_rel2 = build_dummy_partition_rel(root, rel2, cnt_parts);
+
 		/* We should never try to join two overlapping sets of rels. */
 		Assert(!bms_overlap(child_rel1->relids, child_rel2->relids));
 		child_joinrelids = bms_union(child_rel1->relids, child_rel2->relids);
@@ -1582,3 +1591,56 @@ match_expr_to_partition_keys(Expr *expr, RelOptInfo *rel, bool strict_op)
 
 	return -1;
 }
+
+/*
+ * build_dummy_partition_rel
+ *		Build a RelOptInfo and AppendRelInfo for a pruned partition
+ *
+ * This does not result in opening the relation or a range table entry being
+ * created.  Also, the RelOptInfo thus created is not stored anywhere else
+ * beside the parent's part_rels array.
+ *
+ * The only reason this exists is because partition-wise join, in some cases,
+ * needs a RelOptInfo to represent an empty relation that's on the nullable
+ * side of an outer join, so that a Path representing the outer join can be
+ * created.
+ */
+RelOptInfo *
+build_dummy_partition_rel(PlannerInfo *root, RelOptInfo *parent, int partidx)
+{
+	RangeTblEntry *parentrte = root->simple_rte_array[parent->relid];
+	RelOptInfo *rel;
+
+	Assert(parent->part_rels[partidx] == NULL);
+
+	/* Create minimally valid-looking RelOptInfo with parent's relid. */
+	rel = makeNode(RelOptInfo);
+	rel->reloptkind = RELOPT_OTHER_MEMBER_REL;
+	rel->relid = parent->relid;
+	rel->relids = bms_copy(parent->relids);
+	if (parent->top_parent_relids)
+		rel->top_parent_relids = parent->top_parent_relids;
+	else
+		rel->top_parent_relids = bms_copy(parent->relids);
+	rel->reltarget = copy_pathtarget(parent->reltarget);
+	parent->part_rels[partidx] = rel;
+	mark_dummy_rel(rel);
+
+	/*
+	 * Now we'll need a (no-op) AppendRelInfo for parent, because we're
+	 * setting the dummy partition's relid to be same as the parent's.
+	 */
+	if (root->append_rel_array[parent->relid] == NULL)
+	{
+		/* Pass parent's info as for both the parent rel and child rel. */
+		AppendRelInfo *appinfo = make_append_rel_info(parent, parentrte,
+													  parent->tupdesc,
+													  parentrte->relid,
+													  parent->reltype,
+													  parent->relid);
+
+		root->append_rel_array[parent->relid] = appinfo;
+	}
+
+	return rel;
+}
diff --git a/src/backend/optimizer/plan/initsplan.c b/src/backend/optimizer/plan/initsplan.c
index 01335db511..7636aa82c4 100644
--- a/src/backend/optimizer/plan/initsplan.c
+++ b/src/backend/optimizer/plan/initsplan.c
@@ -616,64 +616,6 @@ create_lateral_join_info(PlannerInfo *root)
 				bms_add_member(brel2->lateral_referencers, rti);
 		}
 	}
-
-	/*
-	 * Lastly, propagate lateral_relids and lateral_referencers from appendrel
-	 * parent rels to their child rels.  We intentionally give each child rel
-	 * the same minimum parameterization, even though it's quite possible that
-	 * some don't reference all the lateral rels.  This is because any append
-	 * path for the parent will have to have the same parameterization for
-	 * every child anyway, and there's no value in forcing extra
-	 * reparameterize_path() calls.  Similarly, a lateral reference to the
-	 * parent prevents use of otherwise-movable join rels for each child.
-	 */
-	for (rti = 1; rti < root->simple_rel_array_size; rti++)
-	{
-		RelOptInfo *brel = root->simple_rel_array[rti];
-		RangeTblEntry *brte = root->simple_rte_array[rti];
-
-		/*
-		 * Skip empty slots. Also skip non-simple relations i.e. dead
-		 * relations.
-		 */
-		if (brel == NULL || !IS_SIMPLE_REL(brel))
-			continue;
-
-		/*
-		 * In the case of table inheritance, the parent RTE is directly linked
-		 * to every child table via an AppendRelInfo.  In the case of table
-		 * partitioning, the inheritance hierarchy is expanded one level at a
-		 * time rather than flattened.  Therefore, an other member rel that is
-		 * a partitioned table may have children of its own, and must
-		 * therefore be marked with the appropriate lateral info so that those
-		 * children eventually get marked also.
-		 */
-		Assert(brte);
-		if (brel->reloptkind == RELOPT_OTHER_MEMBER_REL &&
-			(brte->rtekind != RTE_RELATION ||
-			 brte->relkind != RELKIND_PARTITIONED_TABLE))
-			continue;
-
-		if (brte->inh)
-		{
-			foreach(lc, root->append_rel_list)
-			{
-				AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(lc);
-				RelOptInfo *childrel;
-
-				if (appinfo->parent_relid != rti)
-					continue;
-				childrel = root->simple_rel_array[appinfo->child_relid];
-				Assert(childrel->reloptkind == RELOPT_OTHER_MEMBER_REL);
-				Assert(childrel->direct_lateral_relids == NULL);
-				childrel->direct_lateral_relids = brel->direct_lateral_relids;
-				Assert(childrel->lateral_relids == NULL);
-				childrel->lateral_relids = brel->lateral_relids;
-				Assert(childrel->lateral_referencers == NULL);
-				childrel->lateral_referencers = brel->lateral_referencers;
-			}
-		}
-	}
 }
 
 
diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index 14e59188cd..5801ea0854 100644
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -23,6 +23,7 @@
 #include "access/sysattr.h"
 #include "access/xact.h"
 #include "catalog/pg_constraint.h"
+#include "catalog/pg_inherits.h"
 #include "catalog/pg_proc.h"
 #include "catalog/pg_type.h"
 #include "executor/executor.h"
@@ -699,27 +700,24 @@ subquery_planner(PlannerGlobal *glob, Query *parse,
 		}
 		if (rte->lateral)
 			root->hasLateralRTEs = true;
+
+		/*
+		 * While at it, also update the inh status.  If the relation doesn't
+		 * or can't have any children, there is no point in letting inh be set
+		 * to true.  Note that we do this before processing rowmarks, so that
+		 * the correct information for setting isParent field of PlanRowMarks.
+		 */
+		if (rte->rtekind == RTE_RELATION)
+			rte->inh = rte->inh && has_subclass(rte->relid);
 	}
 
 	/*
 	 * Preprocess RowMark information.  We need to do this after subquery
-	 * pullup (so that all non-inherited RTEs are present) and before
-	 * inheritance expansion (so that the info is available for
-	 * expand_inherited_tables to examine and modify).
+	 * pullup (so that all non-inherited RTEs are present).
 	 */
 	preprocess_rowmarks(root);
 
 	/*
-	 * Expand any rangetable entries that are inheritance sets into "append
-	 * relations".  This can add entries to the rangetable, but they must be
-	 * plain base relations not joins, so it's OK (and marginally more
-	 * efficient) to do it after checking for join RTEs.  We must do it after
-	 * pulling up subqueries, else we'd fail to handle inherited tables in
-	 * subqueries.
-	 */
-	expand_inherited_tables(root);
-
-	/*
 	 * Set hasHavingQual to remember if HAVING clause is present.  Needed
 	 * because preprocess_expression will reduce a constant-true condition to
 	 * an empty qual list ... but "HAVING TRUE" is not a semantic no-op.
@@ -1212,8 +1210,11 @@ inheritance_planner(PlannerInfo *root)
 	 */
 	root->unexpanded_tlist = list_copy(root->parse->targetList);
 
-	/* Do the scan/join planning. */
-	tlist = preprocess_targetlist(root);
+	/*
+	 * Do the scan/join planning.  We haven't expanded inheritance yet, so
+	 * pass false.
+	 */
+	tlist = preprocess_targetlist(root, false);
 	root->processed_tlist = tlist;
 	qp_extra.tlist = tlist;
 	qp_extra.activeWindows = qp_extra.groupClause = NIL;
@@ -1222,9 +1223,10 @@ inheritance_planner(PlannerInfo *root)
 	/*
 	 * If it turned out during query planning that all the children are dummy
 	 * (pruned or excluded by constraints), no need to do the steps below.
-	 * Let grouping_planner finish up the final path.
+	 * For regular inheritance case, it's possible that we only need to modify
+	 * the parent table.  Let grouping_planner finish up the final path.
 	 */
-	if (IS_DUMMY_REL(planned_rel))
+	if (!parent_rte->inh || IS_DUMMY_REL(planned_rel))
 	{
 		grouping_planner(root, false, planned_rel, 0.0);
 		return;
@@ -1569,7 +1571,8 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 		 */
 		if (planned_rel == NULL)
 		{
-			tlist = preprocess_targetlist(root);
+			/* We haven't expanded inheritance yet, so pass false. */
+			tlist = preprocess_targetlist(root, false);
 
 			/*
 			 * We are now done hacking up the query's targetlist.  Most of the
@@ -1669,6 +1672,15 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 										standard_qp_callback, &qp_extra);
 
 		/*
+		 * Query planning may have added some columns to the top-level tlist,
+		 * which happens when there are row marks applied to inheritance
+		 * parent relations (additional junk columns needed for applying row
+		 * marks are added after expanding inheritance.)
+		 */
+		if (list_length(tlist) < list_length(root->processed_tlist))
+			tlist = root->processed_tlist;
+
+		/*
 		 * Convert the query's result tlist into PathTarget format.
 		 *
 		 * Note: it's desirable to not do this till after query_planner(),
@@ -2355,7 +2367,7 @@ preprocess_rowmarks(PlannerInfo *root)
 		newrc->allMarkTypes = (1 << newrc->markType);
 		newrc->strength = rc->strength;
 		newrc->waitPolicy = rc->waitPolicy;
-		newrc->isParent = false;
+		newrc->isParent = rte->inh;
 
 		prowmarks = lappend(prowmarks, newrc);
 	}
@@ -2380,7 +2392,7 @@ preprocess_rowmarks(PlannerInfo *root)
 		newrc->allMarkTypes = (1 << newrc->markType);
 		newrc->strength = LCS_NONE;
 		newrc->waitPolicy = LockWaitBlock;	/* doesn't matter */
-		newrc->isParent = false;
+		newrc->isParent = rte->rtekind == RTE_RELATION ? rte->inh : false;
 
 		prowmarks = lappend(prowmarks, newrc);
 	}
@@ -6760,6 +6772,10 @@ apply_scanjoin_target_to_paths(PlannerInfo *root,
 			int			nappinfos;
 			List	   *child_scanjoin_targets = NIL;
 
+			/* Skip processing pruned partitions. */
+			if (child_rel == NULL)
+				continue;
+
 			/* Translate scan/join targets for this child. */
 			appinfos = find_appinfos_by_relids(root, child_rel->relids,
 											   &nappinfos);
@@ -6861,6 +6877,10 @@ create_partitionwise_grouping_paths(PlannerInfo *root,
 		RelOptInfo *child_grouped_rel;
 		RelOptInfo *child_partially_grouped_rel;
 
+		/* Skip processing pruned partitions. */
+		if (child_input_rel == NULL)
+			continue;
+
 		/* Input child rel must have a path */
 		Assert(child_input_rel->pathlist != NIL);
 
diff --git a/src/backend/optimizer/plan/setrefs.c b/src/backend/optimizer/plan/setrefs.c
index 6d6ef1c376..454870609a 100644
--- a/src/backend/optimizer/plan/setrefs.c
+++ b/src/backend/optimizer/plan/setrefs.c
@@ -326,6 +326,12 @@ add_rtes_to_flat_rtable(PlannerInfo *root, bool recursing)
 													  UPPERREL_FINAL, NULL)))
 					add_rtes_to_flat_rtable(rel->subroot, true);
 			}
+			/*
+			 * A NULL rel also means an unplanned subquery rte, so apply
+			 * flatten_unplanned_rtes.
+			 */
+			else
+				flatten_unplanned_rtes(glob, rte);
 		}
 		rti++;
 	}
diff --git a/src/backend/optimizer/prep/preptlist.c b/src/backend/optimizer/prep/preptlist.c
index 8603feef2b..0747403acd 100644
--- a/src/backend/optimizer/prep/preptlist.c
+++ b/src/backend/optimizer/prep/preptlist.c
@@ -65,9 +65,13 @@ static List *expand_targetlist(List *tlist, int command_type,
  *
  * As a side effect, if there's an ON CONFLICT UPDATE clause, its targetlist
  * is also preprocessed (and updated in-place).
+ *
+ * inheritance_expanded specifies whether inheritance tables are expanded
+ * as of calling this function.  Caller must specify it because that affects
+ * which row marking related junk columns get added to the targetlist.
  */
 List *
-preprocess_targetlist(PlannerInfo *root)
+preprocess_targetlist(PlannerInfo *root, bool inheritance_expanded)
 {
 	Query	   *parse = root->parse;
 	int			result_relation = parse->resultRelation;
@@ -134,6 +138,15 @@ preprocess_targetlist(PlannerInfo *root)
 		if (rc->rti != rc->prti)
 			continue;
 
+		/*
+		 * For inheritance parent row marks, we defer adding junk columns
+		 * until we've added child row marks, because some children might
+		 * require different row mark types which will change the parent row
+		 * mark's allMarkTypes fields.
+		 */
+		if (rc->isParent && !inheritance_expanded)
+			continue;
+
 		if (rc->allMarkTypes & ~(1 << ROW_MARK_COPY))
 		{
 			/* Need to fetch TID */
diff --git a/src/backend/optimizer/prep/prepunion.c b/src/backend/optimizer/prep/prepunion.c
index ef1f978889..e4d4e7d6dd 100644
--- a/src/backend/optimizer/prep/prepunion.c
+++ b/src/backend/optimizer/prep/prepunion.c
@@ -39,15 +39,19 @@
 #include "miscadmin.h"
 #include "nodes/makefuncs.h"
 #include "nodes/nodeFuncs.h"
+#include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
 #include "optimizer/paths.h"
 #include "optimizer/planmain.h"
 #include "optimizer/planner.h"
 #include "optimizer/prep.h"
+#include "optimizer/restrictinfo.h"
 #include "optimizer/tlist.h"
+#include "optimizer/var.h"
 #include "parser/parse_coerce.h"
 #include "parser/parsetree.h"
+#include "partitioning/partprune.h"
 #include "utils/lsyscache.h"
 #include "utils/rel.h"
 #include "utils/selfuncs.h"
@@ -99,23 +103,26 @@ static List *generate_append_tlist(List *colTypes, List *colCollations,
 					  List *input_tlists,
 					  List *refnames_tlist);
 static List *generate_setop_grouplist(SetOperationStmt *op, List *targetlist);
+static void expand_append_rtentry(PlannerInfo *root, RelOptInfo *rel,
+					  RangeTblEntry *rte, Index rti);
 static void expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte,
-						 Index rti);
+						 Index rti, RelOptInfo *rel);
 static void expand_partitioned_rtentry(PlannerInfo *root,
 						   RangeTblEntry *parentrte,
-						   Index parentRTindex, Relation parentrel,
-						   PlanRowMark *top_parentrc, LOCKMODE lockmode,
-						   List **appinfos);
-static void expand_single_inheritance_child(PlannerInfo *root,
-								RangeTblEntry *parentrte,
-								Index parentRTindex, Relation parentrel,
-								PlanRowMark *top_parentrc, Relation childrel,
-								List **appinfos, RangeTblEntry **childrte_p,
-								Index *childRTindex_p);
-static void make_inh_translation_list(Relation oldrelation,
-						  Relation newrelation,
-						  Index newvarno,
-						  List **translated_vars);
+						   Index parentRTindex, RelOptInfo *parentrel);
+static RelOptInfo *add_inheritance_child_rel(PlannerInfo *root,
+						  RangeTblEntry *parentrte,
+						  Index parentRTindex, RelOptInfo *parentrel,
+						  PlanRowMark *top_parentrc, Relation childrel,
+						  RangeTblEntry **childrte_p, Index *childRTindex_p);
+static void make_inh_translation_list(TupleDesc old_tupdesc,
+						  TupleDesc new_tupdesc,
+						  Oid from_rel, Oid to_rel,
+						  Index newvarno, List **translated_vars);
+static RelOptInfo *build_append_child_rel(PlannerInfo *root,
+					   RelOptInfo *parent,
+					   Index childRTindex);
+static List *add_rowmark_junk_columns(PlannerInfo *root, PlanRowMark *rc);
 static Bitmapset *translate_col_privs(const Bitmapset *parent_privs,
 					List *translated_vars);
 static Node *adjust_appendrel_attrs_mutator(Node *node,
@@ -1472,33 +1479,134 @@ generate_setop_grouplist(SetOperationStmt *op, List *targetlist)
 void
 expand_inherited_tables(PlannerInfo *root)
 {
-	Index		nrtes;
+	int			orig_rtable_size;
 	Index		rti;
-	ListCell   *rl;
+
+	Assert(root->simple_rel_array_size > 0);
+	orig_rtable_size = root->simple_rel_array_size;
 
 	/*
-	 * expand_inherited_rtentry may add RTEs to parse->rtable. The function is
+	 * expand_append_rtentry may add RTEs to parse->rtable. The function is
 	 * expected to recursively handle any RTEs that it creates with inh=true.
 	 * So just scan as far as the original end of the rtable list.
 	 */
-	nrtes = list_length(root->parse->rtable);
-	rl = list_head(root->parse->rtable);
-	for (rti = 1; rti <= nrtes; rti++)
+	for (rti = 1; rti < orig_rtable_size; rti++)
 	{
-		RangeTblEntry *rte = (RangeTblEntry *) lfirst(rl);
+		RelOptInfo *brel = root->simple_rel_array[rti];
+		RangeTblEntry *rte = root->simple_rte_array[rti];
 
-		expand_inherited_rtentry(root, rte, rti);
-		rl = lnext(rl);
+		/* there may be empty slots corresponding to non-baserel RTEs */
+		if (brel == NULL)
+			continue;
+
+		if (rte->inh)
+			expand_append_rtentry(root, brel, rte, rti);
+	}
+}
+
+/*
+ * expand_append_rtentry
+ *		This initializes RelOptInfos for an appendrel's child relations, if
+ *		any
+ *
+ * 'rel' is the appendrel parent, whose range table entry ('rte') has been
+ * marked to require adding children.  An appendrel parent could either
+ * be a subquery (if we flattened UNION ALL query) or a table that's known
+ * to have inheritance children.  The latter consists of both regular
+ * inheritance parents and partitioned tables.
+ *
+ * For a subquery parent, there is not much to be done here because the
+ * children's RTEs are already present in the query, so we just initialize
+ * RelOptInfos for them.  Also, the AppendRelInfos for child subqueries
+ * have already been added.
+ *
+ * For tables, we need to add the children to the range table and initialize
+ * AppendRelInfos, RelOptInfos, and PlanRowMarks (if any) for them.  For
+ * a partitioned parent, we only add the children remaining after pruning.
+ * For regular inheritance parents, we find the children using
+ * find_all_inheritors and add all of them.
+ *
+ * If it turns out that there are no children, then we set rte->inh to false
+ * to let the caller know that only the parent table needs to be scanned.  The
+ * caller can accordingly switch to a non-Append path.  For a partitioned
+ * parent, that means an empty relation because parents themselves contain no
+ * data.
+ *
+ * For the regular inheritance case, the parent also gets another RTE with
+ * inh = false to represent it as an appendrel child.  The original RTE is
+ * considered to represent the whole inheritance set.
+ */
+static void
+expand_append_rtentry(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte,
+					  Index rti)
+{
+	Assert(rte->inh);
+	/* Inheritance parent (partitioned or not) or UNION ALL parent subquery. */
+	Assert(rte->rtekind == RTE_RELATION || rte->rtekind == RTE_SUBQUERY);
+
+	/*
+	 * UNION ALL children already got RTEs and AppendRelInfos, so just build
+	 * RelOptInfos and return.
+	 *
+	 * It might be a bit odd that this code is in this, because there is
+	 * nothing to expand really.
+	 */
+	if (rte->rtekind == RTE_SUBQUERY)
+	{
+		ListCell   *l;
+
+		/*
+		 * We don't need to use expand_planner_arrays in this case, because
+		 * no new child RTEs are created.  setup_simple_rel_arrays() and
+		 * setup_append_rel_array would've considered these child RTEs when
+		 * allocating space for various arrays.
+		 */
+		foreach(l, root->append_rel_list)
+		{
+			AppendRelInfo *appinfo = lfirst(l);
+			Index		childRTindex = appinfo->child_relid;
+
+			if (appinfo->parent_relid != rti)
+				continue;
+
+			Assert(childRTindex < root->simple_rel_array_size);
+			Assert(root->simple_rte_array[childRTindex] != NULL);
+
+			/*
+			 * We set the correct value of baserestricinfo and
+			 * baserestrict_min_security below.
+			 */
+			root->simple_rel_array[childRTindex] =
+				build_append_child_rel(root, rel, appinfo->child_relid);
+		}
+	}
+	else
+	{
+		Assert(rte->rtekind == RTE_RELATION);
+		Assert(has_subclass(rte->relid));
+
+		/*
+		 * The rewriter should already have obtained an appropriate lock on
+		 * each relation named in the query.  However, for each child relation
+		 * we add to the query, we must obtain an appropriate lock, because
+		 * this will be the first use of those relations in the
+		 * parse/rewrite/plan pipeline.  Child rels should use the same
+		 * lockmode as their parent.
+		 */
+		Assert(rte->rellockmode != NoLock);
+
+		if (rte->relkind == RELKIND_PARTITIONED_TABLE)
+			expand_partitioned_rtentry(root, rte, rti, rel);
+		else
+			expand_inherited_rtentry(root, rte, rti, rel);
 	}
 }
 
 /*
  * expand_inherited_rtentry
- *		Check whether a rangetable entry represents an inheritance set.
- *		If so, add entries for all the child tables to the query's
- *		rangetable, and build AppendRelInfo nodes for all the child tables
- *		and add them to root->append_rel_list.  If not, clear the entry's
- *		"inh" flag to prevent later code from looking for AppendRelInfos.
+ *		Add entries for all the child tables to the query's rangetable, and
+ *		build AppendRelInfo nodes for all the child tables and add them to
+ *		root->append_rel_list.
  *
  * Note that the original RTE is considered to represent the whole
  * inheritance set.  The first of the generated RTEs is an RTE for the same
@@ -1509,45 +1617,22 @@ expand_inherited_tables(PlannerInfo *root)
  * regular inheritance, a parent RTE must always have at least two associated
  * AppendRelInfos: one corresponding to the parent table as a simple member of
  * inheritance set and one or more corresponding to the actual children.
- * Since a partitioned table is not scanned, it might have only one associated
- * AppendRelInfo.
  */
 static void
-expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti)
+expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti,
+						 RelOptInfo *rel)
 {
 	Oid			parentOID;
 	PlanRowMark *oldrc;
-	Relation	oldrelation;
-	LOCKMODE	lockmode;
+	LOCKMODE	lockmode = rte->rellockmode;
 	List	   *inhOIDs;
 	ListCell   *l;
+	int			num_children;
+	int			num_children_added = 0;
 
-	/* Does RT entry allow inheritance? */
-	if (!rte->inh)
-		return;
-	/* Ignore any already-expanded UNION ALL nodes */
-	if (rte->rtekind != RTE_RELATION)
-	{
-		Assert(rte->rtekind == RTE_SUBQUERY);
-		return;
-	}
-	/* Fast path for common case of childless table */
+	Assert(rte->rtekind == RTE_RELATION);
+	Assert(lockmode != NoLock);
 	parentOID = rte->relid;
-	if (!has_subclass(parentOID))
-	{
-		/* Clear flag before returning */
-		rte->inh = false;
-		return;
-	}
-
-	/*
-	 * The rewriter should already have obtained an appropriate lock on each
-	 * relation named in the query.  However, for each child relation we add
-	 * to the query, we must obtain an appropriate lock, because this will be
-	 * the first use of those relations in the parse/rewrite/plan pipeline.
-	 * Child rels should use the same lockmode as their parent.
-	 */
-	lockmode = rte->rellockmode;
 
 	/* Scan for all members of inheritance set, acquire needed locks */
 	inhOIDs = find_all_inheritors(parentOID, lockmode, NULL);
@@ -1557,7 +1642,8 @@ expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti)
 	 * case.  This could happen despite above has_subclass() check, if table
 	 * once had a child but no longer does.
 	 */
-	if (list_length(inhOIDs) < 2)
+	num_children = list_length(inhOIDs);
+	if (num_children < 2)
 	{
 		/* Clear flag before returning */
 		rte->inh = false;
@@ -1565,219 +1651,220 @@ expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti)
 	}
 
 	/*
-	 * If parent relation is selected FOR UPDATE/SHARE, we need to mark its
-	 * PlanRowMark as isParent = true, and generate a new PlanRowMark for each
-	 * child.
+	 * If parent relation is selected FOR UPDATE/SHARE, preprocess_rowmarks
+	 * should've set isParent = true.  We'll generate a new PlanRowMark for
+	 * each child.
 	 */
 	oldrc = get_plan_rowmark(root->rowMarks, rti);
-	if (oldrc)
-		oldrc->isParent = true;
+	Assert(oldrc == NULL || oldrc->isParent);
 
 	/*
-	 * Must open the parent relation to examine its tupdesc.  We need not lock
-	 * it; we assume the rewriter already did.
+	 * Must expand PlannerInfo arrays by num_children before we can add
+	 * children.
 	 */
-	oldrelation = heap_open(parentOID, NoLock);
+	expand_planner_arrays(root, num_children);
 
-	/* Scan the inheritance set and expand it */
-	if (RelationGetPartitionDesc(oldrelation) != NULL)
+	foreach(l, inhOIDs)
 	{
-		Assert(rte->relkind == RELKIND_PARTITIONED_TABLE);
-
-		/*
-		 * If this table has partitions, recursively expand them in the order
-		 * in which they appear in the PartitionDesc.  While at it, also
-		 * extract the partition key columns of all the partitioned tables.
-		 */
-		expand_partitioned_rtentry(root, rte, rti, oldrelation, oldrc,
-								   lockmode, &root->append_rel_list);
-	}
-	else
-	{
-		List	   *appinfos = NIL;
+		Oid			childOID = lfirst_oid(l);
+		Relation	newrelation;
 		RangeTblEntry *childrte;
 		Index		childRTindex;
 
+		/* Already locked above. */
+		newrelation = heap_open(childOID, NoLock);
+
 		/*
-		 * This table has no partitions.  Expand any plain inheritance
-		 * children in the order the OIDs were returned by
-		 * find_all_inheritors.
+		 * It is possible that the parent table has children that are temp
+		 * tables of other backends.  We cannot safely access such tables
+		 * (because of buffering issues), and the best thing to do seems
+		 * to be to silently ignore them.
 		 */
-		foreach(l, inhOIDs)
+		if (RELATION_IS_OTHER_TEMP(newrelation))
 		{
-			Oid			childOID = lfirst_oid(l);
-			Relation	newrelation;
-
-			/* Open rel if needed; we already have required locks */
-			if (childOID != parentOID)
-				newrelation = heap_open(childOID, NoLock);
-			else
-				newrelation = oldrelation;
-
-			/*
-			 * It is possible that the parent table has children that are temp
-			 * tables of other backends.  We cannot safely access such tables
-			 * (because of buffering issues), and the best thing to do seems
-			 * to be to silently ignore them.
-			 */
-			if (childOID != parentOID && RELATION_IS_OTHER_TEMP(newrelation))
-			{
-				heap_close(newrelation, lockmode);
-				continue;
-			}
-
-			expand_single_inheritance_child(root, rte, rti, oldrelation, oldrc,
-											newrelation,
-											&appinfos, &childrte,
-											&childRTindex);
-
-			/* Close child relations, but keep locks */
-			if (childOID != parentOID)
-				heap_close(newrelation, NoLock);
+			heap_close(newrelation, lockmode);
+			continue;
 		}
 
-		/*
-		 * If all the children were temp tables, pretend it's a
-		 * non-inheritance situation; we don't need Append node in that case.
-		 * The duplicate RTE we added for the parent table is harmless, so we
-		 * don't bother to get rid of it; ditto for the useless PlanRowMark
-		 * node.
-		 */
-		if (list_length(appinfos) < 2)
-			rte->inh = false;
-		else
-			root->append_rel_list = list_concat(root->append_rel_list,
-												appinfos);
+		(void) add_inheritance_child_rel(root, rte, rti, rel, oldrc,
+										 newrelation, &childrte,
+										 &childRTindex);
+		Assert(childrte != NULL);
+		/* All regular inheritance children are leaf children. */
+		Assert(!childrte->inh);
+		Assert(childRTindex > 0);
 
+		/* Close child relations, but keep locks */
+		heap_close(newrelation, NoLock);
+		num_children_added++;
 	}
 
-	heap_close(oldrelation, NoLock);
+	/*
+	 * If all children, including the parent (as child rel), were
+	 * excluded, mark the parent rel as empty.  If all the children were temp
+	 * tables, pretend it's a non-inheritance situation; we don't need Append
+	 * node in that case.  The duplicate RTE we added for the parent table is
+	 * harmless, so we don't bother to get rid of it; ditto for the useless
+	 * PlanRowMark node.
+	 */
+	if (num_children_added == 0)
+		mark_dummy_rel(rel);
+	else if (num_children_added == 1)
+		rte->inh = false;
+
+	/*
+	 * Add junk columns needed by the row mark if any and also add the
+	 * relevant expressions to the root parent's reltarget.
+	 */
+	if (oldrc)
+	{
+		List   *tlist = add_rowmark_junk_columns(root, oldrc);
+
+		build_base_rel_tlists(root, tlist);
+	}
 }
 
 /*
  * expand_partitioned_rtentry
- *		Recursively expand an RTE for a partitioned table.
+ *		Prunes unnecessary partitions of a partitioned table and adds
+ *		remaining ones to the Query and the PlannerInfo
  *
- * Note that RelationGetPartitionDispatchInfo will expand partitions in the
- * same order as this code.
+ * Partitions are added to the query in order in which they are found in
+ * the parent's PartitionDesc.
+ *
+ * Note: even though only the unpruned partitions will be added to the
+ * resulting plan, this still locks *all* partitions via find_all_inheritors
+ * in order to avoid partitions being locked in a different order than other
+ * places in the backend that may lock partitions.
  */
 static void
 expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
-						   Index parentRTindex, Relation parentrel,
-						   PlanRowMark *top_parentrc, LOCKMODE lockmode,
-						   List **appinfos)
+						   Index parentRTindex, RelOptInfo *parentrel)
 {
+	LOCKMODE	lockmode = parentrte->rellockmode;
+	PlanRowMark *rootrc = NULL;
 	int			i;
-	RangeTblEntry *childrte;
-	Index		childRTindex;
-	PartitionDesc partdesc = RelationGetPartitionDesc(parentrel);
+	Bitmapset  *partindexes;
+	Index		rootParentRTindex = parentrel->inh_root_parent > 0 ?
+									parentrel->inh_root_parent :
+									parentRTindex;
 
-	check_stack_depth();
-
-	/* A partitioned table should always have a partition descriptor. */
-	Assert(partdesc);
-
-	Assert(parentrte->inh);
+	/* If root partitioned table, lock *all* partitions in the tree. */
+	if (parentRTindex == rootParentRTindex)
+		(void) find_all_inheritors(parentrte->relid, lockmode, NULL);
 
 	/*
-	 * Note down whether any partition key cols are being updated. Though it's
-	 * the root partitioned table's updatedCols we are interested in, we
-	 * instead use parentrte to get the updatedCols. This is convenient
-	 * because parentrte already has the root partrel's updatedCols translated
-	 * to match the attribute ordering of parentrel.
+	 * Initialize partitioned_child_rels to contain this RT index.
+	 *
+	 * Note that during the set_append_rel_pathlist() phase, values of the
+	 * indexes of partitioned relations that appear down in the tree will be
+	 * bubbled up into root parent's list so that when we've created Paths for
+	 * all the children, the root table's list will contain all such indexes.
 	 */
-	if (!root->partColsUpdated)
-		root->partColsUpdated =
-			has_partition_attrs(parentrel, parentrte->updatedCols, NULL);
+	parentrel->partitioned_child_rels = list_make1_int(parentRTindex);
 
-	/* First expand the partitioned table itself. */
-	expand_single_inheritance_child(root, parentrte, parentRTindex, parentrel,
-									top_parentrc, parentrel,
-									appinfos, &childrte, &childRTindex);
+	/* Perform pruning. */
+	partindexes = prune_append_rel_partitions(parentrel);
+
+	/* Must expand PlannerInfo arrays before we can add children. */
+	expand_planner_arrays(root, bms_num_members(partindexes));
 
 	/*
-	 * If the partitioned table has no partitions, treat this as the
-	 * non-inheritance case.
+	 * For partitioned tables, we also store the partition RelOptInfo
+	 * pointers in the parent's RelOptInfo.
 	 */
-	if (partdesc->nparts == 0)
-	{
-		parentrte->inh = false;
-		return;
-	}
+	parentrel->part_rels = (RelOptInfo **) palloc0(sizeof(RelOptInfo *) *
+												   parentrel->nparts);
 
-	for (i = 0; i < partdesc->nparts; i++)
+	rootrc = get_plan_rowmark(root->rowMarks, rootParentRTindex);
+	Assert(rootrc == NULL || rootrc->isParent);
+	i = -1;
+	while ((i = bms_next_member(partindexes, i)) >= 0)
 	{
-		Oid			childOID = partdesc->oids[i];
-		Relation	childrel;
+		Oid		childOID = parentrel->part_oids[i];
+		Relation	newrelation;
+		RelOptInfo *childrel;
+		RangeTblEntry *childrte;
+		Index		childRTindex;
 
-		/* Open rel; we already have required locks */
-		childrel = heap_open(childOID, NoLock);
+		/* Already locked above. */
+		newrelation = heap_open(childOID, NoLock);
+		Assert(!RELATION_IS_OTHER_TEMP(newrelation));
 
 		/*
-		 * Temporary partitions belonging to other sessions should have been
-		 * disallowed at definition, but for paranoia's sake, let's double
-		 * check.
+		 * A partitioned child table with 0 children is a dummy rel, so don't
+		 * bother creating planner objects for it.
 		 */
-		if (RELATION_IS_OTHER_TEMP(childrel))
-			elog(ERROR, "temporary relation from another session found as partition");
+		if (newrelation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE &&
+			RelationGetPartitionDesc(newrelation)->nparts == 0)
+		{
+			heap_close(newrelation, NoLock);
+			continue;
+		}
 
-		expand_single_inheritance_child(root, parentrte, parentRTindex,
-										parentrel, top_parentrc, childrel,
-										appinfos, &childrte, &childRTindex);
+		childrel = add_inheritance_child_rel(root, parentrte, parentRTindex,
+											 parentrel, rootrc, newrelation,
+											 &childrte, &childRTindex);
+		Assert(childrel != NULL);
+		parentrel->part_rels[i] = childrel;
 
-		/* If this child is itself partitioned, recurse */
-		if (childrel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
+		/* Close child relations, but keep locks */
+		heap_close(newrelation, NoLock);
+
+		/* If the child is partitioned itself, expand it too. */
+		if (childrel->part_scheme)
+		{
+			Assert(childrte->inh);
 			expand_partitioned_rtentry(root, childrte, childRTindex,
-									   childrel, top_parentrc, lockmode,
-									   appinfos);
+									   childrel);
+		}
+	}
 
-		/* Close child relation, but keep locks */
-		heap_close(childrel, NoLock);
+	/*
+	 * Add junk columns needed by the row mark if any and also add the
+	 * relevant expressions to the root parent's reltarget.
+	 */
+	if (rootrc)
+	{
+		List   *tlist = add_rowmark_junk_columns(root, rootrc);
+
+		build_base_rel_tlists(root, tlist);
 	}
 }
 
 /*
- * expand_single_inheritance_child
- *		Build a RangeTblEntry and an AppendRelInfo, if appropriate, plus
- *		maybe a PlanRowMark.
+ * add_inheritance_child_rel
+ *		Build a RangeTblEntry, an AppendRelInfo, a PlanRowMark, and finally
+ *		a RelOptInfo for an inheritance child relation.
  *
- * We now expand the partition hierarchy level by level, creating a
- * corresponding hierarchy of AppendRelInfos and RelOptInfos, where each
- * partitioned descendant acts as a parent of its immediate partitions.
- * (This is a difference from what older versions of PostgreSQL did and what
- * is still done in the case of table inheritance for unpartitioned tables,
- * where the hierarchy is flattened during RTE expansion.)
+ * The return value is the RelOptInfo that's added.
  *
  * PlanRowMarks still carry the top-parent's RTI, and the top-parent's
  * allMarkTypes field still accumulates values from all descendents.
  *
  * "parentrte" and "parentRTindex" are immediate parent's RTE and
  * RTI. "top_parentrc" is top parent's PlanRowMark.
- *
- * The child RangeTblEntry and its RTI are returned in "childrte_p" and
- * "childRTindex_p" resp.
  */
-static void
-expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte,
-								Index parentRTindex, Relation parentrel,
-								PlanRowMark *top_parentrc, Relation childrel,
-								List **appinfos, RangeTblEntry **childrte_p,
-								Index *childRTindex_p)
+static RelOptInfo *
+add_inheritance_child_rel(PlannerInfo *root, RangeTblEntry *parentrte,
+						  Index parentRTindex, RelOptInfo *parentrel,
+						  PlanRowMark *top_parentrc, Relation childrel,
+						  RangeTblEntry **childrte_p, Index *childRTindex_p)
 {
 	Query	   *parse = root->parse;
-	Oid			parentOID = RelationGetRelid(parentrel);
 	Oid			childOID = RelationGetRelid(childrel);
 	RangeTblEntry *childrte;
 	Index		childRTindex;
 	AppendRelInfo *appinfo;
+	RelOptInfo *childrelopt;
 
 	/*
 	 * Build an RTE for the child, and attach to query's rangetable list. We
 	 * copy most fields of the parent's RTE, but replace relation OID and
-	 * relkind, and set inh = false.  Also, set requiredPerms to zero since
-	 * all required permissions checks are done on the original RTE. Likewise,
-	 * set the child's securityQuals to empty, because we only want to apply
-	 * the parent's RLS conditions regardless of what RLS properties
+	 * relkind, and set inh appropriately.  Also, set requiredPerms to zero
+	 * since all required permissions checks are done on the original RTE.
+	 * Likewise, set the child's securityQuals to empty, because we only want
+	 * to apply the parent's RLS conditions regardless of what RLS properties
 	 * individual children may have.  (This is an intentional choice to make
 	 * inherited RLS work like regular permissions checks.) The parent
 	 * securityQuals will be propagated to children along with other base
@@ -1787,55 +1874,42 @@ expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte,
 	*childrte_p = childrte;
 	childrte->relid = childOID;
 	childrte->relkind = childrel->rd_rel->relkind;
-	/* A partitioned child will need to be expanded further. */
-	if (childOID != parentOID &&
-		childrte->relkind == RELKIND_PARTITIONED_TABLE)
-		childrte->inh = true;
-	else
-		childrte->inh = false;
+	/*
+	 * A partitioned child will need to be expanded as an append parent
+	 * itself, so set its inh to true.
+	 */
+	childrte->inh = (childrte->relkind == RELKIND_PARTITIONED_TABLE);
 	childrte->requiredPerms = 0;
 	childrte->securityQuals = NIL;
 	parse->rtable = lappend(parse->rtable, childrte);
 	childRTindex = list_length(parse->rtable);
 	*childRTindex_p = childRTindex;
 
-	/*
-	 * We need an AppendRelInfo if paths will be built for the child RTE. If
-	 * childrte->inh is true, then we'll always need to generate append paths
-	 * for it.  If childrte->inh is false, we must scan it if it's not a
-	 * partitioned table; but if it is a partitioned table, then it never has
-	 * any data of its own and need not be scanned.
-	 */
-	if (childrte->relkind != RELKIND_PARTITIONED_TABLE || childrte->inh)
-	{
-		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->translated_vars);
-		appinfo->parent_reloid = parentOID;
-		*appinfos = lappend(*appinfos, appinfo);
+	/* Create an AppendRelInfo and add it to planner's global list. */
+	appinfo = make_append_rel_info(parentrel, parentrte,
+								   childrel->rd_att,
+								   childOID,
+								   childrel->rd_rel->reltype,
+								   childRTindex);
+	root->append_rel_list = lappend(root->append_rel_list, appinfo);
 
-		/*
-		 * Translate the column permissions bitmaps to the child's attnums (we
-		 * have to build the translated_vars list before we can do this). But
-		 * if this is the parent table, leave copyObject's result alone.
-		 *
-		 * Note: we need to do this even though the executor won't run any
-		 * permissions checks on the child RTE.  The insertedCols/updatedCols
-		 * bitmaps may be examined for trigger-firing purposes.
-		 */
-		if (childOID != parentOID)
-		{
-			childrte->selectedCols = translate_col_privs(parentrte->selectedCols,
-														 appinfo->translated_vars);
-			childrte->insertedCols = translate_col_privs(parentrte->insertedCols,
-														 appinfo->translated_vars);
-			childrte->updatedCols = translate_col_privs(parentrte->updatedCols,
-														appinfo->translated_vars);
-		}
+	/*
+	 * Translate the column permissions bitmaps to the child's attnums (we
+	 * have to build the translated_vars list before we can do this). But
+	 * if this is the parent table, leave copyObject's result alone.
+	 *
+	 * Note: we need to do this even though the executor won't run any
+	 * permissions checks on the child RTE.  The insertedCols/updatedCols
+	 * bitmaps may be examined for trigger-firing purposes.
+	 */
+	if (childrte->relid != parentrte->relid)
+	{
+		childrte->selectedCols = translate_col_privs(parentrte->selectedCols,
+													 appinfo->translated_vars);
+		childrte->insertedCols = translate_col_privs(parentrte->insertedCols,
+													 appinfo->translated_vars);
+		childrte->updatedCols = translate_col_privs(parentrte->updatedCols,
+													appinfo->translated_vars);
 	}
 
 	/*
@@ -1867,6 +1941,24 @@ expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte,
 
 		root->rowMarks = lappend(root->rowMarks, childrc);
 	}
+
+	/*
+	 * Add the RelOptInfo.  Even though we may not really scan this relation
+	 * for reasons such as contradictory quals, we still need need to create
+	 * one, because for every RTE in the query's range table, there must be an
+	 * accompanying RelOptInfo.
+	 */
+
+	/* First, store the RTE and appinfos into planner arrays. */
+	Assert(root->simple_rte_array[childRTindex] == NULL);
+	root->simple_rte_array[childRTindex] = childrte;
+	Assert(root->append_rel_array[childRTindex] == NULL);
+	root->append_rel_array[childRTindex] = appinfo;
+
+	childrelopt = build_append_child_rel(root, parentrel, childRTindex);
+	Assert(childrelopt != NULL);
+
+	return childrelopt;
 }
 
 /*
@@ -1877,14 +1969,11 @@ expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte,
  * For paranoia's sake, we match type/collation as well as attribute name.
  */
 static void
-make_inh_translation_list(Relation oldrelation, Relation newrelation,
-						  Index newvarno,
-						  List **translated_vars)
+make_inh_translation_list(TupleDesc old_tupdesc, TupleDesc new_tupdesc,
+						  Oid from_rel, Oid to_rel,
+						  Index newvarno, List **translated_vars)
 {
 	List	   *vars = NIL;
-	TupleDesc	old_tupdesc = RelationGetDescr(oldrelation);
-	TupleDesc	new_tupdesc = RelationGetDescr(newrelation);
-	Oid			new_relid = RelationGetRelid(newrelation);
 	int			oldnatts = old_tupdesc->natts;
 	int			newnatts = new_tupdesc->natts;
 	int			old_attno;
@@ -1914,7 +2003,7 @@ make_inh_translation_list(Relation oldrelation, Relation newrelation,
 		 * When we are generating the "translation list" for the parent table
 		 * of an inheritance set, no need to search for matches.
 		 */
-		if (oldrelation == newrelation)
+		if (from_rel == to_rel)
 		{
 			vars = lappend(vars, makeVar(newvarno,
 										 (AttrNumber) (old_attno + 1),
@@ -1940,10 +2029,10 @@ make_inh_translation_list(Relation oldrelation, Relation newrelation,
 		{
 			HeapTuple	newtup;
 
-			newtup = SearchSysCacheAttName(new_relid, attname);
+			newtup = SearchSysCacheAttName(to_rel, attname);
 			if (!newtup)
 				elog(ERROR, "could not find inherited attribute \"%s\" of relation \"%s\"",
-					 attname, RelationGetRelationName(newrelation));
+					 attname, get_rel_name(to_rel));
 			new_attno = ((Form_pg_attribute) GETSTRUCT(newtup))->attnum - 1;
 			ReleaseSysCache(newtup);
 
@@ -1953,10 +2042,10 @@ make_inh_translation_list(Relation oldrelation, Relation newrelation,
 		/* Found it, check type and collation match */
 		if (atttypid != att->atttypid || atttypmod != att->atttypmod)
 			elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's type",
-				 attname, RelationGetRelationName(newrelation));
+				 attname, get_rel_name(to_rel));
 		if (attcollation != att->attcollation)
 			elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's collation",
-				 attname, RelationGetRelationName(newrelation));
+				 attname, get_rel_name(to_rel));
 
 		vars = lappend(vars, makeVar(newvarno,
 									 (AttrNumber) (new_attno + 1),
@@ -2023,6 +2112,255 @@ translate_col_privs(const Bitmapset *parent_privs,
 }
 
 /*
+ *	build_append_child_rel
+ *		Build a RelOptInfo for child relation of an append rel
+ *
+ * After creating the RelOptInfo for the given child RT index, it goes on to
+ * initialize some of its fields base on the parent RelOptInfo.
+ *
+ * If the quals in baserestrictinfo turns out to be self-contradictory, the
+ * RelOptInfo is marked dummy before returning.
+ */
+static RelOptInfo *
+build_append_child_rel(PlannerInfo *root,
+					   RelOptInfo *parent,
+					   Index childRTindex)
+{
+	RelOptInfo *childrel;
+	RangeTblEntry *childRTE = root->simple_rte_array[childRTindex];
+	AppendRelInfo *appinfo = root->append_rel_array[childRTindex];
+	List	   *childquals;
+	ListCell   *lc;
+	bool		have_const_false_cq;
+	Index		cq_min_security;
+
+	/* Build the RelOptInfo. */
+	childrel = build_simple_rel(root, childRTindex, parent);
+
+	/*
+	 * Propagate lateral_relids and lateral_referencers from appendrel
+	 * parent rels to their child rels.  We intentionally give each child rel
+	 * the same minimum parameterization, even though it's quite possible that
+	 * some don't reference all the lateral rels.  This is because any append
+	 * path for the parent will have to have the same parameterization for
+	 * every child anyway, and there's no value in forcing extra
+	 * reparameterize_path() calls.  Similarly, a lateral reference to the
+	 * parent prevents use of otherwise-movable join rels for each child.
+	 */
+	childrel->direct_lateral_relids = parent->direct_lateral_relids;
+	childrel->lateral_relids = parent->lateral_relids;
+	childrel->lateral_referencers = parent->lateral_referencers;
+
+	/*
+	 * We have to copy the parent's quals to the child, with appropriate
+	 * substitution of variables.  However, only the baserestrictinfo
+	 * quals are needed before we can check for constraint exclusion; so
+	 * do that first and then check to see if we can disregard this child.
+	 *
+	 * The child rel's targetlist might contain non-Var expressions, which
+	 * means that substitution into the quals could produce opportunities
+	 * for const-simplification, and perhaps even pseudoconstant quals.
+	 * Therefore, transform each RestrictInfo separately to see if it
+	 * reduces to a constant or pseudoconstant.  (We must process them
+	 * separately to keep track of the security level of each qual.)
+	 */
+	childquals = false;
+	cq_min_security = UINT_MAX;
+	have_const_false_cq = false;
+	foreach(lc, parent->baserestrictinfo)
+	{
+		RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
+		Node	   *childqual = (Node *) rinfo->clause;
+		ListCell   *lc2;
+
+		Assert(IsA(rinfo, RestrictInfo));
+		childqual = adjust_appendrel_attrs(root, childqual,
+										   1, &appinfo);
+		childqual = eval_const_expressions(root, childqual);
+		/* check for flat-out constant */
+		if (childqual && IsA(childqual, Const))
+		{
+			if (((Const *) childqual)->constisnull ||
+				!DatumGetBool(((Const *) childqual)->constvalue))
+			{
+				/* Restriction reduces to constant FALSE or NULL */
+				have_const_false_cq = true;
+				break;
+			}
+			/* Restriction reduces to constant TRUE, so drop it */
+			continue;
+		}
+		/* might have gotten an AND clause, if so flatten it */
+		foreach(lc2, make_ands_implicit((Expr *) childqual))
+		{
+			Node	   *onecq = (Node *) lfirst(lc2);
+			bool		pseudoconstant;
+
+			/* check for pseudoconstant (no Vars or volatile functions) */
+			pseudoconstant =
+					!contain_vars_of_level(onecq, 0) &&
+					!contain_volatile_functions(onecq);
+			if (pseudoconstant)
+			{
+				/* tell createplan.c to check for gating quals */
+				root->hasPseudoConstantQuals = true;
+			}
+			/* reconstitute RestrictInfo with appropriate properties */
+			childquals = lappend(childquals,
+								 make_restrictinfo((Expr *) onecq,
+												   rinfo->is_pushed_down,
+												   rinfo->outerjoin_delayed,
+												   pseudoconstant,
+												   rinfo->security_level,
+												   NULL, NULL, NULL));
+			cq_min_security = Min(cq_min_security, rinfo->security_level);
+		}
+	}
+
+	/*
+	 * In addition to the quals inherited from the parent, we might
+	 * have securityQuals associated with this particular child node.
+	 * (Currently this can only happen in appendrels originating from
+	 * UNION ALL; inheritance child tables don't have their own
+	 * securityQuals.)	Pull any such securityQuals up into the
+	 * baserestrictinfo for the child.  This is similar to
+	 * process_security_barrier_quals() for the parent rel, except
+	 * that we can't make any general deductions from such quals,
+	 * since they don't hold for the whole appendrel.
+	 */
+	if (childRTE->securityQuals)
+	{
+		Index		security_level = 0;
+
+		foreach(lc, childRTE->securityQuals)
+		{
+			List	   *qualset = (List *) lfirst(lc);
+			ListCell   *lc2;
+
+			foreach(lc2, qualset)
+			{
+				Expr	   *qual = (Expr *) lfirst(lc2);
+
+				/*
+				 * not likely that we'd see constants here, so no
+				 * check
+				 */
+				childquals = lappend(childquals,
+									 make_restrictinfo(qual,
+													   true,
+													   false,
+													   false,
+													   security_level,
+													   NULL, NULL,
+													   NULL));
+				cq_min_security = Min(cq_min_security, security_level);
+			}
+			security_level++;
+		}
+		Assert(security_level <= root->qual_security_level);
+	}
+
+	/* Set child's version of baserestrictinfo. */
+	childrel->baserestrictinfo = childquals;
+	childrel->baserestrict_min_security = cq_min_security;
+
+	if (have_const_false_cq)
+	{
+		/*
+		 * Some restriction clause reduced to constant FALSE or NULL after
+		 * substitution, so this child need not be scanned.
+		 */
+		set_dummy_rel_pathlist(childrel);
+	}
+
+	return childrel;
+}
+
+/*
+ * add_rowmark_junk_columns
+ * 		Add necessary junk columns for rowmarked inheritance parent rel.
+ *
+ * These values are needed for locking of rels selected FOR UPDATE/SHARE, and
+ * to do EvalPlanQual rechecking.  See comments for PlanRowMark in
+ * plannodes.h.
+ */
+static List *
+add_rowmark_junk_columns(PlannerInfo *root, PlanRowMark *rc)
+{
+	List   *tlist = root->processed_tlist;
+	Var		   *var;
+	char		resname[32];
+	TargetEntry *tle;
+
+	if (rc->allMarkTypes & ~(1 << ROW_MARK_COPY))
+	{
+		/* Need to fetch TID */
+		var = makeVar(rc->rti,
+					  SelfItemPointerAttributeNumber,
+					  TIDOID,
+					  -1,
+					  InvalidOid,
+					  0);
+		snprintf(resname, sizeof(resname), "ctid%u", rc->rowmarkId);
+		tle = makeTargetEntry((Expr *) var,
+							  list_length(tlist) + 1,
+							  pstrdup(resname),
+							  true);
+		tlist = lappend(tlist, tle);
+	}
+	if (rc->allMarkTypes & (1 << ROW_MARK_COPY))
+	{
+		/* Need the whole row as a junk var */
+		var = makeWholeRowVar(root->simple_rte_array[rc->rti],
+							  rc->rti,
+							  0,
+							  false);
+		snprintf(resname, sizeof(resname), "wholerow%u", rc->rowmarkId);
+		tle = makeTargetEntry((Expr *) var,
+							  list_length(tlist) + 1,
+							  pstrdup(resname),
+							  true);
+		tlist = lappend(tlist, tle);
+	}
+
+	/* For inheritance cases, always fetch the tableoid too. */
+	var = makeVar(rc->rti,
+				  TableOidAttributeNumber,
+				  OIDOID,
+				  -1,
+				  InvalidOid,
+				  0);
+	snprintf(resname, sizeof(resname), "tableoid%u", rc->rowmarkId);
+	tle = makeTargetEntry((Expr *) var,
+						  list_length(tlist) + 1,
+						  pstrdup(resname),
+						  true);
+	tlist = lappend(tlist, tle);
+
+	return tlist;
+}
+
+AppendRelInfo *
+make_append_rel_info(RelOptInfo *parentrel, RangeTblEntry *parentrte,
+					 TupleDesc childdesc, Oid childoid, Oid childreltype,
+					 Index childRTindex)
+{
+	AppendRelInfo  *appinfo = makeNode(AppendRelInfo);
+
+	appinfo->parent_relid = parentrel->relid;
+	appinfo->child_relid = childRTindex;
+	appinfo->parent_reltype = parentrel->reltype;
+	appinfo->child_reltype = childreltype;
+	make_inh_translation_list(parentrel->tupdesc, childdesc,
+							  parentrte->relid, childoid,
+							  childRTindex,
+							  &appinfo->translated_vars);
+	appinfo->parent_reloid = parentrte->relid;
+
+	return appinfo;
+}
+
+/*
  * adjust_appendrel_attrs
  *	  Copy the specified query or expression and translate Vars referring to a
  *	  parent rel to refer to the corresponding child rel instead.  We also
diff --git a/src/backend/optimizer/util/Makefile b/src/backend/optimizer/util/Makefile
index c54d0a690d..da9ccf32b4 100644
--- a/src/backend/optimizer/util/Makefile
+++ b/src/backend/optimizer/util/Makefile
@@ -13,6 +13,6 @@ top_builddir = ../../../..
 include $(top_builddir)/src/Makefile.global
 
 OBJS = clauses.o joininfo.o orclauses.o pathnode.o placeholder.o \
-       plancat.o predtest.o relnode.o restrictinfo.o tlist.o var.o
+	   plancat.o predtest.o relnode.o restrictinfo.o tlist.o var.o
 
 include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/optimizer/util/plancat.c b/src/backend/optimizer/util/plancat.c
index ed0953f9e1..92805046c8 100644
--- a/src/backend/optimizer/util/plancat.c
+++ b/src/backend/optimizer/util/plancat.c
@@ -106,7 +106,7 @@ static void set_baserel_partition_key_exprs(Relation relation,
  */
 void
 get_relation_info(PlannerInfo *root, Oid relationObjectId, bool inhparent,
-				  RelOptInfo *rel)
+				  Bitmapset *updatedCols, RelOptInfo *rel)
 {
 	Index		varno = rel->relid;
 	Relation	relation;
@@ -444,11 +444,31 @@ get_relation_info(PlannerInfo *root, Oid relationObjectId, bool inhparent,
 	get_relation_foreign_keys(root, rel, relation, inhparent);
 
 	/*
-	 * Collect info about relation's partitioning scheme, if any. Only
-	 * inheritance parents may be partitioned.
+	 * Collect some additional information for inheritance parents.
 	 */
-	if (inhparent && relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
-		set_relation_partition_info(root, rel, relation);
+	if (inhparent)
+	{
+		/*
+		 * We'll need the TupleDesc when initializing the child relation.
+		 * A copy is being made because concurrent changes might drop
+		 * the relcache entry.  That's possible because ALTER TABLE
+		 * child_table NO INHERIT parent_table only requires an
+		 * AccessShareLock on parent_table.
+		 */
+		rel->tupdesc = CreateTupleDescCopy(RelationGetDescr(relation));
+		rel->reltype = RelationGetForm(relation)->reltype;
+
+		/*
+		 * If partitioned, also save the information of partitioning scheme,
+		 * and whether the query updates any of the partition key columns.
+		 */
+		if (relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
+		{
+			set_relation_partition_info(root, rel, relation);
+			root->partColsUpdated |= has_partition_attrs(relation, updatedCols,
+														 NULL);
+		}
+	}
 
 	heap_close(relation, NoLock);
 
@@ -1854,16 +1874,20 @@ set_relation_partition_info(PlannerInfo *root, RelOptInfo *rel,
 							Relation relation)
 {
 	PartitionDesc partdesc;
-	PartitionKey partkey;
 
 	Assert(relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE);
 
 	partdesc = RelationGetPartitionDesc(relation);
-	partkey = RelationGetPartitionKey(relation);
 	rel->part_scheme = find_partition_scheme(root, relation);
 	Assert(partdesc != NULL && rel->part_scheme != NULL);
-	rel->boundinfo = partition_bounds_copy(partdesc->boundinfo, partkey);
 	rel->nparts = partdesc->nparts;
+
+	/*
+	 * Since we must've taken a lock on the table, it's okay to simply copy
+	 * the pointers to relcache data here.
+	 */
+	rel->part_oids = partdesc->oids;
+	rel->boundinfo = partdesc->boundinfo;
 	set_baserel_partition_key_exprs(relation, rel);
 	rel->partition_qual = RelationGetPartitionQual(relation);
 }
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index 29ba19349f..c23db9d78d 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -130,6 +130,37 @@ setup_append_rel_array(PlannerInfo *root)
 	}
 }
 
+/* Expand the PlannerInfo arrays by add_size members and zero-init it. */
+void
+expand_planner_arrays(PlannerInfo *root, int add_size)
+{
+	int		new_size = root->simple_rel_array_size + add_size;
+
+	root->simple_rte_array = (RangeTblEntry **)
+							repalloc(root->simple_rte_array,
+									 sizeof(RangeTblEntry *) * new_size);
+	root->simple_rel_array = (RelOptInfo **)
+								repalloc(root->simple_rel_array,
+										 sizeof(RelOptInfo *) * new_size);
+	if (root->append_rel_array)
+		root->append_rel_array = (AppendRelInfo **)
+									repalloc(root->append_rel_array,
+									 sizeof(AppendRelInfo *) * new_size);
+	else
+		root->append_rel_array = (AppendRelInfo **)
+									palloc0(sizeof(AppendRelInfo *) *
+											new_size);
+
+	/* Set the contents of just allocated memory to 0. */
+	MemSet(root->simple_rte_array + root->simple_rel_array_size,
+		   0, sizeof(RangeTblEntry *) * add_size);
+	MemSet(root->simple_rel_array + root->simple_rel_array_size,
+		   0, sizeof(RelOptInfo *) * add_size);
+	MemSet(root->append_rel_array + root->simple_rel_array_size,
+		   0, sizeof(AppendRelInfo *) * add_size);
+	root->simple_rel_array_size = new_size;
+}
+
 /*
  * build_simple_rel
  *	  Construct a new RelOptInfo for a base relation or 'other' relation.
@@ -238,7 +269,8 @@ build_simple_rel(PlannerInfo *root, int relid, RelOptInfo *parent)
 	{
 		case RTE_RELATION:
 			/* Table --- retrieve statistics from the system catalogs */
-			get_relation_info(root, rte->relid, rte->inh, rel);
+			get_relation_info(root, rte->relid, rte->inh, rte->updatedCols,
+							  rel);
 			break;
 		case RTE_SUBQUERY:
 		case RTE_FUNCTION:
@@ -279,52 +311,6 @@ build_simple_rel(PlannerInfo *root, int relid, RelOptInfo *parent)
 		root->qual_security_level = Max(root->qual_security_level,
 										list_length(rte->securityQuals));
 
-	/*
-	 * If this rel is an appendrel parent, recurse to build "other rel"
-	 * RelOptInfos for its children.  They are "other rels" because they are
-	 * not in the main join tree, but we will need RelOptInfos to plan access
-	 * to them.
-	 */
-	if (rte->inh)
-	{
-		ListCell   *l;
-		int			nparts = rel->nparts;
-		int			cnt_parts = 0;
-
-		if (nparts > 0)
-			rel->part_rels = (RelOptInfo **)
-				palloc(sizeof(RelOptInfo *) * nparts);
-
-		foreach(l, root->append_rel_list)
-		{
-			AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(l);
-			RelOptInfo *childrel;
-
-			/* append_rel_list contains all append rels; ignore others */
-			if (appinfo->parent_relid != relid)
-				continue;
-
-			childrel = build_simple_rel(root, appinfo->child_relid,
-										rel);
-
-			/* Nothing more to do for an unpartitioned table. */
-			if (!rel->part_scheme)
-				continue;
-
-			/*
-			 * The order of partition OIDs in append_rel_list is the same as
-			 * the order in the PartitionDesc, so the order of part_rels will
-			 * also match the PartitionDesc.  See expand_partitioned_rtentry.
-			 */
-			Assert(cnt_parts < nparts);
-			rel->part_rels[cnt_parts] = childrel;
-			cnt_parts++;
-		}
-
-		/* We should have seen all the child partitions. */
-		Assert(cnt_parts == nparts);
-	}
-
 	return rel;
 }
 
diff --git a/src/backend/partitioning/partprune.c b/src/backend/partitioning/partprune.c
index 35c87535d3..fcf8d6032c 100644
--- a/src/backend/partitioning/partprune.c
+++ b/src/backend/partitioning/partprune.c
@@ -45,6 +45,7 @@
 #include "nodes/makefuncs.h"
 #include "nodes/nodeFuncs.h"
 #include "optimizer/clauses.h"
+#include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
 #include "optimizer/planner.h"
 #include "optimizer/predtest.h"
@@ -436,17 +437,23 @@ make_partitionedrel_pruneinfo(PlannerInfo *root, RelOptInfo *parentrel,
 		 * is, not pruned already).
 		 */
 		subplan_map = (int *) palloc(nparts * sizeof(int));
+		memset(subplan_map, -1, nparts * sizeof(int));
 		subpart_map = (int *) palloc(nparts * sizeof(int));
+		memset(subpart_map, -1, nparts * sizeof(int));
 		present_parts = NULL;
 
 		for (i = 0; i < nparts; i++)
 		{
 			RelOptInfo *partrel = subpart->part_rels[i];
-			int			subplanidx = relid_subplan_map[partrel->relid] - 1;
-			int			subpartidx = relid_subpart_map[partrel->relid] - 1;
+			int			subplanidx;
+			int			subpartidx;
 
-			subplan_map[i] = subplanidx;
-			subpart_map[i] = subpartidx;
+			/* Skip processing pruned partitions. */
+			if (partrel == NULL)
+				continue;
+
+			subplan_map[i] = subplanidx = relid_subplan_map[partrel->relid] - 1;
+			subpart_map[i] = subpartidx = relid_subpart_map[partrel->relid] - 1;
 			if (subplanidx >= 0)
 			{
 				present_parts = bms_add_member(present_parts, i);
@@ -540,23 +547,20 @@ gen_partprune_steps(RelOptInfo *rel, List *clauses, bool *contradictory)
 
 /*
  * prune_append_rel_partitions
- *		Returns RT indexes of the minimum set of child partitions which must
- *		be scanned to satisfy rel's baserestrictinfo quals.
+ *		Returns indexes into rel->part_rels of the minimum set of child
+ *		partitions which must be scanned to satisfy rel's baserestrictinfo
+ *		quals.
  *
  * Callers must ensure that 'rel' is a partitioned table.
  */
-Relids
+Bitmapset *
 prune_append_rel_partitions(RelOptInfo *rel)
 {
-	Relids		result;
 	List	   *clauses = rel->baserestrictinfo;
 	List	   *pruning_steps;
 	bool		contradictory;
 	PartitionPruneContext context;
-	Bitmapset  *partindexes;
-	int			i;
 
-	Assert(clauses != NIL);
 	Assert(rel->part_scheme != NULL);
 
 	/* If there are no partitions, return the empty set */
@@ -564,6 +568,13 @@ prune_append_rel_partitions(RelOptInfo *rel)
 		return NULL;
 
 	/*
+	 * If pruning is disabled or if there are no clauses to prune with,
+	 * return all partitions.
+	 */
+	if (!enable_partition_pruning || clauses == NIL)
+		return bms_add_range(NULL, 0, rel->nparts - 1);
+
+	/*
 	 * Process clauses.  If the clauses are found to be contradictory, we can
 	 * return the empty set.
 	 */
@@ -590,15 +601,7 @@ prune_append_rel_partitions(RelOptInfo *rel)
 	context.evalexecparams = false;
 
 	/* Actual pruning happens here. */
-	partindexes = get_matching_partitions(&context, pruning_steps);
-
-	/* Add selected partitions' RT indexes to result. */
-	i = -1;
-	result = NULL;
-	while ((i = bms_next_member(partindexes, i)) >= 0)
-		result = bms_add_member(result, rel->part_rels[i]->relid);
-
-	return result;
+	return get_matching_partitions(&context, pruning_steps);
 }
 
 /*
diff --git a/src/include/nodes/relation.h b/src/include/nodes/relation.h
index 94f14019bd..e6fdbcd030 100644
--- a/src/include/nodes/relation.h
+++ b/src/include/nodes/relation.h
@@ -15,6 +15,7 @@
 #define RELATION_H
 
 #include "access/sdir.h"
+#include "access/tupdesc.h"
 #include "fmgr.h"
 #include "lib/stringinfo.h"
 #include "nodes/params.h"
@@ -723,6 +724,7 @@ typedef struct RelOptInfo
 	int			nparts;			/* number of partitions */
 	struct PartitionBoundInfoData *boundinfo;	/* Partition bounds */
 	List	   *partition_qual; /* partition constraint */
+	Oid		   *part_oids;		/* partition OIDs */
 	struct RelOptInfo **part_rels;	/* Array of RelOptInfos of partitions,
 									 * stored in the same order of bounds */
 	List	  **partexprs;		/* Non-nullable partition key expressions. */
@@ -732,6 +734,12 @@ typedef struct RelOptInfo
 	Index		inh_root_parent;	/* For otherrels, this is the RT index of
 									 * inheritance table mentioned in the query
 									 * from which this relation originated */
+	/*
+	 * Set only if this is an inheritance parent relation.  This information
+	 * is needed when initializing the planning info for children.
+	 */
+	TupleDesc	tupdesc;		/* A "copy" of the table's tuple desriptor */
+	Oid			reltype;		/* Table's reltype */
 } RelOptInfo;
 
 /*
diff --git a/src/include/optimizer/pathnode.h b/src/include/optimizer/pathnode.h
index 81abcf53a8..b1baa3117a 100644
--- a/src/include/optimizer/pathnode.h
+++ b/src/include/optimizer/pathnode.h
@@ -261,6 +261,7 @@ extern Path *reparameterize_path_by_child(PlannerInfo *root, Path *path,
  */
 extern void setup_simple_rel_arrays(PlannerInfo *root);
 extern void setup_append_rel_array(PlannerInfo *root);
+extern void expand_planner_arrays(PlannerInfo *root, int add_size);
 extern RelOptInfo *build_simple_rel(PlannerInfo *root, int relid,
 				 RelOptInfo *parent);
 extern RelOptInfo *find_base_rel(PlannerInfo *root, int relid);
diff --git a/src/include/optimizer/plancat.h b/src/include/optimizer/plancat.h
index 7d53cbbb87..edaf2a3b4f 100644
--- a/src/include/optimizer/plancat.h
+++ b/src/include/optimizer/plancat.h
@@ -26,7 +26,7 @@ extern PGDLLIMPORT get_relation_info_hook_type get_relation_info_hook;
 
 
 extern void get_relation_info(PlannerInfo *root, Oid relationObjectId,
-				  bool inhparent, RelOptInfo *rel);
+				  bool inhparent, Bitmapset *updatedCols, RelOptInfo *rel);
 
 extern List *infer_arbiter_indexes(PlannerInfo *root);
 
diff --git a/src/include/optimizer/prep.h b/src/include/optimizer/prep.h
index 38608770a2..faae07d240 100644
--- a/src/include/optimizer/prep.h
+++ b/src/include/optimizer/prep.h
@@ -38,7 +38,8 @@ extern Expr *canonicalize_qual(Expr *qual, bool is_check);
 /*
  * prototypes for preptlist.c
  */
-extern List *preprocess_targetlist(PlannerInfo *root);
+extern List *preprocess_targetlist(PlannerInfo *root,
+							bool inheritance_expanded);
 
 extern PlanRowMark *get_plan_rowmark(List *rowmarks, Index rtindex);
 
@@ -51,7 +52,10 @@ extern void expand_inherited_tables(PlannerInfo *root);
 
 extern Node *adjust_appendrel_attrs(PlannerInfo *root, Node *node,
 					   int nappinfos, AppendRelInfo **appinfos);
-
+extern AppendRelInfo *make_append_rel_info(RelOptInfo *parentrel,
+					 RangeTblEntry *parentrte,
+					 TupleDesc childdesc, Oid childoid, Oid childreltype,
+					 Index childRTindex);
 extern Node *adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node,
 								  Relids child_relids,
 								  Relids top_parent_relids);
@@ -64,5 +68,4 @@ extern SpecialJoinInfo *build_child_join_sjinfo(PlannerInfo *root,
 						Relids left_relids, Relids right_relids);
 extern Relids adjust_child_relids_multilevel(PlannerInfo *root, Relids relids,
 							   Relids child_relids, Relids top_parent_relids);
-
 #endif							/* PREP_H */
diff --git a/src/include/partitioning/partprune.h b/src/include/partitioning/partprune.h
index e07aaaf798..ac0a979010 100644
--- a/src/include/partitioning/partprune.h
+++ b/src/include/partitioning/partprune.h
@@ -76,7 +76,7 @@ extern PartitionPruneInfo *make_partition_pruneinfo(PlannerInfo *root,
 						 List *subpaths,
 						 List *partitioned_rels,
 						 List *prunequal);
-extern Relids prune_append_rel_partitions(RelOptInfo *rel);
+extern Bitmapset *prune_append_rel_partitions(RelOptInfo *rel);
 extern Bitmapset *get_matching_partitions(PartitionPruneContext *context,
 						List *pruning_steps);
 
diff --git a/src/test/regress/expected/partition_aggregate.out b/src/test/regress/expected/partition_aggregate.out
index 6bc106831e..1450cef057 100644
--- a/src/test/regress/expected/partition_aggregate.out
+++ b/src/test/regress/expected/partition_aggregate.out
@@ -144,7 +144,7 @@ SELECT c, sum(a) FROM pagg_tab WHERE 1 = 2 GROUP BY c;
            QUERY PLAN           
 --------------------------------
  HashAggregate
-   Group Key: pagg_tab.c
+   Group Key: c
    ->  Result
          One-Time Filter: false
 (4 rows)
@@ -159,7 +159,7 @@ SELECT c, sum(a) FROM pagg_tab WHERE c = 'x' GROUP BY c;
            QUERY PLAN           
 --------------------------------
  GroupAggregate
-   Group Key: pagg_tab.c
+   Group Key: c
    ->  Result
          One-Time Filter: false
 (4 rows)
-- 
2.11.0

From d61e59a0f7f059f1dad6a730b4c30a383d13c877 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Wed, 7 Nov 2018 16:51:31 +0900
Subject: [PATCH v6 4/6] Move append expansion code into its own file

This commit moves expand_append_rel and underlings currently in
optimizer/prep/prepunionc.c to optimizer/utils/append.c.

All of the AppendRelInfo based expression manipulation routines
are moved to optimizer/utils/appendinfo.c.

This commit only moves the code and contains no functional changes.
---
 src/backend/optimizer/path/allpaths.c   |    2 +
 src/backend/optimizer/path/equivclass.c |    1 +
 src/backend/optimizer/path/joinrels.c   |    1 +
 src/backend/optimizer/plan/planner.c    |    1 +
 src/backend/optimizer/prep/prepunion.c  | 1574 -------------------------------
 src/backend/optimizer/util/Makefile     |    5 +-
 src/backend/optimizer/util/append.c     |  777 +++++++++++++++
 src/backend/optimizer/util/appendinfo.c |  851 +++++++++++++++++
 src/backend/optimizer/util/pathnode.c   |    1 +
 src/backend/optimizer/util/relnode.c    |    1 +
 src/backend/partitioning/partprune.c    |    1 +
 src/include/optimizer/append.h          |   25 +
 src/include/optimizer/appendinfo.h      |   43 +
 src/include/optimizer/prep.h            |   19 -
 14 files changed, 1707 insertions(+), 1595 deletions(-)
 create mode 100644 src/backend/optimizer/util/append.c
 create mode 100644 src/backend/optimizer/util/appendinfo.c
 create mode 100644 src/include/optimizer/append.h
 create mode 100644 src/include/optimizer/appendinfo.h

diff --git a/src/backend/optimizer/path/allpaths.c b/src/backend/optimizer/path/allpaths.c
index a4dd34f2cd..d93883ed42 100644
--- a/src/backend/optimizer/path/allpaths.c
+++ b/src/backend/optimizer/path/allpaths.c
@@ -30,6 +30,8 @@
 #ifdef OPTIMIZER_DEBUG
 #include "nodes/print.h"
 #endif
+#include "optimizer/append.h"
+#include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/geqo.h"
diff --git a/src/backend/optimizer/path/equivclass.c b/src/backend/optimizer/path/equivclass.c
index b22b36ec0e..5ace28eab0 100644
--- a/src/backend/optimizer/path/equivclass.c
+++ b/src/backend/optimizer/path/equivclass.c
@@ -22,6 +22,7 @@
 #include "catalog/pg_type.h"
 #include "nodes/makefuncs.h"
 #include "nodes/nodeFuncs.h"
+#include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
 #include "optimizer/pathnode.h"
 #include "optimizer/paths.h"
diff --git a/src/backend/optimizer/path/joinrels.c b/src/backend/optimizer/path/joinrels.c
index da0831de4e..6e321ec9e7 100644
--- a/src/backend/optimizer/path/joinrels.c
+++ b/src/backend/optimizer/path/joinrels.c
@@ -15,6 +15,7 @@
 #include "postgres.h"
 
 #include "miscadmin.h"
+#include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
 #include "optimizer/joininfo.h"
 #include "optimizer/pathnode.h"
diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index 5801ea0854..a222bd8f1b 100644
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -39,6 +39,7 @@
 #include "nodes/print.h"
 #endif
 #include "nodes/relation.h"
+#include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
diff --git a/src/backend/optimizer/prep/prepunion.c b/src/backend/optimizer/prep/prepunion.c
index e4d4e7d6dd..70f37c593f 100644
--- a/src/backend/optimizer/prep/prepunion.c
+++ b/src/backend/optimizer/prep/prepunion.c
@@ -12,11 +12,6 @@
  * case, but most of the heavy lifting for that is done elsewhere,
  * notably in prepjointree.c and allpaths.c.
  *
- * There is also some code here to support planning of queries that use
- * inheritance (SELECT FROM foo*).  Inheritance trees are converted into
- * append relations, and thenceforth share code with the UNION ALL case.
- *
- *
  * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
@@ -39,32 +34,21 @@
 #include "miscadmin.h"
 #include "nodes/makefuncs.h"
 #include "nodes/nodeFuncs.h"
-#include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
 #include "optimizer/paths.h"
 #include "optimizer/planmain.h"
 #include "optimizer/planner.h"
 #include "optimizer/prep.h"
-#include "optimizer/restrictinfo.h"
 #include "optimizer/tlist.h"
-#include "optimizer/var.h"
 #include "parser/parse_coerce.h"
 #include "parser/parsetree.h"
-#include "partitioning/partprune.h"
 #include "utils/lsyscache.h"
 #include "utils/rel.h"
 #include "utils/selfuncs.h"
 #include "utils/syscache.h"
 
 
-typedef struct
-{
-	PlannerInfo *root;
-	int			nappinfos;
-	AppendRelInfo **appinfos;
-} adjust_appendrel_attrs_context;
-
 static RelOptInfo *recurse_set_operations(Node *setOp, PlannerInfo *root,
 					   List *colTypes, List *colCollations,
 					   bool junkOK,
@@ -103,34 +87,6 @@ static List *generate_append_tlist(List *colTypes, List *colCollations,
 					  List *input_tlists,
 					  List *refnames_tlist);
 static List *generate_setop_grouplist(SetOperationStmt *op, List *targetlist);
-static void expand_append_rtentry(PlannerInfo *root, RelOptInfo *rel,
-					  RangeTblEntry *rte, Index rti);
-static void expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte,
-						 Index rti, RelOptInfo *rel);
-static void expand_partitioned_rtentry(PlannerInfo *root,
-						   RangeTblEntry *parentrte,
-						   Index parentRTindex, RelOptInfo *parentrel);
-static RelOptInfo *add_inheritance_child_rel(PlannerInfo *root,
-						  RangeTblEntry *parentrte,
-						  Index parentRTindex, RelOptInfo *parentrel,
-						  PlanRowMark *top_parentrc, Relation childrel,
-						  RangeTblEntry **childrte_p, Index *childRTindex_p);
-static void make_inh_translation_list(TupleDesc old_tupdesc,
-						  TupleDesc new_tupdesc,
-						  Oid from_rel, Oid to_rel,
-						  Index newvarno, List **translated_vars);
-static RelOptInfo *build_append_child_rel(PlannerInfo *root,
-					   RelOptInfo *parent,
-					   Index childRTindex);
-static List *add_rowmark_junk_columns(PlannerInfo *root, PlanRowMark *rc);
-static Bitmapset *translate_col_privs(const Bitmapset *parent_privs,
-					List *translated_vars);
-static Node *adjust_appendrel_attrs_mutator(Node *node,
-							   adjust_appendrel_attrs_context *context);
-static Relids adjust_child_relids(Relids relids, int nappinfos,
-					AppendRelInfo **appinfos);
-static List *adjust_inherited_tlist(List *tlist,
-					   AppendRelInfo *context);
 
 
 /*
@@ -1467,1533 +1423,3 @@ generate_setop_grouplist(SetOperationStmt *op, List *targetlist)
 	Assert(lg == NULL);
 	return grouplist;
 }
-
-
-/*
- * expand_inherited_tables
- *		Expand each rangetable entry that represents an inheritance set
- *		into an "append relation".  At the conclusion of this process,
- *		the "inh" flag is set in all and only those RTEs that are append
- *		relation parents.
- */
-void
-expand_inherited_tables(PlannerInfo *root)
-{
-	int			orig_rtable_size;
-	Index		rti;
-
-	Assert(root->simple_rel_array_size > 0);
-	orig_rtable_size = root->simple_rel_array_size;
-
-	/*
-	 * expand_append_rtentry may add RTEs to parse->rtable. The function is
-	 * expected to recursively handle any RTEs that it creates with inh=true.
-	 * So just scan as far as the original end of the rtable list.
-	 */
-	for (rti = 1; rti < orig_rtable_size; rti++)
-	{
-		RelOptInfo *brel = root->simple_rel_array[rti];
-		RangeTblEntry *rte = root->simple_rte_array[rti];
-
-		/* there may be empty slots corresponding to non-baserel RTEs */
-		if (brel == NULL)
-			continue;
-
-		if (rte->inh)
-			expand_append_rtentry(root, brel, rte, rti);
-	}
-}
-
-/*
- * expand_append_rtentry
- *		This initializes RelOptInfos for an appendrel's child relations, if
- *		any
- *
- * 'rel' is the appendrel parent, whose range table entry ('rte') has been
- * marked to require adding children.  An appendrel parent could either
- * be a subquery (if we flattened UNION ALL query) or a table that's known
- * to have inheritance children.  The latter consists of both regular
- * inheritance parents and partitioned tables.
- *
- * For a subquery parent, there is not much to be done here because the
- * children's RTEs are already present in the query, so we just initialize
- * RelOptInfos for them.  Also, the AppendRelInfos for child subqueries
- * have already been added.
- *
- * For tables, we need to add the children to the range table and initialize
- * AppendRelInfos, RelOptInfos, and PlanRowMarks (if any) for them.  For
- * a partitioned parent, we only add the children remaining after pruning.
- * For regular inheritance parents, we find the children using
- * find_all_inheritors and add all of them.
- *
- * If it turns out that there are no children, then we set rte->inh to false
- * to let the caller know that only the parent table needs to be scanned.  The
- * caller can accordingly switch to a non-Append path.  For a partitioned
- * parent, that means an empty relation because parents themselves contain no
- * data.
- *
- * For the regular inheritance case, the parent also gets another RTE with
- * inh = false to represent it as an appendrel child.  The original RTE is
- * considered to represent the whole inheritance set.
- */
-static void
-expand_append_rtentry(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte,
-					  Index rti)
-{
-	Assert(rte->inh);
-	/* Inheritance parent (partitioned or not) or UNION ALL parent subquery. */
-	Assert(rte->rtekind == RTE_RELATION || rte->rtekind == RTE_SUBQUERY);
-
-	/*
-	 * UNION ALL children already got RTEs and AppendRelInfos, so just build
-	 * RelOptInfos and return.
-	 *
-	 * It might be a bit odd that this code is in this, because there is
-	 * nothing to expand really.
-	 */
-	if (rte->rtekind == RTE_SUBQUERY)
-	{
-		ListCell   *l;
-
-		/*
-		 * We don't need to use expand_planner_arrays in this case, because
-		 * no new child RTEs are created.  setup_simple_rel_arrays() and
-		 * setup_append_rel_array would've considered these child RTEs when
-		 * allocating space for various arrays.
-		 */
-		foreach(l, root->append_rel_list)
-		{
-			AppendRelInfo *appinfo = lfirst(l);
-			Index		childRTindex = appinfo->child_relid;
-
-			if (appinfo->parent_relid != rti)
-				continue;
-
-			Assert(childRTindex < root->simple_rel_array_size);
-			Assert(root->simple_rte_array[childRTindex] != NULL);
-
-			/*
-			 * We set the correct value of baserestricinfo and
-			 * baserestrict_min_security below.
-			 */
-			root->simple_rel_array[childRTindex] =
-				build_append_child_rel(root, rel, appinfo->child_relid);
-		}
-	}
-	else
-	{
-		Assert(rte->rtekind == RTE_RELATION);
-		Assert(has_subclass(rte->relid));
-
-		/*
-		 * The rewriter should already have obtained an appropriate lock on
-		 * each relation named in the query.  However, for each child relation
-		 * we add to the query, we must obtain an appropriate lock, because
-		 * this will be the first use of those relations in the
-		 * parse/rewrite/plan pipeline.  Child rels should use the same
-		 * lockmode as their parent.
-		 */
-		Assert(rte->rellockmode != NoLock);
-
-		if (rte->relkind == RELKIND_PARTITIONED_TABLE)
-			expand_partitioned_rtentry(root, rte, rti, rel);
-		else
-			expand_inherited_rtentry(root, rte, rti, rel);
-	}
-}
-
-/*
- * expand_inherited_rtentry
- *		Add entries for all the child tables to the query's rangetable, and
- *		build AppendRelInfo nodes for all the child tables and add them to
- *		root->append_rel_list.
- *
- * Note that the original RTE is considered to represent the whole
- * inheritance set.  The first of the generated RTEs is an RTE for the same
- * table, but with inh = false, to represent the parent table in its role
- * as a simple member of the inheritance set.
- *
- * A childless table is never considered to be an inheritance set. For
- * regular inheritance, a parent RTE must always have at least two associated
- * AppendRelInfos: one corresponding to the parent table as a simple member of
- * inheritance set and one or more corresponding to the actual children.
- */
-static void
-expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti,
-						 RelOptInfo *rel)
-{
-	Oid			parentOID;
-	PlanRowMark *oldrc;
-	LOCKMODE	lockmode = rte->rellockmode;
-	List	   *inhOIDs;
-	ListCell   *l;
-	int			num_children;
-	int			num_children_added = 0;
-
-	Assert(rte->rtekind == RTE_RELATION);
-	Assert(lockmode != NoLock);
-	parentOID = rte->relid;
-
-	/* Scan for all members of inheritance set, acquire needed locks */
-	inhOIDs = find_all_inheritors(parentOID, lockmode, NULL);
-
-	/*
-	 * Check that there's at least one descendant, else treat as no-child
-	 * case.  This could happen despite above has_subclass() check, if table
-	 * once had a child but no longer does.
-	 */
-	num_children = list_length(inhOIDs);
-	if (num_children < 2)
-	{
-		/* Clear flag before returning */
-		rte->inh = false;
-		return;
-	}
-
-	/*
-	 * If parent relation is selected FOR UPDATE/SHARE, preprocess_rowmarks
-	 * should've set isParent = true.  We'll generate a new PlanRowMark for
-	 * each child.
-	 */
-	oldrc = get_plan_rowmark(root->rowMarks, rti);
-	Assert(oldrc == NULL || oldrc->isParent);
-
-	/*
-	 * Must expand PlannerInfo arrays by num_children before we can add
-	 * children.
-	 */
-	expand_planner_arrays(root, num_children);
-
-	foreach(l, inhOIDs)
-	{
-		Oid			childOID = lfirst_oid(l);
-		Relation	newrelation;
-		RangeTblEntry *childrte;
-		Index		childRTindex;
-
-		/* Already locked above. */
-		newrelation = heap_open(childOID, NoLock);
-
-		/*
-		 * It is possible that the parent table has children that are temp
-		 * tables of other backends.  We cannot safely access such tables
-		 * (because of buffering issues), and the best thing to do seems
-		 * to be to silently ignore them.
-		 */
-		if (RELATION_IS_OTHER_TEMP(newrelation))
-		{
-			heap_close(newrelation, lockmode);
-			continue;
-		}
-
-		(void) add_inheritance_child_rel(root, rte, rti, rel, oldrc,
-										 newrelation, &childrte,
-										 &childRTindex);
-		Assert(childrte != NULL);
-		/* All regular inheritance children are leaf children. */
-		Assert(!childrte->inh);
-		Assert(childRTindex > 0);
-
-		/* Close child relations, but keep locks */
-		heap_close(newrelation, NoLock);
-		num_children_added++;
-	}
-
-	/*
-	 * If all children, including the parent (as child rel), were
-	 * excluded, mark the parent rel as empty.  If all the children were temp
-	 * tables, pretend it's a non-inheritance situation; we don't need Append
-	 * node in that case.  The duplicate RTE we added for the parent table is
-	 * harmless, so we don't bother to get rid of it; ditto for the useless
-	 * PlanRowMark node.
-	 */
-	if (num_children_added == 0)
-		mark_dummy_rel(rel);
-	else if (num_children_added == 1)
-		rte->inh = false;
-
-	/*
-	 * Add junk columns needed by the row mark if any and also add the
-	 * relevant expressions to the root parent's reltarget.
-	 */
-	if (oldrc)
-	{
-		List   *tlist = add_rowmark_junk_columns(root, oldrc);
-
-		build_base_rel_tlists(root, tlist);
-	}
-}
-
-/*
- * expand_partitioned_rtentry
- *		Prunes unnecessary partitions of a partitioned table and adds
- *		remaining ones to the Query and the PlannerInfo
- *
- * Partitions are added to the query in order in which they are found in
- * the parent's PartitionDesc.
- *
- * Note: even though only the unpruned partitions will be added to the
- * resulting plan, this still locks *all* partitions via find_all_inheritors
- * in order to avoid partitions being locked in a different order than other
- * places in the backend that may lock partitions.
- */
-static void
-expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
-						   Index parentRTindex, RelOptInfo *parentrel)
-{
-	LOCKMODE	lockmode = parentrte->rellockmode;
-	PlanRowMark *rootrc = NULL;
-	int			i;
-	Bitmapset  *partindexes;
-	Index		rootParentRTindex = parentrel->inh_root_parent > 0 ?
-									parentrel->inh_root_parent :
-									parentRTindex;
-
-	/* If root partitioned table, lock *all* partitions in the tree. */
-	if (parentRTindex == rootParentRTindex)
-		(void) find_all_inheritors(parentrte->relid, lockmode, NULL);
-
-	/*
-	 * Initialize partitioned_child_rels to contain this RT index.
-	 *
-	 * Note that during the set_append_rel_pathlist() phase, values of the
-	 * indexes of partitioned relations that appear down in the tree will be
-	 * bubbled up into root parent's list so that when we've created Paths for
-	 * all the children, the root table's list will contain all such indexes.
-	 */
-	parentrel->partitioned_child_rels = list_make1_int(parentRTindex);
-
-	/* Perform pruning. */
-	partindexes = prune_append_rel_partitions(parentrel);
-
-	/* Must expand PlannerInfo arrays before we can add children. */
-	expand_planner_arrays(root, bms_num_members(partindexes));
-
-	/*
-	 * For partitioned tables, we also store the partition RelOptInfo
-	 * pointers in the parent's RelOptInfo.
-	 */
-	parentrel->part_rels = (RelOptInfo **) palloc0(sizeof(RelOptInfo *) *
-												   parentrel->nparts);
-
-	rootrc = get_plan_rowmark(root->rowMarks, rootParentRTindex);
-	Assert(rootrc == NULL || rootrc->isParent);
-	i = -1;
-	while ((i = bms_next_member(partindexes, i)) >= 0)
-	{
-		Oid		childOID = parentrel->part_oids[i];
-		Relation	newrelation;
-		RelOptInfo *childrel;
-		RangeTblEntry *childrte;
-		Index		childRTindex;
-
-		/* Already locked above. */
-		newrelation = heap_open(childOID, NoLock);
-		Assert(!RELATION_IS_OTHER_TEMP(newrelation));
-
-		/*
-		 * A partitioned child table with 0 children is a dummy rel, so don't
-		 * bother creating planner objects for it.
-		 */
-		if (newrelation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE &&
-			RelationGetPartitionDesc(newrelation)->nparts == 0)
-		{
-			heap_close(newrelation, NoLock);
-			continue;
-		}
-
-		childrel = add_inheritance_child_rel(root, parentrte, parentRTindex,
-											 parentrel, rootrc, newrelation,
-											 &childrte, &childRTindex);
-		Assert(childrel != NULL);
-		parentrel->part_rels[i] = childrel;
-
-		/* Close child relations, but keep locks */
-		heap_close(newrelation, NoLock);
-
-		/* If the child is partitioned itself, expand it too. */
-		if (childrel->part_scheme)
-		{
-			Assert(childrte->inh);
-			expand_partitioned_rtentry(root, childrte, childRTindex,
-									   childrel);
-		}
-	}
-
-	/*
-	 * Add junk columns needed by the row mark if any and also add the
-	 * relevant expressions to the root parent's reltarget.
-	 */
-	if (rootrc)
-	{
-		List   *tlist = add_rowmark_junk_columns(root, rootrc);
-
-		build_base_rel_tlists(root, tlist);
-	}
-}
-
-/*
- * add_inheritance_child_rel
- *		Build a RangeTblEntry, an AppendRelInfo, a PlanRowMark, and finally
- *		a RelOptInfo for an inheritance child relation.
- *
- * The return value is the RelOptInfo that's added.
- *
- * PlanRowMarks still carry the top-parent's RTI, and the top-parent's
- * allMarkTypes field still accumulates values from all descendents.
- *
- * "parentrte" and "parentRTindex" are immediate parent's RTE and
- * RTI. "top_parentrc" is top parent's PlanRowMark.
- */
-static RelOptInfo *
-add_inheritance_child_rel(PlannerInfo *root, RangeTblEntry *parentrte,
-						  Index parentRTindex, RelOptInfo *parentrel,
-						  PlanRowMark *top_parentrc, Relation childrel,
-						  RangeTblEntry **childrte_p, Index *childRTindex_p)
-{
-	Query	   *parse = root->parse;
-	Oid			childOID = RelationGetRelid(childrel);
-	RangeTblEntry *childrte;
-	Index		childRTindex;
-	AppendRelInfo *appinfo;
-	RelOptInfo *childrelopt;
-
-	/*
-	 * Build an RTE for the child, and attach to query's rangetable list. We
-	 * copy most fields of the parent's RTE, but replace relation OID and
-	 * relkind, and set inh appropriately.  Also, set requiredPerms to zero
-	 * since all required permissions checks are done on the original RTE.
-	 * Likewise, set the child's securityQuals to empty, because we only want
-	 * to apply the parent's RLS conditions regardless of what RLS properties
-	 * individual children may have.  (This is an intentional choice to make
-	 * inherited RLS work like regular permissions checks.) The parent
-	 * securityQuals will be propagated to children along with other base
-	 * restriction clauses, so we don't need to do it here.
-	 */
-	childrte = copyObject(parentrte);
-	*childrte_p = childrte;
-	childrte->relid = childOID;
-	childrte->relkind = childrel->rd_rel->relkind;
-	/*
-	 * A partitioned child will need to be expanded as an append parent
-	 * itself, so set its inh to true.
-	 */
-	childrte->inh = (childrte->relkind == RELKIND_PARTITIONED_TABLE);
-	childrte->requiredPerms = 0;
-	childrte->securityQuals = NIL;
-	parse->rtable = lappend(parse->rtable, childrte);
-	childRTindex = list_length(parse->rtable);
-	*childRTindex_p = childRTindex;
-
-	/* Create an AppendRelInfo and add it to planner's global list. */
-	appinfo = make_append_rel_info(parentrel, parentrte,
-								   childrel->rd_att,
-								   childOID,
-								   childrel->rd_rel->reltype,
-								   childRTindex);
-	root->append_rel_list = lappend(root->append_rel_list, appinfo);
-
-	/*
-	 * Translate the column permissions bitmaps to the child's attnums (we
-	 * have to build the translated_vars list before we can do this). But
-	 * if this is the parent table, leave copyObject's result alone.
-	 *
-	 * Note: we need to do this even though the executor won't run any
-	 * permissions checks on the child RTE.  The insertedCols/updatedCols
-	 * bitmaps may be examined for trigger-firing purposes.
-	 */
-	if (childrte->relid != parentrte->relid)
-	{
-		childrte->selectedCols = translate_col_privs(parentrte->selectedCols,
-													 appinfo->translated_vars);
-		childrte->insertedCols = translate_col_privs(parentrte->insertedCols,
-													 appinfo->translated_vars);
-		childrte->updatedCols = translate_col_privs(parentrte->updatedCols,
-													appinfo->translated_vars);
-	}
-
-	/*
-	 * Build a PlanRowMark if parent is marked FOR UPDATE/SHARE.
-	 */
-	if (top_parentrc)
-	{
-		PlanRowMark *childrc = makeNode(PlanRowMark);
-
-		childrc->rti = childRTindex;
-		childrc->prti = top_parentrc->rti;
-		childrc->rowmarkId = top_parentrc->rowmarkId;
-		/* Reselect rowmark type, because relkind might not match parent */
-		childrc->markType = select_rowmark_type(childrte,
-												top_parentrc->strength);
-		childrc->allMarkTypes = (1 << childrc->markType);
-		childrc->strength = top_parentrc->strength;
-		childrc->waitPolicy = top_parentrc->waitPolicy;
-
-		/*
-		 * We mark RowMarks for partitioned child tables as parent RowMarks so
-		 * that the executor ignores them (except their existence means that
-		 * the child tables be locked using appropriate mode).
-		 */
-		childrc->isParent = (childrte->relkind == RELKIND_PARTITIONED_TABLE);
-
-		/* Include child's rowmark type in top parent's allMarkTypes */
-		top_parentrc->allMarkTypes |= childrc->allMarkTypes;
-
-		root->rowMarks = lappend(root->rowMarks, childrc);
-	}
-
-	/*
-	 * Add the RelOptInfo.  Even though we may not really scan this relation
-	 * for reasons such as contradictory quals, we still need need to create
-	 * one, because for every RTE in the query's range table, there must be an
-	 * accompanying RelOptInfo.
-	 */
-
-	/* First, store the RTE and appinfos into planner arrays. */
-	Assert(root->simple_rte_array[childRTindex] == NULL);
-	root->simple_rte_array[childRTindex] = childrte;
-	Assert(root->append_rel_array[childRTindex] == NULL);
-	root->append_rel_array[childRTindex] = appinfo;
-
-	childrelopt = build_append_child_rel(root, parentrel, childRTindex);
-	Assert(childrelopt != NULL);
-
-	return childrelopt;
-}
-
-/*
- * make_inh_translation_list
- *	  Build the list of translations from parent Vars to child Vars for
- *	  an inheritance child.
- *
- * For paranoia's sake, we match type/collation as well as attribute name.
- */
-static void
-make_inh_translation_list(TupleDesc old_tupdesc, TupleDesc new_tupdesc,
-						  Oid from_rel, Oid to_rel,
-						  Index newvarno, List **translated_vars)
-{
-	List	   *vars = NIL;
-	int			oldnatts = old_tupdesc->natts;
-	int			newnatts = new_tupdesc->natts;
-	int			old_attno;
-	int			new_attno = 0;
-
-	for (old_attno = 0; old_attno < oldnatts; old_attno++)
-	{
-		Form_pg_attribute att;
-		char	   *attname;
-		Oid			atttypid;
-		int32		atttypmod;
-		Oid			attcollation;
-
-		att = TupleDescAttr(old_tupdesc, old_attno);
-		if (att->attisdropped)
-		{
-			/* Just put NULL into this list entry */
-			vars = lappend(vars, NULL);
-			continue;
-		}
-		attname = NameStr(att->attname);
-		atttypid = att->atttypid;
-		atttypmod = att->atttypmod;
-		attcollation = att->attcollation;
-
-		/*
-		 * When we are generating the "translation list" for the parent table
-		 * of an inheritance set, no need to search for matches.
-		 */
-		if (from_rel == to_rel)
-		{
-			vars = lappend(vars, makeVar(newvarno,
-										 (AttrNumber) (old_attno + 1),
-										 atttypid,
-										 atttypmod,
-										 attcollation,
-										 0));
-			continue;
-		}
-
-		/*
-		 * Otherwise we have to search for the matching column by name.
-		 * There's no guarantee it'll have the same column position, because
-		 * of cases like ALTER TABLE ADD COLUMN and multiple inheritance.
-		 * However, in simple cases, the relative order of columns is mostly
-		 * the same in both relations, so try the column of newrelation that
-		 * follows immediately after the one that we just found, and if that
-		 * fails, let syscache handle it.
-		 */
-		if (new_attno >= newnatts ||
-			(att = TupleDescAttr(new_tupdesc, new_attno))->attisdropped ||
-			strcmp(attname, NameStr(att->attname)) != 0)
-		{
-			HeapTuple	newtup;
-
-			newtup = SearchSysCacheAttName(to_rel, attname);
-			if (!newtup)
-				elog(ERROR, "could not find inherited attribute \"%s\" of relation \"%s\"",
-					 attname, get_rel_name(to_rel));
-			new_attno = ((Form_pg_attribute) GETSTRUCT(newtup))->attnum - 1;
-			ReleaseSysCache(newtup);
-
-			att = TupleDescAttr(new_tupdesc, new_attno);
-		}
-
-		/* Found it, check type and collation match */
-		if (atttypid != att->atttypid || atttypmod != att->atttypmod)
-			elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's type",
-				 attname, get_rel_name(to_rel));
-		if (attcollation != att->attcollation)
-			elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's collation",
-				 attname, get_rel_name(to_rel));
-
-		vars = lappend(vars, makeVar(newvarno,
-									 (AttrNumber) (new_attno + 1),
-									 atttypid,
-									 atttypmod,
-									 attcollation,
-									 0));
-		new_attno++;
-	}
-
-	*translated_vars = vars;
-}
-
-/*
- * translate_col_privs
- *	  Translate a bitmapset representing per-column privileges from the
- *	  parent rel's attribute numbering to the child's.
- *
- * The only surprise here is that we don't translate a parent whole-row
- * reference into a child whole-row reference.  That would mean requiring
- * permissions on all child columns, which is overly strict, since the
- * query is really only going to reference the inherited columns.  Instead
- * we set the per-column bits for all inherited columns.
- */
-static Bitmapset *
-translate_col_privs(const Bitmapset *parent_privs,
-					List *translated_vars)
-{
-	Bitmapset  *child_privs = NULL;
-	bool		whole_row;
-	int			attno;
-	ListCell   *lc;
-
-	/* System attributes have the same numbers in all tables */
-	for (attno = FirstLowInvalidHeapAttributeNumber + 1; attno < 0; attno++)
-	{
-		if (bms_is_member(attno - FirstLowInvalidHeapAttributeNumber,
-						  parent_privs))
-			child_privs = bms_add_member(child_privs,
-										 attno - FirstLowInvalidHeapAttributeNumber);
-	}
-
-	/* Check if parent has whole-row reference */
-	whole_row = bms_is_member(InvalidAttrNumber - FirstLowInvalidHeapAttributeNumber,
-							  parent_privs);
-
-	/* And now translate the regular user attributes, using the vars list */
-	attno = InvalidAttrNumber;
-	foreach(lc, translated_vars)
-	{
-		Var		   *var = lfirst_node(Var, lc);
-
-		attno++;
-		if (var == NULL)		/* ignore dropped columns */
-			continue;
-		if (whole_row ||
-			bms_is_member(attno - FirstLowInvalidHeapAttributeNumber,
-						  parent_privs))
-			child_privs = bms_add_member(child_privs,
-										 var->varattno - FirstLowInvalidHeapAttributeNumber);
-	}
-
-	return child_privs;
-}
-
-/*
- *	build_append_child_rel
- *		Build a RelOptInfo for child relation of an append rel
- *
- * After creating the RelOptInfo for the given child RT index, it goes on to
- * initialize some of its fields base on the parent RelOptInfo.
- *
- * If the quals in baserestrictinfo turns out to be self-contradictory, the
- * RelOptInfo is marked dummy before returning.
- */
-static RelOptInfo *
-build_append_child_rel(PlannerInfo *root,
-					   RelOptInfo *parent,
-					   Index childRTindex)
-{
-	RelOptInfo *childrel;
-	RangeTblEntry *childRTE = root->simple_rte_array[childRTindex];
-	AppendRelInfo *appinfo = root->append_rel_array[childRTindex];
-	List	   *childquals;
-	ListCell   *lc;
-	bool		have_const_false_cq;
-	Index		cq_min_security;
-
-	/* Build the RelOptInfo. */
-	childrel = build_simple_rel(root, childRTindex, parent);
-
-	/*
-	 * Propagate lateral_relids and lateral_referencers from appendrel
-	 * parent rels to their child rels.  We intentionally give each child rel
-	 * the same minimum parameterization, even though it's quite possible that
-	 * some don't reference all the lateral rels.  This is because any append
-	 * path for the parent will have to have the same parameterization for
-	 * every child anyway, and there's no value in forcing extra
-	 * reparameterize_path() calls.  Similarly, a lateral reference to the
-	 * parent prevents use of otherwise-movable join rels for each child.
-	 */
-	childrel->direct_lateral_relids = parent->direct_lateral_relids;
-	childrel->lateral_relids = parent->lateral_relids;
-	childrel->lateral_referencers = parent->lateral_referencers;
-
-	/*
-	 * We have to copy the parent's quals to the child, with appropriate
-	 * substitution of variables.  However, only the baserestrictinfo
-	 * quals are needed before we can check for constraint exclusion; so
-	 * do that first and then check to see if we can disregard this child.
-	 *
-	 * The child rel's targetlist might contain non-Var expressions, which
-	 * means that substitution into the quals could produce opportunities
-	 * for const-simplification, and perhaps even pseudoconstant quals.
-	 * Therefore, transform each RestrictInfo separately to see if it
-	 * reduces to a constant or pseudoconstant.  (We must process them
-	 * separately to keep track of the security level of each qual.)
-	 */
-	childquals = false;
-	cq_min_security = UINT_MAX;
-	have_const_false_cq = false;
-	foreach(lc, parent->baserestrictinfo)
-	{
-		RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
-		Node	   *childqual = (Node *) rinfo->clause;
-		ListCell   *lc2;
-
-		Assert(IsA(rinfo, RestrictInfo));
-		childqual = adjust_appendrel_attrs(root, childqual,
-										   1, &appinfo);
-		childqual = eval_const_expressions(root, childqual);
-		/* check for flat-out constant */
-		if (childqual && IsA(childqual, Const))
-		{
-			if (((Const *) childqual)->constisnull ||
-				!DatumGetBool(((Const *) childqual)->constvalue))
-			{
-				/* Restriction reduces to constant FALSE or NULL */
-				have_const_false_cq = true;
-				break;
-			}
-			/* Restriction reduces to constant TRUE, so drop it */
-			continue;
-		}
-		/* might have gotten an AND clause, if so flatten it */
-		foreach(lc2, make_ands_implicit((Expr *) childqual))
-		{
-			Node	   *onecq = (Node *) lfirst(lc2);
-			bool		pseudoconstant;
-
-			/* check for pseudoconstant (no Vars or volatile functions) */
-			pseudoconstant =
-					!contain_vars_of_level(onecq, 0) &&
-					!contain_volatile_functions(onecq);
-			if (pseudoconstant)
-			{
-				/* tell createplan.c to check for gating quals */
-				root->hasPseudoConstantQuals = true;
-			}
-			/* reconstitute RestrictInfo with appropriate properties */
-			childquals = lappend(childquals,
-								 make_restrictinfo((Expr *) onecq,
-												   rinfo->is_pushed_down,
-												   rinfo->outerjoin_delayed,
-												   pseudoconstant,
-												   rinfo->security_level,
-												   NULL, NULL, NULL));
-			cq_min_security = Min(cq_min_security, rinfo->security_level);
-		}
-	}
-
-	/*
-	 * In addition to the quals inherited from the parent, we might
-	 * have securityQuals associated with this particular child node.
-	 * (Currently this can only happen in appendrels originating from
-	 * UNION ALL; inheritance child tables don't have their own
-	 * securityQuals.)	Pull any such securityQuals up into the
-	 * baserestrictinfo for the child.  This is similar to
-	 * process_security_barrier_quals() for the parent rel, except
-	 * that we can't make any general deductions from such quals,
-	 * since they don't hold for the whole appendrel.
-	 */
-	if (childRTE->securityQuals)
-	{
-		Index		security_level = 0;
-
-		foreach(lc, childRTE->securityQuals)
-		{
-			List	   *qualset = (List *) lfirst(lc);
-			ListCell   *lc2;
-
-			foreach(lc2, qualset)
-			{
-				Expr	   *qual = (Expr *) lfirst(lc2);
-
-				/*
-				 * not likely that we'd see constants here, so no
-				 * check
-				 */
-				childquals = lappend(childquals,
-									 make_restrictinfo(qual,
-													   true,
-													   false,
-													   false,
-													   security_level,
-													   NULL, NULL,
-													   NULL));
-				cq_min_security = Min(cq_min_security, security_level);
-			}
-			security_level++;
-		}
-		Assert(security_level <= root->qual_security_level);
-	}
-
-	/* Set child's version of baserestrictinfo. */
-	childrel->baserestrictinfo = childquals;
-	childrel->baserestrict_min_security = cq_min_security;
-
-	if (have_const_false_cq)
-	{
-		/*
-		 * Some restriction clause reduced to constant FALSE or NULL after
-		 * substitution, so this child need not be scanned.
-		 */
-		set_dummy_rel_pathlist(childrel);
-	}
-
-	return childrel;
-}
-
-/*
- * add_rowmark_junk_columns
- * 		Add necessary junk columns for rowmarked inheritance parent rel.
- *
- * These values are needed for locking of rels selected FOR UPDATE/SHARE, and
- * to do EvalPlanQual rechecking.  See comments for PlanRowMark in
- * plannodes.h.
- */
-static List *
-add_rowmark_junk_columns(PlannerInfo *root, PlanRowMark *rc)
-{
-	List   *tlist = root->processed_tlist;
-	Var		   *var;
-	char		resname[32];
-	TargetEntry *tle;
-
-	if (rc->allMarkTypes & ~(1 << ROW_MARK_COPY))
-	{
-		/* Need to fetch TID */
-		var = makeVar(rc->rti,
-					  SelfItemPointerAttributeNumber,
-					  TIDOID,
-					  -1,
-					  InvalidOid,
-					  0);
-		snprintf(resname, sizeof(resname), "ctid%u", rc->rowmarkId);
-		tle = makeTargetEntry((Expr *) var,
-							  list_length(tlist) + 1,
-							  pstrdup(resname),
-							  true);
-		tlist = lappend(tlist, tle);
-	}
-	if (rc->allMarkTypes & (1 << ROW_MARK_COPY))
-	{
-		/* Need the whole row as a junk var */
-		var = makeWholeRowVar(root->simple_rte_array[rc->rti],
-							  rc->rti,
-							  0,
-							  false);
-		snprintf(resname, sizeof(resname), "wholerow%u", rc->rowmarkId);
-		tle = makeTargetEntry((Expr *) var,
-							  list_length(tlist) + 1,
-							  pstrdup(resname),
-							  true);
-		tlist = lappend(tlist, tle);
-	}
-
-	/* For inheritance cases, always fetch the tableoid too. */
-	var = makeVar(rc->rti,
-				  TableOidAttributeNumber,
-				  OIDOID,
-				  -1,
-				  InvalidOid,
-				  0);
-	snprintf(resname, sizeof(resname), "tableoid%u", rc->rowmarkId);
-	tle = makeTargetEntry((Expr *) var,
-						  list_length(tlist) + 1,
-						  pstrdup(resname),
-						  true);
-	tlist = lappend(tlist, tle);
-
-	return tlist;
-}
-
-AppendRelInfo *
-make_append_rel_info(RelOptInfo *parentrel, RangeTblEntry *parentrte,
-					 TupleDesc childdesc, Oid childoid, Oid childreltype,
-					 Index childRTindex)
-{
-	AppendRelInfo  *appinfo = makeNode(AppendRelInfo);
-
-	appinfo->parent_relid = parentrel->relid;
-	appinfo->child_relid = childRTindex;
-	appinfo->parent_reltype = parentrel->reltype;
-	appinfo->child_reltype = childreltype;
-	make_inh_translation_list(parentrel->tupdesc, childdesc,
-							  parentrte->relid, childoid,
-							  childRTindex,
-							  &appinfo->translated_vars);
-	appinfo->parent_reloid = parentrte->relid;
-
-	return appinfo;
-}
-
-/*
- * adjust_appendrel_attrs
- *	  Copy the specified query or expression and translate Vars referring to a
- *	  parent rel to refer to the corresponding child rel instead.  We also
- *	  update rtindexes appearing outside Vars, such as resultRelation and
- *	  jointree relids.
- *
- * Note: this is only applied after conversion of sublinks to subplans,
- * so we don't need to cope with recursion into sub-queries.
- *
- * Note: this is not hugely different from what pullup_replace_vars() does;
- * maybe we should try to fold the two routines together.
- */
-Node *
-adjust_appendrel_attrs(PlannerInfo *root, Node *node, int nappinfos,
-					   AppendRelInfo **appinfos)
-{
-	Node	   *result;
-	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);
-
-	/*
-	 * Must be prepared to start with a Query or a bare expression tree.
-	 */
-	if (node && IsA(node, Query))
-	{
-		Query	   *newnode;
-		int			cnt;
-
-		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;
-}
-
-static Node *
-adjust_appendrel_attrs_mutator(Node *node,
-							   adjust_appendrel_attrs_context *context)
-{
-	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;
-
-		for (cnt = 0; cnt < nappinfos; cnt++)
-		{
-			if (var->varno == appinfos[cnt]->parent_relid)
-			{
-				appinfo = appinfos[cnt];
-				break;
-			}
-		}
-
-		if (var->varlevelsup == 0 && appinfo)
-		{
-			var->varno = appinfo->child_relid;
-			var->varnoold = appinfo->child_relid;
-			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));
-				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;
-
-					return (Node *) rowexpr;
-				}
-			}
-			/* system attributes don't need any other translation */
-		}
-		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, 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 */
-		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, context->nappinfos,
-											  context->appinfos);
-		return (Node *) phv;
-	}
-
-	/*
-	 * This is needed, because inheritance_make_rel_from_joinlist needs to
-	 * translate root->join_info_list executing make_rel_from_joinlist for a
-	 * given child.
-	 */
-	if (IsA(node, SpecialJoinInfo))
-	{
-		SpecialJoinInfo *oldinfo = (SpecialJoinInfo *) node;
-		SpecialJoinInfo *newinfo = makeNode(SpecialJoinInfo);
-
-		memcpy(newinfo, oldinfo, sizeof(SpecialJoinInfo));
-		newinfo->min_lefthand = adjust_child_relids(oldinfo->min_lefthand,
-													context->nappinfos,
-													context->appinfos);
-		newinfo->min_righthand = adjust_child_relids(oldinfo->min_righthand,
-													 context->nappinfos,
-													 context->appinfos);
-		newinfo->syn_lefthand = adjust_child_relids(oldinfo->syn_lefthand,
-													context->nappinfos,
-													context->appinfos);
-		newinfo->syn_righthand = adjust_child_relids(oldinfo->syn_righthand,
-													 context->nappinfos,
-													 context->appinfos);
-		newinfo->semi_rhs_exprs =
-					(List *) expression_tree_mutator((Node *)
-													 oldinfo->semi_rhs_exprs,
-													 adjust_appendrel_attrs_mutator,
-													 (void *) context);
-		return (Node *) newinfo;
-	}
-
-	/* Shouldn't need to handle planner auxiliary nodes here */
-	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 */
-		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->nullable_relids = adjust_child_relids(oldinfo->nullable_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));
-
-	return expression_tree_mutator(node, adjust_appendrel_attrs_mutator,
-								   (void *) context);
-}
-
-/*
- * Substitute child relids for parent relids in a Relid set.  The array of
- * appinfos specifies the substitutions to be performed.
- */
-static Relids
-adjust_child_relids(Relids relids, int nappinfos, AppendRelInfo **appinfos)
-{
-	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;
-}
-
-/*
- * Replace any relid present in top_parent_relids with its child in
- * child_relids. Members of child_relids can be multiple levels below top
- * parent in the partition hierarchy.
- */
-Relids
-adjust_child_relids_multilevel(PlannerInfo *root, Relids relids,
-							   Relids child_relids, Relids top_parent_relids)
-{
-	AppendRelInfo **appinfos;
-	int			nappinfos;
-	Relids		parent_relids = NULL;
-	Relids		result;
-	Relids		tmp_result = NULL;
-	int			cnt;
-
-	/*
-	 * If the given relids set doesn't contain any of the top parent relids,
-	 * it will remain unchanged.
-	 */
-	if (!bms_overlap(relids, top_parent_relids))
-		return relids;
-
-	appinfos = find_appinfos_by_relids(root, child_relids, &nappinfos);
-
-	/* Construct relids set for the immediate parent of the given child. */
-	for (cnt = 0; cnt < nappinfos; cnt++)
-	{
-		AppendRelInfo *appinfo = appinfos[cnt];
-
-		parent_relids = bms_add_member(parent_relids, appinfo->parent_relid);
-	}
-
-	/* Recurse if immediate parent is not the top parent. */
-	if (!bms_equal(parent_relids, top_parent_relids))
-	{
-		tmp_result = adjust_child_relids_multilevel(root, relids,
-													parent_relids,
-													top_parent_relids);
-		relids = tmp_result;
-	}
-
-	result = adjust_child_relids(relids, nappinfos, appinfos);
-
-	/* Free memory consumed by any intermediate result. */
-	if (tmp_result)
-		bms_free(tmp_result);
-	bms_free(parent_relids);
-	pfree(appinfos);
-
-	return result;
-}
-
-/*
- * 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.
- */
-static List *
-adjust_inherited_tlist(List *tlist, AppendRelInfo *context)
-{
-	bool		changed_it = false;
-	ListCell   *tl;
-	List	   *new_tlist;
-	bool		more;
-	int			attrno;
-
-	/* 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)
-	{
-		TargetEntry *tle = (TargetEntry *) lfirst(tl);
-		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))
-			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);
-		if (childvar == NULL || !IsA(childvar, Var))
-			elog(ERROR, "attribute %d of relation \"%s\" does not exist",
-				 tle->resno, get_rel_name(context->parent_reloid));
-
-		if (tle->resno != childvar->varattno)
-		{
-			tle->resno = childvar->varattno;
-			changed_it = true;
-		}
-	}
-
-	/*
-	 * 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;
-
-	new_tlist = NIL;
-	more = true;
-	for (attrno = 1; more; attrno++)
-	{
-		more = false;
-		foreach(tl, tlist)
-		{
-			TargetEntry *tle = (TargetEntry *) lfirst(tl);
-
-			if (tle->resjunk)
-				continue;		/* ignore junk items */
-
-			if (tle->resno == attrno)
-				new_tlist = lappend(new_tlist, tle);
-			else if (tle->resno > attrno)
-				more = true;
-		}
-	}
-
-	foreach(tl, tlist)
-	{
-		TargetEntry *tle = (TargetEntry *) lfirst(tl);
-
-		if (!tle->resjunk)
-			continue;			/* here, ignore non-junk items */
-
-		tle->resno = attrno;
-		new_tlist = lappend(new_tlist, tle);
-		attrno++;
-	}
-
-	return new_tlist;
-}
-
-/*
- * adjust_appendrel_attrs_multilevel
- *	  Apply Var translations from a toplevel appendrel parent down to a child.
- *
- * In some cases we need to translate expressions referencing a parent relation
- * to reference an appendrel child that's multiple levels removed from it.
- */
-Node *
-adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node,
-								  Relids child_relids,
-								  Relids top_parent_relids)
-{
-	AppendRelInfo **appinfos;
-	Bitmapset  *parent_relids = NULL;
-	int			nappinfos;
-	int			cnt;
-
-	Assert(bms_num_members(child_relids) == bms_num_members(top_parent_relids));
-
-	appinfos = find_appinfos_by_relids(root, child_relids, &nappinfos);
-
-	/* Construct relids set for the immediate parent of given child. */
-	for (cnt = 0; cnt < nappinfos; cnt++)
-	{
-		AppendRelInfo *appinfo = appinfos[cnt];
-
-		parent_relids = bms_add_member(parent_relids, appinfo->parent_relid);
-	}
-
-	/* Recurse if immediate parent is not the top parent. */
-	if (!bms_equal(parent_relids, top_parent_relids))
-		node = adjust_appendrel_attrs_multilevel(root, node, parent_relids,
-												 top_parent_relids);
-
-	/* Now translate for this child */
-	node = adjust_appendrel_attrs(root, node, nappinfos, appinfos);
-
-	pfree(appinfos);
-
-	return node;
-}
-
-/*
- * Construct the SpecialJoinInfo for a child-join by translating
- * SpecialJoinInfo for the join between parents. left_relids and right_relids
- * are the relids of left and right side of the join respectively.
- */
-SpecialJoinInfo *
-build_child_join_sjinfo(PlannerInfo *root, SpecialJoinInfo *parent_sjinfo,
-						Relids left_relids, Relids right_relids)
-{
-	SpecialJoinInfo *sjinfo = makeNode(SpecialJoinInfo);
-	AppendRelInfo **left_appinfos;
-	int			left_nappinfos;
-	AppendRelInfo **right_appinfos;
-	int			right_nappinfos;
-
-	memcpy(sjinfo, parent_sjinfo, sizeof(SpecialJoinInfo));
-	left_appinfos = find_appinfos_by_relids(root, left_relids,
-											&left_nappinfos);
-	right_appinfos = find_appinfos_by_relids(root, right_relids,
-											 &right_nappinfos);
-
-	sjinfo->min_lefthand = adjust_child_relids(sjinfo->min_lefthand,
-											   left_nappinfos, left_appinfos);
-	sjinfo->min_righthand = adjust_child_relids(sjinfo->min_righthand,
-												right_nappinfos,
-												right_appinfos);
-	sjinfo->syn_lefthand = adjust_child_relids(sjinfo->syn_lefthand,
-											   left_nappinfos, left_appinfos);
-	sjinfo->syn_righthand = adjust_child_relids(sjinfo->syn_righthand,
-												right_nappinfos,
-												right_appinfos);
-	sjinfo->semi_rhs_exprs = (List *) adjust_appendrel_attrs(root,
-															 (Node *) sjinfo->semi_rhs_exprs,
-															 right_nappinfos,
-															 right_appinfos);
-
-	pfree(left_appinfos);
-	pfree(right_appinfos);
-
-	return sjinfo;
-}
-
-/*
- * find_appinfos_by_relids
- * 		Find AppendRelInfo structures for all relations specified by relids.
- *
- * The AppendRelInfos are returned in an array, which can be pfree'd by the
- * caller. *nappinfos is set to the number of entries in the array.
- */
-AppendRelInfo **
-find_appinfos_by_relids(PlannerInfo *root, Relids relids, int *nappinfos)
-{
-	AppendRelInfo **appinfos;
-	int			cnt = 0;
-	int			i;
-
-	*nappinfos = bms_num_members(relids);
-	appinfos = (AppendRelInfo **) palloc(sizeof(AppendRelInfo *) * *nappinfos);
-
-	i = -1;
-	while ((i = bms_next_member(relids, i)) >= 0)
-	{
-		AppendRelInfo *appinfo = root->append_rel_array[i];
-
-		if (!appinfo)
-			elog(ERROR, "child rel %d not found in append_rel_array", i);
-
-		appinfos[cnt++] = appinfo;
-	}
-	return appinfos;
-}
diff --git a/src/backend/optimizer/util/Makefile b/src/backend/optimizer/util/Makefile
index da9ccf32b4..d166030a10 100644
--- a/src/backend/optimizer/util/Makefile
+++ b/src/backend/optimizer/util/Makefile
@@ -12,7 +12,8 @@ subdir = src/backend/optimizer/util
 top_builddir = ../../../..
 include $(top_builddir)/src/Makefile.global
 
-OBJS = clauses.o joininfo.o orclauses.o pathnode.o placeholder.o \
-	   plancat.o predtest.o relnode.o restrictinfo.o tlist.o var.o
+OBJS = append.o appendinfo.o clauses.o joininfo.o orclauses.o pathnode.o \
+	   placeholder.o plancat.o predtest.o relnode.o restrictinfo.o tlist.o \
+	   var.o
 
 include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/optimizer/util/append.c b/src/backend/optimizer/util/append.c
new file mode 100644
index 0000000000..d2ad80034f
--- /dev/null
+++ b/src/backend/optimizer/util/append.c
@@ -0,0 +1,777 @@
+/*-------------------------------------------------------------------------
+ *
+ * append.c
+ *	  Routines to process children of an appendrel parent
+ *
+ * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/optimizer/path/append.c
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include <limits.h>
+
+#include "access/sysattr.h"
+#include "catalog/partition.h"
+#include "catalog/pg_class.h"
+#include "catalog/pg_inherits.h"
+#include "catalog/pg_type.h"
+#include "nodes/makefuncs.h"
+#include "optimizer/append.h"
+#include "optimizer/appendinfo.h"
+#include "optimizer/clauses.h"
+#include "optimizer/pathnode.h"
+#include "optimizer/paths.h"
+#include "optimizer/plancat.h"
+#include "optimizer/planmain.h"
+#include "optimizer/planner.h"
+#include "optimizer/prep.h"
+#include "optimizer/restrictinfo.h"
+#include "optimizer/tlist.h"
+#include "optimizer/var.h"
+#include "partitioning/partprune.h"
+#include "utils/rel.h"
+
+static void expand_append_rtentry(PlannerInfo *root, RelOptInfo *rel,
+					  RangeTblEntry *rte, Index rti);
+static void expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte,
+						 Index rti, RelOptInfo *rel);
+static void expand_partitioned_rtentry(PlannerInfo *root,
+						   RangeTblEntry *parentrte,
+						   Index parentRTindex, RelOptInfo *parentrel);
+static RelOptInfo *add_inheritance_child_rel(PlannerInfo *root,
+						  RangeTblEntry *parentrte,
+						  Index parentRTindex, RelOptInfo *parentrel,
+						  PlanRowMark *top_parentrc, Relation childrel,
+						  RangeTblEntry **childrte_p, Index *childRTindex_p);
+static RelOptInfo *build_append_child_rel(PlannerInfo *root,
+					   RelOptInfo *parent,
+					   Index childRTindex);
+static List *add_rowmark_junk_columns(PlannerInfo *root, PlanRowMark *rc);
+
+
+/*
+ * expand_inherited_tables
+ *		Expand each rangetable entry that represents an inheritance set
+ *		into an "append relation".  At the conclusion of this process,
+ *		the "inh" flag is set in all and only those RTEs that are append
+ *		relation parents.
+ */
+void
+expand_inherited_tables(PlannerInfo *root)
+{
+	int			orig_rtable_size;
+	Index		rti;
+
+	Assert(root->simple_rel_array_size > 0);
+	orig_rtable_size = root->simple_rel_array_size;
+
+	/*
+	 * expand_append_rtentry may add RTEs to parse->rtable. The function is
+	 * expected to recursively handle any RTEs that it creates with inh=true.
+	 * So just scan as far as the original end of the rtable list.
+	 */
+	for (rti = 1; rti < orig_rtable_size; rti++)
+	{
+		RelOptInfo *brel = root->simple_rel_array[rti];
+		RangeTblEntry *rte = root->simple_rte_array[rti];
+
+		/* there may be empty slots corresponding to non-baserel RTEs */
+		if (brel == NULL)
+			continue;
+
+		if (rte->inh)
+			expand_append_rtentry(root, brel, rte, rti);
+	}
+}
+
+/*
+ * expand_append_rtentry
+ *		This initializes RelOptInfos for an appendrel's child relations, if
+ *		any
+ *
+ * 'rel' is the appendrel parent, whose range table entry ('rte') has been
+ * marked to require adding children.  An appendrel parent could either
+ * be a subquery (if we flattened UNION ALL query) or a table that's known
+ * to have inheritance children.  The latter consists of both regular
+ * inheritance parents and partitioned tables.
+ *
+ * For a subquery parent, there is not much to be done here because the
+ * children's RTEs are already present in the query, so we just initialize
+ * RelOptInfos for them.  Also, the AppendRelInfos for child subqueries
+ * have already been added.
+ *
+ * For tables, we need to add the children to the range table and initialize
+ * AppendRelInfos, RelOptInfos, and PlanRowMarks (if any) for them.  For
+ * a partitioned parent, we only add the children remaining after pruning.
+ * For regular inheritance parents, we find the children using
+ * find_all_inheritors and add all of them.
+ *
+ * If it turns out that there are no children, then we set rte->inh to false
+ * to let the caller know that only the parent table needs to be scanned.  The
+ * caller can accordingly switch to a non-Append path.  For a partitioned
+ * parent, that means an empty relation because parents themselves contain no
+ * data.
+ *
+ * For the regular inheritance case, the parent also gets another RTE with
+ * inh = false to represent it as an appendrel child.  The original RTE is
+ * considered to represent the whole inheritance set.
+ */
+static void
+expand_append_rtentry(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte,
+					  Index rti)
+{
+	Assert(rte->inh);
+	/* Inheritance parent (partitioned or not) or UNION ALL parent subquery. */
+	Assert(rte->rtekind == RTE_RELATION || rte->rtekind == RTE_SUBQUERY);
+
+	/*
+	 * UNION ALL children already got RTEs and AppendRelInfos, so just build
+	 * RelOptInfos and return.
+	 *
+	 * It might be a bit odd that this code is in this, because there is
+	 * nothing to expand really.
+	 */
+	if (rte->rtekind == RTE_SUBQUERY)
+	{
+		ListCell   *l;
+
+		/*
+		 * We don't need to use expand_planner_arrays in this case, because
+		 * no new child RTEs are created.  setup_simple_rel_arrays() and
+		 * setup_append_rel_array would've considered these child RTEs when
+		 * allocating space for various arrays.
+		 */
+		foreach(l, root->append_rel_list)
+		{
+			AppendRelInfo *appinfo = lfirst(l);
+			Index		childRTindex = appinfo->child_relid;
+
+			if (appinfo->parent_relid != rti)
+				continue;
+
+			Assert(childRTindex < root->simple_rel_array_size);
+			Assert(root->simple_rte_array[childRTindex] != NULL);
+
+			/*
+			 * We set the correct value of baserestricinfo and
+			 * baserestrict_min_security below.
+			 */
+			root->simple_rel_array[childRTindex] =
+				build_append_child_rel(root, rel, appinfo->child_relid);
+		}
+	}
+	else
+	{
+		Assert(rte->rtekind == RTE_RELATION);
+		Assert(has_subclass(rte->relid));
+
+		/*
+		 * The rewriter should already have obtained an appropriate lock on
+		 * each relation named in the query.  However, for each child relation
+		 * we add to the query, we must obtain an appropriate lock, because
+		 * this will be the first use of those relations in the
+		 * parse/rewrite/plan pipeline.  Child rels should use the same
+		 * lockmode as their parent.
+		 */
+		Assert(rte->rellockmode != NoLock);
+
+		if (rte->relkind == RELKIND_PARTITIONED_TABLE)
+			expand_partitioned_rtentry(root, rte, rti, rel);
+		else
+			expand_inherited_rtentry(root, rte, rti, rel);
+	}
+}
+
+/*
+ * expand_inherited_rtentry
+ *		Add entries for all the child tables to the query's rangetable, and
+ *		build AppendRelInfo nodes for all the child tables and add them to
+ *		root->append_rel_list.
+ *
+ * Note that the original RTE is considered to represent the whole
+ * inheritance set.  The first of the generated RTEs is an RTE for the same
+ * table, but with inh = false, to represent the parent table in its role
+ * as a simple member of the inheritance set.
+ *
+ * A childless table is never considered to be an inheritance set. For
+ * regular inheritance, a parent RTE must always have at least two associated
+ * AppendRelInfos: one corresponding to the parent table as a simple member of
+ * inheritance set and one or more corresponding to the actual children.
+ */
+static void
+expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti,
+						 RelOptInfo *rel)
+{
+	Oid			parentOID;
+	PlanRowMark *oldrc;
+	LOCKMODE	lockmode = rte->rellockmode;
+	List	   *inhOIDs;
+	ListCell   *l;
+	int			num_children;
+	int			num_children_added = 0;
+
+	Assert(rte->rtekind == RTE_RELATION);
+	Assert(lockmode != NoLock);
+	parentOID = rte->relid;
+
+	/* Scan for all members of inheritance set, acquire needed locks */
+	inhOIDs = find_all_inheritors(parentOID, lockmode, NULL);
+
+	/*
+	 * Check that there's at least one descendant, else treat as no-child
+	 * case.  This could happen despite above has_subclass() check, if table
+	 * once had a child but no longer does.
+	 */
+	num_children = list_length(inhOIDs);
+	if (num_children < 2)
+	{
+		/* Clear flag before returning */
+		rte->inh = false;
+		return;
+	}
+
+	/*
+	 * If parent relation is selected FOR UPDATE/SHARE, preprocess_rowmarks
+	 * should've set isParent = true.  We'll generate a new PlanRowMark for
+	 * each child.
+	 */
+	oldrc = get_plan_rowmark(root->rowMarks, rti);
+	Assert(oldrc == NULL || oldrc->isParent);
+
+	/*
+	 * Must expand PlannerInfo arrays by num_children before we can add
+	 * children.
+	 */
+	expand_planner_arrays(root, num_children);
+
+	foreach(l, inhOIDs)
+	{
+		Oid			childOID = lfirst_oid(l);
+		Relation	newrelation;
+		RangeTblEntry *childrte;
+		Index		childRTindex;
+
+		/* Already locked above. */
+		newrelation = heap_open(childOID, NoLock);
+
+		/*
+		 * It is possible that the parent table has children that are temp
+		 * tables of other backends.  We cannot safely access such tables
+		 * (because of buffering issues), and the best thing to do seems
+		 * to be to silently ignore them.
+		 */
+		if (RELATION_IS_OTHER_TEMP(newrelation))
+		{
+			heap_close(newrelation, lockmode);
+			continue;
+		}
+
+		(void) add_inheritance_child_rel(root, rte, rti, rel, oldrc,
+										 newrelation, &childrte,
+										 &childRTindex);
+		Assert(childrte != NULL);
+		/* All regular inheritance children are leaf children. */
+		Assert(!childrte->inh);
+		Assert(childRTindex > 0);
+
+		/* Close child relations, but keep locks */
+		heap_close(newrelation, NoLock);
+		num_children_added++;
+	}
+
+	/*
+	 * If all children, including the parent (as child rel), were
+	 * excluded, mark the parent rel as empty.  If all the children were temp
+	 * tables, pretend it's a non-inheritance situation; we don't need Append
+	 * node in that case.  The duplicate RTE we added for the parent table is
+	 * harmless, so we don't bother to get rid of it; ditto for the useless
+	 * PlanRowMark node.
+	 */
+	if (num_children_added == 0)
+		mark_dummy_rel(rel);
+	else if (num_children_added == 1)
+		rte->inh = false;
+
+	/*
+	 * Add junk columns needed by the row mark if any and also add the
+	 * relevant expressions to the root parent's reltarget.
+	 */
+	if (oldrc)
+	{
+		List   *tlist = add_rowmark_junk_columns(root, oldrc);
+
+		build_base_rel_tlists(root, tlist);
+	}
+}
+
+/*
+ * expand_partitioned_rtentry
+ *		Prunes unnecessary partitions of a partitioned table and adds
+ *		remaining ones to the Query and the PlannerInfo
+ *
+ * Partitions are added to the query in order in which they are found in
+ * the parent's PartitionDesc.
+ *
+ * Note: even though only the unpruned partitions will be added to the
+ * resulting plan, this still locks *all* partitions via find_all_inheritors
+ * in order to avoid partitions being locked in a different order than other
+ * places in the backend that may lock partitions.
+ */
+static void
+expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
+						   Index parentRTindex, RelOptInfo *parentrel)
+{
+	LOCKMODE	lockmode = parentrte->rellockmode;
+	PlanRowMark *rootrc = NULL;
+	int			i;
+	Bitmapset  *partindexes;
+	Index		rootParentRTindex = parentrel->inh_root_parent > 0 ?
+									parentrel->inh_root_parent :
+									parentRTindex;
+
+	/* If root partitioned table, lock *all* partitions in the tree. */
+	if (parentRTindex == rootParentRTindex)
+		(void) find_all_inheritors(parentrte->relid, lockmode, NULL);
+
+	/*
+	 * Initialize partitioned_child_rels to contain this RT index.
+	 *
+	 * Note that during the set_append_rel_pathlist() phase, values of the
+	 * indexes of partitioned relations that appear down in the tree will be
+	 * bubbled up into root parent's list so that when we've created Paths for
+	 * all the children, the root table's list will contain all such indexes.
+	 */
+	parentrel->partitioned_child_rels = list_make1_int(parentRTindex);
+
+	/* Perform pruning. */
+	partindexes = prune_append_rel_partitions(parentrel);
+
+	/* Must expand PlannerInfo arrays before we can add children. */
+	expand_planner_arrays(root, bms_num_members(partindexes));
+
+	/*
+	 * For partitioned tables, we also store the partition RelOptInfo
+	 * pointers in the parent's RelOptInfo.
+	 */
+	parentrel->part_rels = (RelOptInfo **) palloc0(sizeof(RelOptInfo *) *
+												   parentrel->nparts);
+
+	rootrc = get_plan_rowmark(root->rowMarks, rootParentRTindex);
+	Assert(rootrc == NULL || rootrc->isParent);
+	i = -1;
+	while ((i = bms_next_member(partindexes, i)) >= 0)
+	{
+		Oid		childOID = parentrel->part_oids[i];
+		Relation	newrelation;
+		RelOptInfo *childrel;
+		RangeTblEntry *childrte;
+		Index		childRTindex;
+
+		/* Already locked above. */
+		newrelation = heap_open(childOID, NoLock);
+		Assert(!RELATION_IS_OTHER_TEMP(newrelation));
+
+		/*
+		 * A partitioned child table with 0 children is a dummy rel, so don't
+		 * bother creating planner objects for it.
+		 */
+		if (newrelation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE &&
+			RelationGetPartitionDesc(newrelation)->nparts == 0)
+		{
+			heap_close(newrelation, NoLock);
+			continue;
+		}
+
+		childrel = add_inheritance_child_rel(root, parentrte, parentRTindex,
+											 parentrel, rootrc, newrelation,
+											 &childrte, &childRTindex);
+		Assert(childrel != NULL);
+		parentrel->part_rels[i] = childrel;
+
+		/* Close child relations, but keep locks */
+		heap_close(newrelation, NoLock);
+
+		/* If the child is partitioned itself, expand it too. */
+		if (childrel->part_scheme)
+		{
+			Assert(childrte->inh);
+			expand_partitioned_rtentry(root, childrte, childRTindex,
+									   childrel);
+		}
+	}
+
+	/*
+	 * Add junk columns needed by the row mark if any and also add the
+	 * relevant expressions to the root parent's reltarget.
+	 */
+	if (rootrc)
+	{
+		List   *tlist = add_rowmark_junk_columns(root, rootrc);
+
+		build_base_rel_tlists(root, tlist);
+	}
+}
+
+/*
+ * add_inheritance_child_rel
+ *		Build a RangeTblEntry, an AppendRelInfo, a PlanRowMark, and finally
+ *		a RelOptInfo for an inheritance child relation.
+ *
+ * The return value is the RelOptInfo that's added.
+ *
+ * PlanRowMarks still carry the top-parent's RTI, and the top-parent's
+ * allMarkTypes field still accumulates values from all descendents.
+ *
+ * "parentrte" and "parentRTindex" are immediate parent's RTE and
+ * RTI. "top_parentrc" is top parent's PlanRowMark.
+ */
+static RelOptInfo *
+add_inheritance_child_rel(PlannerInfo *root, RangeTblEntry *parentrte,
+						  Index parentRTindex, RelOptInfo *parentrel,
+						  PlanRowMark *top_parentrc, Relation childrel,
+						  RangeTblEntry **childrte_p, Index *childRTindex_p)
+{
+	Query	   *parse = root->parse;
+	Oid			childOID = RelationGetRelid(childrel);
+	RangeTblEntry *childrte;
+	Index		childRTindex;
+	AppendRelInfo *appinfo;
+	RelOptInfo *childrelopt;
+
+	/*
+	 * Build an RTE for the child, and attach to query's rangetable list. We
+	 * copy most fields of the parent's RTE, but replace relation OID and
+	 * relkind, and set inh appropriately.  Also, set requiredPerms to zero
+	 * since all required permissions checks are done on the original RTE.
+	 * Likewise, set the child's securityQuals to empty, because we only want
+	 * to apply the parent's RLS conditions regardless of what RLS properties
+	 * individual children may have.  (This is an intentional choice to make
+	 * inherited RLS work like regular permissions checks.) The parent
+	 * securityQuals will be propagated to children along with other base
+	 * restriction clauses, so we don't need to do it here.
+	 */
+	childrte = copyObject(parentrte);
+	*childrte_p = childrte;
+	childrte->relid = childOID;
+	childrte->relkind = childrel->rd_rel->relkind;
+	/*
+	 * A partitioned child will need to be expanded as an append parent
+	 * itself, so set its inh to true.
+	 */
+	childrte->inh = (childrte->relkind == RELKIND_PARTITIONED_TABLE);
+	childrte->requiredPerms = 0;
+	childrte->securityQuals = NIL;
+	parse->rtable = lappend(parse->rtable, childrte);
+	childRTindex = list_length(parse->rtable);
+	*childRTindex_p = childRTindex;
+
+	/* Create an AppendRelInfo and add it to planner's global list. */
+	appinfo = make_append_rel_info(parentrel, parentrte,
+								   childrel->rd_att,
+								   childOID,
+								   childrel->rd_rel->reltype,
+								   childRTindex);
+	root->append_rel_list = lappend(root->append_rel_list, appinfo);
+
+	/*
+	 * Translate the column permissions bitmaps to the child's attnums (we
+	 * have to build the translated_vars list before we can do this). But
+	 * if this is the parent table, leave copyObject's result alone.
+	 *
+	 * Note: we need to do this even though the executor won't run any
+	 * permissions checks on the child RTE.  The insertedCols/updatedCols
+	 * bitmaps may be examined for trigger-firing purposes.
+	 */
+	if (childrte->relid != parentrte->relid)
+	{
+		childrte->selectedCols = translate_col_privs(parentrte->selectedCols,
+													 appinfo->translated_vars);
+		childrte->insertedCols = translate_col_privs(parentrte->insertedCols,
+													 appinfo->translated_vars);
+		childrte->updatedCols = translate_col_privs(parentrte->updatedCols,
+													appinfo->translated_vars);
+	}
+
+	/*
+	 * Build a PlanRowMark if parent is marked FOR UPDATE/SHARE.
+	 */
+	if (top_parentrc)
+	{
+		PlanRowMark *childrc = makeNode(PlanRowMark);
+
+		childrc->rti = childRTindex;
+		childrc->prti = top_parentrc->rti;
+		childrc->rowmarkId = top_parentrc->rowmarkId;
+		/* Reselect rowmark type, because relkind might not match parent */
+		childrc->markType = select_rowmark_type(childrte,
+												top_parentrc->strength);
+		childrc->allMarkTypes = (1 << childrc->markType);
+		childrc->strength = top_parentrc->strength;
+		childrc->waitPolicy = top_parentrc->waitPolicy;
+
+		/*
+		 * We mark RowMarks for partitioned child tables as parent RowMarks so
+		 * that the executor ignores them (except their existence means that
+		 * the child tables be locked using appropriate mode).
+		 */
+		childrc->isParent = (childrte->relkind == RELKIND_PARTITIONED_TABLE);
+
+		/* Include child's rowmark type in top parent's allMarkTypes */
+		top_parentrc->allMarkTypes |= childrc->allMarkTypes;
+
+		root->rowMarks = lappend(root->rowMarks, childrc);
+	}
+
+	/*
+	 * Add the RelOptInfo.  Even though we may not really scan this relation
+	 * for reasons such as contradictory quals, we still need need to create
+	 * one, because for every RTE in the query's range table, there must be an
+	 * accompanying RelOptInfo.
+	 */
+
+	/* First, store the RTE and appinfos into planner arrays. */
+	Assert(root->simple_rte_array[childRTindex] == NULL);
+	root->simple_rte_array[childRTindex] = childrte;
+	Assert(root->append_rel_array[childRTindex] == NULL);
+	root->append_rel_array[childRTindex] = appinfo;
+
+	childrelopt = build_append_child_rel(root, parentrel, childRTindex);
+	Assert(childrelopt != NULL);
+
+	return childrelopt;
+}
+
+/*
+ *	build_append_child_rel
+ *		Build a RelOptInfo for child relation of an append rel
+ *
+ * After creating the RelOptInfo for the given child RT index, it goes on to
+ * initialize some of its fields base on the parent RelOptInfo.
+ *
+ * If the quals in baserestrictinfo turns out to be self-contradictory, the
+ * RelOptInfo is marked dummy before returning.
+ */
+static RelOptInfo *
+build_append_child_rel(PlannerInfo *root,
+					   RelOptInfo *parent,
+					   Index childRTindex)
+{
+	RelOptInfo *childrel;
+	RangeTblEntry *childRTE = root->simple_rte_array[childRTindex];
+	AppendRelInfo *appinfo = root->append_rel_array[childRTindex];
+	List	   *childquals;
+	ListCell   *lc;
+	bool		have_const_false_cq;
+	Index		cq_min_security;
+
+	/* Build the RelOptInfo. */
+	childrel = build_simple_rel(root, childRTindex, parent);
+
+	/*
+	 * Propagate lateral_relids and lateral_referencers from appendrel
+	 * parent rels to their child rels.  We intentionally give each child rel
+	 * the same minimum parameterization, even though it's quite possible that
+	 * some don't reference all the lateral rels.  This is because any append
+	 * path for the parent will have to have the same parameterization for
+	 * every child anyway, and there's no value in forcing extra
+	 * reparameterize_path() calls.  Similarly, a lateral reference to the
+	 * parent prevents use of otherwise-movable join rels for each child.
+	 */
+	childrel->direct_lateral_relids = parent->direct_lateral_relids;
+	childrel->lateral_relids = parent->lateral_relids;
+	childrel->lateral_referencers = parent->lateral_referencers;
+
+	/*
+	 * We have to copy the parent's quals to the child, with appropriate
+	 * substitution of variables.  However, only the baserestrictinfo
+	 * quals are needed before we can check for constraint exclusion; so
+	 * do that first and then check to see if we can disregard this child.
+	 *
+	 * The child rel's targetlist might contain non-Var expressions, which
+	 * means that substitution into the quals could produce opportunities
+	 * for const-simplification, and perhaps even pseudoconstant quals.
+	 * Therefore, transform each RestrictInfo separately to see if it
+	 * reduces to a constant or pseudoconstant.  (We must process them
+	 * separately to keep track of the security level of each qual.)
+	 */
+	childquals = false;
+	cq_min_security = UINT_MAX;
+	have_const_false_cq = false;
+	foreach(lc, parent->baserestrictinfo)
+	{
+		RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
+		Node	   *childqual = (Node *) rinfo->clause;
+		ListCell   *lc2;
+
+		Assert(IsA(rinfo, RestrictInfo));
+		childqual = adjust_appendrel_attrs(root, childqual,
+										   1, &appinfo);
+		childqual = eval_const_expressions(root, childqual);
+		/* check for flat-out constant */
+		if (childqual && IsA(childqual, Const))
+		{
+			if (((Const *) childqual)->constisnull ||
+				!DatumGetBool(((Const *) childqual)->constvalue))
+			{
+				/* Restriction reduces to constant FALSE or NULL */
+				have_const_false_cq = true;
+				break;
+			}
+			/* Restriction reduces to constant TRUE, so drop it */
+			continue;
+		}
+		/* might have gotten an AND clause, if so flatten it */
+		foreach(lc2, make_ands_implicit((Expr *) childqual))
+		{
+			Node	   *onecq = (Node *) lfirst(lc2);
+			bool		pseudoconstant;
+
+			/* check for pseudoconstant (no Vars or volatile functions) */
+			pseudoconstant =
+					!contain_vars_of_level(onecq, 0) &&
+					!contain_volatile_functions(onecq);
+			if (pseudoconstant)
+			{
+				/* tell createplan.c to check for gating quals */
+				root->hasPseudoConstantQuals = true;
+			}
+			/* reconstitute RestrictInfo with appropriate properties */
+			childquals = lappend(childquals,
+								 make_restrictinfo((Expr *) onecq,
+												   rinfo->is_pushed_down,
+												   rinfo->outerjoin_delayed,
+												   pseudoconstant,
+												   rinfo->security_level,
+												   NULL, NULL, NULL));
+			cq_min_security = Min(cq_min_security, rinfo->security_level);
+		}
+	}
+
+	/*
+	 * In addition to the quals inherited from the parent, we might
+	 * have securityQuals associated with this particular child node.
+	 * (Currently this can only happen in appendrels originating from
+	 * UNION ALL; inheritance child tables don't have their own
+	 * securityQuals.)	Pull any such securityQuals up into the
+	 * baserestrictinfo for the child.  This is similar to
+	 * process_security_barrier_quals() for the parent rel, except
+	 * that we can't make any general deductions from such quals,
+	 * since they don't hold for the whole appendrel.
+	 */
+	if (childRTE->securityQuals)
+	{
+		Index		security_level = 0;
+
+		foreach(lc, childRTE->securityQuals)
+		{
+			List	   *qualset = (List *) lfirst(lc);
+			ListCell   *lc2;
+
+			foreach(lc2, qualset)
+			{
+				Expr	   *qual = (Expr *) lfirst(lc2);
+
+				/*
+				 * not likely that we'd see constants here, so no
+				 * check
+				 */
+				childquals = lappend(childquals,
+									 make_restrictinfo(qual,
+													   true,
+													   false,
+													   false,
+													   security_level,
+													   NULL, NULL,
+													   NULL));
+				cq_min_security = Min(cq_min_security, security_level);
+			}
+			security_level++;
+		}
+		Assert(security_level <= root->qual_security_level);
+	}
+
+	/* Set child's version of baserestrictinfo. */
+	childrel->baserestrictinfo = childquals;
+	childrel->baserestrict_min_security = cq_min_security;
+
+	if (have_const_false_cq)
+	{
+		/*
+		 * Some restriction clause reduced to constant FALSE or NULL after
+		 * substitution, so this child need not be scanned.
+		 */
+		set_dummy_rel_pathlist(childrel);
+	}
+
+	return childrel;
+}
+
+/*
+ * add_rowmark_junk_columns
+ * 		Add necessary junk columns for rowmarked inheritance parent rel.
+ *
+ * These values are needed for locking of rels selected FOR UPDATE/SHARE, and
+ * to do EvalPlanQual rechecking.  See comments for PlanRowMark in
+ * plannodes.h.
+ */
+static List *
+add_rowmark_junk_columns(PlannerInfo *root, PlanRowMark *rc)
+{
+	List   *tlist = root->processed_tlist;
+	Var		   *var;
+	char		resname[32];
+	TargetEntry *tle;
+
+	if (rc->allMarkTypes & ~(1 << ROW_MARK_COPY))
+	{
+		/* Need to fetch TID */
+		var = makeVar(rc->rti,
+					  SelfItemPointerAttributeNumber,
+					  TIDOID,
+					  -1,
+					  InvalidOid,
+					  0);
+		snprintf(resname, sizeof(resname), "ctid%u", rc->rowmarkId);
+		tle = makeTargetEntry((Expr *) var,
+							  list_length(tlist) + 1,
+							  pstrdup(resname),
+							  true);
+		tlist = lappend(tlist, tle);
+	}
+	if (rc->allMarkTypes & (1 << ROW_MARK_COPY))
+	{
+		/* Need the whole row as a junk var */
+		var = makeWholeRowVar(root->simple_rte_array[rc->rti],
+							  rc->rti,
+							  0,
+							  false);
+		snprintf(resname, sizeof(resname), "wholerow%u", rc->rowmarkId);
+		tle = makeTargetEntry((Expr *) var,
+							  list_length(tlist) + 1,
+							  pstrdup(resname),
+							  true);
+		tlist = lappend(tlist, tle);
+	}
+
+	/* For inheritance cases, always fetch the tableoid too. */
+	var = makeVar(rc->rti,
+				  TableOidAttributeNumber,
+				  OIDOID,
+				  -1,
+				  InvalidOid,
+				  0);
+	snprintf(resname, sizeof(resname), "tableoid%u", rc->rowmarkId);
+	tle = makeTargetEntry((Expr *) var,
+						  list_length(tlist) + 1,
+						  pstrdup(resname),
+						  true);
+	tlist = lappend(tlist, tle);
+
+	return tlist;
+}
diff --git a/src/backend/optimizer/util/appendinfo.c b/src/backend/optimizer/util/appendinfo.c
new file mode 100644
index 0000000000..9502535e53
--- /dev/null
+++ b/src/backend/optimizer/util/appendinfo.c
@@ -0,0 +1,851 @@
+/*-------------------------------------------------------------------------
+ *
+ * appendinfo.c
+ *	  Routines for mapping between append parent(s) and children
+ *
+ * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/optimizer/path/appendinfo.c
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include "access/htup_details.h"
+#include "access/sysattr.h"
+#include "nodes/makefuncs.h"
+#include "nodes/nodeFuncs.h"
+#include "optimizer/appendinfo.h"
+#include "parser/parsetree.h"
+#include "utils/rel.h"
+#include "utils/lsyscache.h"
+#include "utils/syscache.h"
+
+typedef struct
+{
+	PlannerInfo *root;
+	int			nappinfos;
+	AppendRelInfo **appinfos;
+} adjust_appendrel_attrs_context;
+
+static void make_inh_translation_list(TupleDesc old_tupdesc,
+						  TupleDesc new_tupdesc,
+						  Oid from_rel, Oid to_rel,
+						  Index newvarno, List **translated_vars);
+static Node *adjust_appendrel_attrs_mutator(Node *node,
+							   adjust_appendrel_attrs_context *context);
+static Relids adjust_child_relids(Relids relids, int nappinfos,
+					AppendRelInfo **appinfos);
+static List *adjust_inherited_tlist(List *tlist,
+					   AppendRelInfo *context);
+
+AppendRelInfo *
+make_append_rel_info(RelOptInfo *parentrel, RangeTblEntry *parentrte,
+					 TupleDesc childdesc, Oid childoid, Oid childreltype,
+					 Index childRTindex)
+{
+	AppendRelInfo  *appinfo = makeNode(AppendRelInfo);
+
+	appinfo->parent_relid = parentrel->relid;
+	appinfo->child_relid = childRTindex;
+	appinfo->parent_reltype = parentrel->reltype;
+	appinfo->child_reltype = childreltype;
+	make_inh_translation_list(parentrel->tupdesc, childdesc,
+							  parentrte->relid, childoid,
+							  childRTindex,
+							  &appinfo->translated_vars);
+	appinfo->parent_reloid = parentrte->relid;
+
+	return appinfo;
+}
+
+/*
+ * adjust_appendrel_attrs
+ *	  Copy the specified query or expression and translate Vars referring to a
+ *	  parent rel to refer to the corresponding child rel instead.  We also
+ *	  update rtindexes appearing outside Vars, such as resultRelation and
+ *	  jointree relids.
+ *
+ * Note: this is only applied after conversion of sublinks to subplans,
+ * so we don't need to cope with recursion into sub-queries.
+ *
+ * Note: this is not hugely different from what pullup_replace_vars() does;
+ * maybe we should try to fold the two routines together.
+ */
+Node *
+adjust_appendrel_attrs(PlannerInfo *root, Node *node, int nappinfos,
+					   AppendRelInfo **appinfos)
+{
+	Node	   *result;
+	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);
+
+	/*
+	 * Must be prepared to start with a Query or a bare expression tree.
+	 */
+	if (node && IsA(node, Query))
+	{
+		Query	   *newnode;
+		int			cnt;
+
+		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;
+}
+
+static Node *
+adjust_appendrel_attrs_mutator(Node *node,
+							   adjust_appendrel_attrs_context *context)
+{
+	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;
+
+		for (cnt = 0; cnt < nappinfos; cnt++)
+		{
+			if (var->varno == appinfos[cnt]->parent_relid)
+			{
+				appinfo = appinfos[cnt];
+				break;
+			}
+		}
+
+		if (var->varlevelsup == 0 && appinfo)
+		{
+			var->varno = appinfo->child_relid;
+			var->varnoold = appinfo->child_relid;
+			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));
+				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;
+
+					return (Node *) rowexpr;
+				}
+			}
+			/* system attributes don't need any other translation */
+		}
+		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, 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 */
+		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, context->nappinfos,
+											  context->appinfos);
+		return (Node *) phv;
+	}
+
+	/*
+	 * This is needed, because inheritance_make_rel_from_joinlist needs to
+	 * translate root->join_info_list executing make_rel_from_joinlist for a
+	 * given child.
+	 */
+	if (IsA(node, SpecialJoinInfo))
+	{
+		SpecialJoinInfo *oldinfo = (SpecialJoinInfo *) node;
+		SpecialJoinInfo *newinfo = makeNode(SpecialJoinInfo);
+
+		memcpy(newinfo, oldinfo, sizeof(SpecialJoinInfo));
+		newinfo->min_lefthand = adjust_child_relids(oldinfo->min_lefthand,
+													context->nappinfos,
+													context->appinfos);
+		newinfo->min_righthand = adjust_child_relids(oldinfo->min_righthand,
+													 context->nappinfos,
+													 context->appinfos);
+		newinfo->syn_lefthand = adjust_child_relids(oldinfo->syn_lefthand,
+													context->nappinfos,
+													context->appinfos);
+		newinfo->syn_righthand = adjust_child_relids(oldinfo->syn_righthand,
+													 context->nappinfos,
+													 context->appinfos);
+		newinfo->semi_rhs_exprs =
+					(List *) expression_tree_mutator((Node *)
+													 oldinfo->semi_rhs_exprs,
+													 adjust_appendrel_attrs_mutator,
+													 (void *) context);
+		return (Node *) newinfo;
+	}
+
+	/* Shouldn't need to handle planner auxiliary nodes here */
+	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 */
+		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->nullable_relids = adjust_child_relids(oldinfo->nullable_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));
+
+	return expression_tree_mutator(node, adjust_appendrel_attrs_mutator,
+								   (void *) context);
+}
+
+/*
+ * Substitute child relids for parent relids in a Relid set.  The array of
+ * appinfos specifies the substitutions to be performed.
+ */
+static Relids
+adjust_child_relids(Relids relids, int nappinfos, AppendRelInfo **appinfos)
+{
+	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;
+}
+
+/*
+ * Replace any relid present in top_parent_relids with its child in
+ * child_relids. Members of child_relids can be multiple levels below top
+ * parent in the partition hierarchy.
+ */
+Relids
+adjust_child_relids_multilevel(PlannerInfo *root, Relids relids,
+							   Relids child_relids, Relids top_parent_relids)
+{
+	AppendRelInfo **appinfos;
+	int			nappinfos;
+	Relids		parent_relids = NULL;
+	Relids		result;
+	Relids		tmp_result = NULL;
+	int			cnt;
+
+	/*
+	 * If the given relids set doesn't contain any of the top parent relids,
+	 * it will remain unchanged.
+	 */
+	if (!bms_overlap(relids, top_parent_relids))
+		return relids;
+
+	appinfos = find_appinfos_by_relids(root, child_relids, &nappinfos);
+
+	/* Construct relids set for the immediate parent of the given child. */
+	for (cnt = 0; cnt < nappinfos; cnt++)
+	{
+		AppendRelInfo *appinfo = appinfos[cnt];
+
+		parent_relids = bms_add_member(parent_relids, appinfo->parent_relid);
+	}
+
+	/* Recurse if immediate parent is not the top parent. */
+	if (!bms_equal(parent_relids, top_parent_relids))
+	{
+		tmp_result = adjust_child_relids_multilevel(root, relids,
+													parent_relids,
+													top_parent_relids);
+		relids = tmp_result;
+	}
+
+	result = adjust_child_relids(relids, nappinfos, appinfos);
+
+	/* Free memory consumed by any intermediate result. */
+	if (tmp_result)
+		bms_free(tmp_result);
+	bms_free(parent_relids);
+	pfree(appinfos);
+
+	return result;
+}
+
+/*
+ * adjust_appendrel_attrs_multilevel
+ *	  Apply Var translations from a toplevel appendrel parent down to a child.
+ *
+ * In some cases we need to translate expressions referencing a parent relation
+ * to reference an appendrel child that's multiple levels removed from it.
+ */
+Node *
+adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node,
+								  Relids child_relids,
+								  Relids top_parent_relids)
+{
+	AppendRelInfo **appinfos;
+	Bitmapset  *parent_relids = NULL;
+	int			nappinfos;
+	int			cnt;
+
+	Assert(bms_num_members(child_relids) == bms_num_members(top_parent_relids));
+
+	appinfos = find_appinfos_by_relids(root, child_relids, &nappinfos);
+
+	/* Construct relids set for the immediate parent of given child. */
+	for (cnt = 0; cnt < nappinfos; cnt++)
+	{
+		AppendRelInfo *appinfo = appinfos[cnt];
+
+		parent_relids = bms_add_member(parent_relids, appinfo->parent_relid);
+	}
+
+	/* Recurse if immediate parent is not the top parent. */
+	if (!bms_equal(parent_relids, top_parent_relids))
+		node = adjust_appendrel_attrs_multilevel(root, node, parent_relids,
+												 top_parent_relids);
+
+	/* Now translate for this child */
+	node = adjust_appendrel_attrs(root, node, nappinfos, appinfos);
+
+	pfree(appinfos);
+
+	return node;
+}
+
+/*
+ * Construct the SpecialJoinInfo for a child-join by translating
+ * SpecialJoinInfo for the join between parents. left_relids and right_relids
+ * are the relids of left and right side of the join respectively.
+ */
+SpecialJoinInfo *
+build_child_join_sjinfo(PlannerInfo *root, SpecialJoinInfo *parent_sjinfo,
+						Relids left_relids, Relids right_relids)
+{
+	SpecialJoinInfo *sjinfo = makeNode(SpecialJoinInfo);
+	AppendRelInfo **left_appinfos;
+	int			left_nappinfos;
+	AppendRelInfo **right_appinfos;
+	int			right_nappinfos;
+
+	memcpy(sjinfo, parent_sjinfo, sizeof(SpecialJoinInfo));
+	left_appinfos = find_appinfos_by_relids(root, left_relids,
+											&left_nappinfos);
+	right_appinfos = find_appinfos_by_relids(root, right_relids,
+											 &right_nappinfos);
+
+	sjinfo->min_lefthand = adjust_child_relids(sjinfo->min_lefthand,
+											   left_nappinfos, left_appinfos);
+	sjinfo->min_righthand = adjust_child_relids(sjinfo->min_righthand,
+												right_nappinfos,
+												right_appinfos);
+	sjinfo->syn_lefthand = adjust_child_relids(sjinfo->syn_lefthand,
+											   left_nappinfos, left_appinfos);
+	sjinfo->syn_righthand = adjust_child_relids(sjinfo->syn_righthand,
+												right_nappinfos,
+												right_appinfos);
+	sjinfo->semi_rhs_exprs = (List *) adjust_appendrel_attrs(root,
+															 (Node *) sjinfo->semi_rhs_exprs,
+															 right_nappinfos,
+															 right_appinfos);
+
+	pfree(left_appinfos);
+	pfree(right_appinfos);
+
+	return sjinfo;
+}
+
+/*
+ * find_appinfos_by_relids
+ * 		Find AppendRelInfo structures for all relations specified by relids.
+ *
+ * The AppendRelInfos are returned in an array, which can be pfree'd by the
+ * caller. *nappinfos is set to the number of entries in the array.
+ */
+AppendRelInfo **
+find_appinfos_by_relids(PlannerInfo *root, Relids relids, int *nappinfos)
+{
+	AppendRelInfo **appinfos;
+	int			cnt = 0;
+	int			i;
+
+	*nappinfos = bms_num_members(relids);
+	appinfos = (AppendRelInfo **) palloc(sizeof(AppendRelInfo *) * *nappinfos);
+
+	i = -1;
+	while ((i = bms_next_member(relids, i)) >= 0)
+	{
+		AppendRelInfo *appinfo = root->append_rel_array[i];
+
+		if (!appinfo)
+			elog(ERROR, "child rel %d not found in append_rel_array", i);
+
+		appinfos[cnt++] = appinfo;
+	}
+	return appinfos;
+}
+
+/*
+ * make_inh_translation_list
+ *	  Build the list of translations from parent Vars to child Vars for
+ *	  an inheritance child.
+ *
+ * For paranoia's sake, we match type/collation as well as attribute name.
+ */
+static void
+make_inh_translation_list(TupleDesc old_tupdesc, TupleDesc new_tupdesc,
+						  Oid from_rel, Oid to_rel,
+						  Index newvarno, List **translated_vars)
+{
+	List	   *vars = NIL;
+	int			oldnatts = old_tupdesc->natts;
+	int			newnatts = new_tupdesc->natts;
+	int			old_attno;
+	int			new_attno = 0;
+
+	for (old_attno = 0; old_attno < oldnatts; old_attno++)
+	{
+		Form_pg_attribute att;
+		char	   *attname;
+		Oid			atttypid;
+		int32		atttypmod;
+		Oid			attcollation;
+
+		att = TupleDescAttr(old_tupdesc, old_attno);
+		if (att->attisdropped)
+		{
+			/* Just put NULL into this list entry */
+			vars = lappend(vars, NULL);
+			continue;
+		}
+		attname = NameStr(att->attname);
+		atttypid = att->atttypid;
+		atttypmod = att->atttypmod;
+		attcollation = att->attcollation;
+
+		/*
+		 * When we are generating the "translation list" for the parent table
+		 * of an inheritance set, no need to search for matches.
+		 */
+		if (from_rel == to_rel)
+		{
+			vars = lappend(vars, makeVar(newvarno,
+										 (AttrNumber) (old_attno + 1),
+										 atttypid,
+										 atttypmod,
+										 attcollation,
+										 0));
+			continue;
+		}
+
+		/*
+		 * Otherwise we have to search for the matching column by name.
+		 * There's no guarantee it'll have the same column position, because
+		 * of cases like ALTER TABLE ADD COLUMN and multiple inheritance.
+		 * However, in simple cases, the relative order of columns is mostly
+		 * the same in both relations, so try the column of newrelation that
+		 * follows immediately after the one that we just found, and if that
+		 * fails, let syscache handle it.
+		 */
+		if (new_attno >= newnatts ||
+			(att = TupleDescAttr(new_tupdesc, new_attno))->attisdropped ||
+			strcmp(attname, NameStr(att->attname)) != 0)
+		{
+			HeapTuple	newtup;
+
+			newtup = SearchSysCacheAttName(to_rel, attname);
+			if (!newtup)
+				elog(ERROR, "could not find inherited attribute \"%s\" of relation \"%s\"",
+					 attname, get_rel_name(to_rel));
+			new_attno = ((Form_pg_attribute) GETSTRUCT(newtup))->attnum - 1;
+			ReleaseSysCache(newtup);
+
+			att = TupleDescAttr(new_tupdesc, new_attno);
+		}
+
+		/* Found it, check type and collation match */
+		if (atttypid != att->atttypid || atttypmod != att->atttypmod)
+			elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's type",
+				 attname, get_rel_name(to_rel));
+		if (attcollation != att->attcollation)
+			elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's collation",
+				 attname, get_rel_name(to_rel));
+
+		vars = lappend(vars, makeVar(newvarno,
+									 (AttrNumber) (new_attno + 1),
+									 atttypid,
+									 atttypmod,
+									 attcollation,
+									 0));
+		new_attno++;
+	}
+
+	*translated_vars = vars;
+}
+
+/*
+ * translate_col_privs
+ *	  Translate a bitmapset representing per-column privileges from the
+ *	  parent rel's attribute numbering to the child's.
+ *
+ * The only surprise here is that we don't translate a parent whole-row
+ * reference into a child whole-row reference.  That would mean requiring
+ * permissions on all child columns, which is overly strict, since the
+ * query is really only going to reference the inherited columns.  Instead
+ * we set the per-column bits for all inherited columns.
+ */
+Bitmapset *
+translate_col_privs(const Bitmapset *parent_privs,
+					List *translated_vars)
+{
+	Bitmapset  *child_privs = NULL;
+	bool		whole_row;
+	int			attno;
+	ListCell   *lc;
+
+	/* System attributes have the same numbers in all tables */
+	for (attno = FirstLowInvalidHeapAttributeNumber + 1; attno < 0; attno++)
+	{
+		if (bms_is_member(attno - FirstLowInvalidHeapAttributeNumber,
+						  parent_privs))
+			child_privs = bms_add_member(child_privs,
+										 attno - FirstLowInvalidHeapAttributeNumber);
+	}
+
+	/* Check if parent has whole-row reference */
+	whole_row = bms_is_member(InvalidAttrNumber - FirstLowInvalidHeapAttributeNumber,
+							  parent_privs);
+
+	/* And now translate the regular user attributes, using the vars list */
+	attno = InvalidAttrNumber;
+	foreach(lc, translated_vars)
+	{
+		Var		   *var = lfirst_node(Var, lc);
+
+		attno++;
+		if (var == NULL)		/* ignore dropped columns */
+			continue;
+		if (whole_row ||
+			bms_is_member(attno - FirstLowInvalidHeapAttributeNumber,
+						  parent_privs))
+			child_privs = bms_add_member(child_privs,
+										 var->varattno - FirstLowInvalidHeapAttributeNumber);
+	}
+
+	return child_privs;
+}
+
+/*
+ * 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.
+ */
+static List *
+adjust_inherited_tlist(List *tlist, AppendRelInfo *context)
+{
+	bool		changed_it = false;
+	ListCell   *tl;
+	List	   *new_tlist;
+	bool		more;
+	int			attrno;
+
+	/* 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)
+	{
+		TargetEntry *tle = (TargetEntry *) lfirst(tl);
+		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))
+			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);
+		if (childvar == NULL || !IsA(childvar, Var))
+			elog(ERROR, "attribute %d of relation \"%s\" does not exist",
+				 tle->resno, get_rel_name(context->parent_reloid));
+
+		if (tle->resno != childvar->varattno)
+		{
+			tle->resno = childvar->varattno;
+			changed_it = true;
+		}
+	}
+
+	/*
+	 * 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;
+
+	new_tlist = NIL;
+	more = true;
+	for (attrno = 1; more; attrno++)
+	{
+		more = false;
+		foreach(tl, tlist)
+		{
+			TargetEntry *tle = (TargetEntry *) lfirst(tl);
+
+			if (tle->resjunk)
+				continue;		/* ignore junk items */
+
+			if (tle->resno == attrno)
+				new_tlist = lappend(new_tlist, tle);
+			else if (tle->resno > attrno)
+				more = true;
+		}
+	}
+
+	foreach(tl, tlist)
+	{
+		TargetEntry *tle = (TargetEntry *) lfirst(tl);
+
+		if (!tle->resjunk)
+			continue;			/* here, ignore non-junk items */
+
+		tle->resno = attrno;
+		new_tlist = lappend(new_tlist, tle);
+		attrno++;
+	}
+
+	return new_tlist;
+}
diff --git a/src/backend/optimizer/util/pathnode.c b/src/backend/optimizer/util/pathnode.c
index d50d86b252..8ce88876c4 100644
--- a/src/backend/optimizer/util/pathnode.c
+++ b/src/backend/optimizer/util/pathnode.c
@@ -20,6 +20,7 @@
 #include "foreign/fdwapi.h"
 #include "nodes/extensible.h"
 #include "nodes/nodeFuncs.h"
+#include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index c23db9d78d..52a11f434f 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -17,6 +17,7 @@
 #include <limits.h>
 
 #include "miscadmin.h"
+#include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
diff --git a/src/backend/partitioning/partprune.c b/src/backend/partitioning/partprune.c
index fcf8d6032c..e76906da1f 100644
--- a/src/backend/partitioning/partprune.c
+++ b/src/backend/partitioning/partprune.c
@@ -44,6 +44,7 @@
 #include "miscadmin.h"
 #include "nodes/makefuncs.h"
 #include "nodes/nodeFuncs.h"
+#include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
diff --git a/src/include/optimizer/append.h b/src/include/optimizer/append.h
new file mode 100644
index 0000000000..b5f025c137
--- /dev/null
+++ b/src/include/optimizer/append.h
@@ -0,0 +1,25 @@
+/*-------------------------------------------------------------------------
+ *
+ * append.h
+ *	  prototypes for append.c.
+ *
+ *
+ * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/optimizer/append.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef APPEND_H
+#define APPEND_H
+
+#include "nodes/relation.h"
+
+/*
+ * append.c
+ *	  utilities for dealing with append relations
+ */
+extern void expand_inherited_tables(PlannerInfo *root);
+
+#endif							/* APPEND_H */
diff --git a/src/include/optimizer/appendinfo.h b/src/include/optimizer/appendinfo.h
new file mode 100644
index 0000000000..e205e78e6d
--- /dev/null
+++ b/src/include/optimizer/appendinfo.h
@@ -0,0 +1,43 @@
+/*-------------------------------------------------------------------------
+ *
+ * appendinfo.h
+ *	  Routines for mapping expressions between append rel parent(s) and
+ *	  children
+ *
+ * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/optimizer/appendinfo.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef APPENDINFO_H
+#define APPENDINFO_H
+
+#include "nodes/plannodes.h"
+#include "nodes/relation.h"
+#include "utils/relcache.h"
+
+extern AppendRelInfo *make_append_rel_info(RelOptInfo *parentrel,
+					 RangeTblEntry *parentrte,
+					 TupleDesc childdesc, Oid childoid, Oid childreltype,
+					 Index childRTindex);
+extern Bitmapset *translate_col_privs(const Bitmapset *parent_privs,
+					List *translated_vars);
+extern Node *adjust_appendrel_attrs(PlannerInfo *root, Node *node,
+					   int nappinfos, AppendRelInfo **appinfos);
+
+extern Node *adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node,
+								  Relids child_relids,
+								  Relids top_parent_relids);
+
+extern AppendRelInfo **find_appinfos_by_relids(PlannerInfo *root,
+						Relids relids, int *nappinfos);
+
+extern SpecialJoinInfo *build_child_join_sjinfo(PlannerInfo *root,
+						SpecialJoinInfo *parent_sjinfo,
+						Relids left_relids, Relids right_relids);
+extern Relids adjust_child_relids_multilevel(PlannerInfo *root, Relids relids,
+							   Relids child_relids, Relids top_parent_relids);
+
+#endif							/* APPENDINFO_H */
diff --git a/src/include/optimizer/prep.h b/src/include/optimizer/prep.h
index faae07d240..3ad9b4a77e 100644
--- a/src/include/optimizer/prep.h
+++ b/src/include/optimizer/prep.h
@@ -48,24 +48,5 @@ extern PlanRowMark *get_plan_rowmark(List *rowmarks, Index rtindex);
  */
 extern RelOptInfo *plan_set_operations(PlannerInfo *root);
 
-extern void expand_inherited_tables(PlannerInfo *root);
 
-extern Node *adjust_appendrel_attrs(PlannerInfo *root, Node *node,
-					   int nappinfos, AppendRelInfo **appinfos);
-extern AppendRelInfo *make_append_rel_info(RelOptInfo *parentrel,
-					 RangeTblEntry *parentrte,
-					 TupleDesc childdesc, Oid childoid, Oid childreltype,
-					 Index childRTindex);
-extern Node *adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node,
-								  Relids child_relids,
-								  Relids top_parent_relids);
-
-extern AppendRelInfo **find_appinfos_by_relids(PlannerInfo *root,
-						Relids relids, int *nappinfos);
-
-extern SpecialJoinInfo *build_child_join_sjinfo(PlannerInfo *root,
-						SpecialJoinInfo *parent_sjinfo,
-						Relids left_relids, Relids right_relids);
-extern Relids adjust_child_relids_multilevel(PlannerInfo *root, Relids relids,
-							   Relids child_relids, Relids top_parent_relids);
 #endif							/* PREP_H */
-- 
2.11.0

From 12797690b709a797b9fdaa5152a875416ab08f96 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Mon, 15 Oct 2018 10:59:24 +0900
Subject: [PATCH v6 5/6] Teach planner to only process unpruned partitions

This adds a bitmapset field live_parts to RelOptInfo and stores
the partition indexes of non-dummy partitions in it, meaning it
contains indexes of only those partitions that have a non-NULL
RelOptInfo present in its parent's RelOptInfo's part_rels array.

This speeds up processing partitioned table's partitions compared
to going through the whole part_rels array in a number of places.
---
 src/backend/optimizer/path/joinrels.c |  3 +++
 src/backend/optimizer/plan/planner.c  | 18 +++++++++---------
 src/backend/optimizer/util/append.c   |  8 ++++++++
 src/backend/optimizer/util/relnode.c  |  3 +++
 src/backend/partitioning/partprune.c  | 18 +++++-------------
 src/include/nodes/relation.h          |  2 ++
 6 files changed, 30 insertions(+), 22 deletions(-)

diff --git a/src/backend/optimizer/path/joinrels.c b/src/backend/optimizer/path/joinrels.c
index 6e321ec9e7..76531a05cf 100644
--- a/src/backend/optimizer/path/joinrels.c
+++ b/src/backend/optimizer/path/joinrels.c
@@ -1424,6 +1424,9 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
 		populate_joinrel_with_paths(root, child_rel1, child_rel2,
 									child_joinrel, child_sjinfo,
 									child_restrictlist);
+		if (!IS_DUMMY_REL(child_joinrel))
+			joinrel->live_parts = bms_add_member(joinrel->live_parts,
+												 cnt_parts);
 	}
 }
 
diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index a222bd8f1b..14e845f5d0 100644
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -6765,7 +6765,9 @@ apply_scanjoin_target_to_paths(PlannerInfo *root,
 		List	   *live_children = NIL;
 
 		/* Adjust each partition. */
-		for (partition_idx = 0; partition_idx < rel->nparts; partition_idx++)
+		partition_idx = -1;
+		while ((partition_idx = bms_next_member(rel->live_parts,
+												partition_idx)) >= 0)
 		{
 			RelOptInfo *child_rel = rel->part_rels[partition_idx];
 			ListCell   *lc;
@@ -6773,9 +6775,7 @@ apply_scanjoin_target_to_paths(PlannerInfo *root,
 			int			nappinfos;
 			List	   *child_scanjoin_targets = NIL;
 
-			/* Skip processing pruned partitions. */
-			if (child_rel == NULL)
-				continue;
+			Assert(child_rel != NULL);
 
 			/* Translate scan/join targets for this child. */
 			appinfos = find_appinfos_by_relids(root, child_rel->relids,
@@ -6856,7 +6856,6 @@ create_partitionwise_grouping_paths(PlannerInfo *root,
 									PartitionwiseAggregateType patype,
 									GroupPathExtraData *extra)
 {
-	int			nparts = input_rel->nparts;
 	int			cnt_parts;
 	List	   *grouped_live_children = NIL;
 	List	   *partially_grouped_live_children = NIL;
@@ -6868,7 +6867,9 @@ create_partitionwise_grouping_paths(PlannerInfo *root,
 		   partially_grouped_rel != NULL);
 
 	/* Add paths for partitionwise aggregation/grouping. */
-	for (cnt_parts = 0; cnt_parts < nparts; cnt_parts++)
+	cnt_parts = -1;
+	while ((cnt_parts = bms_next_member(input_rel->live_parts,
+										cnt_parts)) >= 0)
 	{
 		RelOptInfo *child_input_rel = input_rel->part_rels[cnt_parts];
 		PathTarget *child_target = copy_pathtarget(target);
@@ -6878,9 +6879,8 @@ create_partitionwise_grouping_paths(PlannerInfo *root,
 		RelOptInfo *child_grouped_rel;
 		RelOptInfo *child_partially_grouped_rel;
 
-		/* Skip processing pruned partitions. */
-		if (child_input_rel == NULL)
-			continue;
+		/* A live partition must have a RelOptInfo. */
+		Assert(child_input_rel != NULL);
 
 		/* Input child rel must have a path */
 		Assert(child_input_rel->pathlist != NIL);
diff --git a/src/backend/optimizer/util/append.c b/src/backend/optimizer/util/append.c
index d2ad80034f..3b3fb304b9 100644
--- a/src/backend/optimizer/util/append.c
+++ b/src/backend/optimizer/util/append.c
@@ -351,6 +351,7 @@ expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
 
 	/* Perform pruning. */
 	partindexes = prune_append_rel_partitions(parentrel);
+	parentrel->live_parts = partindexes;
 
 	/* Must expand PlannerInfo arrays before we can add children. */
 	expand_planner_arrays(root, bms_num_members(partindexes));
@@ -394,6 +395,13 @@ expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
 		Assert(childrel != NULL);
 		parentrel->part_rels[i] = childrel;
 
+		/*
+		 * If partition is excluded by constraints, remove it from
+		 * live_parts, too.
+		 */
+		if (IS_DUMMY_REL(childrel))
+			parentrel->live_parts = bms_del_member(parentrel->live_parts, i);
+
 		/* Close child relations, but keep locks */
 		heap_close(newrelation, NoLock);
 
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index 52a11f434f..6c7eafe6db 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -1748,6 +1748,9 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
 		joinrel->partexprs[cnt] = partexpr;
 		joinrel->nullable_partexprs[cnt] = nullable_partexpr;
 	}
+
+	/* Partitions will be added by try_partitionwise_join. */
+	joinrel->live_parts = NULL;
 }
 
 /*
diff --git a/src/backend/partitioning/partprune.c b/src/backend/partitioning/partprune.c
index e76906da1f..8bc2f5c5c2 100644
--- a/src/backend/partitioning/partprune.c
+++ b/src/backend/partitioning/partprune.c
@@ -441,29 +441,21 @@ make_partitionedrel_pruneinfo(PlannerInfo *root, RelOptInfo *parentrel,
 		memset(subplan_map, -1, nparts * sizeof(int));
 		subpart_map = (int *) palloc(nparts * sizeof(int));
 		memset(subpart_map, -1, nparts * sizeof(int));
-		present_parts = NULL;
+		present_parts = bms_copy(subpart->live_parts);
 
-		for (i = 0; i < nparts; i++)
+		i = -1;
+		while ((i = bms_next_member(present_parts, i)) >= 0)
 		{
 			RelOptInfo *partrel = subpart->part_rels[i];
 			int			subplanidx;
 			int			subpartidx;
 
-			/* Skip processing pruned partitions. */
-			if (partrel == NULL)
-				continue;
-
+			Assert(partrel != NULL);
 			subplan_map[i] = subplanidx = relid_subplan_map[partrel->relid] - 1;
 			subpart_map[i] = subpartidx = relid_subpart_map[partrel->relid] - 1;
+			/* Record finding this subplan */
 			if (subplanidx >= 0)
-			{
-				present_parts = bms_add_member(present_parts, i);
-
-				/* Record finding this subplan  */
 				subplansfound = bms_add_member(subplansfound, subplanidx);
-			}
-			else if (subpartidx >= 0)
-				present_parts = bms_add_member(present_parts, i);
 		}
 
 		pinfo = makeNode(PartitionedRelPruneInfo);
diff --git a/src/include/nodes/relation.h b/src/include/nodes/relation.h
index e6fdbcd030..f43fa46fc5 100644
--- a/src/include/nodes/relation.h
+++ b/src/include/nodes/relation.h
@@ -727,6 +727,8 @@ typedef struct RelOptInfo
 	Oid		   *part_oids;		/* partition OIDs */
 	struct RelOptInfo **part_rels;	/* Array of RelOptInfos of partitions,
 									 * stored in the same order of bounds */
+	Bitmapset  *live_parts;		/* Set of live partitions; contains indexes
+								 * into part_rels array */
 	List	  **partexprs;		/* Non-nullable partition key expressions. */
 	List	  **nullable_partexprs; /* Nullable partition key expressions. */
 	List	   *partitioned_child_rels; /* List of RT indexes. */
-- 
2.11.0

From d4387591743853cdaa6a21d17a3560a8e0d671d6 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Fri, 12 Oct 2018 19:12:53 +0900
Subject: [PATCH v6 6/6] Do not lock all partitions at the beginning

---
 src/backend/optimizer/util/append.c | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

diff --git a/src/backend/optimizer/util/append.c b/src/backend/optimizer/util/append.c
index 3b3fb304b9..0b0b75d409 100644
--- a/src/backend/optimizer/util/append.c
+++ b/src/backend/optimizer/util/append.c
@@ -335,10 +335,6 @@ expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
 									parentrel->inh_root_parent :
 									parentRTindex;
 
-	/* If root partitioned table, lock *all* partitions in the tree. */
-	if (parentRTindex == rootParentRTindex)
-		(void) find_all_inheritors(parentrte->relid, lockmode, NULL);
-
 	/*
 	 * Initialize partitioned_child_rels to contain this RT index.
 	 *
@@ -374,8 +370,7 @@ expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
 		RangeTblEntry *childrte;
 		Index		childRTindex;
 
-		/* Already locked above. */
-		newrelation = heap_open(childOID, NoLock);
+		newrelation = heap_open(childOID, lockmode);
 		Assert(!RELATION_IS_OTHER_TEMP(newrelation));
 
 		/*
-- 
2.11.0

From 52a66aca3b1eabdba4a151590a14b7fa013eb9f5 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Wed, 17 Oct 2018 11:18:12 +0900
Subject: [PATCH v7 1/6] Overhaul inheritance update/delete planning

With the current method, inheritance_planner, which handles the
planning for update/delete commands targeting inheritance trees,
performs the *whole* planning for each child table.  That involves
translating the query tree to set a given child table in place of
the original inheritance root table as the query's target table,
followed by calling grouping_planner on the translated query, which
performs query planning and additional steps needed to apply correct
target list based on the child target table.

That's inefficient for two reasons:

 1. partprune.c cannot be used to perform partition pruning, because
    it can only be invoked from query_planner.  With the current
    approach, query_planner only sees the individual partitions in
    the query tree it receives, not the parent partitioned table.
    This leaves each partition to be pruned using constraint
    exclusion.  (constraint exclusion cannon prune hash partitions
    which means UPDATE/DELETE don't support hash partition pruning.)

 2. Repeated invocation of query_planner results in allocating large
    amounts of memory, especially if there are many child tables.
    Also, it involves repeatedly performing the same processing,
    such as jointree processing.

This commit addresses both of the issues by rewriting portions of
inheritance_planner and adding some supporting functionality to
allpath.c.

With the new implementation, inheritance_planner calls query_planner
only once at the beginning with the original unmodified query, which
creates the access paths of individual relations after pruning any
unnecessary partitions.  For each target child relation, it also
creates a sub-PartitionInfo containing translated version of the
query and a targetlist suitable for the child.  Child PlannerInfos
are saved in the top PlannerInfo for using later.  If the query
involves join against the target relation, join paths are created
for each target child relation by  replacing the original target
table in the join tree by a given child table.  Join relations
(RelOptInfos thereof) for all target child relations are collected
in a global list in the top PlannerInfo.

After creating the join paths for all target child relations,
inheritance_planner calls grouping_planner() on each child join
relation using the previously created child PlannerInfo to finish up
the paths such that they produce query's top-level target list
expanded according to a given child relation's descriptor.
grouping_planner()'s interface is modified so that we can pass it
what's called a 'planned_rel', a RelOptInfo that already contains
the necessary paths needed to produce its output.

This removes some existing code in inheritance_planner that dealt
with any subquery RTEs in the query.  The rationale of that code
was that the subquery RTEs may change during each iteration of
planning (that is, for different children), so different iterations
better use different copies of those RTEs.  That was handled by
making fresh copies of those RTEs for each iteration of planning
which were appended to the range table, accompanied by modifying all
expressions and auxiliary structures that referenced the original
subquery RTEs to instead reference the copies (that is, change the
varnos).  This copying meant we would end up adding S * N new entries
to the original range table by the time we got to the last unpruned
child, where S is the number of subquery RTEs in the original query
and N the number of unpruned children.  Since with the new code
we perform planning just once, I think we don't need this special
handling.  Actually, there is a regression test output change due
to no longer having copies of subquery RTEs (see the diff of
partition_join.out file.)

Also we no longer need the hack in relation_excluded_by_constraints()
involving setting PlannerInfo.inhTargetKind to enable constraint
exclusion for target child relation, which is no longer
is no longer needed.  Constraint exclusion runs during query_planner
step described above.

Regression test output change in partition_join.out is due to the fact
that we no longer create duplicates of subquery RTEs in child range
tables.
---
 doc/src/sgml/ddl.sgml                        |  14 +-
 src/backend/nodes/outfuncs.c                 |   1 -
 src/backend/optimizer/path/allpaths.c        | 307 ++++++++++++++++++-
 src/backend/optimizer/plan/createplan.c      |  10 -
 src/backend/optimizer/plan/planner.c         | 428 +++++++--------------------
 src/backend/optimizer/prep/prepjointree.c    |   1 -
 src/backend/optimizer/prep/prepunion.c       |  33 ++-
 src/backend/optimizer/util/plancat.c         |  50 +---
 src/include/nodes/relation.h                 |  31 +-
 src/test/regress/expected/partition_join.out |   4 +-
 10 files changed, 472 insertions(+), 407 deletions(-)

diff --git a/doc/src/sgml/ddl.sgml b/doc/src/sgml/ddl.sgml
index c8268222af..ca7359c4a4 100644
--- a/doc/src/sgml/ddl.sgml
+++ b/doc/src/sgml/ddl.sgml
@@ -3935,15 +3935,6 @@ EXPLAIN SELECT count(*) FROM measurement WHERE logdate &gt;= DATE '2008-01-01';
 
    <note>
     <para>
-     Currently, pruning of partitions during the planning of an
-     <command>UPDATE</command> or <command>DELETE</command> command is
-     implemented using the constraint exclusion method (however, it is
-     controlled by the <literal>enable_partition_pruning</literal> rather than
-     <literal>constraint_exclusion</literal>) &mdash; see the following section
-     for details and caveats that apply.
-    </para>
-
-    <para>
      Execution-time partition pruning currently only occurs for the
      <literal>Append</literal> and <literal>MergeAppend</literal> node types.
      It is not yet implemented for the <literal>ModifyTable</literal> node
@@ -3966,9 +3957,8 @@ EXPLAIN SELECT count(*) FROM measurement WHERE logdate &gt;= DATE '2008-01-01';
 
    <para>
     <firstterm>Constraint exclusion</firstterm> is a query optimization
-    technique similar to partition pruning.  While it is primarily used
-    for partitioning implemented using the legacy inheritance method, it can be
-    used for other purposes, including with declarative partitioning.
+    technique similar to partition pruning.  It is primarily used
+    for partitioning implemented using the legacy inheritance method.
    </para>
 
    <para>
diff --git a/src/backend/nodes/outfuncs.c b/src/backend/nodes/outfuncs.c
index f0c396530d..08657fcfd9 100644
--- a/src/backend/nodes/outfuncs.c
+++ b/src/backend/nodes/outfuncs.c
@@ -2309,7 +2309,6 @@ _outPlannerInfo(StringInfo str, const PlannerInfo *node)
 	WRITE_FLOAT_FIELD(tuple_fraction, "%.4f");
 	WRITE_FLOAT_FIELD(limit_tuples, "%.0f");
 	WRITE_UINT_FIELD(qual_security_level);
-	WRITE_ENUM_FIELD(inhTargetKind, InheritanceKind);
 	WRITE_BOOL_FIELD(hasJoinRTEs);
 	WRITE_BOOL_FIELD(hasLateralRTEs);
 	WRITE_BOOL_FIELD(hasDeletedRTEs);
diff --git a/src/backend/optimizer/path/allpaths.c b/src/backend/optimizer/path/allpaths.c
index 738bb30848..7787592870 100644
--- a/src/backend/optimizer/path/allpaths.c
+++ b/src/backend/optimizer/path/allpaths.c
@@ -36,6 +36,7 @@
 #include "optimizer/pathnode.h"
 #include "optimizer/paths.h"
 #include "optimizer/plancat.h"
+#include "optimizer/planmain.h"
 #include "optimizer/planner.h"
 #include "optimizer/prep.h"
 #include "optimizer/restrictinfo.h"
@@ -93,6 +94,9 @@ static void set_foreign_pathlist(PlannerInfo *root, RelOptInfo *rel,
 					 RangeTblEntry *rte);
 static void set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 					Index rti, RangeTblEntry *rte);
+static PlannerInfo *adjust_inherit_target_child(PlannerInfo *root,
+							RelOptInfo *childrel,
+							AppendRelInfo *appinfo);
 static void set_append_rel_pathlist(PlannerInfo *root, RelOptInfo *rel,
 						Index rti, RangeTblEntry *rte);
 static void generate_mergeappend_paths(PlannerInfo *root, RelOptInfo *rel,
@@ -119,6 +123,8 @@ static void set_namedtuplestore_pathlist(PlannerInfo *root, RelOptInfo *rel,
 static void set_worktable_pathlist(PlannerInfo *root, RelOptInfo *rel,
 					   RangeTblEntry *rte);
 static RelOptInfo *make_rel_from_joinlist(PlannerInfo *root, List *joinlist);
+static void inheritance_make_rel_from_joinlist(PlannerInfo *root,
+						List *joinlist);
 static bool subquery_is_pushdown_safe(Query *subquery, Query *topquery,
 						  pushdown_safety_info *safetyInfo);
 static bool recurse_pushdown_safe(Node *setOp, Query *topquery,
@@ -217,13 +223,40 @@ make_one_rel(PlannerInfo *root, List *joinlist)
 
 	/*
 	 * Generate access paths for the entire join tree.
+	 *
+	 * For UPDATE/DELETE on an inheritance parent, join paths should be
+	 * generated for each child result rel separately.
 	 */
-	rel = make_rel_from_joinlist(root, joinlist);
+	if (root->parse->resultRelation &&
+		root->simple_rte_array[root->parse->resultRelation]->inh)
+	{
+		inheritance_make_rel_from_joinlist(root, joinlist);
 
-	/*
-	 * The result should join all and only the query's base rels.
-	 */
-	Assert(bms_equal(rel->relids, root->all_baserels));
+		/*
+		 * There should be as many child source rels as there are child
+		 * subroots.
+		 */
+		Assert(list_length(root->inh_target_child_roots) ==
+			   list_length(root->inh_target_child_rels));
+
+		/*
+		 * Return the RelOptInfo of original target relation, although this
+		 * doesn't really contain the final path.  inheritance_planner
+		 * from where we got here will generate the final path, but not
+		 * through this RelOptInfo.
+		 */
+		rel = find_base_rel(root, root->parse->resultRelation);
+	}
+	else
+	{
+		rel = make_rel_from_joinlist(root, joinlist);
+
+		/*
+		 * The result should join all and only the query's base rels.
+		 */
+		Assert(bms_equal(rel->relids, root->all_baserels));
+
+	}
 
 	return rel;
 }
@@ -1001,6 +1034,7 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 		ListCell   *parentvars;
 		ListCell   *childvars;
 		ListCell   *lc;
+		PlannerInfo *subroot = root;
 
 		/* append_rel_list contains all append rels; ignore others */
 		if (appinfo->parent_relid != parentRTindex)
@@ -1219,9 +1253,17 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 			set_rel_consider_parallel(root, childrel, childRTE);
 
 		/*
-		 * Compute the child's size.
+		 * If the parent is the result relation, we need a reltarget for the
+		 * child relation that will be suitable to use the child also as the
+		 * target relation.
 		 */
-		set_rel_size(root, childrel, childRTindex, childRTE);
+		if (appinfo->parent_relid == root->parse->resultRelation)
+			subroot = adjust_inherit_target_child(root, childrel, appinfo);
+
+		/*
+		 * Compute the child's size using possibly modified subroot.
+		 */
+		set_rel_size(subroot, childrel, childRTindex, childRTE);
 
 		/*
 		 * It is possible that constraint exclusion detected a contradiction
@@ -1231,6 +1273,26 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 		if (IS_DUMMY_REL(childrel))
 			continue;
 
+		/*
+		 * If we modified subroot for the target inheritance case, add it
+		 * to root->inh_target_child_roots.
+		 */
+		if (subroot != root)
+		{
+			root->inh_target_child_roots =
+							lappend(root->inh_target_child_roots, subroot);
+
+			/*
+			 * If the childrel itself was a partitioned table, its children
+			 * would've been added into subroot.  Copy relevant fields
+			 * into the parent root.
+			 */
+			if (subroot->inh_target_child_roots != NIL)
+				root->inh_target_child_roots =
+							list_concat(root->inh_target_child_roots,
+										subroot->inh_target_child_roots);
+		}
+
 		/* We have at least one live child. */
 		has_live_children = true;
 
@@ -1327,6 +1389,109 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 }
 
 /*
+ * adjust_inherit_target_child
+ *		For an inheritance target child relation, this adjusts its
+ *		reltarget so that it contains expressions suitable for processing as
+ *		a target relation, creates a child PlannerInfo containing translated
+ *		copy of the query and returns it.
+ *
+ * The child PlannerInfo reuses most of the parent PlannerInfo's fields
+ * unchanged, except unexpanded_tlist and processed_tlist are based on the
+ * child relation.
+ */
+static PlannerInfo *
+adjust_inherit_target_child(PlannerInfo *root, RelOptInfo *childrel,
+							AppendRelInfo *appinfo)
+{
+	PlannerInfo *subroot;
+	List	   *tlist;
+	List	   *translated_exprs;
+	ListCell   *lc2;
+
+	Assert(root->parse->commandType == CMD_UPDATE ||
+		   root->parse->commandType == CMD_DELETE);
+
+	/*
+	 * We'd like to build the reltarget afresh; save the translated
+	 * version of parent's expressions aside.
+	 */
+	translated_exprs = childrel->reltarget->exprs;
+	childrel->reltarget->exprs = NIL;
+
+	/* Translate the original query's expressions to this child. */
+	subroot = makeNode(PlannerInfo);
+	memcpy(subroot, root, sizeof(PlannerInfo));
+
+	/*
+	 * Restore the unexpanded tlist for translation, so that child's
+	 * query contains targetList numbered (resnos) per its own
+	 * TupleDesc, which adjust_inherited_tlist ensures.
+	 */
+	root->parse->targetList = root->unexpanded_tlist;
+	subroot->parse = (Query *) adjust_appendrel_attrs(root,
+													  (Node *) root->parse,
+													  1, &appinfo);
+
+	/*
+	 * Save subroot's targetlist so that childrel's own children can use it as
+	 * unexpanded tlist.  Must copy because subroot->parse->targetList will
+	 * be modified soon.
+	 */
+	subroot->unexpanded_tlist = list_copy(subroot->parse->targetList);
+
+	/*
+	 * Apply planner's expansion of targetlist, such as adding various junk
+	 * column, filling placeholder entries for dropped columns, etc., all of
+	 * which occurs with the child's TupleDesc.
+	 */
+	tlist = preprocess_targetlist(subroot);
+	subroot->processed_tlist = tlist;
+	build_base_rel_tlists(subroot, tlist);
+
+	/*
+	 * Some of the expressions in parent's reltarget might not be in the
+	 * child's freshly built reltarget expressions, because the latter only
+	 * contains those attributes that are needed to be present in the top-
+	 * level tlist (or ones that preprocess_targetlist thinks are needed to
+	 * be in the tlist.)  We may need other attributes such as those that
+	 * are required for computing WHERE clauses, which are already computed
+	 * for the parent during deconstruct_jointree processing of the original
+	 * query.  We've already got a translated copy of those attributes, from
+	 * which pick only those that are not already present.
+	 */
+	foreach(lc2, translated_exprs)
+	{
+		Expr *expr = lfirst(lc2);
+
+		if (!list_member(childrel->reltarget->exprs, expr))
+			childrel->reltarget->exprs = lappend(childrel->reltarget->exprs,
+												 expr);
+	}
+
+	/*
+	 * Set a few other fields of subroot.
+	 *
+	 * Reset inh_target_child_roots to not be same as parent root's so that
+	 * the subroots for this child's own children (if any) don't end up in
+	 * root parent's list.  We'll eventually merge all entries into one list,
+	 * but that's now now.
+	 */
+	subroot->inh_target_child_roots = NIL;
+
+	/*
+	 * Adjust all_baserels to replace the original target relation with the
+	 * child target relation.  Copy it before modifying though.
+	 */
+	subroot->all_baserels = bms_copy(root->all_baserels);
+	subroot->all_baserels = bms_del_member(subroot->all_baserels,
+										   root->parse->resultRelation);
+	subroot->all_baserels = bms_add_member(subroot->all_baserels,
+										   subroot->parse->resultRelation);
+
+	return subroot;
+}
+
+/*
  * set_append_rel_pathlist
  *	  Build access paths for an "append relation"
  */
@@ -2624,6 +2789,134 @@ generate_gather_paths(PlannerInfo *root, RelOptInfo *rel, bool override_rows)
 }
 
 /*
+ * inheritance_make_rel_from_joinlist
+ *		Perform join planning for all non-dummy leaf inheritance children
+ *		in their role as an UPDATE/DELETE query's target relation
+ *
+ * If a child relation is a partitioned table, its children are processed in
+ * turn by recursively calling this function.
+ */
+static void
+inheritance_make_rel_from_joinlist(PlannerInfo *root, List *joinlist)
+{
+	Index		resultRelation = root->parse->resultRelation;
+	ListCell   *lc;
+#ifdef USE_ASSERT_CHECKING
+	Relids	all_baserels;
+#endif
+
+	/*
+	 * For UPDATE/DELETE queries, the top parent can only ever be a table.
+	 * As a contrast, it could be a UNION ALL subquery in the case of SELECT.
+	 */
+	Assert(root->parse->commandType == CMD_UPDATE ||
+		   root->parse->commandType == CMD_DELETE);
+	Assert(planner_rt_fetch(resultRelation, root)->rtekind == RTE_RELATION);
+
+	/* Nothing to do. */
+	if (IS_DUMMY_REL(find_base_rel(root, resultRelation )))
+		return;
+
+	foreach(lc, root->inh_target_child_roots)
+	{
+		PlannerInfo *subroot = lfirst(lc);
+		RelOptInfo *childrel;
+		AppendRelInfo *appinfo;
+		List	   *translated_joinlist;
+
+		Assert(subroot->parse->resultRelation > 0);
+		childrel = find_base_rel(root, subroot->parse->resultRelation);
+		appinfo = root->append_rel_array[subroot->parse->resultRelation];
+
+		if (appinfo->parent_relid != root->parse->resultRelation)
+			continue;
+
+		/* Ignore excluded/pruned children. */
+		if (IS_DUMMY_REL(childrel))
+			continue;
+
+		/*
+		 * Modify joinlist such that relations joined to the top parent rel
+		 * appear to be joined to the child rel instead.  Do the same for
+		 * any SpecialJoinInfo structs.
+		 */
+		translated_joinlist = (List *)
+						adjust_appendrel_attrs(subroot,
+											   (Node *) joinlist,
+											   1, &appinfo);
+		subroot->join_info_list = (List *)
+						adjust_appendrel_attrs(subroot,
+											   (Node *) root->join_info_list,
+											   1, &appinfo);
+
+		/*
+		 * Sub-partitioned tables have to be processed recursively using the
+		 * translated subroot as the parent, because AppendRelInfos link
+		 * sub-partitions to their immediate parents, not the root partitioned
+		 * table.
+		 */
+		if (childrel->part_scheme != NULL)
+		{
+			inheritance_make_rel_from_joinlist(subroot, translated_joinlist);
+
+			/*
+			 * Add this child relation as a placeholder in the parent root's
+			 * inh_target_child_rels so that inheritance_planner see same
+			 * number of entries as inh_target_child_roots.
+			 */
+			root->inh_target_child_rels =
+					lappend(root->inh_target_child_rels, childrel);
+
+			/* Also propagate this child's own children into parent's list. */
+			if (subroot->inh_target_child_rels != NIL)
+				root->inh_target_child_rels =
+					list_concat(root->inh_target_child_rels,
+								subroot->inh_target_child_rels);
+			continue;
+		}
+
+		/*
+		 * Since we added the child rel directly into the join tree, we must
+		 * modify it to be a "base" rel instead of an "other" rel, which the
+		 * join planning code expects the relations being joined to be.
+		 *
+		 * NB: Do we need to change the child EC members to be marked
+		 * as non-child somehow?
+		 */
+		childrel->reloptkind = RELOPT_BASEREL;
+
+		Assert(subroot->join_rel_list == NIL);
+		Assert(subroot->join_rel_hash == NULL);
+
+		/* Perform join planning and save the resulting RelOptInfo. */
+		childrel = make_rel_from_joinlist(subroot, translated_joinlist);
+
+		/*
+		 * Remember this child target rel.  inheritance_planner will perform
+		 * the remaining steps of planning for each child relation separately.
+		 * Specifically, it will call grouping_planner on every
+		 * RelOptInfo contained in the inh_target_child_rels list, each of
+		 * which represents the source of tuples to be modified for a given
+		 * target child rel.
+		 */
+		root->inh_target_child_rels =
+						lappend(root->inh_target_child_rels, childrel);
+#ifdef USE_ASSERT_CHECKING
+		/*
+		 * The following implements essentially the same Assert as in
+		 * make_one_rel, our caller.
+		 */
+		all_baserels = bms_copy(root->all_baserels);
+		all_baserels = bms_del_member(all_baserels,
+									  root->parse->resultRelation);
+		all_baserels = bms_add_member(all_baserels,
+									  subroot->parse->resultRelation);
+		Assert(bms_equal(childrel->relids, all_baserels));
+#endif
+	}
+}
+
+/*
  * make_rel_from_joinlist
  *	  Build access paths using a "joinlist" to guide the join path search.
  *
diff --git a/src/backend/optimizer/plan/createplan.c b/src/backend/optimizer/plan/createplan.c
index da7a92081a..28c4b53fea 100644
--- a/src/backend/optimizer/plan/createplan.c
+++ b/src/backend/optimizer/plan/createplan.c
@@ -1998,12 +1998,7 @@ create_groupingsets_plan(PlannerInfo *root, GroupingSetsPath *best_path)
 	/*
 	 * During setrefs.c, we'll need the grouping_map to fix up the cols lists
 	 * in GroupingFunc nodes.  Save it for setrefs.c to use.
-	 *
-	 * This doesn't work if we're in an inheritance subtree (see notes in
-	 * create_modifytable_plan).  Fortunately we can't be because there would
-	 * never be grouping in an UPDATE/DELETE; but let's Assert that.
 	 */
-	Assert(root->inhTargetKind == INHKIND_NONE);
 	Assert(root->grouping_map == NULL);
 	root->grouping_map = grouping_map;
 
@@ -2160,12 +2155,7 @@ create_minmaxagg_plan(PlannerInfo *root, MinMaxAggPath *best_path)
 	 * with InitPlan output params.  (We can't just do that locally in the
 	 * MinMaxAgg node, because path nodes above here may have Agg references
 	 * as well.)  Save the mmaggregates list to tell setrefs.c to do that.
-	 *
-	 * This doesn't work if we're in an inheritance subtree (see notes in
-	 * create_modifytable_plan).  Fortunately we can't be because there would
-	 * never be aggregates in an UPDATE/DELETE; but let's Assert that.
 	 */
-	Assert(root->inhTargetKind == INHKIND_NONE);
 	Assert(root->minmax_aggs == NIL);
 	root->minmax_aggs = best_path->mmaggregates;
 
diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index c729a99f8b..d094b3092b 100644
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -37,6 +37,7 @@
 #ifdef OPTIMIZER_DEBUG
 #include "nodes/print.h"
 #endif
+#include "nodes/relation.h"
 #include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
@@ -126,7 +127,7 @@ static Node *preprocess_expression(PlannerInfo *root, Node *expr, int kind);
 static void preprocess_qual_conditions(PlannerInfo *root, Node *jtnode);
 static void inheritance_planner(PlannerInfo *root);
 static void grouping_planner(PlannerInfo *root, bool inheritance_update,
-				 double tuple_fraction);
+				 RelOptInfo *planned_rel, double tuple_fraction);
 static grouping_sets_data *preprocess_grouping_sets(PlannerInfo *root);
 static List *remap_to_groupclause_idx(List *groupClause, List *gsets,
 						 int *tleref_to_colnum_map);
@@ -630,7 +631,6 @@ subquery_planner(PlannerGlobal *glob, Query *parse,
 	root->grouping_map = NULL;
 	root->minmax_aggs = NIL;
 	root->qual_security_level = 0;
-	root->inhTargetKind = INHKIND_NONE;
 	root->hasRecursion = hasRecursion;
 	if (hasRecursion)
 		root->wt_param_id = SS_assign_special_param(root);
@@ -970,7 +970,7 @@ subquery_planner(PlannerGlobal *glob, Query *parse,
 		rt_fetch(parse->resultRelation, parse->rtable)->inh)
 		inheritance_planner(root);
 	else
-		grouping_planner(root, false, tuple_fraction);
+		grouping_planner(root, false, NULL, tuple_fraction);
 
 	/*
 	 * Capture the set of outer-level param IDs we have access to, for use in
@@ -1146,12 +1146,19 @@ preprocess_phv_expression(PlannerInfo *root, Expr *expr)
  *	  inheritance set.
  *
  * We have to handle this case differently from cases where a source relation
- * is an inheritance set. Source inheritance is expanded at the bottom of the
- * plan tree (see allpaths.c), but target inheritance has to be expanded at
- * the top.  The reason is that for UPDATE, each target relation needs a
- * different targetlist matching its own column set.  Fortunately,
- * the UPDATE/DELETE target can never be the nullable side of an outer join,
- * so it's OK to generate the plan this way.
+ * is an inheritance set.  That's mainly because for UPDATE, each target
+ * relation needs a different targetlist matching its own column set.  So, we
+ * must modify the source scan/join path for each target relation such that it
+ * produces the desired target list.
+ *
+ * The source scan/join paths for individual target relations are still
+ * created in allpaths.c by first expanding the inheritance in the usual way
+ * by set_append_rel_size, followed by join planning for each target relation
+ * separately in make_one_rel.  Finally, we apply grouping_planner here to each
+ * child scan/join path so that it produces the desired targetlist.
+ *
+ * Fortunately, the UPDATE/DELETE target can never be the nullable side of an
+ * outer join, so it's OK to generate the plan this way.
  *
  * Returns nothing; the useful output is in the Paths we attach to
  * the (UPPERREL_FINAL, NULL) upperrel stored in *root.
@@ -1164,14 +1171,8 @@ inheritance_planner(PlannerInfo *root)
 {
 	Query	   *parse = root->parse;
 	int			top_parentRTindex = parse->resultRelation;
-	Bitmapset  *subqueryRTindexes;
-	Bitmapset  *modifiableARIindexes;
 	int			nominalRelation = -1;
 	Index		rootRelation = 0;
-	List	   *final_rtable = NIL;
-	int			save_rel_array_size = 0;
-	RelOptInfo **save_rel_array = NULL;
-	AppendRelInfo **save_append_rel_array = NULL;
 	List	   *subpaths = NIL;
 	List	   *subroots = NIL;
 	List	   *resultRelations = NIL;
@@ -1179,70 +1180,59 @@ inheritance_planner(PlannerInfo *root)
 	List	   *returningLists = NIL;
 	List	   *rowMarks;
 	RelOptInfo *final_rel;
-	ListCell   *lc;
-	Index		rti;
+	ListCell   *lc1,
+			   *lc2;
 	RangeTblEntry *parent_rte;
-	PlannerInfo *parent_root;
-	Query	   *parent_parse;
-	Bitmapset  *parent_relids = bms_make_singleton(top_parentRTindex);
-	PlannerInfo **parent_roots = NULL;
+	List	   *tlist;
+	standard_qp_extra qp_extra;
+	RelOptInfo *planned_rel;
 
+	/* Inheritance is never used for insert. */
 	Assert(parse->commandType != CMD_INSERT);
+	parent_rte = planner_rt_fetch(top_parentRTindex, root);
 
 	/*
-	 * We generate a modified instance of the original Query for each target
-	 * relation, plan that, and put all the plans into a list that will be
-	 * controlled by a single ModifyTable node.  All the instances share the
-	 * same rangetable, but each instance must have its own set of subquery
-	 * RTEs within the finished rangetable because (1) they are likely to get
-	 * scribbled on during planning, and (2) it's not inconceivable that
-	 * subqueries could get planned differently in different cases.  We need
-	 * not create duplicate copies of other RTE kinds, in particular not the
-	 * target relations, because they don't have either of those issues.  Not
-	 * having to duplicate the target relations is important because doing so
-	 * (1) would result in a rangetable of length O(N^2) for N targets, with
-	 * at least O(N^3) work expended here; and (2) would greatly complicate
-	 * management of the rowMarks list.
+	 * Generate the access paths for all relations mentioned in the query,
+	 * including the target inheritance set.  When doing the join planning,
+	 * references in the join tree to the original target relation that's the
+	 * root parent of the inheritance tree is replaced by each of its
+	 * inheritance children and the resulting joinrel RelOptInfo's are
+	 * added to root->inh_target_child_rels.
 	 *
-	 * To begin with, generate a bitmapset of the relids of the subquery RTEs.
+	 * Final planning steps (grouping_planner) are applied to the best path
+	 * of each of those child joinrels using a modified instance of the
+	 * original query for a given child target rel.  All the paths so generated
+	 * are put into  a list that will be controlled by a single ModifyTable
+	 * node.  All the instances share the same rangetable.
 	 */
-	subqueryRTindexes = NULL;
-	rti = 1;
-	foreach(lc, parse->rtable)
-	{
-		RangeTblEntry *rte = lfirst_node(RangeTblEntry, lc);
-
-		if (rte->rtekind == RTE_SUBQUERY)
-			subqueryRTindexes = bms_add_member(subqueryRTindexes, rti);
-		rti++;
-	}
 
 	/*
-	 * Next, we want to identify which AppendRelInfo items contain references
-	 * to any of the aforesaid subquery RTEs.  These items will need to be
-	 * copied and modified to adjust their subquery references; whereas the
-	 * other ones need not be touched.  It's worth being tense over this
-	 * because we can usually avoid processing most of the AppendRelInfo
-	 * items, thereby saving O(N^2) space and time when the target is a large
-	 * inheritance tree.  We can identify AppendRelInfo items by their
-	 * child_relid, since that should be unique within the list.
+	 * Save the unexpanded version of the query's targetlist to be used below
+	 * for passing to grouping_planner for each child target relation.
 	 */
-	modifiableARIindexes = NULL;
-	if (subqueryRTindexes != NULL)
-	{
-		foreach(lc, root->append_rel_list)
-		{
-			AppendRelInfo *appinfo = lfirst_node(AppendRelInfo, lc);
+	root->unexpanded_tlist = list_copy(root->parse->targetList);
 
-			if (bms_is_member(appinfo->parent_relid, subqueryRTindexes) ||
-				bms_is_member(appinfo->child_relid, subqueryRTindexes) ||
-				bms_overlap(pull_varnos((Node *) appinfo->translated_vars),
-							subqueryRTindexes))
-				modifiableARIindexes = bms_add_member(modifiableARIindexes,
-													  appinfo->child_relid);
-		}
+	/* Do the scan/join planning. */
+	tlist = preprocess_targetlist(root);
+	root->processed_tlist = tlist;
+	qp_extra.tlist = tlist;
+	qp_extra.activeWindows = qp_extra.groupClause = NIL;
+	planned_rel = query_planner(root, tlist, standard_qp_callback, &qp_extra);
+
+	/*
+	 * If it turned out during query planning that all the children are dummy
+	 * (pruned or excluded by constraints), no need to do the steps below.
+	 * Let grouping_planner finish up the final path.
+	 */
+	if (IS_DUMMY_REL(planned_rel))
+	{
+		grouping_planner(root, false, planned_rel, 0.0);
+		return;
 	}
 
+	Assert(planned_rel->relid == top_parentRTindex);
+	Assert(planned_rel->reloptkind == RELOPT_BASEREL);
+
 	/*
 	 * If the parent RTE is a partitioned table, we should use that as the
 	 * nominal target relation, because the RTEs added for partitioned tables
@@ -1250,7 +1240,6 @@ inheritance_planner(PlannerInfo *root)
 	 * not appear anywhere else in the plan, so the confusion explained below
 	 * for non-partitioning inheritance cases is not possible.
 	 */
-	parent_rte = rt_fetch(top_parentRTindex, root->parse->rtable);
 	if (parent_rte->relkind == RELKIND_PARTITIONED_TABLE)
 	{
 		nominalRelation = top_parentRTindex;
@@ -1258,59 +1247,23 @@ inheritance_planner(PlannerInfo *root)
 	}
 
 	/*
-	 * The PlannerInfo for each child is obtained by translating the relevant
-	 * members of the PlannerInfo for its immediate parent, which we find
-	 * using the parent_relid in its AppendRelInfo.  We save the PlannerInfo
-	 * for each parent in an array indexed by relid for fast retrieval. Since
-	 * the maximum number of parents is limited by the number of RTEs in the
-	 * query, we use that number to allocate the array. An extra entry is
-	 * needed since relids start from 1.
+	 * Get on with finalizing the path for each child target relation by
+	 * calling grouping_planner on its joinrel.  Note that we're restoring
+	 * the query's targetlist to the original one for grouping_planner's
+	 * targetlist expansion steps to perform the expansion with individual
+	 * child descriptors.
 	 */
-	parent_roots = (PlannerInfo **) palloc0((list_length(parse->rtable) + 1) *
-											sizeof(PlannerInfo *));
-	parent_roots[top_parentRTindex] = root;
-
-	/*
-	 * And now we can get on with generating a plan for each child table.
-	 */
-	foreach(lc, root->append_rel_list)
+	forboth(lc1, root->inh_target_child_roots,
+			lc2, root->inh_target_child_rels)
 	{
-		AppendRelInfo *appinfo = lfirst_node(AppendRelInfo, lc);
-		PlannerInfo *subroot;
+		PlannerInfo *subroot = lfirst(lc1);
+		RelOptInfo *childrel = lfirst(lc2);
+		AppendRelInfo *appinfo;
 		RangeTblEntry *child_rte;
 		RelOptInfo *sub_final_rel;
 		Path	   *subpath;
 
-		/* append_rel_list contains all append rels; ignore others */
-		if (!bms_is_member(appinfo->parent_relid, parent_relids))
-			continue;
-
-		/*
-		 * expand_inherited_rtentry() always processes a parent before any of
-		 * that parent's children, so the parent_root for this relation should
-		 * already be available.
-		 */
-		parent_root = parent_roots[appinfo->parent_relid];
-		Assert(parent_root != NULL);
-		parent_parse = parent_root->parse;
-
-		/*
-		 * We need a working copy of the PlannerInfo so that we can control
-		 * propagation of information back to the main copy.
-		 */
-		subroot = makeNode(PlannerInfo);
-		memcpy(subroot, parent_root, sizeof(PlannerInfo));
-
-		/*
-		 * Generate modified query with this rel as target.  We first apply
-		 * adjust_appendrel_attrs, which copies the Query and changes
-		 * references to the parent RTE to refer to the current child RTE,
-		 * then fool around with subquery RTEs.
-		 */
-		subroot->parse = (Query *)
-			adjust_appendrel_attrs(parent_root,
-								   (Node *) parent_parse,
-								   1, &appinfo);
+		appinfo = root->append_rel_array[subroot->parse->resultRelation];
 
 		/*
 		 * If there are securityQuals attached to the parent, move them to the
@@ -1322,31 +1275,12 @@ inheritance_planner(PlannerInfo *root)
 		parent_rte->securityQuals = NIL;
 
 		/*
-		 * Mark whether we're planning a query to a partitioned table or an
-		 * inheritance parent.
+		 * Ignore a partitioned child.  Instead, the paths of its children will
+		 * be added to subpaths.
 		 */
-		subroot->inhTargetKind =
-			(rootRelation != 0) ? INHKIND_PARTITIONED : INHKIND_INHERITED;
-
-		/*
-		 * If this child is further partitioned, remember it as a parent.
-		 * Since a partitioned table does not have any data, we don't need to
-		 * create a plan for it, and we can stop processing it here.  We do,
-		 * however, need to remember its modified PlannerInfo for use when
-		 * processing its children, since we'll update their varnos based on
-		 * the delta from immediate parent to child, not from top to child.
-		 *
-		 * Note: a very non-obvious point is that we have not yet added
-		 * duplicate subquery RTEs to the subroot's rtable.  We mustn't,
-		 * because then its children would have two sets of duplicates,
-		 * confusing matters.
-		 */
-		if (child_rte->inh)
+		if (childrel->part_scheme)
 		{
-			Assert(child_rte->relkind == RELKIND_PARTITIONED_TABLE);
-			parent_relids = bms_add_member(parent_relids, appinfo->child_relid);
-			parent_roots[appinfo->child_relid] = subroot;
-
+			Assert(child_rte->inh);
 			continue;
 		}
 
@@ -1374,111 +1308,8 @@ inheritance_planner(PlannerInfo *root)
 		if (nominalRelation < 0)
 			nominalRelation = appinfo->child_relid;
 
-		/*
-		 * The rowMarks list might contain references to subquery RTEs, so
-		 * make a copy that we can apply ChangeVarNodes to.  (Fortunately, the
-		 * executor doesn't need to see the modified copies --- we can just
-		 * pass it the original rowMarks list.)
-		 */
-		subroot->rowMarks = copyObject(parent_root->rowMarks);
-
-		/*
-		 * The append_rel_list likewise might contain references to subquery
-		 * RTEs (if any subqueries were flattenable UNION ALLs).  So prepare
-		 * to apply ChangeVarNodes to that, too.  As explained above, we only
-		 * want to copy items that actually contain such references; the rest
-		 * can just get linked into the subroot's append_rel_list.
-		 *
-		 * If we know there are no such references, we can just use the outer
-		 * append_rel_list unmodified.
-		 */
-		if (modifiableARIindexes != NULL)
-		{
-			ListCell   *lc2;
-
-			subroot->append_rel_list = NIL;
-			foreach(lc2, parent_root->append_rel_list)
-			{
-				AppendRelInfo *appinfo2 = lfirst_node(AppendRelInfo, lc2);
-
-				if (bms_is_member(appinfo2->child_relid, modifiableARIindexes))
-					appinfo2 = copyObject(appinfo2);
-
-				subroot->append_rel_list = lappend(subroot->append_rel_list,
-												   appinfo2);
-			}
-		}
-
-		/*
-		 * Add placeholders to the child Query's rangetable list to fill the
-		 * RT indexes already reserved for subqueries in previous children.
-		 * These won't be referenced, so there's no need to make them very
-		 * valid-looking.
-		 */
-		while (list_length(subroot->parse->rtable) < list_length(final_rtable))
-			subroot->parse->rtable = lappend(subroot->parse->rtable,
-											 makeNode(RangeTblEntry));
-
-		/*
-		 * If this isn't the first child Query, generate duplicates of all
-		 * subquery RTEs, and adjust Var numbering to reference the
-		 * duplicates. To simplify the loop logic, we scan the original rtable
-		 * not the copy just made by adjust_appendrel_attrs; that should be OK
-		 * since subquery RTEs couldn't contain any references to the target
-		 * rel.
-		 */
-		if (final_rtable != NIL && subqueryRTindexes != NULL)
-		{
-			ListCell   *lr;
-
-			rti = 1;
-			foreach(lr, parent_parse->rtable)
-			{
-				RangeTblEntry *rte = lfirst_node(RangeTblEntry, lr);
-
-				if (bms_is_member(rti, subqueryRTindexes))
-				{
-					Index		newrti;
-
-					/*
-					 * The RTE can't contain any references to its own RT
-					 * index, except in its securityQuals, so we can save a
-					 * few cycles by applying ChangeVarNodes to the rest of
-					 * the rangetable before we append the RTE to it.
-					 */
-					newrti = list_length(subroot->parse->rtable) + 1;
-					ChangeVarNodes((Node *) subroot->parse, rti, newrti, 0);
-					ChangeVarNodes((Node *) subroot->rowMarks, rti, newrti, 0);
-					/* Skip processing unchanging parts of append_rel_list */
-					if (modifiableARIindexes != NULL)
-					{
-						ListCell   *lc2;
-
-						foreach(lc2, subroot->append_rel_list)
-						{
-							AppendRelInfo *appinfo2 = lfirst_node(AppendRelInfo, lc2);
-
-							if (bms_is_member(appinfo2->child_relid,
-											  modifiableARIindexes))
-								ChangeVarNodes((Node *) appinfo2, rti, newrti, 0);
-						}
-					}
-					rte = copyObject(rte);
-					ChangeVarNodes((Node *) rte->securityQuals, rti, newrti, 0);
-					subroot->parse->rtable = lappend(subroot->parse->rtable,
-													 rte);
-				}
-				rti++;
-			}
-		}
-
-		/* There shouldn't be any OJ info to translate, as yet */
-		Assert(subroot->join_info_list == NIL);
-		/* and we haven't created PlaceHolderInfos, either */
-		Assert(subroot->placeholder_list == NIL);
-
-		/* Generate Path(s) for accessing this result relation */
-		grouping_planner(subroot, true, 0.0 /* retrieve all tuples */ );
+		/* Apply the top-level targetlist to childrel's path. */
+		grouping_planner(subroot, true, childrel, 0.0);
 
 		/*
 		 * Select cheapest path in case there's more than one.  We always run
@@ -1490,45 +1321,10 @@ inheritance_planner(PlannerInfo *root)
 		subpath = sub_final_rel->cheapest_total_path;
 
 		/*
-		 * If this child rel was excluded by constraint exclusion, exclude it
-		 * from the result plan.
+		 * child rel cannot be empty, or inheritance_make_rel_from_joinlist
+		 * wouldn't have put it in the list to begin with.
 		 */
-		if (IS_DUMMY_PATH(subpath))
-			continue;
-
-		/*
-		 * If this is the first non-excluded child, its post-planning rtable
-		 * becomes the initial contents of final_rtable; otherwise, append
-		 * just its modified subquery RTEs to final_rtable.
-		 */
-		if (final_rtable == NIL)
-			final_rtable = subroot->parse->rtable;
-		else
-			final_rtable = list_concat(final_rtable,
-									   list_copy_tail(subroot->parse->rtable,
-													  list_length(final_rtable)));
-
-		/*
-		 * We need to collect all the RelOptInfos from all child plans into
-		 * the main PlannerInfo, since setrefs.c will need them.  We use the
-		 * last child's simple_rel_array (previous ones are too short), so we
-		 * have to propagate forward the RelOptInfos that were already built
-		 * in previous children.
-		 */
-		Assert(subroot->simple_rel_array_size >= save_rel_array_size);
-		for (rti = 1; rti < save_rel_array_size; rti++)
-		{
-			RelOptInfo *brel = save_rel_array[rti];
-
-			if (brel)
-				subroot->simple_rel_array[rti] = brel;
-		}
-		save_rel_array_size = subroot->simple_rel_array_size;
-		save_rel_array = subroot->simple_rel_array;
-		save_append_rel_array = subroot->append_rel_array;
-
-		/* Make sure any initplans from this rel get into the outer list */
-		root->init_plans = subroot->init_plans;
+		Assert(!IS_DUMMY_PATH(subpath));
 
 		/* Build list of sub-paths */
 		subpaths = lappend(subpaths, subpath);
@@ -1560,36 +1356,6 @@ inheritance_planner(PlannerInfo *root)
 	 */
 
 	/*
-	 * If we managed to exclude every child rel, return a dummy plan; it
-	 * doesn't even need a ModifyTable node.
-	 */
-	if (subpaths == NIL)
-	{
-		set_dummy_rel_pathlist(final_rel);
-		return;
-	}
-
-	/*
-	 * Put back the final adjusted rtable into the master copy of the Query.
-	 * (We mustn't do this if we found no non-excluded children.)
-	 */
-	parse->rtable = final_rtable;
-	root->simple_rel_array_size = save_rel_array_size;
-	root->simple_rel_array = save_rel_array;
-	root->append_rel_array = save_append_rel_array;
-
-	/* Must reconstruct master's simple_rte_array, too */
-	root->simple_rte_array = (RangeTblEntry **)
-		palloc0((list_length(final_rtable) + 1) * sizeof(RangeTblEntry *));
-	rti = 1;
-	foreach(lc, final_rtable)
-	{
-		RangeTblEntry *rte = lfirst_node(RangeTblEntry, lc);
-
-		root->simple_rte_array[rti++] = rte;
-	}
-
-	/*
 	 * If there was a FOR [KEY] UPDATE/SHARE clause, the LockRows node will
 	 * have dealt with fetching non-locked marked rows, else we need to have
 	 * ModifyTable do that.
@@ -1629,6 +1395,12 @@ inheritance_planner(PlannerInfo *root)
  * (inheritance_planner will create a single ModifyTable node covering all the
  * target tables.)
  *
+ * If non-NULL, planned_rel is a RelOptInfo containing paths for the query's
+ * top-level joinrel, which the caller produced by itself.  In that case, this
+ * function only needs to adjust the targetlist of its cheapest_total_path.
+ * The only caller that may pass such a RelOptInfo currently is
+ * inheritance_planner.
+ *
  * tuple_fraction is the fraction of tuples we expect will be retrieved.
  * tuple_fraction is interpreted as follows:
  *	  0: expect all tuples to be retrieved (normal case)
@@ -1647,6 +1419,7 @@ inheritance_planner(PlannerInfo *root)
  */
 static void
 grouping_planner(PlannerInfo *root, bool inheritance_update,
+				 RelOptInfo *planned_rel,
 				 double tuple_fraction)
 {
 	Query	   *parse = root->parse;
@@ -1659,7 +1432,7 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 	List	   *final_targets;
 	List	   *final_targets_contain_srfs;
 	bool		final_target_parallel_safe;
-	RelOptInfo *current_rel;
+	RelOptInfo *current_rel = planned_rel;
 	RelOptInfo *final_rel;
 	ListCell   *lc;
 
@@ -1699,6 +1472,7 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 		 * special work for recursive unions is the responsibility of
 		 * plan_set_operations.
 		 */
+		Assert(current_rel == NULL);
 		current_rel = plan_set_operations(root);
 
 		/*
@@ -1788,17 +1562,26 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 				parse->groupClause = preprocess_groupclause(root, NIL);
 		}
 
-		/* Preprocess targetlist */
-		tlist = preprocess_targetlist(root);
-
 		/*
-		 * We are now done hacking up the query's targetlist.  Most of the
-		 * remaining planning work will be done with the PathTarget
-		 * representation of tlists, but save aside the full representation so
-		 * that we can transfer its decoration (resnames etc) to the topmost
-		 * tlist of the finished Plan.
+		 * Preprocess targetlist, if needed.  If the caller has already done
+		 * query planning, root->processed_tlist already contain the desired
+		 * targetlist.
 		 */
-		root->processed_tlist = tlist;
+		if (planned_rel == NULL)
+		{
+			tlist = preprocess_targetlist(root);
+
+			/*
+			 * We are now done hacking up the query's targetlist.  Most of the
+			 * remaining planning work will be done with the PathTarget
+			 * representation of tlists, but save aside the full representation
+			 * so that we can transfer its decoration (resnames etc) to the
+			 * topmost tlist of the finished Plan.
+			 */
+			root->processed_tlist = tlist;
+		}
+		else
+			tlist = root->processed_tlist;
 
 		/*
 		 * Collect statistics about aggregates for estimating costs, and mark
@@ -1878,8 +1661,9 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 		 * We also generate (in standard_qp_callback) pathkey representations
 		 * of the query's sort clause, distinct clause, etc.
 		 */
-		current_rel = query_planner(root, tlist,
-									standard_qp_callback, &qp_extra);
+		if (current_rel == NULL)
+			current_rel = query_planner(root, tlist,
+										standard_qp_callback, &qp_extra);
 
 		/*
 		 * Convert the query's result tlist into PathTarget format.
diff --git a/src/backend/optimizer/prep/prepjointree.c b/src/backend/optimizer/prep/prepjointree.c
index cd6e11904e..78baec00dc 100644
--- a/src/backend/optimizer/prep/prepjointree.c
+++ b/src/backend/optimizer/prep/prepjointree.c
@@ -917,7 +917,6 @@ pull_up_simple_subquery(PlannerInfo *root, Node *jtnode, RangeTblEntry *rte,
 	subroot->grouping_map = NULL;
 	subroot->minmax_aggs = NIL;
 	subroot->qual_security_level = 0;
-	subroot->inhTargetKind = INHKIND_NONE;
 	subroot->hasRecursion = false;
 	subroot->wt_param_id = -1;
 	subroot->non_recursive_path = NULL;
diff --git a/src/backend/optimizer/prep/prepunion.c b/src/backend/optimizer/prep/prepunion.c
index d5720518a8..ef1f978889 100644
--- a/src/backend/optimizer/prep/prepunion.c
+++ b/src/backend/optimizer/prep/prepunion.c
@@ -2253,8 +2253,39 @@ adjust_appendrel_attrs_mutator(Node *node,
 											  context->appinfos);
 		return (Node *) phv;
 	}
+
+	/*
+	 * This is needed, because inheritance_make_rel_from_joinlist needs to
+	 * translate root->join_info_list executing make_rel_from_joinlist for a
+	 * given child.
+	 */
+	if (IsA(node, SpecialJoinInfo))
+	{
+		SpecialJoinInfo *oldinfo = (SpecialJoinInfo *) node;
+		SpecialJoinInfo *newinfo = makeNode(SpecialJoinInfo);
+
+		memcpy(newinfo, oldinfo, sizeof(SpecialJoinInfo));
+		newinfo->min_lefthand = adjust_child_relids(oldinfo->min_lefthand,
+													context->nappinfos,
+													context->appinfos);
+		newinfo->min_righthand = adjust_child_relids(oldinfo->min_righthand,
+													 context->nappinfos,
+													 context->appinfos);
+		newinfo->syn_lefthand = adjust_child_relids(oldinfo->syn_lefthand,
+													context->nappinfos,
+													context->appinfos);
+		newinfo->syn_righthand = adjust_child_relids(oldinfo->syn_righthand,
+													 context->nappinfos,
+													 context->appinfos);
+		newinfo->semi_rhs_exprs =
+					(List *) expression_tree_mutator((Node *)
+													 oldinfo->semi_rhs_exprs,
+													 adjust_appendrel_attrs_mutator,
+													 (void *) context);
+		return (Node *) newinfo;
+	}
+
 	/* 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));
diff --git a/src/backend/optimizer/util/plancat.c b/src/backend/optimizer/util/plancat.c
index 0c88c90de4..ed0953f9e1 100644
--- a/src/backend/optimizer/util/plancat.c
+++ b/src/backend/optimizer/util/plancat.c
@@ -1264,36 +1264,6 @@ get_relation_constraints(PlannerInfo *root,
 		}
 	}
 
-	/*
-	 * Append partition predicates, if any.
-	 *
-	 * For selects, partition pruning uses the parent table's partition bound
-	 * descriptor, instead of constraint exclusion which is driven by the
-	 * individual partition's partition constraint.
-	 */
-	if (enable_partition_pruning && root->parse->commandType != CMD_SELECT)
-	{
-		List	   *pcqual = RelationGetPartitionQual(relation);
-
-		if (pcqual)
-		{
-			/*
-			 * Run the partition quals through const-simplification similar to
-			 * check constraints.  We skip canonicalize_qual, though, because
-			 * partition quals should be in canonical form already; also,
-			 * since the qual is in implicit-AND format, we'd have to
-			 * explicitly convert it to explicit-AND format and back again.
-			 */
-			pcqual = (List *) eval_const_expressions(root, (Node *) pcqual);
-
-			/* Fix Vars to have the desired varno */
-			if (varno != 1)
-				ChangeVarNodes((Node *) pcqual, 1, varno, 0);
-
-			result = list_concat(result, pcqual);
-		}
-	}
-
 	heap_close(relation, NoLock);
 
 	return result;
@@ -1420,31 +1390,15 @@ relation_excluded_by_constraints(PlannerInfo *root,
 	switch (constraint_exclusion)
 	{
 		case CONSTRAINT_EXCLUSION_OFF:
-
-			/*
-			 * Don't prune if feature turned off -- except if the relation is
-			 * a partition.  While partprune.c-style partition pruning is not
-			 * yet in use for all cases (update/delete is not handled), it
-			 * would be a UI horror to use different user-visible controls
-			 * depending on such a volatile implementation detail.  Therefore,
-			 * for partitioned tables we use enable_partition_pruning to
-			 * control this behavior.
-			 */
-			if (root->inhTargetKind == INHKIND_PARTITIONED)
-				break;
 			return false;
 
 		case CONSTRAINT_EXCLUSION_PARTITION:
 
 			/*
 			 * When constraint_exclusion is set to 'partition' we only handle
-			 * OTHER_MEMBER_RELs, or BASERELs in cases where the result target
-			 * is an inheritance parent or a partitioned table.
+			 * OTHER_MEMBER_RELs.
 			 */
-			if ((rel->reloptkind != RELOPT_OTHER_MEMBER_REL) &&
-				!(rel->reloptkind == RELOPT_BASEREL &&
-				  root->inhTargetKind != INHKIND_NONE &&
-				  rel->relid == root->parse->resultRelation))
+			if (rel->reloptkind != RELOPT_OTHER_MEMBER_REL)
 				return false;
 			break;
 
diff --git a/src/include/nodes/relation.h b/src/include/nodes/relation.h
index 6fd24203dd..2ad3dc4711 100644
--- a/src/include/nodes/relation.h
+++ b/src/include/nodes/relation.h
@@ -319,9 +319,6 @@ typedef struct PlannerInfo
 	Index		qual_security_level;	/* minimum security_level for quals */
 	/* Note: qual_security_level is zero if there are no securityQuals */
 
-	InheritanceKind inhTargetKind;	/* indicates if the target relation is an
-									 * inheritance child or partition or a
-									 * partitioned table */
 	bool		hasJoinRTEs;	/* true if any RTEs are RTE_JOIN kind */
 	bool		hasLateralRTEs; /* true if any RTEs are marked LATERAL */
 	bool		hasDeletedRTEs; /* true if any RTE was deleted from jointree */
@@ -343,6 +340,34 @@ typedef struct PlannerInfo
 
 	/* Does this query modify any partition key columns? */
 	bool		partColsUpdated;
+
+	/*
+	 * The following fields are set during query planning portion of an
+	 * inherited UPDATE/DEELETE operation.
+	 */
+
+	/*
+	 * This stores the original version of the query's targetlist that's
+	 * not modified by the planner.
+	 */
+	List	   *unexpanded_tlist;
+
+	/*
+	 * List containing a PlannerInfo corresponding to each child target rel.
+	 * Content of each PlannerInfo is same as the parent PlannerInfo, except
+	 * for the parse tree which is a translated copy of the parent's parse
+	 * tree.
+	 */
+	List	   *inh_target_child_roots;
+
+	/*
+	 * RelOptInfos corresponding to each child target rel.  For leaf children,
+	 * it's the RelOptInfo representing the output of make_rel_from_joinlist()
+	 * called with the parent rel in the original join tree replaced by a
+	 * given leaf child.  For non-leaf children, it's the baserel RelOptInfo
+	 * itself, left as a placeholder.
+	 */
+	List	   *inh_target_child_rels;
 } PlannerInfo;
 
 
diff --git a/src/test/regress/expected/partition_join.out b/src/test/regress/expected/partition_join.out
index 3ba3aaf2d8..a539280851 100644
--- a/src/test/regress/expected/partition_join.out
+++ b/src/test/regress/expected/partition_join.out
@@ -1781,7 +1781,7 @@ WHERE EXISTS (
                Filter: (c IS NULL)
          ->  Nested Loop
                ->  Seq Scan on int4_tbl
-               ->  Subquery Scan on ss_1
+               ->  Subquery Scan on ss
                      ->  Limit
                            ->  Seq Scan on int8_tbl int8_tbl_1
    ->  Nested Loop Semi Join
@@ -1789,7 +1789,7 @@ WHERE EXISTS (
                Filter: (c IS NULL)
          ->  Nested Loop
                ->  Seq Scan on int4_tbl
-               ->  Subquery Scan on ss_2
+               ->  Subquery Scan on ss
                      ->  Limit
                            ->  Seq Scan on int8_tbl int8_tbl_2
 (28 rows)
-- 
2.11.0

From b96ef2f769ad224cad0cb5b2050f72b13e85770f Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Fri, 26 Oct 2018 16:45:59 +0900
Subject: [PATCH v7 2/6] Store inheritance root parent index in otherrel's
 RelOptInfo

Although it's set by build_simple_rel, it's not being used by any
code yet.
---
 src/backend/nodes/outfuncs.c         |  1 +
 src/backend/optimizer/util/relnode.c | 14 ++++++++++++++
 src/include/nodes/relation.h         |  4 ++++
 3 files changed, 19 insertions(+)

diff --git a/src/backend/nodes/outfuncs.c b/src/backend/nodes/outfuncs.c
index 08657fcfd9..1d7c420e75 100644
--- a/src/backend/nodes/outfuncs.c
+++ b/src/backend/nodes/outfuncs.c
@@ -2370,6 +2370,7 @@ _outRelOptInfo(StringInfo str, const RelOptInfo *node)
 	WRITE_BOOL_FIELD(consider_partitionwise_join);
 	WRITE_BITMAPSET_FIELD(top_parent_relids);
 	WRITE_NODE_FIELD(partitioned_child_rels);
+	WRITE_UINT_FIELD(inh_root_parent);
 }
 
 static void
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index 39f5729b91..29ba19349f 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -215,9 +215,23 @@ build_simple_rel(PlannerInfo *root, int relid, RelOptInfo *parent)
 			rel->top_parent_relids = parent->top_parent_relids;
 		else
 			rel->top_parent_relids = bms_copy(parent->relids);
+
+		/*
+		 * For inheritance child relations, we also set inh_root_parent.
+		 * Note that 'parent' might itself be a child (a sub-partitioned
+		 * partition), in which case we simply use its value of
+		 * inh_root_parent.
+		 */
+		if (parent->rtekind == RTE_RELATION)
+			rel->inh_root_parent = parent->inh_root_parent > 0 ?
+										parent->inh_root_parent :
+										parent->relid;
 	}
 	else
+	{
 		rel->top_parent_relids = NULL;
+		rel->inh_root_parent = 0;
+	}
 
 	/* Check type of rtable entry */
 	switch (rte->rtekind)
diff --git a/src/include/nodes/relation.h b/src/include/nodes/relation.h
index 2ad3dc4711..94f14019bd 100644
--- a/src/include/nodes/relation.h
+++ b/src/include/nodes/relation.h
@@ -728,6 +728,10 @@ typedef struct RelOptInfo
 	List	  **partexprs;		/* Non-nullable partition key expressions. */
 	List	  **nullable_partexprs; /* Nullable partition key expressions. */
 	List	   *partitioned_child_rels; /* List of RT indexes. */
+
+	Index		inh_root_parent;	/* For otherrels, this is the RT index of
+									 * inheritance table mentioned in the query
+									 * from which this relation originated */
 } RelOptInfo;
 
 /*
-- 
2.11.0

From b2ac351c356a95e32488de10fcf8dbec1816d6a7 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Wed, 17 Oct 2018 18:14:13 +0900
Subject: [PATCH v7 3/6] Lazy creation of RTEs for inheritance children

Currently, expand_inherited_tables called from subquery_planner opens
all inheritance child tables and adds them to the query's range
table and PlannerInfo in the form of AppendRelInfo's initially and
later RelOptInfo's.  For partitioning, that's pretty wasteful, because
it's possible to determine only the partitions that will need to be
scanned using partition pruning, which doesn't require opening the
partitions themselves.  However, the point at which the above
processing happens is too early to perform partition pruning.

This commit rearranges things within the planner so that inheritance
child relations can be added to the Query and PlannerInfo during
make_one_rel, just before set_base_rel_sizes is called.  Although the
late initialization approach only benefits the partitioning case, it
seems undesirable to do it only for partitioned tables, because it
means adding code to handle partitions specially at various places
within the planner.  So, *all* inheritance parent tables are expanded
in make_one_rel.  All unpruned partitions are added to Query in the
form of their RangeTblEntry's being added to the range table and to
PlannerInfo in the form of an AppendRelInfo and a RelOptInfo for each.

For partitioning, although we don't create a RangeTblEntry and
RelOptInfo for pruned partitions at make_one_rel time, partitionwise
join code relies on the fact that even though partitions may have
been pruned, they'd still own a RelOptInfo to handle the outer join
case where the pruned partition appears on the nullable side of join.
Partitionwise join code deals with that by allocating dummy
RelOptInfos for pruned partitions that are based mostly on their
parent's properties.

There are some regression test diffs:

 1. Caused by the fact that we no longer allocate a duplicate RT
    entry for a partitioned table in its role as child, as seen in
    the partition_aggregate.out test output.

 2. Those in postgres_fdw.out are caused by the fact that junk columns
    required for row marking are added to reltarget->exprs later than
    user columns, because the row marking junk columns arent added
    until after the inheritance is expanded which as of this commit
    is later than it used to be.
---
 contrib/postgres_fdw/expected/postgres_fdw.out    |  32 +-
 src/backend/optimizer/path/allpaths.c             | 222 ++----
 src/backend/optimizer/path/joinrels.c             |  62 ++
 src/backend/optimizer/plan/initsplan.c            |  58 --
 src/backend/optimizer/plan/planner.c              |  60 +-
 src/backend/optimizer/plan/setrefs.c              |   6 +
 src/backend/optimizer/prep/preptlist.c            |  15 +-
 src/backend/optimizer/prep/prepunion.c            | 852 +++++++++++++++-------
 src/backend/optimizer/util/Makefile               |   2 +-
 src/backend/optimizer/util/plancat.c              |  40 +-
 src/backend/optimizer/util/relnode.c              |  80 +-
 src/backend/partitioning/partprune.c              |  43 +-
 src/include/nodes/relation.h                      |   8 +
 src/include/optimizer/pathnode.h                  |   1 +
 src/include/optimizer/plancat.h                   |   2 +-
 src/include/optimizer/prep.h                      |   9 +-
 src/include/partitioning/partprune.h              |   2 +-
 src/test/regress/expected/partition_aggregate.out |   4 +-
 18 files changed, 882 insertions(+), 616 deletions(-)

diff --git a/contrib/postgres_fdw/expected/postgres_fdw.out b/contrib/postgres_fdw/expected/postgres_fdw.out
index 21a2ef5ad3..f546260af8 100644
--- a/contrib/postgres_fdw/expected/postgres_fdw.out
+++ b/contrib/postgres_fdw/expected/postgres_fdw.out
@@ -7085,15 +7085,15 @@ select * from bar where f1 in (select f1 from foo) for update;
                      Output: bar2.f1, bar2.f2, bar2.ctid, bar2.*, bar2.tableoid
                      Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct2 FOR UPDATE
          ->  Hash
-               Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+               Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                ->  HashAggregate
-                     Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                     Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                      Group Key: foo.f1
                      ->  Append
                            ->  Seq Scan on public.foo
-                                 Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                                 Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                            ->  Foreign Scan on public.foo2
-                                 Output: foo2.ctid, foo2.*, foo2.tableoid, foo2.f1
+                                 Output: foo2.f1, foo2.ctid, foo2.*, foo2.tableoid
                                  Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct1
 (23 rows)
 
@@ -7123,15 +7123,15 @@ select * from bar where f1 in (select f1 from foo) for share;
                      Output: bar2.f1, bar2.f2, bar2.ctid, bar2.*, bar2.tableoid
                      Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct2 FOR SHARE
          ->  Hash
-               Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+               Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                ->  HashAggregate
-                     Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                     Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                      Group Key: foo.f1
                      ->  Append
                            ->  Seq Scan on public.foo
-                                 Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                                 Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                            ->  Foreign Scan on public.foo2
-                                 Output: foo2.ctid, foo2.*, foo2.tableoid, foo2.f1
+                                 Output: foo2.f1, foo2.ctid, foo2.*, foo2.tableoid
                                  Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct1
 (23 rows)
 
@@ -7160,15 +7160,15 @@ update bar set f2 = f2 + 100 where f1 in (select f1 from foo);
          ->  Seq Scan on public.bar
                Output: bar.f1, bar.f2, bar.ctid
          ->  Hash
-               Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+               Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                ->  HashAggregate
-                     Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                     Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                      Group Key: foo.f1
                      ->  Append
                            ->  Seq Scan on public.foo
-                                 Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                                 Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                            ->  Foreign Scan on public.foo2
-                                 Output: foo2.ctid, foo2.*, foo2.tableoid, foo2.f1
+                                 Output: foo2.f1, foo2.ctid, foo2.*, foo2.tableoid
                                  Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct1
    ->  Hash Join
          Output: bar2.f1, (bar2.f2 + 100), bar2.f3, bar2.ctid, foo.ctid, foo.*, foo.tableoid
@@ -7178,15 +7178,15 @@ update bar set f2 = f2 + 100 where f1 in (select f1 from foo);
                Output: bar2.f1, bar2.f2, bar2.f3, bar2.ctid
                Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct2 FOR UPDATE
          ->  Hash
-               Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+               Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                ->  HashAggregate
-                     Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                     Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                      Group Key: foo.f1
                      ->  Append
                            ->  Seq Scan on public.foo
-                                 Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                                 Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                            ->  Foreign Scan on public.foo2
-                                 Output: foo2.ctid, foo2.*, foo2.tableoid, foo2.f1
+                                 Output: foo2.f1, foo2.ctid, foo2.*, foo2.tableoid
                                  Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct1
 (39 rows)
 
diff --git a/src/backend/optimizer/path/allpaths.c b/src/backend/optimizer/path/allpaths.c
index 7787592870..a4dd34f2cd 100644
--- a/src/backend/optimizer/path/allpaths.c
+++ b/src/backend/optimizer/path/allpaths.c
@@ -44,7 +44,6 @@
 #include "optimizer/var.h"
 #include "parser/parse_clause.h"
 #include "parser/parsetree.h"
-#include "partitioning/partprune.h"
 #include "rewrite/rewriteManip.h"
 #include "utils/lsyscache.h"
 
@@ -180,6 +179,16 @@ make_one_rel(PlannerInfo *root, List *joinlist)
 	set_base_rel_consider_startup(root);
 
 	/*
+	 * Expand RT entries that represent inherited or partitioned tables.
+	 * This will perform partition pruning on partitioned tables in the
+	 * original range table and also recursively on any child partitioned
+	 * tables that were added by the expansion of the original parent(s).
+	 * As new entries are added to the range table, various arrays in the
+	 * PlannerInfo will be expanded accordingly.
+	 */
+	expand_inherited_tables(root);
+
+	/*
 	 * Compute size estimates and consider_parallel flags for each base rel.
 	 */
 	set_base_rel_sizes(root);
@@ -404,7 +413,11 @@ set_rel_size(PlannerInfo *root, RelOptInfo *rel,
 		 */
 		set_dummy_rel_pathlist(rel);
 	}
-	else if (rte->inh)
+	/*
+	 * expand_inherited_tables may have proved that the relation is empty, so
+	 * check if it's so.
+	 */
+	else if (rte->inh && !IS_DUMMY_REL(rel))
 	{
 		/* It's an "append relation", process accordingly */
 		set_append_rel_size(root, rel, rti, rte);
@@ -957,8 +970,6 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 	double	   *parent_attrsizes;
 	int			nattrs;
 	ListCell   *l;
-	Relids		live_children = NULL;
-	bool		did_pruning = false;
 
 	/* Guard against stack overflow due to overly deep inheritance tree. */
 	check_stack_depth();
@@ -966,32 +977,6 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 	Assert(IS_SIMPLE_REL(rel));
 
 	/*
-	 * Initialize partitioned_child_rels to contain this RT index.
-	 *
-	 * Note that during the set_append_rel_pathlist() phase, we will bubble up
-	 * the indexes of partitioned relations that appear down in the tree, so
-	 * that when we've created Paths for all the children, the root
-	 * partitioned table's list will contain all such indexes.
-	 */
-	if (rte->relkind == RELKIND_PARTITIONED_TABLE)
-		rel->partitioned_child_rels = list_make1_int(rti);
-
-	/*
-	 * If the partitioned relation has any baserestrictinfo quals then we
-	 * attempt to use these quals to prune away partitions that cannot
-	 * possibly contain any tuples matching these quals.  In this case we'll
-	 * store the relids of all partitions which could possibly contain a
-	 * matching tuple, and skip anything else in the loop below.
-	 */
-	if (enable_partition_pruning &&
-		rte->relkind == RELKIND_PARTITIONED_TABLE &&
-		rel->baserestrictinfo != NIL)
-	{
-		live_children = prune_append_rel_partitions(rel);
-		did_pruning = true;
-	}
-
-	/*
 	 * If this is a partitioned baserel, set the consider_partitionwise_join
 	 * flag; currently, we only consider partitionwise joins with the baserel
 	 * if its targetlist doesn't contain a whole-row Var.
@@ -1028,12 +1013,8 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 		int			childRTindex;
 		RangeTblEntry *childRTE;
 		RelOptInfo *childrel;
-		List	   *childquals;
-		Index		cq_min_security;
-		bool		have_const_false_cq;
 		ListCell   *parentvars;
 		ListCell   *childvars;
-		ListCell   *lc;
 		PlannerInfo *subroot = root;
 
 		/* append_rel_list contains all append rels; ignore others */
@@ -1042,18 +1023,34 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 
 		childRTindex = appinfo->child_relid;
 		childRTE = root->simple_rte_array[childRTindex];
+		Assert(childRTE != NULL);
 
 		/*
-		 * The child rel's RelOptInfo was already created during
-		 * add_base_rels_to_query.
+		 * The child rel's RelOptInfo is created during
+		 * expand_inherited_tables().
 		 */
 		childrel = find_base_rel(root, childRTindex);
 		Assert(childrel->reloptkind == RELOPT_OTHER_MEMBER_REL);
 
 		/*
-		 * Copy/Modify targetlist. Even if this child is deemed empty, we need
-		 * its targetlist in case it falls on nullable side in a child-join
-		 * because of partitionwise join.
+		 * Child relation may have be marked dummy if build_append_child_rel
+		 * found self-contradictory quals.
+		 */
+		if (IS_DUMMY_REL(childrel))
+			continue;
+
+		if (relation_excluded_by_constraints(root, childrel, childRTE))
+		{
+			/*
+			 * This child need not be scanned, so we can omit it from the
+			 * appendrel.
+			 */
+			set_dummy_rel_pathlist(childrel);
+			continue;
+		}
+
+		/*
+		 * Copy/Modify targetlist.
 		 *
 		 * NB: the resulting childrel->reltarget->exprs may contain arbitrary
 		 * expressions, which otherwise would not occur in a rel's targetlist.
@@ -1082,144 +1079,6 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 			add_child_rel_equivalences(root, appinfo, rel, childrel);
 		childrel->has_eclass_joins = rel->has_eclass_joins;
 
-		/*
-		 * We have to copy the parent's quals to the child, with appropriate
-		 * substitution of variables.  However, only the baserestrictinfo
-		 * quals are needed before we can check for constraint exclusion; so
-		 * do that first and then check to see if we can disregard this child.
-		 *
-		 * The child rel's targetlist might contain non-Var expressions, which
-		 * means that substitution into the quals could produce opportunities
-		 * for const-simplification, and perhaps even pseudoconstant quals.
-		 * Therefore, transform each RestrictInfo separately to see if it
-		 * reduces to a constant or pseudoconstant.  (We must process them
-		 * separately to keep track of the security level of each qual.)
-		 */
-		childquals = NIL;
-		cq_min_security = UINT_MAX;
-		have_const_false_cq = false;
-		foreach(lc, rel->baserestrictinfo)
-		{
-			RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
-			Node	   *childqual;
-			ListCell   *lc2;
-
-			Assert(IsA(rinfo, RestrictInfo));
-			childqual = adjust_appendrel_attrs(root,
-											   (Node *) rinfo->clause,
-											   1, &appinfo);
-			childqual = eval_const_expressions(root, childqual);
-			/* check for flat-out constant */
-			if (childqual && IsA(childqual, Const))
-			{
-				if (((Const *) childqual)->constisnull ||
-					!DatumGetBool(((Const *) childqual)->constvalue))
-				{
-					/* Restriction reduces to constant FALSE or NULL */
-					have_const_false_cq = true;
-					break;
-				}
-				/* Restriction reduces to constant TRUE, so drop it */
-				continue;
-			}
-			/* might have gotten an AND clause, if so flatten it */
-			foreach(lc2, make_ands_implicit((Expr *) childqual))
-			{
-				Node	   *onecq = (Node *) lfirst(lc2);
-				bool		pseudoconstant;
-
-				/* check for pseudoconstant (no Vars or volatile functions) */
-				pseudoconstant =
-					!contain_vars_of_level(onecq, 0) &&
-					!contain_volatile_functions(onecq);
-				if (pseudoconstant)
-				{
-					/* tell createplan.c to check for gating quals */
-					root->hasPseudoConstantQuals = true;
-				}
-				/* reconstitute RestrictInfo with appropriate properties */
-				childquals = lappend(childquals,
-									 make_restrictinfo((Expr *) onecq,
-													   rinfo->is_pushed_down,
-													   rinfo->outerjoin_delayed,
-													   pseudoconstant,
-													   rinfo->security_level,
-													   NULL, NULL, NULL));
-				/* track minimum security level among child quals */
-				cq_min_security = Min(cq_min_security, rinfo->security_level);
-			}
-		}
-
-		/*
-		 * In addition to the quals inherited from the parent, we might have
-		 * securityQuals associated with this particular child node.
-		 * (Currently this can only happen in appendrels originating from
-		 * UNION ALL; inheritance child tables don't have their own
-		 * securityQuals, see expand_inherited_rtentry().)	Pull any such
-		 * securityQuals up into the baserestrictinfo for the child.  This is
-		 * similar to process_security_barrier_quals() for the parent rel,
-		 * except that we can't make any general deductions from such quals,
-		 * since they don't hold for the whole appendrel.
-		 */
-		if (childRTE->securityQuals)
-		{
-			Index		security_level = 0;
-
-			foreach(lc, childRTE->securityQuals)
-			{
-				List	   *qualset = (List *) lfirst(lc);
-				ListCell   *lc2;
-
-				foreach(lc2, qualset)
-				{
-					Expr	   *qual = (Expr *) lfirst(lc2);
-
-					/* not likely that we'd see constants here, so no check */
-					childquals = lappend(childquals,
-										 make_restrictinfo(qual,
-														   true, false, false,
-														   security_level,
-														   NULL, NULL, NULL));
-					cq_min_security = Min(cq_min_security, security_level);
-				}
-				security_level++;
-			}
-			Assert(security_level <= root->qual_security_level);
-		}
-
-		/*
-		 * OK, we've got all the baserestrictinfo quals for this child.
-		 */
-		childrel->baserestrictinfo = childquals;
-		childrel->baserestrict_min_security = cq_min_security;
-
-		if (have_const_false_cq)
-		{
-			/*
-			 * Some restriction clause reduced to constant FALSE or NULL after
-			 * substitution, so this child need not be scanned.
-			 */
-			set_dummy_rel_pathlist(childrel);
-			continue;
-		}
-
-		if (did_pruning && !bms_is_member(appinfo->child_relid, live_children))
-		{
-			/* This partition was pruned; skip it. */
-			set_dummy_rel_pathlist(childrel);
-			continue;
-		}
-
-		if (relation_excluded_by_constraints(root, childrel, childRTE))
-		{
-			/*
-			 * This child need not be scanned, so we can omit it from the
-			 * appendrel.
-			 */
-			set_dummy_rel_pathlist(childrel);
-			continue;
-		}
-
 		/* CE failed, so finish copying/modifying join quals. */
 		childrel->joininfo = (List *)
 			adjust_appendrel_attrs(root,
@@ -1284,8 +1143,7 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 
 			/*
 			 * If the childrel itself was a partitioned table, its children
-			 * would've been added into subroot.  Copy relevant fields
-			 * into the parent root.
+			 * would've been added into subroot.
 			 */
 			if (subroot->inh_target_child_roots != NIL)
 				root->inh_target_child_roots =
@@ -1442,9 +1300,10 @@ adjust_inherit_target_child(PlannerInfo *root, RelOptInfo *childrel,
 	/*
 	 * Apply planner's expansion of targetlist, such as adding various junk
 	 * column, filling placeholder entries for dropped columns, etc., all of
-	 * which occurs with the child's TupleDesc.
+	 * which occurs with the child's TupleDesc.  Since inheritance has already
+	 * been expanded (we wouldn't be here otherwise), pass true.
 	 */
-	tlist = preprocess_targetlist(subroot);
+	tlist = preprocess_targetlist(subroot, true);
 	subroot->processed_tlist = tlist;
 	build_base_rel_tlists(subroot, tlist);
 
@@ -2826,6 +2685,7 @@ inheritance_make_rel_from_joinlist(PlannerInfo *root, List *joinlist)
 
 		Assert(subroot->parse->resultRelation > 0);
 		childrel = find_base_rel(root, subroot->parse->resultRelation);
+		Assert(childrel != NULL);
 		appinfo = root->append_rel_array[subroot->parse->resultRelation];
 
 		if (appinfo->parent_relid != root->parse->resultRelation)
diff --git a/src/backend/optimizer/path/joinrels.c b/src/backend/optimizer/path/joinrels.c
index d3d21fed5d..da0831de4e 100644
--- a/src/backend/optimizer/path/joinrels.c
+++ b/src/backend/optimizer/path/joinrels.c
@@ -20,6 +20,7 @@
 #include "optimizer/pathnode.h"
 #include "optimizer/paths.h"
 #include "optimizer/prep.h"
+#include "optimizer/tlist.h"
 #include "partitioning/partbounds.h"
 #include "utils/lsyscache.h"
 #include "utils/memutils.h"
@@ -46,6 +47,9 @@ static void try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1,
 					   List *parent_restrictlist);
 static int match_expr_to_partition_keys(Expr *expr, RelOptInfo *rel,
 							 bool strict_op);
+static RelOptInfo *build_dummy_partition_rel(PlannerInfo *root,
+									RelOptInfo *parent,
+									int partidx);
 
 
 /*
@@ -1376,6 +1380,11 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
 		AppendRelInfo **appinfos;
 		int			nappinfos;
 
+		if (child_rel1 == NULL)
+			child_rel1 = build_dummy_partition_rel(root, rel1, cnt_parts);
+		if (child_rel2 == NULL)
+			child_rel2 = build_dummy_partition_rel(root, rel2, cnt_parts);
+
 		/* We should never try to join two overlapping sets of rels. */
 		Assert(!bms_overlap(child_rel1->relids, child_rel2->relids));
 		child_joinrelids = bms_union(child_rel1->relids, child_rel2->relids);
@@ -1582,3 +1591,56 @@ match_expr_to_partition_keys(Expr *expr, RelOptInfo *rel, bool strict_op)
 
 	return -1;
 }
+
+/*
+ * build_dummy_partition_rel
+ *		Build a RelOptInfo and AppendRelInfo for a pruned partition
+ *
+ * This does not result in opening the relation or a range table entry being
+ * created.  Also, the RelOptInfo thus created is not stored anywhere else
+ * beside the parent's part_rels array.
+ *
+ * The only reason this exists is because partition-wise join, in some cases,
+ * needs a RelOptInfo to represent an empty relation that's on the nullable
+ * side of an outer join, so that a Path representing the outer join can be
+ * created.
+ */
+RelOptInfo *
+build_dummy_partition_rel(PlannerInfo *root, RelOptInfo *parent, int partidx)
+{
+	RangeTblEntry *parentrte = root->simple_rte_array[parent->relid];
+	RelOptInfo *rel;
+
+	Assert(parent->part_rels[partidx] == NULL);
+
+	/* Create minimally valid-looking RelOptInfo with parent's relid. */
+	rel = makeNode(RelOptInfo);
+	rel->reloptkind = RELOPT_OTHER_MEMBER_REL;
+	rel->relid = parent->relid;
+	rel->relids = bms_copy(parent->relids);
+	if (parent->top_parent_relids)
+		rel->top_parent_relids = parent->top_parent_relids;
+	else
+		rel->top_parent_relids = bms_copy(parent->relids);
+	rel->reltarget = copy_pathtarget(parent->reltarget);
+	parent->part_rels[partidx] = rel;
+	mark_dummy_rel(rel);
+
+	/*
+	 * Now we'll need a (no-op) AppendRelInfo for parent, because we're
+	 * setting the dummy partition's relid to be same as the parent's.
+	 */
+	if (root->append_rel_array[parent->relid] == NULL)
+	{
+		/* Pass parent's info as for both the parent rel and child rel. */
+		AppendRelInfo *appinfo = make_append_rel_info(parent, parentrte,
+													  parent->tupdesc,
+													  parentrte->relid,
+													  parent->reltype,
+													  parent->relid);
+
+		root->append_rel_array[parent->relid] = appinfo;
+	}
+
+	return rel;
+}
diff --git a/src/backend/optimizer/plan/initsplan.c b/src/backend/optimizer/plan/initsplan.c
index 01335db511..7636aa82c4 100644
--- a/src/backend/optimizer/plan/initsplan.c
+++ b/src/backend/optimizer/plan/initsplan.c
@@ -616,64 +616,6 @@ create_lateral_join_info(PlannerInfo *root)
 				bms_add_member(brel2->lateral_referencers, rti);
 		}
 	}
-
-	/*
-	 * Lastly, propagate lateral_relids and lateral_referencers from appendrel
-	 * parent rels to their child rels.  We intentionally give each child rel
-	 * the same minimum parameterization, even though it's quite possible that
-	 * some don't reference all the lateral rels.  This is because any append
-	 * path for the parent will have to have the same parameterization for
-	 * every child anyway, and there's no value in forcing extra
-	 * reparameterize_path() calls.  Similarly, a lateral reference to the
-	 * parent prevents use of otherwise-movable join rels for each child.
-	 */
-	for (rti = 1; rti < root->simple_rel_array_size; rti++)
-	{
-		RelOptInfo *brel = root->simple_rel_array[rti];
-		RangeTblEntry *brte = root->simple_rte_array[rti];
-
-		/*
-		 * Skip empty slots. Also skip non-simple relations i.e. dead
-		 * relations.
-		 */
-		if (brel == NULL || !IS_SIMPLE_REL(brel))
-			continue;
-
-		/*
-		 * In the case of table inheritance, the parent RTE is directly linked
-		 * to every child table via an AppendRelInfo.  In the case of table
-		 * partitioning, the inheritance hierarchy is expanded one level at a
-		 * time rather than flattened.  Therefore, an other member rel that is
-		 * a partitioned table may have children of its own, and must
-		 * therefore be marked with the appropriate lateral info so that those
-		 * children eventually get marked also.
-		 */
-		Assert(brte);
-		if (brel->reloptkind == RELOPT_OTHER_MEMBER_REL &&
-			(brte->rtekind != RTE_RELATION ||
-			 brte->relkind != RELKIND_PARTITIONED_TABLE))
-			continue;
-
-		if (brte->inh)
-		{
-			foreach(lc, root->append_rel_list)
-			{
-				AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(lc);
-				RelOptInfo *childrel;
-
-				if (appinfo->parent_relid != rti)
-					continue;
-				childrel = root->simple_rel_array[appinfo->child_relid];
-				Assert(childrel->reloptkind == RELOPT_OTHER_MEMBER_REL);
-				Assert(childrel->direct_lateral_relids == NULL);
-				childrel->direct_lateral_relids = brel->direct_lateral_relids;
-				Assert(childrel->lateral_relids == NULL);
-				childrel->lateral_relids = brel->lateral_relids;
-				Assert(childrel->lateral_referencers == NULL);
-				childrel->lateral_referencers = brel->lateral_referencers;
-			}
-		}
-	}
 }
 
 
diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index d094b3092b..5747694f63 100644
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -23,6 +23,7 @@
 #include "access/sysattr.h"
 #include "access/xact.h"
 #include "catalog/pg_constraint.h"
+#include "catalog/pg_inherits.h"
 #include "catalog/pg_proc.h"
 #include "catalog/pg_type.h"
 #include "executor/executor.h"
@@ -699,27 +700,24 @@ subquery_planner(PlannerGlobal *glob, Query *parse,
 		}
 		if (rte->lateral)
 			root->hasLateralRTEs = true;
+
+		/*
+		 * While at it, also update the inh status.  If the relation doesn't
+		 * or can't have any children, there is no point in letting inh be set
+		 * to true.  Note that we do this before processing rowmarks, so that
+		 * the correct information for setting isParent field of PlanRowMarks.
+		 */
+		if (rte->rtekind == RTE_RELATION)
+			rte->inh = rte->inh && has_subclass(rte->relid);
 	}
 
 	/*
 	 * Preprocess RowMark information.  We need to do this after subquery
-	 * pullup (so that all non-inherited RTEs are present) and before
-	 * inheritance expansion (so that the info is available for
-	 * expand_inherited_tables to examine and modify).
+	 * pullup (so that all non-inherited RTEs are present).
 	 */
 	preprocess_rowmarks(root);
 
 	/*
-	 * Expand any rangetable entries that are inheritance sets into "append
-	 * relations".  This can add entries to the rangetable, but they must be
-	 * plain base relations not joins, so it's OK (and marginally more
-	 * efficient) to do it after checking for join RTEs.  We must do it after
-	 * pulling up subqueries, else we'd fail to handle inherited tables in
-	 * subqueries.
-	 */
-	expand_inherited_tables(root);
-
-	/*
 	 * Set hasHavingQual to remember if HAVING clause is present.  Needed
 	 * because preprocess_expression will reduce a constant-true condition to
 	 * an empty qual list ... but "HAVING TRUE" is not a semantic no-op.
@@ -1212,8 +1210,11 @@ inheritance_planner(PlannerInfo *root)
 	 */
 	root->unexpanded_tlist = list_copy(root->parse->targetList);
 
-	/* Do the scan/join planning. */
-	tlist = preprocess_targetlist(root);
+	/*
+	 * Do the scan/join planning.  We haven't expanded inheritance yet, so
+	 * pass false.
+	 */
+	tlist = preprocess_targetlist(root, false);
 	root->processed_tlist = tlist;
 	qp_extra.tlist = tlist;
 	qp_extra.activeWindows = qp_extra.groupClause = NIL;
@@ -1222,9 +1223,10 @@ inheritance_planner(PlannerInfo *root)
 	/*
 	 * If it turned out during query planning that all the children are dummy
 	 * (pruned or excluded by constraints), no need to do the steps below.
-	 * Let grouping_planner finish up the final path.
+	 * For regular inheritance case, it's possible that we only need to modify
+	 * the parent table.  Let grouping_planner finish up the final path.
 	 */
-	if (IS_DUMMY_REL(planned_rel))
+	if (!parent_rte->inh || IS_DUMMY_REL(planned_rel))
 	{
 		grouping_planner(root, false, planned_rel, 0.0);
 		return;
@@ -1569,7 +1571,8 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 		 */
 		if (planned_rel == NULL)
 		{
-			tlist = preprocess_targetlist(root);
+			/* We haven't expanded inheritance yet, so pass false. */
+			tlist = preprocess_targetlist(root, false);
 
 			/*
 			 * We are now done hacking up the query's targetlist.  Most of the
@@ -1666,6 +1669,15 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 										standard_qp_callback, &qp_extra);
 
 		/*
+		 * Query planning may have added some columns to the top-level tlist,
+		 * which happens when there are row marks applied to inheritance
+		 * parent relations (additional junk columns needed for applying row
+		 * marks are added after expanding inheritance.)
+		 */
+		if (list_length(tlist) < list_length(root->processed_tlist))
+			tlist = root->processed_tlist;
+
+		/*
 		 * Convert the query's result tlist into PathTarget format.
 		 *
 		 * Note: it's desirable to not do this till after query_planner(),
@@ -2352,7 +2364,7 @@ preprocess_rowmarks(PlannerInfo *root)
 		newrc->allMarkTypes = (1 << newrc->markType);
 		newrc->strength = rc->strength;
 		newrc->waitPolicy = rc->waitPolicy;
-		newrc->isParent = false;
+		newrc->isParent = rte->inh;
 
 		prowmarks = lappend(prowmarks, newrc);
 	}
@@ -2377,7 +2389,7 @@ preprocess_rowmarks(PlannerInfo *root)
 		newrc->allMarkTypes = (1 << newrc->markType);
 		newrc->strength = LCS_NONE;
 		newrc->waitPolicy = LockWaitBlock;	/* doesn't matter */
-		newrc->isParent = false;
+		newrc->isParent = rte->rtekind == RTE_RELATION ? rte->inh : false;
 
 		prowmarks = lappend(prowmarks, newrc);
 	}
@@ -6757,6 +6769,10 @@ apply_scanjoin_target_to_paths(PlannerInfo *root,
 			int			nappinfos;
 			List	   *child_scanjoin_targets = NIL;
 
+			/* Skip processing pruned partitions. */
+			if (child_rel == NULL)
+				continue;
+
 			/* Translate scan/join targets for this child. */
 			appinfos = find_appinfos_by_relids(root, child_rel->relids,
 											   &nappinfos);
@@ -6858,6 +6874,10 @@ create_partitionwise_grouping_paths(PlannerInfo *root,
 		RelOptInfo *child_grouped_rel;
 		RelOptInfo *child_partially_grouped_rel;
 
+		/* Skip processing pruned partitions. */
+		if (child_input_rel == NULL)
+			continue;
+
 		/* Input child rel must have a path */
 		Assert(child_input_rel->pathlist != NIL);
 
diff --git a/src/backend/optimizer/plan/setrefs.c b/src/backend/optimizer/plan/setrefs.c
index 6d6ef1c376..454870609a 100644
--- a/src/backend/optimizer/plan/setrefs.c
+++ b/src/backend/optimizer/plan/setrefs.c
@@ -326,6 +326,12 @@ add_rtes_to_flat_rtable(PlannerInfo *root, bool recursing)
 													  UPPERREL_FINAL, NULL)))
 					add_rtes_to_flat_rtable(rel->subroot, true);
 			}
+			/*
+			 * A NULL rel also means an unplanned subquery rte, so apply
+			 * flatten_unplanned_rtes.
+			 */
+			else
+				flatten_unplanned_rtes(glob, rte);
 		}
 		rti++;
 	}
diff --git a/src/backend/optimizer/prep/preptlist.c b/src/backend/optimizer/prep/preptlist.c
index 8603feef2b..0747403acd 100644
--- a/src/backend/optimizer/prep/preptlist.c
+++ b/src/backend/optimizer/prep/preptlist.c
@@ -65,9 +65,13 @@ static List *expand_targetlist(List *tlist, int command_type,
  *
  * As a side effect, if there's an ON CONFLICT UPDATE clause, its targetlist
  * is also preprocessed (and updated in-place).
+ *
+ * inheritance_expanded specifies whether inheritance tables are expanded
+ * as of calling this function.  Caller must specify it because that affects
+ * which row marking related junk columns get added to the targetlist.
  */
 List *
-preprocess_targetlist(PlannerInfo *root)
+preprocess_targetlist(PlannerInfo *root, bool inheritance_expanded)
 {
 	Query	   *parse = root->parse;
 	int			result_relation = parse->resultRelation;
@@ -134,6 +138,15 @@ preprocess_targetlist(PlannerInfo *root)
 		if (rc->rti != rc->prti)
 			continue;
 
+		/*
+		 * For inheritance parent row marks, we defer adding junk columns
+		 * until we've added child row marks, because some children might
+		 * require different row mark types which will change the parent row
+		 * mark's allMarkTypes fields.
+		 */
+		if (rc->isParent && !inheritance_expanded)
+			continue;
+
 		if (rc->allMarkTypes & ~(1 << ROW_MARK_COPY))
 		{
 			/* Need to fetch TID */
diff --git a/src/backend/optimizer/prep/prepunion.c b/src/backend/optimizer/prep/prepunion.c
index ef1f978889..e4d4e7d6dd 100644
--- a/src/backend/optimizer/prep/prepunion.c
+++ b/src/backend/optimizer/prep/prepunion.c
@@ -39,15 +39,19 @@
 #include "miscadmin.h"
 #include "nodes/makefuncs.h"
 #include "nodes/nodeFuncs.h"
+#include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
 #include "optimizer/paths.h"
 #include "optimizer/planmain.h"
 #include "optimizer/planner.h"
 #include "optimizer/prep.h"
+#include "optimizer/restrictinfo.h"
 #include "optimizer/tlist.h"
+#include "optimizer/var.h"
 #include "parser/parse_coerce.h"
 #include "parser/parsetree.h"
+#include "partitioning/partprune.h"
 #include "utils/lsyscache.h"
 #include "utils/rel.h"
 #include "utils/selfuncs.h"
@@ -99,23 +103,26 @@ static List *generate_append_tlist(List *colTypes, List *colCollations,
 					  List *input_tlists,
 					  List *refnames_tlist);
 static List *generate_setop_grouplist(SetOperationStmt *op, List *targetlist);
+static void expand_append_rtentry(PlannerInfo *root, RelOptInfo *rel,
+					  RangeTblEntry *rte, Index rti);
 static void expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte,
-						 Index rti);
+						 Index rti, RelOptInfo *rel);
 static void expand_partitioned_rtentry(PlannerInfo *root,
 						   RangeTblEntry *parentrte,
-						   Index parentRTindex, Relation parentrel,
-						   PlanRowMark *top_parentrc, LOCKMODE lockmode,
-						   List **appinfos);
-static void expand_single_inheritance_child(PlannerInfo *root,
-								RangeTblEntry *parentrte,
-								Index parentRTindex, Relation parentrel,
-								PlanRowMark *top_parentrc, Relation childrel,
-								List **appinfos, RangeTblEntry **childrte_p,
-								Index *childRTindex_p);
-static void make_inh_translation_list(Relation oldrelation,
-						  Relation newrelation,
-						  Index newvarno,
-						  List **translated_vars);
+						   Index parentRTindex, RelOptInfo *parentrel);
+static RelOptInfo *add_inheritance_child_rel(PlannerInfo *root,
+						  RangeTblEntry *parentrte,
+						  Index parentRTindex, RelOptInfo *parentrel,
+						  PlanRowMark *top_parentrc, Relation childrel,
+						  RangeTblEntry **childrte_p, Index *childRTindex_p);
+static void make_inh_translation_list(TupleDesc old_tupdesc,
+						  TupleDesc new_tupdesc,
+						  Oid from_rel, Oid to_rel,
+						  Index newvarno, List **translated_vars);
+static RelOptInfo *build_append_child_rel(PlannerInfo *root,
+					   RelOptInfo *parent,
+					   Index childRTindex);
+static List *add_rowmark_junk_columns(PlannerInfo *root, PlanRowMark *rc);
 static Bitmapset *translate_col_privs(const Bitmapset *parent_privs,
 					List *translated_vars);
 static Node *adjust_appendrel_attrs_mutator(Node *node,
@@ -1472,33 +1479,134 @@ generate_setop_grouplist(SetOperationStmt *op, List *targetlist)
 void
 expand_inherited_tables(PlannerInfo *root)
 {
-	Index		nrtes;
+	int			orig_rtable_size;
 	Index		rti;
-	ListCell   *rl;
+
+	Assert(root->simple_rel_array_size > 0);
+	orig_rtable_size = root->simple_rel_array_size;
 
 	/*
-	 * expand_inherited_rtentry may add RTEs to parse->rtable. The function is
+	 * expand_append_rtentry may add RTEs to parse->rtable. The function is
 	 * expected to recursively handle any RTEs that it creates with inh=true.
 	 * So just scan as far as the original end of the rtable list.
 	 */
-	nrtes = list_length(root->parse->rtable);
-	rl = list_head(root->parse->rtable);
-	for (rti = 1; rti <= nrtes; rti++)
+	for (rti = 1; rti < orig_rtable_size; rti++)
 	{
-		RangeTblEntry *rte = (RangeTblEntry *) lfirst(rl);
+		RelOptInfo *brel = root->simple_rel_array[rti];
+		RangeTblEntry *rte = root->simple_rte_array[rti];
 
-		expand_inherited_rtentry(root, rte, rti);
-		rl = lnext(rl);
+		/* there may be empty slots corresponding to non-baserel RTEs */
+		if (brel == NULL)
+			continue;
+
+		if (rte->inh)
+			expand_append_rtentry(root, brel, rte, rti);
+	}
+}
+
+/*
+ * expand_append_rtentry
+ *		This initializes RelOptInfos for an appendrel's child relations, if
+ *		any
+ *
+ * 'rel' is the appendrel parent, whose range table entry ('rte') has been
+ * marked to require adding children.  An appendrel parent could either
+ * be a subquery (if we flattened UNION ALL query) or a table that's known
+ * to have inheritance children.  The latter consists of both regular
+ * inheritance parents and partitioned tables.
+ *
+ * For a subquery parent, there is not much to be done here because the
+ * children's RTEs are already present in the query, so we just initialize
+ * RelOptInfos for them.  Also, the AppendRelInfos for child subqueries
+ * have already been added.
+ *
+ * For tables, we need to add the children to the range table and initialize
+ * AppendRelInfos, RelOptInfos, and PlanRowMarks (if any) for them.  For
+ * a partitioned parent, we only add the children remaining after pruning.
+ * For regular inheritance parents, we find the children using
+ * find_all_inheritors and add all of them.
+ *
+ * If it turns out that there are no children, then we set rte->inh to false
+ * to let the caller know that only the parent table needs to be scanned.  The
+ * caller can accordingly switch to a non-Append path.  For a partitioned
+ * parent, that means an empty relation because parents themselves contain no
+ * data.
+ *
+ * For the regular inheritance case, the parent also gets another RTE with
+ * inh = false to represent it as an appendrel child.  The original RTE is
+ * considered to represent the whole inheritance set.
+ */
+static void
+expand_append_rtentry(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte,
+					  Index rti)
+{
+	Assert(rte->inh);
+	/* Inheritance parent (partitioned or not) or UNION ALL parent subquery. */
+	Assert(rte->rtekind == RTE_RELATION || rte->rtekind == RTE_SUBQUERY);
+
+	/*
+	 * UNION ALL children already got RTEs and AppendRelInfos, so just build
+	 * RelOptInfos and return.
+	 *
+	 * It might be a bit odd that this code is in this, because there is
+	 * nothing to expand really.
+	 */
+	if (rte->rtekind == RTE_SUBQUERY)
+	{
+		ListCell   *l;
+
+		/*
+		 * We don't need to use expand_planner_arrays in this case, because
+		 * no new child RTEs are created.  setup_simple_rel_arrays() and
+		 * setup_append_rel_array would've considered these child RTEs when
+		 * allocating space for various arrays.
+		 */
+		foreach(l, root->append_rel_list)
+		{
+			AppendRelInfo *appinfo = lfirst(l);
+			Index		childRTindex = appinfo->child_relid;
+
+			if (appinfo->parent_relid != rti)
+				continue;
+
+			Assert(childRTindex < root->simple_rel_array_size);
+			Assert(root->simple_rte_array[childRTindex] != NULL);
+
+			/*
+			 * We set the correct value of baserestricinfo and
+			 * baserestrict_min_security below.
+			 */
+			root->simple_rel_array[childRTindex] =
+				build_append_child_rel(root, rel, appinfo->child_relid);
+		}
+	}
+	else
+	{
+		Assert(rte->rtekind == RTE_RELATION);
+		Assert(has_subclass(rte->relid));
+
+		/*
+		 * The rewriter should already have obtained an appropriate lock on
+		 * each relation named in the query.  However, for each child relation
+		 * we add to the query, we must obtain an appropriate lock, because
+		 * this will be the first use of those relations in the
+		 * parse/rewrite/plan pipeline.  Child rels should use the same
+		 * lockmode as their parent.
+		 */
+		Assert(rte->rellockmode != NoLock);
+
+		if (rte->relkind == RELKIND_PARTITIONED_TABLE)
+			expand_partitioned_rtentry(root, rte, rti, rel);
+		else
+			expand_inherited_rtentry(root, rte, rti, rel);
 	}
 }
 
 /*
  * expand_inherited_rtentry
- *		Check whether a rangetable entry represents an inheritance set.
- *		If so, add entries for all the child tables to the query's
- *		rangetable, and build AppendRelInfo nodes for all the child tables
- *		and add them to root->append_rel_list.  If not, clear the entry's
- *		"inh" flag to prevent later code from looking for AppendRelInfos.
+ *		Add entries for all the child tables to the query's rangetable, and
+ *		build AppendRelInfo nodes for all the child tables and add them to
+ *		root->append_rel_list.
  *
  * Note that the original RTE is considered to represent the whole
  * inheritance set.  The first of the generated RTEs is an RTE for the same
@@ -1509,45 +1617,22 @@ expand_inherited_tables(PlannerInfo *root)
  * regular inheritance, a parent RTE must always have at least two associated
  * AppendRelInfos: one corresponding to the parent table as a simple member of
  * inheritance set and one or more corresponding to the actual children.
- * Since a partitioned table is not scanned, it might have only one associated
- * AppendRelInfo.
  */
 static void
-expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti)
+expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti,
+						 RelOptInfo *rel)
 {
 	Oid			parentOID;
 	PlanRowMark *oldrc;
-	Relation	oldrelation;
-	LOCKMODE	lockmode;
+	LOCKMODE	lockmode = rte->rellockmode;
 	List	   *inhOIDs;
 	ListCell   *l;
+	int			num_children;
+	int			num_children_added = 0;
 
-	/* Does RT entry allow inheritance? */
-	if (!rte->inh)
-		return;
-	/* Ignore any already-expanded UNION ALL nodes */
-	if (rte->rtekind != RTE_RELATION)
-	{
-		Assert(rte->rtekind == RTE_SUBQUERY);
-		return;
-	}
-	/* Fast path for common case of childless table */
+	Assert(rte->rtekind == RTE_RELATION);
+	Assert(lockmode != NoLock);
 	parentOID = rte->relid;
-	if (!has_subclass(parentOID))
-	{
-		/* Clear flag before returning */
-		rte->inh = false;
-		return;
-	}
-
-	/*
-	 * The rewriter should already have obtained an appropriate lock on each
-	 * relation named in the query.  However, for each child relation we add
-	 * to the query, we must obtain an appropriate lock, because this will be
-	 * the first use of those relations in the parse/rewrite/plan pipeline.
-	 * Child rels should use the same lockmode as their parent.
-	 */
-	lockmode = rte->rellockmode;
 
 	/* Scan for all members of inheritance set, acquire needed locks */
 	inhOIDs = find_all_inheritors(parentOID, lockmode, NULL);
@@ -1557,7 +1642,8 @@ expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti)
 	 * case.  This could happen despite above has_subclass() check, if table
 	 * once had a child but no longer does.
 	 */
-	if (list_length(inhOIDs) < 2)
+	num_children = list_length(inhOIDs);
+	if (num_children < 2)
 	{
 		/* Clear flag before returning */
 		rte->inh = false;
@@ -1565,219 +1651,220 @@ expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti)
 	}
 
 	/*
-	 * If parent relation is selected FOR UPDATE/SHARE, we need to mark its
-	 * PlanRowMark as isParent = true, and generate a new PlanRowMark for each
-	 * child.
+	 * If parent relation is selected FOR UPDATE/SHARE, preprocess_rowmarks
+	 * should've set isParent = true.  We'll generate a new PlanRowMark for
+	 * each child.
 	 */
 	oldrc = get_plan_rowmark(root->rowMarks, rti);
-	if (oldrc)
-		oldrc->isParent = true;
+	Assert(oldrc == NULL || oldrc->isParent);
 
 	/*
-	 * Must open the parent relation to examine its tupdesc.  We need not lock
-	 * it; we assume the rewriter already did.
+	 * Must expand PlannerInfo arrays by num_children before we can add
+	 * children.
 	 */
-	oldrelation = heap_open(parentOID, NoLock);
+	expand_planner_arrays(root, num_children);
 
-	/* Scan the inheritance set and expand it */
-	if (RelationGetPartitionDesc(oldrelation) != NULL)
+	foreach(l, inhOIDs)
 	{
-		Assert(rte->relkind == RELKIND_PARTITIONED_TABLE);
-
-		/*
-		 * If this table has partitions, recursively expand them in the order
-		 * in which they appear in the PartitionDesc.  While at it, also
-		 * extract the partition key columns of all the partitioned tables.
-		 */
-		expand_partitioned_rtentry(root, rte, rti, oldrelation, oldrc,
-								   lockmode, &root->append_rel_list);
-	}
-	else
-	{
-		List	   *appinfos = NIL;
+		Oid			childOID = lfirst_oid(l);
+		Relation	newrelation;
 		RangeTblEntry *childrte;
 		Index		childRTindex;
 
+		/* Already locked above. */
+		newrelation = heap_open(childOID, NoLock);
+
 		/*
-		 * This table has no partitions.  Expand any plain inheritance
-		 * children in the order the OIDs were returned by
-		 * find_all_inheritors.
+		 * It is possible that the parent table has children that are temp
+		 * tables of other backends.  We cannot safely access such tables
+		 * (because of buffering issues), and the best thing to do seems
+		 * to be to silently ignore them.
 		 */
-		foreach(l, inhOIDs)
+		if (RELATION_IS_OTHER_TEMP(newrelation))
 		{
-			Oid			childOID = lfirst_oid(l);
-			Relation	newrelation;
-
-			/* Open rel if needed; we already have required locks */
-			if (childOID != parentOID)
-				newrelation = heap_open(childOID, NoLock);
-			else
-				newrelation = oldrelation;
-
-			/*
-			 * It is possible that the parent table has children that are temp
-			 * tables of other backends.  We cannot safely access such tables
-			 * (because of buffering issues), and the best thing to do seems
-			 * to be to silently ignore them.
-			 */
-			if (childOID != parentOID && RELATION_IS_OTHER_TEMP(newrelation))
-			{
-				heap_close(newrelation, lockmode);
-				continue;
-			}
-
-			expand_single_inheritance_child(root, rte, rti, oldrelation, oldrc,
-											newrelation,
-											&appinfos, &childrte,
-											&childRTindex);
-
-			/* Close child relations, but keep locks */
-			if (childOID != parentOID)
-				heap_close(newrelation, NoLock);
+			heap_close(newrelation, lockmode);
+			continue;
 		}
 
-		/*
-		 * If all the children were temp tables, pretend it's a
-		 * non-inheritance situation; we don't need Append node in that case.
-		 * The duplicate RTE we added for the parent table is harmless, so we
-		 * don't bother to get rid of it; ditto for the useless PlanRowMark
-		 * node.
-		 */
-		if (list_length(appinfos) < 2)
-			rte->inh = false;
-		else
-			root->append_rel_list = list_concat(root->append_rel_list,
-												appinfos);
+		(void) add_inheritance_child_rel(root, rte, rti, rel, oldrc,
+										 newrelation, &childrte,
+										 &childRTindex);
+		Assert(childrte != NULL);
+		/* All regular inheritance children are leaf children. */
+		Assert(!childrte->inh);
+		Assert(childRTindex > 0);
 
+		/* Close child relations, but keep locks */
+		heap_close(newrelation, NoLock);
+		num_children_added++;
 	}
 
-	heap_close(oldrelation, NoLock);
+	/*
+	 * If all children, including the parent (as child rel), were
+	 * excluded, mark the parent rel as empty.  If all the children were temp
+	 * tables, pretend it's a non-inheritance situation; we don't need Append
+	 * node in that case.  The duplicate RTE we added for the parent table is
+	 * harmless, so we don't bother to get rid of it; ditto for the useless
+	 * PlanRowMark node.
+	 */
+	if (num_children_added == 0)
+		mark_dummy_rel(rel);
+	else if (num_children_added == 1)
+		rte->inh = false;
+
+	/*
+	 * Add junk columns needed by the row mark if any and also add the
+	 * relevant expressions to the root parent's reltarget.
+	 */
+	if (oldrc)
+	{
+		List   *tlist = add_rowmark_junk_columns(root, oldrc);
+
+		build_base_rel_tlists(root, tlist);
+	}
 }
 
 /*
  * expand_partitioned_rtentry
- *		Recursively expand an RTE for a partitioned table.
+ *		Prunes unnecessary partitions of a partitioned table and adds
+ *		remaining ones to the Query and the PlannerInfo
  *
- * Note that RelationGetPartitionDispatchInfo will expand partitions in the
- * same order as this code.
+ * Partitions are added to the query in order in which they are found in
+ * the parent's PartitionDesc.
+ *
+ * Note: even though only the unpruned partitions will be added to the
+ * resulting plan, this still locks *all* partitions via find_all_inheritors
+ * in order to avoid partitions being locked in a different order than other
+ * places in the backend that may lock partitions.
  */
 static void
 expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
-						   Index parentRTindex, Relation parentrel,
-						   PlanRowMark *top_parentrc, LOCKMODE lockmode,
-						   List **appinfos)
+						   Index parentRTindex, RelOptInfo *parentrel)
 {
+	LOCKMODE	lockmode = parentrte->rellockmode;
+	PlanRowMark *rootrc = NULL;
 	int			i;
-	RangeTblEntry *childrte;
-	Index		childRTindex;
-	PartitionDesc partdesc = RelationGetPartitionDesc(parentrel);
+	Bitmapset  *partindexes;
+	Index		rootParentRTindex = parentrel->inh_root_parent > 0 ?
+									parentrel->inh_root_parent :
+									parentRTindex;
 
-	check_stack_depth();
-
-	/* A partitioned table should always have a partition descriptor. */
-	Assert(partdesc);
-
-	Assert(parentrte->inh);
+	/* If root partitioned table, lock *all* partitions in the tree. */
+	if (parentRTindex == rootParentRTindex)
+		(void) find_all_inheritors(parentrte->relid, lockmode, NULL);
 
 	/*
-	 * Note down whether any partition key cols are being updated. Though it's
-	 * the root partitioned table's updatedCols we are interested in, we
-	 * instead use parentrte to get the updatedCols. This is convenient
-	 * because parentrte already has the root partrel's updatedCols translated
-	 * to match the attribute ordering of parentrel.
+	 * Initialize partitioned_child_rels to contain this RT index.
+	 *
+	 * Note that during the set_append_rel_pathlist() phase, values of the
+	 * indexes of partitioned relations that appear down in the tree will be
+	 * bubbled up into root parent's list so that when we've created Paths for
+	 * all the children, the root table's list will contain all such indexes.
 	 */
-	if (!root->partColsUpdated)
-		root->partColsUpdated =
-			has_partition_attrs(parentrel, parentrte->updatedCols, NULL);
+	parentrel->partitioned_child_rels = list_make1_int(parentRTindex);
 
-	/* First expand the partitioned table itself. */
-	expand_single_inheritance_child(root, parentrte, parentRTindex, parentrel,
-									top_parentrc, parentrel,
-									appinfos, &childrte, &childRTindex);
+	/* Perform pruning. */
+	partindexes = prune_append_rel_partitions(parentrel);
+
+	/* Must expand PlannerInfo arrays before we can add children. */
+	expand_planner_arrays(root, bms_num_members(partindexes));
 
 	/*
-	 * If the partitioned table has no partitions, treat this as the
-	 * non-inheritance case.
+	 * For partitioned tables, we also store the partition RelOptInfo
+	 * pointers in the parent's RelOptInfo.
 	 */
-	if (partdesc->nparts == 0)
-	{
-		parentrte->inh = false;
-		return;
-	}
+	parentrel->part_rels = (RelOptInfo **) palloc0(sizeof(RelOptInfo *) *
+												   parentrel->nparts);
 
-	for (i = 0; i < partdesc->nparts; i++)
+	rootrc = get_plan_rowmark(root->rowMarks, rootParentRTindex);
+	Assert(rootrc == NULL || rootrc->isParent);
+	i = -1;
+	while ((i = bms_next_member(partindexes, i)) >= 0)
 	{
-		Oid			childOID = partdesc->oids[i];
-		Relation	childrel;
+		Oid		childOID = parentrel->part_oids[i];
+		Relation	newrelation;
+		RelOptInfo *childrel;
+		RangeTblEntry *childrte;
+		Index		childRTindex;
 
-		/* Open rel; we already have required locks */
-		childrel = heap_open(childOID, NoLock);
+		/* Already locked above. */
+		newrelation = heap_open(childOID, NoLock);
+		Assert(!RELATION_IS_OTHER_TEMP(newrelation));
 
 		/*
-		 * Temporary partitions belonging to other sessions should have been
-		 * disallowed at definition, but for paranoia's sake, let's double
-		 * check.
+		 * A partitioned child table with 0 children is a dummy rel, so don't
+		 * bother creating planner objects for it.
 		 */
-		if (RELATION_IS_OTHER_TEMP(childrel))
-			elog(ERROR, "temporary relation from another session found as partition");
+		if (newrelation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE &&
+			RelationGetPartitionDesc(newrelation)->nparts == 0)
+		{
+			heap_close(newrelation, NoLock);
+			continue;
+		}
 
-		expand_single_inheritance_child(root, parentrte, parentRTindex,
-										parentrel, top_parentrc, childrel,
-										appinfos, &childrte, &childRTindex);
+		childrel = add_inheritance_child_rel(root, parentrte, parentRTindex,
+											 parentrel, rootrc, newrelation,
+											 &childrte, &childRTindex);
+		Assert(childrel != NULL);
+		parentrel->part_rels[i] = childrel;
 
-		/* If this child is itself partitioned, recurse */
-		if (childrel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
+		/* Close child relations, but keep locks */
+		heap_close(newrelation, NoLock);
+
+		/* If the child is partitioned itself, expand it too. */
+		if (childrel->part_scheme)
+		{
+			Assert(childrte->inh);
 			expand_partitioned_rtentry(root, childrte, childRTindex,
-									   childrel, top_parentrc, lockmode,
-									   appinfos);
+									   childrel);
+		}
+	}
 
-		/* Close child relation, but keep locks */
-		heap_close(childrel, NoLock);
+	/*
+	 * Add junk columns needed by the row mark if any and also add the
+	 * relevant expressions to the root parent's reltarget.
+	 */
+	if (rootrc)
+	{
+		List   *tlist = add_rowmark_junk_columns(root, rootrc);
+
+		build_base_rel_tlists(root, tlist);
 	}
 }
 
 /*
- * expand_single_inheritance_child
- *		Build a RangeTblEntry and an AppendRelInfo, if appropriate, plus
- *		maybe a PlanRowMark.
+ * add_inheritance_child_rel
+ *		Build a RangeTblEntry, an AppendRelInfo, a PlanRowMark, and finally
+ *		a RelOptInfo for an inheritance child relation.
  *
- * We now expand the partition hierarchy level by level, creating a
- * corresponding hierarchy of AppendRelInfos and RelOptInfos, where each
- * partitioned descendant acts as a parent of its immediate partitions.
- * (This is a difference from what older versions of PostgreSQL did and what
- * is still done in the case of table inheritance for unpartitioned tables,
- * where the hierarchy is flattened during RTE expansion.)
+ * The return value is the RelOptInfo that's added.
  *
  * PlanRowMarks still carry the top-parent's RTI, and the top-parent's
  * allMarkTypes field still accumulates values from all descendents.
  *
  * "parentrte" and "parentRTindex" are immediate parent's RTE and
  * RTI. "top_parentrc" is top parent's PlanRowMark.
- *
- * The child RangeTblEntry and its RTI are returned in "childrte_p" and
- * "childRTindex_p" resp.
  */
-static void
-expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte,
-								Index parentRTindex, Relation parentrel,
-								PlanRowMark *top_parentrc, Relation childrel,
-								List **appinfos, RangeTblEntry **childrte_p,
-								Index *childRTindex_p)
+static RelOptInfo *
+add_inheritance_child_rel(PlannerInfo *root, RangeTblEntry *parentrte,
+						  Index parentRTindex, RelOptInfo *parentrel,
+						  PlanRowMark *top_parentrc, Relation childrel,
+						  RangeTblEntry **childrte_p, Index *childRTindex_p)
 {
 	Query	   *parse = root->parse;
-	Oid			parentOID = RelationGetRelid(parentrel);
 	Oid			childOID = RelationGetRelid(childrel);
 	RangeTblEntry *childrte;
 	Index		childRTindex;
 	AppendRelInfo *appinfo;
+	RelOptInfo *childrelopt;
 
 	/*
 	 * Build an RTE for the child, and attach to query's rangetable list. We
 	 * copy most fields of the parent's RTE, but replace relation OID and
-	 * relkind, and set inh = false.  Also, set requiredPerms to zero since
-	 * all required permissions checks are done on the original RTE. Likewise,
-	 * set the child's securityQuals to empty, because we only want to apply
-	 * the parent's RLS conditions regardless of what RLS properties
+	 * relkind, and set inh appropriately.  Also, set requiredPerms to zero
+	 * since all required permissions checks are done on the original RTE.
+	 * Likewise, set the child's securityQuals to empty, because we only want
+	 * to apply the parent's RLS conditions regardless of what RLS properties
 	 * individual children may have.  (This is an intentional choice to make
 	 * inherited RLS work like regular permissions checks.) The parent
 	 * securityQuals will be propagated to children along with other base
@@ -1787,55 +1874,42 @@ expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte,
 	*childrte_p = childrte;
 	childrte->relid = childOID;
 	childrte->relkind = childrel->rd_rel->relkind;
-	/* A partitioned child will need to be expanded further. */
-	if (childOID != parentOID &&
-		childrte->relkind == RELKIND_PARTITIONED_TABLE)
-		childrte->inh = true;
-	else
-		childrte->inh = false;
+	/*
+	 * A partitioned child will need to be expanded as an append parent
+	 * itself, so set its inh to true.
+	 */
+	childrte->inh = (childrte->relkind == RELKIND_PARTITIONED_TABLE);
 	childrte->requiredPerms = 0;
 	childrte->securityQuals = NIL;
 	parse->rtable = lappend(parse->rtable, childrte);
 	childRTindex = list_length(parse->rtable);
 	*childRTindex_p = childRTindex;
 
-	/*
-	 * We need an AppendRelInfo if paths will be built for the child RTE. If
-	 * childrte->inh is true, then we'll always need to generate append paths
-	 * for it.  If childrte->inh is false, we must scan it if it's not a
-	 * partitioned table; but if it is a partitioned table, then it never has
-	 * any data of its own and need not be scanned.
-	 */
-	if (childrte->relkind != RELKIND_PARTITIONED_TABLE || childrte->inh)
-	{
-		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->translated_vars);
-		appinfo->parent_reloid = parentOID;
-		*appinfos = lappend(*appinfos, appinfo);
+	/* Create an AppendRelInfo and add it to planner's global list. */
+	appinfo = make_append_rel_info(parentrel, parentrte,
+								   childrel->rd_att,
+								   childOID,
+								   childrel->rd_rel->reltype,
+								   childRTindex);
+	root->append_rel_list = lappend(root->append_rel_list, appinfo);
 
-		/*
-		 * Translate the column permissions bitmaps to the child's attnums (we
-		 * have to build the translated_vars list before we can do this). But
-		 * if this is the parent table, leave copyObject's result alone.
-		 *
-		 * Note: we need to do this even though the executor won't run any
-		 * permissions checks on the child RTE.  The insertedCols/updatedCols
-		 * bitmaps may be examined for trigger-firing purposes.
-		 */
-		if (childOID != parentOID)
-		{
-			childrte->selectedCols = translate_col_privs(parentrte->selectedCols,
-														 appinfo->translated_vars);
-			childrte->insertedCols = translate_col_privs(parentrte->insertedCols,
-														 appinfo->translated_vars);
-			childrte->updatedCols = translate_col_privs(parentrte->updatedCols,
-														appinfo->translated_vars);
-		}
+	/*
+	 * Translate the column permissions bitmaps to the child's attnums (we
+	 * have to build the translated_vars list before we can do this). But
+	 * if this is the parent table, leave copyObject's result alone.
+	 *
+	 * Note: we need to do this even though the executor won't run any
+	 * permissions checks on the child RTE.  The insertedCols/updatedCols
+	 * bitmaps may be examined for trigger-firing purposes.
+	 */
+	if (childrte->relid != parentrte->relid)
+	{
+		childrte->selectedCols = translate_col_privs(parentrte->selectedCols,
+													 appinfo->translated_vars);
+		childrte->insertedCols = translate_col_privs(parentrte->insertedCols,
+													 appinfo->translated_vars);
+		childrte->updatedCols = translate_col_privs(parentrte->updatedCols,
+													appinfo->translated_vars);
 	}
 
 	/*
@@ -1867,6 +1941,24 @@ expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte,
 
 		root->rowMarks = lappend(root->rowMarks, childrc);
 	}
+
+	/*
+	 * Add the RelOptInfo.  Even though we may not really scan this relation
+	 * for reasons such as contradictory quals, we still need need to create
+	 * one, because for every RTE in the query's range table, there must be an
+	 * accompanying RelOptInfo.
+	 */
+
+	/* First, store the RTE and appinfos into planner arrays. */
+	Assert(root->simple_rte_array[childRTindex] == NULL);
+	root->simple_rte_array[childRTindex] = childrte;
+	Assert(root->append_rel_array[childRTindex] == NULL);
+	root->append_rel_array[childRTindex] = appinfo;
+
+	childrelopt = build_append_child_rel(root, parentrel, childRTindex);
+	Assert(childrelopt != NULL);
+
+	return childrelopt;
 }
 
 /*
@@ -1877,14 +1969,11 @@ expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte,
  * For paranoia's sake, we match type/collation as well as attribute name.
  */
 static void
-make_inh_translation_list(Relation oldrelation, Relation newrelation,
-						  Index newvarno,
-						  List **translated_vars)
+make_inh_translation_list(TupleDesc old_tupdesc, TupleDesc new_tupdesc,
+						  Oid from_rel, Oid to_rel,
+						  Index newvarno, List **translated_vars)
 {
 	List	   *vars = NIL;
-	TupleDesc	old_tupdesc = RelationGetDescr(oldrelation);
-	TupleDesc	new_tupdesc = RelationGetDescr(newrelation);
-	Oid			new_relid = RelationGetRelid(newrelation);
 	int			oldnatts = old_tupdesc->natts;
 	int			newnatts = new_tupdesc->natts;
 	int			old_attno;
@@ -1914,7 +2003,7 @@ make_inh_translation_list(Relation oldrelation, Relation newrelation,
 		 * When we are generating the "translation list" for the parent table
 		 * of an inheritance set, no need to search for matches.
 		 */
-		if (oldrelation == newrelation)
+		if (from_rel == to_rel)
 		{
 			vars = lappend(vars, makeVar(newvarno,
 										 (AttrNumber) (old_attno + 1),
@@ -1940,10 +2029,10 @@ make_inh_translation_list(Relation oldrelation, Relation newrelation,
 		{
 			HeapTuple	newtup;
 
-			newtup = SearchSysCacheAttName(new_relid, attname);
+			newtup = SearchSysCacheAttName(to_rel, attname);
 			if (!newtup)
 				elog(ERROR, "could not find inherited attribute \"%s\" of relation \"%s\"",
-					 attname, RelationGetRelationName(newrelation));
+					 attname, get_rel_name(to_rel));
 			new_attno = ((Form_pg_attribute) GETSTRUCT(newtup))->attnum - 1;
 			ReleaseSysCache(newtup);
 
@@ -1953,10 +2042,10 @@ make_inh_translation_list(Relation oldrelation, Relation newrelation,
 		/* Found it, check type and collation match */
 		if (atttypid != att->atttypid || atttypmod != att->atttypmod)
 			elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's type",
-				 attname, RelationGetRelationName(newrelation));
+				 attname, get_rel_name(to_rel));
 		if (attcollation != att->attcollation)
 			elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's collation",
-				 attname, RelationGetRelationName(newrelation));
+				 attname, get_rel_name(to_rel));
 
 		vars = lappend(vars, makeVar(newvarno,
 									 (AttrNumber) (new_attno + 1),
@@ -2023,6 +2112,255 @@ translate_col_privs(const Bitmapset *parent_privs,
 }
 
 /*
+ *	build_append_child_rel
+ *		Build a RelOptInfo for child relation of an append rel
+ *
+ * After creating the RelOptInfo for the given child RT index, it goes on to
+ * initialize some of its fields base on the parent RelOptInfo.
+ *
+ * If the quals in baserestrictinfo turns out to be self-contradictory, the
+ * RelOptInfo is marked dummy before returning.
+ */
+static RelOptInfo *
+build_append_child_rel(PlannerInfo *root,
+					   RelOptInfo *parent,
+					   Index childRTindex)
+{
+	RelOptInfo *childrel;
+	RangeTblEntry *childRTE = root->simple_rte_array[childRTindex];
+	AppendRelInfo *appinfo = root->append_rel_array[childRTindex];
+	List	   *childquals;
+	ListCell   *lc;
+	bool		have_const_false_cq;
+	Index		cq_min_security;
+
+	/* Build the RelOptInfo. */
+	childrel = build_simple_rel(root, childRTindex, parent);
+
+	/*
+	 * Propagate lateral_relids and lateral_referencers from appendrel
+	 * parent rels to their child rels.  We intentionally give each child rel
+	 * the same minimum parameterization, even though it's quite possible that
+	 * some don't reference all the lateral rels.  This is because any append
+	 * path for the parent will have to have the same parameterization for
+	 * every child anyway, and there's no value in forcing extra
+	 * reparameterize_path() calls.  Similarly, a lateral reference to the
+	 * parent prevents use of otherwise-movable join rels for each child.
+	 */
+	childrel->direct_lateral_relids = parent->direct_lateral_relids;
+	childrel->lateral_relids = parent->lateral_relids;
+	childrel->lateral_referencers = parent->lateral_referencers;
+
+	/*
+	 * We have to copy the parent's quals to the child, with appropriate
+	 * substitution of variables.  However, only the baserestrictinfo
+	 * quals are needed before we can check for constraint exclusion; so
+	 * do that first and then check to see if we can disregard this child.
+	 *
+	 * The child rel's targetlist might contain non-Var expressions, which
+	 * means that substitution into the quals could produce opportunities
+	 * for const-simplification, and perhaps even pseudoconstant quals.
+	 * Therefore, transform each RestrictInfo separately to see if it
+	 * reduces to a constant or pseudoconstant.  (We must process them
+	 * separately to keep track of the security level of each qual.)
+	 */
+	childquals = false;
+	cq_min_security = UINT_MAX;
+	have_const_false_cq = false;
+	foreach(lc, parent->baserestrictinfo)
+	{
+		RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
+		Node	   *childqual = (Node *) rinfo->clause;
+		ListCell   *lc2;
+
+		Assert(IsA(rinfo, RestrictInfo));
+		childqual = adjust_appendrel_attrs(root, childqual,
+										   1, &appinfo);
+		childqual = eval_const_expressions(root, childqual);
+		/* check for flat-out constant */
+		if (childqual && IsA(childqual, Const))
+		{
+			if (((Const *) childqual)->constisnull ||
+				!DatumGetBool(((Const *) childqual)->constvalue))
+			{
+				/* Restriction reduces to constant FALSE or NULL */
+				have_const_false_cq = true;
+				break;
+			}
+			/* Restriction reduces to constant TRUE, so drop it */
+			continue;
+		}
+		/* might have gotten an AND clause, if so flatten it */
+		foreach(lc2, make_ands_implicit((Expr *) childqual))
+		{
+			Node	   *onecq = (Node *) lfirst(lc2);
+			bool		pseudoconstant;
+
+			/* check for pseudoconstant (no Vars or volatile functions) */
+			pseudoconstant =
+					!contain_vars_of_level(onecq, 0) &&
+					!contain_volatile_functions(onecq);
+			if (pseudoconstant)
+			{
+				/* tell createplan.c to check for gating quals */
+				root->hasPseudoConstantQuals = true;
+			}
+			/* reconstitute RestrictInfo with appropriate properties */
+			childquals = lappend(childquals,
+								 make_restrictinfo((Expr *) onecq,
+												   rinfo->is_pushed_down,
+												   rinfo->outerjoin_delayed,
+												   pseudoconstant,
+												   rinfo->security_level,
+												   NULL, NULL, NULL));
+			cq_min_security = Min(cq_min_security, rinfo->security_level);
+		}
+	}
+
+	/*
+	 * In addition to the quals inherited from the parent, we might
+	 * have securityQuals associated with this particular child node.
+	 * (Currently this can only happen in appendrels originating from
+	 * UNION ALL; inheritance child tables don't have their own
+	 * securityQuals.)	Pull any such securityQuals up into the
+	 * baserestrictinfo for the child.  This is similar to
+	 * process_security_barrier_quals() for the parent rel, except
+	 * that we can't make any general deductions from such quals,
+	 * since they don't hold for the whole appendrel.
+	 */
+	if (childRTE->securityQuals)
+	{
+		Index		security_level = 0;
+
+		foreach(lc, childRTE->securityQuals)
+		{
+			List	   *qualset = (List *) lfirst(lc);
+			ListCell   *lc2;
+
+			foreach(lc2, qualset)
+			{
+				Expr	   *qual = (Expr *) lfirst(lc2);
+
+				/*
+				 * not likely that we'd see constants here, so no
+				 * check
+				 */
+				childquals = lappend(childquals,
+									 make_restrictinfo(qual,
+													   true,
+													   false,
+													   false,
+													   security_level,
+													   NULL, NULL,
+													   NULL));
+				cq_min_security = Min(cq_min_security, security_level);
+			}
+			security_level++;
+		}
+		Assert(security_level <= root->qual_security_level);
+	}
+
+	/* Set child's version of baserestrictinfo. */
+	childrel->baserestrictinfo = childquals;
+	childrel->baserestrict_min_security = cq_min_security;
+
+	if (have_const_false_cq)
+	{
+		/*
+		 * Some restriction clause reduced to constant FALSE or NULL after
+		 * substitution, so this child need not be scanned.
+		 */
+		set_dummy_rel_pathlist(childrel);
+	}
+
+	return childrel;
+}
+
+/*
+ * add_rowmark_junk_columns
+ * 		Add necessary junk columns for rowmarked inheritance parent rel.
+ *
+ * These values are needed for locking of rels selected FOR UPDATE/SHARE, and
+ * to do EvalPlanQual rechecking.  See comments for PlanRowMark in
+ * plannodes.h.
+ */
+static List *
+add_rowmark_junk_columns(PlannerInfo *root, PlanRowMark *rc)
+{
+	List   *tlist = root->processed_tlist;
+	Var		   *var;
+	char		resname[32];
+	TargetEntry *tle;
+
+	if (rc->allMarkTypes & ~(1 << ROW_MARK_COPY))
+	{
+		/* Need to fetch TID */
+		var = makeVar(rc->rti,
+					  SelfItemPointerAttributeNumber,
+					  TIDOID,
+					  -1,
+					  InvalidOid,
+					  0);
+		snprintf(resname, sizeof(resname), "ctid%u", rc->rowmarkId);
+		tle = makeTargetEntry((Expr *) var,
+							  list_length(tlist) + 1,
+							  pstrdup(resname),
+							  true);
+		tlist = lappend(tlist, tle);
+	}
+	if (rc->allMarkTypes & (1 << ROW_MARK_COPY))
+	{
+		/* Need the whole row as a junk var */
+		var = makeWholeRowVar(root->simple_rte_array[rc->rti],
+							  rc->rti,
+							  0,
+							  false);
+		snprintf(resname, sizeof(resname), "wholerow%u", rc->rowmarkId);
+		tle = makeTargetEntry((Expr *) var,
+							  list_length(tlist) + 1,
+							  pstrdup(resname),
+							  true);
+		tlist = lappend(tlist, tle);
+	}
+
+	/* For inheritance cases, always fetch the tableoid too. */
+	var = makeVar(rc->rti,
+				  TableOidAttributeNumber,
+				  OIDOID,
+				  -1,
+				  InvalidOid,
+				  0);
+	snprintf(resname, sizeof(resname), "tableoid%u", rc->rowmarkId);
+	tle = makeTargetEntry((Expr *) var,
+						  list_length(tlist) + 1,
+						  pstrdup(resname),
+						  true);
+	tlist = lappend(tlist, tle);
+
+	return tlist;
+}
+
+AppendRelInfo *
+make_append_rel_info(RelOptInfo *parentrel, RangeTblEntry *parentrte,
+					 TupleDesc childdesc, Oid childoid, Oid childreltype,
+					 Index childRTindex)
+{
+	AppendRelInfo  *appinfo = makeNode(AppendRelInfo);
+
+	appinfo->parent_relid = parentrel->relid;
+	appinfo->child_relid = childRTindex;
+	appinfo->parent_reltype = parentrel->reltype;
+	appinfo->child_reltype = childreltype;
+	make_inh_translation_list(parentrel->tupdesc, childdesc,
+							  parentrte->relid, childoid,
+							  childRTindex,
+							  &appinfo->translated_vars);
+	appinfo->parent_reloid = parentrte->relid;
+
+	return appinfo;
+}
+
+/*
  * adjust_appendrel_attrs
  *	  Copy the specified query or expression and translate Vars referring to a
  *	  parent rel to refer to the corresponding child rel instead.  We also
diff --git a/src/backend/optimizer/util/Makefile b/src/backend/optimizer/util/Makefile
index c54d0a690d..da9ccf32b4 100644
--- a/src/backend/optimizer/util/Makefile
+++ b/src/backend/optimizer/util/Makefile
@@ -13,6 +13,6 @@ top_builddir = ../../../..
 include $(top_builddir)/src/Makefile.global
 
 OBJS = clauses.o joininfo.o orclauses.o pathnode.o placeholder.o \
-       plancat.o predtest.o relnode.o restrictinfo.o tlist.o var.o
+	   plancat.o predtest.o relnode.o restrictinfo.o tlist.o var.o
 
 include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/optimizer/util/plancat.c b/src/backend/optimizer/util/plancat.c
index ed0953f9e1..92805046c8 100644
--- a/src/backend/optimizer/util/plancat.c
+++ b/src/backend/optimizer/util/plancat.c
@@ -106,7 +106,7 @@ static void set_baserel_partition_key_exprs(Relation relation,
  */
 void
 get_relation_info(PlannerInfo *root, Oid relationObjectId, bool inhparent,
-				  RelOptInfo *rel)
+				  Bitmapset *updatedCols, RelOptInfo *rel)
 {
 	Index		varno = rel->relid;
 	Relation	relation;
@@ -444,11 +444,31 @@ get_relation_info(PlannerInfo *root, Oid relationObjectId, bool inhparent,
 	get_relation_foreign_keys(root, rel, relation, inhparent);
 
 	/*
-	 * Collect info about relation's partitioning scheme, if any. Only
-	 * inheritance parents may be partitioned.
+	 * Collect some additional information for inheritance parents.
 	 */
-	if (inhparent && relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
-		set_relation_partition_info(root, rel, relation);
+	if (inhparent)
+	{
+		/*
+		 * We'll need the TupleDesc when initializing the child relation.
+		 * A copy is being made because concurrent changes might drop
+		 * the relcache entry.  That's possible because ALTER TABLE
+		 * child_table NO INHERIT parent_table only requires an
+		 * AccessShareLock on parent_table.
+		 */
+		rel->tupdesc = CreateTupleDescCopy(RelationGetDescr(relation));
+		rel->reltype = RelationGetForm(relation)->reltype;
+
+		/*
+		 * If partitioned, also save the information of partitioning scheme,
+		 * and whether the query updates any of the partition key columns.
+		 */
+		if (relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
+		{
+			set_relation_partition_info(root, rel, relation);
+			root->partColsUpdated |= has_partition_attrs(relation, updatedCols,
+														 NULL);
+		}
+	}
 
 	heap_close(relation, NoLock);
 
@@ -1854,16 +1874,20 @@ set_relation_partition_info(PlannerInfo *root, RelOptInfo *rel,
 							Relation relation)
 {
 	PartitionDesc partdesc;
-	PartitionKey partkey;
 
 	Assert(relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE);
 
 	partdesc = RelationGetPartitionDesc(relation);
-	partkey = RelationGetPartitionKey(relation);
 	rel->part_scheme = find_partition_scheme(root, relation);
 	Assert(partdesc != NULL && rel->part_scheme != NULL);
-	rel->boundinfo = partition_bounds_copy(partdesc->boundinfo, partkey);
 	rel->nparts = partdesc->nparts;
+
+	/*
+	 * Since we must've taken a lock on the table, it's okay to simply copy
+	 * the pointers to relcache data here.
+	 */
+	rel->part_oids = partdesc->oids;
+	rel->boundinfo = partdesc->boundinfo;
 	set_baserel_partition_key_exprs(relation, rel);
 	rel->partition_qual = RelationGetPartitionQual(relation);
 }
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index 29ba19349f..c23db9d78d 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -130,6 +130,37 @@ setup_append_rel_array(PlannerInfo *root)
 	}
 }
 
+/* Expand the PlannerInfo arrays by add_size members and zero-init it. */
+void
+expand_planner_arrays(PlannerInfo *root, int add_size)
+{
+	int		new_size = root->simple_rel_array_size + add_size;
+
+	root->simple_rte_array = (RangeTblEntry **)
+							repalloc(root->simple_rte_array,
+									 sizeof(RangeTblEntry *) * new_size);
+	root->simple_rel_array = (RelOptInfo **)
+								repalloc(root->simple_rel_array,
+										 sizeof(RelOptInfo *) * new_size);
+	if (root->append_rel_array)
+		root->append_rel_array = (AppendRelInfo **)
+									repalloc(root->append_rel_array,
+									 sizeof(AppendRelInfo *) * new_size);
+	else
+		root->append_rel_array = (AppendRelInfo **)
+									palloc0(sizeof(AppendRelInfo *) *
+											new_size);
+
+	/* Set the contents of just allocated memory to 0. */
+	MemSet(root->simple_rte_array + root->simple_rel_array_size,
+		   0, sizeof(RangeTblEntry *) * add_size);
+	MemSet(root->simple_rel_array + root->simple_rel_array_size,
+		   0, sizeof(RelOptInfo *) * add_size);
+	MemSet(root->append_rel_array + root->simple_rel_array_size,
+		   0, sizeof(AppendRelInfo *) * add_size);
+	root->simple_rel_array_size = new_size;
+}
+
 /*
  * build_simple_rel
  *	  Construct a new RelOptInfo for a base relation or 'other' relation.
@@ -238,7 +269,8 @@ build_simple_rel(PlannerInfo *root, int relid, RelOptInfo *parent)
 	{
 		case RTE_RELATION:
 			/* Table --- retrieve statistics from the system catalogs */
-			get_relation_info(root, rte->relid, rte->inh, rel);
+			get_relation_info(root, rte->relid, rte->inh, rte->updatedCols,
+							  rel);
 			break;
 		case RTE_SUBQUERY:
 		case RTE_FUNCTION:
@@ -279,52 +311,6 @@ build_simple_rel(PlannerInfo *root, int relid, RelOptInfo *parent)
 		root->qual_security_level = Max(root->qual_security_level,
 										list_length(rte->securityQuals));
 
-	/*
-	 * If this rel is an appendrel parent, recurse to build "other rel"
-	 * RelOptInfos for its children.  They are "other rels" because they are
-	 * not in the main join tree, but we will need RelOptInfos to plan access
-	 * to them.
-	 */
-	if (rte->inh)
-	{
-		ListCell   *l;
-		int			nparts = rel->nparts;
-		int			cnt_parts = 0;
-
-		if (nparts > 0)
-			rel->part_rels = (RelOptInfo **)
-				palloc(sizeof(RelOptInfo *) * nparts);
-
-		foreach(l, root->append_rel_list)
-		{
-			AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(l);
-			RelOptInfo *childrel;
-
-			/* append_rel_list contains all append rels; ignore others */
-			if (appinfo->parent_relid != relid)
-				continue;
-
-			childrel = build_simple_rel(root, appinfo->child_relid,
-										rel);
-
-			/* Nothing more to do for an unpartitioned table. */
-			if (!rel->part_scheme)
-				continue;
-
-			/*
-			 * The order of partition OIDs in append_rel_list is the same as
-			 * the order in the PartitionDesc, so the order of part_rels will
-			 * also match the PartitionDesc.  See expand_partitioned_rtentry.
-			 */
-			Assert(cnt_parts < nparts);
-			rel->part_rels[cnt_parts] = childrel;
-			cnt_parts++;
-		}
-
-		/* We should have seen all the child partitions. */
-		Assert(cnt_parts == nparts);
-	}
-
 	return rel;
 }
 
diff --git a/src/backend/partitioning/partprune.c b/src/backend/partitioning/partprune.c
index 35c87535d3..fcf8d6032c 100644
--- a/src/backend/partitioning/partprune.c
+++ b/src/backend/partitioning/partprune.c
@@ -45,6 +45,7 @@
 #include "nodes/makefuncs.h"
 #include "nodes/nodeFuncs.h"
 #include "optimizer/clauses.h"
+#include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
 #include "optimizer/planner.h"
 #include "optimizer/predtest.h"
@@ -436,17 +437,23 @@ make_partitionedrel_pruneinfo(PlannerInfo *root, RelOptInfo *parentrel,
 		 * is, not pruned already).
 		 */
 		subplan_map = (int *) palloc(nparts * sizeof(int));
+		memset(subplan_map, -1, nparts * sizeof(int));
 		subpart_map = (int *) palloc(nparts * sizeof(int));
+		memset(subpart_map, -1, nparts * sizeof(int));
 		present_parts = NULL;
 
 		for (i = 0; i < nparts; i++)
 		{
 			RelOptInfo *partrel = subpart->part_rels[i];
-			int			subplanidx = relid_subplan_map[partrel->relid] - 1;
-			int			subpartidx = relid_subpart_map[partrel->relid] - 1;
+			int			subplanidx;
+			int			subpartidx;
 
-			subplan_map[i] = subplanidx;
-			subpart_map[i] = subpartidx;
+			/* Skip processing pruned partitions. */
+			if (partrel == NULL)
+				continue;
+
+			subplan_map[i] = subplanidx = relid_subplan_map[partrel->relid] - 1;
+			subpart_map[i] = subpartidx = relid_subpart_map[partrel->relid] - 1;
 			if (subplanidx >= 0)
 			{
 				present_parts = bms_add_member(present_parts, i);
@@ -540,23 +547,20 @@ gen_partprune_steps(RelOptInfo *rel, List *clauses, bool *contradictory)
 
 /*
  * prune_append_rel_partitions
- *		Returns RT indexes of the minimum set of child partitions which must
- *		be scanned to satisfy rel's baserestrictinfo quals.
+ *		Returns indexes into rel->part_rels of the minimum set of child
+ *		partitions which must be scanned to satisfy rel's baserestrictinfo
+ *		quals.
  *
  * Callers must ensure that 'rel' is a partitioned table.
  */
-Relids
+Bitmapset *
 prune_append_rel_partitions(RelOptInfo *rel)
 {
-	Relids		result;
 	List	   *clauses = rel->baserestrictinfo;
 	List	   *pruning_steps;
 	bool		contradictory;
 	PartitionPruneContext context;
-	Bitmapset  *partindexes;
-	int			i;
 
-	Assert(clauses != NIL);
 	Assert(rel->part_scheme != NULL);
 
 	/* If there are no partitions, return the empty set */
@@ -564,6 +568,13 @@ prune_append_rel_partitions(RelOptInfo *rel)
 		return NULL;
 
 	/*
+	 * If pruning is disabled or if there are no clauses to prune with,
+	 * return all partitions.
+	 */
+	if (!enable_partition_pruning || clauses == NIL)
+		return bms_add_range(NULL, 0, rel->nparts - 1);
+
+	/*
 	 * Process clauses.  If the clauses are found to be contradictory, we can
 	 * return the empty set.
 	 */
@@ -590,15 +601,7 @@ prune_append_rel_partitions(RelOptInfo *rel)
 	context.evalexecparams = false;
 
 	/* Actual pruning happens here. */
-	partindexes = get_matching_partitions(&context, pruning_steps);
-
-	/* Add selected partitions' RT indexes to result. */
-	i = -1;
-	result = NULL;
-	while ((i = bms_next_member(partindexes, i)) >= 0)
-		result = bms_add_member(result, rel->part_rels[i]->relid);
-
-	return result;
+	return get_matching_partitions(&context, pruning_steps);
 }
 
 /*
diff --git a/src/include/nodes/relation.h b/src/include/nodes/relation.h
index 94f14019bd..e6fdbcd030 100644
--- a/src/include/nodes/relation.h
+++ b/src/include/nodes/relation.h
@@ -15,6 +15,7 @@
 #define RELATION_H
 
 #include "access/sdir.h"
+#include "access/tupdesc.h"
 #include "fmgr.h"
 #include "lib/stringinfo.h"
 #include "nodes/params.h"
@@ -723,6 +724,7 @@ typedef struct RelOptInfo
 	int			nparts;			/* number of partitions */
 	struct PartitionBoundInfoData *boundinfo;	/* Partition bounds */
 	List	   *partition_qual; /* partition constraint */
+	Oid		   *part_oids;		/* partition OIDs */
 	struct RelOptInfo **part_rels;	/* Array of RelOptInfos of partitions,
 									 * stored in the same order of bounds */
 	List	  **partexprs;		/* Non-nullable partition key expressions. */
@@ -732,6 +734,12 @@ typedef struct RelOptInfo
 	Index		inh_root_parent;	/* For otherrels, this is the RT index of
 									 * inheritance table mentioned in the query
 									 * from which this relation originated */
+	/*
+	 * Set only if this is an inheritance parent relation.  This information
+	 * is needed when initializing the planning info for children.
+	 */
+	TupleDesc	tupdesc;		/* A "copy" of the table's tuple desriptor */
+	Oid			reltype;		/* Table's reltype */
 } RelOptInfo;
 
 /*
diff --git a/src/include/optimizer/pathnode.h b/src/include/optimizer/pathnode.h
index 81abcf53a8..b1baa3117a 100644
--- a/src/include/optimizer/pathnode.h
+++ b/src/include/optimizer/pathnode.h
@@ -261,6 +261,7 @@ extern Path *reparameterize_path_by_child(PlannerInfo *root, Path *path,
  */
 extern void setup_simple_rel_arrays(PlannerInfo *root);
 extern void setup_append_rel_array(PlannerInfo *root);
+extern void expand_planner_arrays(PlannerInfo *root, int add_size);
 extern RelOptInfo *build_simple_rel(PlannerInfo *root, int relid,
 				 RelOptInfo *parent);
 extern RelOptInfo *find_base_rel(PlannerInfo *root, int relid);
diff --git a/src/include/optimizer/plancat.h b/src/include/optimizer/plancat.h
index 7d53cbbb87..edaf2a3b4f 100644
--- a/src/include/optimizer/plancat.h
+++ b/src/include/optimizer/plancat.h
@@ -26,7 +26,7 @@ extern PGDLLIMPORT get_relation_info_hook_type get_relation_info_hook;
 
 
 extern void get_relation_info(PlannerInfo *root, Oid relationObjectId,
-				  bool inhparent, RelOptInfo *rel);
+				  bool inhparent, Bitmapset *updatedCols, RelOptInfo *rel);
 
 extern List *infer_arbiter_indexes(PlannerInfo *root);
 
diff --git a/src/include/optimizer/prep.h b/src/include/optimizer/prep.h
index 38608770a2..faae07d240 100644
--- a/src/include/optimizer/prep.h
+++ b/src/include/optimizer/prep.h
@@ -38,7 +38,8 @@ extern Expr *canonicalize_qual(Expr *qual, bool is_check);
 /*
  * prototypes for preptlist.c
  */
-extern List *preprocess_targetlist(PlannerInfo *root);
+extern List *preprocess_targetlist(PlannerInfo *root,
+							bool inheritance_expanded);
 
 extern PlanRowMark *get_plan_rowmark(List *rowmarks, Index rtindex);
 
@@ -51,7 +52,10 @@ extern void expand_inherited_tables(PlannerInfo *root);
 
 extern Node *adjust_appendrel_attrs(PlannerInfo *root, Node *node,
 					   int nappinfos, AppendRelInfo **appinfos);
-
+extern AppendRelInfo *make_append_rel_info(RelOptInfo *parentrel,
+					 RangeTblEntry *parentrte,
+					 TupleDesc childdesc, Oid childoid, Oid childreltype,
+					 Index childRTindex);
 extern Node *adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node,
 								  Relids child_relids,
 								  Relids top_parent_relids);
@@ -64,5 +68,4 @@ extern SpecialJoinInfo *build_child_join_sjinfo(PlannerInfo *root,
 						Relids left_relids, Relids right_relids);
 extern Relids adjust_child_relids_multilevel(PlannerInfo *root, Relids relids,
 							   Relids child_relids, Relids top_parent_relids);
-
 #endif							/* PREP_H */
diff --git a/src/include/partitioning/partprune.h b/src/include/partitioning/partprune.h
index e07aaaf798..ac0a979010 100644
--- a/src/include/partitioning/partprune.h
+++ b/src/include/partitioning/partprune.h
@@ -76,7 +76,7 @@ extern PartitionPruneInfo *make_partition_pruneinfo(PlannerInfo *root,
 						 List *subpaths,
 						 List *partitioned_rels,
 						 List *prunequal);
-extern Relids prune_append_rel_partitions(RelOptInfo *rel);
+extern Bitmapset *prune_append_rel_partitions(RelOptInfo *rel);
 extern Bitmapset *get_matching_partitions(PartitionPruneContext *context,
 						List *pruning_steps);
 
diff --git a/src/test/regress/expected/partition_aggregate.out b/src/test/regress/expected/partition_aggregate.out
index 6bc106831e..1450cef057 100644
--- a/src/test/regress/expected/partition_aggregate.out
+++ b/src/test/regress/expected/partition_aggregate.out
@@ -144,7 +144,7 @@ SELECT c, sum(a) FROM pagg_tab WHERE 1 = 2 GROUP BY c;
            QUERY PLAN           
 --------------------------------
  HashAggregate
-   Group Key: pagg_tab.c
+   Group Key: c
    ->  Result
          One-Time Filter: false
 (4 rows)
@@ -159,7 +159,7 @@ SELECT c, sum(a) FROM pagg_tab WHERE c = 'x' GROUP BY c;
            QUERY PLAN           
 --------------------------------
  GroupAggregate
-   Group Key: pagg_tab.c
+   Group Key: c
    ->  Result
          One-Time Filter: false
 (4 rows)
-- 
2.11.0

From ceaab25e8faba6f6c61c0612e3037e4a47c643e1 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Wed, 7 Nov 2018 16:51:31 +0900
Subject: [PATCH v7 4/6] Move append expansion code into its own file

This commit moves expand_append_rel and underlings currently in
optimizer/prep/prepunionc.c to optimizer/utils/append.c.

All of the AppendRelInfo based expression manipulation routines
are moved to optimizer/utils/appendinfo.c.

This commit only moves the code and contains no functional changes.
---
 src/backend/optimizer/path/allpaths.c   |    2 +
 src/backend/optimizer/path/equivclass.c |    1 +
 src/backend/optimizer/path/joinrels.c   |    1 +
 src/backend/optimizer/plan/planner.c    |    1 +
 src/backend/optimizer/prep/prepunion.c  | 1574 -------------------------------
 src/backend/optimizer/util/Makefile     |    5 +-
 src/backend/optimizer/util/append.c     |  777 +++++++++++++++
 src/backend/optimizer/util/appendinfo.c |  851 +++++++++++++++++
 src/backend/optimizer/util/pathnode.c   |    1 +
 src/backend/optimizer/util/relnode.c    |    1 +
 src/backend/partitioning/partprune.c    |    1 +
 src/include/optimizer/append.h          |   25 +
 src/include/optimizer/appendinfo.h      |   43 +
 src/include/optimizer/prep.h            |   19 -
 14 files changed, 1707 insertions(+), 1595 deletions(-)
 create mode 100644 src/backend/optimizer/util/append.c
 create mode 100644 src/backend/optimizer/util/appendinfo.c
 create mode 100644 src/include/optimizer/append.h
 create mode 100644 src/include/optimizer/appendinfo.h

diff --git a/src/backend/optimizer/path/allpaths.c b/src/backend/optimizer/path/allpaths.c
index a4dd34f2cd..d93883ed42 100644
--- a/src/backend/optimizer/path/allpaths.c
+++ b/src/backend/optimizer/path/allpaths.c
@@ -30,6 +30,8 @@
 #ifdef OPTIMIZER_DEBUG
 #include "nodes/print.h"
 #endif
+#include "optimizer/append.h"
+#include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/geqo.h"
diff --git a/src/backend/optimizer/path/equivclass.c b/src/backend/optimizer/path/equivclass.c
index b22b36ec0e..5ace28eab0 100644
--- a/src/backend/optimizer/path/equivclass.c
+++ b/src/backend/optimizer/path/equivclass.c
@@ -22,6 +22,7 @@
 #include "catalog/pg_type.h"
 #include "nodes/makefuncs.h"
 #include "nodes/nodeFuncs.h"
+#include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
 #include "optimizer/pathnode.h"
 #include "optimizer/paths.h"
diff --git a/src/backend/optimizer/path/joinrels.c b/src/backend/optimizer/path/joinrels.c
index da0831de4e..6e321ec9e7 100644
--- a/src/backend/optimizer/path/joinrels.c
+++ b/src/backend/optimizer/path/joinrels.c
@@ -15,6 +15,7 @@
 #include "postgres.h"
 
 #include "miscadmin.h"
+#include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
 #include "optimizer/joininfo.h"
 #include "optimizer/pathnode.h"
diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index 5747694f63..3513b25cac 100644
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -39,6 +39,7 @@
 #include "nodes/print.h"
 #endif
 #include "nodes/relation.h"
+#include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
diff --git a/src/backend/optimizer/prep/prepunion.c b/src/backend/optimizer/prep/prepunion.c
index e4d4e7d6dd..70f37c593f 100644
--- a/src/backend/optimizer/prep/prepunion.c
+++ b/src/backend/optimizer/prep/prepunion.c
@@ -12,11 +12,6 @@
  * case, but most of the heavy lifting for that is done elsewhere,
  * notably in prepjointree.c and allpaths.c.
  *
- * There is also some code here to support planning of queries that use
- * inheritance (SELECT FROM foo*).  Inheritance trees are converted into
- * append relations, and thenceforth share code with the UNION ALL case.
- *
- *
  * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
@@ -39,32 +34,21 @@
 #include "miscadmin.h"
 #include "nodes/makefuncs.h"
 #include "nodes/nodeFuncs.h"
-#include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
 #include "optimizer/paths.h"
 #include "optimizer/planmain.h"
 #include "optimizer/planner.h"
 #include "optimizer/prep.h"
-#include "optimizer/restrictinfo.h"
 #include "optimizer/tlist.h"
-#include "optimizer/var.h"
 #include "parser/parse_coerce.h"
 #include "parser/parsetree.h"
-#include "partitioning/partprune.h"
 #include "utils/lsyscache.h"
 #include "utils/rel.h"
 #include "utils/selfuncs.h"
 #include "utils/syscache.h"
 
 
-typedef struct
-{
-	PlannerInfo *root;
-	int			nappinfos;
-	AppendRelInfo **appinfos;
-} adjust_appendrel_attrs_context;
-
 static RelOptInfo *recurse_set_operations(Node *setOp, PlannerInfo *root,
 					   List *colTypes, List *colCollations,
 					   bool junkOK,
@@ -103,34 +87,6 @@ static List *generate_append_tlist(List *colTypes, List *colCollations,
 					  List *input_tlists,
 					  List *refnames_tlist);
 static List *generate_setop_grouplist(SetOperationStmt *op, List *targetlist);
-static void expand_append_rtentry(PlannerInfo *root, RelOptInfo *rel,
-					  RangeTblEntry *rte, Index rti);
-static void expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte,
-						 Index rti, RelOptInfo *rel);
-static void expand_partitioned_rtentry(PlannerInfo *root,
-						   RangeTblEntry *parentrte,
-						   Index parentRTindex, RelOptInfo *parentrel);
-static RelOptInfo *add_inheritance_child_rel(PlannerInfo *root,
-						  RangeTblEntry *parentrte,
-						  Index parentRTindex, RelOptInfo *parentrel,
-						  PlanRowMark *top_parentrc, Relation childrel,
-						  RangeTblEntry **childrte_p, Index *childRTindex_p);
-static void make_inh_translation_list(TupleDesc old_tupdesc,
-						  TupleDesc new_tupdesc,
-						  Oid from_rel, Oid to_rel,
-						  Index newvarno, List **translated_vars);
-static RelOptInfo *build_append_child_rel(PlannerInfo *root,
-					   RelOptInfo *parent,
-					   Index childRTindex);
-static List *add_rowmark_junk_columns(PlannerInfo *root, PlanRowMark *rc);
-static Bitmapset *translate_col_privs(const Bitmapset *parent_privs,
-					List *translated_vars);
-static Node *adjust_appendrel_attrs_mutator(Node *node,
-							   adjust_appendrel_attrs_context *context);
-static Relids adjust_child_relids(Relids relids, int nappinfos,
-					AppendRelInfo **appinfos);
-static List *adjust_inherited_tlist(List *tlist,
-					   AppendRelInfo *context);
 
 
 /*
@@ -1467,1533 +1423,3 @@ generate_setop_grouplist(SetOperationStmt *op, List *targetlist)
 	Assert(lg == NULL);
 	return grouplist;
 }
-
-
-/*
- * expand_inherited_tables
- *		Expand each rangetable entry that represents an inheritance set
- *		into an "append relation".  At the conclusion of this process,
- *		the "inh" flag is set in all and only those RTEs that are append
- *		relation parents.
- */
-void
-expand_inherited_tables(PlannerInfo *root)
-{
-	int			orig_rtable_size;
-	Index		rti;
-
-	Assert(root->simple_rel_array_size > 0);
-	orig_rtable_size = root->simple_rel_array_size;
-
-	/*
-	 * expand_append_rtentry may add RTEs to parse->rtable. The function is
-	 * expected to recursively handle any RTEs that it creates with inh=true.
-	 * So just scan as far as the original end of the rtable list.
-	 */
-	for (rti = 1; rti < orig_rtable_size; rti++)
-	{
-		RelOptInfo *brel = root->simple_rel_array[rti];
-		RangeTblEntry *rte = root->simple_rte_array[rti];
-
-		/* there may be empty slots corresponding to non-baserel RTEs */
-		if (brel == NULL)
-			continue;
-
-		if (rte->inh)
-			expand_append_rtentry(root, brel, rte, rti);
-	}
-}
-
-/*
- * expand_append_rtentry
- *		This initializes RelOptInfos for an appendrel's child relations, if
- *		any
- *
- * 'rel' is the appendrel parent, whose range table entry ('rte') has been
- * marked to require adding children.  An appendrel parent could either
- * be a subquery (if we flattened UNION ALL query) or a table that's known
- * to have inheritance children.  The latter consists of both regular
- * inheritance parents and partitioned tables.
- *
- * For a subquery parent, there is not much to be done here because the
- * children's RTEs are already present in the query, so we just initialize
- * RelOptInfos for them.  Also, the AppendRelInfos for child subqueries
- * have already been added.
- *
- * For tables, we need to add the children to the range table and initialize
- * AppendRelInfos, RelOptInfos, and PlanRowMarks (if any) for them.  For
- * a partitioned parent, we only add the children remaining after pruning.
- * For regular inheritance parents, we find the children using
- * find_all_inheritors and add all of them.
- *
- * If it turns out that there are no children, then we set rte->inh to false
- * to let the caller know that only the parent table needs to be scanned.  The
- * caller can accordingly switch to a non-Append path.  For a partitioned
- * parent, that means an empty relation because parents themselves contain no
- * data.
- *
- * For the regular inheritance case, the parent also gets another RTE with
- * inh = false to represent it as an appendrel child.  The original RTE is
- * considered to represent the whole inheritance set.
- */
-static void
-expand_append_rtentry(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte,
-					  Index rti)
-{
-	Assert(rte->inh);
-	/* Inheritance parent (partitioned or not) or UNION ALL parent subquery. */
-	Assert(rte->rtekind == RTE_RELATION || rte->rtekind == RTE_SUBQUERY);
-
-	/*
-	 * UNION ALL children already got RTEs and AppendRelInfos, so just build
-	 * RelOptInfos and return.
-	 *
-	 * It might be a bit odd that this code is in this, because there is
-	 * nothing to expand really.
-	 */
-	if (rte->rtekind == RTE_SUBQUERY)
-	{
-		ListCell   *l;
-
-		/*
-		 * We don't need to use expand_planner_arrays in this case, because
-		 * no new child RTEs are created.  setup_simple_rel_arrays() and
-		 * setup_append_rel_array would've considered these child RTEs when
-		 * allocating space for various arrays.
-		 */
-		foreach(l, root->append_rel_list)
-		{
-			AppendRelInfo *appinfo = lfirst(l);
-			Index		childRTindex = appinfo->child_relid;
-
-			if (appinfo->parent_relid != rti)
-				continue;
-
-			Assert(childRTindex < root->simple_rel_array_size);
-			Assert(root->simple_rte_array[childRTindex] != NULL);
-
-			/*
-			 * We set the correct value of baserestricinfo and
-			 * baserestrict_min_security below.
-			 */
-			root->simple_rel_array[childRTindex] =
-				build_append_child_rel(root, rel, appinfo->child_relid);
-		}
-	}
-	else
-	{
-		Assert(rte->rtekind == RTE_RELATION);
-		Assert(has_subclass(rte->relid));
-
-		/*
-		 * The rewriter should already have obtained an appropriate lock on
-		 * each relation named in the query.  However, for each child relation
-		 * we add to the query, we must obtain an appropriate lock, because
-		 * this will be the first use of those relations in the
-		 * parse/rewrite/plan pipeline.  Child rels should use the same
-		 * lockmode as their parent.
-		 */
-		Assert(rte->rellockmode != NoLock);
-
-		if (rte->relkind == RELKIND_PARTITIONED_TABLE)
-			expand_partitioned_rtentry(root, rte, rti, rel);
-		else
-			expand_inherited_rtentry(root, rte, rti, rel);
-	}
-}
-
-/*
- * expand_inherited_rtentry
- *		Add entries for all the child tables to the query's rangetable, and
- *		build AppendRelInfo nodes for all the child tables and add them to
- *		root->append_rel_list.
- *
- * Note that the original RTE is considered to represent the whole
- * inheritance set.  The first of the generated RTEs is an RTE for the same
- * table, but with inh = false, to represent the parent table in its role
- * as a simple member of the inheritance set.
- *
- * A childless table is never considered to be an inheritance set. For
- * regular inheritance, a parent RTE must always have at least two associated
- * AppendRelInfos: one corresponding to the parent table as a simple member of
- * inheritance set and one or more corresponding to the actual children.
- */
-static void
-expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti,
-						 RelOptInfo *rel)
-{
-	Oid			parentOID;
-	PlanRowMark *oldrc;
-	LOCKMODE	lockmode = rte->rellockmode;
-	List	   *inhOIDs;
-	ListCell   *l;
-	int			num_children;
-	int			num_children_added = 0;
-
-	Assert(rte->rtekind == RTE_RELATION);
-	Assert(lockmode != NoLock);
-	parentOID = rte->relid;
-
-	/* Scan for all members of inheritance set, acquire needed locks */
-	inhOIDs = find_all_inheritors(parentOID, lockmode, NULL);
-
-	/*
-	 * Check that there's at least one descendant, else treat as no-child
-	 * case.  This could happen despite above has_subclass() check, if table
-	 * once had a child but no longer does.
-	 */
-	num_children = list_length(inhOIDs);
-	if (num_children < 2)
-	{
-		/* Clear flag before returning */
-		rte->inh = false;
-		return;
-	}
-
-	/*
-	 * If parent relation is selected FOR UPDATE/SHARE, preprocess_rowmarks
-	 * should've set isParent = true.  We'll generate a new PlanRowMark for
-	 * each child.
-	 */
-	oldrc = get_plan_rowmark(root->rowMarks, rti);
-	Assert(oldrc == NULL || oldrc->isParent);
-
-	/*
-	 * Must expand PlannerInfo arrays by num_children before we can add
-	 * children.
-	 */
-	expand_planner_arrays(root, num_children);
-
-	foreach(l, inhOIDs)
-	{
-		Oid			childOID = lfirst_oid(l);
-		Relation	newrelation;
-		RangeTblEntry *childrte;
-		Index		childRTindex;
-
-		/* Already locked above. */
-		newrelation = heap_open(childOID, NoLock);
-
-		/*
-		 * It is possible that the parent table has children that are temp
-		 * tables of other backends.  We cannot safely access such tables
-		 * (because of buffering issues), and the best thing to do seems
-		 * to be to silently ignore them.
-		 */
-		if (RELATION_IS_OTHER_TEMP(newrelation))
-		{
-			heap_close(newrelation, lockmode);
-			continue;
-		}
-
-		(void) add_inheritance_child_rel(root, rte, rti, rel, oldrc,
-										 newrelation, &childrte,
-										 &childRTindex);
-		Assert(childrte != NULL);
-		/* All regular inheritance children are leaf children. */
-		Assert(!childrte->inh);
-		Assert(childRTindex > 0);
-
-		/* Close child relations, but keep locks */
-		heap_close(newrelation, NoLock);
-		num_children_added++;
-	}
-
-	/*
-	 * If all children, including the parent (as child rel), were
-	 * excluded, mark the parent rel as empty.  If all the children were temp
-	 * tables, pretend it's a non-inheritance situation; we don't need Append
-	 * node in that case.  The duplicate RTE we added for the parent table is
-	 * harmless, so we don't bother to get rid of it; ditto for the useless
-	 * PlanRowMark node.
-	 */
-	if (num_children_added == 0)
-		mark_dummy_rel(rel);
-	else if (num_children_added == 1)
-		rte->inh = false;
-
-	/*
-	 * Add junk columns needed by the row mark if any and also add the
-	 * relevant expressions to the root parent's reltarget.
-	 */
-	if (oldrc)
-	{
-		List   *tlist = add_rowmark_junk_columns(root, oldrc);
-
-		build_base_rel_tlists(root, tlist);
-	}
-}
-
-/*
- * expand_partitioned_rtentry
- *		Prunes unnecessary partitions of a partitioned table and adds
- *		remaining ones to the Query and the PlannerInfo
- *
- * Partitions are added to the query in order in which they are found in
- * the parent's PartitionDesc.
- *
- * Note: even though only the unpruned partitions will be added to the
- * resulting plan, this still locks *all* partitions via find_all_inheritors
- * in order to avoid partitions being locked in a different order than other
- * places in the backend that may lock partitions.
- */
-static void
-expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
-						   Index parentRTindex, RelOptInfo *parentrel)
-{
-	LOCKMODE	lockmode = parentrte->rellockmode;
-	PlanRowMark *rootrc = NULL;
-	int			i;
-	Bitmapset  *partindexes;
-	Index		rootParentRTindex = parentrel->inh_root_parent > 0 ?
-									parentrel->inh_root_parent :
-									parentRTindex;
-
-	/* If root partitioned table, lock *all* partitions in the tree. */
-	if (parentRTindex == rootParentRTindex)
-		(void) find_all_inheritors(parentrte->relid, lockmode, NULL);
-
-	/*
-	 * Initialize partitioned_child_rels to contain this RT index.
-	 *
-	 * Note that during the set_append_rel_pathlist() phase, values of the
-	 * indexes of partitioned relations that appear down in the tree will be
-	 * bubbled up into root parent's list so that when we've created Paths for
-	 * all the children, the root table's list will contain all such indexes.
-	 */
-	parentrel->partitioned_child_rels = list_make1_int(parentRTindex);
-
-	/* Perform pruning. */
-	partindexes = prune_append_rel_partitions(parentrel);
-
-	/* Must expand PlannerInfo arrays before we can add children. */
-	expand_planner_arrays(root, bms_num_members(partindexes));
-
-	/*
-	 * For partitioned tables, we also store the partition RelOptInfo
-	 * pointers in the parent's RelOptInfo.
-	 */
-	parentrel->part_rels = (RelOptInfo **) palloc0(sizeof(RelOptInfo *) *
-												   parentrel->nparts);
-
-	rootrc = get_plan_rowmark(root->rowMarks, rootParentRTindex);
-	Assert(rootrc == NULL || rootrc->isParent);
-	i = -1;
-	while ((i = bms_next_member(partindexes, i)) >= 0)
-	{
-		Oid		childOID = parentrel->part_oids[i];
-		Relation	newrelation;
-		RelOptInfo *childrel;
-		RangeTblEntry *childrte;
-		Index		childRTindex;
-
-		/* Already locked above. */
-		newrelation = heap_open(childOID, NoLock);
-		Assert(!RELATION_IS_OTHER_TEMP(newrelation));
-
-		/*
-		 * A partitioned child table with 0 children is a dummy rel, so don't
-		 * bother creating planner objects for it.
-		 */
-		if (newrelation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE &&
-			RelationGetPartitionDesc(newrelation)->nparts == 0)
-		{
-			heap_close(newrelation, NoLock);
-			continue;
-		}
-
-		childrel = add_inheritance_child_rel(root, parentrte, parentRTindex,
-											 parentrel, rootrc, newrelation,
-											 &childrte, &childRTindex);
-		Assert(childrel != NULL);
-		parentrel->part_rels[i] = childrel;
-
-		/* Close child relations, but keep locks */
-		heap_close(newrelation, NoLock);
-
-		/* If the child is partitioned itself, expand it too. */
-		if (childrel->part_scheme)
-		{
-			Assert(childrte->inh);
-			expand_partitioned_rtentry(root, childrte, childRTindex,
-									   childrel);
-		}
-	}
-
-	/*
-	 * Add junk columns needed by the row mark if any and also add the
-	 * relevant expressions to the root parent's reltarget.
-	 */
-	if (rootrc)
-	{
-		List   *tlist = add_rowmark_junk_columns(root, rootrc);
-
-		build_base_rel_tlists(root, tlist);
-	}
-}
-
-/*
- * add_inheritance_child_rel
- *		Build a RangeTblEntry, an AppendRelInfo, a PlanRowMark, and finally
- *		a RelOptInfo for an inheritance child relation.
- *
- * The return value is the RelOptInfo that's added.
- *
- * PlanRowMarks still carry the top-parent's RTI, and the top-parent's
- * allMarkTypes field still accumulates values from all descendents.
- *
- * "parentrte" and "parentRTindex" are immediate parent's RTE and
- * RTI. "top_parentrc" is top parent's PlanRowMark.
- */
-static RelOptInfo *
-add_inheritance_child_rel(PlannerInfo *root, RangeTblEntry *parentrte,
-						  Index parentRTindex, RelOptInfo *parentrel,
-						  PlanRowMark *top_parentrc, Relation childrel,
-						  RangeTblEntry **childrte_p, Index *childRTindex_p)
-{
-	Query	   *parse = root->parse;
-	Oid			childOID = RelationGetRelid(childrel);
-	RangeTblEntry *childrte;
-	Index		childRTindex;
-	AppendRelInfo *appinfo;
-	RelOptInfo *childrelopt;
-
-	/*
-	 * Build an RTE for the child, and attach to query's rangetable list. We
-	 * copy most fields of the parent's RTE, but replace relation OID and
-	 * relkind, and set inh appropriately.  Also, set requiredPerms to zero
-	 * since all required permissions checks are done on the original RTE.
-	 * Likewise, set the child's securityQuals to empty, because we only want
-	 * to apply the parent's RLS conditions regardless of what RLS properties
-	 * individual children may have.  (This is an intentional choice to make
-	 * inherited RLS work like regular permissions checks.) The parent
-	 * securityQuals will be propagated to children along with other base
-	 * restriction clauses, so we don't need to do it here.
-	 */
-	childrte = copyObject(parentrte);
-	*childrte_p = childrte;
-	childrte->relid = childOID;
-	childrte->relkind = childrel->rd_rel->relkind;
-	/*
-	 * A partitioned child will need to be expanded as an append parent
-	 * itself, so set its inh to true.
-	 */
-	childrte->inh = (childrte->relkind == RELKIND_PARTITIONED_TABLE);
-	childrte->requiredPerms = 0;
-	childrte->securityQuals = NIL;
-	parse->rtable = lappend(parse->rtable, childrte);
-	childRTindex = list_length(parse->rtable);
-	*childRTindex_p = childRTindex;
-
-	/* Create an AppendRelInfo and add it to planner's global list. */
-	appinfo = make_append_rel_info(parentrel, parentrte,
-								   childrel->rd_att,
-								   childOID,
-								   childrel->rd_rel->reltype,
-								   childRTindex);
-	root->append_rel_list = lappend(root->append_rel_list, appinfo);
-
-	/*
-	 * Translate the column permissions bitmaps to the child's attnums (we
-	 * have to build the translated_vars list before we can do this). But
-	 * if this is the parent table, leave copyObject's result alone.
-	 *
-	 * Note: we need to do this even though the executor won't run any
-	 * permissions checks on the child RTE.  The insertedCols/updatedCols
-	 * bitmaps may be examined for trigger-firing purposes.
-	 */
-	if (childrte->relid != parentrte->relid)
-	{
-		childrte->selectedCols = translate_col_privs(parentrte->selectedCols,
-													 appinfo->translated_vars);
-		childrte->insertedCols = translate_col_privs(parentrte->insertedCols,
-													 appinfo->translated_vars);
-		childrte->updatedCols = translate_col_privs(parentrte->updatedCols,
-													appinfo->translated_vars);
-	}
-
-	/*
-	 * Build a PlanRowMark if parent is marked FOR UPDATE/SHARE.
-	 */
-	if (top_parentrc)
-	{
-		PlanRowMark *childrc = makeNode(PlanRowMark);
-
-		childrc->rti = childRTindex;
-		childrc->prti = top_parentrc->rti;
-		childrc->rowmarkId = top_parentrc->rowmarkId;
-		/* Reselect rowmark type, because relkind might not match parent */
-		childrc->markType = select_rowmark_type(childrte,
-												top_parentrc->strength);
-		childrc->allMarkTypes = (1 << childrc->markType);
-		childrc->strength = top_parentrc->strength;
-		childrc->waitPolicy = top_parentrc->waitPolicy;
-
-		/*
-		 * We mark RowMarks for partitioned child tables as parent RowMarks so
-		 * that the executor ignores them (except their existence means that
-		 * the child tables be locked using appropriate mode).
-		 */
-		childrc->isParent = (childrte->relkind == RELKIND_PARTITIONED_TABLE);
-
-		/* Include child's rowmark type in top parent's allMarkTypes */
-		top_parentrc->allMarkTypes |= childrc->allMarkTypes;
-
-		root->rowMarks = lappend(root->rowMarks, childrc);
-	}
-
-	/*
-	 * Add the RelOptInfo.  Even though we may not really scan this relation
-	 * for reasons such as contradictory quals, we still need need to create
-	 * one, because for every RTE in the query's range table, there must be an
-	 * accompanying RelOptInfo.
-	 */
-
-	/* First, store the RTE and appinfos into planner arrays. */
-	Assert(root->simple_rte_array[childRTindex] == NULL);
-	root->simple_rte_array[childRTindex] = childrte;
-	Assert(root->append_rel_array[childRTindex] == NULL);
-	root->append_rel_array[childRTindex] = appinfo;
-
-	childrelopt = build_append_child_rel(root, parentrel, childRTindex);
-	Assert(childrelopt != NULL);
-
-	return childrelopt;
-}
-
-/*
- * make_inh_translation_list
- *	  Build the list of translations from parent Vars to child Vars for
- *	  an inheritance child.
- *
- * For paranoia's sake, we match type/collation as well as attribute name.
- */
-static void
-make_inh_translation_list(TupleDesc old_tupdesc, TupleDesc new_tupdesc,
-						  Oid from_rel, Oid to_rel,
-						  Index newvarno, List **translated_vars)
-{
-	List	   *vars = NIL;
-	int			oldnatts = old_tupdesc->natts;
-	int			newnatts = new_tupdesc->natts;
-	int			old_attno;
-	int			new_attno = 0;
-
-	for (old_attno = 0; old_attno < oldnatts; old_attno++)
-	{
-		Form_pg_attribute att;
-		char	   *attname;
-		Oid			atttypid;
-		int32		atttypmod;
-		Oid			attcollation;
-
-		att = TupleDescAttr(old_tupdesc, old_attno);
-		if (att->attisdropped)
-		{
-			/* Just put NULL into this list entry */
-			vars = lappend(vars, NULL);
-			continue;
-		}
-		attname = NameStr(att->attname);
-		atttypid = att->atttypid;
-		atttypmod = att->atttypmod;
-		attcollation = att->attcollation;
-
-		/*
-		 * When we are generating the "translation list" for the parent table
-		 * of an inheritance set, no need to search for matches.
-		 */
-		if (from_rel == to_rel)
-		{
-			vars = lappend(vars, makeVar(newvarno,
-										 (AttrNumber) (old_attno + 1),
-										 atttypid,
-										 atttypmod,
-										 attcollation,
-										 0));
-			continue;
-		}
-
-		/*
-		 * Otherwise we have to search for the matching column by name.
-		 * There's no guarantee it'll have the same column position, because
-		 * of cases like ALTER TABLE ADD COLUMN and multiple inheritance.
-		 * However, in simple cases, the relative order of columns is mostly
-		 * the same in both relations, so try the column of newrelation that
-		 * follows immediately after the one that we just found, and if that
-		 * fails, let syscache handle it.
-		 */
-		if (new_attno >= newnatts ||
-			(att = TupleDescAttr(new_tupdesc, new_attno))->attisdropped ||
-			strcmp(attname, NameStr(att->attname)) != 0)
-		{
-			HeapTuple	newtup;
-
-			newtup = SearchSysCacheAttName(to_rel, attname);
-			if (!newtup)
-				elog(ERROR, "could not find inherited attribute \"%s\" of relation \"%s\"",
-					 attname, get_rel_name(to_rel));
-			new_attno = ((Form_pg_attribute) GETSTRUCT(newtup))->attnum - 1;
-			ReleaseSysCache(newtup);
-
-			att = TupleDescAttr(new_tupdesc, new_attno);
-		}
-
-		/* Found it, check type and collation match */
-		if (atttypid != att->atttypid || atttypmod != att->atttypmod)
-			elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's type",
-				 attname, get_rel_name(to_rel));
-		if (attcollation != att->attcollation)
-			elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's collation",
-				 attname, get_rel_name(to_rel));
-
-		vars = lappend(vars, makeVar(newvarno,
-									 (AttrNumber) (new_attno + 1),
-									 atttypid,
-									 atttypmod,
-									 attcollation,
-									 0));
-		new_attno++;
-	}
-
-	*translated_vars = vars;
-}
-
-/*
- * translate_col_privs
- *	  Translate a bitmapset representing per-column privileges from the
- *	  parent rel's attribute numbering to the child's.
- *
- * The only surprise here is that we don't translate a parent whole-row
- * reference into a child whole-row reference.  That would mean requiring
- * permissions on all child columns, which is overly strict, since the
- * query is really only going to reference the inherited columns.  Instead
- * we set the per-column bits for all inherited columns.
- */
-static Bitmapset *
-translate_col_privs(const Bitmapset *parent_privs,
-					List *translated_vars)
-{
-	Bitmapset  *child_privs = NULL;
-	bool		whole_row;
-	int			attno;
-	ListCell   *lc;
-
-	/* System attributes have the same numbers in all tables */
-	for (attno = FirstLowInvalidHeapAttributeNumber + 1; attno < 0; attno++)
-	{
-		if (bms_is_member(attno - FirstLowInvalidHeapAttributeNumber,
-						  parent_privs))
-			child_privs = bms_add_member(child_privs,
-										 attno - FirstLowInvalidHeapAttributeNumber);
-	}
-
-	/* Check if parent has whole-row reference */
-	whole_row = bms_is_member(InvalidAttrNumber - FirstLowInvalidHeapAttributeNumber,
-							  parent_privs);
-
-	/* And now translate the regular user attributes, using the vars list */
-	attno = InvalidAttrNumber;
-	foreach(lc, translated_vars)
-	{
-		Var		   *var = lfirst_node(Var, lc);
-
-		attno++;
-		if (var == NULL)		/* ignore dropped columns */
-			continue;
-		if (whole_row ||
-			bms_is_member(attno - FirstLowInvalidHeapAttributeNumber,
-						  parent_privs))
-			child_privs = bms_add_member(child_privs,
-										 var->varattno - FirstLowInvalidHeapAttributeNumber);
-	}
-
-	return child_privs;
-}
-
-/*
- *	build_append_child_rel
- *		Build a RelOptInfo for child relation of an append rel
- *
- * After creating the RelOptInfo for the given child RT index, it goes on to
- * initialize some of its fields base on the parent RelOptInfo.
- *
- * If the quals in baserestrictinfo turns out to be self-contradictory, the
- * RelOptInfo is marked dummy before returning.
- */
-static RelOptInfo *
-build_append_child_rel(PlannerInfo *root,
-					   RelOptInfo *parent,
-					   Index childRTindex)
-{
-	RelOptInfo *childrel;
-	RangeTblEntry *childRTE = root->simple_rte_array[childRTindex];
-	AppendRelInfo *appinfo = root->append_rel_array[childRTindex];
-	List	   *childquals;
-	ListCell   *lc;
-	bool		have_const_false_cq;
-	Index		cq_min_security;
-
-	/* Build the RelOptInfo. */
-	childrel = build_simple_rel(root, childRTindex, parent);
-
-	/*
-	 * Propagate lateral_relids and lateral_referencers from appendrel
-	 * parent rels to their child rels.  We intentionally give each child rel
-	 * the same minimum parameterization, even though it's quite possible that
-	 * some don't reference all the lateral rels.  This is because any append
-	 * path for the parent will have to have the same parameterization for
-	 * every child anyway, and there's no value in forcing extra
-	 * reparameterize_path() calls.  Similarly, a lateral reference to the
-	 * parent prevents use of otherwise-movable join rels for each child.
-	 */
-	childrel->direct_lateral_relids = parent->direct_lateral_relids;
-	childrel->lateral_relids = parent->lateral_relids;
-	childrel->lateral_referencers = parent->lateral_referencers;
-
-	/*
-	 * We have to copy the parent's quals to the child, with appropriate
-	 * substitution of variables.  However, only the baserestrictinfo
-	 * quals are needed before we can check for constraint exclusion; so
-	 * do that first and then check to see if we can disregard this child.
-	 *
-	 * The child rel's targetlist might contain non-Var expressions, which
-	 * means that substitution into the quals could produce opportunities
-	 * for const-simplification, and perhaps even pseudoconstant quals.
-	 * Therefore, transform each RestrictInfo separately to see if it
-	 * reduces to a constant or pseudoconstant.  (We must process them
-	 * separately to keep track of the security level of each qual.)
-	 */
-	childquals = false;
-	cq_min_security = UINT_MAX;
-	have_const_false_cq = false;
-	foreach(lc, parent->baserestrictinfo)
-	{
-		RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
-		Node	   *childqual = (Node *) rinfo->clause;
-		ListCell   *lc2;
-
-		Assert(IsA(rinfo, RestrictInfo));
-		childqual = adjust_appendrel_attrs(root, childqual,
-										   1, &appinfo);
-		childqual = eval_const_expressions(root, childqual);
-		/* check for flat-out constant */
-		if (childqual && IsA(childqual, Const))
-		{
-			if (((Const *) childqual)->constisnull ||
-				!DatumGetBool(((Const *) childqual)->constvalue))
-			{
-				/* Restriction reduces to constant FALSE or NULL */
-				have_const_false_cq = true;
-				break;
-			}
-			/* Restriction reduces to constant TRUE, so drop it */
-			continue;
-		}
-		/* might have gotten an AND clause, if so flatten it */
-		foreach(lc2, make_ands_implicit((Expr *) childqual))
-		{
-			Node	   *onecq = (Node *) lfirst(lc2);
-			bool		pseudoconstant;
-
-			/* check for pseudoconstant (no Vars or volatile functions) */
-			pseudoconstant =
-					!contain_vars_of_level(onecq, 0) &&
-					!contain_volatile_functions(onecq);
-			if (pseudoconstant)
-			{
-				/* tell createplan.c to check for gating quals */
-				root->hasPseudoConstantQuals = true;
-			}
-			/* reconstitute RestrictInfo with appropriate properties */
-			childquals = lappend(childquals,
-								 make_restrictinfo((Expr *) onecq,
-												   rinfo->is_pushed_down,
-												   rinfo->outerjoin_delayed,
-												   pseudoconstant,
-												   rinfo->security_level,
-												   NULL, NULL, NULL));
-			cq_min_security = Min(cq_min_security, rinfo->security_level);
-		}
-	}
-
-	/*
-	 * In addition to the quals inherited from the parent, we might
-	 * have securityQuals associated with this particular child node.
-	 * (Currently this can only happen in appendrels originating from
-	 * UNION ALL; inheritance child tables don't have their own
-	 * securityQuals.)	Pull any such securityQuals up into the
-	 * baserestrictinfo for the child.  This is similar to
-	 * process_security_barrier_quals() for the parent rel, except
-	 * that we can't make any general deductions from such quals,
-	 * since they don't hold for the whole appendrel.
-	 */
-	if (childRTE->securityQuals)
-	{
-		Index		security_level = 0;
-
-		foreach(lc, childRTE->securityQuals)
-		{
-			List	   *qualset = (List *) lfirst(lc);
-			ListCell   *lc2;
-
-			foreach(lc2, qualset)
-			{
-				Expr	   *qual = (Expr *) lfirst(lc2);
-
-				/*
-				 * not likely that we'd see constants here, so no
-				 * check
-				 */
-				childquals = lappend(childquals,
-									 make_restrictinfo(qual,
-													   true,
-													   false,
-													   false,
-													   security_level,
-													   NULL, NULL,
-													   NULL));
-				cq_min_security = Min(cq_min_security, security_level);
-			}
-			security_level++;
-		}
-		Assert(security_level <= root->qual_security_level);
-	}
-
-	/* Set child's version of baserestrictinfo. */
-	childrel->baserestrictinfo = childquals;
-	childrel->baserestrict_min_security = cq_min_security;
-
-	if (have_const_false_cq)
-	{
-		/*
-		 * Some restriction clause reduced to constant FALSE or NULL after
-		 * substitution, so this child need not be scanned.
-		 */
-		set_dummy_rel_pathlist(childrel);
-	}
-
-	return childrel;
-}
-
-/*
- * add_rowmark_junk_columns
- * 		Add necessary junk columns for rowmarked inheritance parent rel.
- *
- * These values are needed for locking of rels selected FOR UPDATE/SHARE, and
- * to do EvalPlanQual rechecking.  See comments for PlanRowMark in
- * plannodes.h.
- */
-static List *
-add_rowmark_junk_columns(PlannerInfo *root, PlanRowMark *rc)
-{
-	List   *tlist = root->processed_tlist;
-	Var		   *var;
-	char		resname[32];
-	TargetEntry *tle;
-
-	if (rc->allMarkTypes & ~(1 << ROW_MARK_COPY))
-	{
-		/* Need to fetch TID */
-		var = makeVar(rc->rti,
-					  SelfItemPointerAttributeNumber,
-					  TIDOID,
-					  -1,
-					  InvalidOid,
-					  0);
-		snprintf(resname, sizeof(resname), "ctid%u", rc->rowmarkId);
-		tle = makeTargetEntry((Expr *) var,
-							  list_length(tlist) + 1,
-							  pstrdup(resname),
-							  true);
-		tlist = lappend(tlist, tle);
-	}
-	if (rc->allMarkTypes & (1 << ROW_MARK_COPY))
-	{
-		/* Need the whole row as a junk var */
-		var = makeWholeRowVar(root->simple_rte_array[rc->rti],
-							  rc->rti,
-							  0,
-							  false);
-		snprintf(resname, sizeof(resname), "wholerow%u", rc->rowmarkId);
-		tle = makeTargetEntry((Expr *) var,
-							  list_length(tlist) + 1,
-							  pstrdup(resname),
-							  true);
-		tlist = lappend(tlist, tle);
-	}
-
-	/* For inheritance cases, always fetch the tableoid too. */
-	var = makeVar(rc->rti,
-				  TableOidAttributeNumber,
-				  OIDOID,
-				  -1,
-				  InvalidOid,
-				  0);
-	snprintf(resname, sizeof(resname), "tableoid%u", rc->rowmarkId);
-	tle = makeTargetEntry((Expr *) var,
-						  list_length(tlist) + 1,
-						  pstrdup(resname),
-						  true);
-	tlist = lappend(tlist, tle);
-
-	return tlist;
-}
-
-AppendRelInfo *
-make_append_rel_info(RelOptInfo *parentrel, RangeTblEntry *parentrte,
-					 TupleDesc childdesc, Oid childoid, Oid childreltype,
-					 Index childRTindex)
-{
-	AppendRelInfo  *appinfo = makeNode(AppendRelInfo);
-
-	appinfo->parent_relid = parentrel->relid;
-	appinfo->child_relid = childRTindex;
-	appinfo->parent_reltype = parentrel->reltype;
-	appinfo->child_reltype = childreltype;
-	make_inh_translation_list(parentrel->tupdesc, childdesc,
-							  parentrte->relid, childoid,
-							  childRTindex,
-							  &appinfo->translated_vars);
-	appinfo->parent_reloid = parentrte->relid;
-
-	return appinfo;
-}
-
-/*
- * adjust_appendrel_attrs
- *	  Copy the specified query or expression and translate Vars referring to a
- *	  parent rel to refer to the corresponding child rel instead.  We also
- *	  update rtindexes appearing outside Vars, such as resultRelation and
- *	  jointree relids.
- *
- * Note: this is only applied after conversion of sublinks to subplans,
- * so we don't need to cope with recursion into sub-queries.
- *
- * Note: this is not hugely different from what pullup_replace_vars() does;
- * maybe we should try to fold the two routines together.
- */
-Node *
-adjust_appendrel_attrs(PlannerInfo *root, Node *node, int nappinfos,
-					   AppendRelInfo **appinfos)
-{
-	Node	   *result;
-	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);
-
-	/*
-	 * Must be prepared to start with a Query or a bare expression tree.
-	 */
-	if (node && IsA(node, Query))
-	{
-		Query	   *newnode;
-		int			cnt;
-
-		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;
-}
-
-static Node *
-adjust_appendrel_attrs_mutator(Node *node,
-							   adjust_appendrel_attrs_context *context)
-{
-	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;
-
-		for (cnt = 0; cnt < nappinfos; cnt++)
-		{
-			if (var->varno == appinfos[cnt]->parent_relid)
-			{
-				appinfo = appinfos[cnt];
-				break;
-			}
-		}
-
-		if (var->varlevelsup == 0 && appinfo)
-		{
-			var->varno = appinfo->child_relid;
-			var->varnoold = appinfo->child_relid;
-			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));
-				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;
-
-					return (Node *) rowexpr;
-				}
-			}
-			/* system attributes don't need any other translation */
-		}
-		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, 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 */
-		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, context->nappinfos,
-											  context->appinfos);
-		return (Node *) phv;
-	}
-
-	/*
-	 * This is needed, because inheritance_make_rel_from_joinlist needs to
-	 * translate root->join_info_list executing make_rel_from_joinlist for a
-	 * given child.
-	 */
-	if (IsA(node, SpecialJoinInfo))
-	{
-		SpecialJoinInfo *oldinfo = (SpecialJoinInfo *) node;
-		SpecialJoinInfo *newinfo = makeNode(SpecialJoinInfo);
-
-		memcpy(newinfo, oldinfo, sizeof(SpecialJoinInfo));
-		newinfo->min_lefthand = adjust_child_relids(oldinfo->min_lefthand,
-													context->nappinfos,
-													context->appinfos);
-		newinfo->min_righthand = adjust_child_relids(oldinfo->min_righthand,
-													 context->nappinfos,
-													 context->appinfos);
-		newinfo->syn_lefthand = adjust_child_relids(oldinfo->syn_lefthand,
-													context->nappinfos,
-													context->appinfos);
-		newinfo->syn_righthand = adjust_child_relids(oldinfo->syn_righthand,
-													 context->nappinfos,
-													 context->appinfos);
-		newinfo->semi_rhs_exprs =
-					(List *) expression_tree_mutator((Node *)
-													 oldinfo->semi_rhs_exprs,
-													 adjust_appendrel_attrs_mutator,
-													 (void *) context);
-		return (Node *) newinfo;
-	}
-
-	/* Shouldn't need to handle planner auxiliary nodes here */
-	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 */
-		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->nullable_relids = adjust_child_relids(oldinfo->nullable_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));
-
-	return expression_tree_mutator(node, adjust_appendrel_attrs_mutator,
-								   (void *) context);
-}
-
-/*
- * Substitute child relids for parent relids in a Relid set.  The array of
- * appinfos specifies the substitutions to be performed.
- */
-static Relids
-adjust_child_relids(Relids relids, int nappinfos, AppendRelInfo **appinfos)
-{
-	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;
-}
-
-/*
- * Replace any relid present in top_parent_relids with its child in
- * child_relids. Members of child_relids can be multiple levels below top
- * parent in the partition hierarchy.
- */
-Relids
-adjust_child_relids_multilevel(PlannerInfo *root, Relids relids,
-							   Relids child_relids, Relids top_parent_relids)
-{
-	AppendRelInfo **appinfos;
-	int			nappinfos;
-	Relids		parent_relids = NULL;
-	Relids		result;
-	Relids		tmp_result = NULL;
-	int			cnt;
-
-	/*
-	 * If the given relids set doesn't contain any of the top parent relids,
-	 * it will remain unchanged.
-	 */
-	if (!bms_overlap(relids, top_parent_relids))
-		return relids;
-
-	appinfos = find_appinfos_by_relids(root, child_relids, &nappinfos);
-
-	/* Construct relids set for the immediate parent of the given child. */
-	for (cnt = 0; cnt < nappinfos; cnt++)
-	{
-		AppendRelInfo *appinfo = appinfos[cnt];
-
-		parent_relids = bms_add_member(parent_relids, appinfo->parent_relid);
-	}
-
-	/* Recurse if immediate parent is not the top parent. */
-	if (!bms_equal(parent_relids, top_parent_relids))
-	{
-		tmp_result = adjust_child_relids_multilevel(root, relids,
-													parent_relids,
-													top_parent_relids);
-		relids = tmp_result;
-	}
-
-	result = adjust_child_relids(relids, nappinfos, appinfos);
-
-	/* Free memory consumed by any intermediate result. */
-	if (tmp_result)
-		bms_free(tmp_result);
-	bms_free(parent_relids);
-	pfree(appinfos);
-
-	return result;
-}
-
-/*
- * 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.
- */
-static List *
-adjust_inherited_tlist(List *tlist, AppendRelInfo *context)
-{
-	bool		changed_it = false;
-	ListCell   *tl;
-	List	   *new_tlist;
-	bool		more;
-	int			attrno;
-
-	/* 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)
-	{
-		TargetEntry *tle = (TargetEntry *) lfirst(tl);
-		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))
-			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);
-		if (childvar == NULL || !IsA(childvar, Var))
-			elog(ERROR, "attribute %d of relation \"%s\" does not exist",
-				 tle->resno, get_rel_name(context->parent_reloid));
-
-		if (tle->resno != childvar->varattno)
-		{
-			tle->resno = childvar->varattno;
-			changed_it = true;
-		}
-	}
-
-	/*
-	 * 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;
-
-	new_tlist = NIL;
-	more = true;
-	for (attrno = 1; more; attrno++)
-	{
-		more = false;
-		foreach(tl, tlist)
-		{
-			TargetEntry *tle = (TargetEntry *) lfirst(tl);
-
-			if (tle->resjunk)
-				continue;		/* ignore junk items */
-
-			if (tle->resno == attrno)
-				new_tlist = lappend(new_tlist, tle);
-			else if (tle->resno > attrno)
-				more = true;
-		}
-	}
-
-	foreach(tl, tlist)
-	{
-		TargetEntry *tle = (TargetEntry *) lfirst(tl);
-
-		if (!tle->resjunk)
-			continue;			/* here, ignore non-junk items */
-
-		tle->resno = attrno;
-		new_tlist = lappend(new_tlist, tle);
-		attrno++;
-	}
-
-	return new_tlist;
-}
-
-/*
- * adjust_appendrel_attrs_multilevel
- *	  Apply Var translations from a toplevel appendrel parent down to a child.
- *
- * In some cases we need to translate expressions referencing a parent relation
- * to reference an appendrel child that's multiple levels removed from it.
- */
-Node *
-adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node,
-								  Relids child_relids,
-								  Relids top_parent_relids)
-{
-	AppendRelInfo **appinfos;
-	Bitmapset  *parent_relids = NULL;
-	int			nappinfos;
-	int			cnt;
-
-	Assert(bms_num_members(child_relids) == bms_num_members(top_parent_relids));
-
-	appinfos = find_appinfos_by_relids(root, child_relids, &nappinfos);
-
-	/* Construct relids set for the immediate parent of given child. */
-	for (cnt = 0; cnt < nappinfos; cnt++)
-	{
-		AppendRelInfo *appinfo = appinfos[cnt];
-
-		parent_relids = bms_add_member(parent_relids, appinfo->parent_relid);
-	}
-
-	/* Recurse if immediate parent is not the top parent. */
-	if (!bms_equal(parent_relids, top_parent_relids))
-		node = adjust_appendrel_attrs_multilevel(root, node, parent_relids,
-												 top_parent_relids);
-
-	/* Now translate for this child */
-	node = adjust_appendrel_attrs(root, node, nappinfos, appinfos);
-
-	pfree(appinfos);
-
-	return node;
-}
-
-/*
- * Construct the SpecialJoinInfo for a child-join by translating
- * SpecialJoinInfo for the join between parents. left_relids and right_relids
- * are the relids of left and right side of the join respectively.
- */
-SpecialJoinInfo *
-build_child_join_sjinfo(PlannerInfo *root, SpecialJoinInfo *parent_sjinfo,
-						Relids left_relids, Relids right_relids)
-{
-	SpecialJoinInfo *sjinfo = makeNode(SpecialJoinInfo);
-	AppendRelInfo **left_appinfos;
-	int			left_nappinfos;
-	AppendRelInfo **right_appinfos;
-	int			right_nappinfos;
-
-	memcpy(sjinfo, parent_sjinfo, sizeof(SpecialJoinInfo));
-	left_appinfos = find_appinfos_by_relids(root, left_relids,
-											&left_nappinfos);
-	right_appinfos = find_appinfos_by_relids(root, right_relids,
-											 &right_nappinfos);
-
-	sjinfo->min_lefthand = adjust_child_relids(sjinfo->min_lefthand,
-											   left_nappinfos, left_appinfos);
-	sjinfo->min_righthand = adjust_child_relids(sjinfo->min_righthand,
-												right_nappinfos,
-												right_appinfos);
-	sjinfo->syn_lefthand = adjust_child_relids(sjinfo->syn_lefthand,
-											   left_nappinfos, left_appinfos);
-	sjinfo->syn_righthand = adjust_child_relids(sjinfo->syn_righthand,
-												right_nappinfos,
-												right_appinfos);
-	sjinfo->semi_rhs_exprs = (List *) adjust_appendrel_attrs(root,
-															 (Node *) sjinfo->semi_rhs_exprs,
-															 right_nappinfos,
-															 right_appinfos);
-
-	pfree(left_appinfos);
-	pfree(right_appinfos);
-
-	return sjinfo;
-}
-
-/*
- * find_appinfos_by_relids
- * 		Find AppendRelInfo structures for all relations specified by relids.
- *
- * The AppendRelInfos are returned in an array, which can be pfree'd by the
- * caller. *nappinfos is set to the number of entries in the array.
- */
-AppendRelInfo **
-find_appinfos_by_relids(PlannerInfo *root, Relids relids, int *nappinfos)
-{
-	AppendRelInfo **appinfos;
-	int			cnt = 0;
-	int			i;
-
-	*nappinfos = bms_num_members(relids);
-	appinfos = (AppendRelInfo **) palloc(sizeof(AppendRelInfo *) * *nappinfos);
-
-	i = -1;
-	while ((i = bms_next_member(relids, i)) >= 0)
-	{
-		AppendRelInfo *appinfo = root->append_rel_array[i];
-
-		if (!appinfo)
-			elog(ERROR, "child rel %d not found in append_rel_array", i);
-
-		appinfos[cnt++] = appinfo;
-	}
-	return appinfos;
-}
diff --git a/src/backend/optimizer/util/Makefile b/src/backend/optimizer/util/Makefile
index da9ccf32b4..d166030a10 100644
--- a/src/backend/optimizer/util/Makefile
+++ b/src/backend/optimizer/util/Makefile
@@ -12,7 +12,8 @@ subdir = src/backend/optimizer/util
 top_builddir = ../../../..
 include $(top_builddir)/src/Makefile.global
 
-OBJS = clauses.o joininfo.o orclauses.o pathnode.o placeholder.o \
-	   plancat.o predtest.o relnode.o restrictinfo.o tlist.o var.o
+OBJS = append.o appendinfo.o clauses.o joininfo.o orclauses.o pathnode.o \
+	   placeholder.o plancat.o predtest.o relnode.o restrictinfo.o tlist.o \
+	   var.o
 
 include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/optimizer/util/append.c b/src/backend/optimizer/util/append.c
new file mode 100644
index 0000000000..d2ad80034f
--- /dev/null
+++ b/src/backend/optimizer/util/append.c
@@ -0,0 +1,777 @@
+/*-------------------------------------------------------------------------
+ *
+ * append.c
+ *	  Routines to process children of an appendrel parent
+ *
+ * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/optimizer/path/append.c
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include <limits.h>
+
+#include "access/sysattr.h"
+#include "catalog/partition.h"
+#include "catalog/pg_class.h"
+#include "catalog/pg_inherits.h"
+#include "catalog/pg_type.h"
+#include "nodes/makefuncs.h"
+#include "optimizer/append.h"
+#include "optimizer/appendinfo.h"
+#include "optimizer/clauses.h"
+#include "optimizer/pathnode.h"
+#include "optimizer/paths.h"
+#include "optimizer/plancat.h"
+#include "optimizer/planmain.h"
+#include "optimizer/planner.h"
+#include "optimizer/prep.h"
+#include "optimizer/restrictinfo.h"
+#include "optimizer/tlist.h"
+#include "optimizer/var.h"
+#include "partitioning/partprune.h"
+#include "utils/rel.h"
+
+static void expand_append_rtentry(PlannerInfo *root, RelOptInfo *rel,
+					  RangeTblEntry *rte, Index rti);
+static void expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte,
+						 Index rti, RelOptInfo *rel);
+static void expand_partitioned_rtentry(PlannerInfo *root,
+						   RangeTblEntry *parentrte,
+						   Index parentRTindex, RelOptInfo *parentrel);
+static RelOptInfo *add_inheritance_child_rel(PlannerInfo *root,
+						  RangeTblEntry *parentrte,
+						  Index parentRTindex, RelOptInfo *parentrel,
+						  PlanRowMark *top_parentrc, Relation childrel,
+						  RangeTblEntry **childrte_p, Index *childRTindex_p);
+static RelOptInfo *build_append_child_rel(PlannerInfo *root,
+					   RelOptInfo *parent,
+					   Index childRTindex);
+static List *add_rowmark_junk_columns(PlannerInfo *root, PlanRowMark *rc);
+
+
+/*
+ * expand_inherited_tables
+ *		Expand each rangetable entry that represents an inheritance set
+ *		into an "append relation".  At the conclusion of this process,
+ *		the "inh" flag is set in all and only those RTEs that are append
+ *		relation parents.
+ */
+void
+expand_inherited_tables(PlannerInfo *root)
+{
+	int			orig_rtable_size;
+	Index		rti;
+
+	Assert(root->simple_rel_array_size > 0);
+	orig_rtable_size = root->simple_rel_array_size;
+
+	/*
+	 * expand_append_rtentry may add RTEs to parse->rtable. The function is
+	 * expected to recursively handle any RTEs that it creates with inh=true.
+	 * So just scan as far as the original end of the rtable list.
+	 */
+	for (rti = 1; rti < orig_rtable_size; rti++)
+	{
+		RelOptInfo *brel = root->simple_rel_array[rti];
+		RangeTblEntry *rte = root->simple_rte_array[rti];
+
+		/* there may be empty slots corresponding to non-baserel RTEs */
+		if (brel == NULL)
+			continue;
+
+		if (rte->inh)
+			expand_append_rtentry(root, brel, rte, rti);
+	}
+}
+
+/*
+ * expand_append_rtentry
+ *		This initializes RelOptInfos for an appendrel's child relations, if
+ *		any
+ *
+ * 'rel' is the appendrel parent, whose range table entry ('rte') has been
+ * marked to require adding children.  An appendrel parent could either
+ * be a subquery (if we flattened UNION ALL query) or a table that's known
+ * to have inheritance children.  The latter consists of both regular
+ * inheritance parents and partitioned tables.
+ *
+ * For a subquery parent, there is not much to be done here because the
+ * children's RTEs are already present in the query, so we just initialize
+ * RelOptInfos for them.  Also, the AppendRelInfos for child subqueries
+ * have already been added.
+ *
+ * For tables, we need to add the children to the range table and initialize
+ * AppendRelInfos, RelOptInfos, and PlanRowMarks (if any) for them.  For
+ * a partitioned parent, we only add the children remaining after pruning.
+ * For regular inheritance parents, we find the children using
+ * find_all_inheritors and add all of them.
+ *
+ * If it turns out that there are no children, then we set rte->inh to false
+ * to let the caller know that only the parent table needs to be scanned.  The
+ * caller can accordingly switch to a non-Append path.  For a partitioned
+ * parent, that means an empty relation because parents themselves contain no
+ * data.
+ *
+ * For the regular inheritance case, the parent also gets another RTE with
+ * inh = false to represent it as an appendrel child.  The original RTE is
+ * considered to represent the whole inheritance set.
+ */
+static void
+expand_append_rtentry(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte,
+					  Index rti)
+{
+	Assert(rte->inh);
+	/* Inheritance parent (partitioned or not) or UNION ALL parent subquery. */
+	Assert(rte->rtekind == RTE_RELATION || rte->rtekind == RTE_SUBQUERY);
+
+	/*
+	 * UNION ALL children already got RTEs and AppendRelInfos, so just build
+	 * RelOptInfos and return.
+	 *
+	 * It might be a bit odd that this code is in this, because there is
+	 * nothing to expand really.
+	 */
+	if (rte->rtekind == RTE_SUBQUERY)
+	{
+		ListCell   *l;
+
+		/*
+		 * We don't need to use expand_planner_arrays in this case, because
+		 * no new child RTEs are created.  setup_simple_rel_arrays() and
+		 * setup_append_rel_array would've considered these child RTEs when
+		 * allocating space for various arrays.
+		 */
+		foreach(l, root->append_rel_list)
+		{
+			AppendRelInfo *appinfo = lfirst(l);
+			Index		childRTindex = appinfo->child_relid;
+
+			if (appinfo->parent_relid != rti)
+				continue;
+
+			Assert(childRTindex < root->simple_rel_array_size);
+			Assert(root->simple_rte_array[childRTindex] != NULL);
+
+			/*
+			 * We set the correct value of baserestricinfo and
+			 * baserestrict_min_security below.
+			 */
+			root->simple_rel_array[childRTindex] =
+				build_append_child_rel(root, rel, appinfo->child_relid);
+		}
+	}
+	else
+	{
+		Assert(rte->rtekind == RTE_RELATION);
+		Assert(has_subclass(rte->relid));
+
+		/*
+		 * The rewriter should already have obtained an appropriate lock on
+		 * each relation named in the query.  However, for each child relation
+		 * we add to the query, we must obtain an appropriate lock, because
+		 * this will be the first use of those relations in the
+		 * parse/rewrite/plan pipeline.  Child rels should use the same
+		 * lockmode as their parent.
+		 */
+		Assert(rte->rellockmode != NoLock);
+
+		if (rte->relkind == RELKIND_PARTITIONED_TABLE)
+			expand_partitioned_rtentry(root, rte, rti, rel);
+		else
+			expand_inherited_rtentry(root, rte, rti, rel);
+	}
+}
+
+/*
+ * expand_inherited_rtentry
+ *		Add entries for all the child tables to the query's rangetable, and
+ *		build AppendRelInfo nodes for all the child tables and add them to
+ *		root->append_rel_list.
+ *
+ * Note that the original RTE is considered to represent the whole
+ * inheritance set.  The first of the generated RTEs is an RTE for the same
+ * table, but with inh = false, to represent the parent table in its role
+ * as a simple member of the inheritance set.
+ *
+ * A childless table is never considered to be an inheritance set. For
+ * regular inheritance, a parent RTE must always have at least two associated
+ * AppendRelInfos: one corresponding to the parent table as a simple member of
+ * inheritance set and one or more corresponding to the actual children.
+ */
+static void
+expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti,
+						 RelOptInfo *rel)
+{
+	Oid			parentOID;
+	PlanRowMark *oldrc;
+	LOCKMODE	lockmode = rte->rellockmode;
+	List	   *inhOIDs;
+	ListCell   *l;
+	int			num_children;
+	int			num_children_added = 0;
+
+	Assert(rte->rtekind == RTE_RELATION);
+	Assert(lockmode != NoLock);
+	parentOID = rte->relid;
+
+	/* Scan for all members of inheritance set, acquire needed locks */
+	inhOIDs = find_all_inheritors(parentOID, lockmode, NULL);
+
+	/*
+	 * Check that there's at least one descendant, else treat as no-child
+	 * case.  This could happen despite above has_subclass() check, if table
+	 * once had a child but no longer does.
+	 */
+	num_children = list_length(inhOIDs);
+	if (num_children < 2)
+	{
+		/* Clear flag before returning */
+		rte->inh = false;
+		return;
+	}
+
+	/*
+	 * If parent relation is selected FOR UPDATE/SHARE, preprocess_rowmarks
+	 * should've set isParent = true.  We'll generate a new PlanRowMark for
+	 * each child.
+	 */
+	oldrc = get_plan_rowmark(root->rowMarks, rti);
+	Assert(oldrc == NULL || oldrc->isParent);
+
+	/*
+	 * Must expand PlannerInfo arrays by num_children before we can add
+	 * children.
+	 */
+	expand_planner_arrays(root, num_children);
+
+	foreach(l, inhOIDs)
+	{
+		Oid			childOID = lfirst_oid(l);
+		Relation	newrelation;
+		RangeTblEntry *childrte;
+		Index		childRTindex;
+
+		/* Already locked above. */
+		newrelation = heap_open(childOID, NoLock);
+
+		/*
+		 * It is possible that the parent table has children that are temp
+		 * tables of other backends.  We cannot safely access such tables
+		 * (because of buffering issues), and the best thing to do seems
+		 * to be to silently ignore them.
+		 */
+		if (RELATION_IS_OTHER_TEMP(newrelation))
+		{
+			heap_close(newrelation, lockmode);
+			continue;
+		}
+
+		(void) add_inheritance_child_rel(root, rte, rti, rel, oldrc,
+										 newrelation, &childrte,
+										 &childRTindex);
+		Assert(childrte != NULL);
+		/* All regular inheritance children are leaf children. */
+		Assert(!childrte->inh);
+		Assert(childRTindex > 0);
+
+		/* Close child relations, but keep locks */
+		heap_close(newrelation, NoLock);
+		num_children_added++;
+	}
+
+	/*
+	 * If all children, including the parent (as child rel), were
+	 * excluded, mark the parent rel as empty.  If all the children were temp
+	 * tables, pretend it's a non-inheritance situation; we don't need Append
+	 * node in that case.  The duplicate RTE we added for the parent table is
+	 * harmless, so we don't bother to get rid of it; ditto for the useless
+	 * PlanRowMark node.
+	 */
+	if (num_children_added == 0)
+		mark_dummy_rel(rel);
+	else if (num_children_added == 1)
+		rte->inh = false;
+
+	/*
+	 * Add junk columns needed by the row mark if any and also add the
+	 * relevant expressions to the root parent's reltarget.
+	 */
+	if (oldrc)
+	{
+		List   *tlist = add_rowmark_junk_columns(root, oldrc);
+
+		build_base_rel_tlists(root, tlist);
+	}
+}
+
+/*
+ * expand_partitioned_rtentry
+ *		Prunes unnecessary partitions of a partitioned table and adds
+ *		remaining ones to the Query and the PlannerInfo
+ *
+ * Partitions are added to the query in order in which they are found in
+ * the parent's PartitionDesc.
+ *
+ * Note: even though only the unpruned partitions will be added to the
+ * resulting plan, this still locks *all* partitions via find_all_inheritors
+ * in order to avoid partitions being locked in a different order than other
+ * places in the backend that may lock partitions.
+ */
+static void
+expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
+						   Index parentRTindex, RelOptInfo *parentrel)
+{
+	LOCKMODE	lockmode = parentrte->rellockmode;
+	PlanRowMark *rootrc = NULL;
+	int			i;
+	Bitmapset  *partindexes;
+	Index		rootParentRTindex = parentrel->inh_root_parent > 0 ?
+									parentrel->inh_root_parent :
+									parentRTindex;
+
+	/* If root partitioned table, lock *all* partitions in the tree. */
+	if (parentRTindex == rootParentRTindex)
+		(void) find_all_inheritors(parentrte->relid, lockmode, NULL);
+
+	/*
+	 * Initialize partitioned_child_rels to contain this RT index.
+	 *
+	 * Note that during the set_append_rel_pathlist() phase, values of the
+	 * indexes of partitioned relations that appear down in the tree will be
+	 * bubbled up into root parent's list so that when we've created Paths for
+	 * all the children, the root table's list will contain all such indexes.
+	 */
+	parentrel->partitioned_child_rels = list_make1_int(parentRTindex);
+
+	/* Perform pruning. */
+	partindexes = prune_append_rel_partitions(parentrel);
+
+	/* Must expand PlannerInfo arrays before we can add children. */
+	expand_planner_arrays(root, bms_num_members(partindexes));
+
+	/*
+	 * For partitioned tables, we also store the partition RelOptInfo
+	 * pointers in the parent's RelOptInfo.
+	 */
+	parentrel->part_rels = (RelOptInfo **) palloc0(sizeof(RelOptInfo *) *
+												   parentrel->nparts);
+
+	rootrc = get_plan_rowmark(root->rowMarks, rootParentRTindex);
+	Assert(rootrc == NULL || rootrc->isParent);
+	i = -1;
+	while ((i = bms_next_member(partindexes, i)) >= 0)
+	{
+		Oid		childOID = parentrel->part_oids[i];
+		Relation	newrelation;
+		RelOptInfo *childrel;
+		RangeTblEntry *childrte;
+		Index		childRTindex;
+
+		/* Already locked above. */
+		newrelation = heap_open(childOID, NoLock);
+		Assert(!RELATION_IS_OTHER_TEMP(newrelation));
+
+		/*
+		 * A partitioned child table with 0 children is a dummy rel, so don't
+		 * bother creating planner objects for it.
+		 */
+		if (newrelation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE &&
+			RelationGetPartitionDesc(newrelation)->nparts == 0)
+		{
+			heap_close(newrelation, NoLock);
+			continue;
+		}
+
+		childrel = add_inheritance_child_rel(root, parentrte, parentRTindex,
+											 parentrel, rootrc, newrelation,
+											 &childrte, &childRTindex);
+		Assert(childrel != NULL);
+		parentrel->part_rels[i] = childrel;
+
+		/* Close child relations, but keep locks */
+		heap_close(newrelation, NoLock);
+
+		/* If the child is partitioned itself, expand it too. */
+		if (childrel->part_scheme)
+		{
+			Assert(childrte->inh);
+			expand_partitioned_rtentry(root, childrte, childRTindex,
+									   childrel);
+		}
+	}
+
+	/*
+	 * Add junk columns needed by the row mark if any and also add the
+	 * relevant expressions to the root parent's reltarget.
+	 */
+	if (rootrc)
+	{
+		List   *tlist = add_rowmark_junk_columns(root, rootrc);
+
+		build_base_rel_tlists(root, tlist);
+	}
+}
+
+/*
+ * add_inheritance_child_rel
+ *		Build a RangeTblEntry, an AppendRelInfo, a PlanRowMark, and finally
+ *		a RelOptInfo for an inheritance child relation.
+ *
+ * The return value is the RelOptInfo that's added.
+ *
+ * PlanRowMarks still carry the top-parent's RTI, and the top-parent's
+ * allMarkTypes field still accumulates values from all descendents.
+ *
+ * "parentrte" and "parentRTindex" are immediate parent's RTE and
+ * RTI. "top_parentrc" is top parent's PlanRowMark.
+ */
+static RelOptInfo *
+add_inheritance_child_rel(PlannerInfo *root, RangeTblEntry *parentrte,
+						  Index parentRTindex, RelOptInfo *parentrel,
+						  PlanRowMark *top_parentrc, Relation childrel,
+						  RangeTblEntry **childrte_p, Index *childRTindex_p)
+{
+	Query	   *parse = root->parse;
+	Oid			childOID = RelationGetRelid(childrel);
+	RangeTblEntry *childrte;
+	Index		childRTindex;
+	AppendRelInfo *appinfo;
+	RelOptInfo *childrelopt;
+
+	/*
+	 * Build an RTE for the child, and attach to query's rangetable list. We
+	 * copy most fields of the parent's RTE, but replace relation OID and
+	 * relkind, and set inh appropriately.  Also, set requiredPerms to zero
+	 * since all required permissions checks are done on the original RTE.
+	 * Likewise, set the child's securityQuals to empty, because we only want
+	 * to apply the parent's RLS conditions regardless of what RLS properties
+	 * individual children may have.  (This is an intentional choice to make
+	 * inherited RLS work like regular permissions checks.) The parent
+	 * securityQuals will be propagated to children along with other base
+	 * restriction clauses, so we don't need to do it here.
+	 */
+	childrte = copyObject(parentrte);
+	*childrte_p = childrte;
+	childrte->relid = childOID;
+	childrte->relkind = childrel->rd_rel->relkind;
+	/*
+	 * A partitioned child will need to be expanded as an append parent
+	 * itself, so set its inh to true.
+	 */
+	childrte->inh = (childrte->relkind == RELKIND_PARTITIONED_TABLE);
+	childrte->requiredPerms = 0;
+	childrte->securityQuals = NIL;
+	parse->rtable = lappend(parse->rtable, childrte);
+	childRTindex = list_length(parse->rtable);
+	*childRTindex_p = childRTindex;
+
+	/* Create an AppendRelInfo and add it to planner's global list. */
+	appinfo = make_append_rel_info(parentrel, parentrte,
+								   childrel->rd_att,
+								   childOID,
+								   childrel->rd_rel->reltype,
+								   childRTindex);
+	root->append_rel_list = lappend(root->append_rel_list, appinfo);
+
+	/*
+	 * Translate the column permissions bitmaps to the child's attnums (we
+	 * have to build the translated_vars list before we can do this). But
+	 * if this is the parent table, leave copyObject's result alone.
+	 *
+	 * Note: we need to do this even though the executor won't run any
+	 * permissions checks on the child RTE.  The insertedCols/updatedCols
+	 * bitmaps may be examined for trigger-firing purposes.
+	 */
+	if (childrte->relid != parentrte->relid)
+	{
+		childrte->selectedCols = translate_col_privs(parentrte->selectedCols,
+													 appinfo->translated_vars);
+		childrte->insertedCols = translate_col_privs(parentrte->insertedCols,
+													 appinfo->translated_vars);
+		childrte->updatedCols = translate_col_privs(parentrte->updatedCols,
+													appinfo->translated_vars);
+	}
+
+	/*
+	 * Build a PlanRowMark if parent is marked FOR UPDATE/SHARE.
+	 */
+	if (top_parentrc)
+	{
+		PlanRowMark *childrc = makeNode(PlanRowMark);
+
+		childrc->rti = childRTindex;
+		childrc->prti = top_parentrc->rti;
+		childrc->rowmarkId = top_parentrc->rowmarkId;
+		/* Reselect rowmark type, because relkind might not match parent */
+		childrc->markType = select_rowmark_type(childrte,
+												top_parentrc->strength);
+		childrc->allMarkTypes = (1 << childrc->markType);
+		childrc->strength = top_parentrc->strength;
+		childrc->waitPolicy = top_parentrc->waitPolicy;
+
+		/*
+		 * We mark RowMarks for partitioned child tables as parent RowMarks so
+		 * that the executor ignores them (except their existence means that
+		 * the child tables be locked using appropriate mode).
+		 */
+		childrc->isParent = (childrte->relkind == RELKIND_PARTITIONED_TABLE);
+
+		/* Include child's rowmark type in top parent's allMarkTypes */
+		top_parentrc->allMarkTypes |= childrc->allMarkTypes;
+
+		root->rowMarks = lappend(root->rowMarks, childrc);
+	}
+
+	/*
+	 * Add the RelOptInfo.  Even though we may not really scan this relation
+	 * for reasons such as contradictory quals, we still need need to create
+	 * one, because for every RTE in the query's range table, there must be an
+	 * accompanying RelOptInfo.
+	 */
+
+	/* First, store the RTE and appinfos into planner arrays. */
+	Assert(root->simple_rte_array[childRTindex] == NULL);
+	root->simple_rte_array[childRTindex] = childrte;
+	Assert(root->append_rel_array[childRTindex] == NULL);
+	root->append_rel_array[childRTindex] = appinfo;
+
+	childrelopt = build_append_child_rel(root, parentrel, childRTindex);
+	Assert(childrelopt != NULL);
+
+	return childrelopt;
+}
+
+/*
+ *	build_append_child_rel
+ *		Build a RelOptInfo for child relation of an append rel
+ *
+ * After creating the RelOptInfo for the given child RT index, it goes on to
+ * initialize some of its fields base on the parent RelOptInfo.
+ *
+ * If the quals in baserestrictinfo turns out to be self-contradictory, the
+ * RelOptInfo is marked dummy before returning.
+ */
+static RelOptInfo *
+build_append_child_rel(PlannerInfo *root,
+					   RelOptInfo *parent,
+					   Index childRTindex)
+{
+	RelOptInfo *childrel;
+	RangeTblEntry *childRTE = root->simple_rte_array[childRTindex];
+	AppendRelInfo *appinfo = root->append_rel_array[childRTindex];
+	List	   *childquals;
+	ListCell   *lc;
+	bool		have_const_false_cq;
+	Index		cq_min_security;
+
+	/* Build the RelOptInfo. */
+	childrel = build_simple_rel(root, childRTindex, parent);
+
+	/*
+	 * Propagate lateral_relids and lateral_referencers from appendrel
+	 * parent rels to their child rels.  We intentionally give each child rel
+	 * the same minimum parameterization, even though it's quite possible that
+	 * some don't reference all the lateral rels.  This is because any append
+	 * path for the parent will have to have the same parameterization for
+	 * every child anyway, and there's no value in forcing extra
+	 * reparameterize_path() calls.  Similarly, a lateral reference to the
+	 * parent prevents use of otherwise-movable join rels for each child.
+	 */
+	childrel->direct_lateral_relids = parent->direct_lateral_relids;
+	childrel->lateral_relids = parent->lateral_relids;
+	childrel->lateral_referencers = parent->lateral_referencers;
+
+	/*
+	 * We have to copy the parent's quals to the child, with appropriate
+	 * substitution of variables.  However, only the baserestrictinfo
+	 * quals are needed before we can check for constraint exclusion; so
+	 * do that first and then check to see if we can disregard this child.
+	 *
+	 * The child rel's targetlist might contain non-Var expressions, which
+	 * means that substitution into the quals could produce opportunities
+	 * for const-simplification, and perhaps even pseudoconstant quals.
+	 * Therefore, transform each RestrictInfo separately to see if it
+	 * reduces to a constant or pseudoconstant.  (We must process them
+	 * separately to keep track of the security level of each qual.)
+	 */
+	childquals = false;
+	cq_min_security = UINT_MAX;
+	have_const_false_cq = false;
+	foreach(lc, parent->baserestrictinfo)
+	{
+		RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
+		Node	   *childqual = (Node *) rinfo->clause;
+		ListCell   *lc2;
+
+		Assert(IsA(rinfo, RestrictInfo));
+		childqual = adjust_appendrel_attrs(root, childqual,
+										   1, &appinfo);
+		childqual = eval_const_expressions(root, childqual);
+		/* check for flat-out constant */
+		if (childqual && IsA(childqual, Const))
+		{
+			if (((Const *) childqual)->constisnull ||
+				!DatumGetBool(((Const *) childqual)->constvalue))
+			{
+				/* Restriction reduces to constant FALSE or NULL */
+				have_const_false_cq = true;
+				break;
+			}
+			/* Restriction reduces to constant TRUE, so drop it */
+			continue;
+		}
+		/* might have gotten an AND clause, if so flatten it */
+		foreach(lc2, make_ands_implicit((Expr *) childqual))
+		{
+			Node	   *onecq = (Node *) lfirst(lc2);
+			bool		pseudoconstant;
+
+			/* check for pseudoconstant (no Vars or volatile functions) */
+			pseudoconstant =
+					!contain_vars_of_level(onecq, 0) &&
+					!contain_volatile_functions(onecq);
+			if (pseudoconstant)
+			{
+				/* tell createplan.c to check for gating quals */
+				root->hasPseudoConstantQuals = true;
+			}
+			/* reconstitute RestrictInfo with appropriate properties */
+			childquals = lappend(childquals,
+								 make_restrictinfo((Expr *) onecq,
+												   rinfo->is_pushed_down,
+												   rinfo->outerjoin_delayed,
+												   pseudoconstant,
+												   rinfo->security_level,
+												   NULL, NULL, NULL));
+			cq_min_security = Min(cq_min_security, rinfo->security_level);
+		}
+	}
+
+	/*
+	 * In addition to the quals inherited from the parent, we might
+	 * have securityQuals associated with this particular child node.
+	 * (Currently this can only happen in appendrels originating from
+	 * UNION ALL; inheritance child tables don't have their own
+	 * securityQuals.)	Pull any such securityQuals up into the
+	 * baserestrictinfo for the child.  This is similar to
+	 * process_security_barrier_quals() for the parent rel, except
+	 * that we can't make any general deductions from such quals,
+	 * since they don't hold for the whole appendrel.
+	 */
+	if (childRTE->securityQuals)
+	{
+		Index		security_level = 0;
+
+		foreach(lc, childRTE->securityQuals)
+		{
+			List	   *qualset = (List *) lfirst(lc);
+			ListCell   *lc2;
+
+			foreach(lc2, qualset)
+			{
+				Expr	   *qual = (Expr *) lfirst(lc2);
+
+				/*
+				 * not likely that we'd see constants here, so no
+				 * check
+				 */
+				childquals = lappend(childquals,
+									 make_restrictinfo(qual,
+													   true,
+													   false,
+													   false,
+													   security_level,
+													   NULL, NULL,
+													   NULL));
+				cq_min_security = Min(cq_min_security, security_level);
+			}
+			security_level++;
+		}
+		Assert(security_level <= root->qual_security_level);
+	}
+
+	/* Set child's version of baserestrictinfo. */
+	childrel->baserestrictinfo = childquals;
+	childrel->baserestrict_min_security = cq_min_security;
+
+	if (have_const_false_cq)
+	{
+		/*
+		 * Some restriction clause reduced to constant FALSE or NULL after
+		 * substitution, so this child need not be scanned.
+		 */
+		set_dummy_rel_pathlist(childrel);
+	}
+
+	return childrel;
+}
+
+/*
+ * add_rowmark_junk_columns
+ * 		Add necessary junk columns for rowmarked inheritance parent rel.
+ *
+ * These values are needed for locking of rels selected FOR UPDATE/SHARE, and
+ * to do EvalPlanQual rechecking.  See comments for PlanRowMark in
+ * plannodes.h.
+ */
+static List *
+add_rowmark_junk_columns(PlannerInfo *root, PlanRowMark *rc)
+{
+	List   *tlist = root->processed_tlist;
+	Var		   *var;
+	char		resname[32];
+	TargetEntry *tle;
+
+	if (rc->allMarkTypes & ~(1 << ROW_MARK_COPY))
+	{
+		/* Need to fetch TID */
+		var = makeVar(rc->rti,
+					  SelfItemPointerAttributeNumber,
+					  TIDOID,
+					  -1,
+					  InvalidOid,
+					  0);
+		snprintf(resname, sizeof(resname), "ctid%u", rc->rowmarkId);
+		tle = makeTargetEntry((Expr *) var,
+							  list_length(tlist) + 1,
+							  pstrdup(resname),
+							  true);
+		tlist = lappend(tlist, tle);
+	}
+	if (rc->allMarkTypes & (1 << ROW_MARK_COPY))
+	{
+		/* Need the whole row as a junk var */
+		var = makeWholeRowVar(root->simple_rte_array[rc->rti],
+							  rc->rti,
+							  0,
+							  false);
+		snprintf(resname, sizeof(resname), "wholerow%u", rc->rowmarkId);
+		tle = makeTargetEntry((Expr *) var,
+							  list_length(tlist) + 1,
+							  pstrdup(resname),
+							  true);
+		tlist = lappend(tlist, tle);
+	}
+
+	/* For inheritance cases, always fetch the tableoid too. */
+	var = makeVar(rc->rti,
+				  TableOidAttributeNumber,
+				  OIDOID,
+				  -1,
+				  InvalidOid,
+				  0);
+	snprintf(resname, sizeof(resname), "tableoid%u", rc->rowmarkId);
+	tle = makeTargetEntry((Expr *) var,
+						  list_length(tlist) + 1,
+						  pstrdup(resname),
+						  true);
+	tlist = lappend(tlist, tle);
+
+	return tlist;
+}
diff --git a/src/backend/optimizer/util/appendinfo.c b/src/backend/optimizer/util/appendinfo.c
new file mode 100644
index 0000000000..9502535e53
--- /dev/null
+++ b/src/backend/optimizer/util/appendinfo.c
@@ -0,0 +1,851 @@
+/*-------------------------------------------------------------------------
+ *
+ * appendinfo.c
+ *	  Routines for mapping between append parent(s) and children
+ *
+ * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/optimizer/path/appendinfo.c
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include "access/htup_details.h"
+#include "access/sysattr.h"
+#include "nodes/makefuncs.h"
+#include "nodes/nodeFuncs.h"
+#include "optimizer/appendinfo.h"
+#include "parser/parsetree.h"
+#include "utils/rel.h"
+#include "utils/lsyscache.h"
+#include "utils/syscache.h"
+
+typedef struct
+{
+	PlannerInfo *root;
+	int			nappinfos;
+	AppendRelInfo **appinfos;
+} adjust_appendrel_attrs_context;
+
+static void make_inh_translation_list(TupleDesc old_tupdesc,
+						  TupleDesc new_tupdesc,
+						  Oid from_rel, Oid to_rel,
+						  Index newvarno, List **translated_vars);
+static Node *adjust_appendrel_attrs_mutator(Node *node,
+							   adjust_appendrel_attrs_context *context);
+static Relids adjust_child_relids(Relids relids, int nappinfos,
+					AppendRelInfo **appinfos);
+static List *adjust_inherited_tlist(List *tlist,
+					   AppendRelInfo *context);
+
+AppendRelInfo *
+make_append_rel_info(RelOptInfo *parentrel, RangeTblEntry *parentrte,
+					 TupleDesc childdesc, Oid childoid, Oid childreltype,
+					 Index childRTindex)
+{
+	AppendRelInfo  *appinfo = makeNode(AppendRelInfo);
+
+	appinfo->parent_relid = parentrel->relid;
+	appinfo->child_relid = childRTindex;
+	appinfo->parent_reltype = parentrel->reltype;
+	appinfo->child_reltype = childreltype;
+	make_inh_translation_list(parentrel->tupdesc, childdesc,
+							  parentrte->relid, childoid,
+							  childRTindex,
+							  &appinfo->translated_vars);
+	appinfo->parent_reloid = parentrte->relid;
+
+	return appinfo;
+}
+
+/*
+ * adjust_appendrel_attrs
+ *	  Copy the specified query or expression and translate Vars referring to a
+ *	  parent rel to refer to the corresponding child rel instead.  We also
+ *	  update rtindexes appearing outside Vars, such as resultRelation and
+ *	  jointree relids.
+ *
+ * Note: this is only applied after conversion of sublinks to subplans,
+ * so we don't need to cope with recursion into sub-queries.
+ *
+ * Note: this is not hugely different from what pullup_replace_vars() does;
+ * maybe we should try to fold the two routines together.
+ */
+Node *
+adjust_appendrel_attrs(PlannerInfo *root, Node *node, int nappinfos,
+					   AppendRelInfo **appinfos)
+{
+	Node	   *result;
+	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);
+
+	/*
+	 * Must be prepared to start with a Query or a bare expression tree.
+	 */
+	if (node && IsA(node, Query))
+	{
+		Query	   *newnode;
+		int			cnt;
+
+		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;
+}
+
+static Node *
+adjust_appendrel_attrs_mutator(Node *node,
+							   adjust_appendrel_attrs_context *context)
+{
+	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;
+
+		for (cnt = 0; cnt < nappinfos; cnt++)
+		{
+			if (var->varno == appinfos[cnt]->parent_relid)
+			{
+				appinfo = appinfos[cnt];
+				break;
+			}
+		}
+
+		if (var->varlevelsup == 0 && appinfo)
+		{
+			var->varno = appinfo->child_relid;
+			var->varnoold = appinfo->child_relid;
+			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));
+				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;
+
+					return (Node *) rowexpr;
+				}
+			}
+			/* system attributes don't need any other translation */
+		}
+		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, 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 */
+		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, context->nappinfos,
+											  context->appinfos);
+		return (Node *) phv;
+	}
+
+	/*
+	 * This is needed, because inheritance_make_rel_from_joinlist needs to
+	 * translate root->join_info_list executing make_rel_from_joinlist for a
+	 * given child.
+	 */
+	if (IsA(node, SpecialJoinInfo))
+	{
+		SpecialJoinInfo *oldinfo = (SpecialJoinInfo *) node;
+		SpecialJoinInfo *newinfo = makeNode(SpecialJoinInfo);
+
+		memcpy(newinfo, oldinfo, sizeof(SpecialJoinInfo));
+		newinfo->min_lefthand = adjust_child_relids(oldinfo->min_lefthand,
+													context->nappinfos,
+													context->appinfos);
+		newinfo->min_righthand = adjust_child_relids(oldinfo->min_righthand,
+													 context->nappinfos,
+													 context->appinfos);
+		newinfo->syn_lefthand = adjust_child_relids(oldinfo->syn_lefthand,
+													context->nappinfos,
+													context->appinfos);
+		newinfo->syn_righthand = adjust_child_relids(oldinfo->syn_righthand,
+													 context->nappinfos,
+													 context->appinfos);
+		newinfo->semi_rhs_exprs =
+					(List *) expression_tree_mutator((Node *)
+													 oldinfo->semi_rhs_exprs,
+													 adjust_appendrel_attrs_mutator,
+													 (void *) context);
+		return (Node *) newinfo;
+	}
+
+	/* Shouldn't need to handle planner auxiliary nodes here */
+	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 */
+		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->nullable_relids = adjust_child_relids(oldinfo->nullable_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));
+
+	return expression_tree_mutator(node, adjust_appendrel_attrs_mutator,
+								   (void *) context);
+}
+
+/*
+ * Substitute child relids for parent relids in a Relid set.  The array of
+ * appinfos specifies the substitutions to be performed.
+ */
+static Relids
+adjust_child_relids(Relids relids, int nappinfos, AppendRelInfo **appinfos)
+{
+	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;
+}
+
+/*
+ * Replace any relid present in top_parent_relids with its child in
+ * child_relids. Members of child_relids can be multiple levels below top
+ * parent in the partition hierarchy.
+ */
+Relids
+adjust_child_relids_multilevel(PlannerInfo *root, Relids relids,
+							   Relids child_relids, Relids top_parent_relids)
+{
+	AppendRelInfo **appinfos;
+	int			nappinfos;
+	Relids		parent_relids = NULL;
+	Relids		result;
+	Relids		tmp_result = NULL;
+	int			cnt;
+
+	/*
+	 * If the given relids set doesn't contain any of the top parent relids,
+	 * it will remain unchanged.
+	 */
+	if (!bms_overlap(relids, top_parent_relids))
+		return relids;
+
+	appinfos = find_appinfos_by_relids(root, child_relids, &nappinfos);
+
+	/* Construct relids set for the immediate parent of the given child. */
+	for (cnt = 0; cnt < nappinfos; cnt++)
+	{
+		AppendRelInfo *appinfo = appinfos[cnt];
+
+		parent_relids = bms_add_member(parent_relids, appinfo->parent_relid);
+	}
+
+	/* Recurse if immediate parent is not the top parent. */
+	if (!bms_equal(parent_relids, top_parent_relids))
+	{
+		tmp_result = adjust_child_relids_multilevel(root, relids,
+													parent_relids,
+													top_parent_relids);
+		relids = tmp_result;
+	}
+
+	result = adjust_child_relids(relids, nappinfos, appinfos);
+
+	/* Free memory consumed by any intermediate result. */
+	if (tmp_result)
+		bms_free(tmp_result);
+	bms_free(parent_relids);
+	pfree(appinfos);
+
+	return result;
+}
+
+/*
+ * adjust_appendrel_attrs_multilevel
+ *	  Apply Var translations from a toplevel appendrel parent down to a child.
+ *
+ * In some cases we need to translate expressions referencing a parent relation
+ * to reference an appendrel child that's multiple levels removed from it.
+ */
+Node *
+adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node,
+								  Relids child_relids,
+								  Relids top_parent_relids)
+{
+	AppendRelInfo **appinfos;
+	Bitmapset  *parent_relids = NULL;
+	int			nappinfos;
+	int			cnt;
+
+	Assert(bms_num_members(child_relids) == bms_num_members(top_parent_relids));
+
+	appinfos = find_appinfos_by_relids(root, child_relids, &nappinfos);
+
+	/* Construct relids set for the immediate parent of given child. */
+	for (cnt = 0; cnt < nappinfos; cnt++)
+	{
+		AppendRelInfo *appinfo = appinfos[cnt];
+
+		parent_relids = bms_add_member(parent_relids, appinfo->parent_relid);
+	}
+
+	/* Recurse if immediate parent is not the top parent. */
+	if (!bms_equal(parent_relids, top_parent_relids))
+		node = adjust_appendrel_attrs_multilevel(root, node, parent_relids,
+												 top_parent_relids);
+
+	/* Now translate for this child */
+	node = adjust_appendrel_attrs(root, node, nappinfos, appinfos);
+
+	pfree(appinfos);
+
+	return node;
+}
+
+/*
+ * Construct the SpecialJoinInfo for a child-join by translating
+ * SpecialJoinInfo for the join between parents. left_relids and right_relids
+ * are the relids of left and right side of the join respectively.
+ */
+SpecialJoinInfo *
+build_child_join_sjinfo(PlannerInfo *root, SpecialJoinInfo *parent_sjinfo,
+						Relids left_relids, Relids right_relids)
+{
+	SpecialJoinInfo *sjinfo = makeNode(SpecialJoinInfo);
+	AppendRelInfo **left_appinfos;
+	int			left_nappinfos;
+	AppendRelInfo **right_appinfos;
+	int			right_nappinfos;
+
+	memcpy(sjinfo, parent_sjinfo, sizeof(SpecialJoinInfo));
+	left_appinfos = find_appinfos_by_relids(root, left_relids,
+											&left_nappinfos);
+	right_appinfos = find_appinfos_by_relids(root, right_relids,
+											 &right_nappinfos);
+
+	sjinfo->min_lefthand = adjust_child_relids(sjinfo->min_lefthand,
+											   left_nappinfos, left_appinfos);
+	sjinfo->min_righthand = adjust_child_relids(sjinfo->min_righthand,
+												right_nappinfos,
+												right_appinfos);
+	sjinfo->syn_lefthand = adjust_child_relids(sjinfo->syn_lefthand,
+											   left_nappinfos, left_appinfos);
+	sjinfo->syn_righthand = adjust_child_relids(sjinfo->syn_righthand,
+												right_nappinfos,
+												right_appinfos);
+	sjinfo->semi_rhs_exprs = (List *) adjust_appendrel_attrs(root,
+															 (Node *) sjinfo->semi_rhs_exprs,
+															 right_nappinfos,
+															 right_appinfos);
+
+	pfree(left_appinfos);
+	pfree(right_appinfos);
+
+	return sjinfo;
+}
+
+/*
+ * find_appinfos_by_relids
+ * 		Find AppendRelInfo structures for all relations specified by relids.
+ *
+ * The AppendRelInfos are returned in an array, which can be pfree'd by the
+ * caller. *nappinfos is set to the number of entries in the array.
+ */
+AppendRelInfo **
+find_appinfos_by_relids(PlannerInfo *root, Relids relids, int *nappinfos)
+{
+	AppendRelInfo **appinfos;
+	int			cnt = 0;
+	int			i;
+
+	*nappinfos = bms_num_members(relids);
+	appinfos = (AppendRelInfo **) palloc(sizeof(AppendRelInfo *) * *nappinfos);
+
+	i = -1;
+	while ((i = bms_next_member(relids, i)) >= 0)
+	{
+		AppendRelInfo *appinfo = root->append_rel_array[i];
+
+		if (!appinfo)
+			elog(ERROR, "child rel %d not found in append_rel_array", i);
+
+		appinfos[cnt++] = appinfo;
+	}
+	return appinfos;
+}
+
+/*
+ * make_inh_translation_list
+ *	  Build the list of translations from parent Vars to child Vars for
+ *	  an inheritance child.
+ *
+ * For paranoia's sake, we match type/collation as well as attribute name.
+ */
+static void
+make_inh_translation_list(TupleDesc old_tupdesc, TupleDesc new_tupdesc,
+						  Oid from_rel, Oid to_rel,
+						  Index newvarno, List **translated_vars)
+{
+	List	   *vars = NIL;
+	int			oldnatts = old_tupdesc->natts;
+	int			newnatts = new_tupdesc->natts;
+	int			old_attno;
+	int			new_attno = 0;
+
+	for (old_attno = 0; old_attno < oldnatts; old_attno++)
+	{
+		Form_pg_attribute att;
+		char	   *attname;
+		Oid			atttypid;
+		int32		atttypmod;
+		Oid			attcollation;
+
+		att = TupleDescAttr(old_tupdesc, old_attno);
+		if (att->attisdropped)
+		{
+			/* Just put NULL into this list entry */
+			vars = lappend(vars, NULL);
+			continue;
+		}
+		attname = NameStr(att->attname);
+		atttypid = att->atttypid;
+		atttypmod = att->atttypmod;
+		attcollation = att->attcollation;
+
+		/*
+		 * When we are generating the "translation list" for the parent table
+		 * of an inheritance set, no need to search for matches.
+		 */
+		if (from_rel == to_rel)
+		{
+			vars = lappend(vars, makeVar(newvarno,
+										 (AttrNumber) (old_attno + 1),
+										 atttypid,
+										 atttypmod,
+										 attcollation,
+										 0));
+			continue;
+		}
+
+		/*
+		 * Otherwise we have to search for the matching column by name.
+		 * There's no guarantee it'll have the same column position, because
+		 * of cases like ALTER TABLE ADD COLUMN and multiple inheritance.
+		 * However, in simple cases, the relative order of columns is mostly
+		 * the same in both relations, so try the column of newrelation that
+		 * follows immediately after the one that we just found, and if that
+		 * fails, let syscache handle it.
+		 */
+		if (new_attno >= newnatts ||
+			(att = TupleDescAttr(new_tupdesc, new_attno))->attisdropped ||
+			strcmp(attname, NameStr(att->attname)) != 0)
+		{
+			HeapTuple	newtup;
+
+			newtup = SearchSysCacheAttName(to_rel, attname);
+			if (!newtup)
+				elog(ERROR, "could not find inherited attribute \"%s\" of relation \"%s\"",
+					 attname, get_rel_name(to_rel));
+			new_attno = ((Form_pg_attribute) GETSTRUCT(newtup))->attnum - 1;
+			ReleaseSysCache(newtup);
+
+			att = TupleDescAttr(new_tupdesc, new_attno);
+		}
+
+		/* Found it, check type and collation match */
+		if (atttypid != att->atttypid || atttypmod != att->atttypmod)
+			elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's type",
+				 attname, get_rel_name(to_rel));
+		if (attcollation != att->attcollation)
+			elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's collation",
+				 attname, get_rel_name(to_rel));
+
+		vars = lappend(vars, makeVar(newvarno,
+									 (AttrNumber) (new_attno + 1),
+									 atttypid,
+									 atttypmod,
+									 attcollation,
+									 0));
+		new_attno++;
+	}
+
+	*translated_vars = vars;
+}
+
+/*
+ * translate_col_privs
+ *	  Translate a bitmapset representing per-column privileges from the
+ *	  parent rel's attribute numbering to the child's.
+ *
+ * The only surprise here is that we don't translate a parent whole-row
+ * reference into a child whole-row reference.  That would mean requiring
+ * permissions on all child columns, which is overly strict, since the
+ * query is really only going to reference the inherited columns.  Instead
+ * we set the per-column bits for all inherited columns.
+ */
+Bitmapset *
+translate_col_privs(const Bitmapset *parent_privs,
+					List *translated_vars)
+{
+	Bitmapset  *child_privs = NULL;
+	bool		whole_row;
+	int			attno;
+	ListCell   *lc;
+
+	/* System attributes have the same numbers in all tables */
+	for (attno = FirstLowInvalidHeapAttributeNumber + 1; attno < 0; attno++)
+	{
+		if (bms_is_member(attno - FirstLowInvalidHeapAttributeNumber,
+						  parent_privs))
+			child_privs = bms_add_member(child_privs,
+										 attno - FirstLowInvalidHeapAttributeNumber);
+	}
+
+	/* Check if parent has whole-row reference */
+	whole_row = bms_is_member(InvalidAttrNumber - FirstLowInvalidHeapAttributeNumber,
+							  parent_privs);
+
+	/* And now translate the regular user attributes, using the vars list */
+	attno = InvalidAttrNumber;
+	foreach(lc, translated_vars)
+	{
+		Var		   *var = lfirst_node(Var, lc);
+
+		attno++;
+		if (var == NULL)		/* ignore dropped columns */
+			continue;
+		if (whole_row ||
+			bms_is_member(attno - FirstLowInvalidHeapAttributeNumber,
+						  parent_privs))
+			child_privs = bms_add_member(child_privs,
+										 var->varattno - FirstLowInvalidHeapAttributeNumber);
+	}
+
+	return child_privs;
+}
+
+/*
+ * 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.
+ */
+static List *
+adjust_inherited_tlist(List *tlist, AppendRelInfo *context)
+{
+	bool		changed_it = false;
+	ListCell   *tl;
+	List	   *new_tlist;
+	bool		more;
+	int			attrno;
+
+	/* 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)
+	{
+		TargetEntry *tle = (TargetEntry *) lfirst(tl);
+		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))
+			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);
+		if (childvar == NULL || !IsA(childvar, Var))
+			elog(ERROR, "attribute %d of relation \"%s\" does not exist",
+				 tle->resno, get_rel_name(context->parent_reloid));
+
+		if (tle->resno != childvar->varattno)
+		{
+			tle->resno = childvar->varattno;
+			changed_it = true;
+		}
+	}
+
+	/*
+	 * 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;
+
+	new_tlist = NIL;
+	more = true;
+	for (attrno = 1; more; attrno++)
+	{
+		more = false;
+		foreach(tl, tlist)
+		{
+			TargetEntry *tle = (TargetEntry *) lfirst(tl);
+
+			if (tle->resjunk)
+				continue;		/* ignore junk items */
+
+			if (tle->resno == attrno)
+				new_tlist = lappend(new_tlist, tle);
+			else if (tle->resno > attrno)
+				more = true;
+		}
+	}
+
+	foreach(tl, tlist)
+	{
+		TargetEntry *tle = (TargetEntry *) lfirst(tl);
+
+		if (!tle->resjunk)
+			continue;			/* here, ignore non-junk items */
+
+		tle->resno = attrno;
+		new_tlist = lappend(new_tlist, tle);
+		attrno++;
+	}
+
+	return new_tlist;
+}
diff --git a/src/backend/optimizer/util/pathnode.c b/src/backend/optimizer/util/pathnode.c
index d50d86b252..8ce88876c4 100644
--- a/src/backend/optimizer/util/pathnode.c
+++ b/src/backend/optimizer/util/pathnode.c
@@ -20,6 +20,7 @@
 #include "foreign/fdwapi.h"
 #include "nodes/extensible.h"
 #include "nodes/nodeFuncs.h"
+#include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index c23db9d78d..52a11f434f 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -17,6 +17,7 @@
 #include <limits.h>
 
 #include "miscadmin.h"
+#include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
diff --git a/src/backend/partitioning/partprune.c b/src/backend/partitioning/partprune.c
index fcf8d6032c..e76906da1f 100644
--- a/src/backend/partitioning/partprune.c
+++ b/src/backend/partitioning/partprune.c
@@ -44,6 +44,7 @@
 #include "miscadmin.h"
 #include "nodes/makefuncs.h"
 #include "nodes/nodeFuncs.h"
+#include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
diff --git a/src/include/optimizer/append.h b/src/include/optimizer/append.h
new file mode 100644
index 0000000000..b5f025c137
--- /dev/null
+++ b/src/include/optimizer/append.h
@@ -0,0 +1,25 @@
+/*-------------------------------------------------------------------------
+ *
+ * append.h
+ *	  prototypes for append.c.
+ *
+ *
+ * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/optimizer/append.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef APPEND_H
+#define APPEND_H
+
+#include "nodes/relation.h"
+
+/*
+ * append.c
+ *	  utilities for dealing with append relations
+ */
+extern void expand_inherited_tables(PlannerInfo *root);
+
+#endif							/* APPEND_H */
diff --git a/src/include/optimizer/appendinfo.h b/src/include/optimizer/appendinfo.h
new file mode 100644
index 0000000000..e205e78e6d
--- /dev/null
+++ b/src/include/optimizer/appendinfo.h
@@ -0,0 +1,43 @@
+/*-------------------------------------------------------------------------
+ *
+ * appendinfo.h
+ *	  Routines for mapping expressions between append rel parent(s) and
+ *	  children
+ *
+ * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/optimizer/appendinfo.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef APPENDINFO_H
+#define APPENDINFO_H
+
+#include "nodes/plannodes.h"
+#include "nodes/relation.h"
+#include "utils/relcache.h"
+
+extern AppendRelInfo *make_append_rel_info(RelOptInfo *parentrel,
+					 RangeTblEntry *parentrte,
+					 TupleDesc childdesc, Oid childoid, Oid childreltype,
+					 Index childRTindex);
+extern Bitmapset *translate_col_privs(const Bitmapset *parent_privs,
+					List *translated_vars);
+extern Node *adjust_appendrel_attrs(PlannerInfo *root, Node *node,
+					   int nappinfos, AppendRelInfo **appinfos);
+
+extern Node *adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node,
+								  Relids child_relids,
+								  Relids top_parent_relids);
+
+extern AppendRelInfo **find_appinfos_by_relids(PlannerInfo *root,
+						Relids relids, int *nappinfos);
+
+extern SpecialJoinInfo *build_child_join_sjinfo(PlannerInfo *root,
+						SpecialJoinInfo *parent_sjinfo,
+						Relids left_relids, Relids right_relids);
+extern Relids adjust_child_relids_multilevel(PlannerInfo *root, Relids relids,
+							   Relids child_relids, Relids top_parent_relids);
+
+#endif							/* APPENDINFO_H */
diff --git a/src/include/optimizer/prep.h b/src/include/optimizer/prep.h
index faae07d240..3ad9b4a77e 100644
--- a/src/include/optimizer/prep.h
+++ b/src/include/optimizer/prep.h
@@ -48,24 +48,5 @@ extern PlanRowMark *get_plan_rowmark(List *rowmarks, Index rtindex);
  */
 extern RelOptInfo *plan_set_operations(PlannerInfo *root);
 
-extern void expand_inherited_tables(PlannerInfo *root);
 
-extern Node *adjust_appendrel_attrs(PlannerInfo *root, Node *node,
-					   int nappinfos, AppendRelInfo **appinfos);
-extern AppendRelInfo *make_append_rel_info(RelOptInfo *parentrel,
-					 RangeTblEntry *parentrte,
-					 TupleDesc childdesc, Oid childoid, Oid childreltype,
-					 Index childRTindex);
-extern Node *adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node,
-								  Relids child_relids,
-								  Relids top_parent_relids);
-
-extern AppendRelInfo **find_appinfos_by_relids(PlannerInfo *root,
-						Relids relids, int *nappinfos);
-
-extern SpecialJoinInfo *build_child_join_sjinfo(PlannerInfo *root,
-						SpecialJoinInfo *parent_sjinfo,
-						Relids left_relids, Relids right_relids);
-extern Relids adjust_child_relids_multilevel(PlannerInfo *root, Relids relids,
-							   Relids child_relids, Relids top_parent_relids);
 #endif							/* PREP_H */
-- 
2.11.0

From a26d82f90e2182ed2f0f3f276c9f2e240c512c00 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Mon, 15 Oct 2018 10:59:24 +0900
Subject: [PATCH v7 5/6] Teach planner to only process unpruned partitions

This adds a bitmapset field live_parts to RelOptInfo and stores
the partition indexes of non-dummy partitions in it, meaning it
contains indexes of only those partitions that have a non-NULL
RelOptInfo present in its parent's RelOptInfo's part_rels array.

This speeds up processing partitioned table's partitions compared
to going through the whole part_rels array in a number of places.
---
 src/backend/optimizer/path/joinrels.c |  3 +++
 src/backend/optimizer/plan/planner.c  | 18 +++++++++---------
 src/backend/optimizer/util/append.c   |  8 ++++++++
 src/backend/optimizer/util/relnode.c  |  3 +++
 src/backend/partitioning/partprune.c  | 18 +++++-------------
 src/include/nodes/relation.h          |  2 ++
 6 files changed, 30 insertions(+), 22 deletions(-)

diff --git a/src/backend/optimizer/path/joinrels.c b/src/backend/optimizer/path/joinrels.c
index 6e321ec9e7..76531a05cf 100644
--- a/src/backend/optimizer/path/joinrels.c
+++ b/src/backend/optimizer/path/joinrels.c
@@ -1424,6 +1424,9 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
 		populate_joinrel_with_paths(root, child_rel1, child_rel2,
 									child_joinrel, child_sjinfo,
 									child_restrictlist);
+		if (!IS_DUMMY_REL(child_joinrel))
+			joinrel->live_parts = bms_add_member(joinrel->live_parts,
+												 cnt_parts);
 	}
 }
 
diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index 3513b25cac..c0487d7ae2 100644
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -6762,7 +6762,9 @@ apply_scanjoin_target_to_paths(PlannerInfo *root,
 		List	   *live_children = NIL;
 
 		/* Adjust each partition. */
-		for (partition_idx = 0; partition_idx < rel->nparts; partition_idx++)
+		partition_idx = -1;
+		while ((partition_idx = bms_next_member(rel->live_parts,
+												partition_idx)) >= 0)
 		{
 			RelOptInfo *child_rel = rel->part_rels[partition_idx];
 			ListCell   *lc;
@@ -6770,9 +6772,7 @@ apply_scanjoin_target_to_paths(PlannerInfo *root,
 			int			nappinfos;
 			List	   *child_scanjoin_targets = NIL;
 
-			/* Skip processing pruned partitions. */
-			if (child_rel == NULL)
-				continue;
+			Assert(child_rel != NULL);
 
 			/* Translate scan/join targets for this child. */
 			appinfos = find_appinfos_by_relids(root, child_rel->relids,
@@ -6853,7 +6853,6 @@ create_partitionwise_grouping_paths(PlannerInfo *root,
 									PartitionwiseAggregateType patype,
 									GroupPathExtraData *extra)
 {
-	int			nparts = input_rel->nparts;
 	int			cnt_parts;
 	List	   *grouped_live_children = NIL;
 	List	   *partially_grouped_live_children = NIL;
@@ -6865,7 +6864,9 @@ create_partitionwise_grouping_paths(PlannerInfo *root,
 		   partially_grouped_rel != NULL);
 
 	/* Add paths for partitionwise aggregation/grouping. */
-	for (cnt_parts = 0; cnt_parts < nparts; cnt_parts++)
+	cnt_parts = -1;
+	while ((cnt_parts = bms_next_member(input_rel->live_parts,
+										cnt_parts)) >= 0)
 	{
 		RelOptInfo *child_input_rel = input_rel->part_rels[cnt_parts];
 		PathTarget *child_target = copy_pathtarget(target);
@@ -6875,9 +6876,8 @@ create_partitionwise_grouping_paths(PlannerInfo *root,
 		RelOptInfo *child_grouped_rel;
 		RelOptInfo *child_partially_grouped_rel;
 
-		/* Skip processing pruned partitions. */
-		if (child_input_rel == NULL)
-			continue;
+		/* A live partition must have a RelOptInfo. */
+		Assert(child_input_rel != NULL);
 
 		/* Input child rel must have a path */
 		Assert(child_input_rel->pathlist != NIL);
diff --git a/src/backend/optimizer/util/append.c b/src/backend/optimizer/util/append.c
index d2ad80034f..3b3fb304b9 100644
--- a/src/backend/optimizer/util/append.c
+++ b/src/backend/optimizer/util/append.c
@@ -351,6 +351,7 @@ expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
 
 	/* Perform pruning. */
 	partindexes = prune_append_rel_partitions(parentrel);
+	parentrel->live_parts = partindexes;
 
 	/* Must expand PlannerInfo arrays before we can add children. */
 	expand_planner_arrays(root, bms_num_members(partindexes));
@@ -394,6 +395,13 @@ expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
 		Assert(childrel != NULL);
 		parentrel->part_rels[i] = childrel;
 
+		/*
+		 * If partition is excluded by constraints, remove it from
+		 * live_parts, too.
+		 */
+		if (IS_DUMMY_REL(childrel))
+			parentrel->live_parts = bms_del_member(parentrel->live_parts, i);
+
 		/* Close child relations, but keep locks */
 		heap_close(newrelation, NoLock);
 
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index 52a11f434f..6c7eafe6db 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -1748,6 +1748,9 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
 		joinrel->partexprs[cnt] = partexpr;
 		joinrel->nullable_partexprs[cnt] = nullable_partexpr;
 	}
+
+	/* Partitions will be added by try_partitionwise_join. */
+	joinrel->live_parts = NULL;
 }
 
 /*
diff --git a/src/backend/partitioning/partprune.c b/src/backend/partitioning/partprune.c
index e76906da1f..8bc2f5c5c2 100644
--- a/src/backend/partitioning/partprune.c
+++ b/src/backend/partitioning/partprune.c
@@ -441,29 +441,21 @@ make_partitionedrel_pruneinfo(PlannerInfo *root, RelOptInfo *parentrel,
 		memset(subplan_map, -1, nparts * sizeof(int));
 		subpart_map = (int *) palloc(nparts * sizeof(int));
 		memset(subpart_map, -1, nparts * sizeof(int));
-		present_parts = NULL;
+		present_parts = bms_copy(subpart->live_parts);
 
-		for (i = 0; i < nparts; i++)
+		i = -1;
+		while ((i = bms_next_member(present_parts, i)) >= 0)
 		{
 			RelOptInfo *partrel = subpart->part_rels[i];
 			int			subplanidx;
 			int			subpartidx;
 
-			/* Skip processing pruned partitions. */
-			if (partrel == NULL)
-				continue;
-
+			Assert(partrel != NULL);
 			subplan_map[i] = subplanidx = relid_subplan_map[partrel->relid] - 1;
 			subpart_map[i] = subpartidx = relid_subpart_map[partrel->relid] - 1;
+			/* Record finding this subplan */
 			if (subplanidx >= 0)
-			{
-				present_parts = bms_add_member(present_parts, i);
-
-				/* Record finding this subplan  */
 				subplansfound = bms_add_member(subplansfound, subplanidx);
-			}
-			else if (subpartidx >= 0)
-				present_parts = bms_add_member(present_parts, i);
 		}
 
 		pinfo = makeNode(PartitionedRelPruneInfo);
diff --git a/src/include/nodes/relation.h b/src/include/nodes/relation.h
index e6fdbcd030..f43fa46fc5 100644
--- a/src/include/nodes/relation.h
+++ b/src/include/nodes/relation.h
@@ -727,6 +727,8 @@ typedef struct RelOptInfo
 	Oid		   *part_oids;		/* partition OIDs */
 	struct RelOptInfo **part_rels;	/* Array of RelOptInfos of partitions,
 									 * stored in the same order of bounds */
+	Bitmapset  *live_parts;		/* Set of live partitions; contains indexes
+								 * into part_rels array */
 	List	  **partexprs;		/* Non-nullable partition key expressions. */
 	List	  **nullable_partexprs; /* Nullable partition key expressions. */
 	List	   *partitioned_child_rels; /* List of RT indexes. */
-- 
2.11.0

From 6954a852b359c439414937d60fc00b7a0f91c886 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Fri, 12 Oct 2018 19:12:53 +0900
Subject: [PATCH v7 6/6] Do not lock all partitions at the beginning

---
 src/backend/optimizer/util/append.c | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

diff --git a/src/backend/optimizer/util/append.c b/src/backend/optimizer/util/append.c
index 3b3fb304b9..0b0b75d409 100644
--- a/src/backend/optimizer/util/append.c
+++ b/src/backend/optimizer/util/append.c
@@ -335,10 +335,6 @@ expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
 									parentrel->inh_root_parent :
 									parentRTindex;
 
-	/* If root partitioned table, lock *all* partitions in the tree. */
-	if (parentRTindex == rootParentRTindex)
-		(void) find_all_inheritors(parentrte->relid, lockmode, NULL);
-
 	/*
 	 * Initialize partitioned_child_rels to contain this RT index.
 	 *
@@ -374,8 +370,7 @@ expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
 		RangeTblEntry *childrte;
 		Index		childRTindex;
 
-		/* Already locked above. */
-		newrelation = heap_open(childOID, NoLock);
+		newrelation = heap_open(childOID, lockmode);
 		Assert(!RELATION_IS_OTHER_TEMP(newrelation));
 
 		/*
-- 
2.11.0

From 1df6fede4ec23eea3f149fa399b0feda61e69ae0 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Wed, 17 Oct 2018 11:18:12 +0900
Subject: [PATCH v8 1/6] Overhaul inheritance update/delete planning

With the current method, inheritance_planner, which handles the
planning for update/delete commands targeting inheritance trees,
performs the *whole* planning for each child table.  That involves
translating the query tree to set a given child table in place of
the original inheritance root table as the query's target table,
followed by calling grouping_planner on the translated query, which
performs query planning and additional steps needed to apply correct
target list based on the child target table.

That's inefficient for two reasons:

 1. partprune.c cannot be used to perform partition pruning, because
    it can only be invoked from query_planner.  With the current
    approach, query_planner only sees the individual partitions in
    the query tree it receives, not the parent partitioned table.
    This leaves each partition to be pruned using constraint
    exclusion.  (constraint exclusion cannon prune hash partitions
    which means UPDATE/DELETE don't support hash partition pruning.)

 2. Repeated invocation of query_planner results in allocating large
    amounts of memory, especially if there are many child tables.
    Also, it involves repeatedly performing the same processing,
    such as jointree processing.

This commit addresses both of the issues by rewriting portions of
inheritance_planner and adding some supporting functionality to
allpath.c.

With the new implementation, inheritance_planner calls query_planner
only once at the beginning with the original unmodified query, which
creates the access paths of individual relations after pruning any
unnecessary partitions.  For each target child relation, it also
creates a sub-PartitionInfo containing translated version of the
query and a targetlist suitable for the child.  Child PlannerInfos
are saved in the top PlannerInfo for using later.  If the query
involves join against the target relation, join paths are created
for each target child relation by  replacing the original target
table in the join tree by a given child table.  Join relations
(RelOptInfos thereof) for all target child relations are collected
in a global list in the top PlannerInfo.

After creating the join paths for all target child relations,
inheritance_planner calls grouping_planner() on each child join
relation using the previously created child PlannerInfo to finish up
the paths such that they produce query's top-level target list
expanded according to a given child relation's descriptor.
grouping_planner()'s interface is modified so that we can pass it
what's called a 'planned_rel', a RelOptInfo that already contains
the necessary paths needed to produce its output.

This removes some existing code in inheritance_planner that dealt
with any subquery RTEs in the query.  The rationale of that code
was that the subquery RTEs may change during each iteration of
planning (that is, for different children), so different iterations
better use different copies of those RTEs.  That was handled by
making fresh copies of those RTEs for each iteration of planning
which were appended to the range table, accompanied by modifying all
expressions and auxiliary structures that referenced the original
subquery RTEs to instead reference the copies (that is, change the
varnos).  This copying meant we would end up adding S * N new entries
to the original range table by the time we got to the last unpruned
child, where S is the number of subquery RTEs in the original query
and N the number of unpruned children.  Since with the new code
we perform planning just once, I think we don't need this special
handling.  Actually, there is a regression test output change due
to no longer having copies of subquery RTEs (see the diff of
partition_join.out file.)

Also we no longer need the hack in relation_excluded_by_constraints()
involving setting PlannerInfo.inhTargetKind to enable constraint
exclusion for target child relation, which is no longer
is no longer needed.  Constraint exclusion runs during query_planner
step described above.

Regression test output change in partition_join.out is due to the fact
that we no longer create duplicates of subquery RTEs in child range
tables.
---
 doc/src/sgml/ddl.sgml                        |  14 +-
 src/backend/nodes/outfuncs.c                 |   1 -
 src/backend/optimizer/path/allpaths.c        | 328 +++++++++++++++++++-
 src/backend/optimizer/path/equivclass.c      |  27 +-
 src/backend/optimizer/plan/createplan.c      |  10 -
 src/backend/optimizer/plan/planner.c         | 432 +++++++--------------------
 src/backend/optimizer/prep/prepjointree.c    |   1 -
 src/backend/optimizer/prep/prepunion.c       |  33 +-
 src/backend/optimizer/util/plancat.c         |  50 +---
 src/include/nodes/relation.h                 |  31 +-
 src/include/optimizer/paths.h                |   3 +-
 src/test/regress/expected/partition_join.out |   4 +-
 12 files changed, 517 insertions(+), 417 deletions(-)

diff --git a/doc/src/sgml/ddl.sgml b/doc/src/sgml/ddl.sgml
index 61c4a25460..80f587012c 100644
--- a/doc/src/sgml/ddl.sgml
+++ b/doc/src/sgml/ddl.sgml
@@ -3877,15 +3877,6 @@ EXPLAIN SELECT count(*) FROM measurement WHERE logdate &gt;= DATE '2008-01-01';
 
    <note>
     <para>
-     Currently, pruning of partitions during the planning of an
-     <command>UPDATE</command> or <command>DELETE</command> command is
-     implemented using the constraint exclusion method (however, it is
-     controlled by the <literal>enable_partition_pruning</literal> rather than
-     <literal>constraint_exclusion</literal>) &mdash; see the following section
-     for details and caveats that apply.
-    </para>
-
-    <para>
      Execution-time partition pruning currently only occurs for the
      <literal>Append</literal> and <literal>MergeAppend</literal> node types.
      It is not yet implemented for the <literal>ModifyTable</literal> node
@@ -3908,9 +3899,8 @@ EXPLAIN SELECT count(*) FROM measurement WHERE logdate &gt;= DATE '2008-01-01';
 
    <para>
     <firstterm>Constraint exclusion</firstterm> is a query optimization
-    technique similar to partition pruning.  While it is primarily used
-    for partitioning implemented using the legacy inheritance method, it can be
-    used for other purposes, including with declarative partitioning.
+    technique similar to partition pruning.  It is primarily used
+    for partitioning implemented using the legacy inheritance method.
    </para>
 
    <para>
diff --git a/src/backend/nodes/outfuncs.c b/src/backend/nodes/outfuncs.c
index f0c396530d..08657fcfd9 100644
--- a/src/backend/nodes/outfuncs.c
+++ b/src/backend/nodes/outfuncs.c
@@ -2309,7 +2309,6 @@ _outPlannerInfo(StringInfo str, const PlannerInfo *node)
 	WRITE_FLOAT_FIELD(tuple_fraction, "%.4f");
 	WRITE_FLOAT_FIELD(limit_tuples, "%.0f");
 	WRITE_UINT_FIELD(qual_security_level);
-	WRITE_ENUM_FIELD(inhTargetKind, InheritanceKind);
 	WRITE_BOOL_FIELD(hasJoinRTEs);
 	WRITE_BOOL_FIELD(hasLateralRTEs);
 	WRITE_BOOL_FIELD(hasDeletedRTEs);
diff --git a/src/backend/optimizer/path/allpaths.c b/src/backend/optimizer/path/allpaths.c
index 738bb30848..ba944b2edc 100644
--- a/src/backend/optimizer/path/allpaths.c
+++ b/src/backend/optimizer/path/allpaths.c
@@ -36,6 +36,7 @@
 #include "optimizer/pathnode.h"
 #include "optimizer/paths.h"
 #include "optimizer/plancat.h"
+#include "optimizer/planmain.h"
 #include "optimizer/planner.h"
 #include "optimizer/prep.h"
 #include "optimizer/restrictinfo.h"
@@ -93,6 +94,9 @@ static void set_foreign_pathlist(PlannerInfo *root, RelOptInfo *rel,
 					 RangeTblEntry *rte);
 static void set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 					Index rti, RangeTblEntry *rte);
+static PlannerInfo *adjust_inherit_target_child(PlannerInfo *root,
+							RelOptInfo *childrel,
+							AppendRelInfo *appinfo);
 static void set_append_rel_pathlist(PlannerInfo *root, RelOptInfo *rel,
 						Index rti, RangeTblEntry *rte);
 static void generate_mergeappend_paths(PlannerInfo *root, RelOptInfo *rel,
@@ -119,6 +123,8 @@ static void set_namedtuplestore_pathlist(PlannerInfo *root, RelOptInfo *rel,
 static void set_worktable_pathlist(PlannerInfo *root, RelOptInfo *rel,
 					   RangeTblEntry *rte);
 static RelOptInfo *make_rel_from_joinlist(PlannerInfo *root, List *joinlist);
+static void inheritance_make_rel_from_joinlist(PlannerInfo *root,
+						List *joinlist);
 static bool subquery_is_pushdown_safe(Query *subquery, Query *topquery,
 						  pushdown_safety_info *safetyInfo);
 static bool recurse_pushdown_safe(Node *setOp, Query *topquery,
@@ -217,13 +223,40 @@ make_one_rel(PlannerInfo *root, List *joinlist)
 
 	/*
 	 * Generate access paths for the entire join tree.
+	 *
+	 * For UPDATE/DELETE on an inheritance parent, join paths should be
+	 * generated for each child result rel separately.
 	 */
-	rel = make_rel_from_joinlist(root, joinlist);
+	if (root->parse->resultRelation &&
+		root->simple_rte_array[root->parse->resultRelation]->inh)
+	{
+		inheritance_make_rel_from_joinlist(root, joinlist);
 
-	/*
-	 * The result should join all and only the query's base rels.
-	 */
-	Assert(bms_equal(rel->relids, root->all_baserels));
+		/*
+		 * There should be as many child source rels as there are child
+		 * subroots.
+		 */
+		Assert(list_length(root->inh_target_child_roots) ==
+			   list_length(root->inh_target_child_rels));
+
+		/*
+		 * Return the RelOptInfo of original target relation, although this
+		 * doesn't really contain the final path.  inheritance_planner
+		 * from where we got here will generate the final path, but not
+		 * through this RelOptInfo.
+		 */
+		rel = find_base_rel(root, root->parse->resultRelation);
+	}
+	else
+	{
+		rel = make_rel_from_joinlist(root, joinlist);
+
+		/*
+		 * The result should join all and only the query's base rels.
+		 */
+		Assert(bms_equal(rel->relids, root->all_baserels));
+
+	}
 
 	return rel;
 }
@@ -1001,6 +1034,7 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 		ListCell   *parentvars;
 		ListCell   *childvars;
 		ListCell   *lc;
+		PlannerInfo *subroot = root;
 
 		/* append_rel_list contains all append rels; ignore others */
 		if (appinfo->parent_relid != parentRTindex)
@@ -1029,11 +1063,19 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 		 * fields of childrel->reltarget; not clear if that would be useful.
 		 */
 		childrel->reltarget->exprs = (List *)
-			adjust_appendrel_attrs(root,
+			adjust_appendrel_attrs(subroot,
 								   (Node *) rel->reltarget->exprs,
 								   1, &appinfo);
 
 		/*
+		 * If the parent is the result relation, we need a reltarget for the
+		 * child relation that will be suitable to use the child also as the
+		 * target relation.
+		 */
+		if (appinfo->parent_relid == root->parse->resultRelation)
+			subroot = adjust_inherit_target_child(root, childrel, appinfo);
+
+		/*
 		 * We have to make child entries in the EquivalenceClass data
 		 * structures as well.  This is needed either if the parent
 		 * participates in some eclass joins (because we will want to consider
@@ -1045,7 +1087,8 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 		 * EquivalenceClass data structures.
 		 */
 		if (rel->has_eclass_joins || has_useful_pathkeys(root, rel))
-			add_child_rel_equivalences(root, appinfo, rel, childrel);
+			add_child_rel_equivalences(subroot, appinfo, rel, childrel,
+									   root != subroot);
 		childrel->has_eclass_joins = rel->has_eclass_joins;
 
 		/*
@@ -1188,7 +1231,7 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 
 		/* CE failed, so finish copying/modifying join quals. */
 		childrel->joininfo = (List *)
-			adjust_appendrel_attrs(root,
+			adjust_appendrel_attrs(subroot,
 								   (Node *) rel->joininfo,
 								   1, &appinfo);
 
@@ -1216,12 +1259,12 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 		 * consistency, do this before calling set_rel_size() for the child.
 		 */
 		if (root->glob->parallelModeOK && rel->consider_parallel)
-			set_rel_consider_parallel(root, childrel, childRTE);
+			set_rel_consider_parallel(subroot, childrel, childRTE);
 
 		/*
-		 * Compute the child's size.
+		 * Compute the child's size using possibly modified subroot.
 		 */
-		set_rel_size(root, childrel, childRTindex, childRTE);
+		set_rel_size(subroot, childrel, childRTindex, childRTE);
 
 		/*
 		 * It is possible that constraint exclusion detected a contradiction
@@ -1231,6 +1274,25 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 		if (IS_DUMMY_REL(childrel))
 			continue;
 
+		/*
+		 * If we modified subroot for the target inheritance case, add it
+		 * to root->inh_target_child_roots.
+		 */
+		if (subroot != root)
+		{
+			root->inh_target_child_roots =
+							lappend(root->inh_target_child_roots, subroot);
+
+			/*
+			 * If the childrel itself was a partitioned table, its children
+			 * would've been added into subroot.
+			 */
+			if (subroot->inh_target_child_roots != NIL)
+				root->inh_target_child_roots =
+							list_concat(root->inh_target_child_roots,
+										subroot->inh_target_child_roots);
+		}
+
 		/* We have at least one live child. */
 		has_live_children = true;
 
@@ -1327,6 +1389,125 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 }
 
 /*
+ * adjust_inherit_target_child
+ *		For an inheritance target child relation, this adjusts its
+ *		reltarget so that it contains expressions suitable for processing as
+ *		a target relation, creates a child PlannerInfo containing translated
+ *		copy of the query and returns it.
+ *
+ * The child PlannerInfo reuses most of the parent PlannerInfo's fields
+ * unchanged, except unexpanded_tlist and processed_tlist are based on the
+ * child relation.
+ */
+static PlannerInfo *
+adjust_inherit_target_child(PlannerInfo *root, RelOptInfo *childrel,
+							AppendRelInfo *appinfo)
+{
+	PlannerInfo *subroot;
+	List	   *tlist;
+	List	   *translated_exprs;
+	ListCell   *lc;
+
+	Assert(root->parse->commandType == CMD_UPDATE ||
+		   root->parse->commandType == CMD_DELETE);
+
+	/*
+	 * We'd like to build the reltarget afresh; save the translated
+	 * version of parent's expressions aside.
+	 */
+	translated_exprs = childrel->reltarget->exprs;
+	childrel->reltarget->exprs = NIL;
+
+	/* Translate the original query's expressions to this child. */
+	subroot = makeNode(PlannerInfo);
+	memcpy(subroot, root, sizeof(PlannerInfo));
+
+	/*
+	 * Restore the unexpanded tlist for translation, so that child's
+	 * query contains targetList numbered (resnos) per its own
+	 * TupleDesc, which adjust_inherited_tlist ensures.
+	 */
+	root->parse->targetList = root->unexpanded_tlist;
+	subroot->parse = (Query *) adjust_appendrel_attrs(root,
+													  (Node *) root->parse,
+													  1, &appinfo);
+
+	/*
+	 * Save subroot's targetlist so that childrel's own children can use it as
+	 * unexpanded tlist.  Must copy because subroot->parse->targetList will
+	 * be modified soon.
+	 */
+	subroot->unexpanded_tlist = list_copy(subroot->parse->targetList);
+
+	/*
+	 * Apply planner's expansion of targetlist, such as adding various junk
+	 * column, filling placeholder entries for dropped columns, etc., all of
+	 * which occurs with the child's TupleDesc.
+	 */
+	tlist = preprocess_targetlist(subroot);
+	subroot->processed_tlist = tlist;
+	build_base_rel_tlists(subroot, tlist);
+
+	/*
+	 * Some of the expressions in parent's reltarget might not be in the
+	 * child's freshly built reltarget expressions, because the latter only
+	 * contains those attributes that are needed to be present in the top-
+	 * level tlist (or ones that preprocess_targetlist thinks are needed to
+	 * be in the tlist.)  We may need other attributes such as those that
+	 * are required for computing WHERE clauses, which are already computed
+	 * for the parent during deconstruct_jointree processing of the original
+	 * query.  We've already got a translated copy of those attributes, from
+	 * which pick only those that are not already present.
+	 */
+	foreach(lc, translated_exprs)
+	{
+		Expr *expr = lfirst(lc);
+
+		if (!list_member(childrel->reltarget->exprs, expr))
+			childrel->reltarget->exprs = lappend(childrel->reltarget->exprs,
+												 expr);
+	}
+
+	/*
+	 * Set a few other fields of subroot.
+	 *
+	 * Reset inh_target_child_roots to not be same as parent root's so that
+	 * the subroots for this child's own children (if any) don't end up in
+	 * root parent's list.  We'll eventually merge all entries into one list,
+	 * but that's now now.
+	 */
+	subroot->inh_target_child_roots = NIL;
+
+	/*
+	 * Adjust all_baserels to replace the original target relation with the
+	 * child target relation.  Copy it before modifying though.
+	 */
+	subroot->all_baserels = bms_copy(root->all_baserels);
+	subroot->all_baserels = bms_del_member(subroot->all_baserels,
+										   root->parse->resultRelation);
+	subroot->all_baserels = bms_add_member(subroot->all_baserels,
+										   subroot->parse->resultRelation);
+
+	/*
+	 * Child root should get its own copy of ECs, because they'll be modified
+	 * to replace parent EC expressions by child expressions in
+	 * add_child_rel_equivalences.
+	 */
+	subroot->eq_classes = NIL;
+	foreach(lc, root->eq_classes)
+	{
+		EquivalenceClass *ec = lfirst(lc);
+		EquivalenceClass *new_ec = makeNode(EquivalenceClass);
+
+		memcpy(new_ec, ec, sizeof(EquivalenceClass));
+		new_ec->ec_members = list_copy(ec->ec_members);
+		subroot->eq_classes = lappend(subroot->eq_classes, new_ec);
+	}
+
+	return subroot;
+}
+
+/*
  * set_append_rel_pathlist
  *	  Build access paths for an "append relation"
  */
@@ -2624,6 +2805,131 @@ generate_gather_paths(PlannerInfo *root, RelOptInfo *rel, bool override_rows)
 }
 
 /*
+ * inheritance_make_rel_from_joinlist
+ *		Perform join planning for all non-dummy leaf inheritance children
+ *		in their role as an UPDATE/DELETE query's target relation
+ *
+ * If a child relation is a partitioned table, its children are processed in
+ * turn by recursively calling this function.
+ */
+static void
+inheritance_make_rel_from_joinlist(PlannerInfo *root, List *joinlist)
+{
+	Index		resultRelation = root->parse->resultRelation;
+	ListCell   *lc;
+#ifdef USE_ASSERT_CHECKING
+	Relids	all_baserels;
+#endif
+
+	/*
+	 * For UPDATE/DELETE queries, the top parent can only ever be a table.
+	 * As a contrast, it could be a UNION ALL subquery in the case of SELECT.
+	 */
+	Assert(root->parse->commandType == CMD_UPDATE ||
+		   root->parse->commandType == CMD_DELETE);
+	Assert(planner_rt_fetch(resultRelation, root)->rtekind == RTE_RELATION);
+
+	/* Nothing to do. */
+	if (IS_DUMMY_REL(find_base_rel(root, resultRelation )))
+		return;
+
+	foreach(lc, root->inh_target_child_roots)
+	{
+		PlannerInfo *subroot = lfirst(lc);
+		RelOptInfo *childrel;
+		AppendRelInfo *appinfo;
+		List	   *translated_joinlist;
+
+		Assert(subroot->parse->resultRelation > 0);
+		childrel = find_base_rel(root, subroot->parse->resultRelation);
+		appinfo = root->append_rel_array[subroot->parse->resultRelation];
+
+		if (appinfo->parent_relid != root->parse->resultRelation)
+			continue;
+
+		/* Ignore excluded/pruned children. */
+		if (IS_DUMMY_REL(childrel))
+			continue;
+
+		/*
+		 * Modify joinlist such that relations joined to the top parent rel
+		 * appear to be joined to the child rel instead.  Do the same for
+		 * any SpecialJoinInfo structs.
+		 */
+		translated_joinlist = (List *)
+						adjust_appendrel_attrs(subroot,
+											   (Node *) joinlist,
+											   1, &appinfo);
+		subroot->join_info_list = (List *)
+						adjust_appendrel_attrs(subroot,
+											   (Node *) root->join_info_list,
+											   1, &appinfo);
+
+		/*
+		 * Sub-partitioned tables have to be processed recursively using the
+		 * translated subroot as the parent, because AppendRelInfos link
+		 * sub-partitions to their immediate parents, not the root partitioned
+		 * table.
+		 */
+		if (childrel->part_scheme != NULL)
+		{
+			inheritance_make_rel_from_joinlist(subroot, translated_joinlist);
+
+			/*
+			 * Add this child relation as a placeholder in the parent root's
+			 * inh_target_child_rels so that inheritance_planner see same
+			 * number of entries as inh_target_child_roots.
+			 */
+			root->inh_target_child_rels =
+					lappend(root->inh_target_child_rels, childrel);
+
+			/* Also propagate this child's own children into parent's list. */
+			if (subroot->inh_target_child_rels != NIL)
+				root->inh_target_child_rels =
+					list_concat(root->inh_target_child_rels,
+								subroot->inh_target_child_rels);
+			continue;
+		}
+
+		/*
+		 * Since we added the child rel directly into the join tree, we must
+		 * modify it to be a "base" rel instead of an "other" rel, which the
+		 * join planning code expects the relations being joined to be. 
+		 */
+		childrel->reloptkind = RELOPT_BASEREL;
+
+		Assert(subroot->join_rel_list == NIL);
+		Assert(subroot->join_rel_hash == NULL);
+
+		/* Perform join planning and save the resulting RelOptInfo. */
+		childrel = make_rel_from_joinlist(subroot, translated_joinlist);
+
+		/*
+		 * Remember this child target rel.  inheritance_planner will perform
+		 * the remaining steps of planning for each child relation separately.
+		 * Specifically, it will call grouping_planner on every
+		 * RelOptInfo contained in the inh_target_child_rels list, each of
+		 * which represents the source of tuples to be modified for a given
+		 * target child rel.
+		 */
+		root->inh_target_child_rels =
+						lappend(root->inh_target_child_rels, childrel);
+#ifdef USE_ASSERT_CHECKING
+		/*
+		 * The following implements essentially the same Assert as in
+		 * make_one_rel, our caller.
+		 */
+		all_baserels = bms_copy(root->all_baserels);
+		all_baserels = bms_del_member(all_baserels,
+									  root->parse->resultRelation);
+		all_baserels = bms_add_member(all_baserels,
+									  subroot->parse->resultRelation);
+		Assert(bms_equal(childrel->relids, all_baserels));
+#endif
+	}
+}
+
+/*
  * make_rel_from_joinlist
  *	  Build access paths using a "joinlist" to guide the join path search.
  *
diff --git a/src/backend/optimizer/path/equivclass.c b/src/backend/optimizer/path/equivclass.c
index b22b36ec0e..029665b974 100644
--- a/src/backend/optimizer/path/equivclass.c
+++ b/src/backend/optimizer/path/equivclass.c
@@ -2104,12 +2104,18 @@ match_eclasses_to_foreign_key_col(PlannerInfo *root,
  *
  * parent_rel and child_rel could be derived from appinfo, but since the
  * caller has already computed them, we might as well just pass them in.
+ *
+ * If 'child_is_target' is true then the child EC members *replace* the
+ * corresponding parent members.  In that case, 'root' is the child target
+ * relation's dedicated PlannerInfo so it makes sense to remove the parent
+ * ECs altogether, because they're of no use.
  */
 void
 add_child_rel_equivalences(PlannerInfo *root,
 						   AppendRelInfo *appinfo,
 						   RelOptInfo *parent_rel,
-						   RelOptInfo *child_rel)
+						   RelOptInfo *child_rel,
+						   bool child_is_target)
 {
 	ListCell   *lc1;
 
@@ -2117,6 +2123,8 @@ add_child_rel_equivalences(PlannerInfo *root,
 	{
 		EquivalenceClass *cur_ec = (EquivalenceClass *) lfirst(lc1);
 		ListCell   *lc2;
+		ListCell   *prev;
+		ListCell   *next;
 
 		/*
 		 * If this EC contains a volatile expression, then generating child
@@ -2134,12 +2142,18 @@ add_child_rel_equivalences(PlannerInfo *root,
 			!bms_is_subset(parent_rel->relids, cur_ec->ec_relids))
 			continue;
 
-		foreach(lc2, cur_ec->ec_members)
+		prev = NULL;
+		for (lc2 = list_head(cur_ec->ec_members); lc2 != NULL; lc2 = next)
 		{
 			EquivalenceMember *cur_em = (EquivalenceMember *) lfirst(lc2);
 
+			next = lnext(lc2);
+
 			if (cur_em->em_is_const)
+			{
+				prev = lc2;
 				continue;		/* ignore consts here */
+			}
 
 			/* Does it reference parent_rel? */
 			if (bms_overlap(cur_em->em_relids, parent_rel->relids))
@@ -2177,10 +2191,17 @@ add_child_rel_equivalences(PlannerInfo *root,
 														  child_rel->relids);
 				}
 
+				/* Delete the parent EC member. */
+				if (child_is_target)
+					cur_ec->ec_members = list_delete_cell(cur_ec->ec_members,
+														  lc2, prev);
+
 				(void) add_eq_member(cur_ec, child_expr,
 									 new_relids, new_nullable_relids,
-									 true, cur_em->em_datatype);
+									 !child_is_target, cur_em->em_datatype);
 			}
+			else
+				prev = lc2;
 		}
 	}
 }
diff --git a/src/backend/optimizer/plan/createplan.c b/src/backend/optimizer/plan/createplan.c
index da7a92081a..28c4b53fea 100644
--- a/src/backend/optimizer/plan/createplan.c
+++ b/src/backend/optimizer/plan/createplan.c
@@ -1998,12 +1998,7 @@ create_groupingsets_plan(PlannerInfo *root, GroupingSetsPath *best_path)
 	/*
 	 * During setrefs.c, we'll need the grouping_map to fix up the cols lists
 	 * in GroupingFunc nodes.  Save it for setrefs.c to use.
-	 *
-	 * This doesn't work if we're in an inheritance subtree (see notes in
-	 * create_modifytable_plan).  Fortunately we can't be because there would
-	 * never be grouping in an UPDATE/DELETE; but let's Assert that.
 	 */
-	Assert(root->inhTargetKind == INHKIND_NONE);
 	Assert(root->grouping_map == NULL);
 	root->grouping_map = grouping_map;
 
@@ -2160,12 +2155,7 @@ create_minmaxagg_plan(PlannerInfo *root, MinMaxAggPath *best_path)
 	 * with InitPlan output params.  (We can't just do that locally in the
 	 * MinMaxAgg node, because path nodes above here may have Agg references
 	 * as well.)  Save the mmaggregates list to tell setrefs.c to do that.
-	 *
-	 * This doesn't work if we're in an inheritance subtree (see notes in
-	 * create_modifytable_plan).  Fortunately we can't be because there would
-	 * never be aggregates in an UPDATE/DELETE; but let's Assert that.
 	 */
-	Assert(root->inhTargetKind == INHKIND_NONE);
 	Assert(root->minmax_aggs == NIL);
 	root->minmax_aggs = best_path->mmaggregates;
 
diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index c729a99f8b..3fd1476f71 100644
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -37,6 +37,7 @@
 #ifdef OPTIMIZER_DEBUG
 #include "nodes/print.h"
 #endif
+#include "nodes/relation.h"
 #include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
@@ -126,7 +127,7 @@ static Node *preprocess_expression(PlannerInfo *root, Node *expr, int kind);
 static void preprocess_qual_conditions(PlannerInfo *root, Node *jtnode);
 static void inheritance_planner(PlannerInfo *root);
 static void grouping_planner(PlannerInfo *root, bool inheritance_update,
-				 double tuple_fraction);
+				 RelOptInfo *planned_rel, double tuple_fraction);
 static grouping_sets_data *preprocess_grouping_sets(PlannerInfo *root);
 static List *remap_to_groupclause_idx(List *groupClause, List *gsets,
 						 int *tleref_to_colnum_map);
@@ -630,7 +631,6 @@ subquery_planner(PlannerGlobal *glob, Query *parse,
 	root->grouping_map = NULL;
 	root->minmax_aggs = NIL;
 	root->qual_security_level = 0;
-	root->inhTargetKind = INHKIND_NONE;
 	root->hasRecursion = hasRecursion;
 	if (hasRecursion)
 		root->wt_param_id = SS_assign_special_param(root);
@@ -970,7 +970,7 @@ subquery_planner(PlannerGlobal *glob, Query *parse,
 		rt_fetch(parse->resultRelation, parse->rtable)->inh)
 		inheritance_planner(root);
 	else
-		grouping_planner(root, false, tuple_fraction);
+		grouping_planner(root, false, NULL, tuple_fraction);
 
 	/*
 	 * Capture the set of outer-level param IDs we have access to, for use in
@@ -1146,12 +1146,19 @@ preprocess_phv_expression(PlannerInfo *root, Expr *expr)
  *	  inheritance set.
  *
  * We have to handle this case differently from cases where a source relation
- * is an inheritance set. Source inheritance is expanded at the bottom of the
- * plan tree (see allpaths.c), but target inheritance has to be expanded at
- * the top.  The reason is that for UPDATE, each target relation needs a
- * different targetlist matching its own column set.  Fortunately,
- * the UPDATE/DELETE target can never be the nullable side of an outer join,
- * so it's OK to generate the plan this way.
+ * is an inheritance set.  That's mainly because for UPDATE, each target
+ * relation needs a different targetlist matching its own column set.  So, we
+ * must modify the source scan/join path for each target relation such that it
+ * produces the desired target list.
+ *
+ * The source scan/join paths for individual target relations are still
+ * created in allpaths.c by first expanding the inheritance in the usual way
+ * by set_append_rel_size, followed by join planning for each target relation
+ * separately in make_one_rel.  Finally, we apply grouping_planner here to each
+ * child scan/join path so that it produces the desired targetlist.
+ *
+ * Fortunately, the UPDATE/DELETE target can never be the nullable side of an
+ * outer join, so it's OK to generate the plan this way.
  *
  * Returns nothing; the useful output is in the Paths we attach to
  * the (UPPERREL_FINAL, NULL) upperrel stored in *root.
@@ -1164,14 +1171,8 @@ inheritance_planner(PlannerInfo *root)
 {
 	Query	   *parse = root->parse;
 	int			top_parentRTindex = parse->resultRelation;
-	Bitmapset  *subqueryRTindexes;
-	Bitmapset  *modifiableARIindexes;
 	int			nominalRelation = -1;
 	Index		rootRelation = 0;
-	List	   *final_rtable = NIL;
-	int			save_rel_array_size = 0;
-	RelOptInfo **save_rel_array = NULL;
-	AppendRelInfo **save_append_rel_array = NULL;
 	List	   *subpaths = NIL;
 	List	   *subroots = NIL;
 	List	   *resultRelations = NIL;
@@ -1179,70 +1180,59 @@ inheritance_planner(PlannerInfo *root)
 	List	   *returningLists = NIL;
 	List	   *rowMarks;
 	RelOptInfo *final_rel;
-	ListCell   *lc;
-	Index		rti;
+	ListCell   *lc1,
+			   *lc2;
 	RangeTblEntry *parent_rte;
-	PlannerInfo *parent_root;
-	Query	   *parent_parse;
-	Bitmapset  *parent_relids = bms_make_singleton(top_parentRTindex);
-	PlannerInfo **parent_roots = NULL;
+	List	   *tlist;
+	standard_qp_extra qp_extra;
+	RelOptInfo *planned_rel;
 
+	/* Inheritance is never used for insert. */
 	Assert(parse->commandType != CMD_INSERT);
+	parent_rte = planner_rt_fetch(top_parentRTindex, root);
 
 	/*
-	 * We generate a modified instance of the original Query for each target
-	 * relation, plan that, and put all the plans into a list that will be
-	 * controlled by a single ModifyTable node.  All the instances share the
-	 * same rangetable, but each instance must have its own set of subquery
-	 * RTEs within the finished rangetable because (1) they are likely to get
-	 * scribbled on during planning, and (2) it's not inconceivable that
-	 * subqueries could get planned differently in different cases.  We need
-	 * not create duplicate copies of other RTE kinds, in particular not the
-	 * target relations, because they don't have either of those issues.  Not
-	 * having to duplicate the target relations is important because doing so
-	 * (1) would result in a rangetable of length O(N^2) for N targets, with
-	 * at least O(N^3) work expended here; and (2) would greatly complicate
-	 * management of the rowMarks list.
+	 * Generate the access paths for all relations mentioned in the query,
+	 * including the target inheritance set.  When doing the join planning,
+	 * references in the join tree to the original target relation that's the
+	 * root parent of the inheritance tree is replaced by each of its
+	 * inheritance children and the resulting joinrel RelOptInfo's are
+	 * added to root->inh_target_child_rels.
 	 *
-	 * To begin with, generate a bitmapset of the relids of the subquery RTEs.
+	 * Final planning steps (grouping_planner) are applied to the best path
+	 * of each of those child joinrels using a modified instance of the
+	 * original query for a given child target rel.  All the paths so generated
+	 * are put into  a list that will be controlled by a single ModifyTable
+	 * node.  All the instances share the same rangetable.
 	 */
-	subqueryRTindexes = NULL;
-	rti = 1;
-	foreach(lc, parse->rtable)
-	{
-		RangeTblEntry *rte = lfirst_node(RangeTblEntry, lc);
-
-		if (rte->rtekind == RTE_SUBQUERY)
-			subqueryRTindexes = bms_add_member(subqueryRTindexes, rti);
-		rti++;
-	}
 
 	/*
-	 * Next, we want to identify which AppendRelInfo items contain references
-	 * to any of the aforesaid subquery RTEs.  These items will need to be
-	 * copied and modified to adjust their subquery references; whereas the
-	 * other ones need not be touched.  It's worth being tense over this
-	 * because we can usually avoid processing most of the AppendRelInfo
-	 * items, thereby saving O(N^2) space and time when the target is a large
-	 * inheritance tree.  We can identify AppendRelInfo items by their
-	 * child_relid, since that should be unique within the list.
+	 * Save the unexpanded version of the query's targetlist to be used below
+	 * for passing to grouping_planner for each child target relation.
 	 */
-	modifiableARIindexes = NULL;
-	if (subqueryRTindexes != NULL)
-	{
-		foreach(lc, root->append_rel_list)
-		{
-			AppendRelInfo *appinfo = lfirst_node(AppendRelInfo, lc);
+	root->unexpanded_tlist = list_copy(root->parse->targetList);
 
-			if (bms_is_member(appinfo->parent_relid, subqueryRTindexes) ||
-				bms_is_member(appinfo->child_relid, subqueryRTindexes) ||
-				bms_overlap(pull_varnos((Node *) appinfo->translated_vars),
-							subqueryRTindexes))
-				modifiableARIindexes = bms_add_member(modifiableARIindexes,
-													  appinfo->child_relid);
-		}
+	/* Do the scan/join planning. */
+	tlist = preprocess_targetlist(root);
+	root->processed_tlist = tlist;
+	qp_extra.tlist = tlist;
+	qp_extra.activeWindows = qp_extra.groupClause = NIL;
+	planned_rel = query_planner(root, tlist, standard_qp_callback, &qp_extra);
+
+	/*
+	 * If it turned out during query planning that all the children are dummy
+	 * (pruned or excluded by constraints), no need to do the steps below.
+	 * Let grouping_planner finish up the final path.
+	 */
+	if (IS_DUMMY_REL(planned_rel))
+	{
+		grouping_planner(root, false, planned_rel, 0.0);
+		return;
 	}
 
+	Assert(planned_rel->relid == top_parentRTindex);
+	Assert(planned_rel->reloptkind == RELOPT_BASEREL);
+
 	/*
 	 * If the parent RTE is a partitioned table, we should use that as the
 	 * nominal target relation, because the RTEs added for partitioned tables
@@ -1250,7 +1240,6 @@ inheritance_planner(PlannerInfo *root)
 	 * not appear anywhere else in the plan, so the confusion explained below
 	 * for non-partitioning inheritance cases is not possible.
 	 */
-	parent_rte = rt_fetch(top_parentRTindex, root->parse->rtable);
 	if (parent_rte->relkind == RELKIND_PARTITIONED_TABLE)
 	{
 		nominalRelation = top_parentRTindex;
@@ -1258,95 +1247,40 @@ inheritance_planner(PlannerInfo *root)
 	}
 
 	/*
-	 * The PlannerInfo for each child is obtained by translating the relevant
-	 * members of the PlannerInfo for its immediate parent, which we find
-	 * using the parent_relid in its AppendRelInfo.  We save the PlannerInfo
-	 * for each parent in an array indexed by relid for fast retrieval. Since
-	 * the maximum number of parents is limited by the number of RTEs in the
-	 * query, we use that number to allocate the array. An extra entry is
-	 * needed since relids start from 1.
+	 * Get on with finalizing the path for each child target relation by
+	 * calling grouping_planner on its joinrel.  Note that we're restoring
+	 * the query's targetlist to the original one for grouping_planner's
+	 * targetlist expansion steps to perform the expansion with individual
+	 * child descriptors.
 	 */
-	parent_roots = (PlannerInfo **) palloc0((list_length(parse->rtable) + 1) *
-											sizeof(PlannerInfo *));
-	parent_roots[top_parentRTindex] = root;
-
-	/*
-	 * And now we can get on with generating a plan for each child table.
-	 */
-	foreach(lc, root->append_rel_list)
+	forboth(lc1, root->inh_target_child_roots,
+			lc2, root->inh_target_child_rels)
 	{
-		AppendRelInfo *appinfo = lfirst_node(AppendRelInfo, lc);
-		PlannerInfo *subroot;
+		PlannerInfo *subroot = lfirst(lc1);
+		RelOptInfo *childrel = lfirst(lc2);
+		AppendRelInfo *appinfo;
 		RangeTblEntry *child_rte;
 		RelOptInfo *sub_final_rel;
 		Path	   *subpath;
 
-		/* append_rel_list contains all append rels; ignore others */
-		if (!bms_is_member(appinfo->parent_relid, parent_relids))
-			continue;
-
-		/*
-		 * expand_inherited_rtentry() always processes a parent before any of
-		 * that parent's children, so the parent_root for this relation should
-		 * already be available.
-		 */
-		parent_root = parent_roots[appinfo->parent_relid];
-		Assert(parent_root != NULL);
-		parent_parse = parent_root->parse;
-
-		/*
-		 * We need a working copy of the PlannerInfo so that we can control
-		 * propagation of information back to the main copy.
-		 */
-		subroot = makeNode(PlannerInfo);
-		memcpy(subroot, parent_root, sizeof(PlannerInfo));
-
-		/*
-		 * Generate modified query with this rel as target.  We first apply
-		 * adjust_appendrel_attrs, which copies the Query and changes
-		 * references to the parent RTE to refer to the current child RTE,
-		 * then fool around with subquery RTEs.
-		 */
-		subroot->parse = (Query *)
-			adjust_appendrel_attrs(parent_root,
-								   (Node *) parent_parse,
-								   1, &appinfo);
+		appinfo = root->append_rel_array[subroot->parse->resultRelation];
 
 		/*
 		 * If there are securityQuals attached to the parent, move them to the
 		 * child rel (they've already been transformed properly for that).
 		 */
-		parent_rte = rt_fetch(appinfo->parent_relid, subroot->parse->rtable);
-		child_rte = rt_fetch(appinfo->child_relid, subroot->parse->rtable);
+		parent_rte = planner_rt_fetch(appinfo->parent_relid, subroot);
+		child_rte = planner_rt_fetch(appinfo->child_relid, subroot);
 		child_rte->securityQuals = parent_rte->securityQuals;
 		parent_rte->securityQuals = NIL;
 
 		/*
-		 * Mark whether we're planning a query to a partitioned table or an
-		 * inheritance parent.
+		 * Ignore a partitioned child.  Instead, the paths of its children will
+		 * be added to subpaths.
 		 */
-		subroot->inhTargetKind =
-			(rootRelation != 0) ? INHKIND_PARTITIONED : INHKIND_INHERITED;
-
-		/*
-		 * If this child is further partitioned, remember it as a parent.
-		 * Since a partitioned table does not have any data, we don't need to
-		 * create a plan for it, and we can stop processing it here.  We do,
-		 * however, need to remember its modified PlannerInfo for use when
-		 * processing its children, since we'll update their varnos based on
-		 * the delta from immediate parent to child, not from top to child.
-		 *
-		 * Note: a very non-obvious point is that we have not yet added
-		 * duplicate subquery RTEs to the subroot's rtable.  We mustn't,
-		 * because then its children would have two sets of duplicates,
-		 * confusing matters.
-		 */
-		if (child_rte->inh)
+		if (childrel->part_scheme)
 		{
-			Assert(child_rte->relkind == RELKIND_PARTITIONED_TABLE);
-			parent_relids = bms_add_member(parent_relids, appinfo->child_relid);
-			parent_roots[appinfo->child_relid] = subroot;
-
+			Assert(child_rte->inh);
 			continue;
 		}
 
@@ -1374,111 +1308,8 @@ inheritance_planner(PlannerInfo *root)
 		if (nominalRelation < 0)
 			nominalRelation = appinfo->child_relid;
 
-		/*
-		 * The rowMarks list might contain references to subquery RTEs, so
-		 * make a copy that we can apply ChangeVarNodes to.  (Fortunately, the
-		 * executor doesn't need to see the modified copies --- we can just
-		 * pass it the original rowMarks list.)
-		 */
-		subroot->rowMarks = copyObject(parent_root->rowMarks);
-
-		/*
-		 * The append_rel_list likewise might contain references to subquery
-		 * RTEs (if any subqueries were flattenable UNION ALLs).  So prepare
-		 * to apply ChangeVarNodes to that, too.  As explained above, we only
-		 * want to copy items that actually contain such references; the rest
-		 * can just get linked into the subroot's append_rel_list.
-		 *
-		 * If we know there are no such references, we can just use the outer
-		 * append_rel_list unmodified.
-		 */
-		if (modifiableARIindexes != NULL)
-		{
-			ListCell   *lc2;
-
-			subroot->append_rel_list = NIL;
-			foreach(lc2, parent_root->append_rel_list)
-			{
-				AppendRelInfo *appinfo2 = lfirst_node(AppendRelInfo, lc2);
-
-				if (bms_is_member(appinfo2->child_relid, modifiableARIindexes))
-					appinfo2 = copyObject(appinfo2);
-
-				subroot->append_rel_list = lappend(subroot->append_rel_list,
-												   appinfo2);
-			}
-		}
-
-		/*
-		 * Add placeholders to the child Query's rangetable list to fill the
-		 * RT indexes already reserved for subqueries in previous children.
-		 * These won't be referenced, so there's no need to make them very
-		 * valid-looking.
-		 */
-		while (list_length(subroot->parse->rtable) < list_length(final_rtable))
-			subroot->parse->rtable = lappend(subroot->parse->rtable,
-											 makeNode(RangeTblEntry));
-
-		/*
-		 * If this isn't the first child Query, generate duplicates of all
-		 * subquery RTEs, and adjust Var numbering to reference the
-		 * duplicates. To simplify the loop logic, we scan the original rtable
-		 * not the copy just made by adjust_appendrel_attrs; that should be OK
-		 * since subquery RTEs couldn't contain any references to the target
-		 * rel.
-		 */
-		if (final_rtable != NIL && subqueryRTindexes != NULL)
-		{
-			ListCell   *lr;
-
-			rti = 1;
-			foreach(lr, parent_parse->rtable)
-			{
-				RangeTblEntry *rte = lfirst_node(RangeTblEntry, lr);
-
-				if (bms_is_member(rti, subqueryRTindexes))
-				{
-					Index		newrti;
-
-					/*
-					 * The RTE can't contain any references to its own RT
-					 * index, except in its securityQuals, so we can save a
-					 * few cycles by applying ChangeVarNodes to the rest of
-					 * the rangetable before we append the RTE to it.
-					 */
-					newrti = list_length(subroot->parse->rtable) + 1;
-					ChangeVarNodes((Node *) subroot->parse, rti, newrti, 0);
-					ChangeVarNodes((Node *) subroot->rowMarks, rti, newrti, 0);
-					/* Skip processing unchanging parts of append_rel_list */
-					if (modifiableARIindexes != NULL)
-					{
-						ListCell   *lc2;
-
-						foreach(lc2, subroot->append_rel_list)
-						{
-							AppendRelInfo *appinfo2 = lfirst_node(AppendRelInfo, lc2);
-
-							if (bms_is_member(appinfo2->child_relid,
-											  modifiableARIindexes))
-								ChangeVarNodes((Node *) appinfo2, rti, newrti, 0);
-						}
-					}
-					rte = copyObject(rte);
-					ChangeVarNodes((Node *) rte->securityQuals, rti, newrti, 0);
-					subroot->parse->rtable = lappend(subroot->parse->rtable,
-													 rte);
-				}
-				rti++;
-			}
-		}
-
-		/* There shouldn't be any OJ info to translate, as yet */
-		Assert(subroot->join_info_list == NIL);
-		/* and we haven't created PlaceHolderInfos, either */
-		Assert(subroot->placeholder_list == NIL);
-
-		/* Generate Path(s) for accessing this result relation */
-		grouping_planner(subroot, true, 0.0 /* retrieve all tuples */ );
+		/* Apply the top-level targetlist to childrel's path. */
+		grouping_planner(subroot, true, childrel, 0.0);
 
 		/*
 		 * Select cheapest path in case there's more than one.  We always run
@@ -1490,45 +1321,10 @@ inheritance_planner(PlannerInfo *root)
 		subpath = sub_final_rel->cheapest_total_path;
 
 		/*
-		 * If this child rel was excluded by constraint exclusion, exclude it
-		 * from the result plan.
+		 * child rel cannot be empty, or inheritance_make_rel_from_joinlist
+		 * wouldn't have put it in the list to begin with.
 		 */
-		if (IS_DUMMY_PATH(subpath))
-			continue;
-
-		/*
-		 * If this is the first non-excluded child, its post-planning rtable
-		 * becomes the initial contents of final_rtable; otherwise, append
-		 * just its modified subquery RTEs to final_rtable.
-		 */
-		if (final_rtable == NIL)
-			final_rtable = subroot->parse->rtable;
-		else
-			final_rtable = list_concat(final_rtable,
-									   list_copy_tail(subroot->parse->rtable,
-													  list_length(final_rtable)));
-
-		/*
-		 * We need to collect all the RelOptInfos from all child plans into
-		 * the main PlannerInfo, since setrefs.c will need them.  We use the
-		 * last child's simple_rel_array (previous ones are too short), so we
-		 * have to propagate forward the RelOptInfos that were already built
-		 * in previous children.
-		 */
-		Assert(subroot->simple_rel_array_size >= save_rel_array_size);
-		for (rti = 1; rti < save_rel_array_size; rti++)
-		{
-			RelOptInfo *brel = save_rel_array[rti];
-
-			if (brel)
-				subroot->simple_rel_array[rti] = brel;
-		}
-		save_rel_array_size = subroot->simple_rel_array_size;
-		save_rel_array = subroot->simple_rel_array;
-		save_append_rel_array = subroot->append_rel_array;
-
-		/* Make sure any initplans from this rel get into the outer list */
-		root->init_plans = subroot->init_plans;
+		Assert(!IS_DUMMY_PATH(subpath));
 
 		/* Build list of sub-paths */
 		subpaths = lappend(subpaths, subpath);
@@ -1560,36 +1356,6 @@ inheritance_planner(PlannerInfo *root)
 	 */
 
 	/*
-	 * If we managed to exclude every child rel, return a dummy plan; it
-	 * doesn't even need a ModifyTable node.
-	 */
-	if (subpaths == NIL)
-	{
-		set_dummy_rel_pathlist(final_rel);
-		return;
-	}
-
-	/*
-	 * Put back the final adjusted rtable into the master copy of the Query.
-	 * (We mustn't do this if we found no non-excluded children.)
-	 */
-	parse->rtable = final_rtable;
-	root->simple_rel_array_size = save_rel_array_size;
-	root->simple_rel_array = save_rel_array;
-	root->append_rel_array = save_append_rel_array;
-
-	/* Must reconstruct master's simple_rte_array, too */
-	root->simple_rte_array = (RangeTblEntry **)
-		palloc0((list_length(final_rtable) + 1) * sizeof(RangeTblEntry *));
-	rti = 1;
-	foreach(lc, final_rtable)
-	{
-		RangeTblEntry *rte = lfirst_node(RangeTblEntry, lc);
-
-		root->simple_rte_array[rti++] = rte;
-	}
-
-	/*
 	 * If there was a FOR [KEY] UPDATE/SHARE clause, the LockRows node will
 	 * have dealt with fetching non-locked marked rows, else we need to have
 	 * ModifyTable do that.
@@ -1629,6 +1395,12 @@ inheritance_planner(PlannerInfo *root)
  * (inheritance_planner will create a single ModifyTable node covering all the
  * target tables.)
  *
+ * If non-NULL, planned_rel is a RelOptInfo containing paths for the query's
+ * top-level joinrel, which the caller produced by itself.  In that case, this
+ * function only needs to adjust the targetlist of its cheapest_total_path.
+ * The only caller that may pass such a RelOptInfo currently is
+ * inheritance_planner.
+ *
  * tuple_fraction is the fraction of tuples we expect will be retrieved.
  * tuple_fraction is interpreted as follows:
  *	  0: expect all tuples to be retrieved (normal case)
@@ -1647,6 +1419,7 @@ inheritance_planner(PlannerInfo *root)
  */
 static void
 grouping_planner(PlannerInfo *root, bool inheritance_update,
+				 RelOptInfo *planned_rel,
 				 double tuple_fraction)
 {
 	Query	   *parse = root->parse;
@@ -1659,7 +1432,7 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 	List	   *final_targets;
 	List	   *final_targets_contain_srfs;
 	bool		final_target_parallel_safe;
-	RelOptInfo *current_rel;
+	RelOptInfo *current_rel = planned_rel;
 	RelOptInfo *final_rel;
 	ListCell   *lc;
 
@@ -1699,6 +1472,7 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 		 * special work for recursive unions is the responsibility of
 		 * plan_set_operations.
 		 */
+		Assert(current_rel == NULL);
 		current_rel = plan_set_operations(root);
 
 		/*
@@ -1788,17 +1562,26 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 				parse->groupClause = preprocess_groupclause(root, NIL);
 		}
 
-		/* Preprocess targetlist */
-		tlist = preprocess_targetlist(root);
-
 		/*
-		 * We are now done hacking up the query's targetlist.  Most of the
-		 * remaining planning work will be done with the PathTarget
-		 * representation of tlists, but save aside the full representation so
-		 * that we can transfer its decoration (resnames etc) to the topmost
-		 * tlist of the finished Plan.
+		 * Preprocess targetlist, if needed.  If the caller has already done
+		 * query planning, root->processed_tlist already contain the desired
+		 * targetlist.
 		 */
-		root->processed_tlist = tlist;
+		if (planned_rel == NULL)
+		{
+			tlist = preprocess_targetlist(root);
+
+			/*
+			 * We are now done hacking up the query's targetlist.  Most of the
+			 * remaining planning work will be done with the PathTarget
+			 * representation of tlists, but save aside the full representation
+			 * so that we can transfer its decoration (resnames etc) to the
+			 * topmost tlist of the finished Plan.
+			 */
+			root->processed_tlist = tlist;
+		}
+		else
+			tlist = root->processed_tlist;
 
 		/*
 		 * Collect statistics about aggregates for estimating costs, and mark
@@ -1878,8 +1661,9 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 		 * We also generate (in standard_qp_callback) pathkey representations
 		 * of the query's sort clause, distinct clause, etc.
 		 */
-		current_rel = query_planner(root, tlist,
-									standard_qp_callback, &qp_extra);
+		if (current_rel == NULL)
+			current_rel = query_planner(root, tlist,
+										standard_qp_callback, &qp_extra);
 
 		/*
 		 * Convert the query's result tlist into PathTarget format.
diff --git a/src/backend/optimizer/prep/prepjointree.c b/src/backend/optimizer/prep/prepjointree.c
index cd6e11904e..78baec00dc 100644
--- a/src/backend/optimizer/prep/prepjointree.c
+++ b/src/backend/optimizer/prep/prepjointree.c
@@ -917,7 +917,6 @@ pull_up_simple_subquery(PlannerInfo *root, Node *jtnode, RangeTblEntry *rte,
 	subroot->grouping_map = NULL;
 	subroot->minmax_aggs = NIL;
 	subroot->qual_security_level = 0;
-	subroot->inhTargetKind = INHKIND_NONE;
 	subroot->hasRecursion = false;
 	subroot->wt_param_id = -1;
 	subroot->non_recursive_path = NULL;
diff --git a/src/backend/optimizer/prep/prepunion.c b/src/backend/optimizer/prep/prepunion.c
index 2a1c1cb2e1..134e7bafd9 100644
--- a/src/backend/optimizer/prep/prepunion.c
+++ b/src/backend/optimizer/prep/prepunion.c
@@ -2250,8 +2250,39 @@ adjust_appendrel_attrs_mutator(Node *node,
 											  context->appinfos);
 		return (Node *) phv;
 	}
+
+	/*
+	 * This is needed, because inheritance_make_rel_from_joinlist needs to
+	 * translate root->join_info_list executing make_rel_from_joinlist for a
+	 * given child.
+	 */
+	if (IsA(node, SpecialJoinInfo))
+	{
+		SpecialJoinInfo *oldinfo = (SpecialJoinInfo *) node;
+		SpecialJoinInfo *newinfo = makeNode(SpecialJoinInfo);
+
+		memcpy(newinfo, oldinfo, sizeof(SpecialJoinInfo));
+		newinfo->min_lefthand = adjust_child_relids(oldinfo->min_lefthand,
+													context->nappinfos,
+													context->appinfos);
+		newinfo->min_righthand = adjust_child_relids(oldinfo->min_righthand,
+													 context->nappinfos,
+													 context->appinfos);
+		newinfo->syn_lefthand = adjust_child_relids(oldinfo->syn_lefthand,
+													context->nappinfos,
+													context->appinfos);
+		newinfo->syn_righthand = adjust_child_relids(oldinfo->syn_righthand,
+													 context->nappinfos,
+													 context->appinfos);
+		newinfo->semi_rhs_exprs =
+					(List *) expression_tree_mutator((Node *)
+													 oldinfo->semi_rhs_exprs,
+													 adjust_appendrel_attrs_mutator,
+													 (void *) context);
+		return (Node *) newinfo;
+	}
+
 	/* 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));
diff --git a/src/backend/optimizer/util/plancat.c b/src/backend/optimizer/util/plancat.c
index a570ac0aab..a0fed5be42 100644
--- a/src/backend/optimizer/util/plancat.c
+++ b/src/backend/optimizer/util/plancat.c
@@ -1264,36 +1264,6 @@ get_relation_constraints(PlannerInfo *root,
 		}
 	}
 
-	/*
-	 * Append partition predicates, if any.
-	 *
-	 * For selects, partition pruning uses the parent table's partition bound
-	 * descriptor, instead of constraint exclusion which is driven by the
-	 * individual partition's partition constraint.
-	 */
-	if (enable_partition_pruning && root->parse->commandType != CMD_SELECT)
-	{
-		List	   *pcqual = RelationGetPartitionQual(relation);
-
-		if (pcqual)
-		{
-			/*
-			 * Run the partition quals through const-simplification similar to
-			 * check constraints.  We skip canonicalize_qual, though, because
-			 * partition quals should be in canonical form already; also,
-			 * since the qual is in implicit-AND format, we'd have to
-			 * explicitly convert it to explicit-AND format and back again.
-			 */
-			pcqual = (List *) eval_const_expressions(root, (Node *) pcqual);
-
-			/* Fix Vars to have the desired varno */
-			if (varno != 1)
-				ChangeVarNodes((Node *) pcqual, 1, varno, 0);
-
-			result = list_concat(result, pcqual);
-		}
-	}
-
 	heap_close(relation, NoLock);
 
 	return result;
@@ -1420,31 +1390,15 @@ relation_excluded_by_constraints(PlannerInfo *root,
 	switch (constraint_exclusion)
 	{
 		case CONSTRAINT_EXCLUSION_OFF:
-
-			/*
-			 * Don't prune if feature turned off -- except if the relation is
-			 * a partition.  While partprune.c-style partition pruning is not
-			 * yet in use for all cases (update/delete is not handled), it
-			 * would be a UI horror to use different user-visible controls
-			 * depending on such a volatile implementation detail.  Therefore,
-			 * for partitioned tables we use enable_partition_pruning to
-			 * control this behavior.
-			 */
-			if (root->inhTargetKind == INHKIND_PARTITIONED)
-				break;
 			return false;
 
 		case CONSTRAINT_EXCLUSION_PARTITION:
 
 			/*
 			 * When constraint_exclusion is set to 'partition' we only handle
-			 * OTHER_MEMBER_RELs, or BASERELs in cases where the result target
-			 * is an inheritance parent or a partitioned table.
+			 * OTHER_MEMBER_RELs.
 			 */
-			if ((rel->reloptkind != RELOPT_OTHER_MEMBER_REL) &&
-				!(rel->reloptkind == RELOPT_BASEREL &&
-				  root->inhTargetKind != INHKIND_NONE &&
-				  rel->relid == root->parse->resultRelation))
+			if (rel->reloptkind != RELOPT_OTHER_MEMBER_REL)
 				return false;
 			break;
 
diff --git a/src/include/nodes/relation.h b/src/include/nodes/relation.h
index 6fd24203dd..2ad3dc4711 100644
--- a/src/include/nodes/relation.h
+++ b/src/include/nodes/relation.h
@@ -319,9 +319,6 @@ typedef struct PlannerInfo
 	Index		qual_security_level;	/* minimum security_level for quals */
 	/* Note: qual_security_level is zero if there are no securityQuals */
 
-	InheritanceKind inhTargetKind;	/* indicates if the target relation is an
-									 * inheritance child or partition or a
-									 * partitioned table */
 	bool		hasJoinRTEs;	/* true if any RTEs are RTE_JOIN kind */
 	bool		hasLateralRTEs; /* true if any RTEs are marked LATERAL */
 	bool		hasDeletedRTEs; /* true if any RTE was deleted from jointree */
@@ -343,6 +340,34 @@ typedef struct PlannerInfo
 
 	/* Does this query modify any partition key columns? */
 	bool		partColsUpdated;
+
+	/*
+	 * The following fields are set during query planning portion of an
+	 * inherited UPDATE/DEELETE operation.
+	 */
+
+	/*
+	 * This stores the original version of the query's targetlist that's
+	 * not modified by the planner.
+	 */
+	List	   *unexpanded_tlist;
+
+	/*
+	 * List containing a PlannerInfo corresponding to each child target rel.
+	 * Content of each PlannerInfo is same as the parent PlannerInfo, except
+	 * for the parse tree which is a translated copy of the parent's parse
+	 * tree.
+	 */
+	List	   *inh_target_child_roots;
+
+	/*
+	 * RelOptInfos corresponding to each child target rel.  For leaf children,
+	 * it's the RelOptInfo representing the output of make_rel_from_joinlist()
+	 * called with the parent rel in the original join tree replaced by a
+	 * given leaf child.  For non-leaf children, it's the baserel RelOptInfo
+	 * itself, left as a placeholder.
+	 */
+	List	   *inh_target_child_rels;
 } PlannerInfo;
 
 
diff --git a/src/include/optimizer/paths.h b/src/include/optimizer/paths.h
index cafde307ad..7aa1b6e17f 100644
--- a/src/include/optimizer/paths.h
+++ b/src/include/optimizer/paths.h
@@ -161,7 +161,8 @@ extern EquivalenceClass *match_eclasses_to_foreign_key_col(PlannerInfo *root,
 extern void add_child_rel_equivalences(PlannerInfo *root,
 						   AppendRelInfo *appinfo,
 						   RelOptInfo *parent_rel,
-						   RelOptInfo *child_rel);
+						   RelOptInfo *child_rel,
+						   bool child_is_target);
 extern List *generate_implied_equalities_for_column(PlannerInfo *root,
 									   RelOptInfo *rel,
 									   ec_matches_callback_type callback,
diff --git a/src/test/regress/expected/partition_join.out b/src/test/regress/expected/partition_join.out
index 3ba3aaf2d8..a539280851 100644
--- a/src/test/regress/expected/partition_join.out
+++ b/src/test/regress/expected/partition_join.out
@@ -1781,7 +1781,7 @@ WHERE EXISTS (
                Filter: (c IS NULL)
          ->  Nested Loop
                ->  Seq Scan on int4_tbl
-               ->  Subquery Scan on ss_1
+               ->  Subquery Scan on ss
                      ->  Limit
                            ->  Seq Scan on int8_tbl int8_tbl_1
    ->  Nested Loop Semi Join
@@ -1789,7 +1789,7 @@ WHERE EXISTS (
                Filter: (c IS NULL)
          ->  Nested Loop
                ->  Seq Scan on int4_tbl
-               ->  Subquery Scan on ss_2
+               ->  Subquery Scan on ss
                      ->  Limit
                            ->  Seq Scan on int8_tbl int8_tbl_2
 (28 rows)
-- 
2.11.0

From 2b7f9f7f9f8d8fcbd493eb03cdfa9efdd56d6ed7 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Fri, 26 Oct 2018 16:45:59 +0900
Subject: [PATCH v8 2/6] Store inheritance root parent index in otherrel's
 RelOptInfo

Although it's set by build_simple_rel, it's not being used by any
code yet.
---
 src/backend/nodes/outfuncs.c         |  1 +
 src/backend/optimizer/util/relnode.c | 14 ++++++++++++++
 src/include/nodes/relation.h         |  4 ++++
 3 files changed, 19 insertions(+)

diff --git a/src/backend/nodes/outfuncs.c b/src/backend/nodes/outfuncs.c
index 08657fcfd9..1d7c420e75 100644
--- a/src/backend/nodes/outfuncs.c
+++ b/src/backend/nodes/outfuncs.c
@@ -2370,6 +2370,7 @@ _outRelOptInfo(StringInfo str, const RelOptInfo *node)
 	WRITE_BOOL_FIELD(consider_partitionwise_join);
 	WRITE_BITMAPSET_FIELD(top_parent_relids);
 	WRITE_NODE_FIELD(partitioned_child_rels);
+	WRITE_UINT_FIELD(inh_root_parent);
 }
 
 static void
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index 39f5729b91..29ba19349f 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -215,9 +215,23 @@ build_simple_rel(PlannerInfo *root, int relid, RelOptInfo *parent)
 			rel->top_parent_relids = parent->top_parent_relids;
 		else
 			rel->top_parent_relids = bms_copy(parent->relids);
+
+		/*
+		 * For inheritance child relations, we also set inh_root_parent.
+		 * Note that 'parent' might itself be a child (a sub-partitioned
+		 * partition), in which case we simply use its value of
+		 * inh_root_parent.
+		 */
+		if (parent->rtekind == RTE_RELATION)
+			rel->inh_root_parent = parent->inh_root_parent > 0 ?
+										parent->inh_root_parent :
+										parent->relid;
 	}
 	else
+	{
 		rel->top_parent_relids = NULL;
+		rel->inh_root_parent = 0;
+	}
 
 	/* Check type of rtable entry */
 	switch (rte->rtekind)
diff --git a/src/include/nodes/relation.h b/src/include/nodes/relation.h
index 2ad3dc4711..94f14019bd 100644
--- a/src/include/nodes/relation.h
+++ b/src/include/nodes/relation.h
@@ -728,6 +728,10 @@ typedef struct RelOptInfo
 	List	  **partexprs;		/* Non-nullable partition key expressions. */
 	List	  **nullable_partexprs; /* Nullable partition key expressions. */
 	List	   *partitioned_child_rels; /* List of RT indexes. */
+
+	Index		inh_root_parent;	/* For otherrels, this is the RT index of
+									 * inheritance table mentioned in the query
+									 * from which this relation originated */
 } RelOptInfo;
 
 /*
-- 
2.11.0

From ad19486433a929f661d74d3b3f51eb8cd86f3d58 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Wed, 17 Oct 2018 18:14:13 +0900
Subject: [PATCH v8 3/6] Lazy creation of RTEs for inheritance children

Currently, expand_inherited_tables called from subquery_planner opens
all inheritance child tables and adds them to the query's range
table and PlannerInfo in the form of AppendRelInfo's initially and
later RelOptInfo's.  For partitioning, that's pretty wasteful, because
it's possible to determine only the partitions that will need to be
scanned using partition pruning, which doesn't require opening the
partitions themselves.  However, the point at which the above
processing happens is too early to perform partition pruning.

This commit rearranges things within the planner so that inheritance
child relations can be added to the Query and PlannerInfo during
make_one_rel, just before set_base_rel_sizes is called.  Although the
late initialization approach only benefits the partitioning case, it
seems undesirable to do it only for partitioned tables, because it
means adding code to handle partitions specially at various places
within the planner.  So, *all* inheritance parent tables are expanded
in make_one_rel.  All unpruned partitions are added to Query in the
form of their RangeTblEntry's being added to the range table and to
PlannerInfo in the form of an AppendRelInfo and a RelOptInfo for each.

For partitioning, although we don't create a RangeTblEntry and
RelOptInfo for pruned partitions at make_one_rel time, partitionwise
join code relies on the fact that even though partitions may have
been pruned, they'd still own a RelOptInfo to handle the outer join
case where the pruned partition appears on the nullable side of join.
Partitionwise join code deals with that by allocating dummy
RelOptInfos for pruned partitions that are based mostly on their
parent's properties.

There are some regression test diffs:

 1. Caused by the fact that we no longer allocate a duplicate RT
    entry for a partitioned table in its role as child, as seen in
    the partition_aggregate.out test output.

 2. Those in postgres_fdw.out are caused by the fact that junk columns
    required for row marking are added to reltarget->exprs later than
    user columns, because the row marking junk columns arent added
    until after the inheritance is expanded which as of this commit
    is later than it used to be.
---
 contrib/postgres_fdw/expected/postgres_fdw.out    |  32 +-
 src/backend/optimizer/path/allpaths.c             | 219 +-----
 src/backend/optimizer/path/joinrels.c             |  62 ++
 src/backend/optimizer/plan/initsplan.c            |  58 --
 src/backend/optimizer/plan/planner.c              |  60 +-
 src/backend/optimizer/plan/setrefs.c              |   6 +
 src/backend/optimizer/prep/preptlist.c            |  15 +-
 src/backend/optimizer/prep/prepunion.c            | 851 +++++++++++++++-------
 src/backend/optimizer/util/Makefile               |   2 +-
 src/backend/optimizer/util/plancat.c              |  40 +-
 src/backend/optimizer/util/relnode.c              |  80 +-
 src/backend/partitioning/partprune.c              |  43 +-
 src/include/nodes/relation.h                      |   8 +
 src/include/optimizer/pathnode.h                  |   1 +
 src/include/optimizer/plancat.h                   |   2 +-
 src/include/optimizer/prep.h                      |   9 +-
 src/include/partitioning/partprune.h              |   2 +-
 src/test/regress/expected/partition_aggregate.out |   4 +-
 18 files changed, 882 insertions(+), 612 deletions(-)

diff --git a/contrib/postgres_fdw/expected/postgres_fdw.out b/contrib/postgres_fdw/expected/postgres_fdw.out
index e653c302be..bbda5adc55 100644
--- a/contrib/postgres_fdw/expected/postgres_fdw.out
+++ b/contrib/postgres_fdw/expected/postgres_fdw.out
@@ -7062,15 +7062,15 @@ select * from bar where f1 in (select f1 from foo) for update;
                      Output: bar2.f1, bar2.f2, bar2.ctid, bar2.*, bar2.tableoid
                      Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct2 FOR UPDATE
          ->  Hash
-               Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+               Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                ->  HashAggregate
-                     Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                     Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                      Group Key: foo.f1
                      ->  Append
                            ->  Seq Scan on public.foo
-                                 Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                                 Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                            ->  Foreign Scan on public.foo2
-                                 Output: foo2.ctid, foo2.*, foo2.tableoid, foo2.f1
+                                 Output: foo2.f1, foo2.ctid, foo2.*, foo2.tableoid
                                  Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct1
 (23 rows)
 
@@ -7100,15 +7100,15 @@ select * from bar where f1 in (select f1 from foo) for share;
                      Output: bar2.f1, bar2.f2, bar2.ctid, bar2.*, bar2.tableoid
                      Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct2 FOR SHARE
          ->  Hash
-               Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+               Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                ->  HashAggregate
-                     Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                     Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                      Group Key: foo.f1
                      ->  Append
                            ->  Seq Scan on public.foo
-                                 Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                                 Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                            ->  Foreign Scan on public.foo2
-                                 Output: foo2.ctid, foo2.*, foo2.tableoid, foo2.f1
+                                 Output: foo2.f1, foo2.ctid, foo2.*, foo2.tableoid
                                  Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct1
 (23 rows)
 
@@ -7137,15 +7137,15 @@ update bar set f2 = f2 + 100 where f1 in (select f1 from foo);
          ->  Seq Scan on public.bar
                Output: bar.f1, bar.f2, bar.ctid
          ->  Hash
-               Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+               Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                ->  HashAggregate
-                     Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                     Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                      Group Key: foo.f1
                      ->  Append
                            ->  Seq Scan on public.foo
-                                 Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                                 Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                            ->  Foreign Scan on public.foo2
-                                 Output: foo2.ctid, foo2.*, foo2.tableoid, foo2.f1
+                                 Output: foo2.f1, foo2.ctid, foo2.*, foo2.tableoid
                                  Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct1
    ->  Hash Join
          Output: bar2.f1, (bar2.f2 + 100), bar2.f3, bar2.ctid, foo.ctid, foo.*, foo.tableoid
@@ -7155,15 +7155,15 @@ update bar set f2 = f2 + 100 where f1 in (select f1 from foo);
                Output: bar2.f1, bar2.f2, bar2.f3, bar2.ctid
                Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct2 FOR UPDATE
          ->  Hash
-               Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+               Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                ->  HashAggregate
-                     Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                     Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                      Group Key: foo.f1
                      ->  Append
                            ->  Seq Scan on public.foo
-                                 Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                                 Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                            ->  Foreign Scan on public.foo2
-                                 Output: foo2.ctid, foo2.*, foo2.tableoid, foo2.f1
+                                 Output: foo2.f1, foo2.ctid, foo2.*, foo2.tableoid
                                  Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct1
 (39 rows)
 
diff --git a/src/backend/optimizer/path/allpaths.c b/src/backend/optimizer/path/allpaths.c
index ba944b2edc..d44d034f24 100644
--- a/src/backend/optimizer/path/allpaths.c
+++ b/src/backend/optimizer/path/allpaths.c
@@ -44,7 +44,6 @@
 #include "optimizer/var.h"
 #include "parser/parse_clause.h"
 #include "parser/parsetree.h"
-#include "partitioning/partprune.h"
 #include "rewrite/rewriteManip.h"
 #include "utils/lsyscache.h"
 
@@ -180,6 +179,16 @@ make_one_rel(PlannerInfo *root, List *joinlist)
 	set_base_rel_consider_startup(root);
 
 	/*
+	 * Expand RT entries that represent inherited or partitioned tables.
+	 * This will perform partition pruning on partitioned tables in the
+	 * original range table and also recursively on any child partitioned
+	 * tables that were added by the expansion of the original parent(s).
+	 * As new entries are added to the range table, various arrays in the
+	 * PlannerInfo will be expanded accordingly.
+	 */
+	expand_inherited_tables(root);
+
+	/*
 	 * Compute size estimates and consider_parallel flags for each base rel.
 	 */
 	set_base_rel_sizes(root);
@@ -404,7 +413,11 @@ set_rel_size(PlannerInfo *root, RelOptInfo *rel,
 		 */
 		set_dummy_rel_pathlist(rel);
 	}
-	else if (rte->inh)
+	/*
+	 * expand_inherited_tables may have proved that the relation is empty, so
+	 * check if it's so.
+	 */
+	else if (rte->inh && !IS_DUMMY_REL(rel))
 	{
 		/* It's an "append relation", process accordingly */
 		set_append_rel_size(root, rel, rti, rte);
@@ -957,8 +970,6 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 	double	   *parent_attrsizes;
 	int			nattrs;
 	ListCell   *l;
-	Relids		live_children = NULL;
-	bool		did_pruning = false;
 
 	/* Guard against stack overflow due to overly deep inheritance tree. */
 	check_stack_depth();
@@ -966,32 +977,6 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 	Assert(IS_SIMPLE_REL(rel));
 
 	/*
-	 * Initialize partitioned_child_rels to contain this RT index.
-	 *
-	 * Note that during the set_append_rel_pathlist() phase, we will bubble up
-	 * the indexes of partitioned relations that appear down in the tree, so
-	 * that when we've created Paths for all the children, the root
-	 * partitioned table's list will contain all such indexes.
-	 */
-	if (rte->relkind == RELKIND_PARTITIONED_TABLE)
-		rel->partitioned_child_rels = list_make1_int(rti);
-
-	/*
-	 * If the partitioned relation has any baserestrictinfo quals then we
-	 * attempt to use these quals to prune away partitions that cannot
-	 * possibly contain any tuples matching these quals.  In this case we'll
-	 * store the relids of all partitions which could possibly contain a
-	 * matching tuple, and skip anything else in the loop below.
-	 */
-	if (enable_partition_pruning &&
-		rte->relkind == RELKIND_PARTITIONED_TABLE &&
-		rel->baserestrictinfo != NIL)
-	{
-		live_children = prune_append_rel_partitions(rel);
-		did_pruning = true;
-	}
-
-	/*
 	 * If this is a partitioned baserel, set the consider_partitionwise_join
 	 * flag; currently, we only consider partitionwise joins with the baserel
 	 * if its targetlist doesn't contain a whole-row Var.
@@ -1028,12 +1013,8 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 		int			childRTindex;
 		RangeTblEntry *childRTE;
 		RelOptInfo *childrel;
-		List	   *childquals;
-		Index		cq_min_security;
-		bool		have_const_false_cq;
 		ListCell   *parentvars;
 		ListCell   *childvars;
-		ListCell   *lc;
 		PlannerInfo *subroot = root;
 
 		/* append_rel_list contains all append rels; ignore others */
@@ -1042,18 +1023,34 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 
 		childRTindex = appinfo->child_relid;
 		childRTE = root->simple_rte_array[childRTindex];
+		Assert(childRTE != NULL);
 
 		/*
-		 * The child rel's RelOptInfo was already created during
-		 * add_base_rels_to_query.
+		 * The child rel's RelOptInfo is created during
+		 * expand_inherited_tables().
 		 */
 		childrel = find_base_rel(root, childRTindex);
 		Assert(childrel->reloptkind == RELOPT_OTHER_MEMBER_REL);
 
 		/*
-		 * Copy/Modify targetlist. Even if this child is deemed empty, we need
-		 * its targetlist in case it falls on nullable side in a child-join
-		 * because of partitionwise join.
+		 * Child relation may have be marked dummy if build_append_child_rel
+		 * found self-contradictory quals.
+		 */
+		if (IS_DUMMY_REL(childrel))
+			continue;
+
+		if (relation_excluded_by_constraints(root, childrel, childRTE))
+		{
+			/*
+			 * This child need not be scanned, so we can omit it from the
+			 * appendrel.
+			 */
+			set_dummy_rel_pathlist(childrel);
+			continue;
+		}
+
+		/*
+		 * Copy/Modify targetlist.
 		 *
 		 * NB: the resulting childrel->reltarget->exprs may contain arbitrary
 		 * expressions, which otherwise would not occur in a rel's targetlist.
@@ -1091,144 +1088,6 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 									   root != subroot);
 		childrel->has_eclass_joins = rel->has_eclass_joins;
 
-		/*
-		 * We have to copy the parent's quals to the child, with appropriate
-		 * substitution of variables.  However, only the baserestrictinfo
-		 * quals are needed before we can check for constraint exclusion; so
-		 * do that first and then check to see if we can disregard this child.
-		 *
-		 * The child rel's targetlist might contain non-Var expressions, which
-		 * means that substitution into the quals could produce opportunities
-		 * for const-simplification, and perhaps even pseudoconstant quals.
-		 * Therefore, transform each RestrictInfo separately to see if it
-		 * reduces to a constant or pseudoconstant.  (We must process them
-		 * separately to keep track of the security level of each qual.)
-		 */
-		childquals = NIL;
-		cq_min_security = UINT_MAX;
-		have_const_false_cq = false;
-		foreach(lc, rel->baserestrictinfo)
-		{
-			RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
-			Node	   *childqual;
-			ListCell   *lc2;
-
-			Assert(IsA(rinfo, RestrictInfo));
-			childqual = adjust_appendrel_attrs(root,
-											   (Node *) rinfo->clause,
-											   1, &appinfo);
-			childqual = eval_const_expressions(root, childqual);
-			/* check for flat-out constant */
-			if (childqual && IsA(childqual, Const))
-			{
-				if (((Const *) childqual)->constisnull ||
-					!DatumGetBool(((Const *) childqual)->constvalue))
-				{
-					/* Restriction reduces to constant FALSE or NULL */
-					have_const_false_cq = true;
-					break;
-				}
-				/* Restriction reduces to constant TRUE, so drop it */
-				continue;
-			}
-			/* might have gotten an AND clause, if so flatten it */
-			foreach(lc2, make_ands_implicit((Expr *) childqual))
-			{
-				Node	   *onecq = (Node *) lfirst(lc2);
-				bool		pseudoconstant;
-
-				/* check for pseudoconstant (no Vars or volatile functions) */
-				pseudoconstant =
-					!contain_vars_of_level(onecq, 0) &&
-					!contain_volatile_functions(onecq);
-				if (pseudoconstant)
-				{
-					/* tell createplan.c to check for gating quals */
-					root->hasPseudoConstantQuals = true;
-				}
-				/* reconstitute RestrictInfo with appropriate properties */
-				childquals = lappend(childquals,
-									 make_restrictinfo((Expr *) onecq,
-													   rinfo->is_pushed_down,
-													   rinfo->outerjoin_delayed,
-													   pseudoconstant,
-													   rinfo->security_level,
-													   NULL, NULL, NULL));
-				/* track minimum security level among child quals */
-				cq_min_security = Min(cq_min_security, rinfo->security_level);
-			}
-		}
-
-		/*
-		 * In addition to the quals inherited from the parent, we might have
-		 * securityQuals associated with this particular child node.
-		 * (Currently this can only happen in appendrels originating from
-		 * UNION ALL; inheritance child tables don't have their own
-		 * securityQuals, see expand_inherited_rtentry().)	Pull any such
-		 * securityQuals up into the baserestrictinfo for the child.  This is
-		 * similar to process_security_barrier_quals() for the parent rel,
-		 * except that we can't make any general deductions from such quals,
-		 * since they don't hold for the whole appendrel.
-		 */
-		if (childRTE->securityQuals)
-		{
-			Index		security_level = 0;
-
-			foreach(lc, childRTE->securityQuals)
-			{
-				List	   *qualset = (List *) lfirst(lc);
-				ListCell   *lc2;
-
-				foreach(lc2, qualset)
-				{
-					Expr	   *qual = (Expr *) lfirst(lc2);
-
-					/* not likely that we'd see constants here, so no check */
-					childquals = lappend(childquals,
-										 make_restrictinfo(qual,
-														   true, false, false,
-														   security_level,
-														   NULL, NULL, NULL));
-					cq_min_security = Min(cq_min_security, security_level);
-				}
-				security_level++;
-			}
-			Assert(security_level <= root->qual_security_level);
-		}
-
-		/*
-		 * OK, we've got all the baserestrictinfo quals for this child.
-		 */
-		childrel->baserestrictinfo = childquals;
-		childrel->baserestrict_min_security = cq_min_security;
-
-		if (have_const_false_cq)
-		{
-			/*
-			 * Some restriction clause reduced to constant FALSE or NULL after
-			 * substitution, so this child need not be scanned.
-			 */
-			set_dummy_rel_pathlist(childrel);
-			continue;
-		}
-
-		if (did_pruning && !bms_is_member(appinfo->child_relid, live_children))
-		{
-			/* This partition was pruned; skip it. */
-			set_dummy_rel_pathlist(childrel);
-			continue;
-		}
-
-		if (relation_excluded_by_constraints(root, childrel, childRTE))
-		{
-			/*
-			 * This child need not be scanned, so we can omit it from the
-			 * appendrel.
-			 */
-			set_dummy_rel_pathlist(childrel);
-			continue;
-		}
-
 		/* CE failed, so finish copying/modifying join quals. */
 		childrel->joininfo = (List *)
 			adjust_appendrel_attrs(subroot,
@@ -1442,9 +1301,10 @@ adjust_inherit_target_child(PlannerInfo *root, RelOptInfo *childrel,
 	/*
 	 * Apply planner's expansion of targetlist, such as adding various junk
 	 * column, filling placeholder entries for dropped columns, etc., all of
-	 * which occurs with the child's TupleDesc.
+	 * which occurs with the child's TupleDesc.  Since inheritance has already
+	 * been expanded (we wouldn't be here otherwise), pass true.
 	 */
-	tlist = preprocess_targetlist(subroot);
+	tlist = preprocess_targetlist(subroot, true);
 	subroot->processed_tlist = tlist;
 	build_base_rel_tlists(subroot, tlist);
 
@@ -2842,6 +2702,7 @@ inheritance_make_rel_from_joinlist(PlannerInfo *root, List *joinlist)
 
 		Assert(subroot->parse->resultRelation > 0);
 		childrel = find_base_rel(root, subroot->parse->resultRelation);
+		Assert(childrel != NULL);
 		appinfo = root->append_rel_array[subroot->parse->resultRelation];
 
 		if (appinfo->parent_relid != root->parse->resultRelation)
diff --git a/src/backend/optimizer/path/joinrels.c b/src/backend/optimizer/path/joinrels.c
index d3d21fed5d..da0831de4e 100644
--- a/src/backend/optimizer/path/joinrels.c
+++ b/src/backend/optimizer/path/joinrels.c
@@ -20,6 +20,7 @@
 #include "optimizer/pathnode.h"
 #include "optimizer/paths.h"
 #include "optimizer/prep.h"
+#include "optimizer/tlist.h"
 #include "partitioning/partbounds.h"
 #include "utils/lsyscache.h"
 #include "utils/memutils.h"
@@ -46,6 +47,9 @@ static void try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1,
 					   List *parent_restrictlist);
 static int match_expr_to_partition_keys(Expr *expr, RelOptInfo *rel,
 							 bool strict_op);
+static RelOptInfo *build_dummy_partition_rel(PlannerInfo *root,
+									RelOptInfo *parent,
+									int partidx);
 
 
 /*
@@ -1376,6 +1380,11 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
 		AppendRelInfo **appinfos;
 		int			nappinfos;
 
+		if (child_rel1 == NULL)
+			child_rel1 = build_dummy_partition_rel(root, rel1, cnt_parts);
+		if (child_rel2 == NULL)
+			child_rel2 = build_dummy_partition_rel(root, rel2, cnt_parts);
+
 		/* We should never try to join two overlapping sets of rels. */
 		Assert(!bms_overlap(child_rel1->relids, child_rel2->relids));
 		child_joinrelids = bms_union(child_rel1->relids, child_rel2->relids);
@@ -1582,3 +1591,56 @@ match_expr_to_partition_keys(Expr *expr, RelOptInfo *rel, bool strict_op)
 
 	return -1;
 }
+
+/*
+ * build_dummy_partition_rel
+ *		Build a RelOptInfo and AppendRelInfo for a pruned partition
+ *
+ * This does not result in opening the relation or a range table entry being
+ * created.  Also, the RelOptInfo thus created is not stored anywhere else
+ * beside the parent's part_rels array.
+ *
+ * The only reason this exists is because partition-wise join, in some cases,
+ * needs a RelOptInfo to represent an empty relation that's on the nullable
+ * side of an outer join, so that a Path representing the outer join can be
+ * created.
+ */
+RelOptInfo *
+build_dummy_partition_rel(PlannerInfo *root, RelOptInfo *parent, int partidx)
+{
+	RangeTblEntry *parentrte = root->simple_rte_array[parent->relid];
+	RelOptInfo *rel;
+
+	Assert(parent->part_rels[partidx] == NULL);
+
+	/* Create minimally valid-looking RelOptInfo with parent's relid. */
+	rel = makeNode(RelOptInfo);
+	rel->reloptkind = RELOPT_OTHER_MEMBER_REL;
+	rel->relid = parent->relid;
+	rel->relids = bms_copy(parent->relids);
+	if (parent->top_parent_relids)
+		rel->top_parent_relids = parent->top_parent_relids;
+	else
+		rel->top_parent_relids = bms_copy(parent->relids);
+	rel->reltarget = copy_pathtarget(parent->reltarget);
+	parent->part_rels[partidx] = rel;
+	mark_dummy_rel(rel);
+
+	/*
+	 * Now we'll need a (no-op) AppendRelInfo for parent, because we're
+	 * setting the dummy partition's relid to be same as the parent's.
+	 */
+	if (root->append_rel_array[parent->relid] == NULL)
+	{
+		/* Pass parent's info as for both the parent rel and child rel. */
+		AppendRelInfo *appinfo = make_append_rel_info(parent, parentrte,
+													  parent->tupdesc,
+													  parentrte->relid,
+													  parent->reltype,
+													  parent->relid);
+
+		root->append_rel_array[parent->relid] = appinfo;
+	}
+
+	return rel;
+}
diff --git a/src/backend/optimizer/plan/initsplan.c b/src/backend/optimizer/plan/initsplan.c
index 01335db511..7636aa82c4 100644
--- a/src/backend/optimizer/plan/initsplan.c
+++ b/src/backend/optimizer/plan/initsplan.c
@@ -616,64 +616,6 @@ create_lateral_join_info(PlannerInfo *root)
 				bms_add_member(brel2->lateral_referencers, rti);
 		}
 	}
-
-	/*
-	 * Lastly, propagate lateral_relids and lateral_referencers from appendrel
-	 * parent rels to their child rels.  We intentionally give each child rel
-	 * the same minimum parameterization, even though it's quite possible that
-	 * some don't reference all the lateral rels.  This is because any append
-	 * path for the parent will have to have the same parameterization for
-	 * every child anyway, and there's no value in forcing extra
-	 * reparameterize_path() calls.  Similarly, a lateral reference to the
-	 * parent prevents use of otherwise-movable join rels for each child.
-	 */
-	for (rti = 1; rti < root->simple_rel_array_size; rti++)
-	{
-		RelOptInfo *brel = root->simple_rel_array[rti];
-		RangeTblEntry *brte = root->simple_rte_array[rti];
-
-		/*
-		 * Skip empty slots. Also skip non-simple relations i.e. dead
-		 * relations.
-		 */
-		if (brel == NULL || !IS_SIMPLE_REL(brel))
-			continue;
-
-		/*
-		 * In the case of table inheritance, the parent RTE is directly linked
-		 * to every child table via an AppendRelInfo.  In the case of table
-		 * partitioning, the inheritance hierarchy is expanded one level at a
-		 * time rather than flattened.  Therefore, an other member rel that is
-		 * a partitioned table may have children of its own, and must
-		 * therefore be marked with the appropriate lateral info so that those
-		 * children eventually get marked also.
-		 */
-		Assert(brte);
-		if (brel->reloptkind == RELOPT_OTHER_MEMBER_REL &&
-			(brte->rtekind != RTE_RELATION ||
-			 brte->relkind != RELKIND_PARTITIONED_TABLE))
-			continue;
-
-		if (brte->inh)
-		{
-			foreach(lc, root->append_rel_list)
-			{
-				AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(lc);
-				RelOptInfo *childrel;
-
-				if (appinfo->parent_relid != rti)
-					continue;
-				childrel = root->simple_rel_array[appinfo->child_relid];
-				Assert(childrel->reloptkind == RELOPT_OTHER_MEMBER_REL);
-				Assert(childrel->direct_lateral_relids == NULL);
-				childrel->direct_lateral_relids = brel->direct_lateral_relids;
-				Assert(childrel->lateral_relids == NULL);
-				childrel->lateral_relids = brel->lateral_relids;
-				Assert(childrel->lateral_referencers == NULL);
-				childrel->lateral_referencers = brel->lateral_referencers;
-			}
-		}
-	}
 }
 
 
diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index 3fd1476f71..7f5a1865ba 100644
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -23,6 +23,7 @@
 #include "access/sysattr.h"
 #include "access/xact.h"
 #include "catalog/pg_constraint.h"
+#include "catalog/pg_inherits.h"
 #include "catalog/pg_proc.h"
 #include "catalog/pg_type.h"
 #include "executor/executor.h"
@@ -699,27 +700,24 @@ subquery_planner(PlannerGlobal *glob, Query *parse,
 		}
 		if (rte->lateral)
 			root->hasLateralRTEs = true;
+
+		/*
+		 * While at it, also update the inh status.  If the relation doesn't
+		 * or can't have any children, there is no point in letting inh be set
+		 * to true.  Note that we do this before processing rowmarks, so that
+		 * the correct information for setting isParent field of PlanRowMarks.
+		 */
+		if (rte->rtekind == RTE_RELATION)
+			rte->inh = rte->inh && has_subclass(rte->relid);
 	}
 
 	/*
 	 * Preprocess RowMark information.  We need to do this after subquery
-	 * pullup (so that all non-inherited RTEs are present) and before
-	 * inheritance expansion (so that the info is available for
-	 * expand_inherited_tables to examine and modify).
+	 * pullup (so that all non-inherited RTEs are present).
 	 */
 	preprocess_rowmarks(root);
 
 	/*
-	 * Expand any rangetable entries that are inheritance sets into "append
-	 * relations".  This can add entries to the rangetable, but they must be
-	 * plain base relations not joins, so it's OK (and marginally more
-	 * efficient) to do it after checking for join RTEs.  We must do it after
-	 * pulling up subqueries, else we'd fail to handle inherited tables in
-	 * subqueries.
-	 */
-	expand_inherited_tables(root);
-
-	/*
 	 * Set hasHavingQual to remember if HAVING clause is present.  Needed
 	 * because preprocess_expression will reduce a constant-true condition to
 	 * an empty qual list ... but "HAVING TRUE" is not a semantic no-op.
@@ -1212,8 +1210,11 @@ inheritance_planner(PlannerInfo *root)
 	 */
 	root->unexpanded_tlist = list_copy(root->parse->targetList);
 
-	/* Do the scan/join planning. */
-	tlist = preprocess_targetlist(root);
+	/*
+	 * Do the scan/join planning.  We haven't expanded inheritance yet, so
+	 * pass false.
+	 */
+	tlist = preprocess_targetlist(root, false);
 	root->processed_tlist = tlist;
 	qp_extra.tlist = tlist;
 	qp_extra.activeWindows = qp_extra.groupClause = NIL;
@@ -1222,9 +1223,10 @@ inheritance_planner(PlannerInfo *root)
 	/*
 	 * If it turned out during query planning that all the children are dummy
 	 * (pruned or excluded by constraints), no need to do the steps below.
-	 * Let grouping_planner finish up the final path.
+	 * For regular inheritance case, it's possible that we only need to modify
+	 * the parent table.  Let grouping_planner finish up the final path.
 	 */
-	if (IS_DUMMY_REL(planned_rel))
+	if (!parent_rte->inh || IS_DUMMY_REL(planned_rel))
 	{
 		grouping_planner(root, false, planned_rel, 0.0);
 		return;
@@ -1569,7 +1571,8 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 		 */
 		if (planned_rel == NULL)
 		{
-			tlist = preprocess_targetlist(root);
+			/* We haven't expanded inheritance yet, so pass false. */
+			tlist = preprocess_targetlist(root, false);
 
 			/*
 			 * We are now done hacking up the query's targetlist.  Most of the
@@ -1666,6 +1669,15 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 										standard_qp_callback, &qp_extra);
 
 		/*
+		 * Query planning may have added some columns to the top-level tlist,
+		 * which happens when there are row marks applied to inheritance
+		 * parent relations (additional junk columns needed for applying row
+		 * marks are added after expanding inheritance.)
+		 */
+		if (list_length(tlist) < list_length(root->processed_tlist))
+			tlist = root->processed_tlist;
+
+		/*
 		 * Convert the query's result tlist into PathTarget format.
 		 *
 		 * Note: it's desirable to not do this till after query_planner(),
@@ -2352,7 +2364,7 @@ preprocess_rowmarks(PlannerInfo *root)
 		newrc->allMarkTypes = (1 << newrc->markType);
 		newrc->strength = rc->strength;
 		newrc->waitPolicy = rc->waitPolicy;
-		newrc->isParent = false;
+		newrc->isParent = rte->inh;
 
 		prowmarks = lappend(prowmarks, newrc);
 	}
@@ -2377,7 +2389,7 @@ preprocess_rowmarks(PlannerInfo *root)
 		newrc->allMarkTypes = (1 << newrc->markType);
 		newrc->strength = LCS_NONE;
 		newrc->waitPolicy = LockWaitBlock;	/* doesn't matter */
-		newrc->isParent = false;
+		newrc->isParent = rte->rtekind == RTE_RELATION ? rte->inh : false;
 
 		prowmarks = lappend(prowmarks, newrc);
 	}
@@ -6757,6 +6769,10 @@ apply_scanjoin_target_to_paths(PlannerInfo *root,
 			int			nappinfos;
 			List	   *child_scanjoin_targets = NIL;
 
+			/* Skip processing pruned partitions. */
+			if (child_rel == NULL)
+				continue;
+
 			/* Translate scan/join targets for this child. */
 			appinfos = find_appinfos_by_relids(root, child_rel->relids,
 											   &nappinfos);
@@ -6858,6 +6874,10 @@ create_partitionwise_grouping_paths(PlannerInfo *root,
 		RelOptInfo *child_grouped_rel;
 		RelOptInfo *child_partially_grouped_rel;
 
+		/* Skip processing pruned partitions. */
+		if (child_input_rel == NULL)
+			continue;
+
 		/* Input child rel must have a path */
 		Assert(child_input_rel->pathlist != NIL);
 
diff --git a/src/backend/optimizer/plan/setrefs.c b/src/backend/optimizer/plan/setrefs.c
index 6d6ef1c376..454870609a 100644
--- a/src/backend/optimizer/plan/setrefs.c
+++ b/src/backend/optimizer/plan/setrefs.c
@@ -326,6 +326,12 @@ add_rtes_to_flat_rtable(PlannerInfo *root, bool recursing)
 													  UPPERREL_FINAL, NULL)))
 					add_rtes_to_flat_rtable(rel->subroot, true);
 			}
+			/*
+			 * A NULL rel also means an unplanned subquery rte, so apply
+			 * flatten_unplanned_rtes.
+			 */
+			else
+				flatten_unplanned_rtes(glob, rte);
 		}
 		rti++;
 	}
diff --git a/src/backend/optimizer/prep/preptlist.c b/src/backend/optimizer/prep/preptlist.c
index 8603feef2b..0747403acd 100644
--- a/src/backend/optimizer/prep/preptlist.c
+++ b/src/backend/optimizer/prep/preptlist.c
@@ -65,9 +65,13 @@ static List *expand_targetlist(List *tlist, int command_type,
  *
  * As a side effect, if there's an ON CONFLICT UPDATE clause, its targetlist
  * is also preprocessed (and updated in-place).
+ *
+ * inheritance_expanded specifies whether inheritance tables are expanded
+ * as of calling this function.  Caller must specify it because that affects
+ * which row marking related junk columns get added to the targetlist.
  */
 List *
-preprocess_targetlist(PlannerInfo *root)
+preprocess_targetlist(PlannerInfo *root, bool inheritance_expanded)
 {
 	Query	   *parse = root->parse;
 	int			result_relation = parse->resultRelation;
@@ -134,6 +138,15 @@ preprocess_targetlist(PlannerInfo *root)
 		if (rc->rti != rc->prti)
 			continue;
 
+		/*
+		 * For inheritance parent row marks, we defer adding junk columns
+		 * until we've added child row marks, because some children might
+		 * require different row mark types which will change the parent row
+		 * mark's allMarkTypes fields.
+		 */
+		if (rc->isParent && !inheritance_expanded)
+			continue;
+
 		if (rc->allMarkTypes & ~(1 << ROW_MARK_COPY))
 		{
 			/* Need to fetch TID */
diff --git a/src/backend/optimizer/prep/prepunion.c b/src/backend/optimizer/prep/prepunion.c
index 134e7bafd9..e4d4e7d6dd 100644
--- a/src/backend/optimizer/prep/prepunion.c
+++ b/src/backend/optimizer/prep/prepunion.c
@@ -39,15 +39,19 @@
 #include "miscadmin.h"
 #include "nodes/makefuncs.h"
 #include "nodes/nodeFuncs.h"
+#include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
 #include "optimizer/paths.h"
 #include "optimizer/planmain.h"
 #include "optimizer/planner.h"
 #include "optimizer/prep.h"
+#include "optimizer/restrictinfo.h"
 #include "optimizer/tlist.h"
+#include "optimizer/var.h"
 #include "parser/parse_coerce.h"
 #include "parser/parsetree.h"
+#include "partitioning/partprune.h"
 #include "utils/lsyscache.h"
 #include "utils/rel.h"
 #include "utils/selfuncs.h"
@@ -99,23 +103,26 @@ static List *generate_append_tlist(List *colTypes, List *colCollations,
 					  List *input_tlists,
 					  List *refnames_tlist);
 static List *generate_setop_grouplist(SetOperationStmt *op, List *targetlist);
+static void expand_append_rtentry(PlannerInfo *root, RelOptInfo *rel,
+					  RangeTblEntry *rte, Index rti);
 static void expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte,
-						 Index rti);
+						 Index rti, RelOptInfo *rel);
 static void expand_partitioned_rtentry(PlannerInfo *root,
 						   RangeTblEntry *parentrte,
-						   Index parentRTindex, Relation parentrel,
-						   PlanRowMark *top_parentrc, LOCKMODE lockmode,
-						   List **appinfos);
-static void expand_single_inheritance_child(PlannerInfo *root,
-								RangeTblEntry *parentrte,
-								Index parentRTindex, Relation parentrel,
-								PlanRowMark *top_parentrc, Relation childrel,
-								List **appinfos, RangeTblEntry **childrte_p,
-								Index *childRTindex_p);
-static void make_inh_translation_list(Relation oldrelation,
-						  Relation newrelation,
-						  Index newvarno,
-						  List **translated_vars);
+						   Index parentRTindex, RelOptInfo *parentrel);
+static RelOptInfo *add_inheritance_child_rel(PlannerInfo *root,
+						  RangeTblEntry *parentrte,
+						  Index parentRTindex, RelOptInfo *parentrel,
+						  PlanRowMark *top_parentrc, Relation childrel,
+						  RangeTblEntry **childrte_p, Index *childRTindex_p);
+static void make_inh_translation_list(TupleDesc old_tupdesc,
+						  TupleDesc new_tupdesc,
+						  Oid from_rel, Oid to_rel,
+						  Index newvarno, List **translated_vars);
+static RelOptInfo *build_append_child_rel(PlannerInfo *root,
+					   RelOptInfo *parent,
+					   Index childRTindex);
+static List *add_rowmark_junk_columns(PlannerInfo *root, PlanRowMark *rc);
 static Bitmapset *translate_col_privs(const Bitmapset *parent_privs,
 					List *translated_vars);
 static Node *adjust_appendrel_attrs_mutator(Node *node,
@@ -1472,33 +1479,134 @@ generate_setop_grouplist(SetOperationStmt *op, List *targetlist)
 void
 expand_inherited_tables(PlannerInfo *root)
 {
-	Index		nrtes;
+	int			orig_rtable_size;
 	Index		rti;
-	ListCell   *rl;
+
+	Assert(root->simple_rel_array_size > 0);
+	orig_rtable_size = root->simple_rel_array_size;
 
 	/*
-	 * expand_inherited_rtentry may add RTEs to parse->rtable. The function is
+	 * expand_append_rtentry may add RTEs to parse->rtable. The function is
 	 * expected to recursively handle any RTEs that it creates with inh=true.
 	 * So just scan as far as the original end of the rtable list.
 	 */
-	nrtes = list_length(root->parse->rtable);
-	rl = list_head(root->parse->rtable);
-	for (rti = 1; rti <= nrtes; rti++)
+	for (rti = 1; rti < orig_rtable_size; rti++)
 	{
-		RangeTblEntry *rte = (RangeTblEntry *) lfirst(rl);
+		RelOptInfo *brel = root->simple_rel_array[rti];
+		RangeTblEntry *rte = root->simple_rte_array[rti];
 
-		expand_inherited_rtentry(root, rte, rti);
-		rl = lnext(rl);
+		/* there may be empty slots corresponding to non-baserel RTEs */
+		if (brel == NULL)
+			continue;
+
+		if (rte->inh)
+			expand_append_rtentry(root, brel, rte, rti);
+	}
+}
+
+/*
+ * expand_append_rtentry
+ *		This initializes RelOptInfos for an appendrel's child relations, if
+ *		any
+ *
+ * 'rel' is the appendrel parent, whose range table entry ('rte') has been
+ * marked to require adding children.  An appendrel parent could either
+ * be a subquery (if we flattened UNION ALL query) or a table that's known
+ * to have inheritance children.  The latter consists of both regular
+ * inheritance parents and partitioned tables.
+ *
+ * For a subquery parent, there is not much to be done here because the
+ * children's RTEs are already present in the query, so we just initialize
+ * RelOptInfos for them.  Also, the AppendRelInfos for child subqueries
+ * have already been added.
+ *
+ * For tables, we need to add the children to the range table and initialize
+ * AppendRelInfos, RelOptInfos, and PlanRowMarks (if any) for them.  For
+ * a partitioned parent, we only add the children remaining after pruning.
+ * For regular inheritance parents, we find the children using
+ * find_all_inheritors and add all of them.
+ *
+ * If it turns out that there are no children, then we set rte->inh to false
+ * to let the caller know that only the parent table needs to be scanned.  The
+ * caller can accordingly switch to a non-Append path.  For a partitioned
+ * parent, that means an empty relation because parents themselves contain no
+ * data.
+ *
+ * For the regular inheritance case, the parent also gets another RTE with
+ * inh = false to represent it as an appendrel child.  The original RTE is
+ * considered to represent the whole inheritance set.
+ */
+static void
+expand_append_rtentry(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte,
+					  Index rti)
+{
+	Assert(rte->inh);
+	/* Inheritance parent (partitioned or not) or UNION ALL parent subquery. */
+	Assert(rte->rtekind == RTE_RELATION || rte->rtekind == RTE_SUBQUERY);
+
+	/*
+	 * UNION ALL children already got RTEs and AppendRelInfos, so just build
+	 * RelOptInfos and return.
+	 *
+	 * It might be a bit odd that this code is in this, because there is
+	 * nothing to expand really.
+	 */
+	if (rte->rtekind == RTE_SUBQUERY)
+	{
+		ListCell   *l;
+
+		/*
+		 * We don't need to use expand_planner_arrays in this case, because
+		 * no new child RTEs are created.  setup_simple_rel_arrays() and
+		 * setup_append_rel_array would've considered these child RTEs when
+		 * allocating space for various arrays.
+		 */
+		foreach(l, root->append_rel_list)
+		{
+			AppendRelInfo *appinfo = lfirst(l);
+			Index		childRTindex = appinfo->child_relid;
+
+			if (appinfo->parent_relid != rti)
+				continue;
+
+			Assert(childRTindex < root->simple_rel_array_size);
+			Assert(root->simple_rte_array[childRTindex] != NULL);
+
+			/*
+			 * We set the correct value of baserestricinfo and
+			 * baserestrict_min_security below.
+			 */
+			root->simple_rel_array[childRTindex] =
+				build_append_child_rel(root, rel, appinfo->child_relid);
+		}
+	}
+	else
+	{
+		Assert(rte->rtekind == RTE_RELATION);
+		Assert(has_subclass(rte->relid));
+
+		/*
+		 * The rewriter should already have obtained an appropriate lock on
+		 * each relation named in the query.  However, for each child relation
+		 * we add to the query, we must obtain an appropriate lock, because
+		 * this will be the first use of those relations in the
+		 * parse/rewrite/plan pipeline.  Child rels should use the same
+		 * lockmode as their parent.
+		 */
+		Assert(rte->rellockmode != NoLock);
+
+		if (rte->relkind == RELKIND_PARTITIONED_TABLE)
+			expand_partitioned_rtentry(root, rte, rti, rel);
+		else
+			expand_inherited_rtentry(root, rte, rti, rel);
 	}
 }
 
 /*
  * expand_inherited_rtentry
- *		Check whether a rangetable entry represents an inheritance set.
- *		If so, add entries for all the child tables to the query's
- *		rangetable, and build AppendRelInfo nodes for all the child tables
- *		and add them to root->append_rel_list.  If not, clear the entry's
- *		"inh" flag to prevent later code from looking for AppendRelInfos.
+ *		Add entries for all the child tables to the query's rangetable, and
+ *		build AppendRelInfo nodes for all the child tables and add them to
+ *		root->append_rel_list.
  *
  * Note that the original RTE is considered to represent the whole
  * inheritance set.  The first of the generated RTEs is an RTE for the same
@@ -1509,45 +1617,22 @@ expand_inherited_tables(PlannerInfo *root)
  * regular inheritance, a parent RTE must always have at least two associated
  * AppendRelInfos: one corresponding to the parent table as a simple member of
  * inheritance set and one or more corresponding to the actual children.
- * Since a partitioned table is not scanned, it might have only one associated
- * AppendRelInfo.
  */
 static void
-expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti)
+expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti,
+						 RelOptInfo *rel)
 {
 	Oid			parentOID;
 	PlanRowMark *oldrc;
-	Relation	oldrelation;
-	LOCKMODE	lockmode;
+	LOCKMODE	lockmode = rte->rellockmode;
 	List	   *inhOIDs;
 	ListCell   *l;
+	int			num_children;
+	int			num_children_added = 0;
 
-	/* Does RT entry allow inheritance? */
-	if (!rte->inh)
-		return;
-	/* Ignore any already-expanded UNION ALL nodes */
-	if (rte->rtekind != RTE_RELATION)
-	{
-		Assert(rte->rtekind == RTE_SUBQUERY);
-		return;
-	}
-	/* Fast path for common case of childless table */
+	Assert(rte->rtekind == RTE_RELATION);
+	Assert(lockmode != NoLock);
 	parentOID = rte->relid;
-	if (!has_subclass(parentOID))
-	{
-		/* Clear flag before returning */
-		rte->inh = false;
-		return;
-	}
-
-	/*
-	 * The rewriter should already have obtained an appropriate lock on each
-	 * relation named in the query.  However, for each child relation we add
-	 * to the query, we must obtain an appropriate lock, because this will be
-	 * the first use of those relations in the parse/rewrite/plan pipeline.
-	 * Child rels should use the same lockmode as their parent.
-	 */
-	lockmode = rte->rellockmode;
 
 	/* Scan for all members of inheritance set, acquire needed locks */
 	inhOIDs = find_all_inheritors(parentOID, lockmode, NULL);
@@ -1557,7 +1642,8 @@ expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti)
 	 * case.  This could happen despite above has_subclass() check, if table
 	 * once had a child but no longer does.
 	 */
-	if (list_length(inhOIDs) < 2)
+	num_children = list_length(inhOIDs);
+	if (num_children < 2)
 	{
 		/* Clear flag before returning */
 		rte->inh = false;
@@ -1565,216 +1651,220 @@ expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti)
 	}
 
 	/*
-	 * If parent relation is selected FOR UPDATE/SHARE, we need to mark its
-	 * PlanRowMark as isParent = true, and generate a new PlanRowMark for each
-	 * child.
+	 * If parent relation is selected FOR UPDATE/SHARE, preprocess_rowmarks
+	 * should've set isParent = true.  We'll generate a new PlanRowMark for
+	 * each child.
 	 */
 	oldrc = get_plan_rowmark(root->rowMarks, rti);
-	if (oldrc)
-		oldrc->isParent = true;
+	Assert(oldrc == NULL || oldrc->isParent);
 
 	/*
-	 * Must open the parent relation to examine its tupdesc.  We need not lock
-	 * it; we assume the rewriter already did.
+	 * Must expand PlannerInfo arrays by num_children before we can add
+	 * children.
 	 */
-	oldrelation = heap_open(parentOID, NoLock);
+	expand_planner_arrays(root, num_children);
 
-	/* Scan the inheritance set and expand it */
-	if (RelationGetPartitionDesc(oldrelation) != NULL)
+	foreach(l, inhOIDs)
 	{
-		Assert(rte->relkind == RELKIND_PARTITIONED_TABLE);
-
-		/*
-		 * If this table has partitions, recursively expand them in the order
-		 * in which they appear in the PartitionDesc.  While at it, also
-		 * extract the partition key columns of all the partitioned tables.
-		 */
-		expand_partitioned_rtentry(root, rte, rti, oldrelation, oldrc,
-								   lockmode, &root->append_rel_list);
-	}
-	else
-	{
-		List	   *appinfos = NIL;
+		Oid			childOID = lfirst_oid(l);
+		Relation	newrelation;
 		RangeTblEntry *childrte;
 		Index		childRTindex;
 
+		/* Already locked above. */
+		newrelation = heap_open(childOID, NoLock);
+
 		/*
-		 * This table has no partitions.  Expand any plain inheritance
-		 * children in the order the OIDs were returned by
-		 * find_all_inheritors.
+		 * It is possible that the parent table has children that are temp
+		 * tables of other backends.  We cannot safely access such tables
+		 * (because of buffering issues), and the best thing to do seems
+		 * to be to silently ignore them.
 		 */
-		foreach(l, inhOIDs)
+		if (RELATION_IS_OTHER_TEMP(newrelation))
 		{
-			Oid			childOID = lfirst_oid(l);
-			Relation	newrelation;
-
-			/* Open rel if needed; we already have required locks */
-			if (childOID != parentOID)
-				newrelation = heap_open(childOID, NoLock);
-			else
-				newrelation = oldrelation;
-
-			/*
-			 * It is possible that the parent table has children that are temp
-			 * tables of other backends.  We cannot safely access such tables
-			 * (because of buffering issues), and the best thing to do seems
-			 * to be to silently ignore them.
-			 */
-			if (childOID != parentOID && RELATION_IS_OTHER_TEMP(newrelation))
-			{
-				heap_close(newrelation, lockmode);
-				continue;
-			}
-
-			expand_single_inheritance_child(root, rte, rti, oldrelation, oldrc,
-											newrelation,
-											&appinfos, &childrte,
-											&childRTindex);
-
-			/* Close child relations, but keep locks */
-			if (childOID != parentOID)
-				heap_close(newrelation, NoLock);
+			heap_close(newrelation, lockmode);
+			continue;
 		}
 
-		/*
-		 * If all the children were temp tables, pretend it's a
-		 * non-inheritance situation; we don't need Append node in that case.
-		 * The duplicate RTE we added for the parent table is harmless, so we
-		 * don't bother to get rid of it; ditto for the useless PlanRowMark
-		 * node.
-		 */
-		if (list_length(appinfos) < 2)
-			rte->inh = false;
-		else
-			root->append_rel_list = list_concat(root->append_rel_list,
-												appinfos);
+		(void) add_inheritance_child_rel(root, rte, rti, rel, oldrc,
+										 newrelation, &childrte,
+										 &childRTindex);
+		Assert(childrte != NULL);
+		/* All regular inheritance children are leaf children. */
+		Assert(!childrte->inh);
+		Assert(childRTindex > 0);
 
+		/* Close child relations, but keep locks */
+		heap_close(newrelation, NoLock);
+		num_children_added++;
 	}
 
-	heap_close(oldrelation, NoLock);
+	/*
+	 * If all children, including the parent (as child rel), were
+	 * excluded, mark the parent rel as empty.  If all the children were temp
+	 * tables, pretend it's a non-inheritance situation; we don't need Append
+	 * node in that case.  The duplicate RTE we added for the parent table is
+	 * harmless, so we don't bother to get rid of it; ditto for the useless
+	 * PlanRowMark node.
+	 */
+	if (num_children_added == 0)
+		mark_dummy_rel(rel);
+	else if (num_children_added == 1)
+		rte->inh = false;
+
+	/*
+	 * Add junk columns needed by the row mark if any and also add the
+	 * relevant expressions to the root parent's reltarget.
+	 */
+	if (oldrc)
+	{
+		List   *tlist = add_rowmark_junk_columns(root, oldrc);
+
+		build_base_rel_tlists(root, tlist);
+	}
 }
 
 /*
  * expand_partitioned_rtentry
- *		Recursively expand an RTE for a partitioned table.
+ *		Prunes unnecessary partitions of a partitioned table and adds
+ *		remaining ones to the Query and the PlannerInfo
+ *
+ * Partitions are added to the query in order in which they are found in
+ * the parent's PartitionDesc.
+ *
+ * Note: even though only the unpruned partitions will be added to the
+ * resulting plan, this still locks *all* partitions via find_all_inheritors
+ * in order to avoid partitions being locked in a different order than other
+ * places in the backend that may lock partitions.
  */
 static void
 expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
-						   Index parentRTindex, Relation parentrel,
-						   PlanRowMark *top_parentrc, LOCKMODE lockmode,
-						   List **appinfos)
+						   Index parentRTindex, RelOptInfo *parentrel)
 {
+	LOCKMODE	lockmode = parentrte->rellockmode;
+	PlanRowMark *rootrc = NULL;
 	int			i;
-	RangeTblEntry *childrte;
-	Index		childRTindex;
-	PartitionDesc partdesc = RelationGetPartitionDesc(parentrel);
+	Bitmapset  *partindexes;
+	Index		rootParentRTindex = parentrel->inh_root_parent > 0 ?
+									parentrel->inh_root_parent :
+									parentRTindex;
 
-	check_stack_depth();
-
-	/* A partitioned table should always have a partition descriptor. */
-	Assert(partdesc);
-
-	Assert(parentrte->inh);
+	/* If root partitioned table, lock *all* partitions in the tree. */
+	if (parentRTindex == rootParentRTindex)
+		(void) find_all_inheritors(parentrte->relid, lockmode, NULL);
 
 	/*
-	 * Note down whether any partition key cols are being updated. Though it's
-	 * the root partitioned table's updatedCols we are interested in, we
-	 * instead use parentrte to get the updatedCols. This is convenient
-	 * because parentrte already has the root partrel's updatedCols translated
-	 * to match the attribute ordering of parentrel.
+	 * Initialize partitioned_child_rels to contain this RT index.
+	 *
+	 * Note that during the set_append_rel_pathlist() phase, values of the
+	 * indexes of partitioned relations that appear down in the tree will be
+	 * bubbled up into root parent's list so that when we've created Paths for
+	 * all the children, the root table's list will contain all such indexes.
 	 */
-	if (!root->partColsUpdated)
-		root->partColsUpdated =
-			has_partition_attrs(parentrel, parentrte->updatedCols, NULL);
+	parentrel->partitioned_child_rels = list_make1_int(parentRTindex);
 
-	/* First expand the partitioned table itself. */
-	expand_single_inheritance_child(root, parentrte, parentRTindex, parentrel,
-									top_parentrc, parentrel,
-									appinfos, &childrte, &childRTindex);
+	/* Perform pruning. */
+	partindexes = prune_append_rel_partitions(parentrel);
+
+	/* Must expand PlannerInfo arrays before we can add children. */
+	expand_planner_arrays(root, bms_num_members(partindexes));
 
 	/*
-	 * If the partitioned table has no partitions, treat this as the
-	 * non-inheritance case.
+	 * For partitioned tables, we also store the partition RelOptInfo
+	 * pointers in the parent's RelOptInfo.
 	 */
-	if (partdesc->nparts == 0)
-	{
-		parentrte->inh = false;
-		return;
-	}
+	parentrel->part_rels = (RelOptInfo **) palloc0(sizeof(RelOptInfo *) *
+												   parentrel->nparts);
 
-	for (i = 0; i < partdesc->nparts; i++)
+	rootrc = get_plan_rowmark(root->rowMarks, rootParentRTindex);
+	Assert(rootrc == NULL || rootrc->isParent);
+	i = -1;
+	while ((i = bms_next_member(partindexes, i)) >= 0)
 	{
-		Oid			childOID = partdesc->oids[i];
-		Relation	childrel;
+		Oid		childOID = parentrel->part_oids[i];
+		Relation	newrelation;
+		RelOptInfo *childrel;
+		RangeTblEntry *childrte;
+		Index		childRTindex;
 
-		/* Open rel; we already have required locks */
-		childrel = heap_open(childOID, NoLock);
+		/* Already locked above. */
+		newrelation = heap_open(childOID, NoLock);
+		Assert(!RELATION_IS_OTHER_TEMP(newrelation));
 
 		/*
-		 * Temporary partitions belonging to other sessions should have been
-		 * disallowed at definition, but for paranoia's sake, let's double
-		 * check.
+		 * A partitioned child table with 0 children is a dummy rel, so don't
+		 * bother creating planner objects for it.
 		 */
-		if (RELATION_IS_OTHER_TEMP(childrel))
-			elog(ERROR, "temporary relation from another session found as partition");
+		if (newrelation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE &&
+			RelationGetPartitionDesc(newrelation)->nparts == 0)
+		{
+			heap_close(newrelation, NoLock);
+			continue;
+		}
 
-		expand_single_inheritance_child(root, parentrte, parentRTindex,
-										parentrel, top_parentrc, childrel,
-										appinfos, &childrte, &childRTindex);
+		childrel = add_inheritance_child_rel(root, parentrte, parentRTindex,
+											 parentrel, rootrc, newrelation,
+											 &childrte, &childRTindex);
+		Assert(childrel != NULL);
+		parentrel->part_rels[i] = childrel;
 
-		/* If this child is itself partitioned, recurse */
-		if (childrel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
+		/* Close child relations, but keep locks */
+		heap_close(newrelation, NoLock);
+
+		/* If the child is partitioned itself, expand it too. */
+		if (childrel->part_scheme)
+		{
+			Assert(childrte->inh);
 			expand_partitioned_rtentry(root, childrte, childRTindex,
-									   childrel, top_parentrc, lockmode,
-									   appinfos);
+									   childrel);
+		}
+	}
 
-		/* Close child relation, but keep locks */
-		heap_close(childrel, NoLock);
+	/*
+	 * Add junk columns needed by the row mark if any and also add the
+	 * relevant expressions to the root parent's reltarget.
+	 */
+	if (rootrc)
+	{
+		List   *tlist = add_rowmark_junk_columns(root, rootrc);
+
+		build_base_rel_tlists(root, tlist);
 	}
 }
 
 /*
- * expand_single_inheritance_child
- *		Build a RangeTblEntry and an AppendRelInfo, if appropriate, plus
- *		maybe a PlanRowMark.
+ * add_inheritance_child_rel
+ *		Build a RangeTblEntry, an AppendRelInfo, a PlanRowMark, and finally
+ *		a RelOptInfo for an inheritance child relation.
  *
- * We now expand the partition hierarchy level by level, creating a
- * corresponding hierarchy of AppendRelInfos and RelOptInfos, where each
- * partitioned descendant acts as a parent of its immediate partitions.
- * (This is a difference from what older versions of PostgreSQL did and what
- * is still done in the case of table inheritance for unpartitioned tables,
- * where the hierarchy is flattened during RTE expansion.)
+ * The return value is the RelOptInfo that's added.
  *
  * PlanRowMarks still carry the top-parent's RTI, and the top-parent's
  * allMarkTypes field still accumulates values from all descendents.
  *
  * "parentrte" and "parentRTindex" are immediate parent's RTE and
  * RTI. "top_parentrc" is top parent's PlanRowMark.
- *
- * The child RangeTblEntry and its RTI are returned in "childrte_p" and
- * "childRTindex_p" resp.
  */
-static void
-expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte,
-								Index parentRTindex, Relation parentrel,
-								PlanRowMark *top_parentrc, Relation childrel,
-								List **appinfos, RangeTblEntry **childrte_p,
-								Index *childRTindex_p)
+static RelOptInfo *
+add_inheritance_child_rel(PlannerInfo *root, RangeTblEntry *parentrte,
+						  Index parentRTindex, RelOptInfo *parentrel,
+						  PlanRowMark *top_parentrc, Relation childrel,
+						  RangeTblEntry **childrte_p, Index *childRTindex_p)
 {
 	Query	   *parse = root->parse;
-	Oid			parentOID = RelationGetRelid(parentrel);
 	Oid			childOID = RelationGetRelid(childrel);
 	RangeTblEntry *childrte;
 	Index		childRTindex;
 	AppendRelInfo *appinfo;
+	RelOptInfo *childrelopt;
 
 	/*
 	 * Build an RTE for the child, and attach to query's rangetable list. We
 	 * copy most fields of the parent's RTE, but replace relation OID and
-	 * relkind, and set inh = false.  Also, set requiredPerms to zero since
-	 * all required permissions checks are done on the original RTE. Likewise,
-	 * set the child's securityQuals to empty, because we only want to apply
-	 * the parent's RLS conditions regardless of what RLS properties
+	 * relkind, and set inh appropriately.  Also, set requiredPerms to zero
+	 * since all required permissions checks are done on the original RTE.
+	 * Likewise, set the child's securityQuals to empty, because we only want
+	 * to apply the parent's RLS conditions regardless of what RLS properties
 	 * individual children may have.  (This is an intentional choice to make
 	 * inherited RLS work like regular permissions checks.) The parent
 	 * securityQuals will be propagated to children along with other base
@@ -1784,55 +1874,42 @@ expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte,
 	*childrte_p = childrte;
 	childrte->relid = childOID;
 	childrte->relkind = childrel->rd_rel->relkind;
-	/* A partitioned child will need to be expanded further. */
-	if (childOID != parentOID &&
-		childrte->relkind == RELKIND_PARTITIONED_TABLE)
-		childrte->inh = true;
-	else
-		childrte->inh = false;
+	/*
+	 * A partitioned child will need to be expanded as an append parent
+	 * itself, so set its inh to true.
+	 */
+	childrte->inh = (childrte->relkind == RELKIND_PARTITIONED_TABLE);
 	childrte->requiredPerms = 0;
 	childrte->securityQuals = NIL;
 	parse->rtable = lappend(parse->rtable, childrte);
 	childRTindex = list_length(parse->rtable);
 	*childRTindex_p = childRTindex;
 
-	/*
-	 * We need an AppendRelInfo if paths will be built for the child RTE. If
-	 * childrte->inh is true, then we'll always need to generate append paths
-	 * for it.  If childrte->inh is false, we must scan it if it's not a
-	 * partitioned table; but if it is a partitioned table, then it never has
-	 * any data of its own and need not be scanned.
-	 */
-	if (childrte->relkind != RELKIND_PARTITIONED_TABLE || childrte->inh)
-	{
-		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->translated_vars);
-		appinfo->parent_reloid = parentOID;
-		*appinfos = lappend(*appinfos, appinfo);
+	/* Create an AppendRelInfo and add it to planner's global list. */
+	appinfo = make_append_rel_info(parentrel, parentrte,
+								   childrel->rd_att,
+								   childOID,
+								   childrel->rd_rel->reltype,
+								   childRTindex);
+	root->append_rel_list = lappend(root->append_rel_list, appinfo);
 
-		/*
-		 * Translate the column permissions bitmaps to the child's attnums (we
-		 * have to build the translated_vars list before we can do this). But
-		 * if this is the parent table, leave copyObject's result alone.
-		 *
-		 * Note: we need to do this even though the executor won't run any
-		 * permissions checks on the child RTE.  The insertedCols/updatedCols
-		 * bitmaps may be examined for trigger-firing purposes.
-		 */
-		if (childOID != parentOID)
-		{
-			childrte->selectedCols = translate_col_privs(parentrte->selectedCols,
-														 appinfo->translated_vars);
-			childrte->insertedCols = translate_col_privs(parentrte->insertedCols,
-														 appinfo->translated_vars);
-			childrte->updatedCols = translate_col_privs(parentrte->updatedCols,
-														appinfo->translated_vars);
-		}
+	/*
+	 * Translate the column permissions bitmaps to the child's attnums (we
+	 * have to build the translated_vars list before we can do this). But
+	 * if this is the parent table, leave copyObject's result alone.
+	 *
+	 * Note: we need to do this even though the executor won't run any
+	 * permissions checks on the child RTE.  The insertedCols/updatedCols
+	 * bitmaps may be examined for trigger-firing purposes.
+	 */
+	if (childrte->relid != parentrte->relid)
+	{
+		childrte->selectedCols = translate_col_privs(parentrte->selectedCols,
+													 appinfo->translated_vars);
+		childrte->insertedCols = translate_col_privs(parentrte->insertedCols,
+													 appinfo->translated_vars);
+		childrte->updatedCols = translate_col_privs(parentrte->updatedCols,
+													appinfo->translated_vars);
 	}
 
 	/*
@@ -1864,6 +1941,24 @@ expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte,
 
 		root->rowMarks = lappend(root->rowMarks, childrc);
 	}
+
+	/*
+	 * Add the RelOptInfo.  Even though we may not really scan this relation
+	 * for reasons such as contradictory quals, we still need need to create
+	 * one, because for every RTE in the query's range table, there must be an
+	 * accompanying RelOptInfo.
+	 */
+
+	/* First, store the RTE and appinfos into planner arrays. */
+	Assert(root->simple_rte_array[childRTindex] == NULL);
+	root->simple_rte_array[childRTindex] = childrte;
+	Assert(root->append_rel_array[childRTindex] == NULL);
+	root->append_rel_array[childRTindex] = appinfo;
+
+	childrelopt = build_append_child_rel(root, parentrel, childRTindex);
+	Assert(childrelopt != NULL);
+
+	return childrelopt;
 }
 
 /*
@@ -1874,14 +1969,11 @@ expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte,
  * For paranoia's sake, we match type/collation as well as attribute name.
  */
 static void
-make_inh_translation_list(Relation oldrelation, Relation newrelation,
-						  Index newvarno,
-						  List **translated_vars)
+make_inh_translation_list(TupleDesc old_tupdesc, TupleDesc new_tupdesc,
+						  Oid from_rel, Oid to_rel,
+						  Index newvarno, List **translated_vars)
 {
 	List	   *vars = NIL;
-	TupleDesc	old_tupdesc = RelationGetDescr(oldrelation);
-	TupleDesc	new_tupdesc = RelationGetDescr(newrelation);
-	Oid			new_relid = RelationGetRelid(newrelation);
 	int			oldnatts = old_tupdesc->natts;
 	int			newnatts = new_tupdesc->natts;
 	int			old_attno;
@@ -1911,7 +2003,7 @@ make_inh_translation_list(Relation oldrelation, Relation newrelation,
 		 * When we are generating the "translation list" for the parent table
 		 * of an inheritance set, no need to search for matches.
 		 */
-		if (oldrelation == newrelation)
+		if (from_rel == to_rel)
 		{
 			vars = lappend(vars, makeVar(newvarno,
 										 (AttrNumber) (old_attno + 1),
@@ -1937,10 +2029,10 @@ make_inh_translation_list(Relation oldrelation, Relation newrelation,
 		{
 			HeapTuple	newtup;
 
-			newtup = SearchSysCacheAttName(new_relid, attname);
+			newtup = SearchSysCacheAttName(to_rel, attname);
 			if (!newtup)
 				elog(ERROR, "could not find inherited attribute \"%s\" of relation \"%s\"",
-					 attname, RelationGetRelationName(newrelation));
+					 attname, get_rel_name(to_rel));
 			new_attno = ((Form_pg_attribute) GETSTRUCT(newtup))->attnum - 1;
 			ReleaseSysCache(newtup);
 
@@ -1950,10 +2042,10 @@ make_inh_translation_list(Relation oldrelation, Relation newrelation,
 		/* Found it, check type and collation match */
 		if (atttypid != att->atttypid || atttypmod != att->atttypmod)
 			elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's type",
-				 attname, RelationGetRelationName(newrelation));
+				 attname, get_rel_name(to_rel));
 		if (attcollation != att->attcollation)
 			elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's collation",
-				 attname, RelationGetRelationName(newrelation));
+				 attname, get_rel_name(to_rel));
 
 		vars = lappend(vars, makeVar(newvarno,
 									 (AttrNumber) (new_attno + 1),
@@ -2020,6 +2112,255 @@ translate_col_privs(const Bitmapset *parent_privs,
 }
 
 /*
+ *	build_append_child_rel
+ *		Build a RelOptInfo for child relation of an append rel
+ *
+ * After creating the RelOptInfo for the given child RT index, it goes on to
+ * initialize some of its fields base on the parent RelOptInfo.
+ *
+ * If the quals in baserestrictinfo turns out to be self-contradictory, the
+ * RelOptInfo is marked dummy before returning.
+ */
+static RelOptInfo *
+build_append_child_rel(PlannerInfo *root,
+					   RelOptInfo *parent,
+					   Index childRTindex)
+{
+	RelOptInfo *childrel;
+	RangeTblEntry *childRTE = root->simple_rte_array[childRTindex];
+	AppendRelInfo *appinfo = root->append_rel_array[childRTindex];
+	List	   *childquals;
+	ListCell   *lc;
+	bool		have_const_false_cq;
+	Index		cq_min_security;
+
+	/* Build the RelOptInfo. */
+	childrel = build_simple_rel(root, childRTindex, parent);
+
+	/*
+	 * Propagate lateral_relids and lateral_referencers from appendrel
+	 * parent rels to their child rels.  We intentionally give each child rel
+	 * the same minimum parameterization, even though it's quite possible that
+	 * some don't reference all the lateral rels.  This is because any append
+	 * path for the parent will have to have the same parameterization for
+	 * every child anyway, and there's no value in forcing extra
+	 * reparameterize_path() calls.  Similarly, a lateral reference to the
+	 * parent prevents use of otherwise-movable join rels for each child.
+	 */
+	childrel->direct_lateral_relids = parent->direct_lateral_relids;
+	childrel->lateral_relids = parent->lateral_relids;
+	childrel->lateral_referencers = parent->lateral_referencers;
+
+	/*
+	 * We have to copy the parent's quals to the child, with appropriate
+	 * substitution of variables.  However, only the baserestrictinfo
+	 * quals are needed before we can check for constraint exclusion; so
+	 * do that first and then check to see if we can disregard this child.
+	 *
+	 * The child rel's targetlist might contain non-Var expressions, which
+	 * means that substitution into the quals could produce opportunities
+	 * for const-simplification, and perhaps even pseudoconstant quals.
+	 * Therefore, transform each RestrictInfo separately to see if it
+	 * reduces to a constant or pseudoconstant.  (We must process them
+	 * separately to keep track of the security level of each qual.)
+	 */
+	childquals = false;
+	cq_min_security = UINT_MAX;
+	have_const_false_cq = false;
+	foreach(lc, parent->baserestrictinfo)
+	{
+		RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
+		Node	   *childqual = (Node *) rinfo->clause;
+		ListCell   *lc2;
+
+		Assert(IsA(rinfo, RestrictInfo));
+		childqual = adjust_appendrel_attrs(root, childqual,
+										   1, &appinfo);
+		childqual = eval_const_expressions(root, childqual);
+		/* check for flat-out constant */
+		if (childqual && IsA(childqual, Const))
+		{
+			if (((Const *) childqual)->constisnull ||
+				!DatumGetBool(((Const *) childqual)->constvalue))
+			{
+				/* Restriction reduces to constant FALSE or NULL */
+				have_const_false_cq = true;
+				break;
+			}
+			/* Restriction reduces to constant TRUE, so drop it */
+			continue;
+		}
+		/* might have gotten an AND clause, if so flatten it */
+		foreach(lc2, make_ands_implicit((Expr *) childqual))
+		{
+			Node	   *onecq = (Node *) lfirst(lc2);
+			bool		pseudoconstant;
+
+			/* check for pseudoconstant (no Vars or volatile functions) */
+			pseudoconstant =
+					!contain_vars_of_level(onecq, 0) &&
+					!contain_volatile_functions(onecq);
+			if (pseudoconstant)
+			{
+				/* tell createplan.c to check for gating quals */
+				root->hasPseudoConstantQuals = true;
+			}
+			/* reconstitute RestrictInfo with appropriate properties */
+			childquals = lappend(childquals,
+								 make_restrictinfo((Expr *) onecq,
+												   rinfo->is_pushed_down,
+												   rinfo->outerjoin_delayed,
+												   pseudoconstant,
+												   rinfo->security_level,
+												   NULL, NULL, NULL));
+			cq_min_security = Min(cq_min_security, rinfo->security_level);
+		}
+	}
+
+	/*
+	 * In addition to the quals inherited from the parent, we might
+	 * have securityQuals associated with this particular child node.
+	 * (Currently this can only happen in appendrels originating from
+	 * UNION ALL; inheritance child tables don't have their own
+	 * securityQuals.)	Pull any such securityQuals up into the
+	 * baserestrictinfo for the child.  This is similar to
+	 * process_security_barrier_quals() for the parent rel, except
+	 * that we can't make any general deductions from such quals,
+	 * since they don't hold for the whole appendrel.
+	 */
+	if (childRTE->securityQuals)
+	{
+		Index		security_level = 0;
+
+		foreach(lc, childRTE->securityQuals)
+		{
+			List	   *qualset = (List *) lfirst(lc);
+			ListCell   *lc2;
+
+			foreach(lc2, qualset)
+			{
+				Expr	   *qual = (Expr *) lfirst(lc2);
+
+				/*
+				 * not likely that we'd see constants here, so no
+				 * check
+				 */
+				childquals = lappend(childquals,
+									 make_restrictinfo(qual,
+													   true,
+													   false,
+													   false,
+													   security_level,
+													   NULL, NULL,
+													   NULL));
+				cq_min_security = Min(cq_min_security, security_level);
+			}
+			security_level++;
+		}
+		Assert(security_level <= root->qual_security_level);
+	}
+
+	/* Set child's version of baserestrictinfo. */
+	childrel->baserestrictinfo = childquals;
+	childrel->baserestrict_min_security = cq_min_security;
+
+	if (have_const_false_cq)
+	{
+		/*
+		 * Some restriction clause reduced to constant FALSE or NULL after
+		 * substitution, so this child need not be scanned.
+		 */
+		set_dummy_rel_pathlist(childrel);
+	}
+
+	return childrel;
+}
+
+/*
+ * add_rowmark_junk_columns
+ * 		Add necessary junk columns for rowmarked inheritance parent rel.
+ *
+ * These values are needed for locking of rels selected FOR UPDATE/SHARE, and
+ * to do EvalPlanQual rechecking.  See comments for PlanRowMark in
+ * plannodes.h.
+ */
+static List *
+add_rowmark_junk_columns(PlannerInfo *root, PlanRowMark *rc)
+{
+	List   *tlist = root->processed_tlist;
+	Var		   *var;
+	char		resname[32];
+	TargetEntry *tle;
+
+	if (rc->allMarkTypes & ~(1 << ROW_MARK_COPY))
+	{
+		/* Need to fetch TID */
+		var = makeVar(rc->rti,
+					  SelfItemPointerAttributeNumber,
+					  TIDOID,
+					  -1,
+					  InvalidOid,
+					  0);
+		snprintf(resname, sizeof(resname), "ctid%u", rc->rowmarkId);
+		tle = makeTargetEntry((Expr *) var,
+							  list_length(tlist) + 1,
+							  pstrdup(resname),
+							  true);
+		tlist = lappend(tlist, tle);
+	}
+	if (rc->allMarkTypes & (1 << ROW_MARK_COPY))
+	{
+		/* Need the whole row as a junk var */
+		var = makeWholeRowVar(root->simple_rte_array[rc->rti],
+							  rc->rti,
+							  0,
+							  false);
+		snprintf(resname, sizeof(resname), "wholerow%u", rc->rowmarkId);
+		tle = makeTargetEntry((Expr *) var,
+							  list_length(tlist) + 1,
+							  pstrdup(resname),
+							  true);
+		tlist = lappend(tlist, tle);
+	}
+
+	/* For inheritance cases, always fetch the tableoid too. */
+	var = makeVar(rc->rti,
+				  TableOidAttributeNumber,
+				  OIDOID,
+				  -1,
+				  InvalidOid,
+				  0);
+	snprintf(resname, sizeof(resname), "tableoid%u", rc->rowmarkId);
+	tle = makeTargetEntry((Expr *) var,
+						  list_length(tlist) + 1,
+						  pstrdup(resname),
+						  true);
+	tlist = lappend(tlist, tle);
+
+	return tlist;
+}
+
+AppendRelInfo *
+make_append_rel_info(RelOptInfo *parentrel, RangeTblEntry *parentrte,
+					 TupleDesc childdesc, Oid childoid, Oid childreltype,
+					 Index childRTindex)
+{
+	AppendRelInfo  *appinfo = makeNode(AppendRelInfo);
+
+	appinfo->parent_relid = parentrel->relid;
+	appinfo->child_relid = childRTindex;
+	appinfo->parent_reltype = parentrel->reltype;
+	appinfo->child_reltype = childreltype;
+	make_inh_translation_list(parentrel->tupdesc, childdesc,
+							  parentrte->relid, childoid,
+							  childRTindex,
+							  &appinfo->translated_vars);
+	appinfo->parent_reloid = parentrte->relid;
+
+	return appinfo;
+}
+
+/*
  * adjust_appendrel_attrs
  *	  Copy the specified query or expression and translate Vars referring to a
  *	  parent rel to refer to the corresponding child rel instead.  We also
diff --git a/src/backend/optimizer/util/Makefile b/src/backend/optimizer/util/Makefile
index c54d0a690d..da9ccf32b4 100644
--- a/src/backend/optimizer/util/Makefile
+++ b/src/backend/optimizer/util/Makefile
@@ -13,6 +13,6 @@ top_builddir = ../../../..
 include $(top_builddir)/src/Makefile.global
 
 OBJS = clauses.o joininfo.o orclauses.o pathnode.o placeholder.o \
-       plancat.o predtest.o relnode.o restrictinfo.o tlist.o var.o
+	   plancat.o predtest.o relnode.o restrictinfo.o tlist.o var.o
 
 include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/optimizer/util/plancat.c b/src/backend/optimizer/util/plancat.c
index a0fed5be42..bf441741e0 100644
--- a/src/backend/optimizer/util/plancat.c
+++ b/src/backend/optimizer/util/plancat.c
@@ -106,7 +106,7 @@ static void set_baserel_partition_key_exprs(Relation relation,
  */
 void
 get_relation_info(PlannerInfo *root, Oid relationObjectId, bool inhparent,
-				  RelOptInfo *rel)
+				  Bitmapset *updatedCols, RelOptInfo *rel)
 {
 	Index		varno = rel->relid;
 	Relation	relation;
@@ -444,11 +444,31 @@ get_relation_info(PlannerInfo *root, Oid relationObjectId, bool inhparent,
 	get_relation_foreign_keys(root, rel, relation, inhparent);
 
 	/*
-	 * Collect info about relation's partitioning scheme, if any. Only
-	 * inheritance parents may be partitioned.
+	 * Collect some additional information for inheritance parents.
 	 */
-	if (inhparent && relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
-		set_relation_partition_info(root, rel, relation);
+	if (inhparent)
+	{
+		/*
+		 * We'll need the TupleDesc when initializing the child relation.
+		 * A copy is being made because concurrent changes might drop
+		 * the relcache entry.  That's possible because ALTER TABLE
+		 * child_table NO INHERIT parent_table only requires an
+		 * AccessShareLock on parent_table.
+		 */
+		rel->tupdesc = CreateTupleDescCopy(RelationGetDescr(relation));
+		rel->reltype = RelationGetForm(relation)->reltype;
+
+		/*
+		 * If partitioned, also save the information of partitioning scheme,
+		 * and whether the query updates any of the partition key columns.
+		 */
+		if (relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
+		{
+			set_relation_partition_info(root, rel, relation);
+			root->partColsUpdated |= has_partition_attrs(relation, updatedCols,
+														 NULL);
+		}
+	}
 
 	heap_close(relation, NoLock);
 
@@ -1853,16 +1873,20 @@ set_relation_partition_info(PlannerInfo *root, RelOptInfo *rel,
 							Relation relation)
 {
 	PartitionDesc partdesc;
-	PartitionKey partkey;
 
 	Assert(relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE);
 
 	partdesc = RelationGetPartitionDesc(relation);
-	partkey = RelationGetPartitionKey(relation);
 	rel->part_scheme = find_partition_scheme(root, relation);
 	Assert(partdesc != NULL && rel->part_scheme != NULL);
-	rel->boundinfo = partition_bounds_copy(partdesc->boundinfo, partkey);
 	rel->nparts = partdesc->nparts;
+
+	/*
+	 * Since we must've taken a lock on the table, it's okay to simply copy
+	 * the pointers to relcache data here.
+	 */
+	rel->part_oids = partdesc->oids;
+	rel->boundinfo = partdesc->boundinfo;
 	set_baserel_partition_key_exprs(relation, rel);
 	rel->partition_qual = RelationGetPartitionQual(relation);
 }
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index 29ba19349f..c23db9d78d 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -130,6 +130,37 @@ setup_append_rel_array(PlannerInfo *root)
 	}
 }
 
+/* Expand the PlannerInfo arrays by add_size members and zero-init it. */
+void
+expand_planner_arrays(PlannerInfo *root, int add_size)
+{
+	int		new_size = root->simple_rel_array_size + add_size;
+
+	root->simple_rte_array = (RangeTblEntry **)
+							repalloc(root->simple_rte_array,
+									 sizeof(RangeTblEntry *) * new_size);
+	root->simple_rel_array = (RelOptInfo **)
+								repalloc(root->simple_rel_array,
+										 sizeof(RelOptInfo *) * new_size);
+	if (root->append_rel_array)
+		root->append_rel_array = (AppendRelInfo **)
+									repalloc(root->append_rel_array,
+									 sizeof(AppendRelInfo *) * new_size);
+	else
+		root->append_rel_array = (AppendRelInfo **)
+									palloc0(sizeof(AppendRelInfo *) *
+											new_size);
+
+	/* Set the contents of just allocated memory to 0. */
+	MemSet(root->simple_rte_array + root->simple_rel_array_size,
+		   0, sizeof(RangeTblEntry *) * add_size);
+	MemSet(root->simple_rel_array + root->simple_rel_array_size,
+		   0, sizeof(RelOptInfo *) * add_size);
+	MemSet(root->append_rel_array + root->simple_rel_array_size,
+		   0, sizeof(AppendRelInfo *) * add_size);
+	root->simple_rel_array_size = new_size;
+}
+
 /*
  * build_simple_rel
  *	  Construct a new RelOptInfo for a base relation or 'other' relation.
@@ -238,7 +269,8 @@ build_simple_rel(PlannerInfo *root, int relid, RelOptInfo *parent)
 	{
 		case RTE_RELATION:
 			/* Table --- retrieve statistics from the system catalogs */
-			get_relation_info(root, rte->relid, rte->inh, rel);
+			get_relation_info(root, rte->relid, rte->inh, rte->updatedCols,
+							  rel);
 			break;
 		case RTE_SUBQUERY:
 		case RTE_FUNCTION:
@@ -279,52 +311,6 @@ build_simple_rel(PlannerInfo *root, int relid, RelOptInfo *parent)
 		root->qual_security_level = Max(root->qual_security_level,
 										list_length(rte->securityQuals));
 
-	/*
-	 * If this rel is an appendrel parent, recurse to build "other rel"
-	 * RelOptInfos for its children.  They are "other rels" because they are
-	 * not in the main join tree, but we will need RelOptInfos to plan access
-	 * to them.
-	 */
-	if (rte->inh)
-	{
-		ListCell   *l;
-		int			nparts = rel->nparts;
-		int			cnt_parts = 0;
-
-		if (nparts > 0)
-			rel->part_rels = (RelOptInfo **)
-				palloc(sizeof(RelOptInfo *) * nparts);
-
-		foreach(l, root->append_rel_list)
-		{
-			AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(l);
-			RelOptInfo *childrel;
-
-			/* append_rel_list contains all append rels; ignore others */
-			if (appinfo->parent_relid != relid)
-				continue;
-
-			childrel = build_simple_rel(root, appinfo->child_relid,
-										rel);
-
-			/* Nothing more to do for an unpartitioned table. */
-			if (!rel->part_scheme)
-				continue;
-
-			/*
-			 * The order of partition OIDs in append_rel_list is the same as
-			 * the order in the PartitionDesc, so the order of part_rels will
-			 * also match the PartitionDesc.  See expand_partitioned_rtentry.
-			 */
-			Assert(cnt_parts < nparts);
-			rel->part_rels[cnt_parts] = childrel;
-			cnt_parts++;
-		}
-
-		/* We should have seen all the child partitions. */
-		Assert(cnt_parts == nparts);
-	}
-
 	return rel;
 }
 
diff --git a/src/backend/partitioning/partprune.c b/src/backend/partitioning/partprune.c
index 35c87535d3..fcf8d6032c 100644
--- a/src/backend/partitioning/partprune.c
+++ b/src/backend/partitioning/partprune.c
@@ -45,6 +45,7 @@
 #include "nodes/makefuncs.h"
 #include "nodes/nodeFuncs.h"
 #include "optimizer/clauses.h"
+#include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
 #include "optimizer/planner.h"
 #include "optimizer/predtest.h"
@@ -436,17 +437,23 @@ make_partitionedrel_pruneinfo(PlannerInfo *root, RelOptInfo *parentrel,
 		 * is, not pruned already).
 		 */
 		subplan_map = (int *) palloc(nparts * sizeof(int));
+		memset(subplan_map, -1, nparts * sizeof(int));
 		subpart_map = (int *) palloc(nparts * sizeof(int));
+		memset(subpart_map, -1, nparts * sizeof(int));
 		present_parts = NULL;
 
 		for (i = 0; i < nparts; i++)
 		{
 			RelOptInfo *partrel = subpart->part_rels[i];
-			int			subplanidx = relid_subplan_map[partrel->relid] - 1;
-			int			subpartidx = relid_subpart_map[partrel->relid] - 1;
+			int			subplanidx;
+			int			subpartidx;
 
-			subplan_map[i] = subplanidx;
-			subpart_map[i] = subpartidx;
+			/* Skip processing pruned partitions. */
+			if (partrel == NULL)
+				continue;
+
+			subplan_map[i] = subplanidx = relid_subplan_map[partrel->relid] - 1;
+			subpart_map[i] = subpartidx = relid_subpart_map[partrel->relid] - 1;
 			if (subplanidx >= 0)
 			{
 				present_parts = bms_add_member(present_parts, i);
@@ -540,23 +547,20 @@ gen_partprune_steps(RelOptInfo *rel, List *clauses, bool *contradictory)
 
 /*
  * prune_append_rel_partitions
- *		Returns RT indexes of the minimum set of child partitions which must
- *		be scanned to satisfy rel's baserestrictinfo quals.
+ *		Returns indexes into rel->part_rels of the minimum set of child
+ *		partitions which must be scanned to satisfy rel's baserestrictinfo
+ *		quals.
  *
  * Callers must ensure that 'rel' is a partitioned table.
  */
-Relids
+Bitmapset *
 prune_append_rel_partitions(RelOptInfo *rel)
 {
-	Relids		result;
 	List	   *clauses = rel->baserestrictinfo;
 	List	   *pruning_steps;
 	bool		contradictory;
 	PartitionPruneContext context;
-	Bitmapset  *partindexes;
-	int			i;
 
-	Assert(clauses != NIL);
 	Assert(rel->part_scheme != NULL);
 
 	/* If there are no partitions, return the empty set */
@@ -564,6 +568,13 @@ prune_append_rel_partitions(RelOptInfo *rel)
 		return NULL;
 
 	/*
+	 * If pruning is disabled or if there are no clauses to prune with,
+	 * return all partitions.
+	 */
+	if (!enable_partition_pruning || clauses == NIL)
+		return bms_add_range(NULL, 0, rel->nparts - 1);
+
+	/*
 	 * Process clauses.  If the clauses are found to be contradictory, we can
 	 * return the empty set.
 	 */
@@ -590,15 +601,7 @@ prune_append_rel_partitions(RelOptInfo *rel)
 	context.evalexecparams = false;
 
 	/* Actual pruning happens here. */
-	partindexes = get_matching_partitions(&context, pruning_steps);
-
-	/* Add selected partitions' RT indexes to result. */
-	i = -1;
-	result = NULL;
-	while ((i = bms_next_member(partindexes, i)) >= 0)
-		result = bms_add_member(result, rel->part_rels[i]->relid);
-
-	return result;
+	return get_matching_partitions(&context, pruning_steps);
 }
 
 /*
diff --git a/src/include/nodes/relation.h b/src/include/nodes/relation.h
index 94f14019bd..e6fdbcd030 100644
--- a/src/include/nodes/relation.h
+++ b/src/include/nodes/relation.h
@@ -15,6 +15,7 @@
 #define RELATION_H
 
 #include "access/sdir.h"
+#include "access/tupdesc.h"
 #include "fmgr.h"
 #include "lib/stringinfo.h"
 #include "nodes/params.h"
@@ -723,6 +724,7 @@ typedef struct RelOptInfo
 	int			nparts;			/* number of partitions */
 	struct PartitionBoundInfoData *boundinfo;	/* Partition bounds */
 	List	   *partition_qual; /* partition constraint */
+	Oid		   *part_oids;		/* partition OIDs */
 	struct RelOptInfo **part_rels;	/* Array of RelOptInfos of partitions,
 									 * stored in the same order of bounds */
 	List	  **partexprs;		/* Non-nullable partition key expressions. */
@@ -732,6 +734,12 @@ typedef struct RelOptInfo
 	Index		inh_root_parent;	/* For otherrels, this is the RT index of
 									 * inheritance table mentioned in the query
 									 * from which this relation originated */
+	/*
+	 * Set only if this is an inheritance parent relation.  This information
+	 * is needed when initializing the planning info for children.
+	 */
+	TupleDesc	tupdesc;		/* A "copy" of the table's tuple desriptor */
+	Oid			reltype;		/* Table's reltype */
 } RelOptInfo;
 
 /*
diff --git a/src/include/optimizer/pathnode.h b/src/include/optimizer/pathnode.h
index 81abcf53a8..b1baa3117a 100644
--- a/src/include/optimizer/pathnode.h
+++ b/src/include/optimizer/pathnode.h
@@ -261,6 +261,7 @@ extern Path *reparameterize_path_by_child(PlannerInfo *root, Path *path,
  */
 extern void setup_simple_rel_arrays(PlannerInfo *root);
 extern void setup_append_rel_array(PlannerInfo *root);
+extern void expand_planner_arrays(PlannerInfo *root, int add_size);
 extern RelOptInfo *build_simple_rel(PlannerInfo *root, int relid,
 				 RelOptInfo *parent);
 extern RelOptInfo *find_base_rel(PlannerInfo *root, int relid);
diff --git a/src/include/optimizer/plancat.h b/src/include/optimizer/plancat.h
index 7d53cbbb87..edaf2a3b4f 100644
--- a/src/include/optimizer/plancat.h
+++ b/src/include/optimizer/plancat.h
@@ -26,7 +26,7 @@ extern PGDLLIMPORT get_relation_info_hook_type get_relation_info_hook;
 
 
 extern void get_relation_info(PlannerInfo *root, Oid relationObjectId,
-				  bool inhparent, RelOptInfo *rel);
+				  bool inhparent, Bitmapset *updatedCols, RelOptInfo *rel);
 
 extern List *infer_arbiter_indexes(PlannerInfo *root);
 
diff --git a/src/include/optimizer/prep.h b/src/include/optimizer/prep.h
index 38608770a2..faae07d240 100644
--- a/src/include/optimizer/prep.h
+++ b/src/include/optimizer/prep.h
@@ -38,7 +38,8 @@ extern Expr *canonicalize_qual(Expr *qual, bool is_check);
 /*
  * prototypes for preptlist.c
  */
-extern List *preprocess_targetlist(PlannerInfo *root);
+extern List *preprocess_targetlist(PlannerInfo *root,
+							bool inheritance_expanded);
 
 extern PlanRowMark *get_plan_rowmark(List *rowmarks, Index rtindex);
 
@@ -51,7 +52,10 @@ extern void expand_inherited_tables(PlannerInfo *root);
 
 extern Node *adjust_appendrel_attrs(PlannerInfo *root, Node *node,
 					   int nappinfos, AppendRelInfo **appinfos);
-
+extern AppendRelInfo *make_append_rel_info(RelOptInfo *parentrel,
+					 RangeTblEntry *parentrte,
+					 TupleDesc childdesc, Oid childoid, Oid childreltype,
+					 Index childRTindex);
 extern Node *adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node,
 								  Relids child_relids,
 								  Relids top_parent_relids);
@@ -64,5 +68,4 @@ extern SpecialJoinInfo *build_child_join_sjinfo(PlannerInfo *root,
 						Relids left_relids, Relids right_relids);
 extern Relids adjust_child_relids_multilevel(PlannerInfo *root, Relids relids,
 							   Relids child_relids, Relids top_parent_relids);
-
 #endif							/* PREP_H */
diff --git a/src/include/partitioning/partprune.h b/src/include/partitioning/partprune.h
index e07aaaf798..ac0a979010 100644
--- a/src/include/partitioning/partprune.h
+++ b/src/include/partitioning/partprune.h
@@ -76,7 +76,7 @@ extern PartitionPruneInfo *make_partition_pruneinfo(PlannerInfo *root,
 						 List *subpaths,
 						 List *partitioned_rels,
 						 List *prunequal);
-extern Relids prune_append_rel_partitions(RelOptInfo *rel);
+extern Bitmapset *prune_append_rel_partitions(RelOptInfo *rel);
 extern Bitmapset *get_matching_partitions(PartitionPruneContext *context,
 						List *pruning_steps);
 
diff --git a/src/test/regress/expected/partition_aggregate.out b/src/test/regress/expected/partition_aggregate.out
index 6bc106831e..1450cef057 100644
--- a/src/test/regress/expected/partition_aggregate.out
+++ b/src/test/regress/expected/partition_aggregate.out
@@ -144,7 +144,7 @@ SELECT c, sum(a) FROM pagg_tab WHERE 1 = 2 GROUP BY c;
            QUERY PLAN           
 --------------------------------
  HashAggregate
-   Group Key: pagg_tab.c
+   Group Key: c
    ->  Result
          One-Time Filter: false
 (4 rows)
@@ -159,7 +159,7 @@ SELECT c, sum(a) FROM pagg_tab WHERE c = 'x' GROUP BY c;
            QUERY PLAN           
 --------------------------------
  GroupAggregate
-   Group Key: pagg_tab.c
+   Group Key: c
    ->  Result
          One-Time Filter: false
 (4 rows)
-- 
2.11.0

From f07f25e9c7057d8240b39573a83f9410633dba83 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Wed, 7 Nov 2018 16:51:31 +0900
Subject: [PATCH v8 4/6] Move append expansion code into its own file

This commit moves expand_append_rel and underlings currently in
optimizer/prep/prepunionc.c to optimizer/utils/append.c.

All of the AppendRelInfo based expression manipulation routines
are moved to optimizer/utils/appendinfo.c.

This commit only moves the code and contains no functional changes.
---
 src/backend/optimizer/path/allpaths.c   |    2 +
 src/backend/optimizer/path/equivclass.c |    1 +
 src/backend/optimizer/path/joinrels.c   |    1 +
 src/backend/optimizer/plan/planner.c    |    1 +
 src/backend/optimizer/prep/prepunion.c  | 1574 -------------------------------
 src/backend/optimizer/util/Makefile     |    5 +-
 src/backend/optimizer/util/append.c     |  777 +++++++++++++++
 src/backend/optimizer/util/appendinfo.c |  851 +++++++++++++++++
 src/backend/optimizer/util/pathnode.c   |    1 +
 src/backend/optimizer/util/relnode.c    |    1 +
 src/backend/partitioning/partprune.c    |    1 +
 src/include/optimizer/append.h          |   25 +
 src/include/optimizer/appendinfo.h      |   43 +
 src/include/optimizer/prep.h            |   19 -
 14 files changed, 1707 insertions(+), 1595 deletions(-)
 create mode 100644 src/backend/optimizer/util/append.c
 create mode 100644 src/backend/optimizer/util/appendinfo.c
 create mode 100644 src/include/optimizer/append.h
 create mode 100644 src/include/optimizer/appendinfo.h

diff --git a/src/backend/optimizer/path/allpaths.c b/src/backend/optimizer/path/allpaths.c
index d44d034f24..4261e79bc6 100644
--- a/src/backend/optimizer/path/allpaths.c
+++ b/src/backend/optimizer/path/allpaths.c
@@ -30,6 +30,8 @@
 #ifdef OPTIMIZER_DEBUG
 #include "nodes/print.h"
 #endif
+#include "optimizer/append.h"
+#include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/geqo.h"
diff --git a/src/backend/optimizer/path/equivclass.c b/src/backend/optimizer/path/equivclass.c
index 029665b974..f52adc72d0 100644
--- a/src/backend/optimizer/path/equivclass.c
+++ b/src/backend/optimizer/path/equivclass.c
@@ -22,6 +22,7 @@
 #include "catalog/pg_type.h"
 #include "nodes/makefuncs.h"
 #include "nodes/nodeFuncs.h"
+#include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
 #include "optimizer/pathnode.h"
 #include "optimizer/paths.h"
diff --git a/src/backend/optimizer/path/joinrels.c b/src/backend/optimizer/path/joinrels.c
index da0831de4e..6e321ec9e7 100644
--- a/src/backend/optimizer/path/joinrels.c
+++ b/src/backend/optimizer/path/joinrels.c
@@ -15,6 +15,7 @@
 #include "postgres.h"
 
 #include "miscadmin.h"
+#include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
 #include "optimizer/joininfo.h"
 #include "optimizer/pathnode.h"
diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index 7f5a1865ba..0586c48ed0 100644
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -39,6 +39,7 @@
 #include "nodes/print.h"
 #endif
 #include "nodes/relation.h"
+#include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
diff --git a/src/backend/optimizer/prep/prepunion.c b/src/backend/optimizer/prep/prepunion.c
index e4d4e7d6dd..70f37c593f 100644
--- a/src/backend/optimizer/prep/prepunion.c
+++ b/src/backend/optimizer/prep/prepunion.c
@@ -12,11 +12,6 @@
  * case, but most of the heavy lifting for that is done elsewhere,
  * notably in prepjointree.c and allpaths.c.
  *
- * There is also some code here to support planning of queries that use
- * inheritance (SELECT FROM foo*).  Inheritance trees are converted into
- * append relations, and thenceforth share code with the UNION ALL case.
- *
- *
  * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
@@ -39,32 +34,21 @@
 #include "miscadmin.h"
 #include "nodes/makefuncs.h"
 #include "nodes/nodeFuncs.h"
-#include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
 #include "optimizer/paths.h"
 #include "optimizer/planmain.h"
 #include "optimizer/planner.h"
 #include "optimizer/prep.h"
-#include "optimizer/restrictinfo.h"
 #include "optimizer/tlist.h"
-#include "optimizer/var.h"
 #include "parser/parse_coerce.h"
 #include "parser/parsetree.h"
-#include "partitioning/partprune.h"
 #include "utils/lsyscache.h"
 #include "utils/rel.h"
 #include "utils/selfuncs.h"
 #include "utils/syscache.h"
 
 
-typedef struct
-{
-	PlannerInfo *root;
-	int			nappinfos;
-	AppendRelInfo **appinfos;
-} adjust_appendrel_attrs_context;
-
 static RelOptInfo *recurse_set_operations(Node *setOp, PlannerInfo *root,
 					   List *colTypes, List *colCollations,
 					   bool junkOK,
@@ -103,34 +87,6 @@ static List *generate_append_tlist(List *colTypes, List *colCollations,
 					  List *input_tlists,
 					  List *refnames_tlist);
 static List *generate_setop_grouplist(SetOperationStmt *op, List *targetlist);
-static void expand_append_rtentry(PlannerInfo *root, RelOptInfo *rel,
-					  RangeTblEntry *rte, Index rti);
-static void expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte,
-						 Index rti, RelOptInfo *rel);
-static void expand_partitioned_rtentry(PlannerInfo *root,
-						   RangeTblEntry *parentrte,
-						   Index parentRTindex, RelOptInfo *parentrel);
-static RelOptInfo *add_inheritance_child_rel(PlannerInfo *root,
-						  RangeTblEntry *parentrte,
-						  Index parentRTindex, RelOptInfo *parentrel,
-						  PlanRowMark *top_parentrc, Relation childrel,
-						  RangeTblEntry **childrte_p, Index *childRTindex_p);
-static void make_inh_translation_list(TupleDesc old_tupdesc,
-						  TupleDesc new_tupdesc,
-						  Oid from_rel, Oid to_rel,
-						  Index newvarno, List **translated_vars);
-static RelOptInfo *build_append_child_rel(PlannerInfo *root,
-					   RelOptInfo *parent,
-					   Index childRTindex);
-static List *add_rowmark_junk_columns(PlannerInfo *root, PlanRowMark *rc);
-static Bitmapset *translate_col_privs(const Bitmapset *parent_privs,
-					List *translated_vars);
-static Node *adjust_appendrel_attrs_mutator(Node *node,
-							   adjust_appendrel_attrs_context *context);
-static Relids adjust_child_relids(Relids relids, int nappinfos,
-					AppendRelInfo **appinfos);
-static List *adjust_inherited_tlist(List *tlist,
-					   AppendRelInfo *context);
 
 
 /*
@@ -1467,1533 +1423,3 @@ generate_setop_grouplist(SetOperationStmt *op, List *targetlist)
 	Assert(lg == NULL);
 	return grouplist;
 }
-
-
-/*
- * expand_inherited_tables
- *		Expand each rangetable entry that represents an inheritance set
- *		into an "append relation".  At the conclusion of this process,
- *		the "inh" flag is set in all and only those RTEs that are append
- *		relation parents.
- */
-void
-expand_inherited_tables(PlannerInfo *root)
-{
-	int			orig_rtable_size;
-	Index		rti;
-
-	Assert(root->simple_rel_array_size > 0);
-	orig_rtable_size = root->simple_rel_array_size;
-
-	/*
-	 * expand_append_rtentry may add RTEs to parse->rtable. The function is
-	 * expected to recursively handle any RTEs that it creates with inh=true.
-	 * So just scan as far as the original end of the rtable list.
-	 */
-	for (rti = 1; rti < orig_rtable_size; rti++)
-	{
-		RelOptInfo *brel = root->simple_rel_array[rti];
-		RangeTblEntry *rte = root->simple_rte_array[rti];
-
-		/* there may be empty slots corresponding to non-baserel RTEs */
-		if (brel == NULL)
-			continue;
-
-		if (rte->inh)
-			expand_append_rtentry(root, brel, rte, rti);
-	}
-}
-
-/*
- * expand_append_rtentry
- *		This initializes RelOptInfos for an appendrel's child relations, if
- *		any
- *
- * 'rel' is the appendrel parent, whose range table entry ('rte') has been
- * marked to require adding children.  An appendrel parent could either
- * be a subquery (if we flattened UNION ALL query) or a table that's known
- * to have inheritance children.  The latter consists of both regular
- * inheritance parents and partitioned tables.
- *
- * For a subquery parent, there is not much to be done here because the
- * children's RTEs are already present in the query, so we just initialize
- * RelOptInfos for them.  Also, the AppendRelInfos for child subqueries
- * have already been added.
- *
- * For tables, we need to add the children to the range table and initialize
- * AppendRelInfos, RelOptInfos, and PlanRowMarks (if any) for them.  For
- * a partitioned parent, we only add the children remaining after pruning.
- * For regular inheritance parents, we find the children using
- * find_all_inheritors and add all of them.
- *
- * If it turns out that there are no children, then we set rte->inh to false
- * to let the caller know that only the parent table needs to be scanned.  The
- * caller can accordingly switch to a non-Append path.  For a partitioned
- * parent, that means an empty relation because parents themselves contain no
- * data.
- *
- * For the regular inheritance case, the parent also gets another RTE with
- * inh = false to represent it as an appendrel child.  The original RTE is
- * considered to represent the whole inheritance set.
- */
-static void
-expand_append_rtentry(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte,
-					  Index rti)
-{
-	Assert(rte->inh);
-	/* Inheritance parent (partitioned or not) or UNION ALL parent subquery. */
-	Assert(rte->rtekind == RTE_RELATION || rte->rtekind == RTE_SUBQUERY);
-
-	/*
-	 * UNION ALL children already got RTEs and AppendRelInfos, so just build
-	 * RelOptInfos and return.
-	 *
-	 * It might be a bit odd that this code is in this, because there is
-	 * nothing to expand really.
-	 */
-	if (rte->rtekind == RTE_SUBQUERY)
-	{
-		ListCell   *l;
-
-		/*
-		 * We don't need to use expand_planner_arrays in this case, because
-		 * no new child RTEs are created.  setup_simple_rel_arrays() and
-		 * setup_append_rel_array would've considered these child RTEs when
-		 * allocating space for various arrays.
-		 */
-		foreach(l, root->append_rel_list)
-		{
-			AppendRelInfo *appinfo = lfirst(l);
-			Index		childRTindex = appinfo->child_relid;
-
-			if (appinfo->parent_relid != rti)
-				continue;
-
-			Assert(childRTindex < root->simple_rel_array_size);
-			Assert(root->simple_rte_array[childRTindex] != NULL);
-
-			/*
-			 * We set the correct value of baserestricinfo and
-			 * baserestrict_min_security below.
-			 */
-			root->simple_rel_array[childRTindex] =
-				build_append_child_rel(root, rel, appinfo->child_relid);
-		}
-	}
-	else
-	{
-		Assert(rte->rtekind == RTE_RELATION);
-		Assert(has_subclass(rte->relid));
-
-		/*
-		 * The rewriter should already have obtained an appropriate lock on
-		 * each relation named in the query.  However, for each child relation
-		 * we add to the query, we must obtain an appropriate lock, because
-		 * this will be the first use of those relations in the
-		 * parse/rewrite/plan pipeline.  Child rels should use the same
-		 * lockmode as their parent.
-		 */
-		Assert(rte->rellockmode != NoLock);
-
-		if (rte->relkind == RELKIND_PARTITIONED_TABLE)
-			expand_partitioned_rtentry(root, rte, rti, rel);
-		else
-			expand_inherited_rtentry(root, rte, rti, rel);
-	}
-}
-
-/*
- * expand_inherited_rtentry
- *		Add entries for all the child tables to the query's rangetable, and
- *		build AppendRelInfo nodes for all the child tables and add them to
- *		root->append_rel_list.
- *
- * Note that the original RTE is considered to represent the whole
- * inheritance set.  The first of the generated RTEs is an RTE for the same
- * table, but with inh = false, to represent the parent table in its role
- * as a simple member of the inheritance set.
- *
- * A childless table is never considered to be an inheritance set. For
- * regular inheritance, a parent RTE must always have at least two associated
- * AppendRelInfos: one corresponding to the parent table as a simple member of
- * inheritance set and one or more corresponding to the actual children.
- */
-static void
-expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti,
-						 RelOptInfo *rel)
-{
-	Oid			parentOID;
-	PlanRowMark *oldrc;
-	LOCKMODE	lockmode = rte->rellockmode;
-	List	   *inhOIDs;
-	ListCell   *l;
-	int			num_children;
-	int			num_children_added = 0;
-
-	Assert(rte->rtekind == RTE_RELATION);
-	Assert(lockmode != NoLock);
-	parentOID = rte->relid;
-
-	/* Scan for all members of inheritance set, acquire needed locks */
-	inhOIDs = find_all_inheritors(parentOID, lockmode, NULL);
-
-	/*
-	 * Check that there's at least one descendant, else treat as no-child
-	 * case.  This could happen despite above has_subclass() check, if table
-	 * once had a child but no longer does.
-	 */
-	num_children = list_length(inhOIDs);
-	if (num_children < 2)
-	{
-		/* Clear flag before returning */
-		rte->inh = false;
-		return;
-	}
-
-	/*
-	 * If parent relation is selected FOR UPDATE/SHARE, preprocess_rowmarks
-	 * should've set isParent = true.  We'll generate a new PlanRowMark for
-	 * each child.
-	 */
-	oldrc = get_plan_rowmark(root->rowMarks, rti);
-	Assert(oldrc == NULL || oldrc->isParent);
-
-	/*
-	 * Must expand PlannerInfo arrays by num_children before we can add
-	 * children.
-	 */
-	expand_planner_arrays(root, num_children);
-
-	foreach(l, inhOIDs)
-	{
-		Oid			childOID = lfirst_oid(l);
-		Relation	newrelation;
-		RangeTblEntry *childrte;
-		Index		childRTindex;
-
-		/* Already locked above. */
-		newrelation = heap_open(childOID, NoLock);
-
-		/*
-		 * It is possible that the parent table has children that are temp
-		 * tables of other backends.  We cannot safely access such tables
-		 * (because of buffering issues), and the best thing to do seems
-		 * to be to silently ignore them.
-		 */
-		if (RELATION_IS_OTHER_TEMP(newrelation))
-		{
-			heap_close(newrelation, lockmode);
-			continue;
-		}
-
-		(void) add_inheritance_child_rel(root, rte, rti, rel, oldrc,
-										 newrelation, &childrte,
-										 &childRTindex);
-		Assert(childrte != NULL);
-		/* All regular inheritance children are leaf children. */
-		Assert(!childrte->inh);
-		Assert(childRTindex > 0);
-
-		/* Close child relations, but keep locks */
-		heap_close(newrelation, NoLock);
-		num_children_added++;
-	}
-
-	/*
-	 * If all children, including the parent (as child rel), were
-	 * excluded, mark the parent rel as empty.  If all the children were temp
-	 * tables, pretend it's a non-inheritance situation; we don't need Append
-	 * node in that case.  The duplicate RTE we added for the parent table is
-	 * harmless, so we don't bother to get rid of it; ditto for the useless
-	 * PlanRowMark node.
-	 */
-	if (num_children_added == 0)
-		mark_dummy_rel(rel);
-	else if (num_children_added == 1)
-		rte->inh = false;
-
-	/*
-	 * Add junk columns needed by the row mark if any and also add the
-	 * relevant expressions to the root parent's reltarget.
-	 */
-	if (oldrc)
-	{
-		List   *tlist = add_rowmark_junk_columns(root, oldrc);
-
-		build_base_rel_tlists(root, tlist);
-	}
-}
-
-/*
- * expand_partitioned_rtentry
- *		Prunes unnecessary partitions of a partitioned table and adds
- *		remaining ones to the Query and the PlannerInfo
- *
- * Partitions are added to the query in order in which they are found in
- * the parent's PartitionDesc.
- *
- * Note: even though only the unpruned partitions will be added to the
- * resulting plan, this still locks *all* partitions via find_all_inheritors
- * in order to avoid partitions being locked in a different order than other
- * places in the backend that may lock partitions.
- */
-static void
-expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
-						   Index parentRTindex, RelOptInfo *parentrel)
-{
-	LOCKMODE	lockmode = parentrte->rellockmode;
-	PlanRowMark *rootrc = NULL;
-	int			i;
-	Bitmapset  *partindexes;
-	Index		rootParentRTindex = parentrel->inh_root_parent > 0 ?
-									parentrel->inh_root_parent :
-									parentRTindex;
-
-	/* If root partitioned table, lock *all* partitions in the tree. */
-	if (parentRTindex == rootParentRTindex)
-		(void) find_all_inheritors(parentrte->relid, lockmode, NULL);
-
-	/*
-	 * Initialize partitioned_child_rels to contain this RT index.
-	 *
-	 * Note that during the set_append_rel_pathlist() phase, values of the
-	 * indexes of partitioned relations that appear down in the tree will be
-	 * bubbled up into root parent's list so that when we've created Paths for
-	 * all the children, the root table's list will contain all such indexes.
-	 */
-	parentrel->partitioned_child_rels = list_make1_int(parentRTindex);
-
-	/* Perform pruning. */
-	partindexes = prune_append_rel_partitions(parentrel);
-
-	/* Must expand PlannerInfo arrays before we can add children. */
-	expand_planner_arrays(root, bms_num_members(partindexes));
-
-	/*
-	 * For partitioned tables, we also store the partition RelOptInfo
-	 * pointers in the parent's RelOptInfo.
-	 */
-	parentrel->part_rels = (RelOptInfo **) palloc0(sizeof(RelOptInfo *) *
-												   parentrel->nparts);
-
-	rootrc = get_plan_rowmark(root->rowMarks, rootParentRTindex);
-	Assert(rootrc == NULL || rootrc->isParent);
-	i = -1;
-	while ((i = bms_next_member(partindexes, i)) >= 0)
-	{
-		Oid		childOID = parentrel->part_oids[i];
-		Relation	newrelation;
-		RelOptInfo *childrel;
-		RangeTblEntry *childrte;
-		Index		childRTindex;
-
-		/* Already locked above. */
-		newrelation = heap_open(childOID, NoLock);
-		Assert(!RELATION_IS_OTHER_TEMP(newrelation));
-
-		/*
-		 * A partitioned child table with 0 children is a dummy rel, so don't
-		 * bother creating planner objects for it.
-		 */
-		if (newrelation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE &&
-			RelationGetPartitionDesc(newrelation)->nparts == 0)
-		{
-			heap_close(newrelation, NoLock);
-			continue;
-		}
-
-		childrel = add_inheritance_child_rel(root, parentrte, parentRTindex,
-											 parentrel, rootrc, newrelation,
-											 &childrte, &childRTindex);
-		Assert(childrel != NULL);
-		parentrel->part_rels[i] = childrel;
-
-		/* Close child relations, but keep locks */
-		heap_close(newrelation, NoLock);
-
-		/* If the child is partitioned itself, expand it too. */
-		if (childrel->part_scheme)
-		{
-			Assert(childrte->inh);
-			expand_partitioned_rtentry(root, childrte, childRTindex,
-									   childrel);
-		}
-	}
-
-	/*
-	 * Add junk columns needed by the row mark if any and also add the
-	 * relevant expressions to the root parent's reltarget.
-	 */
-	if (rootrc)
-	{
-		List   *tlist = add_rowmark_junk_columns(root, rootrc);
-
-		build_base_rel_tlists(root, tlist);
-	}
-}
-
-/*
- * add_inheritance_child_rel
- *		Build a RangeTblEntry, an AppendRelInfo, a PlanRowMark, and finally
- *		a RelOptInfo for an inheritance child relation.
- *
- * The return value is the RelOptInfo that's added.
- *
- * PlanRowMarks still carry the top-parent's RTI, and the top-parent's
- * allMarkTypes field still accumulates values from all descendents.
- *
- * "parentrte" and "parentRTindex" are immediate parent's RTE and
- * RTI. "top_parentrc" is top parent's PlanRowMark.
- */
-static RelOptInfo *
-add_inheritance_child_rel(PlannerInfo *root, RangeTblEntry *parentrte,
-						  Index parentRTindex, RelOptInfo *parentrel,
-						  PlanRowMark *top_parentrc, Relation childrel,
-						  RangeTblEntry **childrte_p, Index *childRTindex_p)
-{
-	Query	   *parse = root->parse;
-	Oid			childOID = RelationGetRelid(childrel);
-	RangeTblEntry *childrte;
-	Index		childRTindex;
-	AppendRelInfo *appinfo;
-	RelOptInfo *childrelopt;
-
-	/*
-	 * Build an RTE for the child, and attach to query's rangetable list. We
-	 * copy most fields of the parent's RTE, but replace relation OID and
-	 * relkind, and set inh appropriately.  Also, set requiredPerms to zero
-	 * since all required permissions checks are done on the original RTE.
-	 * Likewise, set the child's securityQuals to empty, because we only want
-	 * to apply the parent's RLS conditions regardless of what RLS properties
-	 * individual children may have.  (This is an intentional choice to make
-	 * inherited RLS work like regular permissions checks.) The parent
-	 * securityQuals will be propagated to children along with other base
-	 * restriction clauses, so we don't need to do it here.
-	 */
-	childrte = copyObject(parentrte);
-	*childrte_p = childrte;
-	childrte->relid = childOID;
-	childrte->relkind = childrel->rd_rel->relkind;
-	/*
-	 * A partitioned child will need to be expanded as an append parent
-	 * itself, so set its inh to true.
-	 */
-	childrte->inh = (childrte->relkind == RELKIND_PARTITIONED_TABLE);
-	childrte->requiredPerms = 0;
-	childrte->securityQuals = NIL;
-	parse->rtable = lappend(parse->rtable, childrte);
-	childRTindex = list_length(parse->rtable);
-	*childRTindex_p = childRTindex;
-
-	/* Create an AppendRelInfo and add it to planner's global list. */
-	appinfo = make_append_rel_info(parentrel, parentrte,
-								   childrel->rd_att,
-								   childOID,
-								   childrel->rd_rel->reltype,
-								   childRTindex);
-	root->append_rel_list = lappend(root->append_rel_list, appinfo);
-
-	/*
-	 * Translate the column permissions bitmaps to the child's attnums (we
-	 * have to build the translated_vars list before we can do this). But
-	 * if this is the parent table, leave copyObject's result alone.
-	 *
-	 * Note: we need to do this even though the executor won't run any
-	 * permissions checks on the child RTE.  The insertedCols/updatedCols
-	 * bitmaps may be examined for trigger-firing purposes.
-	 */
-	if (childrte->relid != parentrte->relid)
-	{
-		childrte->selectedCols = translate_col_privs(parentrte->selectedCols,
-													 appinfo->translated_vars);
-		childrte->insertedCols = translate_col_privs(parentrte->insertedCols,
-													 appinfo->translated_vars);
-		childrte->updatedCols = translate_col_privs(parentrte->updatedCols,
-													appinfo->translated_vars);
-	}
-
-	/*
-	 * Build a PlanRowMark if parent is marked FOR UPDATE/SHARE.
-	 */
-	if (top_parentrc)
-	{
-		PlanRowMark *childrc = makeNode(PlanRowMark);
-
-		childrc->rti = childRTindex;
-		childrc->prti = top_parentrc->rti;
-		childrc->rowmarkId = top_parentrc->rowmarkId;
-		/* Reselect rowmark type, because relkind might not match parent */
-		childrc->markType = select_rowmark_type(childrte,
-												top_parentrc->strength);
-		childrc->allMarkTypes = (1 << childrc->markType);
-		childrc->strength = top_parentrc->strength;
-		childrc->waitPolicy = top_parentrc->waitPolicy;
-
-		/*
-		 * We mark RowMarks for partitioned child tables as parent RowMarks so
-		 * that the executor ignores them (except their existence means that
-		 * the child tables be locked using appropriate mode).
-		 */
-		childrc->isParent = (childrte->relkind == RELKIND_PARTITIONED_TABLE);
-
-		/* Include child's rowmark type in top parent's allMarkTypes */
-		top_parentrc->allMarkTypes |= childrc->allMarkTypes;
-
-		root->rowMarks = lappend(root->rowMarks, childrc);
-	}
-
-	/*
-	 * Add the RelOptInfo.  Even though we may not really scan this relation
-	 * for reasons such as contradictory quals, we still need need to create
-	 * one, because for every RTE in the query's range table, there must be an
-	 * accompanying RelOptInfo.
-	 */
-
-	/* First, store the RTE and appinfos into planner arrays. */
-	Assert(root->simple_rte_array[childRTindex] == NULL);
-	root->simple_rte_array[childRTindex] = childrte;
-	Assert(root->append_rel_array[childRTindex] == NULL);
-	root->append_rel_array[childRTindex] = appinfo;
-
-	childrelopt = build_append_child_rel(root, parentrel, childRTindex);
-	Assert(childrelopt != NULL);
-
-	return childrelopt;
-}
-
-/*
- * make_inh_translation_list
- *	  Build the list of translations from parent Vars to child Vars for
- *	  an inheritance child.
- *
- * For paranoia's sake, we match type/collation as well as attribute name.
- */
-static void
-make_inh_translation_list(TupleDesc old_tupdesc, TupleDesc new_tupdesc,
-						  Oid from_rel, Oid to_rel,
-						  Index newvarno, List **translated_vars)
-{
-	List	   *vars = NIL;
-	int			oldnatts = old_tupdesc->natts;
-	int			newnatts = new_tupdesc->natts;
-	int			old_attno;
-	int			new_attno = 0;
-
-	for (old_attno = 0; old_attno < oldnatts; old_attno++)
-	{
-		Form_pg_attribute att;
-		char	   *attname;
-		Oid			atttypid;
-		int32		atttypmod;
-		Oid			attcollation;
-
-		att = TupleDescAttr(old_tupdesc, old_attno);
-		if (att->attisdropped)
-		{
-			/* Just put NULL into this list entry */
-			vars = lappend(vars, NULL);
-			continue;
-		}
-		attname = NameStr(att->attname);
-		atttypid = att->atttypid;
-		atttypmod = att->atttypmod;
-		attcollation = att->attcollation;
-
-		/*
-		 * When we are generating the "translation list" for the parent table
-		 * of an inheritance set, no need to search for matches.
-		 */
-		if (from_rel == to_rel)
-		{
-			vars = lappend(vars, makeVar(newvarno,
-										 (AttrNumber) (old_attno + 1),
-										 atttypid,
-										 atttypmod,
-										 attcollation,
-										 0));
-			continue;
-		}
-
-		/*
-		 * Otherwise we have to search for the matching column by name.
-		 * There's no guarantee it'll have the same column position, because
-		 * of cases like ALTER TABLE ADD COLUMN and multiple inheritance.
-		 * However, in simple cases, the relative order of columns is mostly
-		 * the same in both relations, so try the column of newrelation that
-		 * follows immediately after the one that we just found, and if that
-		 * fails, let syscache handle it.
-		 */
-		if (new_attno >= newnatts ||
-			(att = TupleDescAttr(new_tupdesc, new_attno))->attisdropped ||
-			strcmp(attname, NameStr(att->attname)) != 0)
-		{
-			HeapTuple	newtup;
-
-			newtup = SearchSysCacheAttName(to_rel, attname);
-			if (!newtup)
-				elog(ERROR, "could not find inherited attribute \"%s\" of relation \"%s\"",
-					 attname, get_rel_name(to_rel));
-			new_attno = ((Form_pg_attribute) GETSTRUCT(newtup))->attnum - 1;
-			ReleaseSysCache(newtup);
-
-			att = TupleDescAttr(new_tupdesc, new_attno);
-		}
-
-		/* Found it, check type and collation match */
-		if (atttypid != att->atttypid || atttypmod != att->atttypmod)
-			elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's type",
-				 attname, get_rel_name(to_rel));
-		if (attcollation != att->attcollation)
-			elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's collation",
-				 attname, get_rel_name(to_rel));
-
-		vars = lappend(vars, makeVar(newvarno,
-									 (AttrNumber) (new_attno + 1),
-									 atttypid,
-									 atttypmod,
-									 attcollation,
-									 0));
-		new_attno++;
-	}
-
-	*translated_vars = vars;
-}
-
-/*
- * translate_col_privs
- *	  Translate a bitmapset representing per-column privileges from the
- *	  parent rel's attribute numbering to the child's.
- *
- * The only surprise here is that we don't translate a parent whole-row
- * reference into a child whole-row reference.  That would mean requiring
- * permissions on all child columns, which is overly strict, since the
- * query is really only going to reference the inherited columns.  Instead
- * we set the per-column bits for all inherited columns.
- */
-static Bitmapset *
-translate_col_privs(const Bitmapset *parent_privs,
-					List *translated_vars)
-{
-	Bitmapset  *child_privs = NULL;
-	bool		whole_row;
-	int			attno;
-	ListCell   *lc;
-
-	/* System attributes have the same numbers in all tables */
-	for (attno = FirstLowInvalidHeapAttributeNumber + 1; attno < 0; attno++)
-	{
-		if (bms_is_member(attno - FirstLowInvalidHeapAttributeNumber,
-						  parent_privs))
-			child_privs = bms_add_member(child_privs,
-										 attno - FirstLowInvalidHeapAttributeNumber);
-	}
-
-	/* Check if parent has whole-row reference */
-	whole_row = bms_is_member(InvalidAttrNumber - FirstLowInvalidHeapAttributeNumber,
-							  parent_privs);
-
-	/* And now translate the regular user attributes, using the vars list */
-	attno = InvalidAttrNumber;
-	foreach(lc, translated_vars)
-	{
-		Var		   *var = lfirst_node(Var, lc);
-
-		attno++;
-		if (var == NULL)		/* ignore dropped columns */
-			continue;
-		if (whole_row ||
-			bms_is_member(attno - FirstLowInvalidHeapAttributeNumber,
-						  parent_privs))
-			child_privs = bms_add_member(child_privs,
-										 var->varattno - FirstLowInvalidHeapAttributeNumber);
-	}
-
-	return child_privs;
-}
-
-/*
- *	build_append_child_rel
- *		Build a RelOptInfo for child relation of an append rel
- *
- * After creating the RelOptInfo for the given child RT index, it goes on to
- * initialize some of its fields base on the parent RelOptInfo.
- *
- * If the quals in baserestrictinfo turns out to be self-contradictory, the
- * RelOptInfo is marked dummy before returning.
- */
-static RelOptInfo *
-build_append_child_rel(PlannerInfo *root,
-					   RelOptInfo *parent,
-					   Index childRTindex)
-{
-	RelOptInfo *childrel;
-	RangeTblEntry *childRTE = root->simple_rte_array[childRTindex];
-	AppendRelInfo *appinfo = root->append_rel_array[childRTindex];
-	List	   *childquals;
-	ListCell   *lc;
-	bool		have_const_false_cq;
-	Index		cq_min_security;
-
-	/* Build the RelOptInfo. */
-	childrel = build_simple_rel(root, childRTindex, parent);
-
-	/*
-	 * Propagate lateral_relids and lateral_referencers from appendrel
-	 * parent rels to their child rels.  We intentionally give each child rel
-	 * the same minimum parameterization, even though it's quite possible that
-	 * some don't reference all the lateral rels.  This is because any append
-	 * path for the parent will have to have the same parameterization for
-	 * every child anyway, and there's no value in forcing extra
-	 * reparameterize_path() calls.  Similarly, a lateral reference to the
-	 * parent prevents use of otherwise-movable join rels for each child.
-	 */
-	childrel->direct_lateral_relids = parent->direct_lateral_relids;
-	childrel->lateral_relids = parent->lateral_relids;
-	childrel->lateral_referencers = parent->lateral_referencers;
-
-	/*
-	 * We have to copy the parent's quals to the child, with appropriate
-	 * substitution of variables.  However, only the baserestrictinfo
-	 * quals are needed before we can check for constraint exclusion; so
-	 * do that first and then check to see if we can disregard this child.
-	 *
-	 * The child rel's targetlist might contain non-Var expressions, which
-	 * means that substitution into the quals could produce opportunities
-	 * for const-simplification, and perhaps even pseudoconstant quals.
-	 * Therefore, transform each RestrictInfo separately to see if it
-	 * reduces to a constant or pseudoconstant.  (We must process them
-	 * separately to keep track of the security level of each qual.)
-	 */
-	childquals = false;
-	cq_min_security = UINT_MAX;
-	have_const_false_cq = false;
-	foreach(lc, parent->baserestrictinfo)
-	{
-		RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
-		Node	   *childqual = (Node *) rinfo->clause;
-		ListCell   *lc2;
-
-		Assert(IsA(rinfo, RestrictInfo));
-		childqual = adjust_appendrel_attrs(root, childqual,
-										   1, &appinfo);
-		childqual = eval_const_expressions(root, childqual);
-		/* check for flat-out constant */
-		if (childqual && IsA(childqual, Const))
-		{
-			if (((Const *) childqual)->constisnull ||
-				!DatumGetBool(((Const *) childqual)->constvalue))
-			{
-				/* Restriction reduces to constant FALSE or NULL */
-				have_const_false_cq = true;
-				break;
-			}
-			/* Restriction reduces to constant TRUE, so drop it */
-			continue;
-		}
-		/* might have gotten an AND clause, if so flatten it */
-		foreach(lc2, make_ands_implicit((Expr *) childqual))
-		{
-			Node	   *onecq = (Node *) lfirst(lc2);
-			bool		pseudoconstant;
-
-			/* check for pseudoconstant (no Vars or volatile functions) */
-			pseudoconstant =
-					!contain_vars_of_level(onecq, 0) &&
-					!contain_volatile_functions(onecq);
-			if (pseudoconstant)
-			{
-				/* tell createplan.c to check for gating quals */
-				root->hasPseudoConstantQuals = true;
-			}
-			/* reconstitute RestrictInfo with appropriate properties */
-			childquals = lappend(childquals,
-								 make_restrictinfo((Expr *) onecq,
-												   rinfo->is_pushed_down,
-												   rinfo->outerjoin_delayed,
-												   pseudoconstant,
-												   rinfo->security_level,
-												   NULL, NULL, NULL));
-			cq_min_security = Min(cq_min_security, rinfo->security_level);
-		}
-	}
-
-	/*
-	 * In addition to the quals inherited from the parent, we might
-	 * have securityQuals associated with this particular child node.
-	 * (Currently this can only happen in appendrels originating from
-	 * UNION ALL; inheritance child tables don't have their own
-	 * securityQuals.)	Pull any such securityQuals up into the
-	 * baserestrictinfo for the child.  This is similar to
-	 * process_security_barrier_quals() for the parent rel, except
-	 * that we can't make any general deductions from such quals,
-	 * since they don't hold for the whole appendrel.
-	 */
-	if (childRTE->securityQuals)
-	{
-		Index		security_level = 0;
-
-		foreach(lc, childRTE->securityQuals)
-		{
-			List	   *qualset = (List *) lfirst(lc);
-			ListCell   *lc2;
-
-			foreach(lc2, qualset)
-			{
-				Expr	   *qual = (Expr *) lfirst(lc2);
-
-				/*
-				 * not likely that we'd see constants here, so no
-				 * check
-				 */
-				childquals = lappend(childquals,
-									 make_restrictinfo(qual,
-													   true,
-													   false,
-													   false,
-													   security_level,
-													   NULL, NULL,
-													   NULL));
-				cq_min_security = Min(cq_min_security, security_level);
-			}
-			security_level++;
-		}
-		Assert(security_level <= root->qual_security_level);
-	}
-
-	/* Set child's version of baserestrictinfo. */
-	childrel->baserestrictinfo = childquals;
-	childrel->baserestrict_min_security = cq_min_security;
-
-	if (have_const_false_cq)
-	{
-		/*
-		 * Some restriction clause reduced to constant FALSE or NULL after
-		 * substitution, so this child need not be scanned.
-		 */
-		set_dummy_rel_pathlist(childrel);
-	}
-
-	return childrel;
-}
-
-/*
- * add_rowmark_junk_columns
- * 		Add necessary junk columns for rowmarked inheritance parent rel.
- *
- * These values are needed for locking of rels selected FOR UPDATE/SHARE, and
- * to do EvalPlanQual rechecking.  See comments for PlanRowMark in
- * plannodes.h.
- */
-static List *
-add_rowmark_junk_columns(PlannerInfo *root, PlanRowMark *rc)
-{
-	List   *tlist = root->processed_tlist;
-	Var		   *var;
-	char		resname[32];
-	TargetEntry *tle;
-
-	if (rc->allMarkTypes & ~(1 << ROW_MARK_COPY))
-	{
-		/* Need to fetch TID */
-		var = makeVar(rc->rti,
-					  SelfItemPointerAttributeNumber,
-					  TIDOID,
-					  -1,
-					  InvalidOid,
-					  0);
-		snprintf(resname, sizeof(resname), "ctid%u", rc->rowmarkId);
-		tle = makeTargetEntry((Expr *) var,
-							  list_length(tlist) + 1,
-							  pstrdup(resname),
-							  true);
-		tlist = lappend(tlist, tle);
-	}
-	if (rc->allMarkTypes & (1 << ROW_MARK_COPY))
-	{
-		/* Need the whole row as a junk var */
-		var = makeWholeRowVar(root->simple_rte_array[rc->rti],
-							  rc->rti,
-							  0,
-							  false);
-		snprintf(resname, sizeof(resname), "wholerow%u", rc->rowmarkId);
-		tle = makeTargetEntry((Expr *) var,
-							  list_length(tlist) + 1,
-							  pstrdup(resname),
-							  true);
-		tlist = lappend(tlist, tle);
-	}
-
-	/* For inheritance cases, always fetch the tableoid too. */
-	var = makeVar(rc->rti,
-				  TableOidAttributeNumber,
-				  OIDOID,
-				  -1,
-				  InvalidOid,
-				  0);
-	snprintf(resname, sizeof(resname), "tableoid%u", rc->rowmarkId);
-	tle = makeTargetEntry((Expr *) var,
-						  list_length(tlist) + 1,
-						  pstrdup(resname),
-						  true);
-	tlist = lappend(tlist, tle);
-
-	return tlist;
-}
-
-AppendRelInfo *
-make_append_rel_info(RelOptInfo *parentrel, RangeTblEntry *parentrte,
-					 TupleDesc childdesc, Oid childoid, Oid childreltype,
-					 Index childRTindex)
-{
-	AppendRelInfo  *appinfo = makeNode(AppendRelInfo);
-
-	appinfo->parent_relid = parentrel->relid;
-	appinfo->child_relid = childRTindex;
-	appinfo->parent_reltype = parentrel->reltype;
-	appinfo->child_reltype = childreltype;
-	make_inh_translation_list(parentrel->tupdesc, childdesc,
-							  parentrte->relid, childoid,
-							  childRTindex,
-							  &appinfo->translated_vars);
-	appinfo->parent_reloid = parentrte->relid;
-
-	return appinfo;
-}
-
-/*
- * adjust_appendrel_attrs
- *	  Copy the specified query or expression and translate Vars referring to a
- *	  parent rel to refer to the corresponding child rel instead.  We also
- *	  update rtindexes appearing outside Vars, such as resultRelation and
- *	  jointree relids.
- *
- * Note: this is only applied after conversion of sublinks to subplans,
- * so we don't need to cope with recursion into sub-queries.
- *
- * Note: this is not hugely different from what pullup_replace_vars() does;
- * maybe we should try to fold the two routines together.
- */
-Node *
-adjust_appendrel_attrs(PlannerInfo *root, Node *node, int nappinfos,
-					   AppendRelInfo **appinfos)
-{
-	Node	   *result;
-	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);
-
-	/*
-	 * Must be prepared to start with a Query or a bare expression tree.
-	 */
-	if (node && IsA(node, Query))
-	{
-		Query	   *newnode;
-		int			cnt;
-
-		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;
-}
-
-static Node *
-adjust_appendrel_attrs_mutator(Node *node,
-							   adjust_appendrel_attrs_context *context)
-{
-	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;
-
-		for (cnt = 0; cnt < nappinfos; cnt++)
-		{
-			if (var->varno == appinfos[cnt]->parent_relid)
-			{
-				appinfo = appinfos[cnt];
-				break;
-			}
-		}
-
-		if (var->varlevelsup == 0 && appinfo)
-		{
-			var->varno = appinfo->child_relid;
-			var->varnoold = appinfo->child_relid;
-			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));
-				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;
-
-					return (Node *) rowexpr;
-				}
-			}
-			/* system attributes don't need any other translation */
-		}
-		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, 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 */
-		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, context->nappinfos,
-											  context->appinfos);
-		return (Node *) phv;
-	}
-
-	/*
-	 * This is needed, because inheritance_make_rel_from_joinlist needs to
-	 * translate root->join_info_list executing make_rel_from_joinlist for a
-	 * given child.
-	 */
-	if (IsA(node, SpecialJoinInfo))
-	{
-		SpecialJoinInfo *oldinfo = (SpecialJoinInfo *) node;
-		SpecialJoinInfo *newinfo = makeNode(SpecialJoinInfo);
-
-		memcpy(newinfo, oldinfo, sizeof(SpecialJoinInfo));
-		newinfo->min_lefthand = adjust_child_relids(oldinfo->min_lefthand,
-													context->nappinfos,
-													context->appinfos);
-		newinfo->min_righthand = adjust_child_relids(oldinfo->min_righthand,
-													 context->nappinfos,
-													 context->appinfos);
-		newinfo->syn_lefthand = adjust_child_relids(oldinfo->syn_lefthand,
-													context->nappinfos,
-													context->appinfos);
-		newinfo->syn_righthand = adjust_child_relids(oldinfo->syn_righthand,
-													 context->nappinfos,
-													 context->appinfos);
-		newinfo->semi_rhs_exprs =
-					(List *) expression_tree_mutator((Node *)
-													 oldinfo->semi_rhs_exprs,
-													 adjust_appendrel_attrs_mutator,
-													 (void *) context);
-		return (Node *) newinfo;
-	}
-
-	/* Shouldn't need to handle planner auxiliary nodes here */
-	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 */
-		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->nullable_relids = adjust_child_relids(oldinfo->nullable_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));
-
-	return expression_tree_mutator(node, adjust_appendrel_attrs_mutator,
-								   (void *) context);
-}
-
-/*
- * Substitute child relids for parent relids in a Relid set.  The array of
- * appinfos specifies the substitutions to be performed.
- */
-static Relids
-adjust_child_relids(Relids relids, int nappinfos, AppendRelInfo **appinfos)
-{
-	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;
-}
-
-/*
- * Replace any relid present in top_parent_relids with its child in
- * child_relids. Members of child_relids can be multiple levels below top
- * parent in the partition hierarchy.
- */
-Relids
-adjust_child_relids_multilevel(PlannerInfo *root, Relids relids,
-							   Relids child_relids, Relids top_parent_relids)
-{
-	AppendRelInfo **appinfos;
-	int			nappinfos;
-	Relids		parent_relids = NULL;
-	Relids		result;
-	Relids		tmp_result = NULL;
-	int			cnt;
-
-	/*
-	 * If the given relids set doesn't contain any of the top parent relids,
-	 * it will remain unchanged.
-	 */
-	if (!bms_overlap(relids, top_parent_relids))
-		return relids;
-
-	appinfos = find_appinfos_by_relids(root, child_relids, &nappinfos);
-
-	/* Construct relids set for the immediate parent of the given child. */
-	for (cnt = 0; cnt < nappinfos; cnt++)
-	{
-		AppendRelInfo *appinfo = appinfos[cnt];
-
-		parent_relids = bms_add_member(parent_relids, appinfo->parent_relid);
-	}
-
-	/* Recurse if immediate parent is not the top parent. */
-	if (!bms_equal(parent_relids, top_parent_relids))
-	{
-		tmp_result = adjust_child_relids_multilevel(root, relids,
-													parent_relids,
-													top_parent_relids);
-		relids = tmp_result;
-	}
-
-	result = adjust_child_relids(relids, nappinfos, appinfos);
-
-	/* Free memory consumed by any intermediate result. */
-	if (tmp_result)
-		bms_free(tmp_result);
-	bms_free(parent_relids);
-	pfree(appinfos);
-
-	return result;
-}
-
-/*
- * 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.
- */
-static List *
-adjust_inherited_tlist(List *tlist, AppendRelInfo *context)
-{
-	bool		changed_it = false;
-	ListCell   *tl;
-	List	   *new_tlist;
-	bool		more;
-	int			attrno;
-
-	/* 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)
-	{
-		TargetEntry *tle = (TargetEntry *) lfirst(tl);
-		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))
-			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);
-		if (childvar == NULL || !IsA(childvar, Var))
-			elog(ERROR, "attribute %d of relation \"%s\" does not exist",
-				 tle->resno, get_rel_name(context->parent_reloid));
-
-		if (tle->resno != childvar->varattno)
-		{
-			tle->resno = childvar->varattno;
-			changed_it = true;
-		}
-	}
-
-	/*
-	 * 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;
-
-	new_tlist = NIL;
-	more = true;
-	for (attrno = 1; more; attrno++)
-	{
-		more = false;
-		foreach(tl, tlist)
-		{
-			TargetEntry *tle = (TargetEntry *) lfirst(tl);
-
-			if (tle->resjunk)
-				continue;		/* ignore junk items */
-
-			if (tle->resno == attrno)
-				new_tlist = lappend(new_tlist, tle);
-			else if (tle->resno > attrno)
-				more = true;
-		}
-	}
-
-	foreach(tl, tlist)
-	{
-		TargetEntry *tle = (TargetEntry *) lfirst(tl);
-
-		if (!tle->resjunk)
-			continue;			/* here, ignore non-junk items */
-
-		tle->resno = attrno;
-		new_tlist = lappend(new_tlist, tle);
-		attrno++;
-	}
-
-	return new_tlist;
-}
-
-/*
- * adjust_appendrel_attrs_multilevel
- *	  Apply Var translations from a toplevel appendrel parent down to a child.
- *
- * In some cases we need to translate expressions referencing a parent relation
- * to reference an appendrel child that's multiple levels removed from it.
- */
-Node *
-adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node,
-								  Relids child_relids,
-								  Relids top_parent_relids)
-{
-	AppendRelInfo **appinfos;
-	Bitmapset  *parent_relids = NULL;
-	int			nappinfos;
-	int			cnt;
-
-	Assert(bms_num_members(child_relids) == bms_num_members(top_parent_relids));
-
-	appinfos = find_appinfos_by_relids(root, child_relids, &nappinfos);
-
-	/* Construct relids set for the immediate parent of given child. */
-	for (cnt = 0; cnt < nappinfos; cnt++)
-	{
-		AppendRelInfo *appinfo = appinfos[cnt];
-
-		parent_relids = bms_add_member(parent_relids, appinfo->parent_relid);
-	}
-
-	/* Recurse if immediate parent is not the top parent. */
-	if (!bms_equal(parent_relids, top_parent_relids))
-		node = adjust_appendrel_attrs_multilevel(root, node, parent_relids,
-												 top_parent_relids);
-
-	/* Now translate for this child */
-	node = adjust_appendrel_attrs(root, node, nappinfos, appinfos);
-
-	pfree(appinfos);
-
-	return node;
-}
-
-/*
- * Construct the SpecialJoinInfo for a child-join by translating
- * SpecialJoinInfo for the join between parents. left_relids and right_relids
- * are the relids of left and right side of the join respectively.
- */
-SpecialJoinInfo *
-build_child_join_sjinfo(PlannerInfo *root, SpecialJoinInfo *parent_sjinfo,
-						Relids left_relids, Relids right_relids)
-{
-	SpecialJoinInfo *sjinfo = makeNode(SpecialJoinInfo);
-	AppendRelInfo **left_appinfos;
-	int			left_nappinfos;
-	AppendRelInfo **right_appinfos;
-	int			right_nappinfos;
-
-	memcpy(sjinfo, parent_sjinfo, sizeof(SpecialJoinInfo));
-	left_appinfos = find_appinfos_by_relids(root, left_relids,
-											&left_nappinfos);
-	right_appinfos = find_appinfos_by_relids(root, right_relids,
-											 &right_nappinfos);
-
-	sjinfo->min_lefthand = adjust_child_relids(sjinfo->min_lefthand,
-											   left_nappinfos, left_appinfos);
-	sjinfo->min_righthand = adjust_child_relids(sjinfo->min_righthand,
-												right_nappinfos,
-												right_appinfos);
-	sjinfo->syn_lefthand = adjust_child_relids(sjinfo->syn_lefthand,
-											   left_nappinfos, left_appinfos);
-	sjinfo->syn_righthand = adjust_child_relids(sjinfo->syn_righthand,
-												right_nappinfos,
-												right_appinfos);
-	sjinfo->semi_rhs_exprs = (List *) adjust_appendrel_attrs(root,
-															 (Node *) sjinfo->semi_rhs_exprs,
-															 right_nappinfos,
-															 right_appinfos);
-
-	pfree(left_appinfos);
-	pfree(right_appinfos);
-
-	return sjinfo;
-}
-
-/*
- * find_appinfos_by_relids
- * 		Find AppendRelInfo structures for all relations specified by relids.
- *
- * The AppendRelInfos are returned in an array, which can be pfree'd by the
- * caller. *nappinfos is set to the number of entries in the array.
- */
-AppendRelInfo **
-find_appinfos_by_relids(PlannerInfo *root, Relids relids, int *nappinfos)
-{
-	AppendRelInfo **appinfos;
-	int			cnt = 0;
-	int			i;
-
-	*nappinfos = bms_num_members(relids);
-	appinfos = (AppendRelInfo **) palloc(sizeof(AppendRelInfo *) * *nappinfos);
-
-	i = -1;
-	while ((i = bms_next_member(relids, i)) >= 0)
-	{
-		AppendRelInfo *appinfo = root->append_rel_array[i];
-
-		if (!appinfo)
-			elog(ERROR, "child rel %d not found in append_rel_array", i);
-
-		appinfos[cnt++] = appinfo;
-	}
-	return appinfos;
-}
diff --git a/src/backend/optimizer/util/Makefile b/src/backend/optimizer/util/Makefile
index da9ccf32b4..d166030a10 100644
--- a/src/backend/optimizer/util/Makefile
+++ b/src/backend/optimizer/util/Makefile
@@ -12,7 +12,8 @@ subdir = src/backend/optimizer/util
 top_builddir = ../../../..
 include $(top_builddir)/src/Makefile.global
 
-OBJS = clauses.o joininfo.o orclauses.o pathnode.o placeholder.o \
-	   plancat.o predtest.o relnode.o restrictinfo.o tlist.o var.o
+OBJS = append.o appendinfo.o clauses.o joininfo.o orclauses.o pathnode.o \
+	   placeholder.o plancat.o predtest.o relnode.o restrictinfo.o tlist.o \
+	   var.o
 
 include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/optimizer/util/append.c b/src/backend/optimizer/util/append.c
new file mode 100644
index 0000000000..d2ad80034f
--- /dev/null
+++ b/src/backend/optimizer/util/append.c
@@ -0,0 +1,777 @@
+/*-------------------------------------------------------------------------
+ *
+ * append.c
+ *	  Routines to process children of an appendrel parent
+ *
+ * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/optimizer/path/append.c
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include <limits.h>
+
+#include "access/sysattr.h"
+#include "catalog/partition.h"
+#include "catalog/pg_class.h"
+#include "catalog/pg_inherits.h"
+#include "catalog/pg_type.h"
+#include "nodes/makefuncs.h"
+#include "optimizer/append.h"
+#include "optimizer/appendinfo.h"
+#include "optimizer/clauses.h"
+#include "optimizer/pathnode.h"
+#include "optimizer/paths.h"
+#include "optimizer/plancat.h"
+#include "optimizer/planmain.h"
+#include "optimizer/planner.h"
+#include "optimizer/prep.h"
+#include "optimizer/restrictinfo.h"
+#include "optimizer/tlist.h"
+#include "optimizer/var.h"
+#include "partitioning/partprune.h"
+#include "utils/rel.h"
+
+static void expand_append_rtentry(PlannerInfo *root, RelOptInfo *rel,
+					  RangeTblEntry *rte, Index rti);
+static void expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte,
+						 Index rti, RelOptInfo *rel);
+static void expand_partitioned_rtentry(PlannerInfo *root,
+						   RangeTblEntry *parentrte,
+						   Index parentRTindex, RelOptInfo *parentrel);
+static RelOptInfo *add_inheritance_child_rel(PlannerInfo *root,
+						  RangeTblEntry *parentrte,
+						  Index parentRTindex, RelOptInfo *parentrel,
+						  PlanRowMark *top_parentrc, Relation childrel,
+						  RangeTblEntry **childrte_p, Index *childRTindex_p);
+static RelOptInfo *build_append_child_rel(PlannerInfo *root,
+					   RelOptInfo *parent,
+					   Index childRTindex);
+static List *add_rowmark_junk_columns(PlannerInfo *root, PlanRowMark *rc);
+
+
+/*
+ * expand_inherited_tables
+ *		Expand each rangetable entry that represents an inheritance set
+ *		into an "append relation".  At the conclusion of this process,
+ *		the "inh" flag is set in all and only those RTEs that are append
+ *		relation parents.
+ */
+void
+expand_inherited_tables(PlannerInfo *root)
+{
+	int			orig_rtable_size;
+	Index		rti;
+
+	Assert(root->simple_rel_array_size > 0);
+	orig_rtable_size = root->simple_rel_array_size;
+
+	/*
+	 * expand_append_rtentry may add RTEs to parse->rtable. The function is
+	 * expected to recursively handle any RTEs that it creates with inh=true.
+	 * So just scan as far as the original end of the rtable list.
+	 */
+	for (rti = 1; rti < orig_rtable_size; rti++)
+	{
+		RelOptInfo *brel = root->simple_rel_array[rti];
+		RangeTblEntry *rte = root->simple_rte_array[rti];
+
+		/* there may be empty slots corresponding to non-baserel RTEs */
+		if (brel == NULL)
+			continue;
+
+		if (rte->inh)
+			expand_append_rtentry(root, brel, rte, rti);
+	}
+}
+
+/*
+ * expand_append_rtentry
+ *		This initializes RelOptInfos for an appendrel's child relations, if
+ *		any
+ *
+ * 'rel' is the appendrel parent, whose range table entry ('rte') has been
+ * marked to require adding children.  An appendrel parent could either
+ * be a subquery (if we flattened UNION ALL query) or a table that's known
+ * to have inheritance children.  The latter consists of both regular
+ * inheritance parents and partitioned tables.
+ *
+ * For a subquery parent, there is not much to be done here because the
+ * children's RTEs are already present in the query, so we just initialize
+ * RelOptInfos for them.  Also, the AppendRelInfos for child subqueries
+ * have already been added.
+ *
+ * For tables, we need to add the children to the range table and initialize
+ * AppendRelInfos, RelOptInfos, and PlanRowMarks (if any) for them.  For
+ * a partitioned parent, we only add the children remaining after pruning.
+ * For regular inheritance parents, we find the children using
+ * find_all_inheritors and add all of them.
+ *
+ * If it turns out that there are no children, then we set rte->inh to false
+ * to let the caller know that only the parent table needs to be scanned.  The
+ * caller can accordingly switch to a non-Append path.  For a partitioned
+ * parent, that means an empty relation because parents themselves contain no
+ * data.
+ *
+ * For the regular inheritance case, the parent also gets another RTE with
+ * inh = false to represent it as an appendrel child.  The original RTE is
+ * considered to represent the whole inheritance set.
+ */
+static void
+expand_append_rtentry(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte,
+					  Index rti)
+{
+	Assert(rte->inh);
+	/* Inheritance parent (partitioned or not) or UNION ALL parent subquery. */
+	Assert(rte->rtekind == RTE_RELATION || rte->rtekind == RTE_SUBQUERY);
+
+	/*
+	 * UNION ALL children already got RTEs and AppendRelInfos, so just build
+	 * RelOptInfos and return.
+	 *
+	 * It might be a bit odd that this code is in this, because there is
+	 * nothing to expand really.
+	 */
+	if (rte->rtekind == RTE_SUBQUERY)
+	{
+		ListCell   *l;
+
+		/*
+		 * We don't need to use expand_planner_arrays in this case, because
+		 * no new child RTEs are created.  setup_simple_rel_arrays() and
+		 * setup_append_rel_array would've considered these child RTEs when
+		 * allocating space for various arrays.
+		 */
+		foreach(l, root->append_rel_list)
+		{
+			AppendRelInfo *appinfo = lfirst(l);
+			Index		childRTindex = appinfo->child_relid;
+
+			if (appinfo->parent_relid != rti)
+				continue;
+
+			Assert(childRTindex < root->simple_rel_array_size);
+			Assert(root->simple_rte_array[childRTindex] != NULL);
+
+			/*
+			 * We set the correct value of baserestricinfo and
+			 * baserestrict_min_security below.
+			 */
+			root->simple_rel_array[childRTindex] =
+				build_append_child_rel(root, rel, appinfo->child_relid);
+		}
+	}
+	else
+	{
+		Assert(rte->rtekind == RTE_RELATION);
+		Assert(has_subclass(rte->relid));
+
+		/*
+		 * The rewriter should already have obtained an appropriate lock on
+		 * each relation named in the query.  However, for each child relation
+		 * we add to the query, we must obtain an appropriate lock, because
+		 * this will be the first use of those relations in the
+		 * parse/rewrite/plan pipeline.  Child rels should use the same
+		 * lockmode as their parent.
+		 */
+		Assert(rte->rellockmode != NoLock);
+
+		if (rte->relkind == RELKIND_PARTITIONED_TABLE)
+			expand_partitioned_rtentry(root, rte, rti, rel);
+		else
+			expand_inherited_rtentry(root, rte, rti, rel);
+	}
+}
+
+/*
+ * expand_inherited_rtentry
+ *		Add entries for all the child tables to the query's rangetable, and
+ *		build AppendRelInfo nodes for all the child tables and add them to
+ *		root->append_rel_list.
+ *
+ * Note that the original RTE is considered to represent the whole
+ * inheritance set.  The first of the generated RTEs is an RTE for the same
+ * table, but with inh = false, to represent the parent table in its role
+ * as a simple member of the inheritance set.
+ *
+ * A childless table is never considered to be an inheritance set. For
+ * regular inheritance, a parent RTE must always have at least two associated
+ * AppendRelInfos: one corresponding to the parent table as a simple member of
+ * inheritance set and one or more corresponding to the actual children.
+ */
+static void
+expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti,
+						 RelOptInfo *rel)
+{
+	Oid			parentOID;
+	PlanRowMark *oldrc;
+	LOCKMODE	lockmode = rte->rellockmode;
+	List	   *inhOIDs;
+	ListCell   *l;
+	int			num_children;
+	int			num_children_added = 0;
+
+	Assert(rte->rtekind == RTE_RELATION);
+	Assert(lockmode != NoLock);
+	parentOID = rte->relid;
+
+	/* Scan for all members of inheritance set, acquire needed locks */
+	inhOIDs = find_all_inheritors(parentOID, lockmode, NULL);
+
+	/*
+	 * Check that there's at least one descendant, else treat as no-child
+	 * case.  This could happen despite above has_subclass() check, if table
+	 * once had a child but no longer does.
+	 */
+	num_children = list_length(inhOIDs);
+	if (num_children < 2)
+	{
+		/* Clear flag before returning */
+		rte->inh = false;
+		return;
+	}
+
+	/*
+	 * If parent relation is selected FOR UPDATE/SHARE, preprocess_rowmarks
+	 * should've set isParent = true.  We'll generate a new PlanRowMark for
+	 * each child.
+	 */
+	oldrc = get_plan_rowmark(root->rowMarks, rti);
+	Assert(oldrc == NULL || oldrc->isParent);
+
+	/*
+	 * Must expand PlannerInfo arrays by num_children before we can add
+	 * children.
+	 */
+	expand_planner_arrays(root, num_children);
+
+	foreach(l, inhOIDs)
+	{
+		Oid			childOID = lfirst_oid(l);
+		Relation	newrelation;
+		RangeTblEntry *childrte;
+		Index		childRTindex;
+
+		/* Already locked above. */
+		newrelation = heap_open(childOID, NoLock);
+
+		/*
+		 * It is possible that the parent table has children that are temp
+		 * tables of other backends.  We cannot safely access such tables
+		 * (because of buffering issues), and the best thing to do seems
+		 * to be to silently ignore them.
+		 */
+		if (RELATION_IS_OTHER_TEMP(newrelation))
+		{
+			heap_close(newrelation, lockmode);
+			continue;
+		}
+
+		(void) add_inheritance_child_rel(root, rte, rti, rel, oldrc,
+										 newrelation, &childrte,
+										 &childRTindex);
+		Assert(childrte != NULL);
+		/* All regular inheritance children are leaf children. */
+		Assert(!childrte->inh);
+		Assert(childRTindex > 0);
+
+		/* Close child relations, but keep locks */
+		heap_close(newrelation, NoLock);
+		num_children_added++;
+	}
+
+	/*
+	 * If all children, including the parent (as child rel), were
+	 * excluded, mark the parent rel as empty.  If all the children were temp
+	 * tables, pretend it's a non-inheritance situation; we don't need Append
+	 * node in that case.  The duplicate RTE we added for the parent table is
+	 * harmless, so we don't bother to get rid of it; ditto for the useless
+	 * PlanRowMark node.
+	 */
+	if (num_children_added == 0)
+		mark_dummy_rel(rel);
+	else if (num_children_added == 1)
+		rte->inh = false;
+
+	/*
+	 * Add junk columns needed by the row mark if any and also add the
+	 * relevant expressions to the root parent's reltarget.
+	 */
+	if (oldrc)
+	{
+		List   *tlist = add_rowmark_junk_columns(root, oldrc);
+
+		build_base_rel_tlists(root, tlist);
+	}
+}
+
+/*
+ * expand_partitioned_rtentry
+ *		Prunes unnecessary partitions of a partitioned table and adds
+ *		remaining ones to the Query and the PlannerInfo
+ *
+ * Partitions are added to the query in order in which they are found in
+ * the parent's PartitionDesc.
+ *
+ * Note: even though only the unpruned partitions will be added to the
+ * resulting plan, this still locks *all* partitions via find_all_inheritors
+ * in order to avoid partitions being locked in a different order than other
+ * places in the backend that may lock partitions.
+ */
+static void
+expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
+						   Index parentRTindex, RelOptInfo *parentrel)
+{
+	LOCKMODE	lockmode = parentrte->rellockmode;
+	PlanRowMark *rootrc = NULL;
+	int			i;
+	Bitmapset  *partindexes;
+	Index		rootParentRTindex = parentrel->inh_root_parent > 0 ?
+									parentrel->inh_root_parent :
+									parentRTindex;
+
+	/* If root partitioned table, lock *all* partitions in the tree. */
+	if (parentRTindex == rootParentRTindex)
+		(void) find_all_inheritors(parentrte->relid, lockmode, NULL);
+
+	/*
+	 * Initialize partitioned_child_rels to contain this RT index.
+	 *
+	 * Note that during the set_append_rel_pathlist() phase, values of the
+	 * indexes of partitioned relations that appear down in the tree will be
+	 * bubbled up into root parent's list so that when we've created Paths for
+	 * all the children, the root table's list will contain all such indexes.
+	 */
+	parentrel->partitioned_child_rels = list_make1_int(parentRTindex);
+
+	/* Perform pruning. */
+	partindexes = prune_append_rel_partitions(parentrel);
+
+	/* Must expand PlannerInfo arrays before we can add children. */
+	expand_planner_arrays(root, bms_num_members(partindexes));
+
+	/*
+	 * For partitioned tables, we also store the partition RelOptInfo
+	 * pointers in the parent's RelOptInfo.
+	 */
+	parentrel->part_rels = (RelOptInfo **) palloc0(sizeof(RelOptInfo *) *
+												   parentrel->nparts);
+
+	rootrc = get_plan_rowmark(root->rowMarks, rootParentRTindex);
+	Assert(rootrc == NULL || rootrc->isParent);
+	i = -1;
+	while ((i = bms_next_member(partindexes, i)) >= 0)
+	{
+		Oid		childOID = parentrel->part_oids[i];
+		Relation	newrelation;
+		RelOptInfo *childrel;
+		RangeTblEntry *childrte;
+		Index		childRTindex;
+
+		/* Already locked above. */
+		newrelation = heap_open(childOID, NoLock);
+		Assert(!RELATION_IS_OTHER_TEMP(newrelation));
+
+		/*
+		 * A partitioned child table with 0 children is a dummy rel, so don't
+		 * bother creating planner objects for it.
+		 */
+		if (newrelation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE &&
+			RelationGetPartitionDesc(newrelation)->nparts == 0)
+		{
+			heap_close(newrelation, NoLock);
+			continue;
+		}
+
+		childrel = add_inheritance_child_rel(root, parentrte, parentRTindex,
+											 parentrel, rootrc, newrelation,
+											 &childrte, &childRTindex);
+		Assert(childrel != NULL);
+		parentrel->part_rels[i] = childrel;
+
+		/* Close child relations, but keep locks */
+		heap_close(newrelation, NoLock);
+
+		/* If the child is partitioned itself, expand it too. */
+		if (childrel->part_scheme)
+		{
+			Assert(childrte->inh);
+			expand_partitioned_rtentry(root, childrte, childRTindex,
+									   childrel);
+		}
+	}
+
+	/*
+	 * Add junk columns needed by the row mark if any and also add the
+	 * relevant expressions to the root parent's reltarget.
+	 */
+	if (rootrc)
+	{
+		List   *tlist = add_rowmark_junk_columns(root, rootrc);
+
+		build_base_rel_tlists(root, tlist);
+	}
+}
+
+/*
+ * add_inheritance_child_rel
+ *		Build a RangeTblEntry, an AppendRelInfo, a PlanRowMark, and finally
+ *		a RelOptInfo for an inheritance child relation.
+ *
+ * The return value is the RelOptInfo that's added.
+ *
+ * PlanRowMarks still carry the top-parent's RTI, and the top-parent's
+ * allMarkTypes field still accumulates values from all descendents.
+ *
+ * "parentrte" and "parentRTindex" are immediate parent's RTE and
+ * RTI. "top_parentrc" is top parent's PlanRowMark.
+ */
+static RelOptInfo *
+add_inheritance_child_rel(PlannerInfo *root, RangeTblEntry *parentrte,
+						  Index parentRTindex, RelOptInfo *parentrel,
+						  PlanRowMark *top_parentrc, Relation childrel,
+						  RangeTblEntry **childrte_p, Index *childRTindex_p)
+{
+	Query	   *parse = root->parse;
+	Oid			childOID = RelationGetRelid(childrel);
+	RangeTblEntry *childrte;
+	Index		childRTindex;
+	AppendRelInfo *appinfo;
+	RelOptInfo *childrelopt;
+
+	/*
+	 * Build an RTE for the child, and attach to query's rangetable list. We
+	 * copy most fields of the parent's RTE, but replace relation OID and
+	 * relkind, and set inh appropriately.  Also, set requiredPerms to zero
+	 * since all required permissions checks are done on the original RTE.
+	 * Likewise, set the child's securityQuals to empty, because we only want
+	 * to apply the parent's RLS conditions regardless of what RLS properties
+	 * individual children may have.  (This is an intentional choice to make
+	 * inherited RLS work like regular permissions checks.) The parent
+	 * securityQuals will be propagated to children along with other base
+	 * restriction clauses, so we don't need to do it here.
+	 */
+	childrte = copyObject(parentrte);
+	*childrte_p = childrte;
+	childrte->relid = childOID;
+	childrte->relkind = childrel->rd_rel->relkind;
+	/*
+	 * A partitioned child will need to be expanded as an append parent
+	 * itself, so set its inh to true.
+	 */
+	childrte->inh = (childrte->relkind == RELKIND_PARTITIONED_TABLE);
+	childrte->requiredPerms = 0;
+	childrte->securityQuals = NIL;
+	parse->rtable = lappend(parse->rtable, childrte);
+	childRTindex = list_length(parse->rtable);
+	*childRTindex_p = childRTindex;
+
+	/* Create an AppendRelInfo and add it to planner's global list. */
+	appinfo = make_append_rel_info(parentrel, parentrte,
+								   childrel->rd_att,
+								   childOID,
+								   childrel->rd_rel->reltype,
+								   childRTindex);
+	root->append_rel_list = lappend(root->append_rel_list, appinfo);
+
+	/*
+	 * Translate the column permissions bitmaps to the child's attnums (we
+	 * have to build the translated_vars list before we can do this). But
+	 * if this is the parent table, leave copyObject's result alone.
+	 *
+	 * Note: we need to do this even though the executor won't run any
+	 * permissions checks on the child RTE.  The insertedCols/updatedCols
+	 * bitmaps may be examined for trigger-firing purposes.
+	 */
+	if (childrte->relid != parentrte->relid)
+	{
+		childrte->selectedCols = translate_col_privs(parentrte->selectedCols,
+													 appinfo->translated_vars);
+		childrte->insertedCols = translate_col_privs(parentrte->insertedCols,
+													 appinfo->translated_vars);
+		childrte->updatedCols = translate_col_privs(parentrte->updatedCols,
+													appinfo->translated_vars);
+	}
+
+	/*
+	 * Build a PlanRowMark if parent is marked FOR UPDATE/SHARE.
+	 */
+	if (top_parentrc)
+	{
+		PlanRowMark *childrc = makeNode(PlanRowMark);
+
+		childrc->rti = childRTindex;
+		childrc->prti = top_parentrc->rti;
+		childrc->rowmarkId = top_parentrc->rowmarkId;
+		/* Reselect rowmark type, because relkind might not match parent */
+		childrc->markType = select_rowmark_type(childrte,
+												top_parentrc->strength);
+		childrc->allMarkTypes = (1 << childrc->markType);
+		childrc->strength = top_parentrc->strength;
+		childrc->waitPolicy = top_parentrc->waitPolicy;
+
+		/*
+		 * We mark RowMarks for partitioned child tables as parent RowMarks so
+		 * that the executor ignores them (except their existence means that
+		 * the child tables be locked using appropriate mode).
+		 */
+		childrc->isParent = (childrte->relkind == RELKIND_PARTITIONED_TABLE);
+
+		/* Include child's rowmark type in top parent's allMarkTypes */
+		top_parentrc->allMarkTypes |= childrc->allMarkTypes;
+
+		root->rowMarks = lappend(root->rowMarks, childrc);
+	}
+
+	/*
+	 * Add the RelOptInfo.  Even though we may not really scan this relation
+	 * for reasons such as contradictory quals, we still need need to create
+	 * one, because for every RTE in the query's range table, there must be an
+	 * accompanying RelOptInfo.
+	 */
+
+	/* First, store the RTE and appinfos into planner arrays. */
+	Assert(root->simple_rte_array[childRTindex] == NULL);
+	root->simple_rte_array[childRTindex] = childrte;
+	Assert(root->append_rel_array[childRTindex] == NULL);
+	root->append_rel_array[childRTindex] = appinfo;
+
+	childrelopt = build_append_child_rel(root, parentrel, childRTindex);
+	Assert(childrelopt != NULL);
+
+	return childrelopt;
+}
+
+/*
+ *	build_append_child_rel
+ *		Build a RelOptInfo for child relation of an append rel
+ *
+ * After creating the RelOptInfo for the given child RT index, it goes on to
+ * initialize some of its fields base on the parent RelOptInfo.
+ *
+ * If the quals in baserestrictinfo turns out to be self-contradictory, the
+ * RelOptInfo is marked dummy before returning.
+ */
+static RelOptInfo *
+build_append_child_rel(PlannerInfo *root,
+					   RelOptInfo *parent,
+					   Index childRTindex)
+{
+	RelOptInfo *childrel;
+	RangeTblEntry *childRTE = root->simple_rte_array[childRTindex];
+	AppendRelInfo *appinfo = root->append_rel_array[childRTindex];
+	List	   *childquals;
+	ListCell   *lc;
+	bool		have_const_false_cq;
+	Index		cq_min_security;
+
+	/* Build the RelOptInfo. */
+	childrel = build_simple_rel(root, childRTindex, parent);
+
+	/*
+	 * Propagate lateral_relids and lateral_referencers from appendrel
+	 * parent rels to their child rels.  We intentionally give each child rel
+	 * the same minimum parameterization, even though it's quite possible that
+	 * some don't reference all the lateral rels.  This is because any append
+	 * path for the parent will have to have the same parameterization for
+	 * every child anyway, and there's no value in forcing extra
+	 * reparameterize_path() calls.  Similarly, a lateral reference to the
+	 * parent prevents use of otherwise-movable join rels for each child.
+	 */
+	childrel->direct_lateral_relids = parent->direct_lateral_relids;
+	childrel->lateral_relids = parent->lateral_relids;
+	childrel->lateral_referencers = parent->lateral_referencers;
+
+	/*
+	 * We have to copy the parent's quals to the child, with appropriate
+	 * substitution of variables.  However, only the baserestrictinfo
+	 * quals are needed before we can check for constraint exclusion; so
+	 * do that first and then check to see if we can disregard this child.
+	 *
+	 * The child rel's targetlist might contain non-Var expressions, which
+	 * means that substitution into the quals could produce opportunities
+	 * for const-simplification, and perhaps even pseudoconstant quals.
+	 * Therefore, transform each RestrictInfo separately to see if it
+	 * reduces to a constant or pseudoconstant.  (We must process them
+	 * separately to keep track of the security level of each qual.)
+	 */
+	childquals = false;
+	cq_min_security = UINT_MAX;
+	have_const_false_cq = false;
+	foreach(lc, parent->baserestrictinfo)
+	{
+		RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
+		Node	   *childqual = (Node *) rinfo->clause;
+		ListCell   *lc2;
+
+		Assert(IsA(rinfo, RestrictInfo));
+		childqual = adjust_appendrel_attrs(root, childqual,
+										   1, &appinfo);
+		childqual = eval_const_expressions(root, childqual);
+		/* check for flat-out constant */
+		if (childqual && IsA(childqual, Const))
+		{
+			if (((Const *) childqual)->constisnull ||
+				!DatumGetBool(((Const *) childqual)->constvalue))
+			{
+				/* Restriction reduces to constant FALSE or NULL */
+				have_const_false_cq = true;
+				break;
+			}
+			/* Restriction reduces to constant TRUE, so drop it */
+			continue;
+		}
+		/* might have gotten an AND clause, if so flatten it */
+		foreach(lc2, make_ands_implicit((Expr *) childqual))
+		{
+			Node	   *onecq = (Node *) lfirst(lc2);
+			bool		pseudoconstant;
+
+			/* check for pseudoconstant (no Vars or volatile functions) */
+			pseudoconstant =
+					!contain_vars_of_level(onecq, 0) &&
+					!contain_volatile_functions(onecq);
+			if (pseudoconstant)
+			{
+				/* tell createplan.c to check for gating quals */
+				root->hasPseudoConstantQuals = true;
+			}
+			/* reconstitute RestrictInfo with appropriate properties */
+			childquals = lappend(childquals,
+								 make_restrictinfo((Expr *) onecq,
+												   rinfo->is_pushed_down,
+												   rinfo->outerjoin_delayed,
+												   pseudoconstant,
+												   rinfo->security_level,
+												   NULL, NULL, NULL));
+			cq_min_security = Min(cq_min_security, rinfo->security_level);
+		}
+	}
+
+	/*
+	 * In addition to the quals inherited from the parent, we might
+	 * have securityQuals associated with this particular child node.
+	 * (Currently this can only happen in appendrels originating from
+	 * UNION ALL; inheritance child tables don't have their own
+	 * securityQuals.)	Pull any such securityQuals up into the
+	 * baserestrictinfo for the child.  This is similar to
+	 * process_security_barrier_quals() for the parent rel, except
+	 * that we can't make any general deductions from such quals,
+	 * since they don't hold for the whole appendrel.
+	 */
+	if (childRTE->securityQuals)
+	{
+		Index		security_level = 0;
+
+		foreach(lc, childRTE->securityQuals)
+		{
+			List	   *qualset = (List *) lfirst(lc);
+			ListCell   *lc2;
+
+			foreach(lc2, qualset)
+			{
+				Expr	   *qual = (Expr *) lfirst(lc2);
+
+				/*
+				 * not likely that we'd see constants here, so no
+				 * check
+				 */
+				childquals = lappend(childquals,
+									 make_restrictinfo(qual,
+													   true,
+													   false,
+													   false,
+													   security_level,
+													   NULL, NULL,
+													   NULL));
+				cq_min_security = Min(cq_min_security, security_level);
+			}
+			security_level++;
+		}
+		Assert(security_level <= root->qual_security_level);
+	}
+
+	/* Set child's version of baserestrictinfo. */
+	childrel->baserestrictinfo = childquals;
+	childrel->baserestrict_min_security = cq_min_security;
+
+	if (have_const_false_cq)
+	{
+		/*
+		 * Some restriction clause reduced to constant FALSE or NULL after
+		 * substitution, so this child need not be scanned.
+		 */
+		set_dummy_rel_pathlist(childrel);
+	}
+
+	return childrel;
+}
+
+/*
+ * add_rowmark_junk_columns
+ * 		Add necessary junk columns for rowmarked inheritance parent rel.
+ *
+ * These values are needed for locking of rels selected FOR UPDATE/SHARE, and
+ * to do EvalPlanQual rechecking.  See comments for PlanRowMark in
+ * plannodes.h.
+ */
+static List *
+add_rowmark_junk_columns(PlannerInfo *root, PlanRowMark *rc)
+{
+	List   *tlist = root->processed_tlist;
+	Var		   *var;
+	char		resname[32];
+	TargetEntry *tle;
+
+	if (rc->allMarkTypes & ~(1 << ROW_MARK_COPY))
+	{
+		/* Need to fetch TID */
+		var = makeVar(rc->rti,
+					  SelfItemPointerAttributeNumber,
+					  TIDOID,
+					  -1,
+					  InvalidOid,
+					  0);
+		snprintf(resname, sizeof(resname), "ctid%u", rc->rowmarkId);
+		tle = makeTargetEntry((Expr *) var,
+							  list_length(tlist) + 1,
+							  pstrdup(resname),
+							  true);
+		tlist = lappend(tlist, tle);
+	}
+	if (rc->allMarkTypes & (1 << ROW_MARK_COPY))
+	{
+		/* Need the whole row as a junk var */
+		var = makeWholeRowVar(root->simple_rte_array[rc->rti],
+							  rc->rti,
+							  0,
+							  false);
+		snprintf(resname, sizeof(resname), "wholerow%u", rc->rowmarkId);
+		tle = makeTargetEntry((Expr *) var,
+							  list_length(tlist) + 1,
+							  pstrdup(resname),
+							  true);
+		tlist = lappend(tlist, tle);
+	}
+
+	/* For inheritance cases, always fetch the tableoid too. */
+	var = makeVar(rc->rti,
+				  TableOidAttributeNumber,
+				  OIDOID,
+				  -1,
+				  InvalidOid,
+				  0);
+	snprintf(resname, sizeof(resname), "tableoid%u", rc->rowmarkId);
+	tle = makeTargetEntry((Expr *) var,
+						  list_length(tlist) + 1,
+						  pstrdup(resname),
+						  true);
+	tlist = lappend(tlist, tle);
+
+	return tlist;
+}
diff --git a/src/backend/optimizer/util/appendinfo.c b/src/backend/optimizer/util/appendinfo.c
new file mode 100644
index 0000000000..9502535e53
--- /dev/null
+++ b/src/backend/optimizer/util/appendinfo.c
@@ -0,0 +1,851 @@
+/*-------------------------------------------------------------------------
+ *
+ * appendinfo.c
+ *	  Routines for mapping between append parent(s) and children
+ *
+ * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/optimizer/path/appendinfo.c
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include "access/htup_details.h"
+#include "access/sysattr.h"
+#include "nodes/makefuncs.h"
+#include "nodes/nodeFuncs.h"
+#include "optimizer/appendinfo.h"
+#include "parser/parsetree.h"
+#include "utils/rel.h"
+#include "utils/lsyscache.h"
+#include "utils/syscache.h"
+
+typedef struct
+{
+	PlannerInfo *root;
+	int			nappinfos;
+	AppendRelInfo **appinfos;
+} adjust_appendrel_attrs_context;
+
+static void make_inh_translation_list(TupleDesc old_tupdesc,
+						  TupleDesc new_tupdesc,
+						  Oid from_rel, Oid to_rel,
+						  Index newvarno, List **translated_vars);
+static Node *adjust_appendrel_attrs_mutator(Node *node,
+							   adjust_appendrel_attrs_context *context);
+static Relids adjust_child_relids(Relids relids, int nappinfos,
+					AppendRelInfo **appinfos);
+static List *adjust_inherited_tlist(List *tlist,
+					   AppendRelInfo *context);
+
+AppendRelInfo *
+make_append_rel_info(RelOptInfo *parentrel, RangeTblEntry *parentrte,
+					 TupleDesc childdesc, Oid childoid, Oid childreltype,
+					 Index childRTindex)
+{
+	AppendRelInfo  *appinfo = makeNode(AppendRelInfo);
+
+	appinfo->parent_relid = parentrel->relid;
+	appinfo->child_relid = childRTindex;
+	appinfo->parent_reltype = parentrel->reltype;
+	appinfo->child_reltype = childreltype;
+	make_inh_translation_list(parentrel->tupdesc, childdesc,
+							  parentrte->relid, childoid,
+							  childRTindex,
+							  &appinfo->translated_vars);
+	appinfo->parent_reloid = parentrte->relid;
+
+	return appinfo;
+}
+
+/*
+ * adjust_appendrel_attrs
+ *	  Copy the specified query or expression and translate Vars referring to a
+ *	  parent rel to refer to the corresponding child rel instead.  We also
+ *	  update rtindexes appearing outside Vars, such as resultRelation and
+ *	  jointree relids.
+ *
+ * Note: this is only applied after conversion of sublinks to subplans,
+ * so we don't need to cope with recursion into sub-queries.
+ *
+ * Note: this is not hugely different from what pullup_replace_vars() does;
+ * maybe we should try to fold the two routines together.
+ */
+Node *
+adjust_appendrel_attrs(PlannerInfo *root, Node *node, int nappinfos,
+					   AppendRelInfo **appinfos)
+{
+	Node	   *result;
+	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);
+
+	/*
+	 * Must be prepared to start with a Query or a bare expression tree.
+	 */
+	if (node && IsA(node, Query))
+	{
+		Query	   *newnode;
+		int			cnt;
+
+		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;
+}
+
+static Node *
+adjust_appendrel_attrs_mutator(Node *node,
+							   adjust_appendrel_attrs_context *context)
+{
+	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;
+
+		for (cnt = 0; cnt < nappinfos; cnt++)
+		{
+			if (var->varno == appinfos[cnt]->parent_relid)
+			{
+				appinfo = appinfos[cnt];
+				break;
+			}
+		}
+
+		if (var->varlevelsup == 0 && appinfo)
+		{
+			var->varno = appinfo->child_relid;
+			var->varnoold = appinfo->child_relid;
+			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));
+				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;
+
+					return (Node *) rowexpr;
+				}
+			}
+			/* system attributes don't need any other translation */
+		}
+		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, 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 */
+		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, context->nappinfos,
+											  context->appinfos);
+		return (Node *) phv;
+	}
+
+	/*
+	 * This is needed, because inheritance_make_rel_from_joinlist needs to
+	 * translate root->join_info_list executing make_rel_from_joinlist for a
+	 * given child.
+	 */
+	if (IsA(node, SpecialJoinInfo))
+	{
+		SpecialJoinInfo *oldinfo = (SpecialJoinInfo *) node;
+		SpecialJoinInfo *newinfo = makeNode(SpecialJoinInfo);
+
+		memcpy(newinfo, oldinfo, sizeof(SpecialJoinInfo));
+		newinfo->min_lefthand = adjust_child_relids(oldinfo->min_lefthand,
+													context->nappinfos,
+													context->appinfos);
+		newinfo->min_righthand = adjust_child_relids(oldinfo->min_righthand,
+													 context->nappinfos,
+													 context->appinfos);
+		newinfo->syn_lefthand = adjust_child_relids(oldinfo->syn_lefthand,
+													context->nappinfos,
+													context->appinfos);
+		newinfo->syn_righthand = adjust_child_relids(oldinfo->syn_righthand,
+													 context->nappinfos,
+													 context->appinfos);
+		newinfo->semi_rhs_exprs =
+					(List *) expression_tree_mutator((Node *)
+													 oldinfo->semi_rhs_exprs,
+													 adjust_appendrel_attrs_mutator,
+													 (void *) context);
+		return (Node *) newinfo;
+	}
+
+	/* Shouldn't need to handle planner auxiliary nodes here */
+	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 */
+		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->nullable_relids = adjust_child_relids(oldinfo->nullable_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));
+
+	return expression_tree_mutator(node, adjust_appendrel_attrs_mutator,
+								   (void *) context);
+}
+
+/*
+ * Substitute child relids for parent relids in a Relid set.  The array of
+ * appinfos specifies the substitutions to be performed.
+ */
+static Relids
+adjust_child_relids(Relids relids, int nappinfos, AppendRelInfo **appinfos)
+{
+	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;
+}
+
+/*
+ * Replace any relid present in top_parent_relids with its child in
+ * child_relids. Members of child_relids can be multiple levels below top
+ * parent in the partition hierarchy.
+ */
+Relids
+adjust_child_relids_multilevel(PlannerInfo *root, Relids relids,
+							   Relids child_relids, Relids top_parent_relids)
+{
+	AppendRelInfo **appinfos;
+	int			nappinfos;
+	Relids		parent_relids = NULL;
+	Relids		result;
+	Relids		tmp_result = NULL;
+	int			cnt;
+
+	/*
+	 * If the given relids set doesn't contain any of the top parent relids,
+	 * it will remain unchanged.
+	 */
+	if (!bms_overlap(relids, top_parent_relids))
+		return relids;
+
+	appinfos = find_appinfos_by_relids(root, child_relids, &nappinfos);
+
+	/* Construct relids set for the immediate parent of the given child. */
+	for (cnt = 0; cnt < nappinfos; cnt++)
+	{
+		AppendRelInfo *appinfo = appinfos[cnt];
+
+		parent_relids = bms_add_member(parent_relids, appinfo->parent_relid);
+	}
+
+	/* Recurse if immediate parent is not the top parent. */
+	if (!bms_equal(parent_relids, top_parent_relids))
+	{
+		tmp_result = adjust_child_relids_multilevel(root, relids,
+													parent_relids,
+													top_parent_relids);
+		relids = tmp_result;
+	}
+
+	result = adjust_child_relids(relids, nappinfos, appinfos);
+
+	/* Free memory consumed by any intermediate result. */
+	if (tmp_result)
+		bms_free(tmp_result);
+	bms_free(parent_relids);
+	pfree(appinfos);
+
+	return result;
+}
+
+/*
+ * adjust_appendrel_attrs_multilevel
+ *	  Apply Var translations from a toplevel appendrel parent down to a child.
+ *
+ * In some cases we need to translate expressions referencing a parent relation
+ * to reference an appendrel child that's multiple levels removed from it.
+ */
+Node *
+adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node,
+								  Relids child_relids,
+								  Relids top_parent_relids)
+{
+	AppendRelInfo **appinfos;
+	Bitmapset  *parent_relids = NULL;
+	int			nappinfos;
+	int			cnt;
+
+	Assert(bms_num_members(child_relids) == bms_num_members(top_parent_relids));
+
+	appinfos = find_appinfos_by_relids(root, child_relids, &nappinfos);
+
+	/* Construct relids set for the immediate parent of given child. */
+	for (cnt = 0; cnt < nappinfos; cnt++)
+	{
+		AppendRelInfo *appinfo = appinfos[cnt];
+
+		parent_relids = bms_add_member(parent_relids, appinfo->parent_relid);
+	}
+
+	/* Recurse if immediate parent is not the top parent. */
+	if (!bms_equal(parent_relids, top_parent_relids))
+		node = adjust_appendrel_attrs_multilevel(root, node, parent_relids,
+												 top_parent_relids);
+
+	/* Now translate for this child */
+	node = adjust_appendrel_attrs(root, node, nappinfos, appinfos);
+
+	pfree(appinfos);
+
+	return node;
+}
+
+/*
+ * Construct the SpecialJoinInfo for a child-join by translating
+ * SpecialJoinInfo for the join between parents. left_relids and right_relids
+ * are the relids of left and right side of the join respectively.
+ */
+SpecialJoinInfo *
+build_child_join_sjinfo(PlannerInfo *root, SpecialJoinInfo *parent_sjinfo,
+						Relids left_relids, Relids right_relids)
+{
+	SpecialJoinInfo *sjinfo = makeNode(SpecialJoinInfo);
+	AppendRelInfo **left_appinfos;
+	int			left_nappinfos;
+	AppendRelInfo **right_appinfos;
+	int			right_nappinfos;
+
+	memcpy(sjinfo, parent_sjinfo, sizeof(SpecialJoinInfo));
+	left_appinfos = find_appinfos_by_relids(root, left_relids,
+											&left_nappinfos);
+	right_appinfos = find_appinfos_by_relids(root, right_relids,
+											 &right_nappinfos);
+
+	sjinfo->min_lefthand = adjust_child_relids(sjinfo->min_lefthand,
+											   left_nappinfos, left_appinfos);
+	sjinfo->min_righthand = adjust_child_relids(sjinfo->min_righthand,
+												right_nappinfos,
+												right_appinfos);
+	sjinfo->syn_lefthand = adjust_child_relids(sjinfo->syn_lefthand,
+											   left_nappinfos, left_appinfos);
+	sjinfo->syn_righthand = adjust_child_relids(sjinfo->syn_righthand,
+												right_nappinfos,
+												right_appinfos);
+	sjinfo->semi_rhs_exprs = (List *) adjust_appendrel_attrs(root,
+															 (Node *) sjinfo->semi_rhs_exprs,
+															 right_nappinfos,
+															 right_appinfos);
+
+	pfree(left_appinfos);
+	pfree(right_appinfos);
+
+	return sjinfo;
+}
+
+/*
+ * find_appinfos_by_relids
+ * 		Find AppendRelInfo structures for all relations specified by relids.
+ *
+ * The AppendRelInfos are returned in an array, which can be pfree'd by the
+ * caller. *nappinfos is set to the number of entries in the array.
+ */
+AppendRelInfo **
+find_appinfos_by_relids(PlannerInfo *root, Relids relids, int *nappinfos)
+{
+	AppendRelInfo **appinfos;
+	int			cnt = 0;
+	int			i;
+
+	*nappinfos = bms_num_members(relids);
+	appinfos = (AppendRelInfo **) palloc(sizeof(AppendRelInfo *) * *nappinfos);
+
+	i = -1;
+	while ((i = bms_next_member(relids, i)) >= 0)
+	{
+		AppendRelInfo *appinfo = root->append_rel_array[i];
+
+		if (!appinfo)
+			elog(ERROR, "child rel %d not found in append_rel_array", i);
+
+		appinfos[cnt++] = appinfo;
+	}
+	return appinfos;
+}
+
+/*
+ * make_inh_translation_list
+ *	  Build the list of translations from parent Vars to child Vars for
+ *	  an inheritance child.
+ *
+ * For paranoia's sake, we match type/collation as well as attribute name.
+ */
+static void
+make_inh_translation_list(TupleDesc old_tupdesc, TupleDesc new_tupdesc,
+						  Oid from_rel, Oid to_rel,
+						  Index newvarno, List **translated_vars)
+{
+	List	   *vars = NIL;
+	int			oldnatts = old_tupdesc->natts;
+	int			newnatts = new_tupdesc->natts;
+	int			old_attno;
+	int			new_attno = 0;
+
+	for (old_attno = 0; old_attno < oldnatts; old_attno++)
+	{
+		Form_pg_attribute att;
+		char	   *attname;
+		Oid			atttypid;
+		int32		atttypmod;
+		Oid			attcollation;
+
+		att = TupleDescAttr(old_tupdesc, old_attno);
+		if (att->attisdropped)
+		{
+			/* Just put NULL into this list entry */
+			vars = lappend(vars, NULL);
+			continue;
+		}
+		attname = NameStr(att->attname);
+		atttypid = att->atttypid;
+		atttypmod = att->atttypmod;
+		attcollation = att->attcollation;
+
+		/*
+		 * When we are generating the "translation list" for the parent table
+		 * of an inheritance set, no need to search for matches.
+		 */
+		if (from_rel == to_rel)
+		{
+			vars = lappend(vars, makeVar(newvarno,
+										 (AttrNumber) (old_attno + 1),
+										 atttypid,
+										 atttypmod,
+										 attcollation,
+										 0));
+			continue;
+		}
+
+		/*
+		 * Otherwise we have to search for the matching column by name.
+		 * There's no guarantee it'll have the same column position, because
+		 * of cases like ALTER TABLE ADD COLUMN and multiple inheritance.
+		 * However, in simple cases, the relative order of columns is mostly
+		 * the same in both relations, so try the column of newrelation that
+		 * follows immediately after the one that we just found, and if that
+		 * fails, let syscache handle it.
+		 */
+		if (new_attno >= newnatts ||
+			(att = TupleDescAttr(new_tupdesc, new_attno))->attisdropped ||
+			strcmp(attname, NameStr(att->attname)) != 0)
+		{
+			HeapTuple	newtup;
+
+			newtup = SearchSysCacheAttName(to_rel, attname);
+			if (!newtup)
+				elog(ERROR, "could not find inherited attribute \"%s\" of relation \"%s\"",
+					 attname, get_rel_name(to_rel));
+			new_attno = ((Form_pg_attribute) GETSTRUCT(newtup))->attnum - 1;
+			ReleaseSysCache(newtup);
+
+			att = TupleDescAttr(new_tupdesc, new_attno);
+		}
+
+		/* Found it, check type and collation match */
+		if (atttypid != att->atttypid || atttypmod != att->atttypmod)
+			elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's type",
+				 attname, get_rel_name(to_rel));
+		if (attcollation != att->attcollation)
+			elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's collation",
+				 attname, get_rel_name(to_rel));
+
+		vars = lappend(vars, makeVar(newvarno,
+									 (AttrNumber) (new_attno + 1),
+									 atttypid,
+									 atttypmod,
+									 attcollation,
+									 0));
+		new_attno++;
+	}
+
+	*translated_vars = vars;
+}
+
+/*
+ * translate_col_privs
+ *	  Translate a bitmapset representing per-column privileges from the
+ *	  parent rel's attribute numbering to the child's.
+ *
+ * The only surprise here is that we don't translate a parent whole-row
+ * reference into a child whole-row reference.  That would mean requiring
+ * permissions on all child columns, which is overly strict, since the
+ * query is really only going to reference the inherited columns.  Instead
+ * we set the per-column bits for all inherited columns.
+ */
+Bitmapset *
+translate_col_privs(const Bitmapset *parent_privs,
+					List *translated_vars)
+{
+	Bitmapset  *child_privs = NULL;
+	bool		whole_row;
+	int			attno;
+	ListCell   *lc;
+
+	/* System attributes have the same numbers in all tables */
+	for (attno = FirstLowInvalidHeapAttributeNumber + 1; attno < 0; attno++)
+	{
+		if (bms_is_member(attno - FirstLowInvalidHeapAttributeNumber,
+						  parent_privs))
+			child_privs = bms_add_member(child_privs,
+										 attno - FirstLowInvalidHeapAttributeNumber);
+	}
+
+	/* Check if parent has whole-row reference */
+	whole_row = bms_is_member(InvalidAttrNumber - FirstLowInvalidHeapAttributeNumber,
+							  parent_privs);
+
+	/* And now translate the regular user attributes, using the vars list */
+	attno = InvalidAttrNumber;
+	foreach(lc, translated_vars)
+	{
+		Var		   *var = lfirst_node(Var, lc);
+
+		attno++;
+		if (var == NULL)		/* ignore dropped columns */
+			continue;
+		if (whole_row ||
+			bms_is_member(attno - FirstLowInvalidHeapAttributeNumber,
+						  parent_privs))
+			child_privs = bms_add_member(child_privs,
+										 var->varattno - FirstLowInvalidHeapAttributeNumber);
+	}
+
+	return child_privs;
+}
+
+/*
+ * 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.
+ */
+static List *
+adjust_inherited_tlist(List *tlist, AppendRelInfo *context)
+{
+	bool		changed_it = false;
+	ListCell   *tl;
+	List	   *new_tlist;
+	bool		more;
+	int			attrno;
+
+	/* 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)
+	{
+		TargetEntry *tle = (TargetEntry *) lfirst(tl);
+		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))
+			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);
+		if (childvar == NULL || !IsA(childvar, Var))
+			elog(ERROR, "attribute %d of relation \"%s\" does not exist",
+				 tle->resno, get_rel_name(context->parent_reloid));
+
+		if (tle->resno != childvar->varattno)
+		{
+			tle->resno = childvar->varattno;
+			changed_it = true;
+		}
+	}
+
+	/*
+	 * 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;
+
+	new_tlist = NIL;
+	more = true;
+	for (attrno = 1; more; attrno++)
+	{
+		more = false;
+		foreach(tl, tlist)
+		{
+			TargetEntry *tle = (TargetEntry *) lfirst(tl);
+
+			if (tle->resjunk)
+				continue;		/* ignore junk items */
+
+			if (tle->resno == attrno)
+				new_tlist = lappend(new_tlist, tle);
+			else if (tle->resno > attrno)
+				more = true;
+		}
+	}
+
+	foreach(tl, tlist)
+	{
+		TargetEntry *tle = (TargetEntry *) lfirst(tl);
+
+		if (!tle->resjunk)
+			continue;			/* here, ignore non-junk items */
+
+		tle->resno = attrno;
+		new_tlist = lappend(new_tlist, tle);
+		attrno++;
+	}
+
+	return new_tlist;
+}
diff --git a/src/backend/optimizer/util/pathnode.c b/src/backend/optimizer/util/pathnode.c
index d50d86b252..8ce88876c4 100644
--- a/src/backend/optimizer/util/pathnode.c
+++ b/src/backend/optimizer/util/pathnode.c
@@ -20,6 +20,7 @@
 #include "foreign/fdwapi.h"
 #include "nodes/extensible.h"
 #include "nodes/nodeFuncs.h"
+#include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index c23db9d78d..52a11f434f 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -17,6 +17,7 @@
 #include <limits.h>
 
 #include "miscadmin.h"
+#include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
diff --git a/src/backend/partitioning/partprune.c b/src/backend/partitioning/partprune.c
index fcf8d6032c..e76906da1f 100644
--- a/src/backend/partitioning/partprune.c
+++ b/src/backend/partitioning/partprune.c
@@ -44,6 +44,7 @@
 #include "miscadmin.h"
 #include "nodes/makefuncs.h"
 #include "nodes/nodeFuncs.h"
+#include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
diff --git a/src/include/optimizer/append.h b/src/include/optimizer/append.h
new file mode 100644
index 0000000000..b5f025c137
--- /dev/null
+++ b/src/include/optimizer/append.h
@@ -0,0 +1,25 @@
+/*-------------------------------------------------------------------------
+ *
+ * append.h
+ *	  prototypes for append.c.
+ *
+ *
+ * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/optimizer/append.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef APPEND_H
+#define APPEND_H
+
+#include "nodes/relation.h"
+
+/*
+ * append.c
+ *	  utilities for dealing with append relations
+ */
+extern void expand_inherited_tables(PlannerInfo *root);
+
+#endif							/* APPEND_H */
diff --git a/src/include/optimizer/appendinfo.h b/src/include/optimizer/appendinfo.h
new file mode 100644
index 0000000000..e205e78e6d
--- /dev/null
+++ b/src/include/optimizer/appendinfo.h
@@ -0,0 +1,43 @@
+/*-------------------------------------------------------------------------
+ *
+ * appendinfo.h
+ *	  Routines for mapping expressions between append rel parent(s) and
+ *	  children
+ *
+ * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/optimizer/appendinfo.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef APPENDINFO_H
+#define APPENDINFO_H
+
+#include "nodes/plannodes.h"
+#include "nodes/relation.h"
+#include "utils/relcache.h"
+
+extern AppendRelInfo *make_append_rel_info(RelOptInfo *parentrel,
+					 RangeTblEntry *parentrte,
+					 TupleDesc childdesc, Oid childoid, Oid childreltype,
+					 Index childRTindex);
+extern Bitmapset *translate_col_privs(const Bitmapset *parent_privs,
+					List *translated_vars);
+extern Node *adjust_appendrel_attrs(PlannerInfo *root, Node *node,
+					   int nappinfos, AppendRelInfo **appinfos);
+
+extern Node *adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node,
+								  Relids child_relids,
+								  Relids top_parent_relids);
+
+extern AppendRelInfo **find_appinfos_by_relids(PlannerInfo *root,
+						Relids relids, int *nappinfos);
+
+extern SpecialJoinInfo *build_child_join_sjinfo(PlannerInfo *root,
+						SpecialJoinInfo *parent_sjinfo,
+						Relids left_relids, Relids right_relids);
+extern Relids adjust_child_relids_multilevel(PlannerInfo *root, Relids relids,
+							   Relids child_relids, Relids top_parent_relids);
+
+#endif							/* APPENDINFO_H */
diff --git a/src/include/optimizer/prep.h b/src/include/optimizer/prep.h
index faae07d240..3ad9b4a77e 100644
--- a/src/include/optimizer/prep.h
+++ b/src/include/optimizer/prep.h
@@ -48,24 +48,5 @@ extern PlanRowMark *get_plan_rowmark(List *rowmarks, Index rtindex);
  */
 extern RelOptInfo *plan_set_operations(PlannerInfo *root);
 
-extern void expand_inherited_tables(PlannerInfo *root);
 
-extern Node *adjust_appendrel_attrs(PlannerInfo *root, Node *node,
-					   int nappinfos, AppendRelInfo **appinfos);
-extern AppendRelInfo *make_append_rel_info(RelOptInfo *parentrel,
-					 RangeTblEntry *parentrte,
-					 TupleDesc childdesc, Oid childoid, Oid childreltype,
-					 Index childRTindex);
-extern Node *adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node,
-								  Relids child_relids,
-								  Relids top_parent_relids);
-
-extern AppendRelInfo **find_appinfos_by_relids(PlannerInfo *root,
-						Relids relids, int *nappinfos);
-
-extern SpecialJoinInfo *build_child_join_sjinfo(PlannerInfo *root,
-						SpecialJoinInfo *parent_sjinfo,
-						Relids left_relids, Relids right_relids);
-extern Relids adjust_child_relids_multilevel(PlannerInfo *root, Relids relids,
-							   Relids child_relids, Relids top_parent_relids);
 #endif							/* PREP_H */
-- 
2.11.0

From 901b9a74aafc06d2221522e1a78860298c854b75 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Mon, 15 Oct 2018 10:59:24 +0900
Subject: [PATCH v8 5/6] Teach planner to only process unpruned partitions

This adds a bitmapset field live_parts to RelOptInfo and stores
the partition indexes of non-dummy partitions in it, meaning it
contains indexes of only those partitions that have a non-NULL
RelOptInfo present in its parent's RelOptInfo's part_rels array.

This speeds up processing partitioned table's partitions compared
to going through the whole part_rels array in a number of places.
---
 src/backend/optimizer/path/joinrels.c |  3 +++
 src/backend/optimizer/plan/planner.c  | 18 +++++++++---------
 src/backend/optimizer/util/append.c   |  8 ++++++++
 src/backend/optimizer/util/relnode.c  |  3 +++
 src/backend/partitioning/partprune.c  | 18 +++++-------------
 src/include/nodes/relation.h          |  2 ++
 6 files changed, 30 insertions(+), 22 deletions(-)

diff --git a/src/backend/optimizer/path/joinrels.c b/src/backend/optimizer/path/joinrels.c
index 6e321ec9e7..76531a05cf 100644
--- a/src/backend/optimizer/path/joinrels.c
+++ b/src/backend/optimizer/path/joinrels.c
@@ -1424,6 +1424,9 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
 		populate_joinrel_with_paths(root, child_rel1, child_rel2,
 									child_joinrel, child_sjinfo,
 									child_restrictlist);
+		if (!IS_DUMMY_REL(child_joinrel))
+			joinrel->live_parts = bms_add_member(joinrel->live_parts,
+												 cnt_parts);
 	}
 }
 
diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index 0586c48ed0..84aa0df6be 100644
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -6762,7 +6762,9 @@ apply_scanjoin_target_to_paths(PlannerInfo *root,
 		List	   *live_children = NIL;
 
 		/* Adjust each partition. */
-		for (partition_idx = 0; partition_idx < rel->nparts; partition_idx++)
+		partition_idx = -1;
+		while ((partition_idx = bms_next_member(rel->live_parts,
+												partition_idx)) >= 0)
 		{
 			RelOptInfo *child_rel = rel->part_rels[partition_idx];
 			ListCell   *lc;
@@ -6770,9 +6772,7 @@ apply_scanjoin_target_to_paths(PlannerInfo *root,
 			int			nappinfos;
 			List	   *child_scanjoin_targets = NIL;
 
-			/* Skip processing pruned partitions. */
-			if (child_rel == NULL)
-				continue;
+			Assert(child_rel != NULL);
 
 			/* Translate scan/join targets for this child. */
 			appinfos = find_appinfos_by_relids(root, child_rel->relids,
@@ -6853,7 +6853,6 @@ create_partitionwise_grouping_paths(PlannerInfo *root,
 									PartitionwiseAggregateType patype,
 									GroupPathExtraData *extra)
 {
-	int			nparts = input_rel->nparts;
 	int			cnt_parts;
 	List	   *grouped_live_children = NIL;
 	List	   *partially_grouped_live_children = NIL;
@@ -6865,7 +6864,9 @@ create_partitionwise_grouping_paths(PlannerInfo *root,
 		   partially_grouped_rel != NULL);
 
 	/* Add paths for partitionwise aggregation/grouping. */
-	for (cnt_parts = 0; cnt_parts < nparts; cnt_parts++)
+	cnt_parts = -1;
+	while ((cnt_parts = bms_next_member(input_rel->live_parts,
+										cnt_parts)) >= 0)
 	{
 		RelOptInfo *child_input_rel = input_rel->part_rels[cnt_parts];
 		PathTarget *child_target = copy_pathtarget(target);
@@ -6875,9 +6876,8 @@ create_partitionwise_grouping_paths(PlannerInfo *root,
 		RelOptInfo *child_grouped_rel;
 		RelOptInfo *child_partially_grouped_rel;
 
-		/* Skip processing pruned partitions. */
-		if (child_input_rel == NULL)
-			continue;
+		/* A live partition must have a RelOptInfo. */
+		Assert(child_input_rel != NULL);
 
 		/* Input child rel must have a path */
 		Assert(child_input_rel->pathlist != NIL);
diff --git a/src/backend/optimizer/util/append.c b/src/backend/optimizer/util/append.c
index d2ad80034f..3b3fb304b9 100644
--- a/src/backend/optimizer/util/append.c
+++ b/src/backend/optimizer/util/append.c
@@ -351,6 +351,7 @@ expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
 
 	/* Perform pruning. */
 	partindexes = prune_append_rel_partitions(parentrel);
+	parentrel->live_parts = partindexes;
 
 	/* Must expand PlannerInfo arrays before we can add children. */
 	expand_planner_arrays(root, bms_num_members(partindexes));
@@ -394,6 +395,13 @@ expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
 		Assert(childrel != NULL);
 		parentrel->part_rels[i] = childrel;
 
+		/*
+		 * If partition is excluded by constraints, remove it from
+		 * live_parts, too.
+		 */
+		if (IS_DUMMY_REL(childrel))
+			parentrel->live_parts = bms_del_member(parentrel->live_parts, i);
+
 		/* Close child relations, but keep locks */
 		heap_close(newrelation, NoLock);
 
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index 52a11f434f..6c7eafe6db 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -1748,6 +1748,9 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
 		joinrel->partexprs[cnt] = partexpr;
 		joinrel->nullable_partexprs[cnt] = nullable_partexpr;
 	}
+
+	/* Partitions will be added by try_partitionwise_join. */
+	joinrel->live_parts = NULL;
 }
 
 /*
diff --git a/src/backend/partitioning/partprune.c b/src/backend/partitioning/partprune.c
index e76906da1f..8bc2f5c5c2 100644
--- a/src/backend/partitioning/partprune.c
+++ b/src/backend/partitioning/partprune.c
@@ -441,29 +441,21 @@ make_partitionedrel_pruneinfo(PlannerInfo *root, RelOptInfo *parentrel,
 		memset(subplan_map, -1, nparts * sizeof(int));
 		subpart_map = (int *) palloc(nparts * sizeof(int));
 		memset(subpart_map, -1, nparts * sizeof(int));
-		present_parts = NULL;
+		present_parts = bms_copy(subpart->live_parts);
 
-		for (i = 0; i < nparts; i++)
+		i = -1;
+		while ((i = bms_next_member(present_parts, i)) >= 0)
 		{
 			RelOptInfo *partrel = subpart->part_rels[i];
 			int			subplanidx;
 			int			subpartidx;
 
-			/* Skip processing pruned partitions. */
-			if (partrel == NULL)
-				continue;
-
+			Assert(partrel != NULL);
 			subplan_map[i] = subplanidx = relid_subplan_map[partrel->relid] - 1;
 			subpart_map[i] = subpartidx = relid_subpart_map[partrel->relid] - 1;
+			/* Record finding this subplan */
 			if (subplanidx >= 0)
-			{
-				present_parts = bms_add_member(present_parts, i);
-
-				/* Record finding this subplan  */
 				subplansfound = bms_add_member(subplansfound, subplanidx);
-			}
-			else if (subpartidx >= 0)
-				present_parts = bms_add_member(present_parts, i);
 		}
 
 		pinfo = makeNode(PartitionedRelPruneInfo);
diff --git a/src/include/nodes/relation.h b/src/include/nodes/relation.h
index e6fdbcd030..f43fa46fc5 100644
--- a/src/include/nodes/relation.h
+++ b/src/include/nodes/relation.h
@@ -727,6 +727,8 @@ typedef struct RelOptInfo
 	Oid		   *part_oids;		/* partition OIDs */
 	struct RelOptInfo **part_rels;	/* Array of RelOptInfos of partitions,
 									 * stored in the same order of bounds */
+	Bitmapset  *live_parts;		/* Set of live partitions; contains indexes
+								 * into part_rels array */
 	List	  **partexprs;		/* Non-nullable partition key expressions. */
 	List	  **nullable_partexprs; /* Nullable partition key expressions. */
 	List	   *partitioned_child_rels; /* List of RT indexes. */
-- 
2.11.0

From 610ba9fadcc7fdb5aea86da67781c48b27cc0563 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Fri, 12 Oct 2018 19:12:53 +0900
Subject: [PATCH v8 6/6] Do not lock all partitions at the beginning

---
 src/backend/optimizer/util/append.c | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

diff --git a/src/backend/optimizer/util/append.c b/src/backend/optimizer/util/append.c
index 3b3fb304b9..0b0b75d409 100644
--- a/src/backend/optimizer/util/append.c
+++ b/src/backend/optimizer/util/append.c
@@ -335,10 +335,6 @@ expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
 									parentrel->inh_root_parent :
 									parentRTindex;
 
-	/* If root partitioned table, lock *all* partitions in the tree. */
-	if (parentRTindex == rootParentRTindex)
-		(void) find_all_inheritors(parentrte->relid, lockmode, NULL);
-
 	/*
 	 * Initialize partitioned_child_rels to contain this RT index.
 	 *
@@ -374,8 +370,7 @@ expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
 		RangeTblEntry *childrte;
 		Index		childRTindex;
 
-		/* Already locked above. */
-		newrelation = heap_open(childOID, NoLock);
+		newrelation = heap_open(childOID, lockmode);
 		Assert(!RELATION_IS_OTHER_TEMP(newrelation));
 
 		/*
-- 
2.11.0

From e2a65321f18ae22486e5a63b59233ef73c8e7eb1 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Wed, 17 Oct 2018 11:18:12 +0900
Subject: [PATCH v9 1/6] Overhaul inheritance update/delete planning

With the current method, inheritance_planner, which handles the
planning for update/delete commands targeting inheritance trees,
performs the *whole* planning for each child table.  That involves
translating the query tree to set a given child table in place of
the original inheritance root table as the query's target table,
followed by calling grouping_planner on the translated query, which
performs query planning and additional steps needed to apply correct
target list based on the child target table.

That's inefficient for two reasons:

 1. partprune.c cannot be used to perform partition pruning, because
    it can only be invoked from query_planner.  With the current
    approach, query_planner only sees the individual partitions in
    the query tree it receives, not the parent partitioned table.
    This leaves each partition to be pruned using constraint
    exclusion.  (constraint exclusion cannon prune hash partitions
    which means UPDATE/DELETE don't support hash partition pruning.)

 2. Repeated invocation of query_planner results in allocating large
    amounts of memory, especially if there are many child tables.
    Also, it involves repeatedly performing the same processing,
    such as jointree processing.

This commit addresses both of the issues by rewriting portions of
inheritance_planner and adding some supporting functionality to
allpath.c.

With the new implementation, inheritance_planner calls query_planner
only once at the beginning with the original unmodified query, which
creates the access paths of individual relations after pruning any
unnecessary partitions.  For each target child relation, it also
creates a sub-PartitionInfo containing translated version of the
query and a targetlist suitable for the child.  Child PlannerInfos
are saved in the top PlannerInfo for using later.  If the query
involves join against the target relation, join paths are created
for each target child relation by  replacing the original target
table in the join tree by a given child table.  Join relations
(RelOptInfos thereof) for all target child relations are collected
in a global list in the top PlannerInfo.

After creating the join paths for all target child relations,
inheritance_planner calls grouping_planner() on each child join
relation using the previously created child PlannerInfo to finish up
the paths such that they produce query's top-level target list
expanded according to a given child relation's descriptor.
grouping_planner()'s interface is modified so that we can pass it
what's called a 'planned_rel', a RelOptInfo that already contains
the necessary paths needed to produce its output.

This removes some existing code in inheritance_planner that dealt
with any subquery RTEs in the query.  The rationale of that code
was that the subquery RTEs may change during each iteration of
planning (that is, for different children), so different iterations
better use different copies of those RTEs.  That was handled by
making fresh copies of those RTEs for each iteration of planning
which were appended to the range table, accompanied by modifying all
expressions and auxiliary structures that referenced the original
subquery RTEs to instead reference the copies (that is, change the
varnos).  This copying meant we would end up adding S * N new entries
to the original range table by the time we got to the last unpruned
child, where S is the number of subquery RTEs in the original query
and N the number of unpruned children.  Since with the new code
we perform planning just once, I think we don't need this special
handling.  Actually, there is a regression test output change due
to no longer having copies of subquery RTEs (see the diff of
partition_join.out file.)

Also we no longer need the hack in relation_excluded_by_constraints()
involving setting PlannerInfo.inhTargetKind to enable constraint
exclusion for target child relation, which is no longer
is no longer needed.  Constraint exclusion runs during query_planner
step described above.

Regression test output change in partition_join.out is due to the fact
that we no longer create duplicates of subquery RTEs in child range
tables.
---
 doc/src/sgml/ddl.sgml                        |  14 +-
 src/backend/nodes/outfuncs.c                 |   1 -
 src/backend/optimizer/path/allpaths.c        | 328 +++++++++++++++++++-
 src/backend/optimizer/path/equivclass.c      |  27 +-
 src/backend/optimizer/plan/createplan.c      |  10 -
 src/backend/optimizer/plan/planner.c         | 432 +++++++--------------------
 src/backend/optimizer/prep/prepjointree.c    |   1 -
 src/backend/optimizer/prep/prepunion.c       |  33 +-
 src/backend/optimizer/util/plancat.c         |  50 +---
 src/include/nodes/relation.h                 |  31 +-
 src/include/optimizer/paths.h                |   3 +-
 src/test/regress/expected/partition_join.out |   4 +-
 12 files changed, 517 insertions(+), 417 deletions(-)

diff --git a/doc/src/sgml/ddl.sgml b/doc/src/sgml/ddl.sgml
index 676a87aeb9..8974ce3654 100644
--- a/doc/src/sgml/ddl.sgml
+++ b/doc/src/sgml/ddl.sgml
@@ -4409,15 +4409,6 @@ EXPLAIN SELECT count(*) FROM measurement WHERE logdate &gt;= DATE '2008-01-01';
 
    <note>
     <para>
-     Currently, pruning of partitions during the planning of an
-     <command>UPDATE</command> or <command>DELETE</command> command is
-     implemented using the constraint exclusion method (however, it is
-     controlled by the <literal>enable_partition_pruning</literal> rather than
-     <literal>constraint_exclusion</literal>) &mdash; see the following section
-     for details and caveats that apply.
-    </para>
-
-    <para>
      Execution-time partition pruning currently only occurs for the
      <literal>Append</literal> and <literal>MergeAppend</literal> node types.
      It is not yet implemented for the <literal>ModifyTable</literal> node
@@ -4440,9 +4431,8 @@ EXPLAIN SELECT count(*) FROM measurement WHERE logdate &gt;= DATE '2008-01-01';
 
    <para>
     <firstterm>Constraint exclusion</firstterm> is a query optimization
-    technique similar to partition pruning.  While it is primarily used
-    for partitioning implemented using the legacy inheritance method, it can be
-    used for other purposes, including with declarative partitioning.
+    technique similar to partition pruning.  It is primarily used
+    for partitioning implemented using the legacy inheritance method.
    </para>
 
    <para>
diff --git a/src/backend/nodes/outfuncs.c b/src/backend/nodes/outfuncs.c
index f0c396530d..08657fcfd9 100644
--- a/src/backend/nodes/outfuncs.c
+++ b/src/backend/nodes/outfuncs.c
@@ -2309,7 +2309,6 @@ _outPlannerInfo(StringInfo str, const PlannerInfo *node)
 	WRITE_FLOAT_FIELD(tuple_fraction, "%.4f");
 	WRITE_FLOAT_FIELD(limit_tuples, "%.0f");
 	WRITE_UINT_FIELD(qual_security_level);
-	WRITE_ENUM_FIELD(inhTargetKind, InheritanceKind);
 	WRITE_BOOL_FIELD(hasJoinRTEs);
 	WRITE_BOOL_FIELD(hasLateralRTEs);
 	WRITE_BOOL_FIELD(hasDeletedRTEs);
diff --git a/src/backend/optimizer/path/allpaths.c b/src/backend/optimizer/path/allpaths.c
index 738bb30848..4f7f034936 100644
--- a/src/backend/optimizer/path/allpaths.c
+++ b/src/backend/optimizer/path/allpaths.c
@@ -36,6 +36,7 @@
 #include "optimizer/pathnode.h"
 #include "optimizer/paths.h"
 #include "optimizer/plancat.h"
+#include "optimizer/planmain.h"
 #include "optimizer/planner.h"
 #include "optimizer/prep.h"
 #include "optimizer/restrictinfo.h"
@@ -93,6 +94,9 @@ static void set_foreign_pathlist(PlannerInfo *root, RelOptInfo *rel,
 					 RangeTblEntry *rte);
 static void set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 					Index rti, RangeTblEntry *rte);
+static PlannerInfo *adjust_inherit_target_child(PlannerInfo *root,
+							RelOptInfo *childrel,
+							AppendRelInfo *appinfo);
 static void set_append_rel_pathlist(PlannerInfo *root, RelOptInfo *rel,
 						Index rti, RangeTblEntry *rte);
 static void generate_mergeappend_paths(PlannerInfo *root, RelOptInfo *rel,
@@ -119,6 +123,8 @@ static void set_namedtuplestore_pathlist(PlannerInfo *root, RelOptInfo *rel,
 static void set_worktable_pathlist(PlannerInfo *root, RelOptInfo *rel,
 					   RangeTblEntry *rte);
 static RelOptInfo *make_rel_from_joinlist(PlannerInfo *root, List *joinlist);
+static void inheritance_make_rel_from_joinlist(PlannerInfo *root,
+						List *joinlist);
 static bool subquery_is_pushdown_safe(Query *subquery, Query *topquery,
 						  pushdown_safety_info *safetyInfo);
 static bool recurse_pushdown_safe(Node *setOp, Query *topquery,
@@ -217,13 +223,40 @@ make_one_rel(PlannerInfo *root, List *joinlist)
 
 	/*
 	 * Generate access paths for the entire join tree.
+	 *
+	 * For UPDATE/DELETE on an inheritance parent, join paths should be
+	 * generated for each child result rel separately.
 	 */
-	rel = make_rel_from_joinlist(root, joinlist);
+	if (root->parse->resultRelation &&
+		root->simple_rte_array[root->parse->resultRelation]->inh)
+	{
+		inheritance_make_rel_from_joinlist(root, joinlist);
 
-	/*
-	 * The result should join all and only the query's base rels.
-	 */
-	Assert(bms_equal(rel->relids, root->all_baserels));
+		/*
+		 * There should be as many child source rels as there are child
+		 * subroots.
+		 */
+		Assert(list_length(root->inh_target_child_roots) ==
+			   list_length(root->inh_target_child_rels));
+
+		/*
+		 * Return the RelOptInfo of original target relation, although this
+		 * doesn't really contain the final path.  inheritance_planner
+		 * from where we got here will generate the final path, but not
+		 * through this RelOptInfo.
+		 */
+		rel = find_base_rel(root, root->parse->resultRelation);
+	}
+	else
+	{
+		rel = make_rel_from_joinlist(root, joinlist);
+
+		/*
+		 * The result should join all and only the query's base rels.
+		 */
+		Assert(bms_equal(rel->relids, root->all_baserels));
+
+	}
 
 	return rel;
 }
@@ -1001,6 +1034,7 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 		ListCell   *parentvars;
 		ListCell   *childvars;
 		ListCell   *lc;
+		PlannerInfo *subroot = root;
 
 		/* append_rel_list contains all append rels; ignore others */
 		if (appinfo->parent_relid != parentRTindex)
@@ -1029,11 +1063,19 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 		 * fields of childrel->reltarget; not clear if that would be useful.
 		 */
 		childrel->reltarget->exprs = (List *)
-			adjust_appendrel_attrs(root,
+			adjust_appendrel_attrs(subroot,
 								   (Node *) rel->reltarget->exprs,
 								   1, &appinfo);
 
 		/*
+		 * If the parent is the result relation, we need a reltarget for the
+		 * child relation that will be suitable to use the child also as the
+		 * target relation.
+		 */
+		if (appinfo->parent_relid == root->parse->resultRelation)
+			subroot = adjust_inherit_target_child(root, childrel, appinfo);
+
+		/*
 		 * We have to make child entries in the EquivalenceClass data
 		 * structures as well.  This is needed either if the parent
 		 * participates in some eclass joins (because we will want to consider
@@ -1045,7 +1087,8 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 		 * EquivalenceClass data structures.
 		 */
 		if (rel->has_eclass_joins || has_useful_pathkeys(root, rel))
-			add_child_rel_equivalences(root, appinfo, rel, childrel);
+			add_child_rel_equivalences(subroot, appinfo, rel, childrel,
+									   root != subroot);
 		childrel->has_eclass_joins = rel->has_eclass_joins;
 
 		/*
@@ -1188,7 +1231,7 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 
 		/* CE failed, so finish copying/modifying join quals. */
 		childrel->joininfo = (List *)
-			adjust_appendrel_attrs(root,
+			adjust_appendrel_attrs(subroot,
 								   (Node *) rel->joininfo,
 								   1, &appinfo);
 
@@ -1216,12 +1259,12 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 		 * consistency, do this before calling set_rel_size() for the child.
 		 */
 		if (root->glob->parallelModeOK && rel->consider_parallel)
-			set_rel_consider_parallel(root, childrel, childRTE);
+			set_rel_consider_parallel(subroot, childrel, childRTE);
 
 		/*
-		 * Compute the child's size.
+		 * Compute the child's size using possibly modified subroot.
 		 */
-		set_rel_size(root, childrel, childRTindex, childRTE);
+		set_rel_size(subroot, childrel, childRTindex, childRTE);
 
 		/*
 		 * It is possible that constraint exclusion detected a contradiction
@@ -1231,6 +1274,25 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 		if (IS_DUMMY_REL(childrel))
 			continue;
 
+		/*
+		 * If we modified subroot for the target inheritance case, add it
+		 * to root->inh_target_child_roots.
+		 */
+		if (subroot != root)
+		{
+			root->inh_target_child_roots =
+							lappend(root->inh_target_child_roots, subroot);
+
+			/*
+			 * If the childrel itself was a partitioned table, its children
+			 * would've been added into subroot.
+			 */
+			if (subroot->inh_target_child_roots != NIL)
+				root->inh_target_child_roots =
+							list_concat(root->inh_target_child_roots,
+										subroot->inh_target_child_roots);
+		}
+
 		/* We have at least one live child. */
 		has_live_children = true;
 
@@ -1327,6 +1389,125 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 }
 
 /*
+ * adjust_inherit_target_child
+ *		For an inheritance target child relation, this adjusts its
+ *		reltarget so that it contains expressions suitable for processing as
+ *		a target relation, creates a child PlannerInfo containing translated
+ *		copy of the query and returns it.
+ *
+ * The child PlannerInfo reuses most of the parent PlannerInfo's fields
+ * unchanged, except unexpanded_tlist and processed_tlist are based on the
+ * child relation.
+ */
+static PlannerInfo *
+adjust_inherit_target_child(PlannerInfo *root, RelOptInfo *childrel,
+							AppendRelInfo *appinfo)
+{
+	PlannerInfo *subroot;
+	List	   *tlist;
+	List	   *translated_exprs;
+	ListCell   *lc;
+
+	Assert(root->parse->commandType == CMD_UPDATE ||
+		   root->parse->commandType == CMD_DELETE);
+
+	/*
+	 * We'd like to build the reltarget afresh; save the translated
+	 * version of parent's expressions aside.
+	 */
+	translated_exprs = childrel->reltarget->exprs;
+	childrel->reltarget->exprs = NIL;
+
+	/* Translate the original query's expressions to this child. */
+	subroot = makeNode(PlannerInfo);
+	memcpy(subroot, root, sizeof(PlannerInfo));
+
+	/*
+	 * Restore the unexpanded tlist for translation, so that child's
+	 * query contains targetList numbered (resnos) per its own
+	 * TupleDesc, which adjust_inherited_tlist ensures.
+	 */
+	root->parse->targetList = root->unexpanded_tlist;
+	subroot->parse = (Query *) adjust_appendrel_attrs(root,
+													  (Node *) root->parse,
+													  1, &appinfo);
+
+	/*
+	 * Save subroot's targetlist so that childrel's own children can use it as
+	 * unexpanded tlist.  Must copy because subroot->parse->targetList will
+	 * be modified soon.
+	 */
+	subroot->unexpanded_tlist = list_copy(subroot->parse->targetList);
+
+	/*
+	 * Apply planner's expansion of targetlist, such as adding various junk
+	 * column, filling placeholder entries for dropped columns, etc., all of
+	 * which occurs with the child's TupleDesc.
+	 */
+	tlist = preprocess_targetlist(subroot);
+	subroot->processed_tlist = tlist;
+	build_base_rel_tlists(subroot, tlist);
+
+	/*
+	 * Some of the expressions in parent's reltarget might not be in the
+	 * child's freshly built reltarget expressions, because the latter only
+	 * contains those attributes that are needed to be present in the top-
+	 * level tlist (or ones that preprocess_targetlist thinks are needed to
+	 * be in the tlist.)  We may need other attributes such as those that
+	 * are required for computing WHERE clauses, which are already computed
+	 * for the parent during deconstruct_jointree processing of the original
+	 * query.  We've already got a translated copy of those attributes, from
+	 * which pick only those that are not already present.
+	 */
+	foreach(lc, translated_exprs)
+	{
+		Expr *expr = lfirst(lc);
+
+		if (!list_member(childrel->reltarget->exprs, expr))
+			childrel->reltarget->exprs = lappend(childrel->reltarget->exprs,
+												 expr);
+	}
+
+	/*
+	 * Set a few other fields of subroot.
+	 *
+	 * Reset inh_target_child_roots to not be same as parent root's so that
+	 * the subroots for this child's own children (if any) don't end up in
+	 * root parent's list.  We'll eventually merge all entries into one list,
+	 * but that's now now.
+	 */
+	subroot->inh_target_child_roots = NIL;
+
+	/*
+	 * Adjust all_baserels to replace the original target relation with the
+	 * child target relation.  Copy it before modifying though.
+	 */
+	subroot->all_baserels = bms_copy(root->all_baserels);
+	subroot->all_baserels = bms_del_member(subroot->all_baserels,
+										   root->parse->resultRelation);
+	subroot->all_baserels = bms_add_member(subroot->all_baserels,
+										   subroot->parse->resultRelation);
+
+	/*
+	 * Child root should get its own copy of ECs, because they'll be modified
+	 * to replace parent EC expressions by child expressions in
+	 * add_child_rel_equivalences.
+	 */
+	subroot->eq_classes = NIL;
+	foreach(lc, root->eq_classes)
+	{
+		EquivalenceClass *ec = lfirst(lc);
+		EquivalenceClass *new_ec = makeNode(EquivalenceClass);
+
+		memcpy(new_ec, ec, sizeof(EquivalenceClass));
+		new_ec->ec_members = list_copy(ec->ec_members);
+		subroot->eq_classes = lappend(subroot->eq_classes, new_ec);
+	}
+
+	return subroot;
+}
+
+/*
  * set_append_rel_pathlist
  *	  Build access paths for an "append relation"
  */
@@ -2624,6 +2805,131 @@ generate_gather_paths(PlannerInfo *root, RelOptInfo *rel, bool override_rows)
 }
 
 /*
+ * inheritance_make_rel_from_joinlist
+ *		Perform join planning for all non-dummy leaf inheritance children
+ *		in their role as an UPDATE/DELETE query's target relation
+ *
+ * If a child relation is a partitioned table, its children are processed in
+ * turn by recursively calling this function.
+ */
+static void
+inheritance_make_rel_from_joinlist(PlannerInfo *root, List *joinlist)
+{
+	Index		resultRelation = root->parse->resultRelation;
+	ListCell   *lc;
+#ifdef USE_ASSERT_CHECKING
+	Relids	all_baserels;
+#endif
+
+	/*
+	 * For UPDATE/DELETE queries, the top parent can only ever be a table.
+	 * As a contrast, it could be a UNION ALL subquery in the case of SELECT.
+	 */
+	Assert(root->parse->commandType == CMD_UPDATE ||
+		   root->parse->commandType == CMD_DELETE);
+	Assert(planner_rt_fetch(resultRelation, root)->rtekind == RTE_RELATION);
+
+	/* Nothing to do. */
+	if (IS_DUMMY_REL(find_base_rel(root, resultRelation )))
+		return;
+
+	foreach(lc, root->inh_target_child_roots)
+	{
+		PlannerInfo *subroot = lfirst(lc);
+		RelOptInfo *childrel;
+		AppendRelInfo *appinfo;
+		List	   *translated_joinlist;
+
+		Assert(subroot->parse->resultRelation > 0);
+		childrel = find_base_rel(root, subroot->parse->resultRelation);
+		appinfo = root->append_rel_array[subroot->parse->resultRelation];
+
+		if (appinfo->parent_relid != root->parse->resultRelation)
+			continue;
+
+		/* Ignore excluded/pruned children. */
+		if (IS_DUMMY_REL(childrel))
+			continue;
+
+		/*
+		 * Modify joinlist such that relations joined to the top parent rel
+		 * appear to be joined to the child rel instead.  Do the same for
+		 * any SpecialJoinInfo structs.
+		 */
+		translated_joinlist = (List *)
+						adjust_appendrel_attrs(subroot,
+											   (Node *) joinlist,
+											   1, &appinfo);
+		subroot->join_info_list = (List *)
+						adjust_appendrel_attrs(subroot,
+											   (Node *) root->join_info_list,
+											   1, &appinfo);
+
+		/*
+		 * Sub-partitioned tables have to be processed recursively using the
+		 * translated subroot as the parent, because AppendRelInfos link
+		 * sub-partitions to their immediate parents, not the root partitioned
+		 * table.
+		 */
+		if (childrel->part_scheme != NULL)
+		{
+			inheritance_make_rel_from_joinlist(subroot, translated_joinlist);
+
+			/*
+			 * Add this child relation as a placeholder in the parent root's
+			 * inh_target_child_rels so that inheritance_planner see same
+			 * number of entries as inh_target_child_roots.
+			 */
+			root->inh_target_child_rels =
+					lappend(root->inh_target_child_rels, childrel);
+
+			/* Also propagate this child's own children into parent's list. */
+			if (subroot->inh_target_child_rels != NIL)
+				root->inh_target_child_rels =
+					list_concat(root->inh_target_child_rels,
+								subroot->inh_target_child_rels);
+			continue;
+		}
+
+		/*
+		 * Since we added the child rel directly into the join tree, we must
+		 * modify it to be a "base" rel instead of an "other" rel, which the
+		 * join planning code expects the relations being joined to be.
+		 */
+		childrel->reloptkind = RELOPT_BASEREL;
+
+		Assert(subroot->join_rel_list == NIL);
+		Assert(subroot->join_rel_hash == NULL);
+
+		/* Perform join planning and save the resulting RelOptInfo. */
+		childrel = make_rel_from_joinlist(subroot, translated_joinlist);
+
+		/*
+		 * Remember this child target rel.  inheritance_planner will perform
+		 * the remaining steps of planning for each child relation separately.
+		 * Specifically, it will call grouping_planner on every
+		 * RelOptInfo contained in the inh_target_child_rels list, each of
+		 * which represents the source of tuples to be modified for a given
+		 * target child rel.
+		 */
+		root->inh_target_child_rels =
+						lappend(root->inh_target_child_rels, childrel);
+#ifdef USE_ASSERT_CHECKING
+		/*
+		 * The following implements essentially the same Assert as in
+		 * make_one_rel, our caller.
+		 */
+		all_baserels = bms_copy(root->all_baserels);
+		all_baserels = bms_del_member(all_baserels,
+									  root->parse->resultRelation);
+		all_baserels = bms_add_member(all_baserels,
+									  subroot->parse->resultRelation);
+		Assert(bms_equal(childrel->relids, all_baserels));
+#endif
+	}
+}
+
+/*
  * make_rel_from_joinlist
  *	  Build access paths using a "joinlist" to guide the join path search.
  *
diff --git a/src/backend/optimizer/path/equivclass.c b/src/backend/optimizer/path/equivclass.c
index b22b36ec0e..029665b974 100644
--- a/src/backend/optimizer/path/equivclass.c
+++ b/src/backend/optimizer/path/equivclass.c
@@ -2104,12 +2104,18 @@ match_eclasses_to_foreign_key_col(PlannerInfo *root,
  *
  * parent_rel and child_rel could be derived from appinfo, but since the
  * caller has already computed them, we might as well just pass them in.
+ *
+ * If 'child_is_target' is true then the child EC members *replace* the
+ * corresponding parent members.  In that case, 'root' is the child target
+ * relation's dedicated PlannerInfo so it makes sense to remove the parent
+ * ECs altogether, because they're of no use.
  */
 void
 add_child_rel_equivalences(PlannerInfo *root,
 						   AppendRelInfo *appinfo,
 						   RelOptInfo *parent_rel,
-						   RelOptInfo *child_rel)
+						   RelOptInfo *child_rel,
+						   bool child_is_target)
 {
 	ListCell   *lc1;
 
@@ -2117,6 +2123,8 @@ add_child_rel_equivalences(PlannerInfo *root,
 	{
 		EquivalenceClass *cur_ec = (EquivalenceClass *) lfirst(lc1);
 		ListCell   *lc2;
+		ListCell   *prev;
+		ListCell   *next;
 
 		/*
 		 * If this EC contains a volatile expression, then generating child
@@ -2134,12 +2142,18 @@ add_child_rel_equivalences(PlannerInfo *root,
 			!bms_is_subset(parent_rel->relids, cur_ec->ec_relids))
 			continue;
 
-		foreach(lc2, cur_ec->ec_members)
+		prev = NULL;
+		for (lc2 = list_head(cur_ec->ec_members); lc2 != NULL; lc2 = next)
 		{
 			EquivalenceMember *cur_em = (EquivalenceMember *) lfirst(lc2);
 
+			next = lnext(lc2);
+
 			if (cur_em->em_is_const)
+			{
+				prev = lc2;
 				continue;		/* ignore consts here */
+			}
 
 			/* Does it reference parent_rel? */
 			if (bms_overlap(cur_em->em_relids, parent_rel->relids))
@@ -2177,10 +2191,17 @@ add_child_rel_equivalences(PlannerInfo *root,
 														  child_rel->relids);
 				}
 
+				/* Delete the parent EC member. */
+				if (child_is_target)
+					cur_ec->ec_members = list_delete_cell(cur_ec->ec_members,
+														  lc2, prev);
+
 				(void) add_eq_member(cur_ec, child_expr,
 									 new_relids, new_nullable_relids,
-									 true, cur_em->em_datatype);
+									 !child_is_target, cur_em->em_datatype);
 			}
+			else
+				prev = lc2;
 		}
 	}
 }
diff --git a/src/backend/optimizer/plan/createplan.c b/src/backend/optimizer/plan/createplan.c
index da7a92081a..28c4b53fea 100644
--- a/src/backend/optimizer/plan/createplan.c
+++ b/src/backend/optimizer/plan/createplan.c
@@ -1998,12 +1998,7 @@ create_groupingsets_plan(PlannerInfo *root, GroupingSetsPath *best_path)
 	/*
 	 * During setrefs.c, we'll need the grouping_map to fix up the cols lists
 	 * in GroupingFunc nodes.  Save it for setrefs.c to use.
-	 *
-	 * This doesn't work if we're in an inheritance subtree (see notes in
-	 * create_modifytable_plan).  Fortunately we can't be because there would
-	 * never be grouping in an UPDATE/DELETE; but let's Assert that.
 	 */
-	Assert(root->inhTargetKind == INHKIND_NONE);
 	Assert(root->grouping_map == NULL);
 	root->grouping_map = grouping_map;
 
@@ -2160,12 +2155,7 @@ create_minmaxagg_plan(PlannerInfo *root, MinMaxAggPath *best_path)
 	 * with InitPlan output params.  (We can't just do that locally in the
 	 * MinMaxAgg node, because path nodes above here may have Agg references
 	 * as well.)  Save the mmaggregates list to tell setrefs.c to do that.
-	 *
-	 * This doesn't work if we're in an inheritance subtree (see notes in
-	 * create_modifytable_plan).  Fortunately we can't be because there would
-	 * never be aggregates in an UPDATE/DELETE; but let's Assert that.
 	 */
-	Assert(root->inhTargetKind == INHKIND_NONE);
 	Assert(root->minmax_aggs == NIL);
 	root->minmax_aggs = best_path->mmaggregates;
 
diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index c729a99f8b..722a1f55ce 100644
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -37,6 +37,7 @@
 #ifdef OPTIMIZER_DEBUG
 #include "nodes/print.h"
 #endif
+#include "nodes/relation.h"
 #include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
@@ -126,7 +127,7 @@ static Node *preprocess_expression(PlannerInfo *root, Node *expr, int kind);
 static void preprocess_qual_conditions(PlannerInfo *root, Node *jtnode);
 static void inheritance_planner(PlannerInfo *root);
 static void grouping_planner(PlannerInfo *root, bool inheritance_update,
-				 double tuple_fraction);
+				 RelOptInfo *planned_rel, double tuple_fraction);
 static grouping_sets_data *preprocess_grouping_sets(PlannerInfo *root);
 static List *remap_to_groupclause_idx(List *groupClause, List *gsets,
 						 int *tleref_to_colnum_map);
@@ -630,7 +631,6 @@ subquery_planner(PlannerGlobal *glob, Query *parse,
 	root->grouping_map = NULL;
 	root->minmax_aggs = NIL;
 	root->qual_security_level = 0;
-	root->inhTargetKind = INHKIND_NONE;
 	root->hasRecursion = hasRecursion;
 	if (hasRecursion)
 		root->wt_param_id = SS_assign_special_param(root);
@@ -970,7 +970,7 @@ subquery_planner(PlannerGlobal *glob, Query *parse,
 		rt_fetch(parse->resultRelation, parse->rtable)->inh)
 		inheritance_planner(root);
 	else
-		grouping_planner(root, false, tuple_fraction);
+		grouping_planner(root, false, NULL, tuple_fraction);
 
 	/*
 	 * Capture the set of outer-level param IDs we have access to, for use in
@@ -1146,12 +1146,19 @@ preprocess_phv_expression(PlannerInfo *root, Expr *expr)
  *	  inheritance set.
  *
  * We have to handle this case differently from cases where a source relation
- * is an inheritance set. Source inheritance is expanded at the bottom of the
- * plan tree (see allpaths.c), but target inheritance has to be expanded at
- * the top.  The reason is that for UPDATE, each target relation needs a
- * different targetlist matching its own column set.  Fortunately,
- * the UPDATE/DELETE target can never be the nullable side of an outer join,
- * so it's OK to generate the plan this way.
+ * is an inheritance set.  That's mainly because for UPDATE, each target
+ * relation needs a different targetlist matching its own column set.  So, we
+ * must modify the source scan/join path for each target relation such that it
+ * produces the desired target list.
+ *
+ * The source scan/join paths for individual target relations are still
+ * created in allpaths.c by first expanding the inheritance in the usual way
+ * by set_append_rel_size, followed by join planning for each target relation
+ * separately in make_one_rel.  Finally, we apply grouping_planner here to each
+ * child scan/join path so that it produces the desired targetlist.
+ *
+ * Fortunately, the UPDATE/DELETE target can never be the nullable side of an
+ * outer join, so it's OK to generate the plan this way.
  *
  * Returns nothing; the useful output is in the Paths we attach to
  * the (UPPERREL_FINAL, NULL) upperrel stored in *root.
@@ -1164,14 +1171,8 @@ inheritance_planner(PlannerInfo *root)
 {
 	Query	   *parse = root->parse;
 	int			top_parentRTindex = parse->resultRelation;
-	Bitmapset  *subqueryRTindexes;
-	Bitmapset  *modifiableARIindexes;
 	int			nominalRelation = -1;
 	Index		rootRelation = 0;
-	List	   *final_rtable = NIL;
-	int			save_rel_array_size = 0;
-	RelOptInfo **save_rel_array = NULL;
-	AppendRelInfo **save_append_rel_array = NULL;
 	List	   *subpaths = NIL;
 	List	   *subroots = NIL;
 	List	   *resultRelations = NIL;
@@ -1179,70 +1180,59 @@ inheritance_planner(PlannerInfo *root)
 	List	   *returningLists = NIL;
 	List	   *rowMarks;
 	RelOptInfo *final_rel;
-	ListCell   *lc;
-	Index		rti;
+	ListCell   *lc1,
+			   *lc2;
 	RangeTblEntry *parent_rte;
-	PlannerInfo *parent_root;
-	Query	   *parent_parse;
-	Bitmapset  *parent_relids = bms_make_singleton(top_parentRTindex);
-	PlannerInfo **parent_roots = NULL;
+	List	   *tlist;
+	standard_qp_extra qp_extra;
+	RelOptInfo *planned_rel;
 
+	/* Inheritance is never used for insert. */
 	Assert(parse->commandType != CMD_INSERT);
+	parent_rte = planner_rt_fetch(top_parentRTindex, root);
 
 	/*
-	 * We generate a modified instance of the original Query for each target
-	 * relation, plan that, and put all the plans into a list that will be
-	 * controlled by a single ModifyTable node.  All the instances share the
-	 * same rangetable, but each instance must have its own set of subquery
-	 * RTEs within the finished rangetable because (1) they are likely to get
-	 * scribbled on during planning, and (2) it's not inconceivable that
-	 * subqueries could get planned differently in different cases.  We need
-	 * not create duplicate copies of other RTE kinds, in particular not the
-	 * target relations, because they don't have either of those issues.  Not
-	 * having to duplicate the target relations is important because doing so
-	 * (1) would result in a rangetable of length O(N^2) for N targets, with
-	 * at least O(N^3) work expended here; and (2) would greatly complicate
-	 * management of the rowMarks list.
+	 * Generate the access paths for all relations mentioned in the query,
+	 * including the target inheritance set.  When doing the join planning,
+	 * references in the join tree to the original target relation that's the
+	 * root parent of the inheritance tree is replaced by each of its
+	 * inheritance children and the resulting joinrel RelOptInfo's are
+	 * added to root->inh_target_child_rels.
 	 *
-	 * To begin with, generate a bitmapset of the relids of the subquery RTEs.
+	 * Final planning steps (grouping_planner) are applied to the best path
+	 * of each of those child joinrels using a modified instance of the
+	 * original query for a given child target rel.  All the paths so generated
+	 * are put into  a list that will be controlled by a single ModifyTable
+	 * node.  All the instances share the same rangetable.
 	 */
-	subqueryRTindexes = NULL;
-	rti = 1;
-	foreach(lc, parse->rtable)
-	{
-		RangeTblEntry *rte = lfirst_node(RangeTblEntry, lc);
-
-		if (rte->rtekind == RTE_SUBQUERY)
-			subqueryRTindexes = bms_add_member(subqueryRTindexes, rti);
-		rti++;
-	}
 
 	/*
-	 * Next, we want to identify which AppendRelInfo items contain references
-	 * to any of the aforesaid subquery RTEs.  These items will need to be
-	 * copied and modified to adjust their subquery references; whereas the
-	 * other ones need not be touched.  It's worth being tense over this
-	 * because we can usually avoid processing most of the AppendRelInfo
-	 * items, thereby saving O(N^2) space and time when the target is a large
-	 * inheritance tree.  We can identify AppendRelInfo items by their
-	 * child_relid, since that should be unique within the list.
+	 * Save the unexpanded version of the query's targetlist to be used below
+	 * for passing to grouping_planner for each child target relation.
 	 */
-	modifiableARIindexes = NULL;
-	if (subqueryRTindexes != NULL)
-	{
-		foreach(lc, root->append_rel_list)
-		{
-			AppendRelInfo *appinfo = lfirst_node(AppendRelInfo, lc);
+	root->unexpanded_tlist = list_copy(root->parse->targetList);
 
-			if (bms_is_member(appinfo->parent_relid, subqueryRTindexes) ||
-				bms_is_member(appinfo->child_relid, subqueryRTindexes) ||
-				bms_overlap(pull_varnos((Node *) appinfo->translated_vars),
-							subqueryRTindexes))
-				modifiableARIindexes = bms_add_member(modifiableARIindexes,
-													  appinfo->child_relid);
-		}
+	/* Do the scan/join planning. */
+	tlist = preprocess_targetlist(root);
+	root->processed_tlist = tlist;
+	qp_extra.tlist = tlist;
+	qp_extra.activeWindows = qp_extra.groupClause = NIL;
+	planned_rel = query_planner(root, tlist, standard_qp_callback, &qp_extra);
+
+	/*
+	 * If it turned out during query planning that all the children are dummy
+	 * (pruned or excluded by constraints), no need to do the steps below.
+	 * Let grouping_planner finish up the final path.
+	 */
+	if (IS_DUMMY_REL(planned_rel))
+	{
+		grouping_planner(root, false, planned_rel, 0.0);
+		return;
 	}
 
+	Assert(planned_rel->relid == top_parentRTindex);
+	Assert(planned_rel->reloptkind == RELOPT_BASEREL);
+
 	/*
 	 * If the parent RTE is a partitioned table, we should use that as the
 	 * nominal target relation, because the RTEs added for partitioned tables
@@ -1250,7 +1240,6 @@ inheritance_planner(PlannerInfo *root)
 	 * not appear anywhere else in the plan, so the confusion explained below
 	 * for non-partitioning inheritance cases is not possible.
 	 */
-	parent_rte = rt_fetch(top_parentRTindex, root->parse->rtable);
 	if (parent_rte->relkind == RELKIND_PARTITIONED_TABLE)
 	{
 		nominalRelation = top_parentRTindex;
@@ -1258,95 +1247,40 @@ inheritance_planner(PlannerInfo *root)
 	}
 
 	/*
-	 * The PlannerInfo for each child is obtained by translating the relevant
-	 * members of the PlannerInfo for its immediate parent, which we find
-	 * using the parent_relid in its AppendRelInfo.  We save the PlannerInfo
-	 * for each parent in an array indexed by relid for fast retrieval. Since
-	 * the maximum number of parents is limited by the number of RTEs in the
-	 * query, we use that number to allocate the array. An extra entry is
-	 * needed since relids start from 1.
+	 * Get on with finalizing the path for each child target relation by
+	 * calling grouping_planner on its joinrel.  Note that we're restoring
+	 * the query's targetlist to the original one for grouping_planner's
+	 * targetlist expansion steps to perform the expansion with individual
+	 * child descriptors.
 	 */
-	parent_roots = (PlannerInfo **) palloc0((list_length(parse->rtable) + 1) *
-											sizeof(PlannerInfo *));
-	parent_roots[top_parentRTindex] = root;
-
-	/*
-	 * And now we can get on with generating a plan for each child table.
-	 */
-	foreach(lc, root->append_rel_list)
+	forboth(lc1, root->inh_target_child_roots,
+			lc2, root->inh_target_child_rels)
 	{
-		AppendRelInfo *appinfo = lfirst_node(AppendRelInfo, lc);
-		PlannerInfo *subroot;
+		PlannerInfo *subroot = lfirst(lc1);
+		RelOptInfo *childrel = lfirst(lc2);
+		AppendRelInfo *appinfo;
 		RangeTblEntry *child_rte;
 		RelOptInfo *sub_final_rel;
 		Path	   *subpath;
 
-		/* append_rel_list contains all append rels; ignore others */
-		if (!bms_is_member(appinfo->parent_relid, parent_relids))
-			continue;
-
-		/*
-		 * expand_inherited_rtentry() always processes a parent before any of
-		 * that parent's children, so the parent_root for this relation should
-		 * already be available.
-		 */
-		parent_root = parent_roots[appinfo->parent_relid];
-		Assert(parent_root != NULL);
-		parent_parse = parent_root->parse;
-
-		/*
-		 * We need a working copy of the PlannerInfo so that we can control
-		 * propagation of information back to the main copy.
-		 */
-		subroot = makeNode(PlannerInfo);
-		memcpy(subroot, parent_root, sizeof(PlannerInfo));
-
-		/*
-		 * Generate modified query with this rel as target.  We first apply
-		 * adjust_appendrel_attrs, which copies the Query and changes
-		 * references to the parent RTE to refer to the current child RTE,
-		 * then fool around with subquery RTEs.
-		 */
-		subroot->parse = (Query *)
-			adjust_appendrel_attrs(parent_root,
-								   (Node *) parent_parse,
-								   1, &appinfo);
+		appinfo = root->append_rel_array[subroot->parse->resultRelation];
 
 		/*
 		 * If there are securityQuals attached to the parent, move them to the
 		 * child rel (they've already been transformed properly for that).
 		 */
-		parent_rte = rt_fetch(appinfo->parent_relid, subroot->parse->rtable);
-		child_rte = rt_fetch(appinfo->child_relid, subroot->parse->rtable);
+		parent_rte = planner_rt_fetch(appinfo->parent_relid, subroot);
+		child_rte = planner_rt_fetch(appinfo->child_relid, subroot);
 		child_rte->securityQuals = parent_rte->securityQuals;
 		parent_rte->securityQuals = NIL;
 
 		/*
-		 * Mark whether we're planning a query to a partitioned table or an
-		 * inheritance parent.
+		 * Ignore a partitioned child.  Instead, the paths of its children will
+		 * be added to subpaths.
 		 */
-		subroot->inhTargetKind =
-			(rootRelation != 0) ? INHKIND_PARTITIONED : INHKIND_INHERITED;
-
-		/*
-		 * If this child is further partitioned, remember it as a parent.
-		 * Since a partitioned table does not have any data, we don't need to
-		 * create a plan for it, and we can stop processing it here.  We do,
-		 * however, need to remember its modified PlannerInfo for use when
-		 * processing its children, since we'll update their varnos based on
-		 * the delta from immediate parent to child, not from top to child.
-		 *
-		 * Note: a very non-obvious point is that we have not yet added
-		 * duplicate subquery RTEs to the subroot's rtable.  We mustn't,
-		 * because then its children would have two sets of duplicates,
-		 * confusing matters.
-		 */
-		if (child_rte->inh)
+		if (childrel->part_scheme)
 		{
-			Assert(child_rte->relkind == RELKIND_PARTITIONED_TABLE);
-			parent_relids = bms_add_member(parent_relids, appinfo->child_relid);
-			parent_roots[appinfo->child_relid] = subroot;
-
+			Assert(child_rte->inh);
 			continue;
 		}
 
@@ -1374,111 +1308,8 @@ inheritance_planner(PlannerInfo *root)
 		if (nominalRelation < 0)
 			nominalRelation = appinfo->child_relid;
 
-		/*
-		 * The rowMarks list might contain references to subquery RTEs, so
-		 * make a copy that we can apply ChangeVarNodes to.  (Fortunately, the
-		 * executor doesn't need to see the modified copies --- we can just
-		 * pass it the original rowMarks list.)
-		 */
-		subroot->rowMarks = copyObject(parent_root->rowMarks);
-
-		/*
-		 * The append_rel_list likewise might contain references to subquery
-		 * RTEs (if any subqueries were flattenable UNION ALLs).  So prepare
-		 * to apply ChangeVarNodes to that, too.  As explained above, we only
-		 * want to copy items that actually contain such references; the rest
-		 * can just get linked into the subroot's append_rel_list.
-		 *
-		 * If we know there are no such references, we can just use the outer
-		 * append_rel_list unmodified.
-		 */
-		if (modifiableARIindexes != NULL)
-		{
-			ListCell   *lc2;
-
-			subroot->append_rel_list = NIL;
-			foreach(lc2, parent_root->append_rel_list)
-			{
-				AppendRelInfo *appinfo2 = lfirst_node(AppendRelInfo, lc2);
-
-				if (bms_is_member(appinfo2->child_relid, modifiableARIindexes))
-					appinfo2 = copyObject(appinfo2);
-
-				subroot->append_rel_list = lappend(subroot->append_rel_list,
-												   appinfo2);
-			}
-		}
-
-		/*
-		 * Add placeholders to the child Query's rangetable list to fill the
-		 * RT indexes already reserved for subqueries in previous children.
-		 * These won't be referenced, so there's no need to make them very
-		 * valid-looking.
-		 */
-		while (list_length(subroot->parse->rtable) < list_length(final_rtable))
-			subroot->parse->rtable = lappend(subroot->parse->rtable,
-											 makeNode(RangeTblEntry));
-
-		/*
-		 * If this isn't the first child Query, generate duplicates of all
-		 * subquery RTEs, and adjust Var numbering to reference the
-		 * duplicates. To simplify the loop logic, we scan the original rtable
-		 * not the copy just made by adjust_appendrel_attrs; that should be OK
-		 * since subquery RTEs couldn't contain any references to the target
-		 * rel.
-		 */
-		if (final_rtable != NIL && subqueryRTindexes != NULL)
-		{
-			ListCell   *lr;
-
-			rti = 1;
-			foreach(lr, parent_parse->rtable)
-			{
-				RangeTblEntry *rte = lfirst_node(RangeTblEntry, lr);
-
-				if (bms_is_member(rti, subqueryRTindexes))
-				{
-					Index		newrti;
-
-					/*
-					 * The RTE can't contain any references to its own RT
-					 * index, except in its securityQuals, so we can save a
-					 * few cycles by applying ChangeVarNodes to the rest of
-					 * the rangetable before we append the RTE to it.
-					 */
-					newrti = list_length(subroot->parse->rtable) + 1;
-					ChangeVarNodes((Node *) subroot->parse, rti, newrti, 0);
-					ChangeVarNodes((Node *) subroot->rowMarks, rti, newrti, 0);
-					/* Skip processing unchanging parts of append_rel_list */
-					if (modifiableARIindexes != NULL)
-					{
-						ListCell   *lc2;
-
-						foreach(lc2, subroot->append_rel_list)
-						{
-							AppendRelInfo *appinfo2 = lfirst_node(AppendRelInfo, lc2);
-
-							if (bms_is_member(appinfo2->child_relid,
-											  modifiableARIindexes))
-								ChangeVarNodes((Node *) appinfo2, rti, newrti, 0);
-						}
-					}
-					rte = copyObject(rte);
-					ChangeVarNodes((Node *) rte->securityQuals, rti, newrti, 0);
-					subroot->parse->rtable = lappend(subroot->parse->rtable,
-													 rte);
-				}
-				rti++;
-			}
-		}
-
-		/* There shouldn't be any OJ info to translate, as yet */
-		Assert(subroot->join_info_list == NIL);
-		/* and we haven't created PlaceHolderInfos, either */
-		Assert(subroot->placeholder_list == NIL);
-
-		/* Generate Path(s) for accessing this result relation */
-		grouping_planner(subroot, true, 0.0 /* retrieve all tuples */ );
+		/* Apply the top-level targetlist to childrel's path. */
+		grouping_planner(subroot, true, childrel, 0.0);
 
 		/*
 		 * Select cheapest path in case there's more than one.  We always run
@@ -1490,45 +1321,10 @@ inheritance_planner(PlannerInfo *root)
 		subpath = sub_final_rel->cheapest_total_path;
 
 		/*
-		 * If this child rel was excluded by constraint exclusion, exclude it
-		 * from the result plan.
+		 * child rel cannot be empty, or inheritance_make_rel_from_joinlist
+		 * wouldn't have put it in the list to begin with.
 		 */
-		if (IS_DUMMY_PATH(subpath))
-			continue;
-
-		/*
-		 * If this is the first non-excluded child, its post-planning rtable
-		 * becomes the initial contents of final_rtable; otherwise, append
-		 * just its modified subquery RTEs to final_rtable.
-		 */
-		if (final_rtable == NIL)
-			final_rtable = subroot->parse->rtable;
-		else
-			final_rtable = list_concat(final_rtable,
-									   list_copy_tail(subroot->parse->rtable,
-													  list_length(final_rtable)));
-
-		/*
-		 * We need to collect all the RelOptInfos from all child plans into
-		 * the main PlannerInfo, since setrefs.c will need them.  We use the
-		 * last child's simple_rel_array (previous ones are too short), so we
-		 * have to propagate forward the RelOptInfos that were already built
-		 * in previous children.
-		 */
-		Assert(subroot->simple_rel_array_size >= save_rel_array_size);
-		for (rti = 1; rti < save_rel_array_size; rti++)
-		{
-			RelOptInfo *brel = save_rel_array[rti];
-
-			if (brel)
-				subroot->simple_rel_array[rti] = brel;
-		}
-		save_rel_array_size = subroot->simple_rel_array_size;
-		save_rel_array = subroot->simple_rel_array;
-		save_append_rel_array = subroot->append_rel_array;
-
-		/* Make sure any initplans from this rel get into the outer list */
-		root->init_plans = subroot->init_plans;
+		Assert(!IS_DUMMY_PATH(subpath));
 
 		/* Build list of sub-paths */
 		subpaths = lappend(subpaths, subpath);
@@ -1560,36 +1356,6 @@ inheritance_planner(PlannerInfo *root)
 	 */
 
 	/*
-	 * If we managed to exclude every child rel, return a dummy plan; it
-	 * doesn't even need a ModifyTable node.
-	 */
-	if (subpaths == NIL)
-	{
-		set_dummy_rel_pathlist(final_rel);
-		return;
-	}
-
-	/*
-	 * Put back the final adjusted rtable into the master copy of the Query.
-	 * (We mustn't do this if we found no non-excluded children.)
-	 */
-	parse->rtable = final_rtable;
-	root->simple_rel_array_size = save_rel_array_size;
-	root->simple_rel_array = save_rel_array;
-	root->append_rel_array = save_append_rel_array;
-
-	/* Must reconstruct master's simple_rte_array, too */
-	root->simple_rte_array = (RangeTblEntry **)
-		palloc0((list_length(final_rtable) + 1) * sizeof(RangeTblEntry *));
-	rti = 1;
-	foreach(lc, final_rtable)
-	{
-		RangeTblEntry *rte = lfirst_node(RangeTblEntry, lc);
-
-		root->simple_rte_array[rti++] = rte;
-	}
-
-	/*
 	 * If there was a FOR [KEY] UPDATE/SHARE clause, the LockRows node will
 	 * have dealt with fetching non-locked marked rows, else we need to have
 	 * ModifyTable do that.
@@ -1629,6 +1395,12 @@ inheritance_planner(PlannerInfo *root)
  * (inheritance_planner will create a single ModifyTable node covering all the
  * target tables.)
  *
+ * If non-NULL, planned_rel is a RelOptInfo containing paths for the query's
+ * top-level joinrel, which the caller produced by itself.  In that case, this
+ * function only needs to adjust the targetlist of its cheapest_total_path.
+ * The only caller that may pass such a RelOptInfo currently is
+ * inheritance_planner.
+ *
  * tuple_fraction is the fraction of tuples we expect will be retrieved.
  * tuple_fraction is interpreted as follows:
  *	  0: expect all tuples to be retrieved (normal case)
@@ -1647,6 +1419,7 @@ inheritance_planner(PlannerInfo *root)
  */
 static void
 grouping_planner(PlannerInfo *root, bool inheritance_update,
+				 RelOptInfo *planned_rel,
 				 double tuple_fraction)
 {
 	Query	   *parse = root->parse;
@@ -1659,7 +1432,7 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 	List	   *final_targets;
 	List	   *final_targets_contain_srfs;
 	bool		final_target_parallel_safe;
-	RelOptInfo *current_rel;
+	RelOptInfo *current_rel = planned_rel;
 	RelOptInfo *final_rel;
 	ListCell   *lc;
 
@@ -1699,6 +1472,7 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 		 * special work for recursive unions is the responsibility of
 		 * plan_set_operations.
 		 */
+		Assert(current_rel == NULL);
 		current_rel = plan_set_operations(root);
 
 		/*
@@ -1788,17 +1562,26 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 				parse->groupClause = preprocess_groupclause(root, NIL);
 		}
 
-		/* Preprocess targetlist */
-		tlist = preprocess_targetlist(root);
-
 		/*
-		 * We are now done hacking up the query's targetlist.  Most of the
-		 * remaining planning work will be done with the PathTarget
-		 * representation of tlists, but save aside the full representation so
-		 * that we can transfer its decoration (resnames etc) to the topmost
-		 * tlist of the finished Plan.
+		 * Preprocess targetlist, if needed.  If the caller has already done
+		 * query planning, root->processed_tlist already contains the desired
+		 * targetlist.
 		 */
-		root->processed_tlist = tlist;
+		if (planned_rel == NULL)
+		{
+			tlist = preprocess_targetlist(root);
+
+			/*
+			 * We are now done hacking up the query's targetlist.  Most of the
+			 * remaining planning work will be done with the PathTarget
+			 * representation of tlists, but save aside the full representation
+			 * so that we can transfer its decoration (resnames etc) to the
+			 * topmost tlist of the finished Plan.
+			 */
+			root->processed_tlist = tlist;
+		}
+		else
+			tlist = root->processed_tlist;
 
 		/*
 		 * Collect statistics about aggregates for estimating costs, and mark
@@ -1878,8 +1661,9 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 		 * We also generate (in standard_qp_callback) pathkey representations
 		 * of the query's sort clause, distinct clause, etc.
 		 */
-		current_rel = query_planner(root, tlist,
-									standard_qp_callback, &qp_extra);
+		if (current_rel == NULL)
+			current_rel = query_planner(root, tlist,
+										standard_qp_callback, &qp_extra);
 
 		/*
 		 * Convert the query's result tlist into PathTarget format.
diff --git a/src/backend/optimizer/prep/prepjointree.c b/src/backend/optimizer/prep/prepjointree.c
index cd6e11904e..78baec00dc 100644
--- a/src/backend/optimizer/prep/prepjointree.c
+++ b/src/backend/optimizer/prep/prepjointree.c
@@ -917,7 +917,6 @@ pull_up_simple_subquery(PlannerInfo *root, Node *jtnode, RangeTblEntry *rte,
 	subroot->grouping_map = NULL;
 	subroot->minmax_aggs = NIL;
 	subroot->qual_security_level = 0;
-	subroot->inhTargetKind = INHKIND_NONE;
 	subroot->hasRecursion = false;
 	subroot->wt_param_id = -1;
 	subroot->non_recursive_path = NULL;
diff --git a/src/backend/optimizer/prep/prepunion.c b/src/backend/optimizer/prep/prepunion.c
index 2a1c1cb2e1..134e7bafd9 100644
--- a/src/backend/optimizer/prep/prepunion.c
+++ b/src/backend/optimizer/prep/prepunion.c
@@ -2250,8 +2250,39 @@ adjust_appendrel_attrs_mutator(Node *node,
 											  context->appinfos);
 		return (Node *) phv;
 	}
+
+	/*
+	 * This is needed, because inheritance_make_rel_from_joinlist needs to
+	 * translate root->join_info_list executing make_rel_from_joinlist for a
+	 * given child.
+	 */
+	if (IsA(node, SpecialJoinInfo))
+	{
+		SpecialJoinInfo *oldinfo = (SpecialJoinInfo *) node;
+		SpecialJoinInfo *newinfo = makeNode(SpecialJoinInfo);
+
+		memcpy(newinfo, oldinfo, sizeof(SpecialJoinInfo));
+		newinfo->min_lefthand = adjust_child_relids(oldinfo->min_lefthand,
+													context->nappinfos,
+													context->appinfos);
+		newinfo->min_righthand = adjust_child_relids(oldinfo->min_righthand,
+													 context->nappinfos,
+													 context->appinfos);
+		newinfo->syn_lefthand = adjust_child_relids(oldinfo->syn_lefthand,
+													context->nappinfos,
+													context->appinfos);
+		newinfo->syn_righthand = adjust_child_relids(oldinfo->syn_righthand,
+													 context->nappinfos,
+													 context->appinfos);
+		newinfo->semi_rhs_exprs =
+					(List *) expression_tree_mutator((Node *)
+													 oldinfo->semi_rhs_exprs,
+													 adjust_appendrel_attrs_mutator,
+													 (void *) context);
+		return (Node *) newinfo;
+	}
+
 	/* 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));
diff --git a/src/backend/optimizer/util/plancat.c b/src/backend/optimizer/util/plancat.c
index a570ac0aab..a0fed5be42 100644
--- a/src/backend/optimizer/util/plancat.c
+++ b/src/backend/optimizer/util/plancat.c
@@ -1264,36 +1264,6 @@ get_relation_constraints(PlannerInfo *root,
 		}
 	}
 
-	/*
-	 * Append partition predicates, if any.
-	 *
-	 * For selects, partition pruning uses the parent table's partition bound
-	 * descriptor, instead of constraint exclusion which is driven by the
-	 * individual partition's partition constraint.
-	 */
-	if (enable_partition_pruning && root->parse->commandType != CMD_SELECT)
-	{
-		List	   *pcqual = RelationGetPartitionQual(relation);
-
-		if (pcqual)
-		{
-			/*
-			 * Run the partition quals through const-simplification similar to
-			 * check constraints.  We skip canonicalize_qual, though, because
-			 * partition quals should be in canonical form already; also,
-			 * since the qual is in implicit-AND format, we'd have to
-			 * explicitly convert it to explicit-AND format and back again.
-			 */
-			pcqual = (List *) eval_const_expressions(root, (Node *) pcqual);
-
-			/* Fix Vars to have the desired varno */
-			if (varno != 1)
-				ChangeVarNodes((Node *) pcqual, 1, varno, 0);
-
-			result = list_concat(result, pcqual);
-		}
-	}
-
 	heap_close(relation, NoLock);
 
 	return result;
@@ -1420,31 +1390,15 @@ relation_excluded_by_constraints(PlannerInfo *root,
 	switch (constraint_exclusion)
 	{
 		case CONSTRAINT_EXCLUSION_OFF:
-
-			/*
-			 * Don't prune if feature turned off -- except if the relation is
-			 * a partition.  While partprune.c-style partition pruning is not
-			 * yet in use for all cases (update/delete is not handled), it
-			 * would be a UI horror to use different user-visible controls
-			 * depending on such a volatile implementation detail.  Therefore,
-			 * for partitioned tables we use enable_partition_pruning to
-			 * control this behavior.
-			 */
-			if (root->inhTargetKind == INHKIND_PARTITIONED)
-				break;
 			return false;
 
 		case CONSTRAINT_EXCLUSION_PARTITION:
 
 			/*
 			 * When constraint_exclusion is set to 'partition' we only handle
-			 * OTHER_MEMBER_RELs, or BASERELs in cases where the result target
-			 * is an inheritance parent or a partitioned table.
+			 * OTHER_MEMBER_RELs.
 			 */
-			if ((rel->reloptkind != RELOPT_OTHER_MEMBER_REL) &&
-				!(rel->reloptkind == RELOPT_BASEREL &&
-				  root->inhTargetKind != INHKIND_NONE &&
-				  rel->relid == root->parse->resultRelation))
+			if (rel->reloptkind != RELOPT_OTHER_MEMBER_REL)
 				return false;
 			break;
 
diff --git a/src/include/nodes/relation.h b/src/include/nodes/relation.h
index 6fd24203dd..2ad3dc4711 100644
--- a/src/include/nodes/relation.h
+++ b/src/include/nodes/relation.h
@@ -319,9 +319,6 @@ typedef struct PlannerInfo
 	Index		qual_security_level;	/* minimum security_level for quals */
 	/* Note: qual_security_level is zero if there are no securityQuals */
 
-	InheritanceKind inhTargetKind;	/* indicates if the target relation is an
-									 * inheritance child or partition or a
-									 * partitioned table */
 	bool		hasJoinRTEs;	/* true if any RTEs are RTE_JOIN kind */
 	bool		hasLateralRTEs; /* true if any RTEs are marked LATERAL */
 	bool		hasDeletedRTEs; /* true if any RTE was deleted from jointree */
@@ -343,6 +340,34 @@ typedef struct PlannerInfo
 
 	/* Does this query modify any partition key columns? */
 	bool		partColsUpdated;
+
+	/*
+	 * The following fields are set during query planning portion of an
+	 * inherited UPDATE/DEELETE operation.
+	 */
+
+	/*
+	 * This stores the original version of the query's targetlist that's
+	 * not modified by the planner.
+	 */
+	List	   *unexpanded_tlist;
+
+	/*
+	 * List containing a PlannerInfo corresponding to each child target rel.
+	 * Content of each PlannerInfo is same as the parent PlannerInfo, except
+	 * for the parse tree which is a translated copy of the parent's parse
+	 * tree.
+	 */
+	List	   *inh_target_child_roots;
+
+	/*
+	 * RelOptInfos corresponding to each child target rel.  For leaf children,
+	 * it's the RelOptInfo representing the output of make_rel_from_joinlist()
+	 * called with the parent rel in the original join tree replaced by a
+	 * given leaf child.  For non-leaf children, it's the baserel RelOptInfo
+	 * itself, left as a placeholder.
+	 */
+	List	   *inh_target_child_rels;
 } PlannerInfo;
 
 
diff --git a/src/include/optimizer/paths.h b/src/include/optimizer/paths.h
index cafde307ad..7aa1b6e17f 100644
--- a/src/include/optimizer/paths.h
+++ b/src/include/optimizer/paths.h
@@ -161,7 +161,8 @@ extern EquivalenceClass *match_eclasses_to_foreign_key_col(PlannerInfo *root,
 extern void add_child_rel_equivalences(PlannerInfo *root,
 						   AppendRelInfo *appinfo,
 						   RelOptInfo *parent_rel,
-						   RelOptInfo *child_rel);
+						   RelOptInfo *child_rel,
+						   bool child_is_target);
 extern List *generate_implied_equalities_for_column(PlannerInfo *root,
 									   RelOptInfo *rel,
 									   ec_matches_callback_type callback,
diff --git a/src/test/regress/expected/partition_join.out b/src/test/regress/expected/partition_join.out
index c55de5d476..c9f02c1fb0 100644
--- a/src/test/regress/expected/partition_join.out
+++ b/src/test/regress/expected/partition_join.out
@@ -1780,7 +1780,7 @@ WHERE EXISTS (
                Filter: (c IS NULL)
          ->  Nested Loop
                ->  Seq Scan on int4_tbl
-               ->  Subquery Scan on ss_1
+               ->  Subquery Scan on ss
                      ->  Limit
                            ->  Seq Scan on int8_tbl int8_tbl_1
    ->  Nested Loop Semi Join
@@ -1788,7 +1788,7 @@ WHERE EXISTS (
                Filter: (c IS NULL)
          ->  Nested Loop
                ->  Seq Scan on int4_tbl
-               ->  Subquery Scan on ss_2
+               ->  Subquery Scan on ss
                      ->  Limit
                            ->  Seq Scan on int8_tbl int8_tbl_2
 (28 rows)
-- 
2.11.0

From df5cab1f5347aa68731cb846f62635a7ce73e5c9 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Fri, 26 Oct 2018 16:45:59 +0900
Subject: [PATCH v9 2/6] Store inheritance root parent index in otherrel's
 RelOptInfo

Although it's set by build_simple_rel, it's not being used by any
code yet.
---
 src/backend/nodes/outfuncs.c         |  1 +
 src/backend/optimizer/util/relnode.c | 14 ++++++++++++++
 src/include/nodes/relation.h         |  4 ++++
 3 files changed, 19 insertions(+)

diff --git a/src/backend/nodes/outfuncs.c b/src/backend/nodes/outfuncs.c
index 08657fcfd9..1d7c420e75 100644
--- a/src/backend/nodes/outfuncs.c
+++ b/src/backend/nodes/outfuncs.c
@@ -2370,6 +2370,7 @@ _outRelOptInfo(StringInfo str, const RelOptInfo *node)
 	WRITE_BOOL_FIELD(consider_partitionwise_join);
 	WRITE_BITMAPSET_FIELD(top_parent_relids);
 	WRITE_NODE_FIELD(partitioned_child_rels);
+	WRITE_UINT_FIELD(inh_root_parent);
 }
 
 static void
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index 39f5729b91..29ba19349f 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -215,9 +215,23 @@ build_simple_rel(PlannerInfo *root, int relid, RelOptInfo *parent)
 			rel->top_parent_relids = parent->top_parent_relids;
 		else
 			rel->top_parent_relids = bms_copy(parent->relids);
+
+		/*
+		 * For inheritance child relations, we also set inh_root_parent.
+		 * Note that 'parent' might itself be a child (a sub-partitioned
+		 * partition), in which case we simply use its value of
+		 * inh_root_parent.
+		 */
+		if (parent->rtekind == RTE_RELATION)
+			rel->inh_root_parent = parent->inh_root_parent > 0 ?
+										parent->inh_root_parent :
+										parent->relid;
 	}
 	else
+	{
 		rel->top_parent_relids = NULL;
+		rel->inh_root_parent = 0;
+	}
 
 	/* Check type of rtable entry */
 	switch (rte->rtekind)
diff --git a/src/include/nodes/relation.h b/src/include/nodes/relation.h
index 2ad3dc4711..94f14019bd 100644
--- a/src/include/nodes/relation.h
+++ b/src/include/nodes/relation.h
@@ -728,6 +728,10 @@ typedef struct RelOptInfo
 	List	  **partexprs;		/* Non-nullable partition key expressions. */
 	List	  **nullable_partexprs; /* Nullable partition key expressions. */
 	List	   *partitioned_child_rels; /* List of RT indexes. */
+
+	Index		inh_root_parent;	/* For otherrels, this is the RT index of
+									 * inheritance table mentioned in the query
+									 * from which this relation originated */
 } RelOptInfo;
 
 /*
-- 
2.11.0

From 70691ba07591d128851f37d8d58485c69bfb6643 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Wed, 17 Oct 2018 18:14:13 +0900
Subject: [PATCH v9 3/6] Lazy creation of RTEs for inheritance children

Currently, expand_inherited_tables called from subquery_planner opens
all inheritance child tables and adds them to the query's range
table and PlannerInfo in the form of AppendRelInfo's initially and
later RelOptInfo's.  For partitioning, that's pretty wasteful, because
it's possible to determine only the partitions that will need to be
scanned using partition pruning, which doesn't require opening the
partitions themselves.  However, the point at which the above
processing happens is too early to perform partition pruning.

This commit rearranges things within the planner so that inheritance
child relations can be added to the Query and PlannerInfo during
make_one_rel, just before set_base_rel_sizes is called.  Although the
late initialization approach only benefits the partitioning case, it
seems undesirable to do it only for partitioned tables, because it
means adding code to handle partitions specially at various places
within the planner.  So, *all* inheritance parent tables are expanded
in make_one_rel.  All unpruned partitions are added to Query in the
form of their RangeTblEntry's being added to the range table and to
PlannerInfo in the form of an AppendRelInfo and a RelOptInfo for each.

For partitioning, although we don't create a RangeTblEntry and
RelOptInfo for pruned partitions at make_one_rel time, partitionwise
join code relies on the fact that even though partitions may have
been pruned, they'd still own a RelOptInfo to handle the outer join
case where the pruned partition appears on the nullable side of join.
Partitionwise join code deals with that by allocating dummy
RelOptInfos for pruned partitions that are based mostly on their
parent's properties.

There are some regression test diffs:

 1. Caused by the fact that we no longer allocate a duplicate RT
    entry for a partitioned table in its role as child, as seen in
    the partition_aggregate.out test output.

 2. Those in postgres_fdw.out are caused by the fact that junk columns
    required for row marking are added to reltarget->exprs later than
    user columns, because the row marking junk columns arent added
    until after the inheritance is expanded which as of this commit
    is later than it used to be.
---
 contrib/postgres_fdw/expected/postgres_fdw.out    |  32 +-
 src/backend/optimizer/path/allpaths.c             | 219 +-----
 src/backend/optimizer/path/joinrels.c             |  62 ++
 src/backend/optimizer/plan/initsplan.c            |  58 --
 src/backend/optimizer/plan/planner.c              |  65 +-
 src/backend/optimizer/plan/setrefs.c              |   6 +
 src/backend/optimizer/prep/preptlist.c            |  15 +-
 src/backend/optimizer/prep/prepunion.c            | 854 +++++++++++++++-------
 src/backend/optimizer/util/Makefile               |   2 +-
 src/backend/optimizer/util/plancat.c              |  40 +-
 src/backend/optimizer/util/relnode.c              |  80 +-
 src/backend/partitioning/partprune.c              |  43 +-
 src/include/nodes/relation.h                      |   8 +
 src/include/optimizer/pathnode.h                  |   1 +
 src/include/optimizer/plancat.h                   |   2 +-
 src/include/optimizer/prep.h                      |   9 +-
 src/include/partitioning/partprune.h              |   2 +-
 src/test/regress/expected/partition_aggregate.out |   4 +-
 18 files changed, 883 insertions(+), 619 deletions(-)

diff --git a/contrib/postgres_fdw/expected/postgres_fdw.out b/contrib/postgres_fdw/expected/postgres_fdw.out
index dfa6201b3f..44d12a27b8 100644
--- a/contrib/postgres_fdw/expected/postgres_fdw.out
+++ b/contrib/postgres_fdw/expected/postgres_fdw.out
@@ -7064,15 +7064,15 @@ select * from bar where f1 in (select f1 from foo) for update;
                      Output: bar2.f1, bar2.f2, bar2.ctid, bar2.*, bar2.tableoid
                      Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct2 FOR UPDATE
          ->  Hash
-               Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+               Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                ->  HashAggregate
-                     Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                     Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                      Group Key: foo.f1
                      ->  Append
                            ->  Seq Scan on public.foo
-                                 Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                                 Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                            ->  Foreign Scan on public.foo2
-                                 Output: foo2.ctid, foo2.*, foo2.tableoid, foo2.f1
+                                 Output: foo2.f1, foo2.ctid, foo2.*, foo2.tableoid
                                  Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct1
 (23 rows)
 
@@ -7102,15 +7102,15 @@ select * from bar where f1 in (select f1 from foo) for share;
                      Output: bar2.f1, bar2.f2, bar2.ctid, bar2.*, bar2.tableoid
                      Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct2 FOR SHARE
          ->  Hash
-               Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+               Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                ->  HashAggregate
-                     Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                     Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                      Group Key: foo.f1
                      ->  Append
                            ->  Seq Scan on public.foo
-                                 Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                                 Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                            ->  Foreign Scan on public.foo2
-                                 Output: foo2.ctid, foo2.*, foo2.tableoid, foo2.f1
+                                 Output: foo2.f1, foo2.ctid, foo2.*, foo2.tableoid
                                  Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct1
 (23 rows)
 
@@ -7139,15 +7139,15 @@ update bar set f2 = f2 + 100 where f1 in (select f1 from foo);
          ->  Seq Scan on public.bar
                Output: bar.f1, bar.f2, bar.ctid
          ->  Hash
-               Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+               Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                ->  HashAggregate
-                     Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                     Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                      Group Key: foo.f1
                      ->  Append
                            ->  Seq Scan on public.foo
-                                 Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                                 Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                            ->  Foreign Scan on public.foo2
-                                 Output: foo2.ctid, foo2.*, foo2.tableoid, foo2.f1
+                                 Output: foo2.f1, foo2.ctid, foo2.*, foo2.tableoid
                                  Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct1
    ->  Hash Join
          Output: bar2.f1, (bar2.f2 + 100), bar2.f3, bar2.ctid, foo.ctid, foo.*, foo.tableoid
@@ -7157,15 +7157,15 @@ update bar set f2 = f2 + 100 where f1 in (select f1 from foo);
                Output: bar2.f1, bar2.f2, bar2.f3, bar2.ctid
                Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct2 FOR UPDATE
          ->  Hash
-               Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+               Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                ->  HashAggregate
-                     Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                     Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                      Group Key: foo.f1
                      ->  Append
                            ->  Seq Scan on public.foo
-                                 Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                                 Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                            ->  Foreign Scan on public.foo2
-                                 Output: foo2.ctid, foo2.*, foo2.tableoid, foo2.f1
+                                 Output: foo2.f1, foo2.ctid, foo2.*, foo2.tableoid
                                  Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct1
 (39 rows)
 
diff --git a/src/backend/optimizer/path/allpaths.c b/src/backend/optimizer/path/allpaths.c
index 4f7f034936..3eae8316d5 100644
--- a/src/backend/optimizer/path/allpaths.c
+++ b/src/backend/optimizer/path/allpaths.c
@@ -44,7 +44,6 @@
 #include "optimizer/var.h"
 #include "parser/parse_clause.h"
 #include "parser/parsetree.h"
-#include "partitioning/partprune.h"
 #include "rewrite/rewriteManip.h"
 #include "utils/lsyscache.h"
 
@@ -180,6 +179,16 @@ make_one_rel(PlannerInfo *root, List *joinlist)
 	set_base_rel_consider_startup(root);
 
 	/*
+	 * Expand RT entries that represent inherited or partitioned tables.
+	 * This will perform partition pruning on partitioned tables in the
+	 * original range table and also recursively on any child partitioned
+	 * tables that were added by the expansion of the original parent(s).
+	 * As new entries are added to the range table, various arrays in the
+	 * PlannerInfo will be expanded accordingly.
+	 */
+	expand_inherited_tables(root);
+
+	/*
 	 * Compute size estimates and consider_parallel flags for each base rel.
 	 */
 	set_base_rel_sizes(root);
@@ -404,7 +413,11 @@ set_rel_size(PlannerInfo *root, RelOptInfo *rel,
 		 */
 		set_dummy_rel_pathlist(rel);
 	}
-	else if (rte->inh)
+	/*
+	 * expand_inherited_tables may have proved that the relation is empty, so
+	 * check if it's so.
+	 */
+	else if (rte->inh && !IS_DUMMY_REL(rel))
 	{
 		/* It's an "append relation", process accordingly */
 		set_append_rel_size(root, rel, rti, rte);
@@ -957,8 +970,6 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 	double	   *parent_attrsizes;
 	int			nattrs;
 	ListCell   *l;
-	Relids		live_children = NULL;
-	bool		did_pruning = false;
 
 	/* Guard against stack overflow due to overly deep inheritance tree. */
 	check_stack_depth();
@@ -966,32 +977,6 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 	Assert(IS_SIMPLE_REL(rel));
 
 	/*
-	 * Initialize partitioned_child_rels to contain this RT index.
-	 *
-	 * Note that during the set_append_rel_pathlist() phase, we will bubble up
-	 * the indexes of partitioned relations that appear down in the tree, so
-	 * that when we've created Paths for all the children, the root
-	 * partitioned table's list will contain all such indexes.
-	 */
-	if (rte->relkind == RELKIND_PARTITIONED_TABLE)
-		rel->partitioned_child_rels = list_make1_int(rti);
-
-	/*
-	 * If the partitioned relation has any baserestrictinfo quals then we
-	 * attempt to use these quals to prune away partitions that cannot
-	 * possibly contain any tuples matching these quals.  In this case we'll
-	 * store the relids of all partitions which could possibly contain a
-	 * matching tuple, and skip anything else in the loop below.
-	 */
-	if (enable_partition_pruning &&
-		rte->relkind == RELKIND_PARTITIONED_TABLE &&
-		rel->baserestrictinfo != NIL)
-	{
-		live_children = prune_append_rel_partitions(rel);
-		did_pruning = true;
-	}
-
-	/*
 	 * If this is a partitioned baserel, set the consider_partitionwise_join
 	 * flag; currently, we only consider partitionwise joins with the baserel
 	 * if its targetlist doesn't contain a whole-row Var.
@@ -1028,12 +1013,8 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 		int			childRTindex;
 		RangeTblEntry *childRTE;
 		RelOptInfo *childrel;
-		List	   *childquals;
-		Index		cq_min_security;
-		bool		have_const_false_cq;
 		ListCell   *parentvars;
 		ListCell   *childvars;
-		ListCell   *lc;
 		PlannerInfo *subroot = root;
 
 		/* append_rel_list contains all append rels; ignore others */
@@ -1042,18 +1023,34 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 
 		childRTindex = appinfo->child_relid;
 		childRTE = root->simple_rte_array[childRTindex];
+		Assert(childRTE != NULL);
 
 		/*
-		 * The child rel's RelOptInfo was already created during
-		 * add_base_rels_to_query.
+		 * The child rel's RelOptInfo is created during
+		 * expand_inherited_tables().
 		 */
 		childrel = find_base_rel(root, childRTindex);
 		Assert(childrel->reloptkind == RELOPT_OTHER_MEMBER_REL);
 
 		/*
-		 * Copy/Modify targetlist. Even if this child is deemed empty, we need
-		 * its targetlist in case it falls on nullable side in a child-join
-		 * because of partitionwise join.
+		 * Child relation may have been marked dummy if build_append_child_rel
+		 * found self-contradictory quals.
+		 */
+		if (IS_DUMMY_REL(childrel))
+			continue;
+
+		if (relation_excluded_by_constraints(root, childrel, childRTE))
+		{
+			/*
+			 * This child need not be scanned, so we can omit it from the
+			 * appendrel.
+			 */
+			set_dummy_rel_pathlist(childrel);
+			continue;
+		}
+
+		/*
+		 * Copy/Modify targetlist.
 		 *
 		 * NB: the resulting childrel->reltarget->exprs may contain arbitrary
 		 * expressions, which otherwise would not occur in a rel's targetlist.
@@ -1091,144 +1088,6 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 									   root != subroot);
 		childrel->has_eclass_joins = rel->has_eclass_joins;
 
-		/*
-		 * We have to copy the parent's quals to the child, with appropriate
-		 * substitution of variables.  However, only the baserestrictinfo
-		 * quals are needed before we can check for constraint exclusion; so
-		 * do that first and then check to see if we can disregard this child.
-		 *
-		 * The child rel's targetlist might contain non-Var expressions, which
-		 * means that substitution into the quals could produce opportunities
-		 * for const-simplification, and perhaps even pseudoconstant quals.
-		 * Therefore, transform each RestrictInfo separately to see if it
-		 * reduces to a constant or pseudoconstant.  (We must process them
-		 * separately to keep track of the security level of each qual.)
-		 */
-		childquals = NIL;
-		cq_min_security = UINT_MAX;
-		have_const_false_cq = false;
-		foreach(lc, rel->baserestrictinfo)
-		{
-			RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
-			Node	   *childqual;
-			ListCell   *lc2;
-
-			Assert(IsA(rinfo, RestrictInfo));
-			childqual = adjust_appendrel_attrs(root,
-											   (Node *) rinfo->clause,
-											   1, &appinfo);
-			childqual = eval_const_expressions(root, childqual);
-			/* check for flat-out constant */
-			if (childqual && IsA(childqual, Const))
-			{
-				if (((Const *) childqual)->constisnull ||
-					!DatumGetBool(((Const *) childqual)->constvalue))
-				{
-					/* Restriction reduces to constant FALSE or NULL */
-					have_const_false_cq = true;
-					break;
-				}
-				/* Restriction reduces to constant TRUE, so drop it */
-				continue;
-			}
-			/* might have gotten an AND clause, if so flatten it */
-			foreach(lc2, make_ands_implicit((Expr *) childqual))
-			{
-				Node	   *onecq = (Node *) lfirst(lc2);
-				bool		pseudoconstant;
-
-				/* check for pseudoconstant (no Vars or volatile functions) */
-				pseudoconstant =
-					!contain_vars_of_level(onecq, 0) &&
-					!contain_volatile_functions(onecq);
-				if (pseudoconstant)
-				{
-					/* tell createplan.c to check for gating quals */
-					root->hasPseudoConstantQuals = true;
-				}
-				/* reconstitute RestrictInfo with appropriate properties */
-				childquals = lappend(childquals,
-									 make_restrictinfo((Expr *) onecq,
-													   rinfo->is_pushed_down,
-													   rinfo->outerjoin_delayed,
-													   pseudoconstant,
-													   rinfo->security_level,
-													   NULL, NULL, NULL));
-				/* track minimum security level among child quals */
-				cq_min_security = Min(cq_min_security, rinfo->security_level);
-			}
-		}
-
-		/*
-		 * In addition to the quals inherited from the parent, we might have
-		 * securityQuals associated with this particular child node.
-		 * (Currently this can only happen in appendrels originating from
-		 * UNION ALL; inheritance child tables don't have their own
-		 * securityQuals, see expand_inherited_rtentry().)	Pull any such
-		 * securityQuals up into the baserestrictinfo for the child.  This is
-		 * similar to process_security_barrier_quals() for the parent rel,
-		 * except that we can't make any general deductions from such quals,
-		 * since they don't hold for the whole appendrel.
-		 */
-		if (childRTE->securityQuals)
-		{
-			Index		security_level = 0;
-
-			foreach(lc, childRTE->securityQuals)
-			{
-				List	   *qualset = (List *) lfirst(lc);
-				ListCell   *lc2;
-
-				foreach(lc2, qualset)
-				{
-					Expr	   *qual = (Expr *) lfirst(lc2);
-
-					/* not likely that we'd see constants here, so no check */
-					childquals = lappend(childquals,
-										 make_restrictinfo(qual,
-														   true, false, false,
-														   security_level,
-														   NULL, NULL, NULL));
-					cq_min_security = Min(cq_min_security, security_level);
-				}
-				security_level++;
-			}
-			Assert(security_level <= root->qual_security_level);
-		}
-
-		/*
-		 * OK, we've got all the baserestrictinfo quals for this child.
-		 */
-		childrel->baserestrictinfo = childquals;
-		childrel->baserestrict_min_security = cq_min_security;
-
-		if (have_const_false_cq)
-		{
-			/*
-			 * Some restriction clause reduced to constant FALSE or NULL after
-			 * substitution, so this child need not be scanned.
-			 */
-			set_dummy_rel_pathlist(childrel);
-			continue;
-		}
-
-		if (did_pruning && !bms_is_member(appinfo->child_relid, live_children))
-		{
-			/* This partition was pruned; skip it. */
-			set_dummy_rel_pathlist(childrel);
-			continue;
-		}
-
-		if (relation_excluded_by_constraints(root, childrel, childRTE))
-		{
-			/*
-			 * This child need not be scanned, so we can omit it from the
-			 * appendrel.
-			 */
-			set_dummy_rel_pathlist(childrel);
-			continue;
-		}
-
 		/* CE failed, so finish copying/modifying join quals. */
 		childrel->joininfo = (List *)
 			adjust_appendrel_attrs(subroot,
@@ -1442,9 +1301,10 @@ adjust_inherit_target_child(PlannerInfo *root, RelOptInfo *childrel,
 	/*
 	 * Apply planner's expansion of targetlist, such as adding various junk
 	 * column, filling placeholder entries for dropped columns, etc., all of
-	 * which occurs with the child's TupleDesc.
+	 * which occurs with the child's TupleDesc.  Since inheritance has already
+	 * been expanded (we wouldn't be here otherwise), pass true.
 	 */
-	tlist = preprocess_targetlist(subroot);
+	tlist = preprocess_targetlist(subroot, true);
 	subroot->processed_tlist = tlist;
 	build_base_rel_tlists(subroot, tlist);
 
@@ -2842,6 +2702,7 @@ inheritance_make_rel_from_joinlist(PlannerInfo *root, List *joinlist)
 
 		Assert(subroot->parse->resultRelation > 0);
 		childrel = find_base_rel(root, subroot->parse->resultRelation);
+		Assert(childrel != NULL);
 		appinfo = root->append_rel_array[subroot->parse->resultRelation];
 
 		if (appinfo->parent_relid != root->parse->resultRelation)
diff --git a/src/backend/optimizer/path/joinrels.c b/src/backend/optimizer/path/joinrels.c
index d3d21fed5d..da0831de4e 100644
--- a/src/backend/optimizer/path/joinrels.c
+++ b/src/backend/optimizer/path/joinrels.c
@@ -20,6 +20,7 @@
 #include "optimizer/pathnode.h"
 #include "optimizer/paths.h"
 #include "optimizer/prep.h"
+#include "optimizer/tlist.h"
 #include "partitioning/partbounds.h"
 #include "utils/lsyscache.h"
 #include "utils/memutils.h"
@@ -46,6 +47,9 @@ static void try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1,
 					   List *parent_restrictlist);
 static int match_expr_to_partition_keys(Expr *expr, RelOptInfo *rel,
 							 bool strict_op);
+static RelOptInfo *build_dummy_partition_rel(PlannerInfo *root,
+									RelOptInfo *parent,
+									int partidx);
 
 
 /*
@@ -1376,6 +1380,11 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
 		AppendRelInfo **appinfos;
 		int			nappinfos;
 
+		if (child_rel1 == NULL)
+			child_rel1 = build_dummy_partition_rel(root, rel1, cnt_parts);
+		if (child_rel2 == NULL)
+			child_rel2 = build_dummy_partition_rel(root, rel2, cnt_parts);
+
 		/* We should never try to join two overlapping sets of rels. */
 		Assert(!bms_overlap(child_rel1->relids, child_rel2->relids));
 		child_joinrelids = bms_union(child_rel1->relids, child_rel2->relids);
@@ -1582,3 +1591,56 @@ match_expr_to_partition_keys(Expr *expr, RelOptInfo *rel, bool strict_op)
 
 	return -1;
 }
+
+/*
+ * build_dummy_partition_rel
+ *		Build a RelOptInfo and AppendRelInfo for a pruned partition
+ *
+ * This does not result in opening the relation or a range table entry being
+ * created.  Also, the RelOptInfo thus created is not stored anywhere else
+ * beside the parent's part_rels array.
+ *
+ * The only reason this exists is because partition-wise join, in some cases,
+ * needs a RelOptInfo to represent an empty relation that's on the nullable
+ * side of an outer join, so that a Path representing the outer join can be
+ * created.
+ */
+RelOptInfo *
+build_dummy_partition_rel(PlannerInfo *root, RelOptInfo *parent, int partidx)
+{
+	RangeTblEntry *parentrte = root->simple_rte_array[parent->relid];
+	RelOptInfo *rel;
+
+	Assert(parent->part_rels[partidx] == NULL);
+
+	/* Create minimally valid-looking RelOptInfo with parent's relid. */
+	rel = makeNode(RelOptInfo);
+	rel->reloptkind = RELOPT_OTHER_MEMBER_REL;
+	rel->relid = parent->relid;
+	rel->relids = bms_copy(parent->relids);
+	if (parent->top_parent_relids)
+		rel->top_parent_relids = parent->top_parent_relids;
+	else
+		rel->top_parent_relids = bms_copy(parent->relids);
+	rel->reltarget = copy_pathtarget(parent->reltarget);
+	parent->part_rels[partidx] = rel;
+	mark_dummy_rel(rel);
+
+	/*
+	 * Now we'll need a (no-op) AppendRelInfo for parent, because we're
+	 * setting the dummy partition's relid to be same as the parent's.
+	 */
+	if (root->append_rel_array[parent->relid] == NULL)
+	{
+		/* Pass parent's info as for both the parent rel and child rel. */
+		AppendRelInfo *appinfo = make_append_rel_info(parent, parentrte,
+													  parent->tupdesc,
+													  parentrte->relid,
+													  parent->reltype,
+													  parent->relid);
+
+		root->append_rel_array[parent->relid] = appinfo;
+	}
+
+	return rel;
+}
diff --git a/src/backend/optimizer/plan/initsplan.c b/src/backend/optimizer/plan/initsplan.c
index 01335db511..7636aa82c4 100644
--- a/src/backend/optimizer/plan/initsplan.c
+++ b/src/backend/optimizer/plan/initsplan.c
@@ -616,64 +616,6 @@ create_lateral_join_info(PlannerInfo *root)
 				bms_add_member(brel2->lateral_referencers, rti);
 		}
 	}
-
-	/*
-	 * Lastly, propagate lateral_relids and lateral_referencers from appendrel
-	 * parent rels to their child rels.  We intentionally give each child rel
-	 * the same minimum parameterization, even though it's quite possible that
-	 * some don't reference all the lateral rels.  This is because any append
-	 * path for the parent will have to have the same parameterization for
-	 * every child anyway, and there's no value in forcing extra
-	 * reparameterize_path() calls.  Similarly, a lateral reference to the
-	 * parent prevents use of otherwise-movable join rels for each child.
-	 */
-	for (rti = 1; rti < root->simple_rel_array_size; rti++)
-	{
-		RelOptInfo *brel = root->simple_rel_array[rti];
-		RangeTblEntry *brte = root->simple_rte_array[rti];
-
-		/*
-		 * Skip empty slots. Also skip non-simple relations i.e. dead
-		 * relations.
-		 */
-		if (brel == NULL || !IS_SIMPLE_REL(brel))
-			continue;
-
-		/*
-		 * In the case of table inheritance, the parent RTE is directly linked
-		 * to every child table via an AppendRelInfo.  In the case of table
-		 * partitioning, the inheritance hierarchy is expanded one level at a
-		 * time rather than flattened.  Therefore, an other member rel that is
-		 * a partitioned table may have children of its own, and must
-		 * therefore be marked with the appropriate lateral info so that those
-		 * children eventually get marked also.
-		 */
-		Assert(brte);
-		if (brel->reloptkind == RELOPT_OTHER_MEMBER_REL &&
-			(brte->rtekind != RTE_RELATION ||
-			 brte->relkind != RELKIND_PARTITIONED_TABLE))
-			continue;
-
-		if (brte->inh)
-		{
-			foreach(lc, root->append_rel_list)
-			{
-				AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(lc);
-				RelOptInfo *childrel;
-
-				if (appinfo->parent_relid != rti)
-					continue;
-				childrel = root->simple_rel_array[appinfo->child_relid];
-				Assert(childrel->reloptkind == RELOPT_OTHER_MEMBER_REL);
-				Assert(childrel->direct_lateral_relids == NULL);
-				childrel->direct_lateral_relids = brel->direct_lateral_relids;
-				Assert(childrel->lateral_relids == NULL);
-				childrel->lateral_relids = brel->lateral_relids;
-				Assert(childrel->lateral_referencers == NULL);
-				childrel->lateral_referencers = brel->lateral_referencers;
-			}
-		}
-	}
 }
 
 
diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index 722a1f55ce..1ee7d9585b 100644
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -23,6 +23,7 @@
 #include "access/sysattr.h"
 #include "access/xact.h"
 #include "catalog/pg_constraint.h"
+#include "catalog/pg_inherits.h"
 #include "catalog/pg_proc.h"
 #include "catalog/pg_type.h"
 #include "executor/executor.h"
@@ -699,27 +700,24 @@ subquery_planner(PlannerGlobal *glob, Query *parse,
 		}
 		if (rte->lateral)
 			root->hasLateralRTEs = true;
+
+		/*
+		 * While at it, also update the inh status.  If the relation doesn't
+		 * or can't have any children, there is no point in letting inh be set
+		 * to true.  Note that we do this before processing rowmarks, so that
+		 * the correct information for setting isParent field of PlanRowMarks.
+		 */
+		if (rte->rtekind == RTE_RELATION)
+			rte->inh = rte->inh && has_subclass(rte->relid);
 	}
 
 	/*
 	 * Preprocess RowMark information.  We need to do this after subquery
-	 * pullup (so that all non-inherited RTEs are present) and before
-	 * inheritance expansion (so that the info is available for
-	 * expand_inherited_tables to examine and modify).
+	 * pullup (so that all non-inherited RTEs are present).
 	 */
 	preprocess_rowmarks(root);
 
 	/*
-	 * Expand any rangetable entries that are inheritance sets into "append
-	 * relations".  This can add entries to the rangetable, but they must be
-	 * plain base relations not joins, so it's OK (and marginally more
-	 * efficient) to do it after checking for join RTEs.  We must do it after
-	 * pulling up subqueries, else we'd fail to handle inherited tables in
-	 * subqueries.
-	 */
-	expand_inherited_tables(root);
-
-	/*
 	 * Set hasHavingQual to remember if HAVING clause is present.  Needed
 	 * because preprocess_expression will reduce a constant-true condition to
 	 * an empty qual list ... but "HAVING TRUE" is not a semantic no-op.
@@ -1212,8 +1210,11 @@ inheritance_planner(PlannerInfo *root)
 	 */
 	root->unexpanded_tlist = list_copy(root->parse->targetList);
 
-	/* Do the scan/join planning. */
-	tlist = preprocess_targetlist(root);
+	/*
+	 * Do the scan/join planning.  We haven't expanded inheritance yet, so
+	 * pass false.
+	 */
+	tlist = preprocess_targetlist(root, false);
 	root->processed_tlist = tlist;
 	qp_extra.tlist = tlist;
 	qp_extra.activeWindows = qp_extra.groupClause = NIL;
@@ -1222,9 +1223,10 @@ inheritance_planner(PlannerInfo *root)
 	/*
 	 * If it turned out during query planning that all the children are dummy
 	 * (pruned or excluded by constraints), no need to do the steps below.
-	 * Let grouping_planner finish up the final path.
+	 * For regular inheritance case, it's possible that we only need to modify
+	 * the parent table.  Let grouping_planner finish up the final path.
 	 */
-	if (IS_DUMMY_REL(planned_rel))
+	if (!parent_rte->inh || IS_DUMMY_REL(planned_rel))
 	{
 		grouping_planner(root, false, planned_rel, 0.0);
 		return;
@@ -1569,14 +1571,19 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 		 */
 		if (planned_rel == NULL)
 		{
-			tlist = preprocess_targetlist(root);
+			/* We haven't expanded inheritance yet, so pass false. */
+			tlist = preprocess_targetlist(root, false);
 
 			/*
-			 * We are now done hacking up the query's targetlist.  Most of the
-			 * remaining planning work will be done with the PathTarget
-			 * representation of tlists, but save aside the full representation
-			 * so that we can transfer its decoration (resnames etc) to the
-			 * topmost tlist of the finished Plan.
+			 * We are now mostly done hacking up the query's targetlist.  More
+			 * columns might be added during query_planner after inheritance
+			 * expansion in make_one_rel, because some children may require
+			 * different column than the parent for row mark handling; see
+			 * add_rowmark_junk_columns().  Most of the remaining planning
+			 * work will be done with the PathTarget representation of tlists,
+			 * but save aside the full representation so that we can transfer
+			 * its decoration (resnames etc) to the topmost tlist of the
+			 * finished Plan.
 			 */
 			root->processed_tlist = tlist;
 		}
@@ -2352,7 +2359,7 @@ preprocess_rowmarks(PlannerInfo *root)
 		newrc->allMarkTypes = (1 << newrc->markType);
 		newrc->strength = rc->strength;
 		newrc->waitPolicy = rc->waitPolicy;
-		newrc->isParent = false;
+		newrc->isParent = rte->inh;
 
 		prowmarks = lappend(prowmarks, newrc);
 	}
@@ -2377,7 +2384,7 @@ preprocess_rowmarks(PlannerInfo *root)
 		newrc->allMarkTypes = (1 << newrc->markType);
 		newrc->strength = LCS_NONE;
 		newrc->waitPolicy = LockWaitBlock;	/* doesn't matter */
-		newrc->isParent = false;
+		newrc->isParent = rte->rtekind == RTE_RELATION ? rte->inh : false;
 
 		prowmarks = lappend(prowmarks, newrc);
 	}
@@ -6757,6 +6764,10 @@ apply_scanjoin_target_to_paths(PlannerInfo *root,
 			int			nappinfos;
 			List	   *child_scanjoin_targets = NIL;
 
+			/* Skip processing pruned partitions. */
+			if (child_rel == NULL)
+				continue;
+
 			/* Translate scan/join targets for this child. */
 			appinfos = find_appinfos_by_relids(root, child_rel->relids,
 											   &nappinfos);
@@ -6858,6 +6869,10 @@ create_partitionwise_grouping_paths(PlannerInfo *root,
 		RelOptInfo *child_grouped_rel;
 		RelOptInfo *child_partially_grouped_rel;
 
+		/* Skip processing pruned partitions. */
+		if (child_input_rel == NULL)
+			continue;
+
 		/* Input child rel must have a path */
 		Assert(child_input_rel->pathlist != NIL);
 
diff --git a/src/backend/optimizer/plan/setrefs.c b/src/backend/optimizer/plan/setrefs.c
index 6d6ef1c376..454870609a 100644
--- a/src/backend/optimizer/plan/setrefs.c
+++ b/src/backend/optimizer/plan/setrefs.c
@@ -326,6 +326,12 @@ add_rtes_to_flat_rtable(PlannerInfo *root, bool recursing)
 													  UPPERREL_FINAL, NULL)))
 					add_rtes_to_flat_rtable(rel->subroot, true);
 			}
+			/*
+			 * A NULL rel also means an unplanned subquery rte, so apply
+			 * flatten_unplanned_rtes.
+			 */
+			else
+				flatten_unplanned_rtes(glob, rte);
 		}
 		rti++;
 	}
diff --git a/src/backend/optimizer/prep/preptlist.c b/src/backend/optimizer/prep/preptlist.c
index 8603feef2b..0747403acd 100644
--- a/src/backend/optimizer/prep/preptlist.c
+++ b/src/backend/optimizer/prep/preptlist.c
@@ -65,9 +65,13 @@ static List *expand_targetlist(List *tlist, int command_type,
  *
  * As a side effect, if there's an ON CONFLICT UPDATE clause, its targetlist
  * is also preprocessed (and updated in-place).
+ *
+ * inheritance_expanded specifies whether inheritance tables are expanded
+ * as of calling this function.  Caller must specify it because that affects
+ * which row marking related junk columns get added to the targetlist.
  */
 List *
-preprocess_targetlist(PlannerInfo *root)
+preprocess_targetlist(PlannerInfo *root, bool inheritance_expanded)
 {
 	Query	   *parse = root->parse;
 	int			result_relation = parse->resultRelation;
@@ -134,6 +138,15 @@ preprocess_targetlist(PlannerInfo *root)
 		if (rc->rti != rc->prti)
 			continue;
 
+		/*
+		 * For inheritance parent row marks, we defer adding junk columns
+		 * until we've added child row marks, because some children might
+		 * require different row mark types which will change the parent row
+		 * mark's allMarkTypes fields.
+		 */
+		if (rc->isParent && !inheritance_expanded)
+			continue;
+
 		if (rc->allMarkTypes & ~(1 << ROW_MARK_COPY))
 		{
 			/* Need to fetch TID */
diff --git a/src/backend/optimizer/prep/prepunion.c b/src/backend/optimizer/prep/prepunion.c
index 134e7bafd9..96430a4cc7 100644
--- a/src/backend/optimizer/prep/prepunion.c
+++ b/src/backend/optimizer/prep/prepunion.c
@@ -39,15 +39,19 @@
 #include "miscadmin.h"
 #include "nodes/makefuncs.h"
 #include "nodes/nodeFuncs.h"
+#include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
 #include "optimizer/paths.h"
 #include "optimizer/planmain.h"
 #include "optimizer/planner.h"
 #include "optimizer/prep.h"
+#include "optimizer/restrictinfo.h"
 #include "optimizer/tlist.h"
+#include "optimizer/var.h"
 #include "parser/parse_coerce.h"
 #include "parser/parsetree.h"
+#include "partitioning/partprune.h"
 #include "utils/lsyscache.h"
 #include "utils/rel.h"
 #include "utils/selfuncs.h"
@@ -99,23 +103,26 @@ static List *generate_append_tlist(List *colTypes, List *colCollations,
 					  List *input_tlists,
 					  List *refnames_tlist);
 static List *generate_setop_grouplist(SetOperationStmt *op, List *targetlist);
+static void expand_append_rtentry(PlannerInfo *root, RelOptInfo *rel,
+					  RangeTblEntry *rte, Index rti);
 static void expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte,
-						 Index rti);
+						 Index rti, RelOptInfo *rel);
 static void expand_partitioned_rtentry(PlannerInfo *root,
 						   RangeTblEntry *parentrte,
-						   Index parentRTindex, Relation parentrel,
-						   PlanRowMark *top_parentrc, LOCKMODE lockmode,
-						   List **appinfos);
-static void expand_single_inheritance_child(PlannerInfo *root,
-								RangeTblEntry *parentrte,
-								Index parentRTindex, Relation parentrel,
-								PlanRowMark *top_parentrc, Relation childrel,
-								List **appinfos, RangeTblEntry **childrte_p,
-								Index *childRTindex_p);
-static void make_inh_translation_list(Relation oldrelation,
-						  Relation newrelation,
-						  Index newvarno,
-						  List **translated_vars);
+						   Index parentRTindex, RelOptInfo *parentrel);
+static RelOptInfo *add_inheritance_child_rel(PlannerInfo *root,
+						  RangeTblEntry *parentrte,
+						  Index parentRTindex, RelOptInfo *parentrel,
+						  PlanRowMark *top_parentrc, Relation childrel,
+						  RangeTblEntry **childrte_p, Index *childRTindex_p);
+static void make_inh_translation_list(TupleDesc old_tupdesc,
+						  TupleDesc new_tupdesc,
+						  Oid from_rel, Oid to_rel,
+						  Index newvarno, List **translated_vars);
+static RelOptInfo *build_append_child_rel(PlannerInfo *root,
+					   RelOptInfo *parent,
+					   Index childRTindex);
+static List *add_rowmark_junk_columns(PlannerInfo *root, PlanRowMark *rc);
 static Bitmapset *translate_col_privs(const Bitmapset *parent_privs,
 					List *translated_vars);
 static Node *adjust_appendrel_attrs_mutator(Node *node,
@@ -1472,33 +1479,134 @@ generate_setop_grouplist(SetOperationStmt *op, List *targetlist)
 void
 expand_inherited_tables(PlannerInfo *root)
 {
-	Index		nrtes;
+	int			orig_rtable_size;
 	Index		rti;
-	ListCell   *rl;
+
+	Assert(root->simple_rel_array_size > 0);
+	orig_rtable_size = root->simple_rel_array_size;
 
 	/*
-	 * expand_inherited_rtentry may add RTEs to parse->rtable. The function is
+	 * expand_append_rtentry may add RTEs to parse->rtable. The function is
 	 * expected to recursively handle any RTEs that it creates with inh=true.
 	 * So just scan as far as the original end of the rtable list.
 	 */
-	nrtes = list_length(root->parse->rtable);
-	rl = list_head(root->parse->rtable);
-	for (rti = 1; rti <= nrtes; rti++)
+	for (rti = 1; rti < orig_rtable_size; rti++)
 	{
-		RangeTblEntry *rte = (RangeTblEntry *) lfirst(rl);
+		RelOptInfo *brel = root->simple_rel_array[rti];
+		RangeTblEntry *rte = root->simple_rte_array[rti];
 
-		expand_inherited_rtentry(root, rte, rti);
-		rl = lnext(rl);
+		/* there may be empty slots corresponding to non-baserel RTEs */
+		if (brel == NULL)
+			continue;
+
+		if (rte->inh)
+			expand_append_rtentry(root, brel, rte, rti);
+	}
+}
+
+/*
+ * expand_append_rtentry
+ *		This initializes RelOptInfos for an appendrel's child relations, if
+ *		any
+ *
+ * 'rel' is the appendrel parent, whose range table entry ('rte') has been
+ * marked to require adding children.  An appendrel parent could either
+ * be a subquery (if we flattened UNION ALL query) or a table that's known
+ * to have inheritance children.  The latter consists of both regular
+ * inheritance parents and partitioned tables.
+ *
+ * For a subquery parent, there is not much to be done here because the
+ * children's RTEs are already present in the query, so we just initialize
+ * RelOptInfos for them.  Also, the AppendRelInfos for child subqueries
+ * have already been added.
+ *
+ * For tables, we need to add the children to the range table and initialize
+ * AppendRelInfos, RelOptInfos, and PlanRowMarks (if any) for them.  For
+ * a partitioned parent, we only add the children remaining after pruning.
+ * For regular inheritance parents, we find the children using
+ * find_all_inheritors and add all of them.
+ *
+ * If it turns out that there are no children, then we set rte->inh to false
+ * to let the caller know that only the parent table needs to be scanned.  The
+ * caller can accordingly switch to a non-Append path.  For a partitioned
+ * parent, that means an empty relation because parents themselves contain no
+ * data.
+ *
+ * For the regular inheritance case, the parent also gets another RTE with
+ * inh = false to represent it as an appendrel child.  The original RTE is
+ * considered to represent the whole inheritance set.
+ */
+static void
+expand_append_rtentry(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte,
+					  Index rti)
+{
+	Assert(rte->inh);
+	/* Inheritance parent (partitioned or not) or UNION ALL parent subquery. */
+	Assert(rte->rtekind == RTE_RELATION || rte->rtekind == RTE_SUBQUERY);
+
+	/*
+	 * UNION ALL children already got RTEs and AppendRelInfos, so just build
+	 * RelOptInfos and return.
+	 *
+	 * It might be a bit odd that this code is in this, because there is
+	 * nothing to expand really.
+	 */
+	if (rte->rtekind == RTE_SUBQUERY)
+	{
+		ListCell   *l;
+
+		/*
+		 * We don't need to use expand_planner_arrays in this case, because
+		 * no new child RTEs are created.  setup_simple_rel_arrays() and
+		 * setup_append_rel_array would've considered these child RTEs when
+		 * allocating space for various arrays.
+		 */
+		foreach(l, root->append_rel_list)
+		{
+			AppendRelInfo *appinfo = lfirst(l);
+			Index		childRTindex = appinfo->child_relid;
+
+			if (appinfo->parent_relid != rti)
+				continue;
+
+			Assert(childRTindex < root->simple_rel_array_size);
+			Assert(root->simple_rte_array[childRTindex] != NULL);
+
+			/*
+			 * We set the correct value of baserestricinfo and
+			 * baserestrict_min_security below.
+			 */
+			root->simple_rel_array[childRTindex] =
+				build_append_child_rel(root, rel, appinfo->child_relid);
+		}
+	}
+	else
+	{
+		Assert(rte->rtekind == RTE_RELATION);
+		Assert(has_subclass(rte->relid));
+
+		/*
+		 * The rewriter should already have obtained an appropriate lock on
+		 * each relation named in the query.  However, for each child relation
+		 * we add to the query, we must obtain an appropriate lock, because
+		 * this will be the first use of those relations in the
+		 * parse/rewrite/plan pipeline.  Child rels should use the same
+		 * lockmode as their parent.
+		 */
+		Assert(rte->rellockmode != NoLock);
+
+		if (rte->relkind == RELKIND_PARTITIONED_TABLE)
+			expand_partitioned_rtentry(root, rte, rti, rel);
+		else
+			expand_inherited_rtentry(root, rte, rti, rel);
 	}
 }
 
 /*
  * expand_inherited_rtentry
- *		Check whether a rangetable entry represents an inheritance set.
- *		If so, add entries for all the child tables to the query's
- *		rangetable, and build AppendRelInfo nodes for all the child tables
- *		and add them to root->append_rel_list.  If not, clear the entry's
- *		"inh" flag to prevent later code from looking for AppendRelInfos.
+ *		Add entries for all the child tables to the query's rangetable, and
+ *		build AppendRelInfo nodes for all the child tables and add them to
+ *		root->append_rel_list.
  *
  * Note that the original RTE is considered to represent the whole
  * inheritance set.  The first of the generated RTEs is an RTE for the same
@@ -1509,55 +1617,33 @@ expand_inherited_tables(PlannerInfo *root)
  * regular inheritance, a parent RTE must always have at least two associated
  * AppendRelInfos: one corresponding to the parent table as a simple member of
  * inheritance set and one or more corresponding to the actual children.
- * Since a partitioned table is not scanned, it might have only one associated
- * AppendRelInfo.
  */
 static void
-expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti)
+expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti,
+						 RelOptInfo *rel)
 {
 	Oid			parentOID;
 	PlanRowMark *oldrc;
-	Relation	oldrelation;
-	LOCKMODE	lockmode;
+	LOCKMODE	lockmode = rte->rellockmode;
 	List	   *inhOIDs;
 	ListCell   *l;
+	int			num_children;
+	int			num_children_added = 0;
 
-	/* Does RT entry allow inheritance? */
-	if (!rte->inh)
-		return;
-	/* Ignore any already-expanded UNION ALL nodes */
-	if (rte->rtekind != RTE_RELATION)
-	{
-		Assert(rte->rtekind == RTE_SUBQUERY);
-		return;
-	}
-	/* Fast path for common case of childless table */
+	Assert(rte->rtekind == RTE_RELATION);
+	Assert(lockmode != NoLock);
 	parentOID = rte->relid;
-	if (!has_subclass(parentOID))
-	{
-		/* Clear flag before returning */
-		rte->inh = false;
-		return;
-	}
-
-	/*
-	 * The rewriter should already have obtained an appropriate lock on each
-	 * relation named in the query.  However, for each child relation we add
-	 * to the query, we must obtain an appropriate lock, because this will be
-	 * the first use of those relations in the parse/rewrite/plan pipeline.
-	 * Child rels should use the same lockmode as their parent.
-	 */
-	lockmode = rte->rellockmode;
 
 	/* Scan for all members of inheritance set, acquire needed locks */
 	inhOIDs = find_all_inheritors(parentOID, lockmode, NULL);
 
 	/*
 	 * Check that there's at least one descendant, else treat as no-child
-	 * case.  This could happen despite above has_subclass() check, if table
-	 * once had a child but no longer does.
+	 * case.  This could happen despite has_subclass() check performed by
+	 * subquery_planner, if table once had a child but no longer does.
 	 */
-	if (list_length(inhOIDs) < 2)
+	num_children = list_length(inhOIDs);
+	if (num_children < 2)
 	{
 		/* Clear flag before returning */
 		rte->inh = false;
@@ -1565,216 +1651,219 @@ expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti)
 	}
 
 	/*
-	 * If parent relation is selected FOR UPDATE/SHARE, we need to mark its
-	 * PlanRowMark as isParent = true, and generate a new PlanRowMark for each
-	 * child.
+	 * If parent relation is selected FOR UPDATE/SHARE, preprocess_rowmarks
+	 * should've set isParent = true.  We'll generate a new PlanRowMark for
+	 * each child.
 	 */
 	oldrc = get_plan_rowmark(root->rowMarks, rti);
-	if (oldrc)
-		oldrc->isParent = true;
+	Assert(oldrc == NULL || oldrc->isParent);
 
 	/*
-	 * Must open the parent relation to examine its tupdesc.  We need not lock
-	 * it; we assume the rewriter already did.
+	 * Must expand PlannerInfo arrays by num_children before we can add
+	 * children.
 	 */
-	oldrelation = heap_open(parentOID, NoLock);
+	expand_planner_arrays(root, num_children);
 
-	/* Scan the inheritance set and expand it */
-	if (RelationGetPartitionDesc(oldrelation) != NULL)
+	foreach(l, inhOIDs)
 	{
-		Assert(rte->relkind == RELKIND_PARTITIONED_TABLE);
-
-		/*
-		 * If this table has partitions, recursively expand them in the order
-		 * in which they appear in the PartitionDesc.  While at it, also
-		 * extract the partition key columns of all the partitioned tables.
-		 */
-		expand_partitioned_rtentry(root, rte, rti, oldrelation, oldrc,
-								   lockmode, &root->append_rel_list);
-	}
-	else
-	{
-		List	   *appinfos = NIL;
+		Oid			childOID = lfirst_oid(l);
+		Relation	newrelation;
 		RangeTblEntry *childrte;
 		Index		childRTindex;
 
+		/* Already locked above. */
+		newrelation = heap_open(childOID, NoLock);
+
 		/*
-		 * This table has no partitions.  Expand any plain inheritance
-		 * children in the order the OIDs were returned by
-		 * find_all_inheritors.
+		 * It is possible that the parent table has children that are temp
+		 * tables of other backends.  We cannot safely access such tables
+		 * (because of buffering issues), and the best thing to do seems
+		 * to be to silently ignore them.
 		 */
-		foreach(l, inhOIDs)
+		if (RELATION_IS_OTHER_TEMP(newrelation))
 		{
-			Oid			childOID = lfirst_oid(l);
-			Relation	newrelation;
-
-			/* Open rel if needed; we already have required locks */
-			if (childOID != parentOID)
-				newrelation = heap_open(childOID, NoLock);
-			else
-				newrelation = oldrelation;
-
-			/*
-			 * It is possible that the parent table has children that are temp
-			 * tables of other backends.  We cannot safely access such tables
-			 * (because of buffering issues), and the best thing to do seems
-			 * to be to silently ignore them.
-			 */
-			if (childOID != parentOID && RELATION_IS_OTHER_TEMP(newrelation))
-			{
-				heap_close(newrelation, lockmode);
-				continue;
-			}
-
-			expand_single_inheritance_child(root, rte, rti, oldrelation, oldrc,
-											newrelation,
-											&appinfos, &childrte,
-											&childRTindex);
-
-			/* Close child relations, but keep locks */
-			if (childOID != parentOID)
-				heap_close(newrelation, NoLock);
+			heap_close(newrelation, lockmode);
+			continue;
 		}
 
-		/*
-		 * If all the children were temp tables, pretend it's a
-		 * non-inheritance situation; we don't need Append node in that case.
-		 * The duplicate RTE we added for the parent table is harmless, so we
-		 * don't bother to get rid of it; ditto for the useless PlanRowMark
-		 * node.
-		 */
-		if (list_length(appinfos) < 2)
-			rte->inh = false;
-		else
-			root->append_rel_list = list_concat(root->append_rel_list,
-												appinfos);
+		(void) add_inheritance_child_rel(root, rte, rti, rel, oldrc,
+										 newrelation, &childrte,
+										 &childRTindex);
+		Assert(childrte != NULL);
+		/* All regular inheritance children are leaf children. */
+		Assert(!childrte->inh);
+		Assert(childRTindex > 0);
 
+		/* Close child relations, but keep locks */
+		heap_close(newrelation, NoLock);
+		num_children_added++;
 	}
 
-	heap_close(oldrelation, NoLock);
+	/*
+	 * If all children, including the parent (as child rel), were
+	 * excluded, mark the parent rel as empty.  If all the children were temp
+	 * tables, pretend it's a non-inheritance situation; we don't need Append
+	 * node in that case.  The duplicate RTE we added for the parent table is
+	 * harmless, so we don't bother to get rid of it; ditto for the useless
+	 * PlanRowMark node.
+	 */
+	if (num_children_added == 0)
+		mark_dummy_rel(rel);
+	else if (num_children_added == 1)
+		rte->inh = false;
+
+	/*
+	 * Add junk columns needed by the row mark if any and also add the
+	 * relevant expressions to the root parent's reltarget.
+	 */
+	if (oldrc)
+	{
+		List   *tlist = add_rowmark_junk_columns(root, oldrc);
+
+		build_base_rel_tlists(root, tlist);
+	}
 }
 
 /*
  * expand_partitioned_rtentry
- *		Recursively expand an RTE for a partitioned table.
+ *		Prunes unnecessary partitions of a partitioned table and adds
+ *		remaining ones to the Query and the PlannerInfo
+ *
+ * Partitions are added to the query in order in which they are found in
+ * the parent's PartitionDesc.
+ *
+ * Note: even though only the unpruned partitions will be added to the
+ * resulting plan, this still locks *all* partitions via find_all_inheritors
+ * when this function is called for the root partitioned table.
  */
 static void
 expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
-						   Index parentRTindex, Relation parentrel,
-						   PlanRowMark *top_parentrc, LOCKMODE lockmode,
-						   List **appinfos)
+						   Index parentRTindex, RelOptInfo *parentrel)
 {
+	LOCKMODE	lockmode = parentrte->rellockmode;
+	PlanRowMark *rootrc = NULL;
 	int			i;
-	RangeTblEntry *childrte;
-	Index		childRTindex;
-	PartitionDesc partdesc = RelationGetPartitionDesc(parentrel);
+	Bitmapset  *partindexes;
+	Index		rootParentRTindex = parentrel->inh_root_parent > 0 ?
+									parentrel->inh_root_parent :
+									parentRTindex;
 
-	check_stack_depth();
-
-	/* A partitioned table should always have a partition descriptor. */
-	Assert(partdesc);
-
-	Assert(parentrte->inh);
+	/* If root partitioned table, lock *all* partitions in the tree. */
+	if (parentRTindex == rootParentRTindex)
+		(void) find_all_inheritors(parentrte->relid, lockmode, NULL);
 
 	/*
-	 * Note down whether any partition key cols are being updated. Though it's
-	 * the root partitioned table's updatedCols we are interested in, we
-	 * instead use parentrte to get the updatedCols. This is convenient
-	 * because parentrte already has the root partrel's updatedCols translated
-	 * to match the attribute ordering of parentrel.
+	 * Initialize partitioned_child_rels to contain this RT index.
+	 *
+	 * Note that during the set_append_rel_pathlist() phase, values of the
+	 * indexes of partitioned relations that appear down in the tree will be
+	 * bubbled up into root parent's list so that when we've created Paths for
+	 * all the children, the root table's list will contain all such indexes.
 	 */
-	if (!root->partColsUpdated)
-		root->partColsUpdated =
-			has_partition_attrs(parentrel, parentrte->updatedCols, NULL);
+	parentrel->partitioned_child_rels = list_make1_int(parentRTindex);
 
-	/* First expand the partitioned table itself. */
-	expand_single_inheritance_child(root, parentrte, parentRTindex, parentrel,
-									top_parentrc, parentrel,
-									appinfos, &childrte, &childRTindex);
+	/* Perform pruning. */
+	partindexes = prune_append_rel_partitions(parentrel);
+
+	/* Must expand PlannerInfo arrays before we can add children. */
+	expand_planner_arrays(root, bms_num_members(partindexes));
 
 	/*
-	 * If the partitioned table has no partitions, treat this as the
-	 * non-inheritance case.
+	 * For partitioned tables, we also store the partition RelOptInfo
+	 * pointers in the parent's RelOptInfo.
 	 */
-	if (partdesc->nparts == 0)
-	{
-		parentrte->inh = false;
-		return;
-	}
+	parentrel->part_rels = (RelOptInfo **) palloc0(sizeof(RelOptInfo *) *
+												   parentrel->nparts);
 
-	for (i = 0; i < partdesc->nparts; i++)
+	rootrc = get_plan_rowmark(root->rowMarks, rootParentRTindex);
+	Assert(rootrc == NULL || rootrc->isParent);
+	i = -1;
+	while ((i = bms_next_member(partindexes, i)) >= 0)
 	{
-		Oid			childOID = partdesc->oids[i];
-		Relation	childrel;
+		Oid		childOID = parentrel->part_oids[i];
+		Relation	newrelation;
+		RelOptInfo *childrel;
+		RangeTblEntry *childrte;
+		Index		childRTindex;
 
-		/* Open rel; we already have required locks */
-		childrel = heap_open(childOID, NoLock);
+		/* Already locked above. */
+		newrelation = heap_open(childOID, NoLock);
+		Assert(!RELATION_IS_OTHER_TEMP(newrelation));
 
 		/*
-		 * Temporary partitions belonging to other sessions should have been
-		 * disallowed at definition, but for paranoia's sake, let's double
-		 * check.
+		 * A partitioned child table with 0 children is a dummy rel, so don't
+		 * bother creating planner objects for it.
 		 */
-		if (RELATION_IS_OTHER_TEMP(childrel))
-			elog(ERROR, "temporary relation from another session found as partition");
+		if (newrelation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE &&
+			RelationGetPartitionDesc(newrelation)->nparts == 0)
+		{
+			heap_close(newrelation, NoLock);
+			continue;
+		}
 
-		expand_single_inheritance_child(root, parentrte, parentRTindex,
-										parentrel, top_parentrc, childrel,
-										appinfos, &childrte, &childRTindex);
+		childrel = add_inheritance_child_rel(root, parentrte, parentRTindex,
+											 parentrel, rootrc, newrelation,
+											 &childrte, &childRTindex);
+		Assert(childrel != NULL);
+		parentrel->part_rels[i] = childrel;
 
-		/* If this child is itself partitioned, recurse */
-		if (childrel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
+		/* Close child relations, but keep locks */
+		heap_close(newrelation, NoLock);
+
+		/* If the child is partitioned itself, expand it too. */
+		if (childrel->part_scheme)
+		{
+			Assert(childrte->inh);
 			expand_partitioned_rtentry(root, childrte, childRTindex,
-									   childrel, top_parentrc, lockmode,
-									   appinfos);
+									   childrel);
+		}
+	}
 
-		/* Close child relation, but keep locks */
-		heap_close(childrel, NoLock);
+	/*
+	 * Add junk columns needed by the row mark if any and also add the
+	 * relevant expressions to the root parent's reltarget.
+	 */
+	if (rootrc)
+	{
+		List   *tlist = add_rowmark_junk_columns(root, rootrc);
+
+		build_base_rel_tlists(root, tlist);
 	}
 }
 
 /*
- * expand_single_inheritance_child
- *		Build a RangeTblEntry and an AppendRelInfo, if appropriate, plus
- *		maybe a PlanRowMark.
+ * add_inheritance_child_rel
+ *		Build a RangeTblEntry, an AppendRelInfo, a PlanRowMark, and finally
+ *		a RelOptInfo for an inheritance child relation.
  *
- * We now expand the partition hierarchy level by level, creating a
- * corresponding hierarchy of AppendRelInfos and RelOptInfos, where each
- * partitioned descendant acts as a parent of its immediate partitions.
- * (This is a difference from what older versions of PostgreSQL did and what
- * is still done in the case of table inheritance for unpartitioned tables,
- * where the hierarchy is flattened during RTE expansion.)
+ * The return value is the RelOptInfo that's added.
  *
  * PlanRowMarks still carry the top-parent's RTI, and the top-parent's
  * allMarkTypes field still accumulates values from all descendents.
  *
  * "parentrte" and "parentRTindex" are immediate parent's RTE and
  * RTI. "top_parentrc" is top parent's PlanRowMark.
- *
- * The child RangeTblEntry and its RTI are returned in "childrte_p" and
- * "childRTindex_p" resp.
  */
-static void
-expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte,
-								Index parentRTindex, Relation parentrel,
-								PlanRowMark *top_parentrc, Relation childrel,
-								List **appinfos, RangeTblEntry **childrte_p,
-								Index *childRTindex_p)
+static RelOptInfo *
+add_inheritance_child_rel(PlannerInfo *root, RangeTblEntry *parentrte,
+						  Index parentRTindex, RelOptInfo *parentrel,
+						  PlanRowMark *top_parentrc, Relation childrel,
+						  RangeTblEntry **childrte_p, Index *childRTindex_p)
 {
 	Query	   *parse = root->parse;
-	Oid			parentOID = RelationGetRelid(parentrel);
 	Oid			childOID = RelationGetRelid(childrel);
 	RangeTblEntry *childrte;
 	Index		childRTindex;
 	AppendRelInfo *appinfo;
+	RelOptInfo *childrelopt;
 
 	/*
 	 * Build an RTE for the child, and attach to query's rangetable list. We
 	 * copy most fields of the parent's RTE, but replace relation OID and
-	 * relkind, and set inh = false.  Also, set requiredPerms to zero since
-	 * all required permissions checks are done on the original RTE. Likewise,
-	 * set the child's securityQuals to empty, because we only want to apply
-	 * the parent's RLS conditions regardless of what RLS properties
+	 * relkind, and set inh appropriately.  Also, set requiredPerms to zero
+	 * since all required permissions checks are done on the original RTE.
+	 * Likewise, set the child's securityQuals to empty, because we only want
+	 * to apply the parent's RLS conditions regardless of what RLS properties
 	 * individual children may have.  (This is an intentional choice to make
 	 * inherited RLS work like regular permissions checks.) The parent
 	 * securityQuals will be propagated to children along with other base
@@ -1784,55 +1873,42 @@ expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte,
 	*childrte_p = childrte;
 	childrte->relid = childOID;
 	childrte->relkind = childrel->rd_rel->relkind;
-	/* A partitioned child will need to be expanded further. */
-	if (childOID != parentOID &&
-		childrte->relkind == RELKIND_PARTITIONED_TABLE)
-		childrte->inh = true;
-	else
-		childrte->inh = false;
+	/*
+	 * A partitioned child will need to be expanded as an append parent
+	 * itself, so set its inh to true.
+	 */
+	childrte->inh = (childrte->relkind == RELKIND_PARTITIONED_TABLE);
 	childrte->requiredPerms = 0;
 	childrte->securityQuals = NIL;
 	parse->rtable = lappend(parse->rtable, childrte);
 	childRTindex = list_length(parse->rtable);
 	*childRTindex_p = childRTindex;
 
-	/*
-	 * We need an AppendRelInfo if paths will be built for the child RTE. If
-	 * childrte->inh is true, then we'll always need to generate append paths
-	 * for it.  If childrte->inh is false, we must scan it if it's not a
-	 * partitioned table; but if it is a partitioned table, then it never has
-	 * any data of its own and need not be scanned.
-	 */
-	if (childrte->relkind != RELKIND_PARTITIONED_TABLE || childrte->inh)
-	{
-		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->translated_vars);
-		appinfo->parent_reloid = parentOID;
-		*appinfos = lappend(*appinfos, appinfo);
+	/* Create an AppendRelInfo and add it to planner's global list. */
+	appinfo = make_append_rel_info(parentrel, parentrte,
+								   childrel->rd_att,
+								   childOID,
+								   childrel->rd_rel->reltype,
+								   childRTindex);
+	root->append_rel_list = lappend(root->append_rel_list, appinfo);
 
-		/*
-		 * Translate the column permissions bitmaps to the child's attnums (we
-		 * have to build the translated_vars list before we can do this). But
-		 * if this is the parent table, leave copyObject's result alone.
-		 *
-		 * Note: we need to do this even though the executor won't run any
-		 * permissions checks on the child RTE.  The insertedCols/updatedCols
-		 * bitmaps may be examined for trigger-firing purposes.
-		 */
-		if (childOID != parentOID)
-		{
-			childrte->selectedCols = translate_col_privs(parentrte->selectedCols,
-														 appinfo->translated_vars);
-			childrte->insertedCols = translate_col_privs(parentrte->insertedCols,
-														 appinfo->translated_vars);
-			childrte->updatedCols = translate_col_privs(parentrte->updatedCols,
-														appinfo->translated_vars);
-		}
+	/*
+	 * Translate the column permissions bitmaps to the child's attnums (we
+	 * have to build the translated_vars list before we can do this). But
+	 * if this is the parent table, leave copyObject's result alone.
+	 *
+	 * Note: we need to do this even though the executor won't run any
+	 * permissions checks on the child RTE.  The insertedCols/updatedCols
+	 * bitmaps may be examined for trigger-firing purposes.
+	 */
+	if (childrte->relid != parentrte->relid)
+	{
+		childrte->selectedCols = translate_col_privs(parentrte->selectedCols,
+													 appinfo->translated_vars);
+		childrte->insertedCols = translate_col_privs(parentrte->insertedCols,
+													 appinfo->translated_vars);
+		childrte->updatedCols = translate_col_privs(parentrte->updatedCols,
+													appinfo->translated_vars);
 	}
 
 	/*
@@ -1864,6 +1940,24 @@ expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte,
 
 		root->rowMarks = lappend(root->rowMarks, childrc);
 	}
+
+	/*
+	 * Add the RelOptInfo.  Even though we may not really scan this relation
+	 * for reasons such as contradictory quals, we still need to create one,
+	 * because for every RTE in the query's range table, there must be an
+	 * accompanying RelOptInfo.
+	 */
+
+	/* First, store the RTE and appinfos into planner arrays. */
+	Assert(root->simple_rte_array[childRTindex] == NULL);
+	root->simple_rte_array[childRTindex] = childrte;
+	Assert(root->append_rel_array[childRTindex] == NULL);
+	root->append_rel_array[childRTindex] = appinfo;
+
+	childrelopt = build_append_child_rel(root, parentrel, childRTindex);
+	Assert(childrelopt != NULL);
+
+	return childrelopt;
 }
 
 /*
@@ -1874,14 +1968,11 @@ expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte,
  * For paranoia's sake, we match type/collation as well as attribute name.
  */
 static void
-make_inh_translation_list(Relation oldrelation, Relation newrelation,
-						  Index newvarno,
-						  List **translated_vars)
+make_inh_translation_list(TupleDesc old_tupdesc, TupleDesc new_tupdesc,
+						  Oid from_rel, Oid to_rel,
+						  Index newvarno, List **translated_vars)
 {
 	List	   *vars = NIL;
-	TupleDesc	old_tupdesc = RelationGetDescr(oldrelation);
-	TupleDesc	new_tupdesc = RelationGetDescr(newrelation);
-	Oid			new_relid = RelationGetRelid(newrelation);
 	int			oldnatts = old_tupdesc->natts;
 	int			newnatts = new_tupdesc->natts;
 	int			old_attno;
@@ -1911,7 +2002,7 @@ make_inh_translation_list(Relation oldrelation, Relation newrelation,
 		 * When we are generating the "translation list" for the parent table
 		 * of an inheritance set, no need to search for matches.
 		 */
-		if (oldrelation == newrelation)
+		if (from_rel == to_rel)
 		{
 			vars = lappend(vars, makeVar(newvarno,
 										 (AttrNumber) (old_attno + 1),
@@ -1937,10 +2028,10 @@ make_inh_translation_list(Relation oldrelation, Relation newrelation,
 		{
 			HeapTuple	newtup;
 
-			newtup = SearchSysCacheAttName(new_relid, attname);
+			newtup = SearchSysCacheAttName(to_rel, attname);
 			if (!newtup)
 				elog(ERROR, "could not find inherited attribute \"%s\" of relation \"%s\"",
-					 attname, RelationGetRelationName(newrelation));
+					 attname, get_rel_name(to_rel));
 			new_attno = ((Form_pg_attribute) GETSTRUCT(newtup))->attnum - 1;
 			ReleaseSysCache(newtup);
 
@@ -1950,10 +2041,10 @@ make_inh_translation_list(Relation oldrelation, Relation newrelation,
 		/* Found it, check type and collation match */
 		if (atttypid != att->atttypid || atttypmod != att->atttypmod)
 			elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's type",
-				 attname, RelationGetRelationName(newrelation));
+				 attname, get_rel_name(to_rel));
 		if (attcollation != att->attcollation)
 			elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's collation",
-				 attname, RelationGetRelationName(newrelation));
+				 attname, get_rel_name(to_rel));
 
 		vars = lappend(vars, makeVar(newvarno,
 									 (AttrNumber) (new_attno + 1),
@@ -2020,6 +2111,255 @@ translate_col_privs(const Bitmapset *parent_privs,
 }
 
 /*
+ *	build_append_child_rel
+ *		Build a RelOptInfo for child relation of an append rel
+ *
+ * After creating the RelOptInfo for the given child RT index, it goes on to
+ * initialize some of its fields based on the parent RelOptInfo.
+ *
+ * If the quals in baserestrictinfo turn out to be self-contradictory,
+ * RelOptInfo is marked dummy before returning.
+ */
+static RelOptInfo *
+build_append_child_rel(PlannerInfo *root,
+					   RelOptInfo *parent,
+					   Index childRTindex)
+{
+	RelOptInfo *childrel;
+	RangeTblEntry *childRTE = root->simple_rte_array[childRTindex];
+	AppendRelInfo *appinfo = root->append_rel_array[childRTindex];
+	List	   *childquals;
+	ListCell   *lc;
+	bool		have_const_false_cq;
+	Index		cq_min_security;
+
+	/* Build the RelOptInfo. */
+	childrel = build_simple_rel(root, childRTindex, parent);
+
+	/*
+	 * Propagate lateral_relids and lateral_referencers from appendrel
+	 * parent rels to their child rels.  We intentionally give each child rel
+	 * the same minimum parameterization, even though it's quite possible that
+	 * some don't reference all the lateral rels.  This is because any append
+	 * path for the parent will have to have the same parameterization for
+	 * every child anyway, and there's no value in forcing extra
+	 * reparameterize_path() calls.  Similarly, a lateral reference to the
+	 * parent prevents use of otherwise-movable join rels for each child.
+	 */
+	childrel->direct_lateral_relids = parent->direct_lateral_relids;
+	childrel->lateral_relids = parent->lateral_relids;
+	childrel->lateral_referencers = parent->lateral_referencers;
+
+	/*
+	 * We have to copy the parent's quals to the child, with appropriate
+	 * substitution of variables.  However, only the baserestrictinfo
+	 * quals are needed before we can check for constraint exclusion; so
+	 * do that first and then check to see if we can disregard this child.
+	 *
+	 * The child rel's targetlist might contain non-Var expressions, which
+	 * means that substitution into the quals could produce opportunities
+	 * for const-simplification, and perhaps even pseudoconstant quals.
+	 * Therefore, transform each RestrictInfo separately to see if it
+	 * reduces to a constant or pseudoconstant.  (We must process them
+	 * separately to keep track of the security level of each qual.)
+	 */
+	childquals = false;
+	cq_min_security = UINT_MAX;
+	have_const_false_cq = false;
+	foreach(lc, parent->baserestrictinfo)
+	{
+		RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
+		Node	   *childqual = (Node *) rinfo->clause;
+		ListCell   *lc2;
+
+		Assert(IsA(rinfo, RestrictInfo));
+		childqual = adjust_appendrel_attrs(root, childqual,
+										   1, &appinfo);
+		childqual = eval_const_expressions(root, childqual);
+		/* check for flat-out constant */
+		if (childqual && IsA(childqual, Const))
+		{
+			if (((Const *) childqual)->constisnull ||
+				!DatumGetBool(((Const *) childqual)->constvalue))
+			{
+				/* Restriction reduces to constant FALSE or NULL */
+				have_const_false_cq = true;
+				break;
+			}
+			/* Restriction reduces to constant TRUE, so drop it */
+			continue;
+		}
+		/* might have gotten an AND clause, if so flatten it */
+		foreach(lc2, make_ands_implicit((Expr *) childqual))
+		{
+			Node	   *onecq = (Node *) lfirst(lc2);
+			bool		pseudoconstant;
+
+			/* check for pseudoconstant (no Vars or volatile functions) */
+			pseudoconstant =
+					!contain_vars_of_level(onecq, 0) &&
+					!contain_volatile_functions(onecq);
+			if (pseudoconstant)
+			{
+				/* tell createplan.c to check for gating quals */
+				root->hasPseudoConstantQuals = true;
+			}
+			/* reconstitute RestrictInfo with appropriate properties */
+			childquals = lappend(childquals,
+								 make_restrictinfo((Expr *) onecq,
+												   rinfo->is_pushed_down,
+												   rinfo->outerjoin_delayed,
+												   pseudoconstant,
+												   rinfo->security_level,
+												   NULL, NULL, NULL));
+			cq_min_security = Min(cq_min_security, rinfo->security_level);
+		}
+	}
+
+	/*
+	 * In addition to the quals inherited from the parent, we might
+	 * have securityQuals associated with this particular child node.
+	 * (Currently this can only happen in appendrels originating from
+	 * UNION ALL; inheritance child tables don't have their own
+	 * securityQuals.)	Pull any such securityQuals up into the
+	 * baserestrictinfo for the child.  This is similar to
+	 * process_security_barrier_quals() for the parent rel, except
+	 * that we can't make any general deductions from such quals,
+	 * since they don't hold for the whole appendrel.
+	 */
+	if (childRTE->securityQuals)
+	{
+		Index		security_level = 0;
+
+		foreach(lc, childRTE->securityQuals)
+		{
+			List	   *qualset = (List *) lfirst(lc);
+			ListCell   *lc2;
+
+			foreach(lc2, qualset)
+			{
+				Expr	   *qual = (Expr *) lfirst(lc2);
+
+				/*
+				 * not likely that we'd see constants here, so no
+				 * check
+				 */
+				childquals = lappend(childquals,
+									 make_restrictinfo(qual,
+													   true,
+													   false,
+													   false,
+													   security_level,
+													   NULL, NULL,
+													   NULL));
+				cq_min_security = Min(cq_min_security, security_level);
+			}
+			security_level++;
+		}
+		Assert(security_level <= root->qual_security_level);
+	}
+
+	/* Set child's version of baserestrictinfo. */
+	childrel->baserestrictinfo = childquals;
+	childrel->baserestrict_min_security = cq_min_security;
+
+	if (have_const_false_cq)
+	{
+		/*
+		 * Some restriction clause reduced to constant FALSE or NULL after
+		 * substitution, so this child need not be scanned.
+		 */
+		set_dummy_rel_pathlist(childrel);
+	}
+
+	return childrel;
+}
+
+/*
+ * add_rowmark_junk_columns
+ * 		Add necessary junk columns for rowmarked inheritance parent rel.
+ *
+ * These values are needed for locking of rels selected FOR UPDATE/SHARE, and
+ * to do EvalPlanQual rechecking.  See comments for PlanRowMark in
+ * plannodes.h.
+ */
+static List *
+add_rowmark_junk_columns(PlannerInfo *root, PlanRowMark *rc)
+{
+	List   *tlist = root->processed_tlist;
+	Var		   *var;
+	char		resname[32];
+	TargetEntry *tle;
+
+	if (rc->allMarkTypes & ~(1 << ROW_MARK_COPY))
+	{
+		/* Need to fetch TID */
+		var = makeVar(rc->rti,
+					  SelfItemPointerAttributeNumber,
+					  TIDOID,
+					  -1,
+					  InvalidOid,
+					  0);
+		snprintf(resname, sizeof(resname), "ctid%u", rc->rowmarkId);
+		tle = makeTargetEntry((Expr *) var,
+							  list_length(tlist) + 1,
+							  pstrdup(resname),
+							  true);
+		tlist = lappend(tlist, tle);
+	}
+	if (rc->allMarkTypes & (1 << ROW_MARK_COPY))
+	{
+		/* Need the whole row as a junk var */
+		var = makeWholeRowVar(root->simple_rte_array[rc->rti],
+							  rc->rti,
+							  0,
+							  false);
+		snprintf(resname, sizeof(resname), "wholerow%u", rc->rowmarkId);
+		tle = makeTargetEntry((Expr *) var,
+							  list_length(tlist) + 1,
+							  pstrdup(resname),
+							  true);
+		tlist = lappend(tlist, tle);
+	}
+
+	/* For inheritance cases, always fetch the tableoid too. */
+	var = makeVar(rc->rti,
+				  TableOidAttributeNumber,
+				  OIDOID,
+				  -1,
+				  InvalidOid,
+				  0);
+	snprintf(resname, sizeof(resname), "tableoid%u", rc->rowmarkId);
+	tle = makeTargetEntry((Expr *) var,
+						  list_length(tlist) + 1,
+						  pstrdup(resname),
+						  true);
+	tlist = lappend(tlist, tle);
+
+	return tlist;
+}
+
+AppendRelInfo *
+make_append_rel_info(RelOptInfo *parentrel, RangeTblEntry *parentrte,
+					 TupleDesc childdesc, Oid childoid, Oid childreltype,
+					 Index childRTindex)
+{
+	AppendRelInfo  *appinfo = makeNode(AppendRelInfo);
+
+	appinfo->parent_relid = parentrel->relid;
+	appinfo->child_relid = childRTindex;
+	appinfo->parent_reltype = parentrel->reltype;
+	appinfo->child_reltype = childreltype;
+	make_inh_translation_list(parentrel->tupdesc, childdesc,
+							  parentrte->relid, childoid,
+							  childRTindex,
+							  &appinfo->translated_vars);
+	appinfo->parent_reloid = parentrte->relid;
+
+	return appinfo;
+}
+
+/*
  * adjust_appendrel_attrs
  *	  Copy the specified query or expression and translate Vars referring to a
  *	  parent rel to refer to the corresponding child rel instead.  We also
diff --git a/src/backend/optimizer/util/Makefile b/src/backend/optimizer/util/Makefile
index c54d0a690d..da9ccf32b4 100644
--- a/src/backend/optimizer/util/Makefile
+++ b/src/backend/optimizer/util/Makefile
@@ -13,6 +13,6 @@ top_builddir = ../../../..
 include $(top_builddir)/src/Makefile.global
 
 OBJS = clauses.o joininfo.o orclauses.o pathnode.o placeholder.o \
-       plancat.o predtest.o relnode.o restrictinfo.o tlist.o var.o
+	   plancat.o predtest.o relnode.o restrictinfo.o tlist.o var.o
 
 include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/optimizer/util/plancat.c b/src/backend/optimizer/util/plancat.c
index a0fed5be42..bf441741e0 100644
--- a/src/backend/optimizer/util/plancat.c
+++ b/src/backend/optimizer/util/plancat.c
@@ -106,7 +106,7 @@ static void set_baserel_partition_key_exprs(Relation relation,
  */
 void
 get_relation_info(PlannerInfo *root, Oid relationObjectId, bool inhparent,
-				  RelOptInfo *rel)
+				  Bitmapset *updatedCols, RelOptInfo *rel)
 {
 	Index		varno = rel->relid;
 	Relation	relation;
@@ -444,11 +444,31 @@ get_relation_info(PlannerInfo *root, Oid relationObjectId, bool inhparent,
 	get_relation_foreign_keys(root, rel, relation, inhparent);
 
 	/*
-	 * Collect info about relation's partitioning scheme, if any. Only
-	 * inheritance parents may be partitioned.
+	 * Collect some additional information for inheritance parents.
 	 */
-	if (inhparent && relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
-		set_relation_partition_info(root, rel, relation);
+	if (inhparent)
+	{
+		/*
+		 * We'll need the TupleDesc when initializing the child relation.
+		 * A copy is being made because concurrent changes might drop
+		 * the relcache entry.  That's possible because ALTER TABLE
+		 * child_table NO INHERIT parent_table only requires an
+		 * AccessShareLock on parent_table.
+		 */
+		rel->tupdesc = CreateTupleDescCopy(RelationGetDescr(relation));
+		rel->reltype = RelationGetForm(relation)->reltype;
+
+		/*
+		 * If partitioned, also save the information of partitioning scheme,
+		 * and whether the query updates any of the partition key columns.
+		 */
+		if (relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
+		{
+			set_relation_partition_info(root, rel, relation);
+			root->partColsUpdated |= has_partition_attrs(relation, updatedCols,
+														 NULL);
+		}
+	}
 
 	heap_close(relation, NoLock);
 
@@ -1853,16 +1873,20 @@ set_relation_partition_info(PlannerInfo *root, RelOptInfo *rel,
 							Relation relation)
 {
 	PartitionDesc partdesc;
-	PartitionKey partkey;
 
 	Assert(relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE);
 
 	partdesc = RelationGetPartitionDesc(relation);
-	partkey = RelationGetPartitionKey(relation);
 	rel->part_scheme = find_partition_scheme(root, relation);
 	Assert(partdesc != NULL && rel->part_scheme != NULL);
-	rel->boundinfo = partition_bounds_copy(partdesc->boundinfo, partkey);
 	rel->nparts = partdesc->nparts;
+
+	/*
+	 * Since we must've taken a lock on the table, it's okay to simply copy
+	 * the pointers to relcache data here.
+	 */
+	rel->part_oids = partdesc->oids;
+	rel->boundinfo = partdesc->boundinfo;
 	set_baserel_partition_key_exprs(relation, rel);
 	rel->partition_qual = RelationGetPartitionQual(relation);
 }
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index 29ba19349f..c23db9d78d 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -130,6 +130,37 @@ setup_append_rel_array(PlannerInfo *root)
 	}
 }
 
+/* Expand the PlannerInfo arrays by add_size members and zero-init it. */
+void
+expand_planner_arrays(PlannerInfo *root, int add_size)
+{
+	int		new_size = root->simple_rel_array_size + add_size;
+
+	root->simple_rte_array = (RangeTblEntry **)
+							repalloc(root->simple_rte_array,
+									 sizeof(RangeTblEntry *) * new_size);
+	root->simple_rel_array = (RelOptInfo **)
+								repalloc(root->simple_rel_array,
+										 sizeof(RelOptInfo *) * new_size);
+	if (root->append_rel_array)
+		root->append_rel_array = (AppendRelInfo **)
+									repalloc(root->append_rel_array,
+									 sizeof(AppendRelInfo *) * new_size);
+	else
+		root->append_rel_array = (AppendRelInfo **)
+									palloc0(sizeof(AppendRelInfo *) *
+											new_size);
+
+	/* Set the contents of just allocated memory to 0. */
+	MemSet(root->simple_rte_array + root->simple_rel_array_size,
+		   0, sizeof(RangeTblEntry *) * add_size);
+	MemSet(root->simple_rel_array + root->simple_rel_array_size,
+		   0, sizeof(RelOptInfo *) * add_size);
+	MemSet(root->append_rel_array + root->simple_rel_array_size,
+		   0, sizeof(AppendRelInfo *) * add_size);
+	root->simple_rel_array_size = new_size;
+}
+
 /*
  * build_simple_rel
  *	  Construct a new RelOptInfo for a base relation or 'other' relation.
@@ -238,7 +269,8 @@ build_simple_rel(PlannerInfo *root, int relid, RelOptInfo *parent)
 	{
 		case RTE_RELATION:
 			/* Table --- retrieve statistics from the system catalogs */
-			get_relation_info(root, rte->relid, rte->inh, rel);
+			get_relation_info(root, rte->relid, rte->inh, rte->updatedCols,
+							  rel);
 			break;
 		case RTE_SUBQUERY:
 		case RTE_FUNCTION:
@@ -279,52 +311,6 @@ build_simple_rel(PlannerInfo *root, int relid, RelOptInfo *parent)
 		root->qual_security_level = Max(root->qual_security_level,
 										list_length(rte->securityQuals));
 
-	/*
-	 * If this rel is an appendrel parent, recurse to build "other rel"
-	 * RelOptInfos for its children.  They are "other rels" because they are
-	 * not in the main join tree, but we will need RelOptInfos to plan access
-	 * to them.
-	 */
-	if (rte->inh)
-	{
-		ListCell   *l;
-		int			nparts = rel->nparts;
-		int			cnt_parts = 0;
-
-		if (nparts > 0)
-			rel->part_rels = (RelOptInfo **)
-				palloc(sizeof(RelOptInfo *) * nparts);
-
-		foreach(l, root->append_rel_list)
-		{
-			AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(l);
-			RelOptInfo *childrel;
-
-			/* append_rel_list contains all append rels; ignore others */
-			if (appinfo->parent_relid != relid)
-				continue;
-
-			childrel = build_simple_rel(root, appinfo->child_relid,
-										rel);
-
-			/* Nothing more to do for an unpartitioned table. */
-			if (!rel->part_scheme)
-				continue;
-
-			/*
-			 * The order of partition OIDs in append_rel_list is the same as
-			 * the order in the PartitionDesc, so the order of part_rels will
-			 * also match the PartitionDesc.  See expand_partitioned_rtentry.
-			 */
-			Assert(cnt_parts < nparts);
-			rel->part_rels[cnt_parts] = childrel;
-			cnt_parts++;
-		}
-
-		/* We should have seen all the child partitions. */
-		Assert(cnt_parts == nparts);
-	}
-
 	return rel;
 }
 
diff --git a/src/backend/partitioning/partprune.c b/src/backend/partitioning/partprune.c
index 35c87535d3..fcf8d6032c 100644
--- a/src/backend/partitioning/partprune.c
+++ b/src/backend/partitioning/partprune.c
@@ -45,6 +45,7 @@
 #include "nodes/makefuncs.h"
 #include "nodes/nodeFuncs.h"
 #include "optimizer/clauses.h"
+#include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
 #include "optimizer/planner.h"
 #include "optimizer/predtest.h"
@@ -436,17 +437,23 @@ make_partitionedrel_pruneinfo(PlannerInfo *root, RelOptInfo *parentrel,
 		 * is, not pruned already).
 		 */
 		subplan_map = (int *) palloc(nparts * sizeof(int));
+		memset(subplan_map, -1, nparts * sizeof(int));
 		subpart_map = (int *) palloc(nparts * sizeof(int));
+		memset(subpart_map, -1, nparts * sizeof(int));
 		present_parts = NULL;
 
 		for (i = 0; i < nparts; i++)
 		{
 			RelOptInfo *partrel = subpart->part_rels[i];
-			int			subplanidx = relid_subplan_map[partrel->relid] - 1;
-			int			subpartidx = relid_subpart_map[partrel->relid] - 1;
+			int			subplanidx;
+			int			subpartidx;
 
-			subplan_map[i] = subplanidx;
-			subpart_map[i] = subpartidx;
+			/* Skip processing pruned partitions. */
+			if (partrel == NULL)
+				continue;
+
+			subplan_map[i] = subplanidx = relid_subplan_map[partrel->relid] - 1;
+			subpart_map[i] = subpartidx = relid_subpart_map[partrel->relid] - 1;
 			if (subplanidx >= 0)
 			{
 				present_parts = bms_add_member(present_parts, i);
@@ -540,23 +547,20 @@ gen_partprune_steps(RelOptInfo *rel, List *clauses, bool *contradictory)
 
 /*
  * prune_append_rel_partitions
- *		Returns RT indexes of the minimum set of child partitions which must
- *		be scanned to satisfy rel's baserestrictinfo quals.
+ *		Returns indexes into rel->part_rels of the minimum set of child
+ *		partitions which must be scanned to satisfy rel's baserestrictinfo
+ *		quals.
  *
  * Callers must ensure that 'rel' is a partitioned table.
  */
-Relids
+Bitmapset *
 prune_append_rel_partitions(RelOptInfo *rel)
 {
-	Relids		result;
 	List	   *clauses = rel->baserestrictinfo;
 	List	   *pruning_steps;
 	bool		contradictory;
 	PartitionPruneContext context;
-	Bitmapset  *partindexes;
-	int			i;
 
-	Assert(clauses != NIL);
 	Assert(rel->part_scheme != NULL);
 
 	/* If there are no partitions, return the empty set */
@@ -564,6 +568,13 @@ prune_append_rel_partitions(RelOptInfo *rel)
 		return NULL;
 
 	/*
+	 * If pruning is disabled or if there are no clauses to prune with,
+	 * return all partitions.
+	 */
+	if (!enable_partition_pruning || clauses == NIL)
+		return bms_add_range(NULL, 0, rel->nparts - 1);
+
+	/*
 	 * Process clauses.  If the clauses are found to be contradictory, we can
 	 * return the empty set.
 	 */
@@ -590,15 +601,7 @@ prune_append_rel_partitions(RelOptInfo *rel)
 	context.evalexecparams = false;
 
 	/* Actual pruning happens here. */
-	partindexes = get_matching_partitions(&context, pruning_steps);
-
-	/* Add selected partitions' RT indexes to result. */
-	i = -1;
-	result = NULL;
-	while ((i = bms_next_member(partindexes, i)) >= 0)
-		result = bms_add_member(result, rel->part_rels[i]->relid);
-
-	return result;
+	return get_matching_partitions(&context, pruning_steps);
 }
 
 /*
diff --git a/src/include/nodes/relation.h b/src/include/nodes/relation.h
index 94f14019bd..e6fdbcd030 100644
--- a/src/include/nodes/relation.h
+++ b/src/include/nodes/relation.h
@@ -15,6 +15,7 @@
 #define RELATION_H
 
 #include "access/sdir.h"
+#include "access/tupdesc.h"
 #include "fmgr.h"
 #include "lib/stringinfo.h"
 #include "nodes/params.h"
@@ -723,6 +724,7 @@ typedef struct RelOptInfo
 	int			nparts;			/* number of partitions */
 	struct PartitionBoundInfoData *boundinfo;	/* Partition bounds */
 	List	   *partition_qual; /* partition constraint */
+	Oid		   *part_oids;		/* partition OIDs */
 	struct RelOptInfo **part_rels;	/* Array of RelOptInfos of partitions,
 									 * stored in the same order of bounds */
 	List	  **partexprs;		/* Non-nullable partition key expressions. */
@@ -732,6 +734,12 @@ typedef struct RelOptInfo
 	Index		inh_root_parent;	/* For otherrels, this is the RT index of
 									 * inheritance table mentioned in the query
 									 * from which this relation originated */
+	/*
+	 * Set only if this is an inheritance parent relation.  This information
+	 * is needed when initializing the planning info for children.
+	 */
+	TupleDesc	tupdesc;		/* A "copy" of the table's tuple desriptor */
+	Oid			reltype;		/* Table's reltype */
 } RelOptInfo;
 
 /*
diff --git a/src/include/optimizer/pathnode.h b/src/include/optimizer/pathnode.h
index 81abcf53a8..b1baa3117a 100644
--- a/src/include/optimizer/pathnode.h
+++ b/src/include/optimizer/pathnode.h
@@ -261,6 +261,7 @@ extern Path *reparameterize_path_by_child(PlannerInfo *root, Path *path,
  */
 extern void setup_simple_rel_arrays(PlannerInfo *root);
 extern void setup_append_rel_array(PlannerInfo *root);
+extern void expand_planner_arrays(PlannerInfo *root, int add_size);
 extern RelOptInfo *build_simple_rel(PlannerInfo *root, int relid,
 				 RelOptInfo *parent);
 extern RelOptInfo *find_base_rel(PlannerInfo *root, int relid);
diff --git a/src/include/optimizer/plancat.h b/src/include/optimizer/plancat.h
index 7d53cbbb87..edaf2a3b4f 100644
--- a/src/include/optimizer/plancat.h
+++ b/src/include/optimizer/plancat.h
@@ -26,7 +26,7 @@ extern PGDLLIMPORT get_relation_info_hook_type get_relation_info_hook;
 
 
 extern void get_relation_info(PlannerInfo *root, Oid relationObjectId,
-				  bool inhparent, RelOptInfo *rel);
+				  bool inhparent, Bitmapset *updatedCols, RelOptInfo *rel);
 
 extern List *infer_arbiter_indexes(PlannerInfo *root);
 
diff --git a/src/include/optimizer/prep.h b/src/include/optimizer/prep.h
index 38608770a2..faae07d240 100644
--- a/src/include/optimizer/prep.h
+++ b/src/include/optimizer/prep.h
@@ -38,7 +38,8 @@ extern Expr *canonicalize_qual(Expr *qual, bool is_check);
 /*
  * prototypes for preptlist.c
  */
-extern List *preprocess_targetlist(PlannerInfo *root);
+extern List *preprocess_targetlist(PlannerInfo *root,
+							bool inheritance_expanded);
 
 extern PlanRowMark *get_plan_rowmark(List *rowmarks, Index rtindex);
 
@@ -51,7 +52,10 @@ extern void expand_inherited_tables(PlannerInfo *root);
 
 extern Node *adjust_appendrel_attrs(PlannerInfo *root, Node *node,
 					   int nappinfos, AppendRelInfo **appinfos);
-
+extern AppendRelInfo *make_append_rel_info(RelOptInfo *parentrel,
+					 RangeTblEntry *parentrte,
+					 TupleDesc childdesc, Oid childoid, Oid childreltype,
+					 Index childRTindex);
 extern Node *adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node,
 								  Relids child_relids,
 								  Relids top_parent_relids);
@@ -64,5 +68,4 @@ extern SpecialJoinInfo *build_child_join_sjinfo(PlannerInfo *root,
 						Relids left_relids, Relids right_relids);
 extern Relids adjust_child_relids_multilevel(PlannerInfo *root, Relids relids,
 							   Relids child_relids, Relids top_parent_relids);
-
 #endif							/* PREP_H */
diff --git a/src/include/partitioning/partprune.h b/src/include/partitioning/partprune.h
index e07aaaf798..ac0a979010 100644
--- a/src/include/partitioning/partprune.h
+++ b/src/include/partitioning/partprune.h
@@ -76,7 +76,7 @@ extern PartitionPruneInfo *make_partition_pruneinfo(PlannerInfo *root,
 						 List *subpaths,
 						 List *partitioned_rels,
 						 List *prunequal);
-extern Relids prune_append_rel_partitions(RelOptInfo *rel);
+extern Bitmapset *prune_append_rel_partitions(RelOptInfo *rel);
 extern Bitmapset *get_matching_partitions(PartitionPruneContext *context,
 						List *pruning_steps);
 
diff --git a/src/test/regress/expected/partition_aggregate.out b/src/test/regress/expected/partition_aggregate.out
index 6bc106831e..1450cef057 100644
--- a/src/test/regress/expected/partition_aggregate.out
+++ b/src/test/regress/expected/partition_aggregate.out
@@ -144,7 +144,7 @@ SELECT c, sum(a) FROM pagg_tab WHERE 1 = 2 GROUP BY c;
            QUERY PLAN           
 --------------------------------
  HashAggregate
-   Group Key: pagg_tab.c
+   Group Key: c
    ->  Result
          One-Time Filter: false
 (4 rows)
@@ -159,7 +159,7 @@ SELECT c, sum(a) FROM pagg_tab WHERE c = 'x' GROUP BY c;
            QUERY PLAN           
 --------------------------------
  GroupAggregate
-   Group Key: pagg_tab.c
+   Group Key: c
    ->  Result
          One-Time Filter: false
 (4 rows)
-- 
2.11.0

From 929ab0e596a5103ee58f969c8b5220267c41a5d1 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Wed, 7 Nov 2018 16:51:31 +0900
Subject: [PATCH v9 4/6] Move append expansion code into its own file

This commit moves expand_append_rel and underlings currently in
optimizer/prep/prepunionc.c to optimizer/utils/append.c.

All of the AppendRelInfo based expression manipulation routines
are moved to optimizer/utils/appendinfo.c.

This commit only moves the code and contains no functional changes.
---
 src/backend/optimizer/path/allpaths.c   |    2 +
 src/backend/optimizer/path/equivclass.c |    1 +
 src/backend/optimizer/path/joinrels.c   |    1 +
 src/backend/optimizer/plan/planner.c    |    1 +
 src/backend/optimizer/prep/prepunion.c  | 1573 -------------------------------
 src/backend/optimizer/util/Makefile     |    5 +-
 src/backend/optimizer/util/append.c     |  776 +++++++++++++++
 src/backend/optimizer/util/appendinfo.c |  851 +++++++++++++++++
 src/backend/optimizer/util/pathnode.c   |    1 +
 src/backend/optimizer/util/relnode.c    |    1 +
 src/backend/partitioning/partprune.c    |    1 +
 src/include/optimizer/append.h          |   25 +
 src/include/optimizer/appendinfo.h      |   43 +
 src/include/optimizer/prep.h            |   19 -
 14 files changed, 1706 insertions(+), 1594 deletions(-)
 create mode 100644 src/backend/optimizer/util/append.c
 create mode 100644 src/backend/optimizer/util/appendinfo.c
 create mode 100644 src/include/optimizer/append.h
 create mode 100644 src/include/optimizer/appendinfo.h

diff --git a/src/backend/optimizer/path/allpaths.c b/src/backend/optimizer/path/allpaths.c
index 3eae8316d5..12bb61f8cb 100644
--- a/src/backend/optimizer/path/allpaths.c
+++ b/src/backend/optimizer/path/allpaths.c
@@ -30,6 +30,8 @@
 #ifdef OPTIMIZER_DEBUG
 #include "nodes/print.h"
 #endif
+#include "optimizer/append.h"
+#include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/geqo.h"
diff --git a/src/backend/optimizer/path/equivclass.c b/src/backend/optimizer/path/equivclass.c
index 029665b974..f52adc72d0 100644
--- a/src/backend/optimizer/path/equivclass.c
+++ b/src/backend/optimizer/path/equivclass.c
@@ -22,6 +22,7 @@
 #include "catalog/pg_type.h"
 #include "nodes/makefuncs.h"
 #include "nodes/nodeFuncs.h"
+#include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
 #include "optimizer/pathnode.h"
 #include "optimizer/paths.h"
diff --git a/src/backend/optimizer/path/joinrels.c b/src/backend/optimizer/path/joinrels.c
index da0831de4e..6e321ec9e7 100644
--- a/src/backend/optimizer/path/joinrels.c
+++ b/src/backend/optimizer/path/joinrels.c
@@ -15,6 +15,7 @@
 #include "postgres.h"
 
 #include "miscadmin.h"
+#include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
 #include "optimizer/joininfo.h"
 #include "optimizer/pathnode.h"
diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index 1ee7d9585b..62ad5eb5c2 100644
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -39,6 +39,7 @@
 #include "nodes/print.h"
 #endif
 #include "nodes/relation.h"
+#include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
diff --git a/src/backend/optimizer/prep/prepunion.c b/src/backend/optimizer/prep/prepunion.c
index 96430a4cc7..70f37c593f 100644
--- a/src/backend/optimizer/prep/prepunion.c
+++ b/src/backend/optimizer/prep/prepunion.c
@@ -12,11 +12,6 @@
  * case, but most of the heavy lifting for that is done elsewhere,
  * notably in prepjointree.c and allpaths.c.
  *
- * There is also some code here to support planning of queries that use
- * inheritance (SELECT FROM foo*).  Inheritance trees are converted into
- * append relations, and thenceforth share code with the UNION ALL case.
- *
- *
  * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
@@ -39,32 +34,21 @@
 #include "miscadmin.h"
 #include "nodes/makefuncs.h"
 #include "nodes/nodeFuncs.h"
-#include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
 #include "optimizer/paths.h"
 #include "optimizer/planmain.h"
 #include "optimizer/planner.h"
 #include "optimizer/prep.h"
-#include "optimizer/restrictinfo.h"
 #include "optimizer/tlist.h"
-#include "optimizer/var.h"
 #include "parser/parse_coerce.h"
 #include "parser/parsetree.h"
-#include "partitioning/partprune.h"
 #include "utils/lsyscache.h"
 #include "utils/rel.h"
 #include "utils/selfuncs.h"
 #include "utils/syscache.h"
 
 
-typedef struct
-{
-	PlannerInfo *root;
-	int			nappinfos;
-	AppendRelInfo **appinfos;
-} adjust_appendrel_attrs_context;
-
 static RelOptInfo *recurse_set_operations(Node *setOp, PlannerInfo *root,
 					   List *colTypes, List *colCollations,
 					   bool junkOK,
@@ -103,34 +87,6 @@ static List *generate_append_tlist(List *colTypes, List *colCollations,
 					  List *input_tlists,
 					  List *refnames_tlist);
 static List *generate_setop_grouplist(SetOperationStmt *op, List *targetlist);
-static void expand_append_rtentry(PlannerInfo *root, RelOptInfo *rel,
-					  RangeTblEntry *rte, Index rti);
-static void expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte,
-						 Index rti, RelOptInfo *rel);
-static void expand_partitioned_rtentry(PlannerInfo *root,
-						   RangeTblEntry *parentrte,
-						   Index parentRTindex, RelOptInfo *parentrel);
-static RelOptInfo *add_inheritance_child_rel(PlannerInfo *root,
-						  RangeTblEntry *parentrte,
-						  Index parentRTindex, RelOptInfo *parentrel,
-						  PlanRowMark *top_parentrc, Relation childrel,
-						  RangeTblEntry **childrte_p, Index *childRTindex_p);
-static void make_inh_translation_list(TupleDesc old_tupdesc,
-						  TupleDesc new_tupdesc,
-						  Oid from_rel, Oid to_rel,
-						  Index newvarno, List **translated_vars);
-static RelOptInfo *build_append_child_rel(PlannerInfo *root,
-					   RelOptInfo *parent,
-					   Index childRTindex);
-static List *add_rowmark_junk_columns(PlannerInfo *root, PlanRowMark *rc);
-static Bitmapset *translate_col_privs(const Bitmapset *parent_privs,
-					List *translated_vars);
-static Node *adjust_appendrel_attrs_mutator(Node *node,
-							   adjust_appendrel_attrs_context *context);
-static Relids adjust_child_relids(Relids relids, int nappinfos,
-					AppendRelInfo **appinfos);
-static List *adjust_inherited_tlist(List *tlist,
-					   AppendRelInfo *context);
 
 
 /*
@@ -1467,1532 +1423,3 @@ generate_setop_grouplist(SetOperationStmt *op, List *targetlist)
 	Assert(lg == NULL);
 	return grouplist;
 }
-
-
-/*
- * expand_inherited_tables
- *		Expand each rangetable entry that represents an inheritance set
- *		into an "append relation".  At the conclusion of this process,
- *		the "inh" flag is set in all and only those RTEs that are append
- *		relation parents.
- */
-void
-expand_inherited_tables(PlannerInfo *root)
-{
-	int			orig_rtable_size;
-	Index		rti;
-
-	Assert(root->simple_rel_array_size > 0);
-	orig_rtable_size = root->simple_rel_array_size;
-
-	/*
-	 * expand_append_rtentry may add RTEs to parse->rtable. The function is
-	 * expected to recursively handle any RTEs that it creates with inh=true.
-	 * So just scan as far as the original end of the rtable list.
-	 */
-	for (rti = 1; rti < orig_rtable_size; rti++)
-	{
-		RelOptInfo *brel = root->simple_rel_array[rti];
-		RangeTblEntry *rte = root->simple_rte_array[rti];
-
-		/* there may be empty slots corresponding to non-baserel RTEs */
-		if (brel == NULL)
-			continue;
-
-		if (rte->inh)
-			expand_append_rtentry(root, brel, rte, rti);
-	}
-}
-
-/*
- * expand_append_rtentry
- *		This initializes RelOptInfos for an appendrel's child relations, if
- *		any
- *
- * 'rel' is the appendrel parent, whose range table entry ('rte') has been
- * marked to require adding children.  An appendrel parent could either
- * be a subquery (if we flattened UNION ALL query) or a table that's known
- * to have inheritance children.  The latter consists of both regular
- * inheritance parents and partitioned tables.
- *
- * For a subquery parent, there is not much to be done here because the
- * children's RTEs are already present in the query, so we just initialize
- * RelOptInfos for them.  Also, the AppendRelInfos for child subqueries
- * have already been added.
- *
- * For tables, we need to add the children to the range table and initialize
- * AppendRelInfos, RelOptInfos, and PlanRowMarks (if any) for them.  For
- * a partitioned parent, we only add the children remaining after pruning.
- * For regular inheritance parents, we find the children using
- * find_all_inheritors and add all of them.
- *
- * If it turns out that there are no children, then we set rte->inh to false
- * to let the caller know that only the parent table needs to be scanned.  The
- * caller can accordingly switch to a non-Append path.  For a partitioned
- * parent, that means an empty relation because parents themselves contain no
- * data.
- *
- * For the regular inheritance case, the parent also gets another RTE with
- * inh = false to represent it as an appendrel child.  The original RTE is
- * considered to represent the whole inheritance set.
- */
-static void
-expand_append_rtentry(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte,
-					  Index rti)
-{
-	Assert(rte->inh);
-	/* Inheritance parent (partitioned or not) or UNION ALL parent subquery. */
-	Assert(rte->rtekind == RTE_RELATION || rte->rtekind == RTE_SUBQUERY);
-
-	/*
-	 * UNION ALL children already got RTEs and AppendRelInfos, so just build
-	 * RelOptInfos and return.
-	 *
-	 * It might be a bit odd that this code is in this, because there is
-	 * nothing to expand really.
-	 */
-	if (rte->rtekind == RTE_SUBQUERY)
-	{
-		ListCell   *l;
-
-		/*
-		 * We don't need to use expand_planner_arrays in this case, because
-		 * no new child RTEs are created.  setup_simple_rel_arrays() and
-		 * setup_append_rel_array would've considered these child RTEs when
-		 * allocating space for various arrays.
-		 */
-		foreach(l, root->append_rel_list)
-		{
-			AppendRelInfo *appinfo = lfirst(l);
-			Index		childRTindex = appinfo->child_relid;
-
-			if (appinfo->parent_relid != rti)
-				continue;
-
-			Assert(childRTindex < root->simple_rel_array_size);
-			Assert(root->simple_rte_array[childRTindex] != NULL);
-
-			/*
-			 * We set the correct value of baserestricinfo and
-			 * baserestrict_min_security below.
-			 */
-			root->simple_rel_array[childRTindex] =
-				build_append_child_rel(root, rel, appinfo->child_relid);
-		}
-	}
-	else
-	{
-		Assert(rte->rtekind == RTE_RELATION);
-		Assert(has_subclass(rte->relid));
-
-		/*
-		 * The rewriter should already have obtained an appropriate lock on
-		 * each relation named in the query.  However, for each child relation
-		 * we add to the query, we must obtain an appropriate lock, because
-		 * this will be the first use of those relations in the
-		 * parse/rewrite/plan pipeline.  Child rels should use the same
-		 * lockmode as their parent.
-		 */
-		Assert(rte->rellockmode != NoLock);
-
-		if (rte->relkind == RELKIND_PARTITIONED_TABLE)
-			expand_partitioned_rtentry(root, rte, rti, rel);
-		else
-			expand_inherited_rtentry(root, rte, rti, rel);
-	}
-}
-
-/*
- * expand_inherited_rtentry
- *		Add entries for all the child tables to the query's rangetable, and
- *		build AppendRelInfo nodes for all the child tables and add them to
- *		root->append_rel_list.
- *
- * Note that the original RTE is considered to represent the whole
- * inheritance set.  The first of the generated RTEs is an RTE for the same
- * table, but with inh = false, to represent the parent table in its role
- * as a simple member of the inheritance set.
- *
- * A childless table is never considered to be an inheritance set. For
- * regular inheritance, a parent RTE must always have at least two associated
- * AppendRelInfos: one corresponding to the parent table as a simple member of
- * inheritance set and one or more corresponding to the actual children.
- */
-static void
-expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti,
-						 RelOptInfo *rel)
-{
-	Oid			parentOID;
-	PlanRowMark *oldrc;
-	LOCKMODE	lockmode = rte->rellockmode;
-	List	   *inhOIDs;
-	ListCell   *l;
-	int			num_children;
-	int			num_children_added = 0;
-
-	Assert(rte->rtekind == RTE_RELATION);
-	Assert(lockmode != NoLock);
-	parentOID = rte->relid;
-
-	/* Scan for all members of inheritance set, acquire needed locks */
-	inhOIDs = find_all_inheritors(parentOID, lockmode, NULL);
-
-	/*
-	 * Check that there's at least one descendant, else treat as no-child
-	 * case.  This could happen despite has_subclass() check performed by
-	 * subquery_planner, if table once had a child but no longer does.
-	 */
-	num_children = list_length(inhOIDs);
-	if (num_children < 2)
-	{
-		/* Clear flag before returning */
-		rte->inh = false;
-		return;
-	}
-
-	/*
-	 * If parent relation is selected FOR UPDATE/SHARE, preprocess_rowmarks
-	 * should've set isParent = true.  We'll generate a new PlanRowMark for
-	 * each child.
-	 */
-	oldrc = get_plan_rowmark(root->rowMarks, rti);
-	Assert(oldrc == NULL || oldrc->isParent);
-
-	/*
-	 * Must expand PlannerInfo arrays by num_children before we can add
-	 * children.
-	 */
-	expand_planner_arrays(root, num_children);
-
-	foreach(l, inhOIDs)
-	{
-		Oid			childOID = lfirst_oid(l);
-		Relation	newrelation;
-		RangeTblEntry *childrte;
-		Index		childRTindex;
-
-		/* Already locked above. */
-		newrelation = heap_open(childOID, NoLock);
-
-		/*
-		 * It is possible that the parent table has children that are temp
-		 * tables of other backends.  We cannot safely access such tables
-		 * (because of buffering issues), and the best thing to do seems
-		 * to be to silently ignore them.
-		 */
-		if (RELATION_IS_OTHER_TEMP(newrelation))
-		{
-			heap_close(newrelation, lockmode);
-			continue;
-		}
-
-		(void) add_inheritance_child_rel(root, rte, rti, rel, oldrc,
-										 newrelation, &childrte,
-										 &childRTindex);
-		Assert(childrte != NULL);
-		/* All regular inheritance children are leaf children. */
-		Assert(!childrte->inh);
-		Assert(childRTindex > 0);
-
-		/* Close child relations, but keep locks */
-		heap_close(newrelation, NoLock);
-		num_children_added++;
-	}
-
-	/*
-	 * If all children, including the parent (as child rel), were
-	 * excluded, mark the parent rel as empty.  If all the children were temp
-	 * tables, pretend it's a non-inheritance situation; we don't need Append
-	 * node in that case.  The duplicate RTE we added for the parent table is
-	 * harmless, so we don't bother to get rid of it; ditto for the useless
-	 * PlanRowMark node.
-	 */
-	if (num_children_added == 0)
-		mark_dummy_rel(rel);
-	else if (num_children_added == 1)
-		rte->inh = false;
-
-	/*
-	 * Add junk columns needed by the row mark if any and also add the
-	 * relevant expressions to the root parent's reltarget.
-	 */
-	if (oldrc)
-	{
-		List   *tlist = add_rowmark_junk_columns(root, oldrc);
-
-		build_base_rel_tlists(root, tlist);
-	}
-}
-
-/*
- * expand_partitioned_rtentry
- *		Prunes unnecessary partitions of a partitioned table and adds
- *		remaining ones to the Query and the PlannerInfo
- *
- * Partitions are added to the query in order in which they are found in
- * the parent's PartitionDesc.
- *
- * Note: even though only the unpruned partitions will be added to the
- * resulting plan, this still locks *all* partitions via find_all_inheritors
- * when this function is called for the root partitioned table.
- */
-static void
-expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
-						   Index parentRTindex, RelOptInfo *parentrel)
-{
-	LOCKMODE	lockmode = parentrte->rellockmode;
-	PlanRowMark *rootrc = NULL;
-	int			i;
-	Bitmapset  *partindexes;
-	Index		rootParentRTindex = parentrel->inh_root_parent > 0 ?
-									parentrel->inh_root_parent :
-									parentRTindex;
-
-	/* If root partitioned table, lock *all* partitions in the tree. */
-	if (parentRTindex == rootParentRTindex)
-		(void) find_all_inheritors(parentrte->relid, lockmode, NULL);
-
-	/*
-	 * Initialize partitioned_child_rels to contain this RT index.
-	 *
-	 * Note that during the set_append_rel_pathlist() phase, values of the
-	 * indexes of partitioned relations that appear down in the tree will be
-	 * bubbled up into root parent's list so that when we've created Paths for
-	 * all the children, the root table's list will contain all such indexes.
-	 */
-	parentrel->partitioned_child_rels = list_make1_int(parentRTindex);
-
-	/* Perform pruning. */
-	partindexes = prune_append_rel_partitions(parentrel);
-
-	/* Must expand PlannerInfo arrays before we can add children. */
-	expand_planner_arrays(root, bms_num_members(partindexes));
-
-	/*
-	 * For partitioned tables, we also store the partition RelOptInfo
-	 * pointers in the parent's RelOptInfo.
-	 */
-	parentrel->part_rels = (RelOptInfo **) palloc0(sizeof(RelOptInfo *) *
-												   parentrel->nparts);
-
-	rootrc = get_plan_rowmark(root->rowMarks, rootParentRTindex);
-	Assert(rootrc == NULL || rootrc->isParent);
-	i = -1;
-	while ((i = bms_next_member(partindexes, i)) >= 0)
-	{
-		Oid		childOID = parentrel->part_oids[i];
-		Relation	newrelation;
-		RelOptInfo *childrel;
-		RangeTblEntry *childrte;
-		Index		childRTindex;
-
-		/* Already locked above. */
-		newrelation = heap_open(childOID, NoLock);
-		Assert(!RELATION_IS_OTHER_TEMP(newrelation));
-
-		/*
-		 * A partitioned child table with 0 children is a dummy rel, so don't
-		 * bother creating planner objects for it.
-		 */
-		if (newrelation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE &&
-			RelationGetPartitionDesc(newrelation)->nparts == 0)
-		{
-			heap_close(newrelation, NoLock);
-			continue;
-		}
-
-		childrel = add_inheritance_child_rel(root, parentrte, parentRTindex,
-											 parentrel, rootrc, newrelation,
-											 &childrte, &childRTindex);
-		Assert(childrel != NULL);
-		parentrel->part_rels[i] = childrel;
-
-		/* Close child relations, but keep locks */
-		heap_close(newrelation, NoLock);
-
-		/* If the child is partitioned itself, expand it too. */
-		if (childrel->part_scheme)
-		{
-			Assert(childrte->inh);
-			expand_partitioned_rtentry(root, childrte, childRTindex,
-									   childrel);
-		}
-	}
-
-	/*
-	 * Add junk columns needed by the row mark if any and also add the
-	 * relevant expressions to the root parent's reltarget.
-	 */
-	if (rootrc)
-	{
-		List   *tlist = add_rowmark_junk_columns(root, rootrc);
-
-		build_base_rel_tlists(root, tlist);
-	}
-}
-
-/*
- * add_inheritance_child_rel
- *		Build a RangeTblEntry, an AppendRelInfo, a PlanRowMark, and finally
- *		a RelOptInfo for an inheritance child relation.
- *
- * The return value is the RelOptInfo that's added.
- *
- * PlanRowMarks still carry the top-parent's RTI, and the top-parent's
- * allMarkTypes field still accumulates values from all descendents.
- *
- * "parentrte" and "parentRTindex" are immediate parent's RTE and
- * RTI. "top_parentrc" is top parent's PlanRowMark.
- */
-static RelOptInfo *
-add_inheritance_child_rel(PlannerInfo *root, RangeTblEntry *parentrte,
-						  Index parentRTindex, RelOptInfo *parentrel,
-						  PlanRowMark *top_parentrc, Relation childrel,
-						  RangeTblEntry **childrte_p, Index *childRTindex_p)
-{
-	Query	   *parse = root->parse;
-	Oid			childOID = RelationGetRelid(childrel);
-	RangeTblEntry *childrte;
-	Index		childRTindex;
-	AppendRelInfo *appinfo;
-	RelOptInfo *childrelopt;
-
-	/*
-	 * Build an RTE for the child, and attach to query's rangetable list. We
-	 * copy most fields of the parent's RTE, but replace relation OID and
-	 * relkind, and set inh appropriately.  Also, set requiredPerms to zero
-	 * since all required permissions checks are done on the original RTE.
-	 * Likewise, set the child's securityQuals to empty, because we only want
-	 * to apply the parent's RLS conditions regardless of what RLS properties
-	 * individual children may have.  (This is an intentional choice to make
-	 * inherited RLS work like regular permissions checks.) The parent
-	 * securityQuals will be propagated to children along with other base
-	 * restriction clauses, so we don't need to do it here.
-	 */
-	childrte = copyObject(parentrte);
-	*childrte_p = childrte;
-	childrte->relid = childOID;
-	childrte->relkind = childrel->rd_rel->relkind;
-	/*
-	 * A partitioned child will need to be expanded as an append parent
-	 * itself, so set its inh to true.
-	 */
-	childrte->inh = (childrte->relkind == RELKIND_PARTITIONED_TABLE);
-	childrte->requiredPerms = 0;
-	childrte->securityQuals = NIL;
-	parse->rtable = lappend(parse->rtable, childrte);
-	childRTindex = list_length(parse->rtable);
-	*childRTindex_p = childRTindex;
-
-	/* Create an AppendRelInfo and add it to planner's global list. */
-	appinfo = make_append_rel_info(parentrel, parentrte,
-								   childrel->rd_att,
-								   childOID,
-								   childrel->rd_rel->reltype,
-								   childRTindex);
-	root->append_rel_list = lappend(root->append_rel_list, appinfo);
-
-	/*
-	 * Translate the column permissions bitmaps to the child's attnums (we
-	 * have to build the translated_vars list before we can do this). But
-	 * if this is the parent table, leave copyObject's result alone.
-	 *
-	 * Note: we need to do this even though the executor won't run any
-	 * permissions checks on the child RTE.  The insertedCols/updatedCols
-	 * bitmaps may be examined for trigger-firing purposes.
-	 */
-	if (childrte->relid != parentrte->relid)
-	{
-		childrte->selectedCols = translate_col_privs(parentrte->selectedCols,
-													 appinfo->translated_vars);
-		childrte->insertedCols = translate_col_privs(parentrte->insertedCols,
-													 appinfo->translated_vars);
-		childrte->updatedCols = translate_col_privs(parentrte->updatedCols,
-													appinfo->translated_vars);
-	}
-
-	/*
-	 * Build a PlanRowMark if parent is marked FOR UPDATE/SHARE.
-	 */
-	if (top_parentrc)
-	{
-		PlanRowMark *childrc = makeNode(PlanRowMark);
-
-		childrc->rti = childRTindex;
-		childrc->prti = top_parentrc->rti;
-		childrc->rowmarkId = top_parentrc->rowmarkId;
-		/* Reselect rowmark type, because relkind might not match parent */
-		childrc->markType = select_rowmark_type(childrte,
-												top_parentrc->strength);
-		childrc->allMarkTypes = (1 << childrc->markType);
-		childrc->strength = top_parentrc->strength;
-		childrc->waitPolicy = top_parentrc->waitPolicy;
-
-		/*
-		 * We mark RowMarks for partitioned child tables as parent RowMarks so
-		 * that the executor ignores them (except their existence means that
-		 * the child tables be locked using appropriate mode).
-		 */
-		childrc->isParent = (childrte->relkind == RELKIND_PARTITIONED_TABLE);
-
-		/* Include child's rowmark type in top parent's allMarkTypes */
-		top_parentrc->allMarkTypes |= childrc->allMarkTypes;
-
-		root->rowMarks = lappend(root->rowMarks, childrc);
-	}
-
-	/*
-	 * Add the RelOptInfo.  Even though we may not really scan this relation
-	 * for reasons such as contradictory quals, we still need to create one,
-	 * because for every RTE in the query's range table, there must be an
-	 * accompanying RelOptInfo.
-	 */
-
-	/* First, store the RTE and appinfos into planner arrays. */
-	Assert(root->simple_rte_array[childRTindex] == NULL);
-	root->simple_rte_array[childRTindex] = childrte;
-	Assert(root->append_rel_array[childRTindex] == NULL);
-	root->append_rel_array[childRTindex] = appinfo;
-
-	childrelopt = build_append_child_rel(root, parentrel, childRTindex);
-	Assert(childrelopt != NULL);
-
-	return childrelopt;
-}
-
-/*
- * make_inh_translation_list
- *	  Build the list of translations from parent Vars to child Vars for
- *	  an inheritance child.
- *
- * For paranoia's sake, we match type/collation as well as attribute name.
- */
-static void
-make_inh_translation_list(TupleDesc old_tupdesc, TupleDesc new_tupdesc,
-						  Oid from_rel, Oid to_rel,
-						  Index newvarno, List **translated_vars)
-{
-	List	   *vars = NIL;
-	int			oldnatts = old_tupdesc->natts;
-	int			newnatts = new_tupdesc->natts;
-	int			old_attno;
-	int			new_attno = 0;
-
-	for (old_attno = 0; old_attno < oldnatts; old_attno++)
-	{
-		Form_pg_attribute att;
-		char	   *attname;
-		Oid			atttypid;
-		int32		atttypmod;
-		Oid			attcollation;
-
-		att = TupleDescAttr(old_tupdesc, old_attno);
-		if (att->attisdropped)
-		{
-			/* Just put NULL into this list entry */
-			vars = lappend(vars, NULL);
-			continue;
-		}
-		attname = NameStr(att->attname);
-		atttypid = att->atttypid;
-		atttypmod = att->atttypmod;
-		attcollation = att->attcollation;
-
-		/*
-		 * When we are generating the "translation list" for the parent table
-		 * of an inheritance set, no need to search for matches.
-		 */
-		if (from_rel == to_rel)
-		{
-			vars = lappend(vars, makeVar(newvarno,
-										 (AttrNumber) (old_attno + 1),
-										 atttypid,
-										 atttypmod,
-										 attcollation,
-										 0));
-			continue;
-		}
-
-		/*
-		 * Otherwise we have to search for the matching column by name.
-		 * There's no guarantee it'll have the same column position, because
-		 * of cases like ALTER TABLE ADD COLUMN and multiple inheritance.
-		 * However, in simple cases, the relative order of columns is mostly
-		 * the same in both relations, so try the column of newrelation that
-		 * follows immediately after the one that we just found, and if that
-		 * fails, let syscache handle it.
-		 */
-		if (new_attno >= newnatts ||
-			(att = TupleDescAttr(new_tupdesc, new_attno))->attisdropped ||
-			strcmp(attname, NameStr(att->attname)) != 0)
-		{
-			HeapTuple	newtup;
-
-			newtup = SearchSysCacheAttName(to_rel, attname);
-			if (!newtup)
-				elog(ERROR, "could not find inherited attribute \"%s\" of relation \"%s\"",
-					 attname, get_rel_name(to_rel));
-			new_attno = ((Form_pg_attribute) GETSTRUCT(newtup))->attnum - 1;
-			ReleaseSysCache(newtup);
-
-			att = TupleDescAttr(new_tupdesc, new_attno);
-		}
-
-		/* Found it, check type and collation match */
-		if (atttypid != att->atttypid || atttypmod != att->atttypmod)
-			elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's type",
-				 attname, get_rel_name(to_rel));
-		if (attcollation != att->attcollation)
-			elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's collation",
-				 attname, get_rel_name(to_rel));
-
-		vars = lappend(vars, makeVar(newvarno,
-									 (AttrNumber) (new_attno + 1),
-									 atttypid,
-									 atttypmod,
-									 attcollation,
-									 0));
-		new_attno++;
-	}
-
-	*translated_vars = vars;
-}
-
-/*
- * translate_col_privs
- *	  Translate a bitmapset representing per-column privileges from the
- *	  parent rel's attribute numbering to the child's.
- *
- * The only surprise here is that we don't translate a parent whole-row
- * reference into a child whole-row reference.  That would mean requiring
- * permissions on all child columns, which is overly strict, since the
- * query is really only going to reference the inherited columns.  Instead
- * we set the per-column bits for all inherited columns.
- */
-static Bitmapset *
-translate_col_privs(const Bitmapset *parent_privs,
-					List *translated_vars)
-{
-	Bitmapset  *child_privs = NULL;
-	bool		whole_row;
-	int			attno;
-	ListCell   *lc;
-
-	/* System attributes have the same numbers in all tables */
-	for (attno = FirstLowInvalidHeapAttributeNumber + 1; attno < 0; attno++)
-	{
-		if (bms_is_member(attno - FirstLowInvalidHeapAttributeNumber,
-						  parent_privs))
-			child_privs = bms_add_member(child_privs,
-										 attno - FirstLowInvalidHeapAttributeNumber);
-	}
-
-	/* Check if parent has whole-row reference */
-	whole_row = bms_is_member(InvalidAttrNumber - FirstLowInvalidHeapAttributeNumber,
-							  parent_privs);
-
-	/* And now translate the regular user attributes, using the vars list */
-	attno = InvalidAttrNumber;
-	foreach(lc, translated_vars)
-	{
-		Var		   *var = lfirst_node(Var, lc);
-
-		attno++;
-		if (var == NULL)		/* ignore dropped columns */
-			continue;
-		if (whole_row ||
-			bms_is_member(attno - FirstLowInvalidHeapAttributeNumber,
-						  parent_privs))
-			child_privs = bms_add_member(child_privs,
-										 var->varattno - FirstLowInvalidHeapAttributeNumber);
-	}
-
-	return child_privs;
-}
-
-/*
- *	build_append_child_rel
- *		Build a RelOptInfo for child relation of an append rel
- *
- * After creating the RelOptInfo for the given child RT index, it goes on to
- * initialize some of its fields based on the parent RelOptInfo.
- *
- * If the quals in baserestrictinfo turn out to be self-contradictory,
- * RelOptInfo is marked dummy before returning.
- */
-static RelOptInfo *
-build_append_child_rel(PlannerInfo *root,
-					   RelOptInfo *parent,
-					   Index childRTindex)
-{
-	RelOptInfo *childrel;
-	RangeTblEntry *childRTE = root->simple_rte_array[childRTindex];
-	AppendRelInfo *appinfo = root->append_rel_array[childRTindex];
-	List	   *childquals;
-	ListCell   *lc;
-	bool		have_const_false_cq;
-	Index		cq_min_security;
-
-	/* Build the RelOptInfo. */
-	childrel = build_simple_rel(root, childRTindex, parent);
-
-	/*
-	 * Propagate lateral_relids and lateral_referencers from appendrel
-	 * parent rels to their child rels.  We intentionally give each child rel
-	 * the same minimum parameterization, even though it's quite possible that
-	 * some don't reference all the lateral rels.  This is because any append
-	 * path for the parent will have to have the same parameterization for
-	 * every child anyway, and there's no value in forcing extra
-	 * reparameterize_path() calls.  Similarly, a lateral reference to the
-	 * parent prevents use of otherwise-movable join rels for each child.
-	 */
-	childrel->direct_lateral_relids = parent->direct_lateral_relids;
-	childrel->lateral_relids = parent->lateral_relids;
-	childrel->lateral_referencers = parent->lateral_referencers;
-
-	/*
-	 * We have to copy the parent's quals to the child, with appropriate
-	 * substitution of variables.  However, only the baserestrictinfo
-	 * quals are needed before we can check for constraint exclusion; so
-	 * do that first and then check to see if we can disregard this child.
-	 *
-	 * The child rel's targetlist might contain non-Var expressions, which
-	 * means that substitution into the quals could produce opportunities
-	 * for const-simplification, and perhaps even pseudoconstant quals.
-	 * Therefore, transform each RestrictInfo separately to see if it
-	 * reduces to a constant or pseudoconstant.  (We must process them
-	 * separately to keep track of the security level of each qual.)
-	 */
-	childquals = false;
-	cq_min_security = UINT_MAX;
-	have_const_false_cq = false;
-	foreach(lc, parent->baserestrictinfo)
-	{
-		RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
-		Node	   *childqual = (Node *) rinfo->clause;
-		ListCell   *lc2;
-
-		Assert(IsA(rinfo, RestrictInfo));
-		childqual = adjust_appendrel_attrs(root, childqual,
-										   1, &appinfo);
-		childqual = eval_const_expressions(root, childqual);
-		/* check for flat-out constant */
-		if (childqual && IsA(childqual, Const))
-		{
-			if (((Const *) childqual)->constisnull ||
-				!DatumGetBool(((Const *) childqual)->constvalue))
-			{
-				/* Restriction reduces to constant FALSE or NULL */
-				have_const_false_cq = true;
-				break;
-			}
-			/* Restriction reduces to constant TRUE, so drop it */
-			continue;
-		}
-		/* might have gotten an AND clause, if so flatten it */
-		foreach(lc2, make_ands_implicit((Expr *) childqual))
-		{
-			Node	   *onecq = (Node *) lfirst(lc2);
-			bool		pseudoconstant;
-
-			/* check for pseudoconstant (no Vars or volatile functions) */
-			pseudoconstant =
-					!contain_vars_of_level(onecq, 0) &&
-					!contain_volatile_functions(onecq);
-			if (pseudoconstant)
-			{
-				/* tell createplan.c to check for gating quals */
-				root->hasPseudoConstantQuals = true;
-			}
-			/* reconstitute RestrictInfo with appropriate properties */
-			childquals = lappend(childquals,
-								 make_restrictinfo((Expr *) onecq,
-												   rinfo->is_pushed_down,
-												   rinfo->outerjoin_delayed,
-												   pseudoconstant,
-												   rinfo->security_level,
-												   NULL, NULL, NULL));
-			cq_min_security = Min(cq_min_security, rinfo->security_level);
-		}
-	}
-
-	/*
-	 * In addition to the quals inherited from the parent, we might
-	 * have securityQuals associated with this particular child node.
-	 * (Currently this can only happen in appendrels originating from
-	 * UNION ALL; inheritance child tables don't have their own
-	 * securityQuals.)	Pull any such securityQuals up into the
-	 * baserestrictinfo for the child.  This is similar to
-	 * process_security_barrier_quals() for the parent rel, except
-	 * that we can't make any general deductions from such quals,
-	 * since they don't hold for the whole appendrel.
-	 */
-	if (childRTE->securityQuals)
-	{
-		Index		security_level = 0;
-
-		foreach(lc, childRTE->securityQuals)
-		{
-			List	   *qualset = (List *) lfirst(lc);
-			ListCell   *lc2;
-
-			foreach(lc2, qualset)
-			{
-				Expr	   *qual = (Expr *) lfirst(lc2);
-
-				/*
-				 * not likely that we'd see constants here, so no
-				 * check
-				 */
-				childquals = lappend(childquals,
-									 make_restrictinfo(qual,
-													   true,
-													   false,
-													   false,
-													   security_level,
-													   NULL, NULL,
-													   NULL));
-				cq_min_security = Min(cq_min_security, security_level);
-			}
-			security_level++;
-		}
-		Assert(security_level <= root->qual_security_level);
-	}
-
-	/* Set child's version of baserestrictinfo. */
-	childrel->baserestrictinfo = childquals;
-	childrel->baserestrict_min_security = cq_min_security;
-
-	if (have_const_false_cq)
-	{
-		/*
-		 * Some restriction clause reduced to constant FALSE or NULL after
-		 * substitution, so this child need not be scanned.
-		 */
-		set_dummy_rel_pathlist(childrel);
-	}
-
-	return childrel;
-}
-
-/*
- * add_rowmark_junk_columns
- * 		Add necessary junk columns for rowmarked inheritance parent rel.
- *
- * These values are needed for locking of rels selected FOR UPDATE/SHARE, and
- * to do EvalPlanQual rechecking.  See comments for PlanRowMark in
- * plannodes.h.
- */
-static List *
-add_rowmark_junk_columns(PlannerInfo *root, PlanRowMark *rc)
-{
-	List   *tlist = root->processed_tlist;
-	Var		   *var;
-	char		resname[32];
-	TargetEntry *tle;
-
-	if (rc->allMarkTypes & ~(1 << ROW_MARK_COPY))
-	{
-		/* Need to fetch TID */
-		var = makeVar(rc->rti,
-					  SelfItemPointerAttributeNumber,
-					  TIDOID,
-					  -1,
-					  InvalidOid,
-					  0);
-		snprintf(resname, sizeof(resname), "ctid%u", rc->rowmarkId);
-		tle = makeTargetEntry((Expr *) var,
-							  list_length(tlist) + 1,
-							  pstrdup(resname),
-							  true);
-		tlist = lappend(tlist, tle);
-	}
-	if (rc->allMarkTypes & (1 << ROW_MARK_COPY))
-	{
-		/* Need the whole row as a junk var */
-		var = makeWholeRowVar(root->simple_rte_array[rc->rti],
-							  rc->rti,
-							  0,
-							  false);
-		snprintf(resname, sizeof(resname), "wholerow%u", rc->rowmarkId);
-		tle = makeTargetEntry((Expr *) var,
-							  list_length(tlist) + 1,
-							  pstrdup(resname),
-							  true);
-		tlist = lappend(tlist, tle);
-	}
-
-	/* For inheritance cases, always fetch the tableoid too. */
-	var = makeVar(rc->rti,
-				  TableOidAttributeNumber,
-				  OIDOID,
-				  -1,
-				  InvalidOid,
-				  0);
-	snprintf(resname, sizeof(resname), "tableoid%u", rc->rowmarkId);
-	tle = makeTargetEntry((Expr *) var,
-						  list_length(tlist) + 1,
-						  pstrdup(resname),
-						  true);
-	tlist = lappend(tlist, tle);
-
-	return tlist;
-}
-
-AppendRelInfo *
-make_append_rel_info(RelOptInfo *parentrel, RangeTblEntry *parentrte,
-					 TupleDesc childdesc, Oid childoid, Oid childreltype,
-					 Index childRTindex)
-{
-	AppendRelInfo  *appinfo = makeNode(AppendRelInfo);
-
-	appinfo->parent_relid = parentrel->relid;
-	appinfo->child_relid = childRTindex;
-	appinfo->parent_reltype = parentrel->reltype;
-	appinfo->child_reltype = childreltype;
-	make_inh_translation_list(parentrel->tupdesc, childdesc,
-							  parentrte->relid, childoid,
-							  childRTindex,
-							  &appinfo->translated_vars);
-	appinfo->parent_reloid = parentrte->relid;
-
-	return appinfo;
-}
-
-/*
- * adjust_appendrel_attrs
- *	  Copy the specified query or expression and translate Vars referring to a
- *	  parent rel to refer to the corresponding child rel instead.  We also
- *	  update rtindexes appearing outside Vars, such as resultRelation and
- *	  jointree relids.
- *
- * Note: this is only applied after conversion of sublinks to subplans,
- * so we don't need to cope with recursion into sub-queries.
- *
- * Note: this is not hugely different from what pullup_replace_vars() does;
- * maybe we should try to fold the two routines together.
- */
-Node *
-adjust_appendrel_attrs(PlannerInfo *root, Node *node, int nappinfos,
-					   AppendRelInfo **appinfos)
-{
-	Node	   *result;
-	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);
-
-	/*
-	 * Must be prepared to start with a Query or a bare expression tree.
-	 */
-	if (node && IsA(node, Query))
-	{
-		Query	   *newnode;
-		int			cnt;
-
-		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;
-}
-
-static Node *
-adjust_appendrel_attrs_mutator(Node *node,
-							   adjust_appendrel_attrs_context *context)
-{
-	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;
-
-		for (cnt = 0; cnt < nappinfos; cnt++)
-		{
-			if (var->varno == appinfos[cnt]->parent_relid)
-			{
-				appinfo = appinfos[cnt];
-				break;
-			}
-		}
-
-		if (var->varlevelsup == 0 && appinfo)
-		{
-			var->varno = appinfo->child_relid;
-			var->varnoold = appinfo->child_relid;
-			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));
-				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;
-
-					return (Node *) rowexpr;
-				}
-			}
-			/* system attributes don't need any other translation */
-		}
-		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, 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 */
-		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, context->nappinfos,
-											  context->appinfos);
-		return (Node *) phv;
-	}
-
-	/*
-	 * This is needed, because inheritance_make_rel_from_joinlist needs to
-	 * translate root->join_info_list executing make_rel_from_joinlist for a
-	 * given child.
-	 */
-	if (IsA(node, SpecialJoinInfo))
-	{
-		SpecialJoinInfo *oldinfo = (SpecialJoinInfo *) node;
-		SpecialJoinInfo *newinfo = makeNode(SpecialJoinInfo);
-
-		memcpy(newinfo, oldinfo, sizeof(SpecialJoinInfo));
-		newinfo->min_lefthand = adjust_child_relids(oldinfo->min_lefthand,
-													context->nappinfos,
-													context->appinfos);
-		newinfo->min_righthand = adjust_child_relids(oldinfo->min_righthand,
-													 context->nappinfos,
-													 context->appinfos);
-		newinfo->syn_lefthand = adjust_child_relids(oldinfo->syn_lefthand,
-													context->nappinfos,
-													context->appinfos);
-		newinfo->syn_righthand = adjust_child_relids(oldinfo->syn_righthand,
-													 context->nappinfos,
-													 context->appinfos);
-		newinfo->semi_rhs_exprs =
-					(List *) expression_tree_mutator((Node *)
-													 oldinfo->semi_rhs_exprs,
-													 adjust_appendrel_attrs_mutator,
-													 (void *) context);
-		return (Node *) newinfo;
-	}
-
-	/* Shouldn't need to handle planner auxiliary nodes here */
-	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 */
-		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->nullable_relids = adjust_child_relids(oldinfo->nullable_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));
-
-	return expression_tree_mutator(node, adjust_appendrel_attrs_mutator,
-								   (void *) context);
-}
-
-/*
- * Substitute child relids for parent relids in a Relid set.  The array of
- * appinfos specifies the substitutions to be performed.
- */
-static Relids
-adjust_child_relids(Relids relids, int nappinfos, AppendRelInfo **appinfos)
-{
-	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;
-}
-
-/*
- * Replace any relid present in top_parent_relids with its child in
- * child_relids. Members of child_relids can be multiple levels below top
- * parent in the partition hierarchy.
- */
-Relids
-adjust_child_relids_multilevel(PlannerInfo *root, Relids relids,
-							   Relids child_relids, Relids top_parent_relids)
-{
-	AppendRelInfo **appinfos;
-	int			nappinfos;
-	Relids		parent_relids = NULL;
-	Relids		result;
-	Relids		tmp_result = NULL;
-	int			cnt;
-
-	/*
-	 * If the given relids set doesn't contain any of the top parent relids,
-	 * it will remain unchanged.
-	 */
-	if (!bms_overlap(relids, top_parent_relids))
-		return relids;
-
-	appinfos = find_appinfos_by_relids(root, child_relids, &nappinfos);
-
-	/* Construct relids set for the immediate parent of the given child. */
-	for (cnt = 0; cnt < nappinfos; cnt++)
-	{
-		AppendRelInfo *appinfo = appinfos[cnt];
-
-		parent_relids = bms_add_member(parent_relids, appinfo->parent_relid);
-	}
-
-	/* Recurse if immediate parent is not the top parent. */
-	if (!bms_equal(parent_relids, top_parent_relids))
-	{
-		tmp_result = adjust_child_relids_multilevel(root, relids,
-													parent_relids,
-													top_parent_relids);
-		relids = tmp_result;
-	}
-
-	result = adjust_child_relids(relids, nappinfos, appinfos);
-
-	/* Free memory consumed by any intermediate result. */
-	if (tmp_result)
-		bms_free(tmp_result);
-	bms_free(parent_relids);
-	pfree(appinfos);
-
-	return result;
-}
-
-/*
- * 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.
- */
-static List *
-adjust_inherited_tlist(List *tlist, AppendRelInfo *context)
-{
-	bool		changed_it = false;
-	ListCell   *tl;
-	List	   *new_tlist;
-	bool		more;
-	int			attrno;
-
-	/* 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)
-	{
-		TargetEntry *tle = (TargetEntry *) lfirst(tl);
-		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))
-			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);
-		if (childvar == NULL || !IsA(childvar, Var))
-			elog(ERROR, "attribute %d of relation \"%s\" does not exist",
-				 tle->resno, get_rel_name(context->parent_reloid));
-
-		if (tle->resno != childvar->varattno)
-		{
-			tle->resno = childvar->varattno;
-			changed_it = true;
-		}
-	}
-
-	/*
-	 * 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;
-
-	new_tlist = NIL;
-	more = true;
-	for (attrno = 1; more; attrno++)
-	{
-		more = false;
-		foreach(tl, tlist)
-		{
-			TargetEntry *tle = (TargetEntry *) lfirst(tl);
-
-			if (tle->resjunk)
-				continue;		/* ignore junk items */
-
-			if (tle->resno == attrno)
-				new_tlist = lappend(new_tlist, tle);
-			else if (tle->resno > attrno)
-				more = true;
-		}
-	}
-
-	foreach(tl, tlist)
-	{
-		TargetEntry *tle = (TargetEntry *) lfirst(tl);
-
-		if (!tle->resjunk)
-			continue;			/* here, ignore non-junk items */
-
-		tle->resno = attrno;
-		new_tlist = lappend(new_tlist, tle);
-		attrno++;
-	}
-
-	return new_tlist;
-}
-
-/*
- * adjust_appendrel_attrs_multilevel
- *	  Apply Var translations from a toplevel appendrel parent down to a child.
- *
- * In some cases we need to translate expressions referencing a parent relation
- * to reference an appendrel child that's multiple levels removed from it.
- */
-Node *
-adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node,
-								  Relids child_relids,
-								  Relids top_parent_relids)
-{
-	AppendRelInfo **appinfos;
-	Bitmapset  *parent_relids = NULL;
-	int			nappinfos;
-	int			cnt;
-
-	Assert(bms_num_members(child_relids) == bms_num_members(top_parent_relids));
-
-	appinfos = find_appinfos_by_relids(root, child_relids, &nappinfos);
-
-	/* Construct relids set for the immediate parent of given child. */
-	for (cnt = 0; cnt < nappinfos; cnt++)
-	{
-		AppendRelInfo *appinfo = appinfos[cnt];
-
-		parent_relids = bms_add_member(parent_relids, appinfo->parent_relid);
-	}
-
-	/* Recurse if immediate parent is not the top parent. */
-	if (!bms_equal(parent_relids, top_parent_relids))
-		node = adjust_appendrel_attrs_multilevel(root, node, parent_relids,
-												 top_parent_relids);
-
-	/* Now translate for this child */
-	node = adjust_appendrel_attrs(root, node, nappinfos, appinfos);
-
-	pfree(appinfos);
-
-	return node;
-}
-
-/*
- * Construct the SpecialJoinInfo for a child-join by translating
- * SpecialJoinInfo for the join between parents. left_relids and right_relids
- * are the relids of left and right side of the join respectively.
- */
-SpecialJoinInfo *
-build_child_join_sjinfo(PlannerInfo *root, SpecialJoinInfo *parent_sjinfo,
-						Relids left_relids, Relids right_relids)
-{
-	SpecialJoinInfo *sjinfo = makeNode(SpecialJoinInfo);
-	AppendRelInfo **left_appinfos;
-	int			left_nappinfos;
-	AppendRelInfo **right_appinfos;
-	int			right_nappinfos;
-
-	memcpy(sjinfo, parent_sjinfo, sizeof(SpecialJoinInfo));
-	left_appinfos = find_appinfos_by_relids(root, left_relids,
-											&left_nappinfos);
-	right_appinfos = find_appinfos_by_relids(root, right_relids,
-											 &right_nappinfos);
-
-	sjinfo->min_lefthand = adjust_child_relids(sjinfo->min_lefthand,
-											   left_nappinfos, left_appinfos);
-	sjinfo->min_righthand = adjust_child_relids(sjinfo->min_righthand,
-												right_nappinfos,
-												right_appinfos);
-	sjinfo->syn_lefthand = adjust_child_relids(sjinfo->syn_lefthand,
-											   left_nappinfos, left_appinfos);
-	sjinfo->syn_righthand = adjust_child_relids(sjinfo->syn_righthand,
-												right_nappinfos,
-												right_appinfos);
-	sjinfo->semi_rhs_exprs = (List *) adjust_appendrel_attrs(root,
-															 (Node *) sjinfo->semi_rhs_exprs,
-															 right_nappinfos,
-															 right_appinfos);
-
-	pfree(left_appinfos);
-	pfree(right_appinfos);
-
-	return sjinfo;
-}
-
-/*
- * find_appinfos_by_relids
- * 		Find AppendRelInfo structures for all relations specified by relids.
- *
- * The AppendRelInfos are returned in an array, which can be pfree'd by the
- * caller. *nappinfos is set to the number of entries in the array.
- */
-AppendRelInfo **
-find_appinfos_by_relids(PlannerInfo *root, Relids relids, int *nappinfos)
-{
-	AppendRelInfo **appinfos;
-	int			cnt = 0;
-	int			i;
-
-	*nappinfos = bms_num_members(relids);
-	appinfos = (AppendRelInfo **) palloc(sizeof(AppendRelInfo *) * *nappinfos);
-
-	i = -1;
-	while ((i = bms_next_member(relids, i)) >= 0)
-	{
-		AppendRelInfo *appinfo = root->append_rel_array[i];
-
-		if (!appinfo)
-			elog(ERROR, "child rel %d not found in append_rel_array", i);
-
-		appinfos[cnt++] = appinfo;
-	}
-	return appinfos;
-}
diff --git a/src/backend/optimizer/util/Makefile b/src/backend/optimizer/util/Makefile
index da9ccf32b4..d166030a10 100644
--- a/src/backend/optimizer/util/Makefile
+++ b/src/backend/optimizer/util/Makefile
@@ -12,7 +12,8 @@ subdir = src/backend/optimizer/util
 top_builddir = ../../../..
 include $(top_builddir)/src/Makefile.global
 
-OBJS = clauses.o joininfo.o orclauses.o pathnode.o placeholder.o \
-	   plancat.o predtest.o relnode.o restrictinfo.o tlist.o var.o
+OBJS = append.o appendinfo.o clauses.o joininfo.o orclauses.o pathnode.o \
+	   placeholder.o plancat.o predtest.o relnode.o restrictinfo.o tlist.o \
+	   var.o
 
 include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/optimizer/util/append.c b/src/backend/optimizer/util/append.c
new file mode 100644
index 0000000000..e78a61d613
--- /dev/null
+++ b/src/backend/optimizer/util/append.c
@@ -0,0 +1,776 @@
+/*-------------------------------------------------------------------------
+ *
+ * append.c
+ *	  Routines to process children of an appendrel parent
+ *
+ * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/optimizer/path/append.c
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include <limits.h>
+
+#include "access/sysattr.h"
+#include "catalog/partition.h"
+#include "catalog/pg_class.h"
+#include "catalog/pg_inherits.h"
+#include "catalog/pg_type.h"
+#include "nodes/makefuncs.h"
+#include "optimizer/append.h"
+#include "optimizer/appendinfo.h"
+#include "optimizer/clauses.h"
+#include "optimizer/pathnode.h"
+#include "optimizer/paths.h"
+#include "optimizer/plancat.h"
+#include "optimizer/planmain.h"
+#include "optimizer/planner.h"
+#include "optimizer/prep.h"
+#include "optimizer/restrictinfo.h"
+#include "optimizer/tlist.h"
+#include "optimizer/var.h"
+#include "partitioning/partprune.h"
+#include "utils/rel.h"
+
+static void expand_append_rtentry(PlannerInfo *root, RelOptInfo *rel,
+					  RangeTblEntry *rte, Index rti);
+static void expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte,
+						 Index rti, RelOptInfo *rel);
+static void expand_partitioned_rtentry(PlannerInfo *root,
+						   RangeTblEntry *parentrte,
+						   Index parentRTindex, RelOptInfo *parentrel);
+static RelOptInfo *add_inheritance_child_rel(PlannerInfo *root,
+						  RangeTblEntry *parentrte,
+						  Index parentRTindex, RelOptInfo *parentrel,
+						  PlanRowMark *top_parentrc, Relation childrel,
+						  RangeTblEntry **childrte_p, Index *childRTindex_p);
+static RelOptInfo *build_append_child_rel(PlannerInfo *root,
+					   RelOptInfo *parent,
+					   Index childRTindex);
+static List *add_rowmark_junk_columns(PlannerInfo *root, PlanRowMark *rc);
+
+
+/*
+ * expand_inherited_tables
+ *		Expand each rangetable entry that represents an inheritance set
+ *		into an "append relation".  At the conclusion of this process,
+ *		the "inh" flag is set in all and only those RTEs that are append
+ *		relation parents.
+ */
+void
+expand_inherited_tables(PlannerInfo *root)
+{
+	int			orig_rtable_size;
+	Index		rti;
+
+	Assert(root->simple_rel_array_size > 0);
+	orig_rtable_size = root->simple_rel_array_size;
+
+	/*
+	 * expand_append_rtentry may add RTEs to parse->rtable. The function is
+	 * expected to recursively handle any RTEs that it creates with inh=true.
+	 * So just scan as far as the original end of the rtable list.
+	 */
+	for (rti = 1; rti < orig_rtable_size; rti++)
+	{
+		RelOptInfo *brel = root->simple_rel_array[rti];
+		RangeTblEntry *rte = root->simple_rte_array[rti];
+
+		/* there may be empty slots corresponding to non-baserel RTEs */
+		if (brel == NULL)
+			continue;
+
+		if (rte->inh)
+			expand_append_rtentry(root, brel, rte, rti);
+	}
+}
+
+/*
+ * expand_append_rtentry
+ *		This initializes RelOptInfos for an appendrel's child relations, if
+ *		any
+ *
+ * 'rel' is the appendrel parent, whose range table entry ('rte') has been
+ * marked to require adding children.  An appendrel parent could either
+ * be a subquery (if we flattened UNION ALL query) or a table that's known
+ * to have inheritance children.  The latter consists of both regular
+ * inheritance parents and partitioned tables.
+ *
+ * For a subquery parent, there is not much to be done here because the
+ * children's RTEs are already present in the query, so we just initialize
+ * RelOptInfos for them.  Also, the AppendRelInfos for child subqueries
+ * have already been added.
+ *
+ * For tables, we need to add the children to the range table and initialize
+ * AppendRelInfos, RelOptInfos, and PlanRowMarks (if any) for them.  For
+ * a partitioned parent, we only add the children remaining after pruning.
+ * For regular inheritance parents, we find the children using
+ * find_all_inheritors and add all of them.
+ *
+ * If it turns out that there are no children, then we set rte->inh to false
+ * to let the caller know that only the parent table needs to be scanned.  The
+ * caller can accordingly switch to a non-Append path.  For a partitioned
+ * parent, that means an empty relation because parents themselves contain no
+ * data.
+ *
+ * For the regular inheritance case, the parent also gets another RTE with
+ * inh = false to represent it as an appendrel child.  The original RTE is
+ * considered to represent the whole inheritance set.
+ */
+static void
+expand_append_rtentry(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte,
+					  Index rti)
+{
+	Assert(rte->inh);
+	/* Inheritance parent (partitioned or not) or UNION ALL parent subquery. */
+	Assert(rte->rtekind == RTE_RELATION || rte->rtekind == RTE_SUBQUERY);
+
+	/*
+	 * UNION ALL children already got RTEs and AppendRelInfos, so just build
+	 * RelOptInfos and return.
+	 *
+	 * It might be a bit odd that this code is in this, because there is
+	 * nothing to expand really.
+	 */
+	if (rte->rtekind == RTE_SUBQUERY)
+	{
+		ListCell   *l;
+
+		/*
+		 * We don't need to use expand_planner_arrays in this case, because
+		 * no new child RTEs are created.  setup_simple_rel_arrays() and
+		 * setup_append_rel_array would've considered these child RTEs when
+		 * allocating space for various arrays.
+		 */
+		foreach(l, root->append_rel_list)
+		{
+			AppendRelInfo *appinfo = lfirst(l);
+			Index		childRTindex = appinfo->child_relid;
+
+			if (appinfo->parent_relid != rti)
+				continue;
+
+			Assert(childRTindex < root->simple_rel_array_size);
+			Assert(root->simple_rte_array[childRTindex] != NULL);
+
+			/*
+			 * We set the correct value of baserestricinfo and
+			 * baserestrict_min_security below.
+			 */
+			root->simple_rel_array[childRTindex] =
+				build_append_child_rel(root, rel, appinfo->child_relid);
+		}
+	}
+	else
+	{
+		Assert(rte->rtekind == RTE_RELATION);
+		Assert(has_subclass(rte->relid));
+
+		/*
+		 * The rewriter should already have obtained an appropriate lock on
+		 * each relation named in the query.  However, for each child relation
+		 * we add to the query, we must obtain an appropriate lock, because
+		 * this will be the first use of those relations in the
+		 * parse/rewrite/plan pipeline.  Child rels should use the same
+		 * lockmode as their parent.
+		 */
+		Assert(rte->rellockmode != NoLock);
+
+		if (rte->relkind == RELKIND_PARTITIONED_TABLE)
+			expand_partitioned_rtentry(root, rte, rti, rel);
+		else
+			expand_inherited_rtentry(root, rte, rti, rel);
+	}
+}
+
+/*
+ * expand_inherited_rtentry
+ *		Add entries for all the child tables to the query's rangetable, and
+ *		build AppendRelInfo nodes for all the child tables and add them to
+ *		root->append_rel_list.
+ *
+ * Note that the original RTE is considered to represent the whole
+ * inheritance set.  The first of the generated RTEs is an RTE for the same
+ * table, but with inh = false, to represent the parent table in its role
+ * as a simple member of the inheritance set.
+ *
+ * A childless table is never considered to be an inheritance set. For
+ * regular inheritance, a parent RTE must always have at least two associated
+ * AppendRelInfos: one corresponding to the parent table as a simple member of
+ * inheritance set and one or more corresponding to the actual children.
+ */
+static void
+expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti,
+						 RelOptInfo *rel)
+{
+	Oid			parentOID;
+	PlanRowMark *oldrc;
+	LOCKMODE	lockmode = rte->rellockmode;
+	List	   *inhOIDs;
+	ListCell   *l;
+	int			num_children;
+	int			num_children_added = 0;
+
+	Assert(rte->rtekind == RTE_RELATION);
+	Assert(lockmode != NoLock);
+	parentOID = rte->relid;
+
+	/* Scan for all members of inheritance set, acquire needed locks */
+	inhOIDs = find_all_inheritors(parentOID, lockmode, NULL);
+
+	/*
+	 * Check that there's at least one descendant, else treat as no-child
+	 * case.  This could happen despite has_subclass() check performed by
+	 * subquery_planner, if table once had a child but no longer does.
+	 */
+	num_children = list_length(inhOIDs);
+	if (num_children < 2)
+	{
+		/* Clear flag before returning */
+		rte->inh = false;
+		return;
+	}
+
+	/*
+	 * If parent relation is selected FOR UPDATE/SHARE, preprocess_rowmarks
+	 * should've set isParent = true.  We'll generate a new PlanRowMark for
+	 * each child.
+	 */
+	oldrc = get_plan_rowmark(root->rowMarks, rti);
+	Assert(oldrc == NULL || oldrc->isParent);
+
+	/*
+	 * Must expand PlannerInfo arrays by num_children before we can add
+	 * children.
+	 */
+	expand_planner_arrays(root, num_children);
+
+	foreach(l, inhOIDs)
+	{
+		Oid			childOID = lfirst_oid(l);
+		Relation	newrelation;
+		RangeTblEntry *childrte;
+		Index		childRTindex;
+
+		/* Already locked above. */
+		newrelation = heap_open(childOID, NoLock);
+
+		/*
+		 * It is possible that the parent table has children that are temp
+		 * tables of other backends.  We cannot safely access such tables
+		 * (because of buffering issues), and the best thing to do seems
+		 * to be to silently ignore them.
+		 */
+		if (RELATION_IS_OTHER_TEMP(newrelation))
+		{
+			heap_close(newrelation, lockmode);
+			continue;
+		}
+
+		(void) add_inheritance_child_rel(root, rte, rti, rel, oldrc,
+										 newrelation, &childrte,
+										 &childRTindex);
+		Assert(childrte != NULL);
+		/* All regular inheritance children are leaf children. */
+		Assert(!childrte->inh);
+		Assert(childRTindex > 0);
+
+		/* Close child relations, but keep locks */
+		heap_close(newrelation, NoLock);
+		num_children_added++;
+	}
+
+	/*
+	 * If all children, including the parent (as child rel), were
+	 * excluded, mark the parent rel as empty.  If all the children were temp
+	 * tables, pretend it's a non-inheritance situation; we don't need Append
+	 * node in that case.  The duplicate RTE we added for the parent table is
+	 * harmless, so we don't bother to get rid of it; ditto for the useless
+	 * PlanRowMark node.
+	 */
+	if (num_children_added == 0)
+		mark_dummy_rel(rel);
+	else if (num_children_added == 1)
+		rte->inh = false;
+
+	/*
+	 * Add junk columns needed by the row mark if any and also add the
+	 * relevant expressions to the root parent's reltarget.
+	 */
+	if (oldrc)
+	{
+		List   *tlist = add_rowmark_junk_columns(root, oldrc);
+
+		build_base_rel_tlists(root, tlist);
+	}
+}
+
+/*
+ * expand_partitioned_rtentry
+ *		Prunes unnecessary partitions of a partitioned table and adds
+ *		remaining ones to the Query and the PlannerInfo
+ *
+ * Partitions are added to the query in order in which they are found in
+ * the parent's PartitionDesc.
+ *
+ * Note: even though only the unpruned partitions will be added to the
+ * resulting plan, this still locks *all* partitions via find_all_inheritors
+ * when this function is called for the root partitioned table.
+ */
+static void
+expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
+						   Index parentRTindex, RelOptInfo *parentrel)
+{
+	LOCKMODE	lockmode = parentrte->rellockmode;
+	PlanRowMark *rootrc = NULL;
+	int			i;
+	Bitmapset  *partindexes;
+	Index		rootParentRTindex = parentrel->inh_root_parent > 0 ?
+									parentrel->inh_root_parent :
+									parentRTindex;
+
+	/* If root partitioned table, lock *all* partitions in the tree. */
+	if (parentRTindex == rootParentRTindex)
+		(void) find_all_inheritors(parentrte->relid, lockmode, NULL);
+
+	/*
+	 * Initialize partitioned_child_rels to contain this RT index.
+	 *
+	 * Note that during the set_append_rel_pathlist() phase, values of the
+	 * indexes of partitioned relations that appear down in the tree will be
+	 * bubbled up into root parent's list so that when we've created Paths for
+	 * all the children, the root table's list will contain all such indexes.
+	 */
+	parentrel->partitioned_child_rels = list_make1_int(parentRTindex);
+
+	/* Perform pruning. */
+	partindexes = prune_append_rel_partitions(parentrel);
+
+	/* Must expand PlannerInfo arrays before we can add children. */
+	expand_planner_arrays(root, bms_num_members(partindexes));
+
+	/*
+	 * For partitioned tables, we also store the partition RelOptInfo
+	 * pointers in the parent's RelOptInfo.
+	 */
+	parentrel->part_rels = (RelOptInfo **) palloc0(sizeof(RelOptInfo *) *
+												   parentrel->nparts);
+
+	rootrc = get_plan_rowmark(root->rowMarks, rootParentRTindex);
+	Assert(rootrc == NULL || rootrc->isParent);
+	i = -1;
+	while ((i = bms_next_member(partindexes, i)) >= 0)
+	{
+		Oid		childOID = parentrel->part_oids[i];
+		Relation	newrelation;
+		RelOptInfo *childrel;
+		RangeTblEntry *childrte;
+		Index		childRTindex;
+
+		/* Already locked above. */
+		newrelation = heap_open(childOID, NoLock);
+		Assert(!RELATION_IS_OTHER_TEMP(newrelation));
+
+		/*
+		 * A partitioned child table with 0 children is a dummy rel, so don't
+		 * bother creating planner objects for it.
+		 */
+		if (newrelation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE &&
+			RelationGetPartitionDesc(newrelation)->nparts == 0)
+		{
+			heap_close(newrelation, NoLock);
+			continue;
+		}
+
+		childrel = add_inheritance_child_rel(root, parentrte, parentRTindex,
+											 parentrel, rootrc, newrelation,
+											 &childrte, &childRTindex);
+		Assert(childrel != NULL);
+		parentrel->part_rels[i] = childrel;
+
+		/* Close child relations, but keep locks */
+		heap_close(newrelation, NoLock);
+
+		/* If the child is partitioned itself, expand it too. */
+		if (childrel->part_scheme)
+		{
+			Assert(childrte->inh);
+			expand_partitioned_rtentry(root, childrte, childRTindex,
+									   childrel);
+		}
+	}
+
+	/*
+	 * Add junk columns needed by the row mark if any and also add the
+	 * relevant expressions to the root parent's reltarget.
+	 */
+	if (rootrc)
+	{
+		List   *tlist = add_rowmark_junk_columns(root, rootrc);
+
+		build_base_rel_tlists(root, tlist);
+	}
+}
+
+/*
+ * add_inheritance_child_rel
+ *		Build a RangeTblEntry, an AppendRelInfo, a PlanRowMark, and finally
+ *		a RelOptInfo for an inheritance child relation.
+ *
+ * The return value is the RelOptInfo that's added.
+ *
+ * PlanRowMarks still carry the top-parent's RTI, and the top-parent's
+ * allMarkTypes field still accumulates values from all descendents.
+ *
+ * "parentrte" and "parentRTindex" are immediate parent's RTE and
+ * RTI. "top_parentrc" is top parent's PlanRowMark.
+ */
+static RelOptInfo *
+add_inheritance_child_rel(PlannerInfo *root, RangeTblEntry *parentrte,
+						  Index parentRTindex, RelOptInfo *parentrel,
+						  PlanRowMark *top_parentrc, Relation childrel,
+						  RangeTblEntry **childrte_p, Index *childRTindex_p)
+{
+	Query	   *parse = root->parse;
+	Oid			childOID = RelationGetRelid(childrel);
+	RangeTblEntry *childrte;
+	Index		childRTindex;
+	AppendRelInfo *appinfo;
+	RelOptInfo *childrelopt;
+
+	/*
+	 * Build an RTE for the child, and attach to query's rangetable list. We
+	 * copy most fields of the parent's RTE, but replace relation OID and
+	 * relkind, and set inh appropriately.  Also, set requiredPerms to zero
+	 * since all required permissions checks are done on the original RTE.
+	 * Likewise, set the child's securityQuals to empty, because we only want
+	 * to apply the parent's RLS conditions regardless of what RLS properties
+	 * individual children may have.  (This is an intentional choice to make
+	 * inherited RLS work like regular permissions checks.) The parent
+	 * securityQuals will be propagated to children along with other base
+	 * restriction clauses, so we don't need to do it here.
+	 */
+	childrte = copyObject(parentrte);
+	*childrte_p = childrte;
+	childrte->relid = childOID;
+	childrte->relkind = childrel->rd_rel->relkind;
+	/*
+	 * A partitioned child will need to be expanded as an append parent
+	 * itself, so set its inh to true.
+	 */
+	childrte->inh = (childrte->relkind == RELKIND_PARTITIONED_TABLE);
+	childrte->requiredPerms = 0;
+	childrte->securityQuals = NIL;
+	parse->rtable = lappend(parse->rtable, childrte);
+	childRTindex = list_length(parse->rtable);
+	*childRTindex_p = childRTindex;
+
+	/* Create an AppendRelInfo and add it to planner's global list. */
+	appinfo = make_append_rel_info(parentrel, parentrte,
+								   childrel->rd_att,
+								   childOID,
+								   childrel->rd_rel->reltype,
+								   childRTindex);
+	root->append_rel_list = lappend(root->append_rel_list, appinfo);
+
+	/*
+	 * Translate the column permissions bitmaps to the child's attnums (we
+	 * have to build the translated_vars list before we can do this). But
+	 * if this is the parent table, leave copyObject's result alone.
+	 *
+	 * Note: we need to do this even though the executor won't run any
+	 * permissions checks on the child RTE.  The insertedCols/updatedCols
+	 * bitmaps may be examined for trigger-firing purposes.
+	 */
+	if (childrte->relid != parentrte->relid)
+	{
+		childrte->selectedCols = translate_col_privs(parentrte->selectedCols,
+													 appinfo->translated_vars);
+		childrte->insertedCols = translate_col_privs(parentrte->insertedCols,
+													 appinfo->translated_vars);
+		childrte->updatedCols = translate_col_privs(parentrte->updatedCols,
+													appinfo->translated_vars);
+	}
+
+	/*
+	 * Build a PlanRowMark if parent is marked FOR UPDATE/SHARE.
+	 */
+	if (top_parentrc)
+	{
+		PlanRowMark *childrc = makeNode(PlanRowMark);
+
+		childrc->rti = childRTindex;
+		childrc->prti = top_parentrc->rti;
+		childrc->rowmarkId = top_parentrc->rowmarkId;
+		/* Reselect rowmark type, because relkind might not match parent */
+		childrc->markType = select_rowmark_type(childrte,
+												top_parentrc->strength);
+		childrc->allMarkTypes = (1 << childrc->markType);
+		childrc->strength = top_parentrc->strength;
+		childrc->waitPolicy = top_parentrc->waitPolicy;
+
+		/*
+		 * We mark RowMarks for partitioned child tables as parent RowMarks so
+		 * that the executor ignores them (except their existence means that
+		 * the child tables be locked using appropriate mode).
+		 */
+		childrc->isParent = (childrte->relkind == RELKIND_PARTITIONED_TABLE);
+
+		/* Include child's rowmark type in top parent's allMarkTypes */
+		top_parentrc->allMarkTypes |= childrc->allMarkTypes;
+
+		root->rowMarks = lappend(root->rowMarks, childrc);
+	}
+
+	/*
+	 * Add the RelOptInfo.  Even though we may not really scan this relation
+	 * for reasons such as contradictory quals, we still need to create one,
+	 * because for every RTE in the query's range table, there must be an
+	 * accompanying RelOptInfo.
+	 */
+
+	/* First, store the RTE and appinfos into planner arrays. */
+	Assert(root->simple_rte_array[childRTindex] == NULL);
+	root->simple_rte_array[childRTindex] = childrte;
+	Assert(root->append_rel_array[childRTindex] == NULL);
+	root->append_rel_array[childRTindex] = appinfo;
+
+	childrelopt = build_append_child_rel(root, parentrel, childRTindex);
+	Assert(childrelopt != NULL);
+
+	return childrelopt;
+}
+
+/*
+ *	build_append_child_rel
+ *		Build a RelOptInfo for child relation of an append rel
+ *
+ * After creating the RelOptInfo for the given child RT index, it goes on to
+ * initialize some of its fields based on the parent RelOptInfo.
+ *
+ * If the quals in baserestrictinfo turn out to be self-contradictory, the
+ * RelOptInfo is marked dummy before returning.
+ */
+static RelOptInfo *
+build_append_child_rel(PlannerInfo *root,
+					   RelOptInfo *parent,
+					   Index childRTindex)
+{
+	RelOptInfo *childrel;
+	RangeTblEntry *childRTE = root->simple_rte_array[childRTindex];
+	AppendRelInfo *appinfo = root->append_rel_array[childRTindex];
+	List	   *childquals;
+	ListCell   *lc;
+	bool		have_const_false_cq;
+	Index		cq_min_security;
+
+	/* Build the RelOptInfo. */
+	childrel = build_simple_rel(root, childRTindex, parent);
+
+	/*
+	 * Propagate lateral_relids and lateral_referencers from appendrel
+	 * parent rels to their child rels.  We intentionally give each child rel
+	 * the same minimum parameterization, even though it's quite possible that
+	 * some don't reference all the lateral rels.  This is because any append
+	 * path for the parent will have to have the same parameterization for
+	 * every child anyway, and there's no value in forcing extra
+	 * reparameterize_path() calls.  Similarly, a lateral reference to the
+	 * parent prevents use of otherwise-movable join rels for each child.
+	 */
+	childrel->direct_lateral_relids = parent->direct_lateral_relids;
+	childrel->lateral_relids = parent->lateral_relids;
+	childrel->lateral_referencers = parent->lateral_referencers;
+
+	/*
+	 * We have to copy the parent's quals to the child, with appropriate
+	 * substitution of variables.  However, only the baserestrictinfo
+	 * quals are needed before we can check for constraint exclusion; so
+	 * do that first and then check to see if we can disregard this child.
+	 *
+	 * The child rel's targetlist might contain non-Var expressions, which
+	 * means that substitution into the quals could produce opportunities
+	 * for const-simplification, and perhaps even pseudoconstant quals.
+	 * Therefore, transform each RestrictInfo separately to see if it
+	 * reduces to a constant or pseudoconstant.  (We must process them
+	 * separately to keep track of the security level of each qual.)
+	 */
+	childquals = false;
+	cq_min_security = UINT_MAX;
+	have_const_false_cq = false;
+	foreach(lc, parent->baserestrictinfo)
+	{
+		RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
+		Node	   *childqual = (Node *) rinfo->clause;
+		ListCell   *lc2;
+
+		Assert(IsA(rinfo, RestrictInfo));
+		childqual = adjust_appendrel_attrs(root, childqual,
+										   1, &appinfo);
+		childqual = eval_const_expressions(root, childqual);
+		/* check for flat-out constant */
+		if (childqual && IsA(childqual, Const))
+		{
+			if (((Const *) childqual)->constisnull ||
+				!DatumGetBool(((Const *) childqual)->constvalue))
+			{
+				/* Restriction reduces to constant FALSE or NULL */
+				have_const_false_cq = true;
+				break;
+			}
+			/* Restriction reduces to constant TRUE, so drop it */
+			continue;
+		}
+		/* might have gotten an AND clause, if so flatten it */
+		foreach(lc2, make_ands_implicit((Expr *) childqual))
+		{
+			Node	   *onecq = (Node *) lfirst(lc2);
+			bool		pseudoconstant;
+
+			/* check for pseudoconstant (no Vars or volatile functions) */
+			pseudoconstant =
+					!contain_vars_of_level(onecq, 0) &&
+					!contain_volatile_functions(onecq);
+			if (pseudoconstant)
+			{
+				/* tell createplan.c to check for gating quals */
+				root->hasPseudoConstantQuals = true;
+			}
+			/* reconstitute RestrictInfo with appropriate properties */
+			childquals = lappend(childquals,
+								 make_restrictinfo((Expr *) onecq,
+												   rinfo->is_pushed_down,
+												   rinfo->outerjoin_delayed,
+												   pseudoconstant,
+												   rinfo->security_level,
+												   NULL, NULL, NULL));
+			cq_min_security = Min(cq_min_security, rinfo->security_level);
+		}
+	}
+
+	/*
+	 * In addition to the quals inherited from the parent, we might
+	 * have securityQuals associated with this particular child node.
+	 * (Currently this can only happen in appendrels originating from
+	 * UNION ALL; inheritance child tables don't have their own
+	 * securityQuals.)	Pull any such securityQuals up into the
+	 * baserestrictinfo for the child.  This is similar to
+	 * process_security_barrier_quals() for the parent rel, except
+	 * that we can't make any general deductions from such quals,
+	 * since they don't hold for the whole appendrel.
+	 */
+	if (childRTE->securityQuals)
+	{
+		Index		security_level = 0;
+
+		foreach(lc, childRTE->securityQuals)
+		{
+			List	   *qualset = (List *) lfirst(lc);
+			ListCell   *lc2;
+
+			foreach(lc2, qualset)
+			{
+				Expr	   *qual = (Expr *) lfirst(lc2);
+
+				/*
+				 * not likely that we'd see constants here, so no
+				 * check
+				 */
+				childquals = lappend(childquals,
+									 make_restrictinfo(qual,
+													   true,
+													   false,
+													   false,
+													   security_level,
+													   NULL, NULL,
+													   NULL));
+				cq_min_security = Min(cq_min_security, security_level);
+			}
+			security_level++;
+		}
+		Assert(security_level <= root->qual_security_level);
+	}
+
+	/* Set child's version of baserestrictinfo. */
+	childrel->baserestrictinfo = childquals;
+	childrel->baserestrict_min_security = cq_min_security;
+
+	if (have_const_false_cq)
+	{
+		/*
+		 * Some restriction clause reduced to constant FALSE or NULL after
+		 * substitution, so this child need not be scanned.
+		 */
+		set_dummy_rel_pathlist(childrel);
+	}
+
+	return childrel;
+}
+
+/*
+ * add_rowmark_junk_columns
+ * 		Add necessary junk columns for rowmarked inheritance parent rel.
+ *
+ * These values are needed for locking of rels selected FOR UPDATE/SHARE, and
+ * to do EvalPlanQual rechecking.  See comments for PlanRowMark in
+ * plannodes.h.
+ */
+static List *
+add_rowmark_junk_columns(PlannerInfo *root, PlanRowMark *rc)
+{
+	List   *tlist = root->processed_tlist;
+	Var		   *var;
+	char		resname[32];
+	TargetEntry *tle;
+
+	if (rc->allMarkTypes & ~(1 << ROW_MARK_COPY))
+	{
+		/* Need to fetch TID */
+		var = makeVar(rc->rti,
+					  SelfItemPointerAttributeNumber,
+					  TIDOID,
+					  -1,
+					  InvalidOid,
+					  0);
+		snprintf(resname, sizeof(resname), "ctid%u", rc->rowmarkId);
+		tle = makeTargetEntry((Expr *) var,
+							  list_length(tlist) + 1,
+							  pstrdup(resname),
+							  true);
+		tlist = lappend(tlist, tle);
+	}
+	if (rc->allMarkTypes & (1 << ROW_MARK_COPY))
+	{
+		/* Need the whole row as a junk var */
+		var = makeWholeRowVar(root->simple_rte_array[rc->rti],
+							  rc->rti,
+							  0,
+							  false);
+		snprintf(resname, sizeof(resname), "wholerow%u", rc->rowmarkId);
+		tle = makeTargetEntry((Expr *) var,
+							  list_length(tlist) + 1,
+							  pstrdup(resname),
+							  true);
+		tlist = lappend(tlist, tle);
+	}
+
+	/* For inheritance cases, always fetch the tableoid too. */
+	var = makeVar(rc->rti,
+				  TableOidAttributeNumber,
+				  OIDOID,
+				  -1,
+				  InvalidOid,
+				  0);
+	snprintf(resname, sizeof(resname), "tableoid%u", rc->rowmarkId);
+	tle = makeTargetEntry((Expr *) var,
+						  list_length(tlist) + 1,
+						  pstrdup(resname),
+						  true);
+	tlist = lappend(tlist, tle);
+
+	return tlist;
+}
diff --git a/src/backend/optimizer/util/appendinfo.c b/src/backend/optimizer/util/appendinfo.c
new file mode 100644
index 0000000000..9502535e53
--- /dev/null
+++ b/src/backend/optimizer/util/appendinfo.c
@@ -0,0 +1,851 @@
+/*-------------------------------------------------------------------------
+ *
+ * appendinfo.c
+ *	  Routines for mapping between append parent(s) and children
+ *
+ * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/optimizer/path/appendinfo.c
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include "access/htup_details.h"
+#include "access/sysattr.h"
+#include "nodes/makefuncs.h"
+#include "nodes/nodeFuncs.h"
+#include "optimizer/appendinfo.h"
+#include "parser/parsetree.h"
+#include "utils/rel.h"
+#include "utils/lsyscache.h"
+#include "utils/syscache.h"
+
+typedef struct
+{
+	PlannerInfo *root;
+	int			nappinfos;
+	AppendRelInfo **appinfos;
+} adjust_appendrel_attrs_context;
+
+static void make_inh_translation_list(TupleDesc old_tupdesc,
+						  TupleDesc new_tupdesc,
+						  Oid from_rel, Oid to_rel,
+						  Index newvarno, List **translated_vars);
+static Node *adjust_appendrel_attrs_mutator(Node *node,
+							   adjust_appendrel_attrs_context *context);
+static Relids adjust_child_relids(Relids relids, int nappinfos,
+					AppendRelInfo **appinfos);
+static List *adjust_inherited_tlist(List *tlist,
+					   AppendRelInfo *context);
+
+AppendRelInfo *
+make_append_rel_info(RelOptInfo *parentrel, RangeTblEntry *parentrte,
+					 TupleDesc childdesc, Oid childoid, Oid childreltype,
+					 Index childRTindex)
+{
+	AppendRelInfo  *appinfo = makeNode(AppendRelInfo);
+
+	appinfo->parent_relid = parentrel->relid;
+	appinfo->child_relid = childRTindex;
+	appinfo->parent_reltype = parentrel->reltype;
+	appinfo->child_reltype = childreltype;
+	make_inh_translation_list(parentrel->tupdesc, childdesc,
+							  parentrte->relid, childoid,
+							  childRTindex,
+							  &appinfo->translated_vars);
+	appinfo->parent_reloid = parentrte->relid;
+
+	return appinfo;
+}
+
+/*
+ * adjust_appendrel_attrs
+ *	  Copy the specified query or expression and translate Vars referring to a
+ *	  parent rel to refer to the corresponding child rel instead.  We also
+ *	  update rtindexes appearing outside Vars, such as resultRelation and
+ *	  jointree relids.
+ *
+ * Note: this is only applied after conversion of sublinks to subplans,
+ * so we don't need to cope with recursion into sub-queries.
+ *
+ * Note: this is not hugely different from what pullup_replace_vars() does;
+ * maybe we should try to fold the two routines together.
+ */
+Node *
+adjust_appendrel_attrs(PlannerInfo *root, Node *node, int nappinfos,
+					   AppendRelInfo **appinfos)
+{
+	Node	   *result;
+	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);
+
+	/*
+	 * Must be prepared to start with a Query or a bare expression tree.
+	 */
+	if (node && IsA(node, Query))
+	{
+		Query	   *newnode;
+		int			cnt;
+
+		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;
+}
+
+static Node *
+adjust_appendrel_attrs_mutator(Node *node,
+							   adjust_appendrel_attrs_context *context)
+{
+	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;
+
+		for (cnt = 0; cnt < nappinfos; cnt++)
+		{
+			if (var->varno == appinfos[cnt]->parent_relid)
+			{
+				appinfo = appinfos[cnt];
+				break;
+			}
+		}
+
+		if (var->varlevelsup == 0 && appinfo)
+		{
+			var->varno = appinfo->child_relid;
+			var->varnoold = appinfo->child_relid;
+			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));
+				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;
+
+					return (Node *) rowexpr;
+				}
+			}
+			/* system attributes don't need any other translation */
+		}
+		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, 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 */
+		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, context->nappinfos,
+											  context->appinfos);
+		return (Node *) phv;
+	}
+
+	/*
+	 * This is needed, because inheritance_make_rel_from_joinlist needs to
+	 * translate root->join_info_list executing make_rel_from_joinlist for a
+	 * given child.
+	 */
+	if (IsA(node, SpecialJoinInfo))
+	{
+		SpecialJoinInfo *oldinfo = (SpecialJoinInfo *) node;
+		SpecialJoinInfo *newinfo = makeNode(SpecialJoinInfo);
+
+		memcpy(newinfo, oldinfo, sizeof(SpecialJoinInfo));
+		newinfo->min_lefthand = adjust_child_relids(oldinfo->min_lefthand,
+													context->nappinfos,
+													context->appinfos);
+		newinfo->min_righthand = adjust_child_relids(oldinfo->min_righthand,
+													 context->nappinfos,
+													 context->appinfos);
+		newinfo->syn_lefthand = adjust_child_relids(oldinfo->syn_lefthand,
+													context->nappinfos,
+													context->appinfos);
+		newinfo->syn_righthand = adjust_child_relids(oldinfo->syn_righthand,
+													 context->nappinfos,
+													 context->appinfos);
+		newinfo->semi_rhs_exprs =
+					(List *) expression_tree_mutator((Node *)
+													 oldinfo->semi_rhs_exprs,
+													 adjust_appendrel_attrs_mutator,
+													 (void *) context);
+		return (Node *) newinfo;
+	}
+
+	/* Shouldn't need to handle planner auxiliary nodes here */
+	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 */
+		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->nullable_relids = adjust_child_relids(oldinfo->nullable_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));
+
+	return expression_tree_mutator(node, adjust_appendrel_attrs_mutator,
+								   (void *) context);
+}
+
+/*
+ * Substitute child relids for parent relids in a Relid set.  The array of
+ * appinfos specifies the substitutions to be performed.
+ */
+static Relids
+adjust_child_relids(Relids relids, int nappinfos, AppendRelInfo **appinfos)
+{
+	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;
+}
+
+/*
+ * Replace any relid present in top_parent_relids with its child in
+ * child_relids. Members of child_relids can be multiple levels below top
+ * parent in the partition hierarchy.
+ */
+Relids
+adjust_child_relids_multilevel(PlannerInfo *root, Relids relids,
+							   Relids child_relids, Relids top_parent_relids)
+{
+	AppendRelInfo **appinfos;
+	int			nappinfos;
+	Relids		parent_relids = NULL;
+	Relids		result;
+	Relids		tmp_result = NULL;
+	int			cnt;
+
+	/*
+	 * If the given relids set doesn't contain any of the top parent relids,
+	 * it will remain unchanged.
+	 */
+	if (!bms_overlap(relids, top_parent_relids))
+		return relids;
+
+	appinfos = find_appinfos_by_relids(root, child_relids, &nappinfos);
+
+	/* Construct relids set for the immediate parent of the given child. */
+	for (cnt = 0; cnt < nappinfos; cnt++)
+	{
+		AppendRelInfo *appinfo = appinfos[cnt];
+
+		parent_relids = bms_add_member(parent_relids, appinfo->parent_relid);
+	}
+
+	/* Recurse if immediate parent is not the top parent. */
+	if (!bms_equal(parent_relids, top_parent_relids))
+	{
+		tmp_result = adjust_child_relids_multilevel(root, relids,
+													parent_relids,
+													top_parent_relids);
+		relids = tmp_result;
+	}
+
+	result = adjust_child_relids(relids, nappinfos, appinfos);
+
+	/* Free memory consumed by any intermediate result. */
+	if (tmp_result)
+		bms_free(tmp_result);
+	bms_free(parent_relids);
+	pfree(appinfos);
+
+	return result;
+}
+
+/*
+ * adjust_appendrel_attrs_multilevel
+ *	  Apply Var translations from a toplevel appendrel parent down to a child.
+ *
+ * In some cases we need to translate expressions referencing a parent relation
+ * to reference an appendrel child that's multiple levels removed from it.
+ */
+Node *
+adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node,
+								  Relids child_relids,
+								  Relids top_parent_relids)
+{
+	AppendRelInfo **appinfos;
+	Bitmapset  *parent_relids = NULL;
+	int			nappinfos;
+	int			cnt;
+
+	Assert(bms_num_members(child_relids) == bms_num_members(top_parent_relids));
+
+	appinfos = find_appinfos_by_relids(root, child_relids, &nappinfos);
+
+	/* Construct relids set for the immediate parent of given child. */
+	for (cnt = 0; cnt < nappinfos; cnt++)
+	{
+		AppendRelInfo *appinfo = appinfos[cnt];
+
+		parent_relids = bms_add_member(parent_relids, appinfo->parent_relid);
+	}
+
+	/* Recurse if immediate parent is not the top parent. */
+	if (!bms_equal(parent_relids, top_parent_relids))
+		node = adjust_appendrel_attrs_multilevel(root, node, parent_relids,
+												 top_parent_relids);
+
+	/* Now translate for this child */
+	node = adjust_appendrel_attrs(root, node, nappinfos, appinfos);
+
+	pfree(appinfos);
+
+	return node;
+}
+
+/*
+ * Construct the SpecialJoinInfo for a child-join by translating
+ * SpecialJoinInfo for the join between parents. left_relids and right_relids
+ * are the relids of left and right side of the join respectively.
+ */
+SpecialJoinInfo *
+build_child_join_sjinfo(PlannerInfo *root, SpecialJoinInfo *parent_sjinfo,
+						Relids left_relids, Relids right_relids)
+{
+	SpecialJoinInfo *sjinfo = makeNode(SpecialJoinInfo);
+	AppendRelInfo **left_appinfos;
+	int			left_nappinfos;
+	AppendRelInfo **right_appinfos;
+	int			right_nappinfos;
+
+	memcpy(sjinfo, parent_sjinfo, sizeof(SpecialJoinInfo));
+	left_appinfos = find_appinfos_by_relids(root, left_relids,
+											&left_nappinfos);
+	right_appinfos = find_appinfos_by_relids(root, right_relids,
+											 &right_nappinfos);
+
+	sjinfo->min_lefthand = adjust_child_relids(sjinfo->min_lefthand,
+											   left_nappinfos, left_appinfos);
+	sjinfo->min_righthand = adjust_child_relids(sjinfo->min_righthand,
+												right_nappinfos,
+												right_appinfos);
+	sjinfo->syn_lefthand = adjust_child_relids(sjinfo->syn_lefthand,
+											   left_nappinfos, left_appinfos);
+	sjinfo->syn_righthand = adjust_child_relids(sjinfo->syn_righthand,
+												right_nappinfos,
+												right_appinfos);
+	sjinfo->semi_rhs_exprs = (List *) adjust_appendrel_attrs(root,
+															 (Node *) sjinfo->semi_rhs_exprs,
+															 right_nappinfos,
+															 right_appinfos);
+
+	pfree(left_appinfos);
+	pfree(right_appinfos);
+
+	return sjinfo;
+}
+
+/*
+ * find_appinfos_by_relids
+ * 		Find AppendRelInfo structures for all relations specified by relids.
+ *
+ * The AppendRelInfos are returned in an array, which can be pfree'd by the
+ * caller. *nappinfos is set to the number of entries in the array.
+ */
+AppendRelInfo **
+find_appinfos_by_relids(PlannerInfo *root, Relids relids, int *nappinfos)
+{
+	AppendRelInfo **appinfos;
+	int			cnt = 0;
+	int			i;
+
+	*nappinfos = bms_num_members(relids);
+	appinfos = (AppendRelInfo **) palloc(sizeof(AppendRelInfo *) * *nappinfos);
+
+	i = -1;
+	while ((i = bms_next_member(relids, i)) >= 0)
+	{
+		AppendRelInfo *appinfo = root->append_rel_array[i];
+
+		if (!appinfo)
+			elog(ERROR, "child rel %d not found in append_rel_array", i);
+
+		appinfos[cnt++] = appinfo;
+	}
+	return appinfos;
+}
+
+/*
+ * make_inh_translation_list
+ *	  Build the list of translations from parent Vars to child Vars for
+ *	  an inheritance child.
+ *
+ * For paranoia's sake, we match type/collation as well as attribute name.
+ */
+static void
+make_inh_translation_list(TupleDesc old_tupdesc, TupleDesc new_tupdesc,
+						  Oid from_rel, Oid to_rel,
+						  Index newvarno, List **translated_vars)
+{
+	List	   *vars = NIL;
+	int			oldnatts = old_tupdesc->natts;
+	int			newnatts = new_tupdesc->natts;
+	int			old_attno;
+	int			new_attno = 0;
+
+	for (old_attno = 0; old_attno < oldnatts; old_attno++)
+	{
+		Form_pg_attribute att;
+		char	   *attname;
+		Oid			atttypid;
+		int32		atttypmod;
+		Oid			attcollation;
+
+		att = TupleDescAttr(old_tupdesc, old_attno);
+		if (att->attisdropped)
+		{
+			/* Just put NULL into this list entry */
+			vars = lappend(vars, NULL);
+			continue;
+		}
+		attname = NameStr(att->attname);
+		atttypid = att->atttypid;
+		atttypmod = att->atttypmod;
+		attcollation = att->attcollation;
+
+		/*
+		 * When we are generating the "translation list" for the parent table
+		 * of an inheritance set, no need to search for matches.
+		 */
+		if (from_rel == to_rel)
+		{
+			vars = lappend(vars, makeVar(newvarno,
+										 (AttrNumber) (old_attno + 1),
+										 atttypid,
+										 atttypmod,
+										 attcollation,
+										 0));
+			continue;
+		}
+
+		/*
+		 * Otherwise we have to search for the matching column by name.
+		 * There's no guarantee it'll have the same column position, because
+		 * of cases like ALTER TABLE ADD COLUMN and multiple inheritance.
+		 * However, in simple cases, the relative order of columns is mostly
+		 * the same in both relations, so try the column of newrelation that
+		 * follows immediately after the one that we just found, and if that
+		 * fails, let syscache handle it.
+		 */
+		if (new_attno >= newnatts ||
+			(att = TupleDescAttr(new_tupdesc, new_attno))->attisdropped ||
+			strcmp(attname, NameStr(att->attname)) != 0)
+		{
+			HeapTuple	newtup;
+
+			newtup = SearchSysCacheAttName(to_rel, attname);
+			if (!newtup)
+				elog(ERROR, "could not find inherited attribute \"%s\" of relation \"%s\"",
+					 attname, get_rel_name(to_rel));
+			new_attno = ((Form_pg_attribute) GETSTRUCT(newtup))->attnum - 1;
+			ReleaseSysCache(newtup);
+
+			att = TupleDescAttr(new_tupdesc, new_attno);
+		}
+
+		/* Found it, check type and collation match */
+		if (atttypid != att->atttypid || atttypmod != att->atttypmod)
+			elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's type",
+				 attname, get_rel_name(to_rel));
+		if (attcollation != att->attcollation)
+			elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's collation",
+				 attname, get_rel_name(to_rel));
+
+		vars = lappend(vars, makeVar(newvarno,
+									 (AttrNumber) (new_attno + 1),
+									 atttypid,
+									 atttypmod,
+									 attcollation,
+									 0));
+		new_attno++;
+	}
+
+	*translated_vars = vars;
+}
+
+/*
+ * translate_col_privs
+ *	  Translate a bitmapset representing per-column privileges from the
+ *	  parent rel's attribute numbering to the child's.
+ *
+ * The only surprise here is that we don't translate a parent whole-row
+ * reference into a child whole-row reference.  That would mean requiring
+ * permissions on all child columns, which is overly strict, since the
+ * query is really only going to reference the inherited columns.  Instead
+ * we set the per-column bits for all inherited columns.
+ */
+Bitmapset *
+translate_col_privs(const Bitmapset *parent_privs,
+					List *translated_vars)
+{
+	Bitmapset  *child_privs = NULL;
+	bool		whole_row;
+	int			attno;
+	ListCell   *lc;
+
+	/* System attributes have the same numbers in all tables */
+	for (attno = FirstLowInvalidHeapAttributeNumber + 1; attno < 0; attno++)
+	{
+		if (bms_is_member(attno - FirstLowInvalidHeapAttributeNumber,
+						  parent_privs))
+			child_privs = bms_add_member(child_privs,
+										 attno - FirstLowInvalidHeapAttributeNumber);
+	}
+
+	/* Check if parent has whole-row reference */
+	whole_row = bms_is_member(InvalidAttrNumber - FirstLowInvalidHeapAttributeNumber,
+							  parent_privs);
+
+	/* And now translate the regular user attributes, using the vars list */
+	attno = InvalidAttrNumber;
+	foreach(lc, translated_vars)
+	{
+		Var		   *var = lfirst_node(Var, lc);
+
+		attno++;
+		if (var == NULL)		/* ignore dropped columns */
+			continue;
+		if (whole_row ||
+			bms_is_member(attno - FirstLowInvalidHeapAttributeNumber,
+						  parent_privs))
+			child_privs = bms_add_member(child_privs,
+										 var->varattno - FirstLowInvalidHeapAttributeNumber);
+	}
+
+	return child_privs;
+}
+
+/*
+ * 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.
+ */
+static List *
+adjust_inherited_tlist(List *tlist, AppendRelInfo *context)
+{
+	bool		changed_it = false;
+	ListCell   *tl;
+	List	   *new_tlist;
+	bool		more;
+	int			attrno;
+
+	/* 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)
+	{
+		TargetEntry *tle = (TargetEntry *) lfirst(tl);
+		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))
+			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);
+		if (childvar == NULL || !IsA(childvar, Var))
+			elog(ERROR, "attribute %d of relation \"%s\" does not exist",
+				 tle->resno, get_rel_name(context->parent_reloid));
+
+		if (tle->resno != childvar->varattno)
+		{
+			tle->resno = childvar->varattno;
+			changed_it = true;
+		}
+	}
+
+	/*
+	 * 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;
+
+	new_tlist = NIL;
+	more = true;
+	for (attrno = 1; more; attrno++)
+	{
+		more = false;
+		foreach(tl, tlist)
+		{
+			TargetEntry *tle = (TargetEntry *) lfirst(tl);
+
+			if (tle->resjunk)
+				continue;		/* ignore junk items */
+
+			if (tle->resno == attrno)
+				new_tlist = lappend(new_tlist, tle);
+			else if (tle->resno > attrno)
+				more = true;
+		}
+	}
+
+	foreach(tl, tlist)
+	{
+		TargetEntry *tle = (TargetEntry *) lfirst(tl);
+
+		if (!tle->resjunk)
+			continue;			/* here, ignore non-junk items */
+
+		tle->resno = attrno;
+		new_tlist = lappend(new_tlist, tle);
+		attrno++;
+	}
+
+	return new_tlist;
+}
diff --git a/src/backend/optimizer/util/pathnode.c b/src/backend/optimizer/util/pathnode.c
index d50d86b252..8ce88876c4 100644
--- a/src/backend/optimizer/util/pathnode.c
+++ b/src/backend/optimizer/util/pathnode.c
@@ -20,6 +20,7 @@
 #include "foreign/fdwapi.h"
 #include "nodes/extensible.h"
 #include "nodes/nodeFuncs.h"
+#include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index c23db9d78d..52a11f434f 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -17,6 +17,7 @@
 #include <limits.h>
 
 #include "miscadmin.h"
+#include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
diff --git a/src/backend/partitioning/partprune.c b/src/backend/partitioning/partprune.c
index fcf8d6032c..e76906da1f 100644
--- a/src/backend/partitioning/partprune.c
+++ b/src/backend/partitioning/partprune.c
@@ -44,6 +44,7 @@
 #include "miscadmin.h"
 #include "nodes/makefuncs.h"
 #include "nodes/nodeFuncs.h"
+#include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
diff --git a/src/include/optimizer/append.h b/src/include/optimizer/append.h
new file mode 100644
index 0000000000..b5f025c137
--- /dev/null
+++ b/src/include/optimizer/append.h
@@ -0,0 +1,25 @@
+/*-------------------------------------------------------------------------
+ *
+ * append.h
+ *	  prototypes for append.c.
+ *
+ *
+ * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/optimizer/append.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef APPEND_H
+#define APPEND_H
+
+#include "nodes/relation.h"
+
+/*
+ * append.c
+ *	  utilities for dealing with append relations
+ */
+extern void expand_inherited_tables(PlannerInfo *root);
+
+#endif							/* APPEND_H */
diff --git a/src/include/optimizer/appendinfo.h b/src/include/optimizer/appendinfo.h
new file mode 100644
index 0000000000..e205e78e6d
--- /dev/null
+++ b/src/include/optimizer/appendinfo.h
@@ -0,0 +1,43 @@
+/*-------------------------------------------------------------------------
+ *
+ * appendinfo.h
+ *	  Routines for mapping expressions between append rel parent(s) and
+ *	  children
+ *
+ * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/optimizer/appendinfo.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef APPENDINFO_H
+#define APPENDINFO_H
+
+#include "nodes/plannodes.h"
+#include "nodes/relation.h"
+#include "utils/relcache.h"
+
+extern AppendRelInfo *make_append_rel_info(RelOptInfo *parentrel,
+					 RangeTblEntry *parentrte,
+					 TupleDesc childdesc, Oid childoid, Oid childreltype,
+					 Index childRTindex);
+extern Bitmapset *translate_col_privs(const Bitmapset *parent_privs,
+					List *translated_vars);
+extern Node *adjust_appendrel_attrs(PlannerInfo *root, Node *node,
+					   int nappinfos, AppendRelInfo **appinfos);
+
+extern Node *adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node,
+								  Relids child_relids,
+								  Relids top_parent_relids);
+
+extern AppendRelInfo **find_appinfos_by_relids(PlannerInfo *root,
+						Relids relids, int *nappinfos);
+
+extern SpecialJoinInfo *build_child_join_sjinfo(PlannerInfo *root,
+						SpecialJoinInfo *parent_sjinfo,
+						Relids left_relids, Relids right_relids);
+extern Relids adjust_child_relids_multilevel(PlannerInfo *root, Relids relids,
+							   Relids child_relids, Relids top_parent_relids);
+
+#endif							/* APPENDINFO_H */
diff --git a/src/include/optimizer/prep.h b/src/include/optimizer/prep.h
index faae07d240..3ad9b4a77e 100644
--- a/src/include/optimizer/prep.h
+++ b/src/include/optimizer/prep.h
@@ -48,24 +48,5 @@ extern PlanRowMark *get_plan_rowmark(List *rowmarks, Index rtindex);
  */
 extern RelOptInfo *plan_set_operations(PlannerInfo *root);
 
-extern void expand_inherited_tables(PlannerInfo *root);
 
-extern Node *adjust_appendrel_attrs(PlannerInfo *root, Node *node,
-					   int nappinfos, AppendRelInfo **appinfos);
-extern AppendRelInfo *make_append_rel_info(RelOptInfo *parentrel,
-					 RangeTblEntry *parentrte,
-					 TupleDesc childdesc, Oid childoid, Oid childreltype,
-					 Index childRTindex);
-extern Node *adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node,
-								  Relids child_relids,
-								  Relids top_parent_relids);
-
-extern AppendRelInfo **find_appinfos_by_relids(PlannerInfo *root,
-						Relids relids, int *nappinfos);
-
-extern SpecialJoinInfo *build_child_join_sjinfo(PlannerInfo *root,
-						SpecialJoinInfo *parent_sjinfo,
-						Relids left_relids, Relids right_relids);
-extern Relids adjust_child_relids_multilevel(PlannerInfo *root, Relids relids,
-							   Relids child_relids, Relids top_parent_relids);
 #endif							/* PREP_H */
-- 
2.11.0

From 878c3f75b38a2f89281a96beed37f1e4e1ea5f69 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Mon, 15 Oct 2018 10:59:24 +0900
Subject: [PATCH v9 5/6] Teach planner to only process unpruned partitions

This adds a bitmapset field live_parts to RelOptInfo and stores
the partition indexes of non-dummy partitions in it, meaning it
contains indexes of only those partitions that have a non-NULL
RelOptInfo present in its parent's RelOptInfo's part_rels array.

This speeds up processing partitioned table's partitions compared
to going through the whole part_rels array in a number of places.
---
 src/backend/optimizer/path/joinrels.c |  3 +++
 src/backend/optimizer/plan/planner.c  | 18 +++++++++---------
 src/backend/optimizer/util/append.c   |  1 +
 src/backend/optimizer/util/relnode.c  |  3 +++
 src/backend/partitioning/partprune.c  | 18 +++++-------------
 src/include/nodes/relation.h          |  4 ++++
 6 files changed, 25 insertions(+), 22 deletions(-)

diff --git a/src/backend/optimizer/path/joinrels.c b/src/backend/optimizer/path/joinrels.c
index 6e321ec9e7..76531a05cf 100644
--- a/src/backend/optimizer/path/joinrels.c
+++ b/src/backend/optimizer/path/joinrels.c
@@ -1424,6 +1424,9 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
 		populate_joinrel_with_paths(root, child_rel1, child_rel2,
 									child_joinrel, child_sjinfo,
 									child_restrictlist);
+		if (!IS_DUMMY_REL(child_joinrel))
+			joinrel->live_parts = bms_add_member(joinrel->live_parts,
+												 cnt_parts);
 	}
 }
 
diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index 62ad5eb5c2..42f8a92240 100644
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -6757,7 +6757,9 @@ apply_scanjoin_target_to_paths(PlannerInfo *root,
 		List	   *live_children = NIL;
 
 		/* Adjust each partition. */
-		for (partition_idx = 0; partition_idx < rel->nparts; partition_idx++)
+		partition_idx = -1;
+		while ((partition_idx = bms_next_member(rel->live_parts,
+												partition_idx)) >= 0)
 		{
 			RelOptInfo *child_rel = rel->part_rels[partition_idx];
 			ListCell   *lc;
@@ -6765,9 +6767,7 @@ apply_scanjoin_target_to_paths(PlannerInfo *root,
 			int			nappinfos;
 			List	   *child_scanjoin_targets = NIL;
 
-			/* Skip processing pruned partitions. */
-			if (child_rel == NULL)
-				continue;
+			Assert(child_rel != NULL);
 
 			/* Translate scan/join targets for this child. */
 			appinfos = find_appinfos_by_relids(root, child_rel->relids,
@@ -6848,7 +6848,6 @@ create_partitionwise_grouping_paths(PlannerInfo *root,
 									PartitionwiseAggregateType patype,
 									GroupPathExtraData *extra)
 {
-	int			nparts = input_rel->nparts;
 	int			cnt_parts;
 	List	   *grouped_live_children = NIL;
 	List	   *partially_grouped_live_children = NIL;
@@ -6860,7 +6859,9 @@ create_partitionwise_grouping_paths(PlannerInfo *root,
 		   partially_grouped_rel != NULL);
 
 	/* Add paths for partitionwise aggregation/grouping. */
-	for (cnt_parts = 0; cnt_parts < nparts; cnt_parts++)
+	cnt_parts = -1;
+	while ((cnt_parts = bms_next_member(input_rel->live_parts,
+										cnt_parts)) >= 0)
 	{
 		RelOptInfo *child_input_rel = input_rel->part_rels[cnt_parts];
 		PathTarget *child_target = copy_pathtarget(target);
@@ -6870,9 +6871,8 @@ create_partitionwise_grouping_paths(PlannerInfo *root,
 		RelOptInfo *child_grouped_rel;
 		RelOptInfo *child_partially_grouped_rel;
 
-		/* Skip processing pruned partitions. */
-		if (child_input_rel == NULL)
-			continue;
+		/* A live partition must have a RelOptInfo. */
+		Assert(child_input_rel != NULL);
 
 		/* Input child rel must have a path */
 		Assert(child_input_rel->pathlist != NIL);
diff --git a/src/backend/optimizer/util/append.c b/src/backend/optimizer/util/append.c
index e78a61d613..7227eed4c4 100644
--- a/src/backend/optimizer/util/append.c
+++ b/src/backend/optimizer/util/append.c
@@ -350,6 +350,7 @@ expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
 
 	/* Perform pruning. */
 	partindexes = prune_append_rel_partitions(parentrel);
+	parentrel->live_parts = partindexes;
 
 	/* Must expand PlannerInfo arrays before we can add children. */
 	expand_planner_arrays(root, bms_num_members(partindexes));
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index 52a11f434f..6c7eafe6db 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -1748,6 +1748,9 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
 		joinrel->partexprs[cnt] = partexpr;
 		joinrel->nullable_partexprs[cnt] = nullable_partexpr;
 	}
+
+	/* Partitions will be added by try_partitionwise_join. */
+	joinrel->live_parts = NULL;
 }
 
 /*
diff --git a/src/backend/partitioning/partprune.c b/src/backend/partitioning/partprune.c
index e76906da1f..8bc2f5c5c2 100644
--- a/src/backend/partitioning/partprune.c
+++ b/src/backend/partitioning/partprune.c
@@ -441,29 +441,21 @@ make_partitionedrel_pruneinfo(PlannerInfo *root, RelOptInfo *parentrel,
 		memset(subplan_map, -1, nparts * sizeof(int));
 		subpart_map = (int *) palloc(nparts * sizeof(int));
 		memset(subpart_map, -1, nparts * sizeof(int));
-		present_parts = NULL;
+		present_parts = bms_copy(subpart->live_parts);
 
-		for (i = 0; i < nparts; i++)
+		i = -1;
+		while ((i = bms_next_member(present_parts, i)) >= 0)
 		{
 			RelOptInfo *partrel = subpart->part_rels[i];
 			int			subplanidx;
 			int			subpartidx;
 
-			/* Skip processing pruned partitions. */
-			if (partrel == NULL)
-				continue;
-
+			Assert(partrel != NULL);
 			subplan_map[i] = subplanidx = relid_subplan_map[partrel->relid] - 1;
 			subpart_map[i] = subpartidx = relid_subpart_map[partrel->relid] - 1;
+			/* Record finding this subplan */
 			if (subplanidx >= 0)
-			{
-				present_parts = bms_add_member(present_parts, i);
-
-				/* Record finding this subplan  */
 				subplansfound = bms_add_member(subplansfound, subplanidx);
-			}
-			else if (subpartidx >= 0)
-				present_parts = bms_add_member(present_parts, i);
 		}
 
 		pinfo = makeNode(PartitionedRelPruneInfo);
diff --git a/src/include/nodes/relation.h b/src/include/nodes/relation.h
index e6fdbcd030..ff9a3fde86 100644
--- a/src/include/nodes/relation.h
+++ b/src/include/nodes/relation.h
@@ -727,6 +727,10 @@ typedef struct RelOptInfo
 	Oid		   *part_oids;		/* partition OIDs */
 	struct RelOptInfo **part_rels;	/* Array of RelOptInfos of partitions,
 									 * stored in the same order of bounds */
+	Bitmapset  *live_parts;		/* Indexes into part_rels of the non-NULL
+								 * RelOptInfos of unpruned partitions; exists
+								 * to avoid having to iterate over the entire
+								 * part_rels array to filter NULL entries. */
 	List	  **partexprs;		/* Non-nullable partition key expressions. */
 	List	  **nullable_partexprs; /* Nullable partition key expressions. */
 	List	   *partitioned_child_rels; /* List of RT indexes. */
-- 
2.11.0

From e1f37f4c5c1ec7fcf1d91f47fd615d4ea61a2a46 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Fri, 12 Oct 2018 19:12:53 +0900
Subject: [PATCH v9 6/6] Do not lock all partitions at the beginning

---
 src/backend/optimizer/util/append.c | 11 +----------
 1 file changed, 1 insertion(+), 10 deletions(-)

diff --git a/src/backend/optimizer/util/append.c b/src/backend/optimizer/util/append.c
index 7227eed4c4..9b3fc41a1e 100644
--- a/src/backend/optimizer/util/append.c
+++ b/src/backend/optimizer/util/append.c
@@ -317,10 +317,6 @@ expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti,
  *
  * Partitions are added to the query in order in which they are found in
  * the parent's PartitionDesc.
- *
- * Note: even though only the unpruned partitions will be added to the
- * resulting plan, this still locks *all* partitions via find_all_inheritors
- * when this function is called for the root partitioned table.
  */
 static void
 expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
@@ -334,10 +330,6 @@ expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
 									parentrel->inh_root_parent :
 									parentRTindex;
 
-	/* If root partitioned table, lock *all* partitions in the tree. */
-	if (parentRTindex == rootParentRTindex)
-		(void) find_all_inheritors(parentrte->relid, lockmode, NULL);
-
 	/*
 	 * Initialize partitioned_child_rels to contain this RT index.
 	 *
@@ -373,8 +365,7 @@ expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
 		RangeTblEntry *childrte;
 		Index		childRTindex;
 
-		/* Already locked above. */
-		newrelation = heap_open(childOID, NoLock);
+		newrelation = heap_open(childOID, lockmode);
 		Assert(!RELATION_IS_OTHER_TEMP(newrelation));
 
 		/*
-- 
2.11.0

diff --git a/src/backend/optimizer/path/allpaths.c b/src/backend/optimizer/path/allpaths.c
index 12bb61f..0222485 100644
--- a/src/backend/optimizer/path/allpaths.c
+++ b/src/backend/optimizer/path/allpaths.c
@@ -1018,6 +1018,8 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 		ListCell   *parentvars;
 		ListCell   *childvars;
 		PlannerInfo *subroot = root;
+		bool		child_is_target =
+					   (appinfo->parent_relid == root->parse->resultRelation);
 
 		/* append_rel_list contains all append rels; ignore others */
 		if (appinfo->parent_relid != parentRTindex)
@@ -1071,7 +1073,7 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 		 * child relation that will be suitable to use the child also as the
 		 * target relation.
 		 */
-		if (appinfo->parent_relid == root->parse->resultRelation)
+		if (child_is_target)
 			subroot = adjust_inherit_target_child(root, childrel, appinfo);
 
 		/*
@@ -1087,7 +1089,7 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 		 */
 		if (rel->has_eclass_joins || has_useful_pathkeys(root, rel))
 			add_child_rel_equivalences(subroot, appinfo, rel, childrel,
-									   root != subroot);
+									   child_is_target);
 		childrel->has_eclass_joins = rel->has_eclass_joins;
 
 		/* CE failed, so finish copying/modifying join quals. */
@@ -1139,7 +1141,7 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 		 * If we modified subroot for the target inheritance case, add it
 		 * to root->inh_target_child_roots.
 		 */
-		if (subroot != root)
+		if (child_is_target)
 		{
 			root->inh_target_child_roots =
 							lappend(root->inh_target_child_roots, subroot);

From 96827948f257e4221997b84d4087804b4e5e34e2 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Wed, 17 Oct 2018 11:18:12 +0900
Subject: [PATCH v10 1/6] Overhaul inheritance update/delete planning

With the current method, inheritance_planner, which handles the
planning for update/delete commands targeting inheritance trees,
performs the *whole* planning for each child table.  That involves
translating the query tree to set a given child table in place of
the original inheritance root table as the query's target table,
followed by calling grouping_planner on the translated query, which
performs query planning and additional steps needed to apply correct
target list based on the child target table.

That's inefficient for two reasons:

 1. partprune.c cannot be used to perform partition pruning, because
    it can only be invoked from query_planner.  With the current
    approach, query_planner only sees the individual partitions in
    the query tree it receives, not the parent partitioned table.
    This leaves each partition to be pruned using constraint
    exclusion.  (constraint exclusion cannon prune hash partitions
    which means UPDATE/DELETE don't support hash partition pruning.)

 2. Repeated invocation of query_planner results in allocating large
    amounts of memory, especially if there are many child tables.
    Also, it involves repeatedly performing the same processing,
    such as jointree processing.

This commit addresses both of the issues by rewriting portions of
inheritance_planner and adding some supporting functionality to
allpath.c.

With the new implementation, inheritance_planner calls query_planner
only once at the beginning with the original unmodified query, which
creates the access paths of individual relations after pruning any
unnecessary partitions.  For each target child relation, it also
creates a sub-PartitionInfo containing translated version of the
query and a targetlist suitable for the child.  Child PlannerInfos
are saved in the top PlannerInfo for using later.  If the query
involves join against the target relation, join paths are created
for each target child relation by  replacing the original target
table in the join tree by a given child table.  Join relations
(RelOptInfos thereof) for all target child relations are collected
in a global list in the top PlannerInfo.

After creating the join paths for all target child relations,
inheritance_planner calls grouping_planner() on each child join
relation using the previously created child PlannerInfo to finish up
the paths such that they produce query's top-level target list
expanded according to a given child relation's descriptor.
grouping_planner()'s interface is modified so that we can pass it
what's called a 'planned_rel', a RelOptInfo that already contains
the necessary paths needed to produce its output.

This removes some existing code in inheritance_planner that dealt
with any subquery RTEs in the query.  The rationale of that code
was that the subquery RTEs may change during each iteration of
planning (that is, for different children), so different iterations
better use different copies of those RTEs.  That was handled by
making fresh copies of those RTEs for each iteration of planning
which were appended to the range table, accompanied by modifying all
expressions and auxiliary structures that referenced the original
subquery RTEs to instead reference the copies (that is, change the
varnos).  This copying meant we would end up adding S * N new entries
to the original range table by the time we got to the last unpruned
child, where S is the number of subquery RTEs in the original query
and N the number of unpruned children.  Since with the new code
we perform planning just once, I think we don't need this special
handling.  Actually, there is a regression test output change due
to no longer having copies of subquery RTEs (see the diff of
partition_join.out file.)

Also we no longer need the hack in relation_excluded_by_constraints()
involving setting PlannerInfo.inhTargetKind to enable constraint
exclusion for target child relation, which is no longer needed.
Constraint exclusion now runs during query_planner step described
above.

Regression test output change in partition_join.out is due to the fact
that we no longer create duplicates of subquery RTEs in child range
tables.
---
 doc/src/sgml/ddl.sgml                        |  14 +-
 src/backend/nodes/outfuncs.c                 |   1 -
 src/backend/optimizer/path/allpaths.c        | 602 +++++++++++++++++++++++++--
 src/backend/optimizer/path/equivclass.c      |  27 +-
 src/backend/optimizer/plan/createplan.c      |  10 -
 src/backend/optimizer/plan/planmain.c        | 166 +++++++-
 src/backend/optimizer/plan/planner.c         | 434 +++++--------------
 src/backend/optimizer/prep/prepjointree.c    |   1 -
 src/backend/optimizer/prep/prepunion.c       |  33 +-
 src/backend/optimizer/util/plancat.c         |  50 +--
 src/include/nodes/relation.h                 |  34 +-
 src/include/optimizer/paths.h                |   3 +-
 src/test/regress/expected/partition_join.out |   4 +-
 13 files changed, 937 insertions(+), 442 deletions(-)

diff --git a/doc/src/sgml/ddl.sgml b/doc/src/sgml/ddl.sgml
index 85e4358988..0333f673b3 100644
--- a/doc/src/sgml/ddl.sgml
+++ b/doc/src/sgml/ddl.sgml
@@ -4439,15 +4439,6 @@ EXPLAIN SELECT count(*) FROM measurement WHERE logdate &gt;= DATE '2008-01-01';
 
    <note>
     <para>
-     Currently, pruning of partitions during the planning of an
-     <command>UPDATE</command> or <command>DELETE</command> command is
-     implemented using the constraint exclusion method (however, it is
-     controlled by the <literal>enable_partition_pruning</literal> rather than
-     <literal>constraint_exclusion</literal>) &mdash; see the following section
-     for details and caveats that apply.
-    </para>
-
-    <para>
      Execution-time partition pruning currently only occurs for the
      <literal>Append</literal> and <literal>MergeAppend</literal> node types.
      It is not yet implemented for the <literal>ModifyTable</literal> node
@@ -4470,9 +4461,8 @@ EXPLAIN SELECT count(*) FROM measurement WHERE logdate &gt;= DATE '2008-01-01';
 
    <para>
     <firstterm>Constraint exclusion</firstterm> is a query optimization
-    technique similar to partition pruning.  While it is primarily used
-    for partitioning implemented using the legacy inheritance method, it can be
-    used for other purposes, including with declarative partitioning.
+    technique similar to partition pruning.  It is primarily used
+    for partitioning implemented using the legacy inheritance method.
    </para>
 
    <para>
diff --git a/src/backend/nodes/outfuncs.c b/src/backend/nodes/outfuncs.c
index be6b4ca2f4..3c9db22507 100644
--- a/src/backend/nodes/outfuncs.c
+++ b/src/backend/nodes/outfuncs.c
@@ -2210,7 +2210,6 @@ _outPlannerInfo(StringInfo str, const PlannerInfo *node)
 	WRITE_FLOAT_FIELD(tuple_fraction, "%.4f");
 	WRITE_FLOAT_FIELD(limit_tuples, "%.0f");
 	WRITE_UINT_FIELD(qual_security_level);
-	WRITE_ENUM_FIELD(inhTargetKind, InheritanceKind);
 	WRITE_BOOL_FIELD(hasJoinRTEs);
 	WRITE_BOOL_FIELD(hasLateralRTEs);
 	WRITE_BOOL_FIELD(hasDeletedRTEs);
diff --git a/src/backend/optimizer/path/allpaths.c b/src/backend/optimizer/path/allpaths.c
index 738bb30848..3f3bfbd696 100644
--- a/src/backend/optimizer/path/allpaths.c
+++ b/src/backend/optimizer/path/allpaths.c
@@ -36,6 +36,7 @@
 #include "optimizer/pathnode.h"
 #include "optimizer/paths.h"
 #include "optimizer/plancat.h"
+#include "optimizer/planmain.h"
 #include "optimizer/planner.h"
 #include "optimizer/prep.h"
 #include "optimizer/restrictinfo.h"
@@ -91,8 +92,12 @@ static void set_foreign_size(PlannerInfo *root, RelOptInfo *rel,
 				 RangeTblEntry *rte);
 static void set_foreign_pathlist(PlannerInfo *root, RelOptInfo *rel,
 					 RangeTblEntry *rte);
+static void set_inherit_target_rel_sizes(PlannerInfo *root, RelOptInfo *rel,
+							 Index rti, RangeTblEntry *rte);
 static void set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 					Index rti, RangeTblEntry *rte);
+static void set_inherit_target_rel_pathlists(PlannerInfo *root,
+							 RelOptInfo *rel, Index rti, RangeTblEntry *rte);
 static void set_append_rel_pathlist(PlannerInfo *root, RelOptInfo *rel,
 						Index rti, RangeTblEntry *rte);
 static void generate_mergeappend_paths(PlannerInfo *root, RelOptInfo *rel,
@@ -119,6 +124,8 @@ static void set_namedtuplestore_pathlist(PlannerInfo *root, RelOptInfo *rel,
 static void set_worktable_pathlist(PlannerInfo *root, RelOptInfo *rel,
 					   RangeTblEntry *rte);
 static RelOptInfo *make_rel_from_joinlist(PlannerInfo *root, List *joinlist);
+static void inheritance_make_rel_from_joinlist(PlannerInfo *root,
+						List *joinlist);
 static bool subquery_is_pushdown_safe(Query *subquery, Query *topquery,
 						  pushdown_safety_info *safetyInfo);
 static bool recurse_pushdown_safe(Node *setOp, Query *topquery,
@@ -149,27 +156,6 @@ make_one_rel(PlannerInfo *root, List *joinlist)
 	Index		rti;
 	double		total_pages;
 
-	/*
-	 * Construct the all_baserels Relids set.
-	 */
-	root->all_baserels = NULL;
-	for (rti = 1; rti < root->simple_rel_array_size; rti++)
-	{
-		RelOptInfo *brel = root->simple_rel_array[rti];
-
-		/* there may be empty slots corresponding to non-baserel RTEs */
-		if (brel == NULL)
-			continue;
-
-		Assert(brel->relid == rti); /* sanity check on array */
-
-		/* ignore RTEs that are "other rels" */
-		if (brel->reloptkind != RELOPT_BASEREL)
-			continue;
-
-		root->all_baserels = bms_add_member(root->all_baserels, brel->relid);
-	}
-
 	/* Mark base rels as to whether we care about fast-start plans */
 	set_base_rel_consider_startup(root);
 
@@ -217,13 +203,34 @@ make_one_rel(PlannerInfo *root, List *joinlist)
 
 	/*
 	 * Generate access paths for the entire join tree.
+	 *
+	 * For UPDATE/DELETE on an inheritance parent, join paths should be
+	 * generated for each child result rel separately.
 	 */
-	rel = make_rel_from_joinlist(root, joinlist);
+	if (root->parse->resultRelation &&
+		root->simple_rte_array[root->parse->resultRelation]->inh)
+	{
+		inheritance_make_rel_from_joinlist(root, joinlist);
 
-	/*
-	 * The result should join all and only the query's base rels.
-	 */
-	Assert(bms_equal(rel->relids, root->all_baserels));
+		/*
+		 * Return the RelOptInfo of original target relation, although this
+		 * doesn't really contain the final path.  inheritance_planner
+		 * from where we got here will generate the final path, but it will
+		 * do so by iterative over child subroots, not through this
+		 * RelOptInfo.
+		 */
+		rel = find_base_rel(root, root->parse->resultRelation);
+	}
+	else
+	{
+		rel = make_rel_from_joinlist(root, joinlist);
+
+		/*
+		 * The result should join all and only the query's base rels.
+		 */
+		Assert(bms_equal(rel->relids, root->all_baserels));
+
+	}
 
 	return rel;
 }
@@ -373,8 +380,15 @@ set_rel_size(PlannerInfo *root, RelOptInfo *rel,
 	}
 	else if (rte->inh)
 	{
-		/* It's an "append relation", process accordingly */
-		set_append_rel_size(root, rel, rti, rte);
+		/*
+		 * If it's a target relation, set the sizes of children instead.
+		 * Otherwise, we'll append the outputs of children, so process it as
+		 * an "append relation".
+		 */
+		if (rti == root->parse->resultRelation)
+			set_inherit_target_rel_sizes(root, rel, rti, rte);
+		else
+			set_append_rel_size(root, rel, rti, rte);
 	}
 	else
 	{
@@ -458,14 +472,26 @@ static void
 set_rel_pathlist(PlannerInfo *root, RelOptInfo *rel,
 				 Index rti, RangeTblEntry *rte)
 {
+	bool	inherited_update = false;
+
 	if (IS_DUMMY_REL(rel))
 	{
 		/* We already proved the relation empty, so nothing more to do */
 	}
 	else if (rte->inh)
 	{
-		/* It's an "append relation", process accordingly */
-		set_append_rel_pathlist(root, rel, rti, rte);
+		/*
+		 * If it's a target relation, set the pathlists of children instead.
+		 * Otherwise, we'll append the outputs of children, so process it as
+		 * an "append relation".
+		 */
+		if (rti == root->parse->resultRelation)
+		{
+			inherited_update = true;
+			set_inherit_target_rel_pathlists(root, rel, rti, rte);
+		}
+		else
+			set_append_rel_pathlist(root, rel, rti, rte);
 	}
 	else
 	{
@@ -540,8 +566,12 @@ set_rel_pathlist(PlannerInfo *root, RelOptInfo *rel,
 	if (set_rel_pathlist_hook)
 		(*set_rel_pathlist_hook) (root, rel, rti, rte);
 
-	/* Now find the cheapest of the paths for this rel */
-	set_cheapest(rel);
+	/*
+	 * Now find the cheapest of the paths for this rel, unless it's an
+	 * inheritance parent and this is an update/delete operation.
+	 */
+	if (!inherited_update)
+		set_cheapest(rel);
 
 #ifdef OPTIMIZER_DEBUG
 	debug_print_rel(root, rel);
@@ -903,6 +933,321 @@ set_foreign_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
 }
 
 /*
+ * set_inherit_target_rel_sizes
+ *	  Set size estimates for the child target relations
+ *
+ * The passed-in rel represents the target relation of the query that is
+ * known to have inheritance children. This is very much like
+ * set_append_rel_size, except it doesn't set the size estimates for the
+ * passed-in rel itself, because we don't need to "append" the children
+ * in this case.
+ */
+static void
+set_inherit_target_rel_sizes(PlannerInfo *root, RelOptInfo *rel,
+							 Index rti, RangeTblEntry *rte)
+{
+	int			parentRTindex = rti;
+	ListCell   *l;
+	bool		has_live_children;
+	Relids		live_children = NULL;
+	bool		did_pruning = false;
+
+	/* Guard against stack overflow due to overly deep inheritance tree. */
+	check_stack_depth();
+
+	Assert(IS_SIMPLE_REL(rel));
+
+	/*
+	 * If the partitioned relation has any baserestrictinfo quals then we
+	 * attempt to use these quals to prune away partitions that cannot
+	 * possibly contain any tuples matching these quals.  In this case we'll
+	 * store the relids of all partitions which could possibly contain a
+	 * matching tuple, and skip anything else in the loop below.
+	 */
+	if (enable_partition_pruning &&
+		rte->relkind == RELKIND_PARTITIONED_TABLE &&
+		rel->baserestrictinfo != NIL)
+	{
+		live_children = prune_append_rel_partitions(rel);
+		did_pruning = true;
+	}
+
+	foreach(l, root->append_rel_list)
+	{
+		AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(l);
+		int			childRTindex;
+		RangeTblEntry *childRTE;
+		RelOptInfo *childrel;
+		List	   *childquals;
+		Index		cq_min_security;
+		bool		have_const_false_cq;
+		PlannerInfo *subroot;
+		ListCell   *lc;
+		List	   *translated_exprs,
+				   *child_target_exprs;
+
+		/* append_rel_list contains all append rels; ignore others */
+		if (appinfo->parent_relid != parentRTindex)
+			continue;
+
+		childRTindex = appinfo->child_relid;
+		childRTE = root->simple_rte_array[childRTindex];
+		subroot = root->inh_target_child_roots[childRTindex];
+
+		/*
+		 * The child rel's RelOptInfo was already created during
+		 * add_base_rels_to_query.
+		 */
+		childrel = find_base_rel(root, childRTindex);
+		Assert(childrel->reloptkind == RELOPT_OTHER_MEMBER_REL);
+
+		/*
+		 * We have to copy the parent's quals to the child, with appropriate
+		 * substitution of variables.  However, only the baserestrictinfo
+		 * quals are needed before we can check for constraint exclusion; so
+		 * do that first and then check to see if we can disregard this child.
+		 *
+		 * The child rel's targetlist might contain non-Var expressions, which
+		 * means that substitution into the quals could produce opportunities
+		 * for const-simplification, and perhaps even pseudoconstant quals.
+		 * Therefore, transform each RestrictInfo separately to see if it
+		 * reduces to a constant or pseudoconstant.  (We must process them
+		 * separately to keep track of the security level of each qual.)
+		 */
+		childquals = NIL;
+		cq_min_security = UINT_MAX;
+		have_const_false_cq = false;
+		foreach(lc, rel->baserestrictinfo)
+		{
+			RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
+			Node	   *childqual;
+			ListCell   *lc2;
+
+			Assert(IsA(rinfo, RestrictInfo));
+			childqual = adjust_appendrel_attrs(root,
+											   (Node *) rinfo->clause,
+											   1, &appinfo);
+			childqual = eval_const_expressions(root, childqual);
+			/* check for flat-out constant */
+			if (childqual && IsA(childqual, Const))
+			{
+				if (((Const *) childqual)->constisnull ||
+					!DatumGetBool(((Const *) childqual)->constvalue))
+				{
+					/* Restriction reduces to constant FALSE or NULL */
+					have_const_false_cq = true;
+					break;
+				}
+				/* Restriction reduces to constant TRUE, so drop it */
+				continue;
+			}
+			/* might have gotten an AND clause, if so flatten it */
+			foreach(lc2, make_ands_implicit((Expr *) childqual))
+			{
+				Node	   *onecq = (Node *) lfirst(lc2);
+				bool		pseudoconstant;
+
+				/* check for pseudoconstant (no Vars or volatile functions) */
+				pseudoconstant =
+					!contain_vars_of_level(onecq, 0) &&
+					!contain_volatile_functions(onecq);
+				if (pseudoconstant)
+				{
+					/* tell createplan.c to check for gating quals */
+					root->hasPseudoConstantQuals = true;
+				}
+				/* reconstitute RestrictInfo with appropriate properties */
+				childquals = lappend(childquals,
+									 make_restrictinfo((Expr *) onecq,
+													   rinfo->is_pushed_down,
+													   rinfo->outerjoin_delayed,
+													   pseudoconstant,
+													   rinfo->security_level,
+													   NULL, NULL, NULL));
+				/* track minimum security level among child quals */
+				cq_min_security = Min(cq_min_security, rinfo->security_level);
+			}
+		}
+
+		/*
+		 * In addition to the quals inherited from the parent, we might have
+		 * securityQuals associated with this particular child node.
+		 * (Currently this can only happen in appendrels originating from
+		 * UNION ALL; inheritance child tables don't have their own
+		 * securityQuals, see expand_inherited_rtentry().)	Pull any such
+		 * securityQuals up into the baserestrictinfo for the child.  This is
+		 * similar to process_security_barrier_quals() for the parent rel,
+		 * except that we can't make any general deductions from such quals,
+		 * since they don't hold for the whole appendrel.
+		 */
+		if (childRTE->securityQuals)
+		{
+			Index		security_level = 0;
+
+			foreach(lc, childRTE->securityQuals)
+			{
+				List	   *qualset = (List *) lfirst(lc);
+				ListCell   *lc2;
+
+				foreach(lc2, qualset)
+				{
+					Expr	   *qual = (Expr *) lfirst(lc2);
+
+					/* not likely that we'd see constants here, so no check */
+					childquals = lappend(childquals,
+										 make_restrictinfo(qual,
+														   true, false, false,
+														   security_level,
+														   NULL, NULL, NULL));
+					cq_min_security = Min(cq_min_security, security_level);
+				}
+				security_level++;
+			}
+			Assert(security_level <= root->qual_security_level);
+		}
+
+		/*
+		 * OK, we've got all the baserestrictinfo quals for this child.
+		 */
+		childrel->baserestrictinfo = childquals;
+		childrel->baserestrict_min_security = cq_min_security;
+
+		if (have_const_false_cq)
+		{
+			/*
+			 * Some restriction clause reduced to constant FALSE or NULL after
+			 * substitution, so this child need not be scanned.
+			 */
+			set_dummy_rel_pathlist(childrel);
+			continue;
+		}
+
+		if (did_pruning && !bms_is_member(appinfo->child_relid, live_children))
+		{
+			/* This partition was pruned; skip it. */
+			set_dummy_rel_pathlist(childrel);
+			continue;
+		}
+
+		if (relation_excluded_by_constraints(root, childrel, childRTE))
+		{
+			/*
+			 * This child need not be scanned, so we can omit it from the
+			 * appendrel.
+			 */
+			set_dummy_rel_pathlist(childrel);
+			continue;
+		}
+
+		/*
+		 * Add missing Vars to child's reltarget.
+		 *
+		 * add_inherit_target_child_root() would've added only those that are
+		 * needed to be present in the top-level tlist (or ones that
+		 * preprocess_targetlist thinks are needed to be in the tlist.)  We
+		 * may need other attributes such as those contained in WHERE clauses,
+		 * which are already computed for the parent during
+		 * deconstruct_jointree processing of the original query (child's
+		 * query never goes through deconstruct_jointree.)
+		 */
+		translated_exprs = (List *)
+			adjust_appendrel_attrs(root,
+								   (Node *) rel->reltarget->exprs,
+								   1, &appinfo);
+		child_target_exprs = childrel->reltarget->exprs;
+		foreach(lc, translated_exprs)
+		{
+			Expr *expr = lfirst(lc);
+
+			if (!list_member(child_target_exprs, expr))
+				child_target_exprs = lappend(child_target_exprs, expr);
+		}
+
+		/*
+		 * We have to make child entries in the EquivalenceClass data
+		 * structures as well.  This is needed either if the parent
+		 * participates in some eclass joins (because we will want to consider
+		 * inner-indexscan joins on the individual children) or if the parent
+		 * has useful pathkeys (because we should try to build MergeAppend
+		 * paths that produce those sort orderings). Even if this child is
+		 * deemed dummy, it may fall on nullable side in a child-join, which
+		 * in turn may participate in a MergeAppend, where we will need the
+		 * EquivalenceClass data structures.
+		 */
+		if (rel->has_eclass_joins || has_useful_pathkeys(root, rel))
+			add_child_rel_equivalences(subroot, appinfo, rel, childrel, true);
+		childrel->has_eclass_joins = rel->has_eclass_joins;
+
+		/* CE failed, so finish copying/modifying join quals. */
+		childrel->joininfo = (List *)
+			adjust_appendrel_attrs(subroot,
+								   (Node *) rel->joininfo,
+								   1, &appinfo);
+
+		/*
+		 * If parallelism is allowable for this query in general, see whether
+		 * it's allowable for this childrel in particular.  But if we've
+		 * already decided the appendrel is not parallel-safe as a whole,
+		 * there's no point in considering parallelism for this child.  For
+		 * consistency, do this before calling set_rel_size() for the child.
+		 */
+		if (root->glob->parallelModeOK && rel->consider_parallel)
+			set_rel_consider_parallel(subroot, childrel, childRTE);
+
+		/*
+		 * Compute the child's size using possibly modified subroot.
+		 */
+		set_rel_size(subroot, childrel, childRTindex, childRTE);
+
+		/*
+		 * It is possible that constraint exclusion detected a contradiction
+		 * within a child subquery, even though we didn't prove one above. If
+		 * so, we can skip this child.
+		 */
+		if (IS_DUMMY_REL(childrel))
+			continue;
+
+		/*
+		 * If any live child is not parallel-safe, treat the whole appendrel
+		 * as not parallel-safe.  In future we might be able to generate plans
+		 * in which some children are farmed out to workers while others are
+		 * not; but we don't have that today, so it's a waste to consider
+		 * partial paths anywhere in the appendrel unless it's all safe.
+		 * (Child rels visited before this one will be unmarked in
+		 * set_append_rel_pathlist().)
+		 */
+		if (!childrel->consider_parallel)
+			rel->consider_parallel = false;
+
+		/*
+		 * Accumulate size information from each live child.
+		 */
+		Assert(childrel->rows > 0);
+
+		/* We have at least one live child. */
+		has_live_children = true;
+	}
+
+	if (!has_live_children)
+	{
+		/*
+		 * All children were excluded by constraints, so mark the relation
+		 * ass dummy.  We must do this in this phase so that the rel's
+		 * dummy-ness is visible when we generate paths for other rels.
+		 */
+		set_dummy_rel_pathlist(rel);
+	}
+	else
+		/*
+		 * Set a non-zero value here to cope with the caller's requirement
+		 * that non-dummy relations are actually not empty.  We don't try to
+		 * be accurate here, because we're not going to create a path that
+		 * combines the children outputs.
+		 */
+		rel->rows = 1;
+}
+
+/*
  * set_append_rel_size
  *	  Set size estimates for a simple "append relation"
  *
@@ -1045,7 +1390,8 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 		 * EquivalenceClass data structures.
 		 */
 		if (rel->has_eclass_joins || has_useful_pathkeys(root, rel))
-			add_child_rel_equivalences(root, appinfo, rel, childrel);
+			add_child_rel_equivalences(root, appinfo, rel, childrel,
+									   false);
 		childrel->has_eclass_joins = rel->has_eclass_joins;
 
 		/*
@@ -1327,6 +1673,63 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 }
 
 /*
+ * set_inherit_target_rel_pathlists
+ *	  Build access paths for the child target relations
+ *
+ * Similar to set_append_rel_pathlist, except that we build paths of the
+ * children, but don't build an Append path.
+ */
+static void
+set_inherit_target_rel_pathlists(PlannerInfo *root, RelOptInfo *rel,
+								 Index rti, RangeTblEntry *rte)
+{
+	int			parentRTindex = rti;
+	ListCell   *l;
+
+	/* Nothing to do if all the children were excluded. */
+	if (IS_DUMMY_REL(rel))
+		return;
+
+	/* Generate access paths for each of the children of passed-in rel */
+	foreach(l, root->append_rel_list)
+	{
+		AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(l);
+		int			childRTindex;
+		RangeTblEntry *childRTE;
+		RelOptInfo *childrel;
+
+		/* append_rel_list contains all append rels; ignore others */
+		if (appinfo->parent_relid != parentRTindex)
+			continue;
+
+		/* Re-locate the child RTE and RelOptInfo */
+		childRTindex = appinfo->child_relid;
+		childRTE = root->simple_rte_array[childRTindex];
+		childrel = root->simple_rel_array[childRTindex];
+
+		/*
+		 * If set_append_rel_size() decided the parent appendrel was
+		 * parallel-unsafe at some point after visiting this child rel, we
+		 * need to propagate the unsafety marking down to the child, so that
+		 * we don't generate useless partial paths for it.
+		 */
+		if (!rel->consider_parallel)
+			childrel->consider_parallel = false;
+
+		/*
+		 * Compute the child's access paths.
+		 */
+		set_rel_pathlist(root, childrel, childRTindex, childRTE);
+
+		/*
+		 * If child is dummy, ignore it.
+		 */
+		if (IS_DUMMY_REL(childrel))
+			continue;
+	}
+}
+
+/*
  * set_append_rel_pathlist
  *	  Build access paths for an "append relation"
  */
@@ -2624,6 +3027,139 @@ generate_gather_paths(PlannerInfo *root, RelOptInfo *rel, bool override_rows)
 }
 
 /*
+ * inheritance_make_rel_from_joinlist
+ *		Perform join planning for all non-dummy leaf inheritance children
+ *		in their role as an UPDATE/DELETE query's target relation
+ *
+ * If a child relation is a partitioned table, its children are processed in
+ * turn by recursively calling this function.
+ */
+static void
+inheritance_make_rel_from_joinlist(PlannerInfo *root, List *joinlist)
+{
+	Index		resultRelation = root->parse->resultRelation;
+	ListCell   *lc;
+#ifdef USE_ASSERT_CHECKING
+	Relids	all_baserels;
+#endif
+
+	/*
+	 * For UPDATE/DELETE queries, the top parent can only ever be a table.
+	 * As a contrast, it could be a UNION ALL subquery in the case of SELECT.
+	 */
+	Assert(root->parse->commandType == CMD_UPDATE ||
+		   root->parse->commandType == CMD_DELETE);
+	Assert(planner_rt_fetch(resultRelation, root)->rtekind == RTE_RELATION);
+
+	/* Nothing to do. */
+	if (IS_DUMMY_REL(find_base_rel(root, resultRelation)))
+		return;
+
+	foreach(lc, root->append_rel_list)
+	{
+		AppendRelInfo *appinfo = lfirst(lc);
+		PlannerInfo *subroot;
+		RelOptInfo *childrel;
+		List	   *translated_joinlist;
+
+		if (appinfo->parent_relid != resultRelation)
+			continue;
+
+		subroot = root->inh_target_child_roots[appinfo->child_relid];
+		Assert(subroot->parse->resultRelation > 0);
+		childrel = find_base_rel(root, appinfo->child_relid);
+
+		/* Ignore excluded/pruned children. */
+		if (IS_DUMMY_REL(childrel))
+			continue;
+
+		root->inh_target_child_rels = lappend_int(root->inh_target_child_rels,
+												  appinfo->child_relid);
+
+		/*
+		 * Modify joinlist such that relations joined to the top parent rel
+		 * appear to be joined to the child rel instead.  Do the same for
+		 * any SpecialJoinInfo structs.
+		 */
+		translated_joinlist = (List *)
+						adjust_appendrel_attrs(subroot,
+											   (Node *) joinlist,
+											   1, &appinfo);
+		subroot->join_info_list = (List *)
+						adjust_appendrel_attrs(subroot,
+											   (Node *) root->join_info_list,
+											   1, &appinfo);
+
+		/*
+		 * Sub-partitioned tables have to be processed recursively using the
+		 * translated subroot as the parent, because AppendRelInfos link
+		 * sub-partitions to their immediate parents, not the root partitioned
+		 * table.
+		 */
+		if (childrel->part_scheme != NULL)
+		{
+			inheritance_make_rel_from_joinlist(subroot, translated_joinlist);
+
+			/*
+			 * Add this child relation as a placeholder in the parent root's
+			 * inh_target_child_joinrels so that inheritance_planner see same
+			 * number of entries as inh_target_child_rels.
+			 */
+			root->inh_target_child_joinrels =
+					lappend(root->inh_target_child_joinrels, childrel);
+
+			/* Also propagate this child's own children into parent's list. */
+			if (subroot->inh_target_child_rels != NIL)
+			{
+				root->inh_target_child_rels =
+					list_concat(root->inh_target_child_rels,
+								subroot->inh_target_child_rels);
+				root->inh_target_child_joinrels =
+					list_concat(root->inh_target_child_joinrels,
+								subroot->inh_target_child_joinrels);
+			}
+			continue;
+		}
+
+		/*
+		 * Since we added the child rel directly into the join tree, we must
+		 * modify it to be a "base" rel instead of an "other" rel, which the
+		 * join planning code expects the relations being joined to be.
+		 */
+		childrel->reloptkind = RELOPT_BASEREL;
+
+		Assert(subroot->join_rel_list == NIL);
+		Assert(subroot->join_rel_hash == NULL);
+
+		/* Perform join planning and save the resulting RelOptInfo. */
+		childrel = make_rel_from_joinlist(subroot, translated_joinlist);
+
+		/*
+		 * Remember this child target rel.  inheritance_planner will perform
+		 * the remaining steps of planning for each child relation separately.
+		 * Specifically, it will call grouping_planner on every
+		 * RelOptInfo contained in the inh_target_child_rels list, each of
+		 * which represents the source of tuples to be modified for a given
+		 * target child rel.
+		 */
+		root->inh_target_child_joinrels =
+						lappend(root->inh_target_child_joinrels, childrel);
+#ifdef USE_ASSERT_CHECKING
+		/*
+		 * The following implements essentially the same Assert as in
+		 * make_one_rel, our caller.
+		 */
+		all_baserels = bms_copy(root->all_baserels);
+		all_baserels = bms_del_member(all_baserels,
+									  root->parse->resultRelation);
+		all_baserels = bms_add_member(all_baserels,
+									  subroot->parse->resultRelation);
+		Assert(bms_equal(childrel->relids, all_baserels));
+#endif
+	}
+}
+
+/*
  * make_rel_from_joinlist
  *	  Build access paths using a "joinlist" to guide the join path search.
  *
diff --git a/src/backend/optimizer/path/equivclass.c b/src/backend/optimizer/path/equivclass.c
index b22b36ec0e..029665b974 100644
--- a/src/backend/optimizer/path/equivclass.c
+++ b/src/backend/optimizer/path/equivclass.c
@@ -2104,12 +2104,18 @@ match_eclasses_to_foreign_key_col(PlannerInfo *root,
  *
  * parent_rel and child_rel could be derived from appinfo, but since the
  * caller has already computed them, we might as well just pass them in.
+ *
+ * If 'child_is_target' is true then the child EC members *replace* the
+ * corresponding parent members.  In that case, 'root' is the child target
+ * relation's dedicated PlannerInfo so it makes sense to remove the parent
+ * ECs altogether, because they're of no use.
  */
 void
 add_child_rel_equivalences(PlannerInfo *root,
 						   AppendRelInfo *appinfo,
 						   RelOptInfo *parent_rel,
-						   RelOptInfo *child_rel)
+						   RelOptInfo *child_rel,
+						   bool child_is_target)
 {
 	ListCell   *lc1;
 
@@ -2117,6 +2123,8 @@ add_child_rel_equivalences(PlannerInfo *root,
 	{
 		EquivalenceClass *cur_ec = (EquivalenceClass *) lfirst(lc1);
 		ListCell   *lc2;
+		ListCell   *prev;
+		ListCell   *next;
 
 		/*
 		 * If this EC contains a volatile expression, then generating child
@@ -2134,12 +2142,18 @@ add_child_rel_equivalences(PlannerInfo *root,
 			!bms_is_subset(parent_rel->relids, cur_ec->ec_relids))
 			continue;
 
-		foreach(lc2, cur_ec->ec_members)
+		prev = NULL;
+		for (lc2 = list_head(cur_ec->ec_members); lc2 != NULL; lc2 = next)
 		{
 			EquivalenceMember *cur_em = (EquivalenceMember *) lfirst(lc2);
 
+			next = lnext(lc2);
+
 			if (cur_em->em_is_const)
+			{
+				prev = lc2;
 				continue;		/* ignore consts here */
+			}
 
 			/* Does it reference parent_rel? */
 			if (bms_overlap(cur_em->em_relids, parent_rel->relids))
@@ -2177,10 +2191,17 @@ add_child_rel_equivalences(PlannerInfo *root,
 														  child_rel->relids);
 				}
 
+				/* Delete the parent EC member. */
+				if (child_is_target)
+					cur_ec->ec_members = list_delete_cell(cur_ec->ec_members,
+														  lc2, prev);
+
 				(void) add_eq_member(cur_ec, child_expr,
 									 new_relids, new_nullable_relids,
-									 true, cur_em->em_datatype);
+									 !child_is_target, cur_em->em_datatype);
 			}
+			else
+				prev = lc2;
 		}
 	}
 }
diff --git a/src/backend/optimizer/plan/createplan.c b/src/backend/optimizer/plan/createplan.c
index 91cf78233d..a6c0e5c6a4 100644
--- a/src/backend/optimizer/plan/createplan.c
+++ b/src/backend/optimizer/plan/createplan.c
@@ -2022,12 +2022,7 @@ create_groupingsets_plan(PlannerInfo *root, GroupingSetsPath *best_path)
 	/*
 	 * During setrefs.c, we'll need the grouping_map to fix up the cols lists
 	 * in GroupingFunc nodes.  Save it for setrefs.c to use.
-	 *
-	 * This doesn't work if we're in an inheritance subtree (see notes in
-	 * create_modifytable_plan).  Fortunately we can't be because there would
-	 * never be grouping in an UPDATE/DELETE; but let's Assert that.
 	 */
-	Assert(root->inhTargetKind == INHKIND_NONE);
 	Assert(root->grouping_map == NULL);
 	root->grouping_map = grouping_map;
 
@@ -2184,12 +2179,7 @@ create_minmaxagg_plan(PlannerInfo *root, MinMaxAggPath *best_path)
 	 * with InitPlan output params.  (We can't just do that locally in the
 	 * MinMaxAgg node, because path nodes above here may have Agg references
 	 * as well.)  Save the mmaggregates list to tell setrefs.c to do that.
-	 *
-	 * This doesn't work if we're in an inheritance subtree (see notes in
-	 * create_modifytable_plan).  Fortunately we can't be because there would
-	 * never be aggregates in an UPDATE/DELETE; but let's Assert that.
 	 */
-	Assert(root->inhTargetKind == INHKIND_NONE);
 	Assert(root->minmax_aggs == NIL);
 	root->minmax_aggs = best_path->mmaggregates;
 
diff --git a/src/backend/optimizer/plan/planmain.c b/src/backend/optimizer/plan/planmain.c
index 9b6cc9e10f..c2d2d12a4c 100644
--- a/src/backend/optimizer/plan/planmain.c
+++ b/src/backend/optimizer/plan/planmain.c
@@ -26,7 +26,11 @@
 #include "optimizer/paths.h"
 #include "optimizer/placeholder.h"
 #include "optimizer/planmain.h"
+#include "optimizer/prep.h"
 
+static void add_inherited_target_child_roots(PlannerInfo *root);
+static PlannerInfo *adjust_inherited_target_child_root(PlannerInfo *root,
+									AppendRelInfo *appinfo);
 
 /*
  * query_planner
@@ -57,6 +61,8 @@ query_planner(PlannerInfo *root, List *tlist,
 	Query	   *parse = root->parse;
 	List	   *joinlist;
 	RelOptInfo *final_rel;
+	bool		inherited_update;
+	Index		rti;
 
 	/*
 	 * If the query has an empty join tree, then it's something easy like
@@ -230,14 +236,168 @@ query_planner(PlannerInfo *root, List *tlist,
 	extract_restriction_or_clauses(root);
 
 	/*
+	 * Construct the all_baserels Relids set.
+	 */
+	root->all_baserels = NULL;
+	for (rti = 1; rti < root->simple_rel_array_size; rti++)
+	{
+		RelOptInfo *brel = root->simple_rel_array[rti];
+
+		/* there may be empty slots corresponding to non-baserel RTEs */
+		if (brel == NULL)
+			continue;
+
+		Assert(brel->relid == rti); /* sanity check on array */
+
+		/* ignore RTEs that are "other rels" */
+		if (brel->reloptkind != RELOPT_BASEREL)
+			continue;
+
+		root->all_baserels = bms_add_member(root->all_baserels, brel->relid);
+	}
+
+	inherited_update = (parse->resultRelation &&
+						root->simple_rte_array[parse->resultRelation]->inh);
+
+	/*
+	 * Add child subroots needed to use during planning for individual child
+	 * targets
+	 */
+	if (inherited_update)
+	{
+		root->inh_target_child_roots = (PlannerInfo **)
+										palloc0(root->simple_rel_array_size *
+												sizeof(PlannerInfo *));
+		add_inherited_target_child_roots(root);
+	}
+
+	/*
 	 * Ready to do the primary planning.
 	 */
 	final_rel = make_one_rel(root, joinlist);
 
-	/* Check that we got at least one usable path */
-	if (!final_rel || !final_rel->cheapest_total_path ||
-		final_rel->cheapest_total_path->param_info != NULL)
+	/*
+	 * Check that we got at least one usable path.  In the case of an
+	 * inherited update/delete operation, no path has been created for
+	 * the query's actual target relation yet.
+	 */
+	if (!inherited_update &&
+		(!final_rel ||
+		 !final_rel->cheapest_total_path ||
+		 final_rel->cheapest_total_path->param_info != NULL))
 		elog(ERROR, "failed to construct the join relation");
 
 	return final_rel;
 }
+
+/*
+ * add_inherited_target_child_roots
+ *		Add PlannerInfos for inheritance target children
+ */
+static void
+add_inherited_target_child_roots(PlannerInfo *root)
+{
+	Index		resultRelation = root->parse->resultRelation;
+	ListCell   *lc;
+
+	Assert(root->inh_target_child_roots != NULL);
+
+	foreach(lc, root->append_rel_list)
+	{
+		AppendRelInfo *appinfo = lfirst(lc);
+		RangeTblEntry *childRTE;
+		PlannerInfo   *subroot;
+
+		if (appinfo->parent_relid != resultRelation)
+			continue;
+
+		childRTE = root->simple_rte_array[appinfo->child_relid];
+		subroot = adjust_inherited_target_child_root(root, appinfo);
+
+		if (childRTE->inh)
+			add_inherited_target_child_roots(subroot);
+
+		root->inh_target_child_roots[appinfo->child_relid] = subroot;
+	}
+}
+
+/*
+ * add_inherit_target_child_root
+ *		This translates query to match the child given by appinfo and
+ *		puts it in a PlannerInfo that will be used for planning the child
+ *
+ * The child PlannerInfo reuses most of the parent PlannerInfo's fields
+ * unchanged, except unexpanded_tlist and processed_tlist are based on the
+ * child relation.
+ */
+static PlannerInfo *
+adjust_inherited_target_child_root(PlannerInfo *root, AppendRelInfo *appinfo)
+{
+	PlannerInfo *subroot;
+	List	   *tlist;
+	ListCell   *lc;
+
+	Assert(root->parse->commandType == CMD_UPDATE ||
+		   root->parse->commandType == CMD_DELETE);
+
+	/* Translate the original query's expressions to this child. */
+	subroot = makeNode(PlannerInfo);
+	memcpy(subroot, root, sizeof(PlannerInfo));
+
+	/*
+	 * Restore the unexpanded tlist for translation, so that child's
+	 * query contains targetList numbered (resnos) per its own
+	 * TupleDesc, which adjust_inherited_tlist ensures.
+	 */
+	root->parse->targetList = root->unexpanded_tlist;
+	subroot->parse = (Query *) adjust_appendrel_attrs(root,
+													  (Node *) root->parse,
+													  1, &appinfo);
+
+	/*
+	 * Save the original unexpanded targetlist in child subroot, just as
+	 * we did for the parent root, so that this child's own children can use
+	 * it.  Must use copy because subroot->parse->targetList will be modified
+	 * soon.
+	 */
+	subroot->unexpanded_tlist = list_copy(subroot->parse->targetList);
+
+	/*
+	 * Apply planner's expansion of targetlist, such as adding various junk
+	 * column, filling placeholder entries for dropped columns, etc., all of
+	 * which occurs with the child's TupleDesc.
+	 */
+	tlist = preprocess_targetlist(subroot);
+	subroot->processed_tlist = tlist;
+
+	/* Add any newly added Vars to the child RelOptInfo. */
+	build_base_rel_tlists(subroot, tlist);
+
+	/*
+	 * Adjust all_baserels to replace the original target relation with the
+	 * child target relation.  Copy it before modifying though.
+	 */
+	subroot->all_baserels = bms_copy(root->all_baserels);
+	subroot->all_baserels = bms_del_member(subroot->all_baserels,
+										   root->parse->resultRelation);
+	subroot->all_baserels = bms_add_member(subroot->all_baserels,
+										   subroot->parse->resultRelation);
+
+	/*
+	 * Child root should get its own copy of ECs, because they'll be modified
+	 * to replace parent EC expressions by child expressions in
+	 * add_child_rel_equivalences.
+	 */
+	subroot->eq_classes = NIL;
+	foreach(lc, root->eq_classes)
+	{
+		EquivalenceClass *ec = lfirst(lc);
+		EquivalenceClass *new_ec = makeNode(EquivalenceClass);
+
+		memcpy(new_ec, ec, sizeof(EquivalenceClass));
+		new_ec->ec_members = list_copy(ec->ec_members);
+		subroot->eq_classes = lappend(subroot->eq_classes, new_ec);
+	}
+
+	return subroot;
+}
diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index b645648559..6cff7262e8 100644
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -37,6 +37,7 @@
 #ifdef OPTIMIZER_DEBUG
 #include "nodes/print.h"
 #endif
+#include "nodes/relation.h"
 #include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
@@ -126,7 +127,7 @@ static Node *preprocess_expression(PlannerInfo *root, Node *expr, int kind);
 static void preprocess_qual_conditions(PlannerInfo *root, Node *jtnode);
 static void inheritance_planner(PlannerInfo *root);
 static void grouping_planner(PlannerInfo *root, bool inheritance_update,
-				 double tuple_fraction);
+				 RelOptInfo *planned_rel, double tuple_fraction);
 static grouping_sets_data *preprocess_grouping_sets(PlannerInfo *root);
 static List *remap_to_groupclause_idx(List *groupClause, List *gsets,
 						 int *tleref_to_colnum_map);
@@ -630,7 +631,6 @@ subquery_planner(PlannerGlobal *glob, Query *parse,
 	root->grouping_map = NULL;
 	root->minmax_aggs = NIL;
 	root->qual_security_level = 0;
-	root->inhTargetKind = INHKIND_NONE;
 	root->hasRecursion = hasRecursion;
 	if (hasRecursion)
 		root->wt_param_id = SS_assign_special_param(root);
@@ -970,7 +970,7 @@ subquery_planner(PlannerGlobal *glob, Query *parse,
 		rt_fetch(parse->resultRelation, parse->rtable)->inh)
 		inheritance_planner(root);
 	else
-		grouping_planner(root, false, tuple_fraction);
+		grouping_planner(root, false, NULL, tuple_fraction);
 
 	/*
 	 * Capture the set of outer-level param IDs we have access to, for use in
@@ -1146,12 +1146,19 @@ preprocess_phv_expression(PlannerInfo *root, Expr *expr)
  *	  inheritance set.
  *
  * We have to handle this case differently from cases where a source relation
- * is an inheritance set. Source inheritance is expanded at the bottom of the
- * plan tree (see allpaths.c), but target inheritance has to be expanded at
- * the top.  The reason is that for UPDATE, each target relation needs a
- * different targetlist matching its own column set.  Fortunately,
- * the UPDATE/DELETE target can never be the nullable side of an outer join,
- * so it's OK to generate the plan this way.
+ * is an inheritance set.  That's mainly because for UPDATE, each target
+ * relation needs a different targetlist matching its own column set.  So, we
+ * must modify the source scan/join path for each target relation such that it
+ * produces the desired target list.
+ *
+ * The source scan/join paths for individual target relations are still
+ * created in allpaths.c by first expanding the inheritance in the usual way
+ * by set_append_rel_size, followed by join planning for each target relation
+ * separately in make_one_rel.  Finally, we apply grouping_planner here to each
+ * child scan/join path so that it produces the desired targetlist.
+ *
+ * Fortunately, the UPDATE/DELETE target can never be the nullable side of an
+ * outer join, so it's OK to generate the plan this way.
  *
  * Returns nothing; the useful output is in the Paths we attach to
  * the (UPPERREL_FINAL, NULL) upperrel stored in *root.
@@ -1164,14 +1171,8 @@ inheritance_planner(PlannerInfo *root)
 {
 	Query	   *parse = root->parse;
 	int			top_parentRTindex = parse->resultRelation;
-	Bitmapset  *subqueryRTindexes;
-	Bitmapset  *modifiableARIindexes;
 	int			nominalRelation = -1;
 	Index		rootRelation = 0;
-	List	   *final_rtable = NIL;
-	int			save_rel_array_size = 0;
-	RelOptInfo **save_rel_array = NULL;
-	AppendRelInfo **save_append_rel_array = NULL;
 	List	   *subpaths = NIL;
 	List	   *subroots = NIL;
 	List	   *resultRelations = NIL;
@@ -1179,70 +1180,59 @@ inheritance_planner(PlannerInfo *root)
 	List	   *returningLists = NIL;
 	List	   *rowMarks;
 	RelOptInfo *final_rel;
-	ListCell   *lc;
-	Index		rti;
+	ListCell   *lc1,
+			   *lc2;
 	RangeTblEntry *parent_rte;
-	PlannerInfo *parent_root;
-	Query	   *parent_parse;
-	Bitmapset  *parent_relids = bms_make_singleton(top_parentRTindex);
-	PlannerInfo **parent_roots = NULL;
+	List	   *tlist;
+	standard_qp_extra qp_extra;
+	RelOptInfo *planned_rel;
 
+	/* Inheritance is never used for insert. */
 	Assert(parse->commandType != CMD_INSERT);
+	parent_rte = planner_rt_fetch(top_parentRTindex, root);
 
 	/*
-	 * We generate a modified instance of the original Query for each target
-	 * relation, plan that, and put all the plans into a list that will be
-	 * controlled by a single ModifyTable node.  All the instances share the
-	 * same rangetable, but each instance must have its own set of subquery
-	 * RTEs within the finished rangetable because (1) they are likely to get
-	 * scribbled on during planning, and (2) it's not inconceivable that
-	 * subqueries could get planned differently in different cases.  We need
-	 * not create duplicate copies of other RTE kinds, in particular not the
-	 * target relations, because they don't have either of those issues.  Not
-	 * having to duplicate the target relations is important because doing so
-	 * (1) would result in a rangetable of length O(N^2) for N targets, with
-	 * at least O(N^3) work expended here; and (2) would greatly complicate
-	 * management of the rowMarks list.
+	 * Generate the access paths for all relations mentioned in the query,
+	 * including the target inheritance set.  When doing the join planning,
+	 * references in the join tree to the original target relation that's the
+	 * root parent of the inheritance tree is replaced by each of its
+	 * inheritance children and the resulting joinrel RelOptInfo's are
+	 * added to root->inh_target_child_rels.
 	 *
-	 * To begin with, generate a bitmapset of the relids of the subquery RTEs.
+	 * Final planning steps (grouping_planner) are applied to the best path
+	 * of each of those child joinrels using a modified instance of the
+	 * original query for a given child target rel.  All the paths so
+	 * generated are put into a list that will be controlled by a single
+	 * ModifyTable node.  All the instances share the same rangetable.
 	 */
-	subqueryRTindexes = NULL;
-	rti = 1;
-	foreach(lc, parse->rtable)
-	{
-		RangeTblEntry *rte = lfirst_node(RangeTblEntry, lc);
-
-		if (rte->rtekind == RTE_SUBQUERY)
-			subqueryRTindexes = bms_add_member(subqueryRTindexes, rti);
-		rti++;
-	}
 
 	/*
-	 * Next, we want to identify which AppendRelInfo items contain references
-	 * to any of the aforesaid subquery RTEs.  These items will need to be
-	 * copied and modified to adjust their subquery references; whereas the
-	 * other ones need not be touched.  It's worth being tense over this
-	 * because we can usually avoid processing most of the AppendRelInfo
-	 * items, thereby saving O(N^2) space and time when the target is a large
-	 * inheritance tree.  We can identify AppendRelInfo items by their
-	 * child_relid, since that should be unique within the list.
+	 * Save the unexpanded version of the query's targetlist to be used below
+	 * for passing to grouping_planner for each child target relation.
 	 */
-	modifiableARIindexes = NULL;
-	if (subqueryRTindexes != NULL)
-	{
-		foreach(lc, root->append_rel_list)
-		{
-			AppendRelInfo *appinfo = lfirst_node(AppendRelInfo, lc);
+	root->unexpanded_tlist = list_copy(root->parse->targetList);
 
-			if (bms_is_member(appinfo->parent_relid, subqueryRTindexes) ||
-				bms_is_member(appinfo->child_relid, subqueryRTindexes) ||
-				bms_overlap(pull_varnos((Node *) appinfo->translated_vars),
-							subqueryRTindexes))
-				modifiableARIindexes = bms_add_member(modifiableARIindexes,
-													  appinfo->child_relid);
-		}
+	/* Do the scan/join planning. */
+	tlist = preprocess_targetlist(root);
+	root->processed_tlist = tlist;
+	qp_extra.tlist = tlist;
+	qp_extra.activeWindows = qp_extra.groupClause = NIL;
+	planned_rel = query_planner(root, tlist, standard_qp_callback, &qp_extra);
+
+	/*
+	 * If it turned out during query planning that all the children are dummy
+	 * (pruned or excluded by constraints), no need to do the steps below.
+	 * Let grouping_planner finish up the final path.
+	 */
+	if (IS_DUMMY_REL(planned_rel))
+	{
+		grouping_planner(root, false, planned_rel, 0.0);
+		return;
 	}
 
+	Assert(planned_rel->relid == top_parentRTindex);
+	Assert(planned_rel->reloptkind == RELOPT_BASEREL);
+
 	/*
 	 * If the parent RTE is a partitioned table, we should use that as the
 	 * nominal target relation, because the RTEs added for partitioned tables
@@ -1250,7 +1240,6 @@ inheritance_planner(PlannerInfo *root)
 	 * not appear anywhere else in the plan, so the confusion explained below
 	 * for non-partitioning inheritance cases is not possible.
 	 */
-	parent_rte = rt_fetch(top_parentRTindex, root->parse->rtable);
 	if (parent_rte->relkind == RELKIND_PARTITIONED_TABLE)
 	{
 		nominalRelation = top_parentRTindex;
@@ -1258,95 +1247,42 @@ inheritance_planner(PlannerInfo *root)
 	}
 
 	/*
-	 * The PlannerInfo for each child is obtained by translating the relevant
-	 * members of the PlannerInfo for its immediate parent, which we find
-	 * using the parent_relid in its AppendRelInfo.  We save the PlannerInfo
-	 * for each parent in an array indexed by relid for fast retrieval. Since
-	 * the maximum number of parents is limited by the number of RTEs in the
-	 * query, we use that number to allocate the array. An extra entry is
-	 * needed since relids start from 1.
+	 * Get on with finalizing the path for each child target relation by
+	 * calling grouping_planner on its joinrel.  Note that we're restoring
+	 * the query's targetlist to the original one for grouping_planner's
+	 * targetlist expansion steps to perform the expansion with individual
+	 * child descriptors.
 	 */
-	parent_roots = (PlannerInfo **) palloc0((list_length(parse->rtable) + 1) *
-											sizeof(PlannerInfo *));
-	parent_roots[top_parentRTindex] = root;
-
-	/*
-	 * And now we can get on with generating a plan for each child table.
-	 */
-	foreach(lc, root->append_rel_list)
+	forboth(lc1, root->inh_target_child_rels,
+			lc2, root->inh_target_child_joinrels)
 	{
-		AppendRelInfo *appinfo = lfirst_node(AppendRelInfo, lc);
-		PlannerInfo *subroot;
+		Index		childRTindex = lfirst_int(lc1);
+		RelOptInfo *childrel = lfirst(lc2);
+		PlannerInfo *subroot = root->inh_target_child_roots[childRTindex];
+		AppendRelInfo *appinfo = root->append_rel_array[childRTindex];
 		RangeTblEntry *child_rte;
 		RelOptInfo *sub_final_rel;
 		Path	   *subpath;
 
-		/* append_rel_list contains all append rels; ignore others */
-		if (!bms_is_member(appinfo->parent_relid, parent_relids))
-			continue;
-
-		/*
-		 * expand_inherited_rtentry() always processes a parent before any of
-		 * that parent's children, so the parent_root for this relation should
-		 * already be available.
-		 */
-		parent_root = parent_roots[appinfo->parent_relid];
-		Assert(parent_root != NULL);
-		parent_parse = parent_root->parse;
-
-		/*
-		 * We need a working copy of the PlannerInfo so that we can control
-		 * propagation of information back to the main copy.
-		 */
-		subroot = makeNode(PlannerInfo);
-		memcpy(subroot, parent_root, sizeof(PlannerInfo));
-
-		/*
-		 * Generate modified query with this rel as target.  We first apply
-		 * adjust_appendrel_attrs, which copies the Query and changes
-		 * references to the parent RTE to refer to the current child RTE,
-		 * then fool around with subquery RTEs.
-		 */
-		subroot->parse = (Query *)
-			adjust_appendrel_attrs(parent_root,
-								   (Node *) parent_parse,
-								   1, &appinfo);
+		Assert(subroot != NULL);
+		Assert(subroot->parse->resultRelation == childRTindex);
 
 		/*
 		 * If there are securityQuals attached to the parent, move them to the
 		 * child rel (they've already been transformed properly for that).
 		 */
-		parent_rte = rt_fetch(appinfo->parent_relid, subroot->parse->rtable);
-		child_rte = rt_fetch(appinfo->child_relid, subroot->parse->rtable);
+		parent_rte = planner_rt_fetch(appinfo->parent_relid, subroot);
+		child_rte = planner_rt_fetch(appinfo->child_relid, subroot);
 		child_rte->securityQuals = parent_rte->securityQuals;
 		parent_rte->securityQuals = NIL;
 
 		/*
-		 * Mark whether we're planning a query to a partitioned table or an
-		 * inheritance parent.
+		 * Ignore a partitioned child.  Instead, the paths of its children will
+		 * be added to subpaths.
 		 */
-		subroot->inhTargetKind =
-			(rootRelation != 0) ? INHKIND_PARTITIONED : INHKIND_INHERITED;
-
-		/*
-		 * If this child is further partitioned, remember it as a parent.
-		 * Since a partitioned table does not have any data, we don't need to
-		 * create a plan for it, and we can stop processing it here.  We do,
-		 * however, need to remember its modified PlannerInfo for use when
-		 * processing its children, since we'll update their varnos based on
-		 * the delta from immediate parent to child, not from top to child.
-		 *
-		 * Note: a very non-obvious point is that we have not yet added
-		 * duplicate subquery RTEs to the subroot's rtable.  We mustn't,
-		 * because then its children would have two sets of duplicates,
-		 * confusing matters.
-		 */
-		if (child_rte->inh)
+		if (childrel->part_scheme)
 		{
-			Assert(child_rte->relkind == RELKIND_PARTITIONED_TABLE);
-			parent_relids = bms_add_member(parent_relids, appinfo->child_relid);
-			parent_roots[appinfo->child_relid] = subroot;
-
+			Assert(child_rte->inh);
 			continue;
 		}
 
@@ -1374,111 +1310,8 @@ inheritance_planner(PlannerInfo *root)
 		if (nominalRelation < 0)
 			nominalRelation = appinfo->child_relid;
 
-		/*
-		 * The rowMarks list might contain references to subquery RTEs, so
-		 * make a copy that we can apply ChangeVarNodes to.  (Fortunately, the
-		 * executor doesn't need to see the modified copies --- we can just
-		 * pass it the original rowMarks list.)
-		 */
-		subroot->rowMarks = copyObject(parent_root->rowMarks);
-
-		/*
-		 * The append_rel_list likewise might contain references to subquery
-		 * RTEs (if any subqueries were flattenable UNION ALLs).  So prepare
-		 * to apply ChangeVarNodes to that, too.  As explained above, we only
-		 * want to copy items that actually contain such references; the rest
-		 * can just get linked into the subroot's append_rel_list.
-		 *
-		 * If we know there are no such references, we can just use the outer
-		 * append_rel_list unmodified.
-		 */
-		if (modifiableARIindexes != NULL)
-		{
-			ListCell   *lc2;
-
-			subroot->append_rel_list = NIL;
-			foreach(lc2, parent_root->append_rel_list)
-			{
-				AppendRelInfo *appinfo2 = lfirst_node(AppendRelInfo, lc2);
-
-				if (bms_is_member(appinfo2->child_relid, modifiableARIindexes))
-					appinfo2 = copyObject(appinfo2);
-
-				subroot->append_rel_list = lappend(subroot->append_rel_list,
-												   appinfo2);
-			}
-		}
-
-		/*
-		 * Add placeholders to the child Query's rangetable list to fill the
-		 * RT indexes already reserved for subqueries in previous children.
-		 * These won't be referenced, so there's no need to make them very
-		 * valid-looking.
-		 */
-		while (list_length(subroot->parse->rtable) < list_length(final_rtable))
-			subroot->parse->rtable = lappend(subroot->parse->rtable,
-											 makeNode(RangeTblEntry));
-
-		/*
-		 * If this isn't the first child Query, generate duplicates of all
-		 * subquery RTEs, and adjust Var numbering to reference the
-		 * duplicates. To simplify the loop logic, we scan the original rtable
-		 * not the copy just made by adjust_appendrel_attrs; that should be OK
-		 * since subquery RTEs couldn't contain any references to the target
-		 * rel.
-		 */
-		if (final_rtable != NIL && subqueryRTindexes != NULL)
-		{
-			ListCell   *lr;
-
-			rti = 1;
-			foreach(lr, parent_parse->rtable)
-			{
-				RangeTblEntry *rte = lfirst_node(RangeTblEntry, lr);
-
-				if (bms_is_member(rti, subqueryRTindexes))
-				{
-					Index		newrti;
-
-					/*
-					 * The RTE can't contain any references to its own RT
-					 * index, except in its securityQuals, so we can save a
-					 * few cycles by applying ChangeVarNodes to the rest of
-					 * the rangetable before we append the RTE to it.
-					 */
-					newrti = list_length(subroot->parse->rtable) + 1;
-					ChangeVarNodes((Node *) subroot->parse, rti, newrti, 0);
-					ChangeVarNodes((Node *) subroot->rowMarks, rti, newrti, 0);
-					/* Skip processing unchanging parts of append_rel_list */
-					if (modifiableARIindexes != NULL)
-					{
-						ListCell   *lc2;
-
-						foreach(lc2, subroot->append_rel_list)
-						{
-							AppendRelInfo *appinfo2 = lfirst_node(AppendRelInfo, lc2);
-
-							if (bms_is_member(appinfo2->child_relid,
-											  modifiableARIindexes))
-								ChangeVarNodes((Node *) appinfo2, rti, newrti, 0);
-						}
-					}
-					rte = copyObject(rte);
-					ChangeVarNodes((Node *) rte->securityQuals, rti, newrti, 0);
-					subroot->parse->rtable = lappend(subroot->parse->rtable,
-													 rte);
-				}
-				rti++;
-			}
-		}
-
-		/* There shouldn't be any OJ info to translate, as yet */
-		Assert(subroot->join_info_list == NIL);
-		/* and we haven't created PlaceHolderInfos, either */
-		Assert(subroot->placeholder_list == NIL);
-
-		/* Generate Path(s) for accessing this result relation */
-		grouping_planner(subroot, true, 0.0 /* retrieve all tuples */ );
+		/* Apply the top-level targetlist to childrel's path. */
+		grouping_planner(subroot, true, childrel, 0.0);
 
 		/*
 		 * Select cheapest path in case there's more than one.  We always run
@@ -1490,45 +1323,10 @@ inheritance_planner(PlannerInfo *root)
 		subpath = sub_final_rel->cheapest_total_path;
 
 		/*
-		 * If this child rel was excluded by constraint exclusion, exclude it
-		 * from the result plan.
+		 * child rel cannot be empty, or inheritance_make_rel_from_joinlist
+		 * wouldn't have put it in the list to begin with.
 		 */
-		if (IS_DUMMY_PATH(subpath))
-			continue;
-
-		/*
-		 * If this is the first non-excluded child, its post-planning rtable
-		 * becomes the initial contents of final_rtable; otherwise, append
-		 * just its modified subquery RTEs to final_rtable.
-		 */
-		if (final_rtable == NIL)
-			final_rtable = subroot->parse->rtable;
-		else
-			final_rtable = list_concat(final_rtable,
-									   list_copy_tail(subroot->parse->rtable,
-													  list_length(final_rtable)));
-
-		/*
-		 * We need to collect all the RelOptInfos from all child plans into
-		 * the main PlannerInfo, since setrefs.c will need them.  We use the
-		 * last child's simple_rel_array (previous ones are too short), so we
-		 * have to propagate forward the RelOptInfos that were already built
-		 * in previous children.
-		 */
-		Assert(subroot->simple_rel_array_size >= save_rel_array_size);
-		for (rti = 1; rti < save_rel_array_size; rti++)
-		{
-			RelOptInfo *brel = save_rel_array[rti];
-
-			if (brel)
-				subroot->simple_rel_array[rti] = brel;
-		}
-		save_rel_array_size = subroot->simple_rel_array_size;
-		save_rel_array = subroot->simple_rel_array;
-		save_append_rel_array = subroot->append_rel_array;
-
-		/* Make sure any initplans from this rel get into the outer list */
-		root->init_plans = subroot->init_plans;
+		Assert(!IS_DUMMY_PATH(subpath));
 
 		/* Build list of sub-paths */
 		subpaths = lappend(subpaths, subpath);
@@ -1560,36 +1358,6 @@ inheritance_planner(PlannerInfo *root)
 	 */
 
 	/*
-	 * If we managed to exclude every child rel, return a dummy plan; it
-	 * doesn't even need a ModifyTable node.
-	 */
-	if (subpaths == NIL)
-	{
-		set_dummy_rel_pathlist(final_rel);
-		return;
-	}
-
-	/*
-	 * Put back the final adjusted rtable into the master copy of the Query.
-	 * (We mustn't do this if we found no non-excluded children.)
-	 */
-	parse->rtable = final_rtable;
-	root->simple_rel_array_size = save_rel_array_size;
-	root->simple_rel_array = save_rel_array;
-	root->append_rel_array = save_append_rel_array;
-
-	/* Must reconstruct master's simple_rte_array, too */
-	root->simple_rte_array = (RangeTblEntry **)
-		palloc0((list_length(final_rtable) + 1) * sizeof(RangeTblEntry *));
-	rti = 1;
-	foreach(lc, final_rtable)
-	{
-		RangeTblEntry *rte = lfirst_node(RangeTblEntry, lc);
-
-		root->simple_rte_array[rti++] = rte;
-	}
-
-	/*
 	 * If there was a FOR [KEY] UPDATE/SHARE clause, the LockRows node will
 	 * have dealt with fetching non-locked marked rows, else we need to have
 	 * ModifyTable do that.
@@ -1629,6 +1397,12 @@ inheritance_planner(PlannerInfo *root)
  * (inheritance_planner will create a single ModifyTable node covering all the
  * target tables.)
  *
+ * If non-NULL, planned_rel is a RelOptInfo containing paths for the query's
+ * top-level joinrel, which the caller produced by itself.  In that case, this
+ * function only needs to adjust the targetlist of its cheapest_total_path.
+ * The only caller that may pass such a RelOptInfo currently is
+ * inheritance_planner.
+ *
  * tuple_fraction is the fraction of tuples we expect will be retrieved.
  * tuple_fraction is interpreted as follows:
  *	  0: expect all tuples to be retrieved (normal case)
@@ -1647,6 +1421,7 @@ inheritance_planner(PlannerInfo *root)
  */
 static void
 grouping_planner(PlannerInfo *root, bool inheritance_update,
+				 RelOptInfo *planned_rel,
 				 double tuple_fraction)
 {
 	Query	   *parse = root->parse;
@@ -1659,7 +1434,7 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 	List	   *final_targets;
 	List	   *final_targets_contain_srfs;
 	bool		final_target_parallel_safe;
-	RelOptInfo *current_rel;
+	RelOptInfo *current_rel = planned_rel;
 	RelOptInfo *final_rel;
 	ListCell   *lc;
 
@@ -1699,6 +1474,7 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 		 * special work for recursive unions is the responsibility of
 		 * plan_set_operations.
 		 */
+		Assert(current_rel == NULL);
 		current_rel = plan_set_operations(root);
 
 		/*
@@ -1788,17 +1564,26 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 				parse->groupClause = preprocess_groupclause(root, NIL);
 		}
 
-		/* Preprocess targetlist */
-		tlist = preprocess_targetlist(root);
-
 		/*
-		 * We are now done hacking up the query's targetlist.  Most of the
-		 * remaining planning work will be done with the PathTarget
-		 * representation of tlists, but save aside the full representation so
-		 * that we can transfer its decoration (resnames etc) to the topmost
-		 * tlist of the finished Plan.
+		 * Preprocess targetlist, if needed.  If the caller has already done
+		 * query planning, root->processed_tlist already contains the desired
+		 * targetlist.
 		 */
-		root->processed_tlist = tlist;
+		if (planned_rel == NULL)
+		{
+			tlist = preprocess_targetlist(root);
+
+			/*
+			 * We are now done hacking up the query's targetlist.  Most of the
+			 * remaining planning work will be done with the PathTarget
+			 * representation of tlists, but save aside the full representation
+			 * so that we can transfer its decoration (resnames etc) to the
+			 * topmost tlist of the finished Plan.
+			 */
+			root->processed_tlist = tlist;
+		}
+		else
+			tlist = root->processed_tlist;
 
 		/*
 		 * Collect statistics about aggregates for estimating costs, and mark
@@ -1878,8 +1663,9 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 		 * We also generate (in standard_qp_callback) pathkey representations
 		 * of the query's sort clause, distinct clause, etc.
 		 */
-		current_rel = query_planner(root, tlist,
-									standard_qp_callback, &qp_extra);
+		if (current_rel == NULL)
+			current_rel = query_planner(root, tlist,
+										standard_qp_callback, &qp_extra);
 
 		/*
 		 * Convert the query's result tlist into PathTarget format.
diff --git a/src/backend/optimizer/prep/prepjointree.c b/src/backend/optimizer/prep/prepjointree.c
index cd6e11904e..78baec00dc 100644
--- a/src/backend/optimizer/prep/prepjointree.c
+++ b/src/backend/optimizer/prep/prepjointree.c
@@ -917,7 +917,6 @@ pull_up_simple_subquery(PlannerInfo *root, Node *jtnode, RangeTblEntry *rte,
 	subroot->grouping_map = NULL;
 	subroot->minmax_aggs = NIL;
 	subroot->qual_security_level = 0;
-	subroot->inhTargetKind = INHKIND_NONE;
 	subroot->hasRecursion = false;
 	subroot->wt_param_id = -1;
 	subroot->non_recursive_path = NULL;
diff --git a/src/backend/optimizer/prep/prepunion.c b/src/backend/optimizer/prep/prepunion.c
index da278f785e..b320f8dce4 100644
--- a/src/backend/optimizer/prep/prepunion.c
+++ b/src/backend/optimizer/prep/prepunion.c
@@ -2250,8 +2250,39 @@ adjust_appendrel_attrs_mutator(Node *node,
 											  context->appinfos);
 		return (Node *) phv;
 	}
+
+	/*
+	 * This is needed, because inheritance_make_rel_from_joinlist needs to
+	 * translate root->join_info_list executing make_rel_from_joinlist for a
+	 * given child.
+	 */
+	if (IsA(node, SpecialJoinInfo))
+	{
+		SpecialJoinInfo *oldinfo = (SpecialJoinInfo *) node;
+		SpecialJoinInfo *newinfo = makeNode(SpecialJoinInfo);
+
+		memcpy(newinfo, oldinfo, sizeof(SpecialJoinInfo));
+		newinfo->min_lefthand = adjust_child_relids(oldinfo->min_lefthand,
+													context->nappinfos,
+													context->appinfos);
+		newinfo->min_righthand = adjust_child_relids(oldinfo->min_righthand,
+													 context->nappinfos,
+													 context->appinfos);
+		newinfo->syn_lefthand = adjust_child_relids(oldinfo->syn_lefthand,
+													context->nappinfos,
+													context->appinfos);
+		newinfo->syn_righthand = adjust_child_relids(oldinfo->syn_righthand,
+													 context->nappinfos,
+													 context->appinfos);
+		newinfo->semi_rhs_exprs =
+					(List *) expression_tree_mutator((Node *)
+													 oldinfo->semi_rhs_exprs,
+													 adjust_appendrel_attrs_mutator,
+													 (void *) context);
+		return (Node *) newinfo;
+	}
+
 	/* 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));
diff --git a/src/backend/optimizer/util/plancat.c b/src/backend/optimizer/util/plancat.c
index a570ac0aab..a0fed5be42 100644
--- a/src/backend/optimizer/util/plancat.c
+++ b/src/backend/optimizer/util/plancat.c
@@ -1264,36 +1264,6 @@ get_relation_constraints(PlannerInfo *root,
 		}
 	}
 
-	/*
-	 * Append partition predicates, if any.
-	 *
-	 * For selects, partition pruning uses the parent table's partition bound
-	 * descriptor, instead of constraint exclusion which is driven by the
-	 * individual partition's partition constraint.
-	 */
-	if (enable_partition_pruning && root->parse->commandType != CMD_SELECT)
-	{
-		List	   *pcqual = RelationGetPartitionQual(relation);
-
-		if (pcqual)
-		{
-			/*
-			 * Run the partition quals through const-simplification similar to
-			 * check constraints.  We skip canonicalize_qual, though, because
-			 * partition quals should be in canonical form already; also,
-			 * since the qual is in implicit-AND format, we'd have to
-			 * explicitly convert it to explicit-AND format and back again.
-			 */
-			pcqual = (List *) eval_const_expressions(root, (Node *) pcqual);
-
-			/* Fix Vars to have the desired varno */
-			if (varno != 1)
-				ChangeVarNodes((Node *) pcqual, 1, varno, 0);
-
-			result = list_concat(result, pcqual);
-		}
-	}
-
 	heap_close(relation, NoLock);
 
 	return result;
@@ -1420,31 +1390,15 @@ relation_excluded_by_constraints(PlannerInfo *root,
 	switch (constraint_exclusion)
 	{
 		case CONSTRAINT_EXCLUSION_OFF:
-
-			/*
-			 * Don't prune if feature turned off -- except if the relation is
-			 * a partition.  While partprune.c-style partition pruning is not
-			 * yet in use for all cases (update/delete is not handled), it
-			 * would be a UI horror to use different user-visible controls
-			 * depending on such a volatile implementation detail.  Therefore,
-			 * for partitioned tables we use enable_partition_pruning to
-			 * control this behavior.
-			 */
-			if (root->inhTargetKind == INHKIND_PARTITIONED)
-				break;
 			return false;
 
 		case CONSTRAINT_EXCLUSION_PARTITION:
 
 			/*
 			 * When constraint_exclusion is set to 'partition' we only handle
-			 * OTHER_MEMBER_RELs, or BASERELs in cases where the result target
-			 * is an inheritance parent or a partitioned table.
+			 * OTHER_MEMBER_RELs.
 			 */
-			if ((rel->reloptkind != RELOPT_OTHER_MEMBER_REL) &&
-				!(rel->reloptkind == RELOPT_BASEREL &&
-				  root->inhTargetKind != INHKIND_NONE &&
-				  rel->relid == root->parse->resultRelation))
+			if (rel->reloptkind != RELOPT_OTHER_MEMBER_REL)
 				return false;
 			break;
 
diff --git a/src/include/nodes/relation.h b/src/include/nodes/relation.h
index 6fd24203dd..53e9812237 100644
--- a/src/include/nodes/relation.h
+++ b/src/include/nodes/relation.h
@@ -319,9 +319,6 @@ typedef struct PlannerInfo
 	Index		qual_security_level;	/* minimum security_level for quals */
 	/* Note: qual_security_level is zero if there are no securityQuals */
 
-	InheritanceKind inhTargetKind;	/* indicates if the target relation is an
-									 * inheritance child or partition or a
-									 * partitioned table */
 	bool		hasJoinRTEs;	/* true if any RTEs are RTE_JOIN kind */
 	bool		hasLateralRTEs; /* true if any RTEs are marked LATERAL */
 	bool		hasDeletedRTEs; /* true if any RTE was deleted from jointree */
@@ -343,6 +340,37 @@ typedef struct PlannerInfo
 
 	/* Does this query modify any partition key columns? */
 	bool		partColsUpdated;
+
+	/*
+	 * The following fields are set during query planning portion of an
+	 * inherited UPDATE/DEELETE operation.
+	 */
+
+	/*
+	 * This stores the original version of the query's targetlist that's
+	 * not modified by the planner.
+	 */
+	List	   *unexpanded_tlist;
+
+	/*
+	 * PlannerInfos corresponding to each inheritance child targets.
+	 * Content of each PlannerInfo is same as the parent PlannerInfo, except
+	 * for the parse tree which is a translated copy of the parent's parse
+	 * tree.
+	 */
+	struct PlannerInfo **inh_target_child_roots;
+
+	/* List of RT indexes of child RT indexes. */
+	List	   *inh_target_child_rels;
+
+	/*
+	 * RelOptInfos corresponding to each child target rel.  For leaf children,
+	 * it's the RelOptInfo representing the output of make_rel_from_joinlist()
+	 * called with the parent rel in the original join tree replaced by a
+	 * given leaf child.  For non-leaf children, it's the baserel RelOptInfo
+	 * itself, left as a placeholder.
+	 */
+	List	   *inh_target_child_joinrels;
 } PlannerInfo;
 
 
diff --git a/src/include/optimizer/paths.h b/src/include/optimizer/paths.h
index cafde307ad..7aa1b6e17f 100644
--- a/src/include/optimizer/paths.h
+++ b/src/include/optimizer/paths.h
@@ -161,7 +161,8 @@ extern EquivalenceClass *match_eclasses_to_foreign_key_col(PlannerInfo *root,
 extern void add_child_rel_equivalences(PlannerInfo *root,
 						   AppendRelInfo *appinfo,
 						   RelOptInfo *parent_rel,
-						   RelOptInfo *child_rel);
+						   RelOptInfo *child_rel,
+						   bool child_is_target);
 extern List *generate_implied_equalities_for_column(PlannerInfo *root,
 									   RelOptInfo *rel,
 									   ec_matches_callback_type callback,
diff --git a/src/test/regress/expected/partition_join.out b/src/test/regress/expected/partition_join.out
index c55de5d476..c9f02c1fb0 100644
--- a/src/test/regress/expected/partition_join.out
+++ b/src/test/regress/expected/partition_join.out
@@ -1780,7 +1780,7 @@ WHERE EXISTS (
                Filter: (c IS NULL)
          ->  Nested Loop
                ->  Seq Scan on int4_tbl
-               ->  Subquery Scan on ss_1
+               ->  Subquery Scan on ss
                      ->  Limit
                            ->  Seq Scan on int8_tbl int8_tbl_1
    ->  Nested Loop Semi Join
@@ -1788,7 +1788,7 @@ WHERE EXISTS (
                Filter: (c IS NULL)
          ->  Nested Loop
                ->  Seq Scan on int4_tbl
-               ->  Subquery Scan on ss_2
+               ->  Subquery Scan on ss
                      ->  Limit
                            ->  Seq Scan on int8_tbl int8_tbl_2
 (28 rows)
-- 
2.11.0

From 38c2ae592397a78e234d7c6e1d866b9dfd51cd5f Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Fri, 26 Oct 2018 16:45:59 +0900
Subject: [PATCH v10 2/6] Store inheritance root parent index in otherrel's
 RelOptInfo

Although it's set by build_simple_rel, it's not being used by any
code yet.
---
 src/backend/nodes/outfuncs.c         |  1 +
 src/backend/optimizer/util/relnode.c | 14 ++++++++++++++
 src/include/nodes/relation.h         |  4 ++++
 3 files changed, 19 insertions(+)

diff --git a/src/backend/nodes/outfuncs.c b/src/backend/nodes/outfuncs.c
index 3c9db22507..c5fd84f4aa 100644
--- a/src/backend/nodes/outfuncs.c
+++ b/src/backend/nodes/outfuncs.c
@@ -2271,6 +2271,7 @@ _outRelOptInfo(StringInfo str, const RelOptInfo *node)
 	WRITE_BOOL_FIELD(consider_partitionwise_join);
 	WRITE_BITMAPSET_FIELD(top_parent_relids);
 	WRITE_NODE_FIELD(partitioned_child_rels);
+	WRITE_UINT_FIELD(inh_root_parent);
 }
 
 static void
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index 39f5729b91..29ba19349f 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -215,9 +215,23 @@ build_simple_rel(PlannerInfo *root, int relid, RelOptInfo *parent)
 			rel->top_parent_relids = parent->top_parent_relids;
 		else
 			rel->top_parent_relids = bms_copy(parent->relids);
+
+		/*
+		 * For inheritance child relations, we also set inh_root_parent.
+		 * Note that 'parent' might itself be a child (a sub-partitioned
+		 * partition), in which case we simply use its value of
+		 * inh_root_parent.
+		 */
+		if (parent->rtekind == RTE_RELATION)
+			rel->inh_root_parent = parent->inh_root_parent > 0 ?
+										parent->inh_root_parent :
+										parent->relid;
 	}
 	else
+	{
 		rel->top_parent_relids = NULL;
+		rel->inh_root_parent = 0;
+	}
 
 	/* Check type of rtable entry */
 	switch (rte->rtekind)
diff --git a/src/include/nodes/relation.h b/src/include/nodes/relation.h
index 53e9812237..7f71f1c948 100644
--- a/src/include/nodes/relation.h
+++ b/src/include/nodes/relation.h
@@ -731,6 +731,10 @@ typedef struct RelOptInfo
 	List	  **partexprs;		/* Non-nullable partition key expressions. */
 	List	  **nullable_partexprs; /* Nullable partition key expressions. */
 	List	   *partitioned_child_rels; /* List of RT indexes. */
+
+	Index		inh_root_parent;	/* For otherrels, this is the RT index of
+									 * inheritance table mentioned in the query
+									 * from which this relation originated */
 } RelOptInfo;
 
 /*
-- 
2.11.0

From b668d6e3763d713b0179054d0e448a0b8f6dbcd7 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Wed, 17 Oct 2018 18:14:13 +0900
Subject: [PATCH v10 3/6] Lazy creation of RTEs for inheritance children

Currently, expand_inherited_tables called from subquery_planner opens
all inheritance child tables and adds them to the query's range
table and PlannerInfo in the form of AppendRelInfo's initially and
later RelOptInfo's.  For partitioning, that's pretty wasteful, because
it's possible to determine only the partitions that will need to be
scanned using partition pruning, which doesn't require opening the
partitions themselves.  However, the point at which the above
processing happens is too early to perform partition pruning.

This commit rearranges things within the planner so that inheritance
child relations can be added to the Query and PlannerInfo during
make_one_rel, just before set_base_rel_sizes is called.  Although the
late initialization approach only benefits the partitioning case, it
seems undesirable to do it only for partitioned tables, because it
means adding code to handle partitions specially at various places
within the planner.  So, *all* inheritance parent tables are expanded
in make_one_rel.  All unpruned partitions are added to Query in the
form of their RangeTblEntry's being added to the range table and to
PlannerInfo in the form of an AppendRelInfo and a RelOptInfo for each.

For partitioning, although we don't create a RangeTblEntry and
RelOptInfo for pruned partitions at make_one_rel time, partitionwise
join code relies on the fact that even though partitions may have
been pruned, they'd still own a RelOptInfo to handle the outer join
case where the pruned partition appears on the nullable side of join.
Partitionwise join code deals with that by allocating dummy
RelOptInfos for pruned partitions that are based mostly on their
parent's properties.

There are some regression test diffs:

 1. Caused by the fact that we no longer allocate a duplicate RT
    entry for a partitioned table in its role as child, as seen in
    the partition_aggregate.out test output.

 2. Those in postgres_fdw.out are caused by the fact that junk columns
    required for row marking are added to reltarget->exprs later than
    user columns, because the row marking junk columns arent added
    until after the inheritance is expanded which as of this commit
    is later than it used to be.
---
 contrib/postgres_fdw/expected/postgres_fdw.out    |  32 +-
 src/backend/optimizer/path/allpaths.c             | 355 +--------
 src/backend/optimizer/path/joinrels.c             |  62 ++
 src/backend/optimizer/plan/initsplan.c            |  58 --
 src/backend/optimizer/plan/planmain.c             |  12 +-
 src/backend/optimizer/plan/planner.c              |  65 +-
 src/backend/optimizer/plan/setrefs.c              |   6 +
 src/backend/optimizer/prep/preptlist.c            |  15 +-
 src/backend/optimizer/prep/prepunion.c            | 854 +++++++++++++++-------
 src/backend/optimizer/util/Makefile               |   2 +-
 src/backend/optimizer/util/plancat.c              |  40 +-
 src/backend/optimizer/util/relnode.c              |  80 +-
 src/backend/partitioning/partprune.c              |  43 +-
 src/include/nodes/relation.h                      |   8 +
 src/include/optimizer/pathnode.h                  |   1 +
 src/include/optimizer/plancat.h                   |   2 +-
 src/include/optimizer/prep.h                      |   9 +-
 src/include/partitioning/partprune.h              |   2 +-
 src/test/regress/expected/partition_aggregate.out |   4 +-
 19 files changed, 886 insertions(+), 764 deletions(-)

diff --git a/contrib/postgres_fdw/expected/postgres_fdw.out b/contrib/postgres_fdw/expected/postgres_fdw.out
index bb92d9d37a..33a33606ef 100644
--- a/contrib/postgres_fdw/expected/postgres_fdw.out
+++ b/contrib/postgres_fdw/expected/postgres_fdw.out
@@ -7072,15 +7072,15 @@ select * from bar where f1 in (select f1 from foo) for update;
                      Output: bar2.f1, bar2.f2, bar2.ctid, bar2.*, bar2.tableoid
                      Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct2 FOR UPDATE
          ->  Hash
-               Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+               Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                ->  HashAggregate
-                     Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                     Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                      Group Key: foo.f1
                      ->  Append
                            ->  Seq Scan on public.foo
-                                 Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                                 Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                            ->  Foreign Scan on public.foo2
-                                 Output: foo2.ctid, foo2.*, foo2.tableoid, foo2.f1
+                                 Output: foo2.f1, foo2.ctid, foo2.*, foo2.tableoid
                                  Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct1
 (23 rows)
 
@@ -7110,15 +7110,15 @@ select * from bar where f1 in (select f1 from foo) for share;
                      Output: bar2.f1, bar2.f2, bar2.ctid, bar2.*, bar2.tableoid
                      Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct2 FOR SHARE
          ->  Hash
-               Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+               Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                ->  HashAggregate
-                     Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                     Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                      Group Key: foo.f1
                      ->  Append
                            ->  Seq Scan on public.foo
-                                 Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                                 Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                            ->  Foreign Scan on public.foo2
-                                 Output: foo2.ctid, foo2.*, foo2.tableoid, foo2.f1
+                                 Output: foo2.f1, foo2.ctid, foo2.*, foo2.tableoid
                                  Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct1
 (23 rows)
 
@@ -7147,15 +7147,15 @@ update bar set f2 = f2 + 100 where f1 in (select f1 from foo);
          ->  Seq Scan on public.bar
                Output: bar.f1, bar.f2, bar.ctid
          ->  Hash
-               Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+               Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                ->  HashAggregate
-                     Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                     Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                      Group Key: foo.f1
                      ->  Append
                            ->  Seq Scan on public.foo
-                                 Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                                 Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                            ->  Foreign Scan on public.foo2
-                                 Output: foo2.ctid, foo2.*, foo2.tableoid, foo2.f1
+                                 Output: foo2.f1, foo2.ctid, foo2.*, foo2.tableoid
                                  Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct1
    ->  Hash Join
          Output: bar2.f1, (bar2.f2 + 100), bar2.f3, bar2.ctid, foo.ctid, foo.*, foo.tableoid
@@ -7165,15 +7165,15 @@ update bar set f2 = f2 + 100 where f1 in (select f1 from foo);
                Output: bar2.f1, bar2.f2, bar2.f3, bar2.ctid
                Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct2 FOR UPDATE
          ->  Hash
-               Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+               Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                ->  HashAggregate
-                     Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                     Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                      Group Key: foo.f1
                      ->  Append
                            ->  Seq Scan on public.foo
-                                 Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                                 Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                            ->  Foreign Scan on public.foo2
-                                 Output: foo2.ctid, foo2.*, foo2.tableoid, foo2.f1
+                                 Output: foo2.f1, foo2.ctid, foo2.*, foo2.tableoid
                                  Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct1
 (39 rows)
 
diff --git a/src/backend/optimizer/path/allpaths.c b/src/backend/optimizer/path/allpaths.c
index 3f3bfbd696..e8f9463afb 100644
--- a/src/backend/optimizer/path/allpaths.c
+++ b/src/backend/optimizer/path/allpaths.c
@@ -44,7 +44,6 @@
 #include "optimizer/var.h"
 #include "parser/parse_clause.h"
 #include "parser/parsetree.h"
-#include "partitioning/partprune.h"
 #include "rewrite/rewriteManip.h"
 #include "utils/lsyscache.h"
 
@@ -378,7 +377,11 @@ set_rel_size(PlannerInfo *root, RelOptInfo *rel,
 		 */
 		set_dummy_rel_pathlist(rel);
 	}
-	else if (rte->inh)
+	/*
+	 * expand_inherited_tables may have proved that the relation is empty, so
+	 * check if it's so.
+	 */
+	else if (rte->inh && !IS_DUMMY_REL(rel))
 	{
 		/*
 		 * If it's a target relation, set the sizes of children instead.
@@ -949,38 +952,18 @@ set_inherit_target_rel_sizes(PlannerInfo *root, RelOptInfo *rel,
 	int			parentRTindex = rti;
 	ListCell   *l;
 	bool		has_live_children;
-	Relids		live_children = NULL;
-	bool		did_pruning = false;
 
 	/* Guard against stack overflow due to overly deep inheritance tree. */
 	check_stack_depth();
 
 	Assert(IS_SIMPLE_REL(rel));
 
-	/*
-	 * If the partitioned relation has any baserestrictinfo quals then we
-	 * attempt to use these quals to prune away partitions that cannot
-	 * possibly contain any tuples matching these quals.  In this case we'll
-	 * store the relids of all partitions which could possibly contain a
-	 * matching tuple, and skip anything else in the loop below.
-	 */
-	if (enable_partition_pruning &&
-		rte->relkind == RELKIND_PARTITIONED_TABLE &&
-		rel->baserestrictinfo != NIL)
-	{
-		live_children = prune_append_rel_partitions(rel);
-		did_pruning = true;
-	}
-
 	foreach(l, root->append_rel_list)
 	{
 		AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(l);
 		int			childRTindex;
 		RangeTblEntry *childRTE;
 		RelOptInfo *childrel;
-		List	   *childquals;
-		Index		cq_min_security;
-		bool		have_const_false_cq;
 		PlannerInfo *subroot;
 		ListCell   *lc;
 		List	   *translated_exprs,
@@ -995,139 +978,18 @@ set_inherit_target_rel_sizes(PlannerInfo *root, RelOptInfo *rel,
 		subroot = root->inh_target_child_roots[childRTindex];
 
 		/*
-		 * The child rel's RelOptInfo was already created during
-		 * add_base_rels_to_query.
+		 * The child rel's RelOptInfo is created during
+		 * expand_inherited_tables().
 		 */
 		childrel = find_base_rel(root, childRTindex);
 		Assert(childrel->reloptkind == RELOPT_OTHER_MEMBER_REL);
 
 		/*
-		 * We have to copy the parent's quals to the child, with appropriate
-		 * substitution of variables.  However, only the baserestrictinfo
-		 * quals are needed before we can check for constraint exclusion; so
-		 * do that first and then check to see if we can disregard this child.
-		 *
-		 * The child rel's targetlist might contain non-Var expressions, which
-		 * means that substitution into the quals could produce opportunities
-		 * for const-simplification, and perhaps even pseudoconstant quals.
-		 * Therefore, transform each RestrictInfo separately to see if it
-		 * reduces to a constant or pseudoconstant.  (We must process them
-		 * separately to keep track of the security level of each qual.)
+		 * Child relation may have been marked dummy if build_append_child_rel
+		 * found self-contradictory quals.
 		 */
-		childquals = NIL;
-		cq_min_security = UINT_MAX;
-		have_const_false_cq = false;
-		foreach(lc, rel->baserestrictinfo)
-		{
-			RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
-			Node	   *childqual;
-			ListCell   *lc2;
-
-			Assert(IsA(rinfo, RestrictInfo));
-			childqual = adjust_appendrel_attrs(root,
-											   (Node *) rinfo->clause,
-											   1, &appinfo);
-			childqual = eval_const_expressions(root, childqual);
-			/* check for flat-out constant */
-			if (childqual && IsA(childqual, Const))
-			{
-				if (((Const *) childqual)->constisnull ||
-					!DatumGetBool(((Const *) childqual)->constvalue))
-				{
-					/* Restriction reduces to constant FALSE or NULL */
-					have_const_false_cq = true;
-					break;
-				}
-				/* Restriction reduces to constant TRUE, so drop it */
-				continue;
-			}
-			/* might have gotten an AND clause, if so flatten it */
-			foreach(lc2, make_ands_implicit((Expr *) childqual))
-			{
-				Node	   *onecq = (Node *) lfirst(lc2);
-				bool		pseudoconstant;
-
-				/* check for pseudoconstant (no Vars or volatile functions) */
-				pseudoconstant =
-					!contain_vars_of_level(onecq, 0) &&
-					!contain_volatile_functions(onecq);
-				if (pseudoconstant)
-				{
-					/* tell createplan.c to check for gating quals */
-					root->hasPseudoConstantQuals = true;
-				}
-				/* reconstitute RestrictInfo with appropriate properties */
-				childquals = lappend(childquals,
-									 make_restrictinfo((Expr *) onecq,
-													   rinfo->is_pushed_down,
-													   rinfo->outerjoin_delayed,
-													   pseudoconstant,
-													   rinfo->security_level,
-													   NULL, NULL, NULL));
-				/* track minimum security level among child quals */
-				cq_min_security = Min(cq_min_security, rinfo->security_level);
-			}
-		}
-
-		/*
-		 * In addition to the quals inherited from the parent, we might have
-		 * securityQuals associated with this particular child node.
-		 * (Currently this can only happen in appendrels originating from
-		 * UNION ALL; inheritance child tables don't have their own
-		 * securityQuals, see expand_inherited_rtentry().)	Pull any such
-		 * securityQuals up into the baserestrictinfo for the child.  This is
-		 * similar to process_security_barrier_quals() for the parent rel,
-		 * except that we can't make any general deductions from such quals,
-		 * since they don't hold for the whole appendrel.
-		 */
-		if (childRTE->securityQuals)
-		{
-			Index		security_level = 0;
-
-			foreach(lc, childRTE->securityQuals)
-			{
-				List	   *qualset = (List *) lfirst(lc);
-				ListCell   *lc2;
-
-				foreach(lc2, qualset)
-				{
-					Expr	   *qual = (Expr *) lfirst(lc2);
-
-					/* not likely that we'd see constants here, so no check */
-					childquals = lappend(childquals,
-										 make_restrictinfo(qual,
-														   true, false, false,
-														   security_level,
-														   NULL, NULL, NULL));
-					cq_min_security = Min(cq_min_security, security_level);
-				}
-				security_level++;
-			}
-			Assert(security_level <= root->qual_security_level);
-		}
-
-		/*
-		 * OK, we've got all the baserestrictinfo quals for this child.
-		 */
-		childrel->baserestrictinfo = childquals;
-		childrel->baserestrict_min_security = cq_min_security;
-
-		if (have_const_false_cq)
-		{
-			/*
-			 * Some restriction clause reduced to constant FALSE or NULL after
-			 * substitution, so this child need not be scanned.
-			 */
-			set_dummy_rel_pathlist(childrel);
+		if (IS_DUMMY_REL(childrel))
 			continue;
-		}
-
-		if (did_pruning && !bms_is_member(appinfo->child_relid, live_children))
-		{
-			/* This partition was pruned; skip it. */
-			set_dummy_rel_pathlist(childrel);
-			continue;
-		}
 
 		if (relation_excluded_by_constraints(root, childrel, childRTE))
 		{
@@ -1269,8 +1131,6 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 	double	   *parent_attrsizes;
 	int			nattrs;
 	ListCell   *l;
-	Relids		live_children = NULL;
-	bool		did_pruning = false;
 
 	/* Guard against stack overflow due to overly deep inheritance tree. */
 	check_stack_depth();
@@ -1278,32 +1138,6 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 	Assert(IS_SIMPLE_REL(rel));
 
 	/*
-	 * Initialize partitioned_child_rels to contain this RT index.
-	 *
-	 * Note that during the set_append_rel_pathlist() phase, we will bubble up
-	 * the indexes of partitioned relations that appear down in the tree, so
-	 * that when we've created Paths for all the children, the root
-	 * partitioned table's list will contain all such indexes.
-	 */
-	if (rte->relkind == RELKIND_PARTITIONED_TABLE)
-		rel->partitioned_child_rels = list_make1_int(rti);
-
-	/*
-	 * If the partitioned relation has any baserestrictinfo quals then we
-	 * attempt to use these quals to prune away partitions that cannot
-	 * possibly contain any tuples matching these quals.  In this case we'll
-	 * store the relids of all partitions which could possibly contain a
-	 * matching tuple, and skip anything else in the loop below.
-	 */
-	if (enable_partition_pruning &&
-		rte->relkind == RELKIND_PARTITIONED_TABLE &&
-		rel->baserestrictinfo != NIL)
-	{
-		live_children = prune_append_rel_partitions(rel);
-		did_pruning = true;
-	}
-
-	/*
 	 * If this is a partitioned baserel, set the consider_partitionwise_join
 	 * flag; currently, we only consider partitionwise joins with the baserel
 	 * if its targetlist doesn't contain a whole-row Var.
@@ -1340,12 +1174,8 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 		int			childRTindex;
 		RangeTblEntry *childRTE;
 		RelOptInfo *childrel;
-		List	   *childquals;
-		Index		cq_min_security;
-		bool		have_const_false_cq;
 		ListCell   *parentvars;
 		ListCell   *childvars;
-		ListCell   *lc;
 
 		/* append_rel_list contains all append rels; ignore others */
 		if (appinfo->parent_relid != parentRTindex)
@@ -1353,18 +1183,34 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 
 		childRTindex = appinfo->child_relid;
 		childRTE = root->simple_rte_array[childRTindex];
+		Assert(childRTE != NULL);
 
 		/*
-		 * The child rel's RelOptInfo was already created during
-		 * add_base_rels_to_query.
+		 * The child rel's RelOptInfo is created during
+		 * expand_inherited_tables().
 		 */
 		childrel = find_base_rel(root, childRTindex);
 		Assert(childrel->reloptkind == RELOPT_OTHER_MEMBER_REL);
 
 		/*
-		 * Copy/Modify targetlist. Even if this child is deemed empty, we need
-		 * its targetlist in case it falls on nullable side in a child-join
-		 * because of partitionwise join.
+		 * Child relation may have been marked dummy if build_append_child_rel
+		 * found self-contradictory quals.
+		 */
+		if (IS_DUMMY_REL(childrel))
+			continue;
+
+		if (relation_excluded_by_constraints(root, childrel, childRTE))
+		{
+			/*
+			 * This child need not be scanned, so we can omit it from the
+			 * appendrel.
+			 */
+			set_dummy_rel_pathlist(childrel);
+			continue;
+		}
+
+		/*
+		 * Copy/Modify targetlist.
 		 *
 		 * NB: the resulting childrel->reltarget->exprs may contain arbitrary
 		 * expressions, which otherwise would not occur in a rel's targetlist.
@@ -1394,144 +1240,6 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 									   false);
 		childrel->has_eclass_joins = rel->has_eclass_joins;
 
-		/*
-		 * We have to copy the parent's quals to the child, with appropriate
-		 * substitution of variables.  However, only the baserestrictinfo
-		 * quals are needed before we can check for constraint exclusion; so
-		 * do that first and then check to see if we can disregard this child.
-		 *
-		 * The child rel's targetlist might contain non-Var expressions, which
-		 * means that substitution into the quals could produce opportunities
-		 * for const-simplification, and perhaps even pseudoconstant quals.
-		 * Therefore, transform each RestrictInfo separately to see if it
-		 * reduces to a constant or pseudoconstant.  (We must process them
-		 * separately to keep track of the security level of each qual.)
-		 */
-		childquals = NIL;
-		cq_min_security = UINT_MAX;
-		have_const_false_cq = false;
-		foreach(lc, rel->baserestrictinfo)
-		{
-			RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
-			Node	   *childqual;
-			ListCell   *lc2;
-
-			Assert(IsA(rinfo, RestrictInfo));
-			childqual = adjust_appendrel_attrs(root,
-											   (Node *) rinfo->clause,
-											   1, &appinfo);
-			childqual = eval_const_expressions(root, childqual);
-			/* check for flat-out constant */
-			if (childqual && IsA(childqual, Const))
-			{
-				if (((Const *) childqual)->constisnull ||
-					!DatumGetBool(((Const *) childqual)->constvalue))
-				{
-					/* Restriction reduces to constant FALSE or NULL */
-					have_const_false_cq = true;
-					break;
-				}
-				/* Restriction reduces to constant TRUE, so drop it */
-				continue;
-			}
-			/* might have gotten an AND clause, if so flatten it */
-			foreach(lc2, make_ands_implicit((Expr *) childqual))
-			{
-				Node	   *onecq = (Node *) lfirst(lc2);
-				bool		pseudoconstant;
-
-				/* check for pseudoconstant (no Vars or volatile functions) */
-				pseudoconstant =
-					!contain_vars_of_level(onecq, 0) &&
-					!contain_volatile_functions(onecq);
-				if (pseudoconstant)
-				{
-					/* tell createplan.c to check for gating quals */
-					root->hasPseudoConstantQuals = true;
-				}
-				/* reconstitute RestrictInfo with appropriate properties */
-				childquals = lappend(childquals,
-									 make_restrictinfo((Expr *) onecq,
-													   rinfo->is_pushed_down,
-													   rinfo->outerjoin_delayed,
-													   pseudoconstant,
-													   rinfo->security_level,
-													   NULL, NULL, NULL));
-				/* track minimum security level among child quals */
-				cq_min_security = Min(cq_min_security, rinfo->security_level);
-			}
-		}
-
-		/*
-		 * In addition to the quals inherited from the parent, we might have
-		 * securityQuals associated with this particular child node.
-		 * (Currently this can only happen in appendrels originating from
-		 * UNION ALL; inheritance child tables don't have their own
-		 * securityQuals, see expand_inherited_rtentry().)	Pull any such
-		 * securityQuals up into the baserestrictinfo for the child.  This is
-		 * similar to process_security_barrier_quals() for the parent rel,
-		 * except that we can't make any general deductions from such quals,
-		 * since they don't hold for the whole appendrel.
-		 */
-		if (childRTE->securityQuals)
-		{
-			Index		security_level = 0;
-
-			foreach(lc, childRTE->securityQuals)
-			{
-				List	   *qualset = (List *) lfirst(lc);
-				ListCell   *lc2;
-
-				foreach(lc2, qualset)
-				{
-					Expr	   *qual = (Expr *) lfirst(lc2);
-
-					/* not likely that we'd see constants here, so no check */
-					childquals = lappend(childquals,
-										 make_restrictinfo(qual,
-														   true, false, false,
-														   security_level,
-														   NULL, NULL, NULL));
-					cq_min_security = Min(cq_min_security, security_level);
-				}
-				security_level++;
-			}
-			Assert(security_level <= root->qual_security_level);
-		}
-
-		/*
-		 * OK, we've got all the baserestrictinfo quals for this child.
-		 */
-		childrel->baserestrictinfo = childquals;
-		childrel->baserestrict_min_security = cq_min_security;
-
-		if (have_const_false_cq)
-		{
-			/*
-			 * Some restriction clause reduced to constant FALSE or NULL after
-			 * substitution, so this child need not be scanned.
-			 */
-			set_dummy_rel_pathlist(childrel);
-			continue;
-		}
-
-		if (did_pruning && !bms_is_member(appinfo->child_relid, live_children))
-		{
-			/* This partition was pruned; skip it. */
-			set_dummy_rel_pathlist(childrel);
-			continue;
-		}
-
-		if (relation_excluded_by_constraints(root, childrel, childRTE))
-		{
-			/*
-			 * This child need not be scanned, so we can omit it from the
-			 * appendrel.
-			 */
-			set_dummy_rel_pathlist(childrel);
-			continue;
-		}
-
 		/* CE failed, so finish copying/modifying join quals. */
 		childrel->joininfo = (List *)
 			adjust_appendrel_attrs(root,
@@ -3068,6 +2776,7 @@ inheritance_make_rel_from_joinlist(PlannerInfo *root, List *joinlist)
 		subroot = root->inh_target_child_roots[appinfo->child_relid];
 		Assert(subroot->parse->resultRelation > 0);
 		childrel = find_base_rel(root, appinfo->child_relid);
+		Assert(childrel != NULL);
 
 		/* Ignore excluded/pruned children. */
 		if (IS_DUMMY_REL(childrel))
diff --git a/src/backend/optimizer/path/joinrels.c b/src/backend/optimizer/path/joinrels.c
index d3d21fed5d..da0831de4e 100644
--- a/src/backend/optimizer/path/joinrels.c
+++ b/src/backend/optimizer/path/joinrels.c
@@ -20,6 +20,7 @@
 #include "optimizer/pathnode.h"
 #include "optimizer/paths.h"
 #include "optimizer/prep.h"
+#include "optimizer/tlist.h"
 #include "partitioning/partbounds.h"
 #include "utils/lsyscache.h"
 #include "utils/memutils.h"
@@ -46,6 +47,9 @@ static void try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1,
 					   List *parent_restrictlist);
 static int match_expr_to_partition_keys(Expr *expr, RelOptInfo *rel,
 							 bool strict_op);
+static RelOptInfo *build_dummy_partition_rel(PlannerInfo *root,
+									RelOptInfo *parent,
+									int partidx);
 
 
 /*
@@ -1376,6 +1380,11 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
 		AppendRelInfo **appinfos;
 		int			nappinfos;
 
+		if (child_rel1 == NULL)
+			child_rel1 = build_dummy_partition_rel(root, rel1, cnt_parts);
+		if (child_rel2 == NULL)
+			child_rel2 = build_dummy_partition_rel(root, rel2, cnt_parts);
+
 		/* We should never try to join two overlapping sets of rels. */
 		Assert(!bms_overlap(child_rel1->relids, child_rel2->relids));
 		child_joinrelids = bms_union(child_rel1->relids, child_rel2->relids);
@@ -1582,3 +1591,56 @@ match_expr_to_partition_keys(Expr *expr, RelOptInfo *rel, bool strict_op)
 
 	return -1;
 }
+
+/*
+ * build_dummy_partition_rel
+ *		Build a RelOptInfo and AppendRelInfo for a pruned partition
+ *
+ * This does not result in opening the relation or a range table entry being
+ * created.  Also, the RelOptInfo thus created is not stored anywhere else
+ * beside the parent's part_rels array.
+ *
+ * The only reason this exists is because partition-wise join, in some cases,
+ * needs a RelOptInfo to represent an empty relation that's on the nullable
+ * side of an outer join, so that a Path representing the outer join can be
+ * created.
+ */
+RelOptInfo *
+build_dummy_partition_rel(PlannerInfo *root, RelOptInfo *parent, int partidx)
+{
+	RangeTblEntry *parentrte = root->simple_rte_array[parent->relid];
+	RelOptInfo *rel;
+
+	Assert(parent->part_rels[partidx] == NULL);
+
+	/* Create minimally valid-looking RelOptInfo with parent's relid. */
+	rel = makeNode(RelOptInfo);
+	rel->reloptkind = RELOPT_OTHER_MEMBER_REL;
+	rel->relid = parent->relid;
+	rel->relids = bms_copy(parent->relids);
+	if (parent->top_parent_relids)
+		rel->top_parent_relids = parent->top_parent_relids;
+	else
+		rel->top_parent_relids = bms_copy(parent->relids);
+	rel->reltarget = copy_pathtarget(parent->reltarget);
+	parent->part_rels[partidx] = rel;
+	mark_dummy_rel(rel);
+
+	/*
+	 * Now we'll need a (no-op) AppendRelInfo for parent, because we're
+	 * setting the dummy partition's relid to be same as the parent's.
+	 */
+	if (root->append_rel_array[parent->relid] == NULL)
+	{
+		/* Pass parent's info as for both the parent rel and child rel. */
+		AppendRelInfo *appinfo = make_append_rel_info(parent, parentrte,
+													  parent->tupdesc,
+													  parentrte->relid,
+													  parent->reltype,
+													  parent->relid);
+
+		root->append_rel_array[parent->relid] = appinfo;
+	}
+
+	return rel;
+}
diff --git a/src/backend/optimizer/plan/initsplan.c b/src/backend/optimizer/plan/initsplan.c
index 01335db511..7636aa82c4 100644
--- a/src/backend/optimizer/plan/initsplan.c
+++ b/src/backend/optimizer/plan/initsplan.c
@@ -616,64 +616,6 @@ create_lateral_join_info(PlannerInfo *root)
 				bms_add_member(brel2->lateral_referencers, rti);
 		}
 	}
-
-	/*
-	 * Lastly, propagate lateral_relids and lateral_referencers from appendrel
-	 * parent rels to their child rels.  We intentionally give each child rel
-	 * the same minimum parameterization, even though it's quite possible that
-	 * some don't reference all the lateral rels.  This is because any append
-	 * path for the parent will have to have the same parameterization for
-	 * every child anyway, and there's no value in forcing extra
-	 * reparameterize_path() calls.  Similarly, a lateral reference to the
-	 * parent prevents use of otherwise-movable join rels for each child.
-	 */
-	for (rti = 1; rti < root->simple_rel_array_size; rti++)
-	{
-		RelOptInfo *brel = root->simple_rel_array[rti];
-		RangeTblEntry *brte = root->simple_rte_array[rti];
-
-		/*
-		 * Skip empty slots. Also skip non-simple relations i.e. dead
-		 * relations.
-		 */
-		if (brel == NULL || !IS_SIMPLE_REL(brel))
-			continue;
-
-		/*
-		 * In the case of table inheritance, the parent RTE is directly linked
-		 * to every child table via an AppendRelInfo.  In the case of table
-		 * partitioning, the inheritance hierarchy is expanded one level at a
-		 * time rather than flattened.  Therefore, an other member rel that is
-		 * a partitioned table may have children of its own, and must
-		 * therefore be marked with the appropriate lateral info so that those
-		 * children eventually get marked also.
-		 */
-		Assert(brte);
-		if (brel->reloptkind == RELOPT_OTHER_MEMBER_REL &&
-			(brte->rtekind != RTE_RELATION ||
-			 brte->relkind != RELKIND_PARTITIONED_TABLE))
-			continue;
-
-		if (brte->inh)
-		{
-			foreach(lc, root->append_rel_list)
-			{
-				AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(lc);
-				RelOptInfo *childrel;
-
-				if (appinfo->parent_relid != rti)
-					continue;
-				childrel = root->simple_rel_array[appinfo->child_relid];
-				Assert(childrel->reloptkind == RELOPT_OTHER_MEMBER_REL);
-				Assert(childrel->direct_lateral_relids == NULL);
-				childrel->direct_lateral_relids = brel->direct_lateral_relids;
-				Assert(childrel->lateral_relids == NULL);
-				childrel->lateral_relids = brel->lateral_relids;
-				Assert(childrel->lateral_referencers == NULL);
-				childrel->lateral_referencers = brel->lateral_referencers;
-			}
-		}
-	}
 }
 
 
diff --git a/src/backend/optimizer/plan/planmain.c b/src/backend/optimizer/plan/planmain.c
index c2d2d12a4c..be261061f2 100644
--- a/src/backend/optimizer/plan/planmain.c
+++ b/src/backend/optimizer/plan/planmain.c
@@ -256,6 +256,16 @@ query_planner(PlannerInfo *root, List *tlist,
 		root->all_baserels = bms_add_member(root->all_baserels, brel->relid);
 	}
 
+	/*
+	 * Expand RT entries that represent inherited or partitioned tables.
+	 * This will perform partition pruning on partitioned tables in the
+	 * original range table and also recursively on any child partitioned
+	 * tables that were added by the expansion of the original parent(s).
+	 * As new entries are added to the range table, various arrays in the
+	 * PlannerInfo will be expanded accordingly.
+	 */
+	expand_inherited_tables(root);
+
 	inherited_update = (parse->resultRelation &&
 						root->simple_rte_array[parse->resultRelation]->inh);
 
@@ -367,7 +377,7 @@ adjust_inherited_target_child_root(PlannerInfo *root, AppendRelInfo *appinfo)
 	 * column, filling placeholder entries for dropped columns, etc., all of
 	 * which occurs with the child's TupleDesc.
 	 */
-	tlist = preprocess_targetlist(subroot);
+	tlist = preprocess_targetlist(subroot, true);
 	subroot->processed_tlist = tlist;
 
 	/* Add any newly added Vars to the child RelOptInfo. */
diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index 6cff7262e8..148032342f 100644
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -23,6 +23,7 @@
 #include "access/sysattr.h"
 #include "access/xact.h"
 #include "catalog/pg_constraint.h"
+#include "catalog/pg_inherits.h"
 #include "catalog/pg_proc.h"
 #include "catalog/pg_type.h"
 #include "executor/executor.h"
@@ -699,27 +700,24 @@ subquery_planner(PlannerGlobal *glob, Query *parse,
 		}
 		if (rte->lateral)
 			root->hasLateralRTEs = true;
+
+		/*
+		 * While at it, also update the inh status.  If the relation doesn't
+		 * or can't have any children, there is no point in letting inh be set
+		 * to true.  Note that we do this before processing rowmarks, so that
+		 * the correct information for setting isParent field of PlanRowMarks.
+		 */
+		if (rte->rtekind == RTE_RELATION)
+			rte->inh = rte->inh && has_subclass(rte->relid);
 	}
 
 	/*
 	 * Preprocess RowMark information.  We need to do this after subquery
-	 * pullup (so that all non-inherited RTEs are present) and before
-	 * inheritance expansion (so that the info is available for
-	 * expand_inherited_tables to examine and modify).
+	 * pullup (so that all non-inherited RTEs are present).
 	 */
 	preprocess_rowmarks(root);
 
 	/*
-	 * Expand any rangetable entries that are inheritance sets into "append
-	 * relations".  This can add entries to the rangetable, but they must be
-	 * plain base relations not joins, so it's OK (and marginally more
-	 * efficient) to do it after checking for join RTEs.  We must do it after
-	 * pulling up subqueries, else we'd fail to handle inherited tables in
-	 * subqueries.
-	 */
-	expand_inherited_tables(root);
-
-	/*
 	 * Set hasHavingQual to remember if HAVING clause is present.  Needed
 	 * because preprocess_expression will reduce a constant-true condition to
 	 * an empty qual list ... but "HAVING TRUE" is not a semantic no-op.
@@ -1212,8 +1210,11 @@ inheritance_planner(PlannerInfo *root)
 	 */
 	root->unexpanded_tlist = list_copy(root->parse->targetList);
 
-	/* Do the scan/join planning. */
-	tlist = preprocess_targetlist(root);
+	/*
+	 * Do the scan/join planning.  We haven't expanded inheritance yet, so
+	 * pass false.
+	 */
+	tlist = preprocess_targetlist(root, false);
 	root->processed_tlist = tlist;
 	qp_extra.tlist = tlist;
 	qp_extra.activeWindows = qp_extra.groupClause = NIL;
@@ -1222,9 +1223,10 @@ inheritance_planner(PlannerInfo *root)
 	/*
 	 * If it turned out during query planning that all the children are dummy
 	 * (pruned or excluded by constraints), no need to do the steps below.
-	 * Let grouping_planner finish up the final path.
+	 * For regular inheritance case, it's possible that we only need to modify
+	 * the parent table.  Let grouping_planner finish up the final path.
 	 */
-	if (IS_DUMMY_REL(planned_rel))
+	if (!parent_rte->inh || IS_DUMMY_REL(planned_rel))
 	{
 		grouping_planner(root, false, planned_rel, 0.0);
 		return;
@@ -1571,14 +1573,19 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 		 */
 		if (planned_rel == NULL)
 		{
-			tlist = preprocess_targetlist(root);
+			/* We haven't expanded inheritance yet, so pass false. */
+			tlist = preprocess_targetlist(root, false);
 
 			/*
-			 * We are now done hacking up the query's targetlist.  Most of the
-			 * remaining planning work will be done with the PathTarget
-			 * representation of tlists, but save aside the full representation
-			 * so that we can transfer its decoration (resnames etc) to the
-			 * topmost tlist of the finished Plan.
+			 * We are now mostly done hacking up the query's targetlist.  More
+			 * columns might be added during query_planner after inheritance
+			 * expansion in make_one_rel, because some children may require
+			 * different column than the parent for row mark handling; see
+			 * add_rowmark_junk_columns().  Most of the remaining planning
+			 * work will be done with the PathTarget representation of tlists,
+			 * but save aside the full representation so that we can transfer
+			 * its decoration (resnames etc) to the topmost tlist of the
+			 * finished Plan.
 			 */
 			root->processed_tlist = tlist;
 		}
@@ -2354,7 +2361,7 @@ preprocess_rowmarks(PlannerInfo *root)
 		newrc->allMarkTypes = (1 << newrc->markType);
 		newrc->strength = rc->strength;
 		newrc->waitPolicy = rc->waitPolicy;
-		newrc->isParent = false;
+		newrc->isParent = rte->inh;
 
 		prowmarks = lappend(prowmarks, newrc);
 	}
@@ -2379,7 +2386,7 @@ preprocess_rowmarks(PlannerInfo *root)
 		newrc->allMarkTypes = (1 << newrc->markType);
 		newrc->strength = LCS_NONE;
 		newrc->waitPolicy = LockWaitBlock;	/* doesn't matter */
-		newrc->isParent = false;
+		newrc->isParent = rte->rtekind == RTE_RELATION ? rte->inh : false;
 
 		prowmarks = lappend(prowmarks, newrc);
 	}
@@ -6816,6 +6823,10 @@ apply_scanjoin_target_to_paths(PlannerInfo *root,
 			int			nappinfos;
 			List	   *child_scanjoin_targets = NIL;
 
+			/* Skip processing pruned partitions. */
+			if (child_rel == NULL)
+				continue;
+
 			/* Translate scan/join targets for this child. */
 			appinfos = find_appinfos_by_relids(root, child_rel->relids,
 											   &nappinfos);
@@ -6917,6 +6928,10 @@ create_partitionwise_grouping_paths(PlannerInfo *root,
 		RelOptInfo *child_grouped_rel;
 		RelOptInfo *child_partially_grouped_rel;
 
+		/* Skip processing pruned partitions. */
+		if (child_input_rel == NULL)
+			continue;
+
 		/* Input child rel must have a path */
 		Assert(child_input_rel->pathlist != NIL);
 
diff --git a/src/backend/optimizer/plan/setrefs.c b/src/backend/optimizer/plan/setrefs.c
index 920a99d0d9..03c7b23974 100644
--- a/src/backend/optimizer/plan/setrefs.c
+++ b/src/backend/optimizer/plan/setrefs.c
@@ -325,6 +325,12 @@ add_rtes_to_flat_rtable(PlannerInfo *root, bool recursing)
 													  UPPERREL_FINAL, NULL)))
 					add_rtes_to_flat_rtable(rel->subroot, true);
 			}
+			/*
+			 * A NULL rel also means an unplanned subquery rte, so apply
+			 * flatten_unplanned_rtes.
+			 */
+			else
+				flatten_unplanned_rtes(glob, rte);
 		}
 		rti++;
 	}
diff --git a/src/backend/optimizer/prep/preptlist.c b/src/backend/optimizer/prep/preptlist.c
index 8603feef2b..0747403acd 100644
--- a/src/backend/optimizer/prep/preptlist.c
+++ b/src/backend/optimizer/prep/preptlist.c
@@ -65,9 +65,13 @@ static List *expand_targetlist(List *tlist, int command_type,
  *
  * As a side effect, if there's an ON CONFLICT UPDATE clause, its targetlist
  * is also preprocessed (and updated in-place).
+ *
+ * inheritance_expanded specifies whether inheritance tables are expanded
+ * as of calling this function.  Caller must specify it because that affects
+ * which row marking related junk columns get added to the targetlist.
  */
 List *
-preprocess_targetlist(PlannerInfo *root)
+preprocess_targetlist(PlannerInfo *root, bool inheritance_expanded)
 {
 	Query	   *parse = root->parse;
 	int			result_relation = parse->resultRelation;
@@ -134,6 +138,15 @@ preprocess_targetlist(PlannerInfo *root)
 		if (rc->rti != rc->prti)
 			continue;
 
+		/*
+		 * For inheritance parent row marks, we defer adding junk columns
+		 * until we've added child row marks, because some children might
+		 * require different row mark types which will change the parent row
+		 * mark's allMarkTypes fields.
+		 */
+		if (rc->isParent && !inheritance_expanded)
+			continue;
+
 		if (rc->allMarkTypes & ~(1 << ROW_MARK_COPY))
 		{
 			/* Need to fetch TID */
diff --git a/src/backend/optimizer/prep/prepunion.c b/src/backend/optimizer/prep/prepunion.c
index b320f8dce4..303554de34 100644
--- a/src/backend/optimizer/prep/prepunion.c
+++ b/src/backend/optimizer/prep/prepunion.c
@@ -39,15 +39,19 @@
 #include "miscadmin.h"
 #include "nodes/makefuncs.h"
 #include "nodes/nodeFuncs.h"
+#include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
 #include "optimizer/paths.h"
 #include "optimizer/planmain.h"
 #include "optimizer/planner.h"
 #include "optimizer/prep.h"
+#include "optimizer/restrictinfo.h"
 #include "optimizer/tlist.h"
+#include "optimizer/var.h"
 #include "parser/parse_coerce.h"
 #include "parser/parsetree.h"
+#include "partitioning/partprune.h"
 #include "utils/lsyscache.h"
 #include "utils/rel.h"
 #include "utils/selfuncs.h"
@@ -99,23 +103,26 @@ static List *generate_append_tlist(List *colTypes, List *colCollations,
 					  List *input_tlists,
 					  List *refnames_tlist);
 static List *generate_setop_grouplist(SetOperationStmt *op, List *targetlist);
+static void expand_append_rtentry(PlannerInfo *root, RelOptInfo *rel,
+					  RangeTblEntry *rte, Index rti);
 static void expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte,
-						 Index rti);
+						 Index rti, RelOptInfo *rel);
 static void expand_partitioned_rtentry(PlannerInfo *root,
 						   RangeTblEntry *parentrte,
-						   Index parentRTindex, Relation parentrel,
-						   PlanRowMark *top_parentrc, LOCKMODE lockmode,
-						   List **appinfos);
-static void expand_single_inheritance_child(PlannerInfo *root,
-								RangeTblEntry *parentrte,
-								Index parentRTindex, Relation parentrel,
-								PlanRowMark *top_parentrc, Relation childrel,
-								List **appinfos, RangeTblEntry **childrte_p,
-								Index *childRTindex_p);
-static void make_inh_translation_list(Relation oldrelation,
-						  Relation newrelation,
-						  Index newvarno,
-						  List **translated_vars);
+						   Index parentRTindex, RelOptInfo *parentrel);
+static RelOptInfo *add_inheritance_child_rel(PlannerInfo *root,
+						  RangeTblEntry *parentrte,
+						  Index parentRTindex, RelOptInfo *parentrel,
+						  PlanRowMark *top_parentrc, Relation childrel,
+						  RangeTblEntry **childrte_p, Index *childRTindex_p);
+static void make_inh_translation_list(TupleDesc old_tupdesc,
+						  TupleDesc new_tupdesc,
+						  Oid from_rel, Oid to_rel,
+						  Index newvarno, List **translated_vars);
+static RelOptInfo *build_append_child_rel(PlannerInfo *root,
+					   RelOptInfo *parent,
+					   Index childRTindex);
+static List *add_rowmark_junk_columns(PlannerInfo *root, PlanRowMark *rc);
 static Bitmapset *translate_col_privs(const Bitmapset *parent_privs,
 					List *translated_vars);
 static Node *adjust_appendrel_attrs_mutator(Node *node,
@@ -1472,33 +1479,134 @@ generate_setop_grouplist(SetOperationStmt *op, List *targetlist)
 void
 expand_inherited_tables(PlannerInfo *root)
 {
-	Index		nrtes;
+	int			orig_rtable_size;
 	Index		rti;
-	ListCell   *rl;
+
+	Assert(root->simple_rel_array_size > 0);
+	orig_rtable_size = root->simple_rel_array_size;
 
 	/*
-	 * expand_inherited_rtentry may add RTEs to parse->rtable. The function is
+	 * expand_append_rtentry may add RTEs to parse->rtable. The function is
 	 * expected to recursively handle any RTEs that it creates with inh=true.
 	 * So just scan as far as the original end of the rtable list.
 	 */
-	nrtes = list_length(root->parse->rtable);
-	rl = list_head(root->parse->rtable);
-	for (rti = 1; rti <= nrtes; rti++)
+	for (rti = 1; rti < orig_rtable_size; rti++)
 	{
-		RangeTblEntry *rte = (RangeTblEntry *) lfirst(rl);
+		RelOptInfo *brel = root->simple_rel_array[rti];
+		RangeTblEntry *rte = root->simple_rte_array[rti];
 
-		expand_inherited_rtentry(root, rte, rti);
-		rl = lnext(rl);
+		/* there may be empty slots corresponding to non-baserel RTEs */
+		if (brel == NULL)
+			continue;
+
+		if (rte->inh)
+			expand_append_rtentry(root, brel, rte, rti);
+	}
+}
+
+/*
+ * expand_append_rtentry
+ *		This initializes RelOptInfos for an appendrel's child relations, if
+ *		any
+ *
+ * 'rel' is the appendrel parent, whose range table entry ('rte') has been
+ * marked to require adding children.  An appendrel parent could either
+ * be a subquery (if we flattened UNION ALL query) or a table that's known
+ * to have inheritance children.  The latter consists of both regular
+ * inheritance parents and partitioned tables.
+ *
+ * For a subquery parent, there is not much to be done here because the
+ * children's RTEs are already present in the query, so we just initialize
+ * RelOptInfos for them.  Also, the AppendRelInfos for child subqueries
+ * have already been added.
+ *
+ * For tables, we need to add the children to the range table and initialize
+ * AppendRelInfos, RelOptInfos, and PlanRowMarks (if any) for them.  For
+ * a partitioned parent, we only add the children remaining after pruning.
+ * For regular inheritance parents, we find the children using
+ * find_all_inheritors and add all of them.
+ *
+ * If it turns out that there are no children, then we set rte->inh to false
+ * to let the caller know that only the parent table needs to be scanned.  The
+ * caller can accordingly switch to a non-Append path.  For a partitioned
+ * parent, that means an empty relation because parents themselves contain no
+ * data.
+ *
+ * For the regular inheritance case, the parent also gets another RTE with
+ * inh = false to represent it as an appendrel child.  The original RTE is
+ * considered to represent the whole inheritance set.
+ */
+static void
+expand_append_rtentry(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte,
+					  Index rti)
+{
+	Assert(rte->inh);
+	/* Inheritance parent (partitioned or not) or UNION ALL parent subquery. */
+	Assert(rte->rtekind == RTE_RELATION || rte->rtekind == RTE_SUBQUERY);
+
+	/*
+	 * UNION ALL children already got RTEs and AppendRelInfos, so just build
+	 * RelOptInfos and return.
+	 *
+	 * It might be a bit odd that this code is in this, because there is
+	 * nothing to expand really.
+	 */
+	if (rte->rtekind == RTE_SUBQUERY)
+	{
+		ListCell   *l;
+
+		/*
+		 * We don't need to use expand_planner_arrays in this case, because
+		 * no new child RTEs are created.  setup_simple_rel_arrays() and
+		 * setup_append_rel_array would've considered these child RTEs when
+		 * allocating space for various arrays.
+		 */
+		foreach(l, root->append_rel_list)
+		{
+			AppendRelInfo *appinfo = lfirst(l);
+			Index		childRTindex = appinfo->child_relid;
+
+			if (appinfo->parent_relid != rti)
+				continue;
+
+			Assert(childRTindex < root->simple_rel_array_size);
+			Assert(root->simple_rte_array[childRTindex] != NULL);
+
+			/*
+			 * We set the correct value of baserestricinfo and
+			 * baserestrict_min_security below.
+			 */
+			root->simple_rel_array[childRTindex] =
+				build_append_child_rel(root, rel, appinfo->child_relid);
+		}
+	}
+	else
+	{
+		Assert(rte->rtekind == RTE_RELATION);
+		Assert(has_subclass(rte->relid));
+
+		/*
+		 * The rewriter should already have obtained an appropriate lock on
+		 * each relation named in the query.  However, for each child relation
+		 * we add to the query, we must obtain an appropriate lock, because
+		 * this will be the first use of those relations in the
+		 * parse/rewrite/plan pipeline.  Child rels should use the same
+		 * lockmode as their parent.
+		 */
+		Assert(rte->rellockmode != NoLock);
+
+		if (rte->relkind == RELKIND_PARTITIONED_TABLE)
+			expand_partitioned_rtentry(root, rte, rti, rel);
+		else
+			expand_inherited_rtentry(root, rte, rti, rel);
 	}
 }
 
 /*
  * expand_inherited_rtentry
- *		Check whether a rangetable entry represents an inheritance set.
- *		If so, add entries for all the child tables to the query's
- *		rangetable, and build AppendRelInfo nodes for all the child tables
- *		and add them to root->append_rel_list.  If not, clear the entry's
- *		"inh" flag to prevent later code from looking for AppendRelInfos.
+ *		Add entries for all the child tables to the query's rangetable, and
+ *		build AppendRelInfo nodes for all the child tables and add them to
+ *		root->append_rel_list.
  *
  * Note that the original RTE is considered to represent the whole
  * inheritance set.  The first of the generated RTEs is an RTE for the same
@@ -1509,55 +1617,33 @@ expand_inherited_tables(PlannerInfo *root)
  * regular inheritance, a parent RTE must always have at least two associated
  * AppendRelInfos: one corresponding to the parent table as a simple member of
  * inheritance set and one or more corresponding to the actual children.
- * Since a partitioned table is not scanned, it might have only one associated
- * AppendRelInfo.
  */
 static void
-expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti)
+expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti,
+						 RelOptInfo *rel)
 {
 	Oid			parentOID;
 	PlanRowMark *oldrc;
-	Relation	oldrelation;
-	LOCKMODE	lockmode;
+	LOCKMODE	lockmode = rte->rellockmode;
 	List	   *inhOIDs;
 	ListCell   *l;
+	int			num_children;
+	int			num_children_added = 0;
 
-	/* Does RT entry allow inheritance? */
-	if (!rte->inh)
-		return;
-	/* Ignore any already-expanded UNION ALL nodes */
-	if (rte->rtekind != RTE_RELATION)
-	{
-		Assert(rte->rtekind == RTE_SUBQUERY);
-		return;
-	}
-	/* Fast path for common case of childless table */
+	Assert(rte->rtekind == RTE_RELATION);
+	Assert(lockmode != NoLock);
 	parentOID = rte->relid;
-	if (!has_subclass(parentOID))
-	{
-		/* Clear flag before returning */
-		rte->inh = false;
-		return;
-	}
-
-	/*
-	 * The rewriter should already have obtained an appropriate lock on each
-	 * relation named in the query.  However, for each child relation we add
-	 * to the query, we must obtain an appropriate lock, because this will be
-	 * the first use of those relations in the parse/rewrite/plan pipeline.
-	 * Child rels should use the same lockmode as their parent.
-	 */
-	lockmode = rte->rellockmode;
 
 	/* Scan for all members of inheritance set, acquire needed locks */
 	inhOIDs = find_all_inheritors(parentOID, lockmode, NULL);
 
 	/*
 	 * Check that there's at least one descendant, else treat as no-child
-	 * case.  This could happen despite above has_subclass() check, if table
-	 * once had a child but no longer does.
+	 * case.  This could happen despite has_subclass() check performed by
+	 * subquery_planner, if table once had a child but no longer does.
 	 */
-	if (list_length(inhOIDs) < 2)
+	num_children = list_length(inhOIDs);
+	if (num_children < 2)
 	{
 		/* Clear flag before returning */
 		rte->inh = false;
@@ -1565,216 +1651,219 @@ expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti)
 	}
 
 	/*
-	 * If parent relation is selected FOR UPDATE/SHARE, we need to mark its
-	 * PlanRowMark as isParent = true, and generate a new PlanRowMark for each
-	 * child.
+	 * If parent relation is selected FOR UPDATE/SHARE, preprocess_rowmarks
+	 * should've set isParent = true.  We'll generate a new PlanRowMark for
+	 * each child.
 	 */
 	oldrc = get_plan_rowmark(root->rowMarks, rti);
-	if (oldrc)
-		oldrc->isParent = true;
+	Assert(oldrc == NULL || oldrc->isParent);
 
 	/*
-	 * Must open the parent relation to examine its tupdesc.  We need not lock
-	 * it; we assume the rewriter already did.
+	 * Must expand PlannerInfo arrays by num_children before we can add
+	 * children.
 	 */
-	oldrelation = heap_open(parentOID, NoLock);
+	expand_planner_arrays(root, num_children);
 
-	/* Scan the inheritance set and expand it */
-	if (RelationGetPartitionDesc(oldrelation) != NULL)
+	foreach(l, inhOIDs)
 	{
-		Assert(rte->relkind == RELKIND_PARTITIONED_TABLE);
-
-		/*
-		 * If this table has partitions, recursively expand them in the order
-		 * in which they appear in the PartitionDesc.  While at it, also
-		 * extract the partition key columns of all the partitioned tables.
-		 */
-		expand_partitioned_rtentry(root, rte, rti, oldrelation, oldrc,
-								   lockmode, &root->append_rel_list);
-	}
-	else
-	{
-		List	   *appinfos = NIL;
+		Oid			childOID = lfirst_oid(l);
+		Relation	newrelation;
 		RangeTblEntry *childrte;
 		Index		childRTindex;
 
+		/* Already locked above. */
+		newrelation = heap_open(childOID, NoLock);
+
 		/*
-		 * This table has no partitions.  Expand any plain inheritance
-		 * children in the order the OIDs were returned by
-		 * find_all_inheritors.
+		 * It is possible that the parent table has children that are temp
+		 * tables of other backends.  We cannot safely access such tables
+		 * (because of buffering issues), and the best thing to do seems
+		 * to be to silently ignore them.
 		 */
-		foreach(l, inhOIDs)
+		if (RELATION_IS_OTHER_TEMP(newrelation))
 		{
-			Oid			childOID = lfirst_oid(l);
-			Relation	newrelation;
-
-			/* Open rel if needed; we already have required locks */
-			if (childOID != parentOID)
-				newrelation = heap_open(childOID, NoLock);
-			else
-				newrelation = oldrelation;
-
-			/*
-			 * It is possible that the parent table has children that are temp
-			 * tables of other backends.  We cannot safely access such tables
-			 * (because of buffering issues), and the best thing to do seems
-			 * to be to silently ignore them.
-			 */
-			if (childOID != parentOID && RELATION_IS_OTHER_TEMP(newrelation))
-			{
-				heap_close(newrelation, lockmode);
-				continue;
-			}
-
-			expand_single_inheritance_child(root, rte, rti, oldrelation, oldrc,
-											newrelation,
-											&appinfos, &childrte,
-											&childRTindex);
-
-			/* Close child relations, but keep locks */
-			if (childOID != parentOID)
-				heap_close(newrelation, NoLock);
+			heap_close(newrelation, lockmode);
+			continue;
 		}
 
-		/*
-		 * If all the children were temp tables, pretend it's a
-		 * non-inheritance situation; we don't need Append node in that case.
-		 * The duplicate RTE we added for the parent table is harmless, so we
-		 * don't bother to get rid of it; ditto for the useless PlanRowMark
-		 * node.
-		 */
-		if (list_length(appinfos) < 2)
-			rte->inh = false;
-		else
-			root->append_rel_list = list_concat(root->append_rel_list,
-												appinfos);
+		(void) add_inheritance_child_rel(root, rte, rti, rel, oldrc,
+										 newrelation, &childrte,
+										 &childRTindex);
+		Assert(childrte != NULL);
+		/* All regular inheritance children are leaf children. */
+		Assert(!childrte->inh);
+		Assert(childRTindex > 0);
 
+		/* Close child relations, but keep locks */
+		heap_close(newrelation, NoLock);
+		num_children_added++;
 	}
 
-	heap_close(oldrelation, NoLock);
+	/*
+	 * If all children, including the parent (as child rel), were
+	 * excluded, mark the parent rel as empty.  If all the children were temp
+	 * tables, pretend it's a non-inheritance situation; we don't need Append
+	 * node in that case.  The duplicate RTE we added for the parent table is
+	 * harmless, so we don't bother to get rid of it; ditto for the useless
+	 * PlanRowMark node.
+	 */
+	if (num_children_added == 0)
+		mark_dummy_rel(rel);
+	else if (num_children_added == 1)
+		rte->inh = false;
+
+	/*
+	 * Add junk columns needed by the row mark if any and also add the
+	 * relevant expressions to the root parent's reltarget.
+	 */
+	if (oldrc)
+	{
+		List   *tlist = add_rowmark_junk_columns(root, oldrc);
+
+		build_base_rel_tlists(root, tlist);
+	}
 }
 
 /*
  * expand_partitioned_rtentry
- *		Recursively expand an RTE for a partitioned table.
+ *		Prunes unnecessary partitions of a partitioned table and adds
+ *		remaining ones to the Query and the PlannerInfo
+ *
+ * Partitions are added to the query in order in which they are found in
+ * the parent's PartitionDesc.
+ *
+ * Note: even though only the unpruned partitions will be added to the
+ * resulting plan, this still locks *all* partitions via find_all_inheritors
+ * when this function is called for the root partitioned table.
  */
 static void
 expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
-						   Index parentRTindex, Relation parentrel,
-						   PlanRowMark *top_parentrc, LOCKMODE lockmode,
-						   List **appinfos)
+						   Index parentRTindex, RelOptInfo *parentrel)
 {
+	LOCKMODE	lockmode = parentrte->rellockmode;
+	PlanRowMark *rootrc = NULL;
 	int			i;
-	RangeTblEntry *childrte;
-	Index		childRTindex;
-	PartitionDesc partdesc = RelationGetPartitionDesc(parentrel);
+	Bitmapset  *partindexes;
+	Index		rootParentRTindex = parentrel->inh_root_parent > 0 ?
+									parentrel->inh_root_parent :
+									parentRTindex;
 
-	check_stack_depth();
-
-	/* A partitioned table should always have a partition descriptor. */
-	Assert(partdesc);
-
-	Assert(parentrte->inh);
+	/* If root partitioned table, lock *all* partitions in the tree. */
+	if (parentRTindex == rootParentRTindex)
+		(void) find_all_inheritors(parentrte->relid, lockmode, NULL);
 
 	/*
-	 * Note down whether any partition key cols are being updated. Though it's
-	 * the root partitioned table's updatedCols we are interested in, we
-	 * instead use parentrte to get the updatedCols. This is convenient
-	 * because parentrte already has the root partrel's updatedCols translated
-	 * to match the attribute ordering of parentrel.
+	 * Initialize partitioned_child_rels to contain this RT index.
+	 *
+	 * Note that during the set_append_rel_pathlist() phase, values of the
+	 * indexes of partitioned relations that appear down in the tree will be
+	 * bubbled up into root parent's list so that when we've created Paths for
+	 * all the children, the root table's list will contain all such indexes.
 	 */
-	if (!root->partColsUpdated)
-		root->partColsUpdated =
-			has_partition_attrs(parentrel, parentrte->updatedCols, NULL);
+	parentrel->partitioned_child_rels = list_make1_int(parentRTindex);
 
-	/* First expand the partitioned table itself. */
-	expand_single_inheritance_child(root, parentrte, parentRTindex, parentrel,
-									top_parentrc, parentrel,
-									appinfos, &childrte, &childRTindex);
+	/* Perform pruning. */
+	partindexes = prune_append_rel_partitions(parentrel);
+
+	/* Must expand PlannerInfo arrays before we can add children. */
+	expand_planner_arrays(root, bms_num_members(partindexes));
 
 	/*
-	 * If the partitioned table has no partitions, treat this as the
-	 * non-inheritance case.
+	 * For partitioned tables, we also store the partition RelOptInfo
+	 * pointers in the parent's RelOptInfo.
 	 */
-	if (partdesc->nparts == 0)
-	{
-		parentrte->inh = false;
-		return;
-	}
+	parentrel->part_rels = (RelOptInfo **) palloc0(sizeof(RelOptInfo *) *
+												   parentrel->nparts);
 
-	for (i = 0; i < partdesc->nparts; i++)
+	rootrc = get_plan_rowmark(root->rowMarks, rootParentRTindex);
+	Assert(rootrc == NULL || rootrc->isParent);
+	i = -1;
+	while ((i = bms_next_member(partindexes, i)) >= 0)
 	{
-		Oid			childOID = partdesc->oids[i];
-		Relation	childrel;
+		Oid		childOID = parentrel->part_oids[i];
+		Relation	newrelation;
+		RelOptInfo *childrel;
+		RangeTblEntry *childrte;
+		Index		childRTindex;
 
-		/* Open rel; we already have required locks */
-		childrel = heap_open(childOID, NoLock);
+		/* Already locked above. */
+		newrelation = heap_open(childOID, NoLock);
+		Assert(!RELATION_IS_OTHER_TEMP(newrelation));
 
 		/*
-		 * Temporary partitions belonging to other sessions should have been
-		 * disallowed at definition, but for paranoia's sake, let's double
-		 * check.
+		 * A partitioned child table with 0 children is a dummy rel, so don't
+		 * bother creating planner objects for it.
 		 */
-		if (RELATION_IS_OTHER_TEMP(childrel))
-			elog(ERROR, "temporary relation from another session found as partition");
+		if (newrelation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE &&
+			RelationGetPartitionDesc(newrelation)->nparts == 0)
+		{
+			heap_close(newrelation, NoLock);
+			continue;
+		}
 
-		expand_single_inheritance_child(root, parentrte, parentRTindex,
-										parentrel, top_parentrc, childrel,
-										appinfos, &childrte, &childRTindex);
+		childrel = add_inheritance_child_rel(root, parentrte, parentRTindex,
+											 parentrel, rootrc, newrelation,
+											 &childrte, &childRTindex);
+		Assert(childrel != NULL);
+		parentrel->part_rels[i] = childrel;
 
-		/* If this child is itself partitioned, recurse */
-		if (childrel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
+		/* Close child relations, but keep locks */
+		heap_close(newrelation, NoLock);
+
+		/* If the child is partitioned itself, expand it too. */
+		if (childrel->part_scheme)
+		{
+			Assert(childrte->inh);
 			expand_partitioned_rtentry(root, childrte, childRTindex,
-									   childrel, top_parentrc, lockmode,
-									   appinfos);
+									   childrel);
+		}
+	}
 
-		/* Close child relation, but keep locks */
-		heap_close(childrel, NoLock);
+	/*
+	 * Add junk columns needed by the row mark if any and also add the
+	 * relevant expressions to the root parent's reltarget.
+	 */
+	if (rootrc)
+	{
+		List   *tlist = add_rowmark_junk_columns(root, rootrc);
+
+		build_base_rel_tlists(root, tlist);
 	}
 }
 
 /*
- * expand_single_inheritance_child
- *		Build a RangeTblEntry and an AppendRelInfo, if appropriate, plus
- *		maybe a PlanRowMark.
+ * add_inheritance_child_rel
+ *		Build a RangeTblEntry, an AppendRelInfo, a PlanRowMark, and finally
+ *		a RelOptInfo for an inheritance child relation.
  *
- * We now expand the partition hierarchy level by level, creating a
- * corresponding hierarchy of AppendRelInfos and RelOptInfos, where each
- * partitioned descendant acts as a parent of its immediate partitions.
- * (This is a difference from what older versions of PostgreSQL did and what
- * is still done in the case of table inheritance for unpartitioned tables,
- * where the hierarchy is flattened during RTE expansion.)
+ * The return value is the RelOptInfo that's added.
  *
  * PlanRowMarks still carry the top-parent's RTI, and the top-parent's
  * allMarkTypes field still accumulates values from all descendents.
  *
  * "parentrte" and "parentRTindex" are immediate parent's RTE and
  * RTI. "top_parentrc" is top parent's PlanRowMark.
- *
- * The child RangeTblEntry and its RTI are returned in "childrte_p" and
- * "childRTindex_p" resp.
  */
-static void
-expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte,
-								Index parentRTindex, Relation parentrel,
-								PlanRowMark *top_parentrc, Relation childrel,
-								List **appinfos, RangeTblEntry **childrte_p,
-								Index *childRTindex_p)
+static RelOptInfo *
+add_inheritance_child_rel(PlannerInfo *root, RangeTblEntry *parentrte,
+						  Index parentRTindex, RelOptInfo *parentrel,
+						  PlanRowMark *top_parentrc, Relation childrel,
+						  RangeTblEntry **childrte_p, Index *childRTindex_p)
 {
 	Query	   *parse = root->parse;
-	Oid			parentOID = RelationGetRelid(parentrel);
 	Oid			childOID = RelationGetRelid(childrel);
 	RangeTblEntry *childrte;
 	Index		childRTindex;
 	AppendRelInfo *appinfo;
+	RelOptInfo *childrelopt;
 
 	/*
 	 * Build an RTE for the child, and attach to query's rangetable list. We
 	 * copy most fields of the parent's RTE, but replace relation OID and
-	 * relkind, and set inh = false.  Also, set requiredPerms to zero since
-	 * all required permissions checks are done on the original RTE. Likewise,
-	 * set the child's securityQuals to empty, because we only want to apply
-	 * the parent's RLS conditions regardless of what RLS properties
+	 * relkind, and set inh appropriately.  Also, set requiredPerms to zero
+	 * since all required permissions checks are done on the original RTE.
+	 * Likewise, set the child's securityQuals to empty, because we only want
+	 * to apply the parent's RLS conditions regardless of what RLS properties
 	 * individual children may have.  (This is an intentional choice to make
 	 * inherited RLS work like regular permissions checks.) The parent
 	 * securityQuals will be propagated to children along with other base
@@ -1784,55 +1873,42 @@ expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte,
 	*childrte_p = childrte;
 	childrte->relid = childOID;
 	childrte->relkind = childrel->rd_rel->relkind;
-	/* A partitioned child will need to be expanded further. */
-	if (childOID != parentOID &&
-		childrte->relkind == RELKIND_PARTITIONED_TABLE)
-		childrte->inh = true;
-	else
-		childrte->inh = false;
+	/*
+	 * A partitioned child will need to be expanded as an append parent
+	 * itself, so set its inh to true.
+	 */
+	childrte->inh = (childrte->relkind == RELKIND_PARTITIONED_TABLE);
 	childrte->requiredPerms = 0;
 	childrte->securityQuals = NIL;
 	parse->rtable = lappend(parse->rtable, childrte);
 	childRTindex = list_length(parse->rtable);
 	*childRTindex_p = childRTindex;
 
-	/*
-	 * We need an AppendRelInfo if paths will be built for the child RTE. If
-	 * childrte->inh is true, then we'll always need to generate append paths
-	 * for it.  If childrte->inh is false, we must scan it if it's not a
-	 * partitioned table; but if it is a partitioned table, then it never has
-	 * any data of its own and need not be scanned.
-	 */
-	if (childrte->relkind != RELKIND_PARTITIONED_TABLE || childrte->inh)
-	{
-		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->translated_vars);
-		appinfo->parent_reloid = parentOID;
-		*appinfos = lappend(*appinfos, appinfo);
+	/* Create an AppendRelInfo and add it to planner's global list. */
+	appinfo = make_append_rel_info(parentrel, parentrte,
+								   childrel->rd_att,
+								   childOID,
+								   childrel->rd_rel->reltype,
+								   childRTindex);
+	root->append_rel_list = lappend(root->append_rel_list, appinfo);
 
-		/*
-		 * Translate the column permissions bitmaps to the child's attnums (we
-		 * have to build the translated_vars list before we can do this). But
-		 * if this is the parent table, leave copyObject's result alone.
-		 *
-		 * Note: we need to do this even though the executor won't run any
-		 * permissions checks on the child RTE.  The insertedCols/updatedCols
-		 * bitmaps may be examined for trigger-firing purposes.
-		 */
-		if (childOID != parentOID)
-		{
-			childrte->selectedCols = translate_col_privs(parentrte->selectedCols,
-														 appinfo->translated_vars);
-			childrte->insertedCols = translate_col_privs(parentrte->insertedCols,
-														 appinfo->translated_vars);
-			childrte->updatedCols = translate_col_privs(parentrte->updatedCols,
-														appinfo->translated_vars);
-		}
+	/*
+	 * Translate the column permissions bitmaps to the child's attnums (we
+	 * have to build the translated_vars list before we can do this). But
+	 * if this is the parent table, leave copyObject's result alone.
+	 *
+	 * Note: we need to do this even though the executor won't run any
+	 * permissions checks on the child RTE.  The insertedCols/updatedCols
+	 * bitmaps may be examined for trigger-firing purposes.
+	 */
+	if (childrte->relid != parentrte->relid)
+	{
+		childrte->selectedCols = translate_col_privs(parentrte->selectedCols,
+													 appinfo->translated_vars);
+		childrte->insertedCols = translate_col_privs(parentrte->insertedCols,
+													 appinfo->translated_vars);
+		childrte->updatedCols = translate_col_privs(parentrte->updatedCols,
+													appinfo->translated_vars);
 	}
 
 	/*
@@ -1864,6 +1940,24 @@ expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte,
 
 		root->rowMarks = lappend(root->rowMarks, childrc);
 	}
+
+	/*
+	 * Add the RelOptInfo.  Even though we may not really scan this relation
+	 * for reasons such as contradictory quals, we still need to create one,
+	 * because for every RTE in the query's range table, there must be an
+	 * accompanying RelOptInfo.
+	 */
+
+	/* First, store the RTE and appinfos into planner arrays. */
+	Assert(root->simple_rte_array[childRTindex] == NULL);
+	root->simple_rte_array[childRTindex] = childrte;
+	Assert(root->append_rel_array[childRTindex] == NULL);
+	root->append_rel_array[childRTindex] = appinfo;
+
+	childrelopt = build_append_child_rel(root, parentrel, childRTindex);
+	Assert(childrelopt != NULL);
+
+	return childrelopt;
 }
 
 /*
@@ -1874,14 +1968,11 @@ expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte,
  * For paranoia's sake, we match type/collation as well as attribute name.
  */
 static void
-make_inh_translation_list(Relation oldrelation, Relation newrelation,
-						  Index newvarno,
-						  List **translated_vars)
+make_inh_translation_list(TupleDesc old_tupdesc, TupleDesc new_tupdesc,
+						  Oid from_rel, Oid to_rel,
+						  Index newvarno, List **translated_vars)
 {
 	List	   *vars = NIL;
-	TupleDesc	old_tupdesc = RelationGetDescr(oldrelation);
-	TupleDesc	new_tupdesc = RelationGetDescr(newrelation);
-	Oid			new_relid = RelationGetRelid(newrelation);
 	int			oldnatts = old_tupdesc->natts;
 	int			newnatts = new_tupdesc->natts;
 	int			old_attno;
@@ -1911,7 +2002,7 @@ make_inh_translation_list(Relation oldrelation, Relation newrelation,
 		 * When we are generating the "translation list" for the parent table
 		 * of an inheritance set, no need to search for matches.
 		 */
-		if (oldrelation == newrelation)
+		if (from_rel == to_rel)
 		{
 			vars = lappend(vars, makeVar(newvarno,
 										 (AttrNumber) (old_attno + 1),
@@ -1937,10 +2028,10 @@ make_inh_translation_list(Relation oldrelation, Relation newrelation,
 		{
 			HeapTuple	newtup;
 
-			newtup = SearchSysCacheAttName(new_relid, attname);
+			newtup = SearchSysCacheAttName(to_rel, attname);
 			if (!newtup)
 				elog(ERROR, "could not find inherited attribute \"%s\" of relation \"%s\"",
-					 attname, RelationGetRelationName(newrelation));
+					 attname, get_rel_name(to_rel));
 			new_attno = ((Form_pg_attribute) GETSTRUCT(newtup))->attnum - 1;
 			ReleaseSysCache(newtup);
 
@@ -1950,10 +2041,10 @@ make_inh_translation_list(Relation oldrelation, Relation newrelation,
 		/* Found it, check type and collation match */
 		if (atttypid != att->atttypid || atttypmod != att->atttypmod)
 			elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's type",
-				 attname, RelationGetRelationName(newrelation));
+				 attname, get_rel_name(to_rel));
 		if (attcollation != att->attcollation)
 			elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's collation",
-				 attname, RelationGetRelationName(newrelation));
+				 attname, get_rel_name(to_rel));
 
 		vars = lappend(vars, makeVar(newvarno,
 									 (AttrNumber) (new_attno + 1),
@@ -2020,6 +2111,255 @@ translate_col_privs(const Bitmapset *parent_privs,
 }
 
 /*
+ *	build_append_child_rel
+ *		Build a RelOptInfo for child relation of an append rel
+ *
+ * After creating the RelOptInfo for the given child RT index, it goes on to
+ * initialize some of its fields based on the parent RelOptInfo.
+ *
+ * If the quals in baserestrictinfo turn out to be self-contradictory,
+ * RelOptInfo is marked dummy before returning.
+ */
+static RelOptInfo *
+build_append_child_rel(PlannerInfo *root,
+					   RelOptInfo *parent,
+					   Index childRTindex)
+{
+	RelOptInfo *childrel;
+	RangeTblEntry *childRTE = root->simple_rte_array[childRTindex];
+	AppendRelInfo *appinfo = root->append_rel_array[childRTindex];
+	List	   *childquals;
+	ListCell   *lc;
+	bool		have_const_false_cq;
+	Index		cq_min_security;
+
+	/* Build the RelOptInfo. */
+	childrel = build_simple_rel(root, childRTindex, parent);
+
+	/*
+	 * Propagate lateral_relids and lateral_referencers from appendrel
+	 * parent rels to their child rels.  We intentionally give each child rel
+	 * the same minimum parameterization, even though it's quite possible that
+	 * some don't reference all the lateral rels.  This is because any append
+	 * path for the parent will have to have the same parameterization for
+	 * every child anyway, and there's no value in forcing extra
+	 * reparameterize_path() calls.  Similarly, a lateral reference to the
+	 * parent prevents use of otherwise-movable join rels for each child.
+	 */
+	childrel->direct_lateral_relids = parent->direct_lateral_relids;
+	childrel->lateral_relids = parent->lateral_relids;
+	childrel->lateral_referencers = parent->lateral_referencers;
+
+	/*
+	 * We have to copy the parent's quals to the child, with appropriate
+	 * substitution of variables.  However, only the baserestrictinfo
+	 * quals are needed before we can check for constraint exclusion; so
+	 * do that first and then check to see if we can disregard this child.
+	 *
+	 * The child rel's targetlist might contain non-Var expressions, which
+	 * means that substitution into the quals could produce opportunities
+	 * for const-simplification, and perhaps even pseudoconstant quals.
+	 * Therefore, transform each RestrictInfo separately to see if it
+	 * reduces to a constant or pseudoconstant.  (We must process them
+	 * separately to keep track of the security level of each qual.)
+	 */
+	childquals = false;
+	cq_min_security = UINT_MAX;
+	have_const_false_cq = false;
+	foreach(lc, parent->baserestrictinfo)
+	{
+		RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
+		Node	   *childqual = (Node *) rinfo->clause;
+		ListCell   *lc2;
+
+		Assert(IsA(rinfo, RestrictInfo));
+		childqual = adjust_appendrel_attrs(root, childqual,
+										   1, &appinfo);
+		childqual = eval_const_expressions(root, childqual);
+		/* check for flat-out constant */
+		if (childqual && IsA(childqual, Const))
+		{
+			if (((Const *) childqual)->constisnull ||
+				!DatumGetBool(((Const *) childqual)->constvalue))
+			{
+				/* Restriction reduces to constant FALSE or NULL */
+				have_const_false_cq = true;
+				break;
+			}
+			/* Restriction reduces to constant TRUE, so drop it */
+			continue;
+		}
+		/* might have gotten an AND clause, if so flatten it */
+		foreach(lc2, make_ands_implicit((Expr *) childqual))
+		{
+			Node	   *onecq = (Node *) lfirst(lc2);
+			bool		pseudoconstant;
+
+			/* check for pseudoconstant (no Vars or volatile functions) */
+			pseudoconstant =
+					!contain_vars_of_level(onecq, 0) &&
+					!contain_volatile_functions(onecq);
+			if (pseudoconstant)
+			{
+				/* tell createplan.c to check for gating quals */
+				root->hasPseudoConstantQuals = true;
+			}
+			/* reconstitute RestrictInfo with appropriate properties */
+			childquals = lappend(childquals,
+								 make_restrictinfo((Expr *) onecq,
+												   rinfo->is_pushed_down,
+												   rinfo->outerjoin_delayed,
+												   pseudoconstant,
+												   rinfo->security_level,
+												   NULL, NULL, NULL));
+			cq_min_security = Min(cq_min_security, rinfo->security_level);
+		}
+	}
+
+	/*
+	 * In addition to the quals inherited from the parent, we might
+	 * have securityQuals associated with this particular child node.
+	 * (Currently this can only happen in appendrels originating from
+	 * UNION ALL; inheritance child tables don't have their own
+	 * securityQuals.)	Pull any such securityQuals up into the
+	 * baserestrictinfo for the child.  This is similar to
+	 * process_security_barrier_quals() for the parent rel, except
+	 * that we can't make any general deductions from such quals,
+	 * since they don't hold for the whole appendrel.
+	 */
+	if (childRTE->securityQuals)
+	{
+		Index		security_level = 0;
+
+		foreach(lc, childRTE->securityQuals)
+		{
+			List	   *qualset = (List *) lfirst(lc);
+			ListCell   *lc2;
+
+			foreach(lc2, qualset)
+			{
+				Expr	   *qual = (Expr *) lfirst(lc2);
+
+				/*
+				 * not likely that we'd see constants here, so no
+				 * check
+				 */
+				childquals = lappend(childquals,
+									 make_restrictinfo(qual,
+													   true,
+													   false,
+													   false,
+													   security_level,
+													   NULL, NULL,
+													   NULL));
+				cq_min_security = Min(cq_min_security, security_level);
+			}
+			security_level++;
+		}
+		Assert(security_level <= root->qual_security_level);
+	}
+
+	/* Set child's version of baserestrictinfo. */
+	childrel->baserestrictinfo = childquals;
+	childrel->baserestrict_min_security = cq_min_security;
+
+	if (have_const_false_cq)
+	{
+		/*
+		 * Some restriction clause reduced to constant FALSE or NULL after
+		 * substitution, so this child need not be scanned.
+		 */
+		set_dummy_rel_pathlist(childrel);
+	}
+
+	return childrel;
+}
+
+/*
+ * add_rowmark_junk_columns
+ * 		Add necessary junk columns for rowmarked inheritance parent rel.
+ *
+ * These values are needed for locking of rels selected FOR UPDATE/SHARE, and
+ * to do EvalPlanQual rechecking.  See comments for PlanRowMark in
+ * plannodes.h.
+ */
+static List *
+add_rowmark_junk_columns(PlannerInfo *root, PlanRowMark *rc)
+{
+	List   *tlist = root->processed_tlist;
+	Var		   *var;
+	char		resname[32];
+	TargetEntry *tle;
+
+	if (rc->allMarkTypes & ~(1 << ROW_MARK_COPY))
+	{
+		/* Need to fetch TID */
+		var = makeVar(rc->rti,
+					  SelfItemPointerAttributeNumber,
+					  TIDOID,
+					  -1,
+					  InvalidOid,
+					  0);
+		snprintf(resname, sizeof(resname), "ctid%u", rc->rowmarkId);
+		tle = makeTargetEntry((Expr *) var,
+							  list_length(tlist) + 1,
+							  pstrdup(resname),
+							  true);
+		tlist = lappend(tlist, tle);
+	}
+	if (rc->allMarkTypes & (1 << ROW_MARK_COPY))
+	{
+		/* Need the whole row as a junk var */
+		var = makeWholeRowVar(root->simple_rte_array[rc->rti],
+							  rc->rti,
+							  0,
+							  false);
+		snprintf(resname, sizeof(resname), "wholerow%u", rc->rowmarkId);
+		tle = makeTargetEntry((Expr *) var,
+							  list_length(tlist) + 1,
+							  pstrdup(resname),
+							  true);
+		tlist = lappend(tlist, tle);
+	}
+
+	/* For inheritance cases, always fetch the tableoid too. */
+	var = makeVar(rc->rti,
+				  TableOidAttributeNumber,
+				  OIDOID,
+				  -1,
+				  InvalidOid,
+				  0);
+	snprintf(resname, sizeof(resname), "tableoid%u", rc->rowmarkId);
+	tle = makeTargetEntry((Expr *) var,
+						  list_length(tlist) + 1,
+						  pstrdup(resname),
+						  true);
+	tlist = lappend(tlist, tle);
+
+	return tlist;
+}
+
+AppendRelInfo *
+make_append_rel_info(RelOptInfo *parentrel, RangeTblEntry *parentrte,
+					 TupleDesc childdesc, Oid childoid, Oid childreltype,
+					 Index childRTindex)
+{
+	AppendRelInfo  *appinfo = makeNode(AppendRelInfo);
+
+	appinfo->parent_relid = parentrel->relid;
+	appinfo->child_relid = childRTindex;
+	appinfo->parent_reltype = parentrel->reltype;
+	appinfo->child_reltype = childreltype;
+	make_inh_translation_list(parentrel->tupdesc, childdesc,
+							  parentrte->relid, childoid,
+							  childRTindex,
+							  &appinfo->translated_vars);
+	appinfo->parent_reloid = parentrte->relid;
+
+	return appinfo;
+}
+
+/*
  * adjust_appendrel_attrs
  *	  Copy the specified query or expression and translate Vars referring to a
  *	  parent rel to refer to the corresponding child rel instead.  We also
diff --git a/src/backend/optimizer/util/Makefile b/src/backend/optimizer/util/Makefile
index c54d0a690d..da9ccf32b4 100644
--- a/src/backend/optimizer/util/Makefile
+++ b/src/backend/optimizer/util/Makefile
@@ -13,6 +13,6 @@ top_builddir = ../../../..
 include $(top_builddir)/src/Makefile.global
 
 OBJS = clauses.o joininfo.o orclauses.o pathnode.o placeholder.o \
-       plancat.o predtest.o relnode.o restrictinfo.o tlist.o var.o
+	   plancat.o predtest.o relnode.o restrictinfo.o tlist.o var.o
 
 include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/optimizer/util/plancat.c b/src/backend/optimizer/util/plancat.c
index a0fed5be42..bf441741e0 100644
--- a/src/backend/optimizer/util/plancat.c
+++ b/src/backend/optimizer/util/plancat.c
@@ -106,7 +106,7 @@ static void set_baserel_partition_key_exprs(Relation relation,
  */
 void
 get_relation_info(PlannerInfo *root, Oid relationObjectId, bool inhparent,
-				  RelOptInfo *rel)
+				  Bitmapset *updatedCols, RelOptInfo *rel)
 {
 	Index		varno = rel->relid;
 	Relation	relation;
@@ -444,11 +444,31 @@ get_relation_info(PlannerInfo *root, Oid relationObjectId, bool inhparent,
 	get_relation_foreign_keys(root, rel, relation, inhparent);
 
 	/*
-	 * Collect info about relation's partitioning scheme, if any. Only
-	 * inheritance parents may be partitioned.
+	 * Collect some additional information for inheritance parents.
 	 */
-	if (inhparent && relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
-		set_relation_partition_info(root, rel, relation);
+	if (inhparent)
+	{
+		/*
+		 * We'll need the TupleDesc when initializing the child relation.
+		 * A copy is being made because concurrent changes might drop
+		 * the relcache entry.  That's possible because ALTER TABLE
+		 * child_table NO INHERIT parent_table only requires an
+		 * AccessShareLock on parent_table.
+		 */
+		rel->tupdesc = CreateTupleDescCopy(RelationGetDescr(relation));
+		rel->reltype = RelationGetForm(relation)->reltype;
+
+		/*
+		 * If partitioned, also save the information of partitioning scheme,
+		 * and whether the query updates any of the partition key columns.
+		 */
+		if (relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
+		{
+			set_relation_partition_info(root, rel, relation);
+			root->partColsUpdated |= has_partition_attrs(relation, updatedCols,
+														 NULL);
+		}
+	}
 
 	heap_close(relation, NoLock);
 
@@ -1853,16 +1873,20 @@ set_relation_partition_info(PlannerInfo *root, RelOptInfo *rel,
 							Relation relation)
 {
 	PartitionDesc partdesc;
-	PartitionKey partkey;
 
 	Assert(relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE);
 
 	partdesc = RelationGetPartitionDesc(relation);
-	partkey = RelationGetPartitionKey(relation);
 	rel->part_scheme = find_partition_scheme(root, relation);
 	Assert(partdesc != NULL && rel->part_scheme != NULL);
-	rel->boundinfo = partition_bounds_copy(partdesc->boundinfo, partkey);
 	rel->nparts = partdesc->nparts;
+
+	/*
+	 * Since we must've taken a lock on the table, it's okay to simply copy
+	 * the pointers to relcache data here.
+	 */
+	rel->part_oids = partdesc->oids;
+	rel->boundinfo = partdesc->boundinfo;
 	set_baserel_partition_key_exprs(relation, rel);
 	rel->partition_qual = RelationGetPartitionQual(relation);
 }
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index 29ba19349f..c23db9d78d 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -130,6 +130,37 @@ setup_append_rel_array(PlannerInfo *root)
 	}
 }
 
+/* Expand the PlannerInfo arrays by add_size members and zero-init it. */
+void
+expand_planner_arrays(PlannerInfo *root, int add_size)
+{
+	int		new_size = root->simple_rel_array_size + add_size;
+
+	root->simple_rte_array = (RangeTblEntry **)
+							repalloc(root->simple_rte_array,
+									 sizeof(RangeTblEntry *) * new_size);
+	root->simple_rel_array = (RelOptInfo **)
+								repalloc(root->simple_rel_array,
+										 sizeof(RelOptInfo *) * new_size);
+	if (root->append_rel_array)
+		root->append_rel_array = (AppendRelInfo **)
+									repalloc(root->append_rel_array,
+									 sizeof(AppendRelInfo *) * new_size);
+	else
+		root->append_rel_array = (AppendRelInfo **)
+									palloc0(sizeof(AppendRelInfo *) *
+											new_size);
+
+	/* Set the contents of just allocated memory to 0. */
+	MemSet(root->simple_rte_array + root->simple_rel_array_size,
+		   0, sizeof(RangeTblEntry *) * add_size);
+	MemSet(root->simple_rel_array + root->simple_rel_array_size,
+		   0, sizeof(RelOptInfo *) * add_size);
+	MemSet(root->append_rel_array + root->simple_rel_array_size,
+		   0, sizeof(AppendRelInfo *) * add_size);
+	root->simple_rel_array_size = new_size;
+}
+
 /*
  * build_simple_rel
  *	  Construct a new RelOptInfo for a base relation or 'other' relation.
@@ -238,7 +269,8 @@ build_simple_rel(PlannerInfo *root, int relid, RelOptInfo *parent)
 	{
 		case RTE_RELATION:
 			/* Table --- retrieve statistics from the system catalogs */
-			get_relation_info(root, rte->relid, rte->inh, rel);
+			get_relation_info(root, rte->relid, rte->inh, rte->updatedCols,
+							  rel);
 			break;
 		case RTE_SUBQUERY:
 		case RTE_FUNCTION:
@@ -279,52 +311,6 @@ build_simple_rel(PlannerInfo *root, int relid, RelOptInfo *parent)
 		root->qual_security_level = Max(root->qual_security_level,
 										list_length(rte->securityQuals));
 
-	/*
-	 * If this rel is an appendrel parent, recurse to build "other rel"
-	 * RelOptInfos for its children.  They are "other rels" because they are
-	 * not in the main join tree, but we will need RelOptInfos to plan access
-	 * to them.
-	 */
-	if (rte->inh)
-	{
-		ListCell   *l;
-		int			nparts = rel->nparts;
-		int			cnt_parts = 0;
-
-		if (nparts > 0)
-			rel->part_rels = (RelOptInfo **)
-				palloc(sizeof(RelOptInfo *) * nparts);
-
-		foreach(l, root->append_rel_list)
-		{
-			AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(l);
-			RelOptInfo *childrel;
-
-			/* append_rel_list contains all append rels; ignore others */
-			if (appinfo->parent_relid != relid)
-				continue;
-
-			childrel = build_simple_rel(root, appinfo->child_relid,
-										rel);
-
-			/* Nothing more to do for an unpartitioned table. */
-			if (!rel->part_scheme)
-				continue;
-
-			/*
-			 * The order of partition OIDs in append_rel_list is the same as
-			 * the order in the PartitionDesc, so the order of part_rels will
-			 * also match the PartitionDesc.  See expand_partitioned_rtentry.
-			 */
-			Assert(cnt_parts < nparts);
-			rel->part_rels[cnt_parts] = childrel;
-			cnt_parts++;
-		}
-
-		/* We should have seen all the child partitions. */
-		Assert(cnt_parts == nparts);
-	}
-
 	return rel;
 }
 
diff --git a/src/backend/partitioning/partprune.c b/src/backend/partitioning/partprune.c
index 35c87535d3..fcf8d6032c 100644
--- a/src/backend/partitioning/partprune.c
+++ b/src/backend/partitioning/partprune.c
@@ -45,6 +45,7 @@
 #include "nodes/makefuncs.h"
 #include "nodes/nodeFuncs.h"
 #include "optimizer/clauses.h"
+#include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
 #include "optimizer/planner.h"
 #include "optimizer/predtest.h"
@@ -436,17 +437,23 @@ make_partitionedrel_pruneinfo(PlannerInfo *root, RelOptInfo *parentrel,
 		 * is, not pruned already).
 		 */
 		subplan_map = (int *) palloc(nparts * sizeof(int));
+		memset(subplan_map, -1, nparts * sizeof(int));
 		subpart_map = (int *) palloc(nparts * sizeof(int));
+		memset(subpart_map, -1, nparts * sizeof(int));
 		present_parts = NULL;
 
 		for (i = 0; i < nparts; i++)
 		{
 			RelOptInfo *partrel = subpart->part_rels[i];
-			int			subplanidx = relid_subplan_map[partrel->relid] - 1;
-			int			subpartidx = relid_subpart_map[partrel->relid] - 1;
+			int			subplanidx;
+			int			subpartidx;
 
-			subplan_map[i] = subplanidx;
-			subpart_map[i] = subpartidx;
+			/* Skip processing pruned partitions. */
+			if (partrel == NULL)
+				continue;
+
+			subplan_map[i] = subplanidx = relid_subplan_map[partrel->relid] - 1;
+			subpart_map[i] = subpartidx = relid_subpart_map[partrel->relid] - 1;
 			if (subplanidx >= 0)
 			{
 				present_parts = bms_add_member(present_parts, i);
@@ -540,23 +547,20 @@ gen_partprune_steps(RelOptInfo *rel, List *clauses, bool *contradictory)
 
 /*
  * prune_append_rel_partitions
- *		Returns RT indexes of the minimum set of child partitions which must
- *		be scanned to satisfy rel's baserestrictinfo quals.
+ *		Returns indexes into rel->part_rels of the minimum set of child
+ *		partitions which must be scanned to satisfy rel's baserestrictinfo
+ *		quals.
  *
  * Callers must ensure that 'rel' is a partitioned table.
  */
-Relids
+Bitmapset *
 prune_append_rel_partitions(RelOptInfo *rel)
 {
-	Relids		result;
 	List	   *clauses = rel->baserestrictinfo;
 	List	   *pruning_steps;
 	bool		contradictory;
 	PartitionPruneContext context;
-	Bitmapset  *partindexes;
-	int			i;
 
-	Assert(clauses != NIL);
 	Assert(rel->part_scheme != NULL);
 
 	/* If there are no partitions, return the empty set */
@@ -564,6 +568,13 @@ prune_append_rel_partitions(RelOptInfo *rel)
 		return NULL;
 
 	/*
+	 * If pruning is disabled or if there are no clauses to prune with,
+	 * return all partitions.
+	 */
+	if (!enable_partition_pruning || clauses == NIL)
+		return bms_add_range(NULL, 0, rel->nparts - 1);
+
+	/*
 	 * Process clauses.  If the clauses are found to be contradictory, we can
 	 * return the empty set.
 	 */
@@ -590,15 +601,7 @@ prune_append_rel_partitions(RelOptInfo *rel)
 	context.evalexecparams = false;
 
 	/* Actual pruning happens here. */
-	partindexes = get_matching_partitions(&context, pruning_steps);
-
-	/* Add selected partitions' RT indexes to result. */
-	i = -1;
-	result = NULL;
-	while ((i = bms_next_member(partindexes, i)) >= 0)
-		result = bms_add_member(result, rel->part_rels[i]->relid);
-
-	return result;
+	return get_matching_partitions(&context, pruning_steps);
 }
 
 /*
diff --git a/src/include/nodes/relation.h b/src/include/nodes/relation.h
index 7f71f1c948..458be2769e 100644
--- a/src/include/nodes/relation.h
+++ b/src/include/nodes/relation.h
@@ -15,6 +15,7 @@
 #define RELATION_H
 
 #include "access/sdir.h"
+#include "access/tupdesc.h"
 #include "fmgr.h"
 #include "lib/stringinfo.h"
 #include "nodes/params.h"
@@ -726,6 +727,7 @@ typedef struct RelOptInfo
 	int			nparts;			/* number of partitions */
 	struct PartitionBoundInfoData *boundinfo;	/* Partition bounds */
 	List	   *partition_qual; /* partition constraint */
+	Oid		   *part_oids;		/* partition OIDs */
 	struct RelOptInfo **part_rels;	/* Array of RelOptInfos of partitions,
 									 * stored in the same order of bounds */
 	List	  **partexprs;		/* Non-nullable partition key expressions. */
@@ -735,6 +737,12 @@ typedef struct RelOptInfo
 	Index		inh_root_parent;	/* For otherrels, this is the RT index of
 									 * inheritance table mentioned in the query
 									 * from which this relation originated */
+	/*
+	 * Set only if this is an inheritance parent relation.  This information
+	 * is needed when initializing the planning info for children.
+	 */
+	TupleDesc	tupdesc;		/* A "copy" of the table's tuple desriptor */
+	Oid			reltype;		/* Table's reltype */
 } RelOptInfo;
 
 /*
diff --git a/src/include/optimizer/pathnode.h b/src/include/optimizer/pathnode.h
index 81abcf53a8..b1baa3117a 100644
--- a/src/include/optimizer/pathnode.h
+++ b/src/include/optimizer/pathnode.h
@@ -261,6 +261,7 @@ extern Path *reparameterize_path_by_child(PlannerInfo *root, Path *path,
  */
 extern void setup_simple_rel_arrays(PlannerInfo *root);
 extern void setup_append_rel_array(PlannerInfo *root);
+extern void expand_planner_arrays(PlannerInfo *root, int add_size);
 extern RelOptInfo *build_simple_rel(PlannerInfo *root, int relid,
 				 RelOptInfo *parent);
 extern RelOptInfo *find_base_rel(PlannerInfo *root, int relid);
diff --git a/src/include/optimizer/plancat.h b/src/include/optimizer/plancat.h
index 7d53cbbb87..edaf2a3b4f 100644
--- a/src/include/optimizer/plancat.h
+++ b/src/include/optimizer/plancat.h
@@ -26,7 +26,7 @@ extern PGDLLIMPORT get_relation_info_hook_type get_relation_info_hook;
 
 
 extern void get_relation_info(PlannerInfo *root, Oid relationObjectId,
-				  bool inhparent, RelOptInfo *rel);
+				  bool inhparent, Bitmapset *updatedCols, RelOptInfo *rel);
 
 extern List *infer_arbiter_indexes(PlannerInfo *root);
 
diff --git a/src/include/optimizer/prep.h b/src/include/optimizer/prep.h
index 38608770a2..faae07d240 100644
--- a/src/include/optimizer/prep.h
+++ b/src/include/optimizer/prep.h
@@ -38,7 +38,8 @@ extern Expr *canonicalize_qual(Expr *qual, bool is_check);
 /*
  * prototypes for preptlist.c
  */
-extern List *preprocess_targetlist(PlannerInfo *root);
+extern List *preprocess_targetlist(PlannerInfo *root,
+							bool inheritance_expanded);
 
 extern PlanRowMark *get_plan_rowmark(List *rowmarks, Index rtindex);
 
@@ -51,7 +52,10 @@ extern void expand_inherited_tables(PlannerInfo *root);
 
 extern Node *adjust_appendrel_attrs(PlannerInfo *root, Node *node,
 					   int nappinfos, AppendRelInfo **appinfos);
-
+extern AppendRelInfo *make_append_rel_info(RelOptInfo *parentrel,
+					 RangeTblEntry *parentrte,
+					 TupleDesc childdesc, Oid childoid, Oid childreltype,
+					 Index childRTindex);
 extern Node *adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node,
 								  Relids child_relids,
 								  Relids top_parent_relids);
@@ -64,5 +68,4 @@ extern SpecialJoinInfo *build_child_join_sjinfo(PlannerInfo *root,
 						Relids left_relids, Relids right_relids);
 extern Relids adjust_child_relids_multilevel(PlannerInfo *root, Relids relids,
 							   Relids child_relids, Relids top_parent_relids);
-
 #endif							/* PREP_H */
diff --git a/src/include/partitioning/partprune.h b/src/include/partitioning/partprune.h
index e07aaaf798..ac0a979010 100644
--- a/src/include/partitioning/partprune.h
+++ b/src/include/partitioning/partprune.h
@@ -76,7 +76,7 @@ extern PartitionPruneInfo *make_partition_pruneinfo(PlannerInfo *root,
 						 List *subpaths,
 						 List *partitioned_rels,
 						 List *prunequal);
-extern Relids prune_append_rel_partitions(RelOptInfo *rel);
+extern Bitmapset *prune_append_rel_partitions(RelOptInfo *rel);
 extern Bitmapset *get_matching_partitions(PartitionPruneContext *context,
 						List *pruning_steps);
 
diff --git a/src/test/regress/expected/partition_aggregate.out b/src/test/regress/expected/partition_aggregate.out
index 6bc106831e..1450cef057 100644
--- a/src/test/regress/expected/partition_aggregate.out
+++ b/src/test/regress/expected/partition_aggregate.out
@@ -144,7 +144,7 @@ SELECT c, sum(a) FROM pagg_tab WHERE 1 = 2 GROUP BY c;
            QUERY PLAN           
 --------------------------------
  HashAggregate
-   Group Key: pagg_tab.c
+   Group Key: c
    ->  Result
          One-Time Filter: false
 (4 rows)
@@ -159,7 +159,7 @@ SELECT c, sum(a) FROM pagg_tab WHERE c = 'x' GROUP BY c;
            QUERY PLAN           
 --------------------------------
  GroupAggregate
-   Group Key: pagg_tab.c
+   Group Key: c
    ->  Result
          One-Time Filter: false
 (4 rows)
-- 
2.11.0

From dc5c84daee7ce358c2115bbff2d2c5f3888dead1 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Wed, 7 Nov 2018 16:51:31 +0900
Subject: [PATCH v10 4/6] Move append expansion code into its own file

This commit moves expand_append_rel and underlings currently in
optimizer/prep/prepunionc.c to optimizer/utils/append.c.

All of the AppendRelInfo based expression manipulation routines
are moved to optimizer/utils/appendinfo.c.

This commit only moves the code and contains no functional changes.
---
 src/backend/optimizer/path/allpaths.c   |    2 +
 src/backend/optimizer/path/equivclass.c |    1 +
 src/backend/optimizer/path/joinrels.c   |    1 +
 src/backend/optimizer/plan/planmain.c   |    2 +
 src/backend/optimizer/plan/planner.c    |    1 +
 src/backend/optimizer/prep/prepunion.c  | 1573 -------------------------------
 src/backend/optimizer/util/Makefile     |    5 +-
 src/backend/optimizer/util/appendinfo.c |  851 +++++++++++++++++
 src/backend/optimizer/util/inherit.c    |  776 +++++++++++++++
 src/backend/optimizer/util/pathnode.c   |    1 +
 src/backend/optimizer/util/relnode.c    |    1 +
 src/backend/partitioning/partprune.c    |    1 +
 src/include/optimizer/appendinfo.h      |   43 +
 src/include/optimizer/inherit.h         |   25 +
 src/include/optimizer/prep.h            |   19 -
 15 files changed, 1708 insertions(+), 1594 deletions(-)
 create mode 100644 src/backend/optimizer/util/appendinfo.c
 create mode 100644 src/backend/optimizer/util/inherit.c
 create mode 100644 src/include/optimizer/appendinfo.h
 create mode 100644 src/include/optimizer/inherit.h

diff --git a/src/backend/optimizer/path/allpaths.c b/src/backend/optimizer/path/allpaths.c
index e8f9463afb..927f54c694 100644
--- a/src/backend/optimizer/path/allpaths.c
+++ b/src/backend/optimizer/path/allpaths.c
@@ -30,6 +30,8 @@
 #ifdef OPTIMIZER_DEBUG
 #include "nodes/print.h"
 #endif
+#include "optimizer/inherit.h"
+#include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/geqo.h"
diff --git a/src/backend/optimizer/path/equivclass.c b/src/backend/optimizer/path/equivclass.c
index 029665b974..f52adc72d0 100644
--- a/src/backend/optimizer/path/equivclass.c
+++ b/src/backend/optimizer/path/equivclass.c
@@ -22,6 +22,7 @@
 #include "catalog/pg_type.h"
 #include "nodes/makefuncs.h"
 #include "nodes/nodeFuncs.h"
+#include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
 #include "optimizer/pathnode.h"
 #include "optimizer/paths.h"
diff --git a/src/backend/optimizer/path/joinrels.c b/src/backend/optimizer/path/joinrels.c
index da0831de4e..6e321ec9e7 100644
--- a/src/backend/optimizer/path/joinrels.c
+++ b/src/backend/optimizer/path/joinrels.c
@@ -15,6 +15,7 @@
 #include "postgres.h"
 
 #include "miscadmin.h"
+#include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
 #include "optimizer/joininfo.h"
 #include "optimizer/pathnode.h"
diff --git a/src/backend/optimizer/plan/planmain.c b/src/backend/optimizer/plan/planmain.c
index be261061f2..9eb140b204 100644
--- a/src/backend/optimizer/plan/planmain.c
+++ b/src/backend/optimizer/plan/planmain.c
@@ -20,7 +20,9 @@
  */
 #include "postgres.h"
 
+#include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
+#include "optimizer/inherit.h"
 #include "optimizer/orclauses.h"
 #include "optimizer/pathnode.h"
 #include "optimizer/paths.h"
diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index 148032342f..85379a6c7d 100644
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -39,6 +39,7 @@
 #include "nodes/print.h"
 #endif
 #include "nodes/relation.h"
+#include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
diff --git a/src/backend/optimizer/prep/prepunion.c b/src/backend/optimizer/prep/prepunion.c
index 303554de34..d539326015 100644
--- a/src/backend/optimizer/prep/prepunion.c
+++ b/src/backend/optimizer/prep/prepunion.c
@@ -12,11 +12,6 @@
  * case, but most of the heavy lifting for that is done elsewhere,
  * notably in prepjointree.c and allpaths.c.
  *
- * There is also some code here to support planning of queries that use
- * inheritance (SELECT FROM foo*).  Inheritance trees are converted into
- * append relations, and thenceforth share code with the UNION ALL case.
- *
- *
  * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
@@ -39,32 +34,21 @@
 #include "miscadmin.h"
 #include "nodes/makefuncs.h"
 #include "nodes/nodeFuncs.h"
-#include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
 #include "optimizer/paths.h"
 #include "optimizer/planmain.h"
 #include "optimizer/planner.h"
 #include "optimizer/prep.h"
-#include "optimizer/restrictinfo.h"
 #include "optimizer/tlist.h"
-#include "optimizer/var.h"
 #include "parser/parse_coerce.h"
 #include "parser/parsetree.h"
-#include "partitioning/partprune.h"
 #include "utils/lsyscache.h"
 #include "utils/rel.h"
 #include "utils/selfuncs.h"
 #include "utils/syscache.h"
 
 
-typedef struct
-{
-	PlannerInfo *root;
-	int			nappinfos;
-	AppendRelInfo **appinfos;
-} adjust_appendrel_attrs_context;
-
 static RelOptInfo *recurse_set_operations(Node *setOp, PlannerInfo *root,
 					   List *colTypes, List *colCollations,
 					   bool junkOK,
@@ -103,34 +87,6 @@ static List *generate_append_tlist(List *colTypes, List *colCollations,
 					  List *input_tlists,
 					  List *refnames_tlist);
 static List *generate_setop_grouplist(SetOperationStmt *op, List *targetlist);
-static void expand_append_rtentry(PlannerInfo *root, RelOptInfo *rel,
-					  RangeTblEntry *rte, Index rti);
-static void expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte,
-						 Index rti, RelOptInfo *rel);
-static void expand_partitioned_rtentry(PlannerInfo *root,
-						   RangeTblEntry *parentrte,
-						   Index parentRTindex, RelOptInfo *parentrel);
-static RelOptInfo *add_inheritance_child_rel(PlannerInfo *root,
-						  RangeTblEntry *parentrte,
-						  Index parentRTindex, RelOptInfo *parentrel,
-						  PlanRowMark *top_parentrc, Relation childrel,
-						  RangeTblEntry **childrte_p, Index *childRTindex_p);
-static void make_inh_translation_list(TupleDesc old_tupdesc,
-						  TupleDesc new_tupdesc,
-						  Oid from_rel, Oid to_rel,
-						  Index newvarno, List **translated_vars);
-static RelOptInfo *build_append_child_rel(PlannerInfo *root,
-					   RelOptInfo *parent,
-					   Index childRTindex);
-static List *add_rowmark_junk_columns(PlannerInfo *root, PlanRowMark *rc);
-static Bitmapset *translate_col_privs(const Bitmapset *parent_privs,
-					List *translated_vars);
-static Node *adjust_appendrel_attrs_mutator(Node *node,
-							   adjust_appendrel_attrs_context *context);
-static Relids adjust_child_relids(Relids relids, int nappinfos,
-					AppendRelInfo **appinfos);
-static List *adjust_inherited_tlist(List *tlist,
-					   AppendRelInfo *context);
 
 
 /*
@@ -1467,1532 +1423,3 @@ generate_setop_grouplist(SetOperationStmt *op, List *targetlist)
 	Assert(lg == NULL);
 	return grouplist;
 }
-
-
-/*
- * expand_inherited_tables
- *		Expand each rangetable entry that represents an inheritance set
- *		into an "append relation".  At the conclusion of this process,
- *		the "inh" flag is set in all and only those RTEs that are append
- *		relation parents.
- */
-void
-expand_inherited_tables(PlannerInfo *root)
-{
-	int			orig_rtable_size;
-	Index		rti;
-
-	Assert(root->simple_rel_array_size > 0);
-	orig_rtable_size = root->simple_rel_array_size;
-
-	/*
-	 * expand_append_rtentry may add RTEs to parse->rtable. The function is
-	 * expected to recursively handle any RTEs that it creates with inh=true.
-	 * So just scan as far as the original end of the rtable list.
-	 */
-	for (rti = 1; rti < orig_rtable_size; rti++)
-	{
-		RelOptInfo *brel = root->simple_rel_array[rti];
-		RangeTblEntry *rte = root->simple_rte_array[rti];
-
-		/* there may be empty slots corresponding to non-baserel RTEs */
-		if (brel == NULL)
-			continue;
-
-		if (rte->inh)
-			expand_append_rtentry(root, brel, rte, rti);
-	}
-}
-
-/*
- * expand_append_rtentry
- *		This initializes RelOptInfos for an appendrel's child relations, if
- *		any
- *
- * 'rel' is the appendrel parent, whose range table entry ('rte') has been
- * marked to require adding children.  An appendrel parent could either
- * be a subquery (if we flattened UNION ALL query) or a table that's known
- * to have inheritance children.  The latter consists of both regular
- * inheritance parents and partitioned tables.
- *
- * For a subquery parent, there is not much to be done here because the
- * children's RTEs are already present in the query, so we just initialize
- * RelOptInfos for them.  Also, the AppendRelInfos for child subqueries
- * have already been added.
- *
- * For tables, we need to add the children to the range table and initialize
- * AppendRelInfos, RelOptInfos, and PlanRowMarks (if any) for them.  For
- * a partitioned parent, we only add the children remaining after pruning.
- * For regular inheritance parents, we find the children using
- * find_all_inheritors and add all of them.
- *
- * If it turns out that there are no children, then we set rte->inh to false
- * to let the caller know that only the parent table needs to be scanned.  The
- * caller can accordingly switch to a non-Append path.  For a partitioned
- * parent, that means an empty relation because parents themselves contain no
- * data.
- *
- * For the regular inheritance case, the parent also gets another RTE with
- * inh = false to represent it as an appendrel child.  The original RTE is
- * considered to represent the whole inheritance set.
- */
-static void
-expand_append_rtentry(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte,
-					  Index rti)
-{
-	Assert(rte->inh);
-	/* Inheritance parent (partitioned or not) or UNION ALL parent subquery. */
-	Assert(rte->rtekind == RTE_RELATION || rte->rtekind == RTE_SUBQUERY);
-
-	/*
-	 * UNION ALL children already got RTEs and AppendRelInfos, so just build
-	 * RelOptInfos and return.
-	 *
-	 * It might be a bit odd that this code is in this, because there is
-	 * nothing to expand really.
-	 */
-	if (rte->rtekind == RTE_SUBQUERY)
-	{
-		ListCell   *l;
-
-		/*
-		 * We don't need to use expand_planner_arrays in this case, because
-		 * no new child RTEs are created.  setup_simple_rel_arrays() and
-		 * setup_append_rel_array would've considered these child RTEs when
-		 * allocating space for various arrays.
-		 */
-		foreach(l, root->append_rel_list)
-		{
-			AppendRelInfo *appinfo = lfirst(l);
-			Index		childRTindex = appinfo->child_relid;
-
-			if (appinfo->parent_relid != rti)
-				continue;
-
-			Assert(childRTindex < root->simple_rel_array_size);
-			Assert(root->simple_rte_array[childRTindex] != NULL);
-
-			/*
-			 * We set the correct value of baserestricinfo and
-			 * baserestrict_min_security below.
-			 */
-			root->simple_rel_array[childRTindex] =
-				build_append_child_rel(root, rel, appinfo->child_relid);
-		}
-	}
-	else
-	{
-		Assert(rte->rtekind == RTE_RELATION);
-		Assert(has_subclass(rte->relid));
-
-		/*
-		 * The rewriter should already have obtained an appropriate lock on
-		 * each relation named in the query.  However, for each child relation
-		 * we add to the query, we must obtain an appropriate lock, because
-		 * this will be the first use of those relations in the
-		 * parse/rewrite/plan pipeline.  Child rels should use the same
-		 * lockmode as their parent.
-		 */
-		Assert(rte->rellockmode != NoLock);
-
-		if (rte->relkind == RELKIND_PARTITIONED_TABLE)
-			expand_partitioned_rtentry(root, rte, rti, rel);
-		else
-			expand_inherited_rtentry(root, rte, rti, rel);
-	}
-}
-
-/*
- * expand_inherited_rtentry
- *		Add entries for all the child tables to the query's rangetable, and
- *		build AppendRelInfo nodes for all the child tables and add them to
- *		root->append_rel_list.
- *
- * Note that the original RTE is considered to represent the whole
- * inheritance set.  The first of the generated RTEs is an RTE for the same
- * table, but with inh = false, to represent the parent table in its role
- * as a simple member of the inheritance set.
- *
- * A childless table is never considered to be an inheritance set. For
- * regular inheritance, a parent RTE must always have at least two associated
- * AppendRelInfos: one corresponding to the parent table as a simple member of
- * inheritance set and one or more corresponding to the actual children.
- */
-static void
-expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti,
-						 RelOptInfo *rel)
-{
-	Oid			parentOID;
-	PlanRowMark *oldrc;
-	LOCKMODE	lockmode = rte->rellockmode;
-	List	   *inhOIDs;
-	ListCell   *l;
-	int			num_children;
-	int			num_children_added = 0;
-
-	Assert(rte->rtekind == RTE_RELATION);
-	Assert(lockmode != NoLock);
-	parentOID = rte->relid;
-
-	/* Scan for all members of inheritance set, acquire needed locks */
-	inhOIDs = find_all_inheritors(parentOID, lockmode, NULL);
-
-	/*
-	 * Check that there's at least one descendant, else treat as no-child
-	 * case.  This could happen despite has_subclass() check performed by
-	 * subquery_planner, if table once had a child but no longer does.
-	 */
-	num_children = list_length(inhOIDs);
-	if (num_children < 2)
-	{
-		/* Clear flag before returning */
-		rte->inh = false;
-		return;
-	}
-
-	/*
-	 * If parent relation is selected FOR UPDATE/SHARE, preprocess_rowmarks
-	 * should've set isParent = true.  We'll generate a new PlanRowMark for
-	 * each child.
-	 */
-	oldrc = get_plan_rowmark(root->rowMarks, rti);
-	Assert(oldrc == NULL || oldrc->isParent);
-
-	/*
-	 * Must expand PlannerInfo arrays by num_children before we can add
-	 * children.
-	 */
-	expand_planner_arrays(root, num_children);
-
-	foreach(l, inhOIDs)
-	{
-		Oid			childOID = lfirst_oid(l);
-		Relation	newrelation;
-		RangeTblEntry *childrte;
-		Index		childRTindex;
-
-		/* Already locked above. */
-		newrelation = heap_open(childOID, NoLock);
-
-		/*
-		 * It is possible that the parent table has children that are temp
-		 * tables of other backends.  We cannot safely access such tables
-		 * (because of buffering issues), and the best thing to do seems
-		 * to be to silently ignore them.
-		 */
-		if (RELATION_IS_OTHER_TEMP(newrelation))
-		{
-			heap_close(newrelation, lockmode);
-			continue;
-		}
-
-		(void) add_inheritance_child_rel(root, rte, rti, rel, oldrc,
-										 newrelation, &childrte,
-										 &childRTindex);
-		Assert(childrte != NULL);
-		/* All regular inheritance children are leaf children. */
-		Assert(!childrte->inh);
-		Assert(childRTindex > 0);
-
-		/* Close child relations, but keep locks */
-		heap_close(newrelation, NoLock);
-		num_children_added++;
-	}
-
-	/*
-	 * If all children, including the parent (as child rel), were
-	 * excluded, mark the parent rel as empty.  If all the children were temp
-	 * tables, pretend it's a non-inheritance situation; we don't need Append
-	 * node in that case.  The duplicate RTE we added for the parent table is
-	 * harmless, so we don't bother to get rid of it; ditto for the useless
-	 * PlanRowMark node.
-	 */
-	if (num_children_added == 0)
-		mark_dummy_rel(rel);
-	else if (num_children_added == 1)
-		rte->inh = false;
-
-	/*
-	 * Add junk columns needed by the row mark if any and also add the
-	 * relevant expressions to the root parent's reltarget.
-	 */
-	if (oldrc)
-	{
-		List   *tlist = add_rowmark_junk_columns(root, oldrc);
-
-		build_base_rel_tlists(root, tlist);
-	}
-}
-
-/*
- * expand_partitioned_rtentry
- *		Prunes unnecessary partitions of a partitioned table and adds
- *		remaining ones to the Query and the PlannerInfo
- *
- * Partitions are added to the query in order in which they are found in
- * the parent's PartitionDesc.
- *
- * Note: even though only the unpruned partitions will be added to the
- * resulting plan, this still locks *all* partitions via find_all_inheritors
- * when this function is called for the root partitioned table.
- */
-static void
-expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
-						   Index parentRTindex, RelOptInfo *parentrel)
-{
-	LOCKMODE	lockmode = parentrte->rellockmode;
-	PlanRowMark *rootrc = NULL;
-	int			i;
-	Bitmapset  *partindexes;
-	Index		rootParentRTindex = parentrel->inh_root_parent > 0 ?
-									parentrel->inh_root_parent :
-									parentRTindex;
-
-	/* If root partitioned table, lock *all* partitions in the tree. */
-	if (parentRTindex == rootParentRTindex)
-		(void) find_all_inheritors(parentrte->relid, lockmode, NULL);
-
-	/*
-	 * Initialize partitioned_child_rels to contain this RT index.
-	 *
-	 * Note that during the set_append_rel_pathlist() phase, values of the
-	 * indexes of partitioned relations that appear down in the tree will be
-	 * bubbled up into root parent's list so that when we've created Paths for
-	 * all the children, the root table's list will contain all such indexes.
-	 */
-	parentrel->partitioned_child_rels = list_make1_int(parentRTindex);
-
-	/* Perform pruning. */
-	partindexes = prune_append_rel_partitions(parentrel);
-
-	/* Must expand PlannerInfo arrays before we can add children. */
-	expand_planner_arrays(root, bms_num_members(partindexes));
-
-	/*
-	 * For partitioned tables, we also store the partition RelOptInfo
-	 * pointers in the parent's RelOptInfo.
-	 */
-	parentrel->part_rels = (RelOptInfo **) palloc0(sizeof(RelOptInfo *) *
-												   parentrel->nparts);
-
-	rootrc = get_plan_rowmark(root->rowMarks, rootParentRTindex);
-	Assert(rootrc == NULL || rootrc->isParent);
-	i = -1;
-	while ((i = bms_next_member(partindexes, i)) >= 0)
-	{
-		Oid		childOID = parentrel->part_oids[i];
-		Relation	newrelation;
-		RelOptInfo *childrel;
-		RangeTblEntry *childrte;
-		Index		childRTindex;
-
-		/* Already locked above. */
-		newrelation = heap_open(childOID, NoLock);
-		Assert(!RELATION_IS_OTHER_TEMP(newrelation));
-
-		/*
-		 * A partitioned child table with 0 children is a dummy rel, so don't
-		 * bother creating planner objects for it.
-		 */
-		if (newrelation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE &&
-			RelationGetPartitionDesc(newrelation)->nparts == 0)
-		{
-			heap_close(newrelation, NoLock);
-			continue;
-		}
-
-		childrel = add_inheritance_child_rel(root, parentrte, parentRTindex,
-											 parentrel, rootrc, newrelation,
-											 &childrte, &childRTindex);
-		Assert(childrel != NULL);
-		parentrel->part_rels[i] = childrel;
-
-		/* Close child relations, but keep locks */
-		heap_close(newrelation, NoLock);
-
-		/* If the child is partitioned itself, expand it too. */
-		if (childrel->part_scheme)
-		{
-			Assert(childrte->inh);
-			expand_partitioned_rtentry(root, childrte, childRTindex,
-									   childrel);
-		}
-	}
-
-	/*
-	 * Add junk columns needed by the row mark if any and also add the
-	 * relevant expressions to the root parent's reltarget.
-	 */
-	if (rootrc)
-	{
-		List   *tlist = add_rowmark_junk_columns(root, rootrc);
-
-		build_base_rel_tlists(root, tlist);
-	}
-}
-
-/*
- * add_inheritance_child_rel
- *		Build a RangeTblEntry, an AppendRelInfo, a PlanRowMark, and finally
- *		a RelOptInfo for an inheritance child relation.
- *
- * The return value is the RelOptInfo that's added.
- *
- * PlanRowMarks still carry the top-parent's RTI, and the top-parent's
- * allMarkTypes field still accumulates values from all descendents.
- *
- * "parentrte" and "parentRTindex" are immediate parent's RTE and
- * RTI. "top_parentrc" is top parent's PlanRowMark.
- */
-static RelOptInfo *
-add_inheritance_child_rel(PlannerInfo *root, RangeTblEntry *parentrte,
-						  Index parentRTindex, RelOptInfo *parentrel,
-						  PlanRowMark *top_parentrc, Relation childrel,
-						  RangeTblEntry **childrte_p, Index *childRTindex_p)
-{
-	Query	   *parse = root->parse;
-	Oid			childOID = RelationGetRelid(childrel);
-	RangeTblEntry *childrte;
-	Index		childRTindex;
-	AppendRelInfo *appinfo;
-	RelOptInfo *childrelopt;
-
-	/*
-	 * Build an RTE for the child, and attach to query's rangetable list. We
-	 * copy most fields of the parent's RTE, but replace relation OID and
-	 * relkind, and set inh appropriately.  Also, set requiredPerms to zero
-	 * since all required permissions checks are done on the original RTE.
-	 * Likewise, set the child's securityQuals to empty, because we only want
-	 * to apply the parent's RLS conditions regardless of what RLS properties
-	 * individual children may have.  (This is an intentional choice to make
-	 * inherited RLS work like regular permissions checks.) The parent
-	 * securityQuals will be propagated to children along with other base
-	 * restriction clauses, so we don't need to do it here.
-	 */
-	childrte = copyObject(parentrte);
-	*childrte_p = childrte;
-	childrte->relid = childOID;
-	childrte->relkind = childrel->rd_rel->relkind;
-	/*
-	 * A partitioned child will need to be expanded as an append parent
-	 * itself, so set its inh to true.
-	 */
-	childrte->inh = (childrte->relkind == RELKIND_PARTITIONED_TABLE);
-	childrte->requiredPerms = 0;
-	childrte->securityQuals = NIL;
-	parse->rtable = lappend(parse->rtable, childrte);
-	childRTindex = list_length(parse->rtable);
-	*childRTindex_p = childRTindex;
-
-	/* Create an AppendRelInfo and add it to planner's global list. */
-	appinfo = make_append_rel_info(parentrel, parentrte,
-								   childrel->rd_att,
-								   childOID,
-								   childrel->rd_rel->reltype,
-								   childRTindex);
-	root->append_rel_list = lappend(root->append_rel_list, appinfo);
-
-	/*
-	 * Translate the column permissions bitmaps to the child's attnums (we
-	 * have to build the translated_vars list before we can do this). But
-	 * if this is the parent table, leave copyObject's result alone.
-	 *
-	 * Note: we need to do this even though the executor won't run any
-	 * permissions checks on the child RTE.  The insertedCols/updatedCols
-	 * bitmaps may be examined for trigger-firing purposes.
-	 */
-	if (childrte->relid != parentrte->relid)
-	{
-		childrte->selectedCols = translate_col_privs(parentrte->selectedCols,
-													 appinfo->translated_vars);
-		childrte->insertedCols = translate_col_privs(parentrte->insertedCols,
-													 appinfo->translated_vars);
-		childrte->updatedCols = translate_col_privs(parentrte->updatedCols,
-													appinfo->translated_vars);
-	}
-
-	/*
-	 * Build a PlanRowMark if parent is marked FOR UPDATE/SHARE.
-	 */
-	if (top_parentrc)
-	{
-		PlanRowMark *childrc = makeNode(PlanRowMark);
-
-		childrc->rti = childRTindex;
-		childrc->prti = top_parentrc->rti;
-		childrc->rowmarkId = top_parentrc->rowmarkId;
-		/* Reselect rowmark type, because relkind might not match parent */
-		childrc->markType = select_rowmark_type(childrte,
-												top_parentrc->strength);
-		childrc->allMarkTypes = (1 << childrc->markType);
-		childrc->strength = top_parentrc->strength;
-		childrc->waitPolicy = top_parentrc->waitPolicy;
-
-		/*
-		 * We mark RowMarks for partitioned child tables as parent RowMarks so
-		 * that the executor ignores them (except their existence means that
-		 * the child tables be locked using appropriate mode).
-		 */
-		childrc->isParent = (childrte->relkind == RELKIND_PARTITIONED_TABLE);
-
-		/* Include child's rowmark type in top parent's allMarkTypes */
-		top_parentrc->allMarkTypes |= childrc->allMarkTypes;
-
-		root->rowMarks = lappend(root->rowMarks, childrc);
-	}
-
-	/*
-	 * Add the RelOptInfo.  Even though we may not really scan this relation
-	 * for reasons such as contradictory quals, we still need to create one,
-	 * because for every RTE in the query's range table, there must be an
-	 * accompanying RelOptInfo.
-	 */
-
-	/* First, store the RTE and appinfos into planner arrays. */
-	Assert(root->simple_rte_array[childRTindex] == NULL);
-	root->simple_rte_array[childRTindex] = childrte;
-	Assert(root->append_rel_array[childRTindex] == NULL);
-	root->append_rel_array[childRTindex] = appinfo;
-
-	childrelopt = build_append_child_rel(root, parentrel, childRTindex);
-	Assert(childrelopt != NULL);
-
-	return childrelopt;
-}
-
-/*
- * make_inh_translation_list
- *	  Build the list of translations from parent Vars to child Vars for
- *	  an inheritance child.
- *
- * For paranoia's sake, we match type/collation as well as attribute name.
- */
-static void
-make_inh_translation_list(TupleDesc old_tupdesc, TupleDesc new_tupdesc,
-						  Oid from_rel, Oid to_rel,
-						  Index newvarno, List **translated_vars)
-{
-	List	   *vars = NIL;
-	int			oldnatts = old_tupdesc->natts;
-	int			newnatts = new_tupdesc->natts;
-	int			old_attno;
-	int			new_attno = 0;
-
-	for (old_attno = 0; old_attno < oldnatts; old_attno++)
-	{
-		Form_pg_attribute att;
-		char	   *attname;
-		Oid			atttypid;
-		int32		atttypmod;
-		Oid			attcollation;
-
-		att = TupleDescAttr(old_tupdesc, old_attno);
-		if (att->attisdropped)
-		{
-			/* Just put NULL into this list entry */
-			vars = lappend(vars, NULL);
-			continue;
-		}
-		attname = NameStr(att->attname);
-		atttypid = att->atttypid;
-		atttypmod = att->atttypmod;
-		attcollation = att->attcollation;
-
-		/*
-		 * When we are generating the "translation list" for the parent table
-		 * of an inheritance set, no need to search for matches.
-		 */
-		if (from_rel == to_rel)
-		{
-			vars = lappend(vars, makeVar(newvarno,
-										 (AttrNumber) (old_attno + 1),
-										 atttypid,
-										 atttypmod,
-										 attcollation,
-										 0));
-			continue;
-		}
-
-		/*
-		 * Otherwise we have to search for the matching column by name.
-		 * There's no guarantee it'll have the same column position, because
-		 * of cases like ALTER TABLE ADD COLUMN and multiple inheritance.
-		 * However, in simple cases, the relative order of columns is mostly
-		 * the same in both relations, so try the column of newrelation that
-		 * follows immediately after the one that we just found, and if that
-		 * fails, let syscache handle it.
-		 */
-		if (new_attno >= newnatts ||
-			(att = TupleDescAttr(new_tupdesc, new_attno))->attisdropped ||
-			strcmp(attname, NameStr(att->attname)) != 0)
-		{
-			HeapTuple	newtup;
-
-			newtup = SearchSysCacheAttName(to_rel, attname);
-			if (!newtup)
-				elog(ERROR, "could not find inherited attribute \"%s\" of relation \"%s\"",
-					 attname, get_rel_name(to_rel));
-			new_attno = ((Form_pg_attribute) GETSTRUCT(newtup))->attnum - 1;
-			ReleaseSysCache(newtup);
-
-			att = TupleDescAttr(new_tupdesc, new_attno);
-		}
-
-		/* Found it, check type and collation match */
-		if (atttypid != att->atttypid || atttypmod != att->atttypmod)
-			elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's type",
-				 attname, get_rel_name(to_rel));
-		if (attcollation != att->attcollation)
-			elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's collation",
-				 attname, get_rel_name(to_rel));
-
-		vars = lappend(vars, makeVar(newvarno,
-									 (AttrNumber) (new_attno + 1),
-									 atttypid,
-									 atttypmod,
-									 attcollation,
-									 0));
-		new_attno++;
-	}
-
-	*translated_vars = vars;
-}
-
-/*
- * translate_col_privs
- *	  Translate a bitmapset representing per-column privileges from the
- *	  parent rel's attribute numbering to the child's.
- *
- * The only surprise here is that we don't translate a parent whole-row
- * reference into a child whole-row reference.  That would mean requiring
- * permissions on all child columns, which is overly strict, since the
- * query is really only going to reference the inherited columns.  Instead
- * we set the per-column bits for all inherited columns.
- */
-static Bitmapset *
-translate_col_privs(const Bitmapset *parent_privs,
-					List *translated_vars)
-{
-	Bitmapset  *child_privs = NULL;
-	bool		whole_row;
-	int			attno;
-	ListCell   *lc;
-
-	/* System attributes have the same numbers in all tables */
-	for (attno = FirstLowInvalidHeapAttributeNumber + 1; attno < 0; attno++)
-	{
-		if (bms_is_member(attno - FirstLowInvalidHeapAttributeNumber,
-						  parent_privs))
-			child_privs = bms_add_member(child_privs,
-										 attno - FirstLowInvalidHeapAttributeNumber);
-	}
-
-	/* Check if parent has whole-row reference */
-	whole_row = bms_is_member(InvalidAttrNumber - FirstLowInvalidHeapAttributeNumber,
-							  parent_privs);
-
-	/* And now translate the regular user attributes, using the vars list */
-	attno = InvalidAttrNumber;
-	foreach(lc, translated_vars)
-	{
-		Var		   *var = lfirst_node(Var, lc);
-
-		attno++;
-		if (var == NULL)		/* ignore dropped columns */
-			continue;
-		if (whole_row ||
-			bms_is_member(attno - FirstLowInvalidHeapAttributeNumber,
-						  parent_privs))
-			child_privs = bms_add_member(child_privs,
-										 var->varattno - FirstLowInvalidHeapAttributeNumber);
-	}
-
-	return child_privs;
-}
-
-/*
- *	build_append_child_rel
- *		Build a RelOptInfo for child relation of an append rel
- *
- * After creating the RelOptInfo for the given child RT index, it goes on to
- * initialize some of its fields based on the parent RelOptInfo.
- *
- * If the quals in baserestrictinfo turn out to be self-contradictory,
- * RelOptInfo is marked dummy before returning.
- */
-static RelOptInfo *
-build_append_child_rel(PlannerInfo *root,
-					   RelOptInfo *parent,
-					   Index childRTindex)
-{
-	RelOptInfo *childrel;
-	RangeTblEntry *childRTE = root->simple_rte_array[childRTindex];
-	AppendRelInfo *appinfo = root->append_rel_array[childRTindex];
-	List	   *childquals;
-	ListCell   *lc;
-	bool		have_const_false_cq;
-	Index		cq_min_security;
-
-	/* Build the RelOptInfo. */
-	childrel = build_simple_rel(root, childRTindex, parent);
-
-	/*
-	 * Propagate lateral_relids and lateral_referencers from appendrel
-	 * parent rels to their child rels.  We intentionally give each child rel
-	 * the same minimum parameterization, even though it's quite possible that
-	 * some don't reference all the lateral rels.  This is because any append
-	 * path for the parent will have to have the same parameterization for
-	 * every child anyway, and there's no value in forcing extra
-	 * reparameterize_path() calls.  Similarly, a lateral reference to the
-	 * parent prevents use of otherwise-movable join rels for each child.
-	 */
-	childrel->direct_lateral_relids = parent->direct_lateral_relids;
-	childrel->lateral_relids = parent->lateral_relids;
-	childrel->lateral_referencers = parent->lateral_referencers;
-
-	/*
-	 * We have to copy the parent's quals to the child, with appropriate
-	 * substitution of variables.  However, only the baserestrictinfo
-	 * quals are needed before we can check for constraint exclusion; so
-	 * do that first and then check to see if we can disregard this child.
-	 *
-	 * The child rel's targetlist might contain non-Var expressions, which
-	 * means that substitution into the quals could produce opportunities
-	 * for const-simplification, and perhaps even pseudoconstant quals.
-	 * Therefore, transform each RestrictInfo separately to see if it
-	 * reduces to a constant or pseudoconstant.  (We must process them
-	 * separately to keep track of the security level of each qual.)
-	 */
-	childquals = false;
-	cq_min_security = UINT_MAX;
-	have_const_false_cq = false;
-	foreach(lc, parent->baserestrictinfo)
-	{
-		RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
-		Node	   *childqual = (Node *) rinfo->clause;
-		ListCell   *lc2;
-
-		Assert(IsA(rinfo, RestrictInfo));
-		childqual = adjust_appendrel_attrs(root, childqual,
-										   1, &appinfo);
-		childqual = eval_const_expressions(root, childqual);
-		/* check for flat-out constant */
-		if (childqual && IsA(childqual, Const))
-		{
-			if (((Const *) childqual)->constisnull ||
-				!DatumGetBool(((Const *) childqual)->constvalue))
-			{
-				/* Restriction reduces to constant FALSE or NULL */
-				have_const_false_cq = true;
-				break;
-			}
-			/* Restriction reduces to constant TRUE, so drop it */
-			continue;
-		}
-		/* might have gotten an AND clause, if so flatten it */
-		foreach(lc2, make_ands_implicit((Expr *) childqual))
-		{
-			Node	   *onecq = (Node *) lfirst(lc2);
-			bool		pseudoconstant;
-
-			/* check for pseudoconstant (no Vars or volatile functions) */
-			pseudoconstant =
-					!contain_vars_of_level(onecq, 0) &&
-					!contain_volatile_functions(onecq);
-			if (pseudoconstant)
-			{
-				/* tell createplan.c to check for gating quals */
-				root->hasPseudoConstantQuals = true;
-			}
-			/* reconstitute RestrictInfo with appropriate properties */
-			childquals = lappend(childquals,
-								 make_restrictinfo((Expr *) onecq,
-												   rinfo->is_pushed_down,
-												   rinfo->outerjoin_delayed,
-												   pseudoconstant,
-												   rinfo->security_level,
-												   NULL, NULL, NULL));
-			cq_min_security = Min(cq_min_security, rinfo->security_level);
-		}
-	}
-
-	/*
-	 * In addition to the quals inherited from the parent, we might
-	 * have securityQuals associated with this particular child node.
-	 * (Currently this can only happen in appendrels originating from
-	 * UNION ALL; inheritance child tables don't have their own
-	 * securityQuals.)	Pull any such securityQuals up into the
-	 * baserestrictinfo for the child.  This is similar to
-	 * process_security_barrier_quals() for the parent rel, except
-	 * that we can't make any general deductions from such quals,
-	 * since they don't hold for the whole appendrel.
-	 */
-	if (childRTE->securityQuals)
-	{
-		Index		security_level = 0;
-
-		foreach(lc, childRTE->securityQuals)
-		{
-			List	   *qualset = (List *) lfirst(lc);
-			ListCell   *lc2;
-
-			foreach(lc2, qualset)
-			{
-				Expr	   *qual = (Expr *) lfirst(lc2);
-
-				/*
-				 * not likely that we'd see constants here, so no
-				 * check
-				 */
-				childquals = lappend(childquals,
-									 make_restrictinfo(qual,
-													   true,
-													   false,
-													   false,
-													   security_level,
-													   NULL, NULL,
-													   NULL));
-				cq_min_security = Min(cq_min_security, security_level);
-			}
-			security_level++;
-		}
-		Assert(security_level <= root->qual_security_level);
-	}
-
-	/* Set child's version of baserestrictinfo. */
-	childrel->baserestrictinfo = childquals;
-	childrel->baserestrict_min_security = cq_min_security;
-
-	if (have_const_false_cq)
-	{
-		/*
-		 * Some restriction clause reduced to constant FALSE or NULL after
-		 * substitution, so this child need not be scanned.
-		 */
-		set_dummy_rel_pathlist(childrel);
-	}
-
-	return childrel;
-}
-
-/*
- * add_rowmark_junk_columns
- * 		Add necessary junk columns for rowmarked inheritance parent rel.
- *
- * These values are needed for locking of rels selected FOR UPDATE/SHARE, and
- * to do EvalPlanQual rechecking.  See comments for PlanRowMark in
- * plannodes.h.
- */
-static List *
-add_rowmark_junk_columns(PlannerInfo *root, PlanRowMark *rc)
-{
-	List   *tlist = root->processed_tlist;
-	Var		   *var;
-	char		resname[32];
-	TargetEntry *tle;
-
-	if (rc->allMarkTypes & ~(1 << ROW_MARK_COPY))
-	{
-		/* Need to fetch TID */
-		var = makeVar(rc->rti,
-					  SelfItemPointerAttributeNumber,
-					  TIDOID,
-					  -1,
-					  InvalidOid,
-					  0);
-		snprintf(resname, sizeof(resname), "ctid%u", rc->rowmarkId);
-		tle = makeTargetEntry((Expr *) var,
-							  list_length(tlist) + 1,
-							  pstrdup(resname),
-							  true);
-		tlist = lappend(tlist, tle);
-	}
-	if (rc->allMarkTypes & (1 << ROW_MARK_COPY))
-	{
-		/* Need the whole row as a junk var */
-		var = makeWholeRowVar(root->simple_rte_array[rc->rti],
-							  rc->rti,
-							  0,
-							  false);
-		snprintf(resname, sizeof(resname), "wholerow%u", rc->rowmarkId);
-		tle = makeTargetEntry((Expr *) var,
-							  list_length(tlist) + 1,
-							  pstrdup(resname),
-							  true);
-		tlist = lappend(tlist, tle);
-	}
-
-	/* For inheritance cases, always fetch the tableoid too. */
-	var = makeVar(rc->rti,
-				  TableOidAttributeNumber,
-				  OIDOID,
-				  -1,
-				  InvalidOid,
-				  0);
-	snprintf(resname, sizeof(resname), "tableoid%u", rc->rowmarkId);
-	tle = makeTargetEntry((Expr *) var,
-						  list_length(tlist) + 1,
-						  pstrdup(resname),
-						  true);
-	tlist = lappend(tlist, tle);
-
-	return tlist;
-}
-
-AppendRelInfo *
-make_append_rel_info(RelOptInfo *parentrel, RangeTblEntry *parentrte,
-					 TupleDesc childdesc, Oid childoid, Oid childreltype,
-					 Index childRTindex)
-{
-	AppendRelInfo  *appinfo = makeNode(AppendRelInfo);
-
-	appinfo->parent_relid = parentrel->relid;
-	appinfo->child_relid = childRTindex;
-	appinfo->parent_reltype = parentrel->reltype;
-	appinfo->child_reltype = childreltype;
-	make_inh_translation_list(parentrel->tupdesc, childdesc,
-							  parentrte->relid, childoid,
-							  childRTindex,
-							  &appinfo->translated_vars);
-	appinfo->parent_reloid = parentrte->relid;
-
-	return appinfo;
-}
-
-/*
- * adjust_appendrel_attrs
- *	  Copy the specified query or expression and translate Vars referring to a
- *	  parent rel to refer to the corresponding child rel instead.  We also
- *	  update rtindexes appearing outside Vars, such as resultRelation and
- *	  jointree relids.
- *
- * Note: this is only applied after conversion of sublinks to subplans,
- * so we don't need to cope with recursion into sub-queries.
- *
- * Note: this is not hugely different from what pullup_replace_vars() does;
- * maybe we should try to fold the two routines together.
- */
-Node *
-adjust_appendrel_attrs(PlannerInfo *root, Node *node, int nappinfos,
-					   AppendRelInfo **appinfos)
-{
-	Node	   *result;
-	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);
-
-	/*
-	 * Must be prepared to start with a Query or a bare expression tree.
-	 */
-	if (node && IsA(node, Query))
-	{
-		Query	   *newnode;
-		int			cnt;
-
-		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;
-}
-
-static Node *
-adjust_appendrel_attrs_mutator(Node *node,
-							   adjust_appendrel_attrs_context *context)
-{
-	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;
-
-		for (cnt = 0; cnt < nappinfos; cnt++)
-		{
-			if (var->varno == appinfos[cnt]->parent_relid)
-			{
-				appinfo = appinfos[cnt];
-				break;
-			}
-		}
-
-		if (var->varlevelsup == 0 && appinfo)
-		{
-			var->varno = appinfo->child_relid;
-			var->varnoold = appinfo->child_relid;
-			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));
-				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;
-
-					return (Node *) rowexpr;
-				}
-			}
-			/* system attributes don't need any other translation */
-		}
-		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, 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 */
-		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, context->nappinfos,
-											  context->appinfos);
-		return (Node *) phv;
-	}
-
-	/*
-	 * This is needed, because inheritance_make_rel_from_joinlist needs to
-	 * translate root->join_info_list executing make_rel_from_joinlist for a
-	 * given child.
-	 */
-	if (IsA(node, SpecialJoinInfo))
-	{
-		SpecialJoinInfo *oldinfo = (SpecialJoinInfo *) node;
-		SpecialJoinInfo *newinfo = makeNode(SpecialJoinInfo);
-
-		memcpy(newinfo, oldinfo, sizeof(SpecialJoinInfo));
-		newinfo->min_lefthand = adjust_child_relids(oldinfo->min_lefthand,
-													context->nappinfos,
-													context->appinfos);
-		newinfo->min_righthand = adjust_child_relids(oldinfo->min_righthand,
-													 context->nappinfos,
-													 context->appinfos);
-		newinfo->syn_lefthand = adjust_child_relids(oldinfo->syn_lefthand,
-													context->nappinfos,
-													context->appinfos);
-		newinfo->syn_righthand = adjust_child_relids(oldinfo->syn_righthand,
-													 context->nappinfos,
-													 context->appinfos);
-		newinfo->semi_rhs_exprs =
-					(List *) expression_tree_mutator((Node *)
-													 oldinfo->semi_rhs_exprs,
-													 adjust_appendrel_attrs_mutator,
-													 (void *) context);
-		return (Node *) newinfo;
-	}
-
-	/* Shouldn't need to handle planner auxiliary nodes here */
-	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 */
-		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->nullable_relids = adjust_child_relids(oldinfo->nullable_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));
-
-	return expression_tree_mutator(node, adjust_appendrel_attrs_mutator,
-								   (void *) context);
-}
-
-/*
- * Substitute child relids for parent relids in a Relid set.  The array of
- * appinfos specifies the substitutions to be performed.
- */
-static Relids
-adjust_child_relids(Relids relids, int nappinfos, AppendRelInfo **appinfos)
-{
-	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;
-}
-
-/*
- * Replace any relid present in top_parent_relids with its child in
- * child_relids. Members of child_relids can be multiple levels below top
- * parent in the partition hierarchy.
- */
-Relids
-adjust_child_relids_multilevel(PlannerInfo *root, Relids relids,
-							   Relids child_relids, Relids top_parent_relids)
-{
-	AppendRelInfo **appinfos;
-	int			nappinfos;
-	Relids		parent_relids = NULL;
-	Relids		result;
-	Relids		tmp_result = NULL;
-	int			cnt;
-
-	/*
-	 * If the given relids set doesn't contain any of the top parent relids,
-	 * it will remain unchanged.
-	 */
-	if (!bms_overlap(relids, top_parent_relids))
-		return relids;
-
-	appinfos = find_appinfos_by_relids(root, child_relids, &nappinfos);
-
-	/* Construct relids set for the immediate parent of the given child. */
-	for (cnt = 0; cnt < nappinfos; cnt++)
-	{
-		AppendRelInfo *appinfo = appinfos[cnt];
-
-		parent_relids = bms_add_member(parent_relids, appinfo->parent_relid);
-	}
-
-	/* Recurse if immediate parent is not the top parent. */
-	if (!bms_equal(parent_relids, top_parent_relids))
-	{
-		tmp_result = adjust_child_relids_multilevel(root, relids,
-													parent_relids,
-													top_parent_relids);
-		relids = tmp_result;
-	}
-
-	result = adjust_child_relids(relids, nappinfos, appinfos);
-
-	/* Free memory consumed by any intermediate result. */
-	if (tmp_result)
-		bms_free(tmp_result);
-	bms_free(parent_relids);
-	pfree(appinfos);
-
-	return result;
-}
-
-/*
- * 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.
- */
-static List *
-adjust_inherited_tlist(List *tlist, AppendRelInfo *context)
-{
-	bool		changed_it = false;
-	ListCell   *tl;
-	List	   *new_tlist;
-	bool		more;
-	int			attrno;
-
-	/* 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)
-	{
-		TargetEntry *tle = (TargetEntry *) lfirst(tl);
-		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))
-			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);
-		if (childvar == NULL || !IsA(childvar, Var))
-			elog(ERROR, "attribute %d of relation \"%s\" does not exist",
-				 tle->resno, get_rel_name(context->parent_reloid));
-
-		if (tle->resno != childvar->varattno)
-		{
-			tle->resno = childvar->varattno;
-			changed_it = true;
-		}
-	}
-
-	/*
-	 * 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;
-
-	new_tlist = NIL;
-	more = true;
-	for (attrno = 1; more; attrno++)
-	{
-		more = false;
-		foreach(tl, tlist)
-		{
-			TargetEntry *tle = (TargetEntry *) lfirst(tl);
-
-			if (tle->resjunk)
-				continue;		/* ignore junk items */
-
-			if (tle->resno == attrno)
-				new_tlist = lappend(new_tlist, tle);
-			else if (tle->resno > attrno)
-				more = true;
-		}
-	}
-
-	foreach(tl, tlist)
-	{
-		TargetEntry *tle = (TargetEntry *) lfirst(tl);
-
-		if (!tle->resjunk)
-			continue;			/* here, ignore non-junk items */
-
-		tle->resno = attrno;
-		new_tlist = lappend(new_tlist, tle);
-		attrno++;
-	}
-
-	return new_tlist;
-}
-
-/*
- * adjust_appendrel_attrs_multilevel
- *	  Apply Var translations from a toplevel appendrel parent down to a child.
- *
- * In some cases we need to translate expressions referencing a parent relation
- * to reference an appendrel child that's multiple levels removed from it.
- */
-Node *
-adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node,
-								  Relids child_relids,
-								  Relids top_parent_relids)
-{
-	AppendRelInfo **appinfos;
-	Bitmapset  *parent_relids = NULL;
-	int			nappinfos;
-	int			cnt;
-
-	Assert(bms_num_members(child_relids) == bms_num_members(top_parent_relids));
-
-	appinfos = find_appinfos_by_relids(root, child_relids, &nappinfos);
-
-	/* Construct relids set for the immediate parent of given child. */
-	for (cnt = 0; cnt < nappinfos; cnt++)
-	{
-		AppendRelInfo *appinfo = appinfos[cnt];
-
-		parent_relids = bms_add_member(parent_relids, appinfo->parent_relid);
-	}
-
-	/* Recurse if immediate parent is not the top parent. */
-	if (!bms_equal(parent_relids, top_parent_relids))
-		node = adjust_appendrel_attrs_multilevel(root, node, parent_relids,
-												 top_parent_relids);
-
-	/* Now translate for this child */
-	node = adjust_appendrel_attrs(root, node, nappinfos, appinfos);
-
-	pfree(appinfos);
-
-	return node;
-}
-
-/*
- * Construct the SpecialJoinInfo for a child-join by translating
- * SpecialJoinInfo for the join between parents. left_relids and right_relids
- * are the relids of left and right side of the join respectively.
- */
-SpecialJoinInfo *
-build_child_join_sjinfo(PlannerInfo *root, SpecialJoinInfo *parent_sjinfo,
-						Relids left_relids, Relids right_relids)
-{
-	SpecialJoinInfo *sjinfo = makeNode(SpecialJoinInfo);
-	AppendRelInfo **left_appinfos;
-	int			left_nappinfos;
-	AppendRelInfo **right_appinfos;
-	int			right_nappinfos;
-
-	memcpy(sjinfo, parent_sjinfo, sizeof(SpecialJoinInfo));
-	left_appinfos = find_appinfos_by_relids(root, left_relids,
-											&left_nappinfos);
-	right_appinfos = find_appinfos_by_relids(root, right_relids,
-											 &right_nappinfos);
-
-	sjinfo->min_lefthand = adjust_child_relids(sjinfo->min_lefthand,
-											   left_nappinfos, left_appinfos);
-	sjinfo->min_righthand = adjust_child_relids(sjinfo->min_righthand,
-												right_nappinfos,
-												right_appinfos);
-	sjinfo->syn_lefthand = adjust_child_relids(sjinfo->syn_lefthand,
-											   left_nappinfos, left_appinfos);
-	sjinfo->syn_righthand = adjust_child_relids(sjinfo->syn_righthand,
-												right_nappinfos,
-												right_appinfos);
-	sjinfo->semi_rhs_exprs = (List *) adjust_appendrel_attrs(root,
-															 (Node *) sjinfo->semi_rhs_exprs,
-															 right_nappinfos,
-															 right_appinfos);
-
-	pfree(left_appinfos);
-	pfree(right_appinfos);
-
-	return sjinfo;
-}
-
-/*
- * find_appinfos_by_relids
- * 		Find AppendRelInfo structures for all relations specified by relids.
- *
- * The AppendRelInfos are returned in an array, which can be pfree'd by the
- * caller. *nappinfos is set to the number of entries in the array.
- */
-AppendRelInfo **
-find_appinfos_by_relids(PlannerInfo *root, Relids relids, int *nappinfos)
-{
-	AppendRelInfo **appinfos;
-	int			cnt = 0;
-	int			i;
-
-	*nappinfos = bms_num_members(relids);
-	appinfos = (AppendRelInfo **) palloc(sizeof(AppendRelInfo *) * *nappinfos);
-
-	i = -1;
-	while ((i = bms_next_member(relids, i)) >= 0)
-	{
-		AppendRelInfo *appinfo = root->append_rel_array[i];
-
-		if (!appinfo)
-			elog(ERROR, "child rel %d not found in append_rel_array", i);
-
-		appinfos[cnt++] = appinfo;
-	}
-	return appinfos;
-}
diff --git a/src/backend/optimizer/util/Makefile b/src/backend/optimizer/util/Makefile
index da9ccf32b4..8a5e2ad1bd 100644
--- a/src/backend/optimizer/util/Makefile
+++ b/src/backend/optimizer/util/Makefile
@@ -12,7 +12,8 @@ subdir = src/backend/optimizer/util
 top_builddir = ../../../..
 include $(top_builddir)/src/Makefile.global
 
-OBJS = clauses.o joininfo.o orclauses.o pathnode.o placeholder.o \
-	   plancat.o predtest.o relnode.o restrictinfo.o tlist.o var.o
+OBJS = appendinfo.o clauses.o inherit.o joininfo.o orclauses.o pathnode.o \
+	   placeholder.o plancat.o predtest.o relnode.o restrictinfo.o tlist.o \
+	   var.o
 
 include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/optimizer/util/appendinfo.c b/src/backend/optimizer/util/appendinfo.c
new file mode 100644
index 0000000000..9502535e53
--- /dev/null
+++ b/src/backend/optimizer/util/appendinfo.c
@@ -0,0 +1,851 @@
+/*-------------------------------------------------------------------------
+ *
+ * appendinfo.c
+ *	  Routines for mapping between append parent(s) and children
+ *
+ * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/optimizer/path/appendinfo.c
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include "access/htup_details.h"
+#include "access/sysattr.h"
+#include "nodes/makefuncs.h"
+#include "nodes/nodeFuncs.h"
+#include "optimizer/appendinfo.h"
+#include "parser/parsetree.h"
+#include "utils/rel.h"
+#include "utils/lsyscache.h"
+#include "utils/syscache.h"
+
+typedef struct
+{
+	PlannerInfo *root;
+	int			nappinfos;
+	AppendRelInfo **appinfos;
+} adjust_appendrel_attrs_context;
+
+static void make_inh_translation_list(TupleDesc old_tupdesc,
+						  TupleDesc new_tupdesc,
+						  Oid from_rel, Oid to_rel,
+						  Index newvarno, List **translated_vars);
+static Node *adjust_appendrel_attrs_mutator(Node *node,
+							   adjust_appendrel_attrs_context *context);
+static Relids adjust_child_relids(Relids relids, int nappinfos,
+					AppendRelInfo **appinfos);
+static List *adjust_inherited_tlist(List *tlist,
+					   AppendRelInfo *context);
+
+AppendRelInfo *
+make_append_rel_info(RelOptInfo *parentrel, RangeTblEntry *parentrte,
+					 TupleDesc childdesc, Oid childoid, Oid childreltype,
+					 Index childRTindex)
+{
+	AppendRelInfo  *appinfo = makeNode(AppendRelInfo);
+
+	appinfo->parent_relid = parentrel->relid;
+	appinfo->child_relid = childRTindex;
+	appinfo->parent_reltype = parentrel->reltype;
+	appinfo->child_reltype = childreltype;
+	make_inh_translation_list(parentrel->tupdesc, childdesc,
+							  parentrte->relid, childoid,
+							  childRTindex,
+							  &appinfo->translated_vars);
+	appinfo->parent_reloid = parentrte->relid;
+
+	return appinfo;
+}
+
+/*
+ * adjust_appendrel_attrs
+ *	  Copy the specified query or expression and translate Vars referring to a
+ *	  parent rel to refer to the corresponding child rel instead.  We also
+ *	  update rtindexes appearing outside Vars, such as resultRelation and
+ *	  jointree relids.
+ *
+ * Note: this is only applied after conversion of sublinks to subplans,
+ * so we don't need to cope with recursion into sub-queries.
+ *
+ * Note: this is not hugely different from what pullup_replace_vars() does;
+ * maybe we should try to fold the two routines together.
+ */
+Node *
+adjust_appendrel_attrs(PlannerInfo *root, Node *node, int nappinfos,
+					   AppendRelInfo **appinfos)
+{
+	Node	   *result;
+	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);
+
+	/*
+	 * Must be prepared to start with a Query or a bare expression tree.
+	 */
+	if (node && IsA(node, Query))
+	{
+		Query	   *newnode;
+		int			cnt;
+
+		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;
+}
+
+static Node *
+adjust_appendrel_attrs_mutator(Node *node,
+							   adjust_appendrel_attrs_context *context)
+{
+	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;
+
+		for (cnt = 0; cnt < nappinfos; cnt++)
+		{
+			if (var->varno == appinfos[cnt]->parent_relid)
+			{
+				appinfo = appinfos[cnt];
+				break;
+			}
+		}
+
+		if (var->varlevelsup == 0 && appinfo)
+		{
+			var->varno = appinfo->child_relid;
+			var->varnoold = appinfo->child_relid;
+			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));
+				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;
+
+					return (Node *) rowexpr;
+				}
+			}
+			/* system attributes don't need any other translation */
+		}
+		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, 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 */
+		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, context->nappinfos,
+											  context->appinfos);
+		return (Node *) phv;
+	}
+
+	/*
+	 * This is needed, because inheritance_make_rel_from_joinlist needs to
+	 * translate root->join_info_list executing make_rel_from_joinlist for a
+	 * given child.
+	 */
+	if (IsA(node, SpecialJoinInfo))
+	{
+		SpecialJoinInfo *oldinfo = (SpecialJoinInfo *) node;
+		SpecialJoinInfo *newinfo = makeNode(SpecialJoinInfo);
+
+		memcpy(newinfo, oldinfo, sizeof(SpecialJoinInfo));
+		newinfo->min_lefthand = adjust_child_relids(oldinfo->min_lefthand,
+													context->nappinfos,
+													context->appinfos);
+		newinfo->min_righthand = adjust_child_relids(oldinfo->min_righthand,
+													 context->nappinfos,
+													 context->appinfos);
+		newinfo->syn_lefthand = adjust_child_relids(oldinfo->syn_lefthand,
+													context->nappinfos,
+													context->appinfos);
+		newinfo->syn_righthand = adjust_child_relids(oldinfo->syn_righthand,
+													 context->nappinfos,
+													 context->appinfos);
+		newinfo->semi_rhs_exprs =
+					(List *) expression_tree_mutator((Node *)
+													 oldinfo->semi_rhs_exprs,
+													 adjust_appendrel_attrs_mutator,
+													 (void *) context);
+		return (Node *) newinfo;
+	}
+
+	/* Shouldn't need to handle planner auxiliary nodes here */
+	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 */
+		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->nullable_relids = adjust_child_relids(oldinfo->nullable_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));
+
+	return expression_tree_mutator(node, adjust_appendrel_attrs_mutator,
+								   (void *) context);
+}
+
+/*
+ * Substitute child relids for parent relids in a Relid set.  The array of
+ * appinfos specifies the substitutions to be performed.
+ */
+static Relids
+adjust_child_relids(Relids relids, int nappinfos, AppendRelInfo **appinfos)
+{
+	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;
+}
+
+/*
+ * Replace any relid present in top_parent_relids with its child in
+ * child_relids. Members of child_relids can be multiple levels below top
+ * parent in the partition hierarchy.
+ */
+Relids
+adjust_child_relids_multilevel(PlannerInfo *root, Relids relids,
+							   Relids child_relids, Relids top_parent_relids)
+{
+	AppendRelInfo **appinfos;
+	int			nappinfos;
+	Relids		parent_relids = NULL;
+	Relids		result;
+	Relids		tmp_result = NULL;
+	int			cnt;
+
+	/*
+	 * If the given relids set doesn't contain any of the top parent relids,
+	 * it will remain unchanged.
+	 */
+	if (!bms_overlap(relids, top_parent_relids))
+		return relids;
+
+	appinfos = find_appinfos_by_relids(root, child_relids, &nappinfos);
+
+	/* Construct relids set for the immediate parent of the given child. */
+	for (cnt = 0; cnt < nappinfos; cnt++)
+	{
+		AppendRelInfo *appinfo = appinfos[cnt];
+
+		parent_relids = bms_add_member(parent_relids, appinfo->parent_relid);
+	}
+
+	/* Recurse if immediate parent is not the top parent. */
+	if (!bms_equal(parent_relids, top_parent_relids))
+	{
+		tmp_result = adjust_child_relids_multilevel(root, relids,
+													parent_relids,
+													top_parent_relids);
+		relids = tmp_result;
+	}
+
+	result = adjust_child_relids(relids, nappinfos, appinfos);
+
+	/* Free memory consumed by any intermediate result. */
+	if (tmp_result)
+		bms_free(tmp_result);
+	bms_free(parent_relids);
+	pfree(appinfos);
+
+	return result;
+}
+
+/*
+ * adjust_appendrel_attrs_multilevel
+ *	  Apply Var translations from a toplevel appendrel parent down to a child.
+ *
+ * In some cases we need to translate expressions referencing a parent relation
+ * to reference an appendrel child that's multiple levels removed from it.
+ */
+Node *
+adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node,
+								  Relids child_relids,
+								  Relids top_parent_relids)
+{
+	AppendRelInfo **appinfos;
+	Bitmapset  *parent_relids = NULL;
+	int			nappinfos;
+	int			cnt;
+
+	Assert(bms_num_members(child_relids) == bms_num_members(top_parent_relids));
+
+	appinfos = find_appinfos_by_relids(root, child_relids, &nappinfos);
+
+	/* Construct relids set for the immediate parent of given child. */
+	for (cnt = 0; cnt < nappinfos; cnt++)
+	{
+		AppendRelInfo *appinfo = appinfos[cnt];
+
+		parent_relids = bms_add_member(parent_relids, appinfo->parent_relid);
+	}
+
+	/* Recurse if immediate parent is not the top parent. */
+	if (!bms_equal(parent_relids, top_parent_relids))
+		node = adjust_appendrel_attrs_multilevel(root, node, parent_relids,
+												 top_parent_relids);
+
+	/* Now translate for this child */
+	node = adjust_appendrel_attrs(root, node, nappinfos, appinfos);
+
+	pfree(appinfos);
+
+	return node;
+}
+
+/*
+ * Construct the SpecialJoinInfo for a child-join by translating
+ * SpecialJoinInfo for the join between parents. left_relids and right_relids
+ * are the relids of left and right side of the join respectively.
+ */
+SpecialJoinInfo *
+build_child_join_sjinfo(PlannerInfo *root, SpecialJoinInfo *parent_sjinfo,
+						Relids left_relids, Relids right_relids)
+{
+	SpecialJoinInfo *sjinfo = makeNode(SpecialJoinInfo);
+	AppendRelInfo **left_appinfos;
+	int			left_nappinfos;
+	AppendRelInfo **right_appinfos;
+	int			right_nappinfos;
+
+	memcpy(sjinfo, parent_sjinfo, sizeof(SpecialJoinInfo));
+	left_appinfos = find_appinfos_by_relids(root, left_relids,
+											&left_nappinfos);
+	right_appinfos = find_appinfos_by_relids(root, right_relids,
+											 &right_nappinfos);
+
+	sjinfo->min_lefthand = adjust_child_relids(sjinfo->min_lefthand,
+											   left_nappinfos, left_appinfos);
+	sjinfo->min_righthand = adjust_child_relids(sjinfo->min_righthand,
+												right_nappinfos,
+												right_appinfos);
+	sjinfo->syn_lefthand = adjust_child_relids(sjinfo->syn_lefthand,
+											   left_nappinfos, left_appinfos);
+	sjinfo->syn_righthand = adjust_child_relids(sjinfo->syn_righthand,
+												right_nappinfos,
+												right_appinfos);
+	sjinfo->semi_rhs_exprs = (List *) adjust_appendrel_attrs(root,
+															 (Node *) sjinfo->semi_rhs_exprs,
+															 right_nappinfos,
+															 right_appinfos);
+
+	pfree(left_appinfos);
+	pfree(right_appinfos);
+
+	return sjinfo;
+}
+
+/*
+ * find_appinfos_by_relids
+ * 		Find AppendRelInfo structures for all relations specified by relids.
+ *
+ * The AppendRelInfos are returned in an array, which can be pfree'd by the
+ * caller. *nappinfos is set to the number of entries in the array.
+ */
+AppendRelInfo **
+find_appinfos_by_relids(PlannerInfo *root, Relids relids, int *nappinfos)
+{
+	AppendRelInfo **appinfos;
+	int			cnt = 0;
+	int			i;
+
+	*nappinfos = bms_num_members(relids);
+	appinfos = (AppendRelInfo **) palloc(sizeof(AppendRelInfo *) * *nappinfos);
+
+	i = -1;
+	while ((i = bms_next_member(relids, i)) >= 0)
+	{
+		AppendRelInfo *appinfo = root->append_rel_array[i];
+
+		if (!appinfo)
+			elog(ERROR, "child rel %d not found in append_rel_array", i);
+
+		appinfos[cnt++] = appinfo;
+	}
+	return appinfos;
+}
+
+/*
+ * make_inh_translation_list
+ *	  Build the list of translations from parent Vars to child Vars for
+ *	  an inheritance child.
+ *
+ * For paranoia's sake, we match type/collation as well as attribute name.
+ */
+static void
+make_inh_translation_list(TupleDesc old_tupdesc, TupleDesc new_tupdesc,
+						  Oid from_rel, Oid to_rel,
+						  Index newvarno, List **translated_vars)
+{
+	List	   *vars = NIL;
+	int			oldnatts = old_tupdesc->natts;
+	int			newnatts = new_tupdesc->natts;
+	int			old_attno;
+	int			new_attno = 0;
+
+	for (old_attno = 0; old_attno < oldnatts; old_attno++)
+	{
+		Form_pg_attribute att;
+		char	   *attname;
+		Oid			atttypid;
+		int32		atttypmod;
+		Oid			attcollation;
+
+		att = TupleDescAttr(old_tupdesc, old_attno);
+		if (att->attisdropped)
+		{
+			/* Just put NULL into this list entry */
+			vars = lappend(vars, NULL);
+			continue;
+		}
+		attname = NameStr(att->attname);
+		atttypid = att->atttypid;
+		atttypmod = att->atttypmod;
+		attcollation = att->attcollation;
+
+		/*
+		 * When we are generating the "translation list" for the parent table
+		 * of an inheritance set, no need to search for matches.
+		 */
+		if (from_rel == to_rel)
+		{
+			vars = lappend(vars, makeVar(newvarno,
+										 (AttrNumber) (old_attno + 1),
+										 atttypid,
+										 atttypmod,
+										 attcollation,
+										 0));
+			continue;
+		}
+
+		/*
+		 * Otherwise we have to search for the matching column by name.
+		 * There's no guarantee it'll have the same column position, because
+		 * of cases like ALTER TABLE ADD COLUMN and multiple inheritance.
+		 * However, in simple cases, the relative order of columns is mostly
+		 * the same in both relations, so try the column of newrelation that
+		 * follows immediately after the one that we just found, and if that
+		 * fails, let syscache handle it.
+		 */
+		if (new_attno >= newnatts ||
+			(att = TupleDescAttr(new_tupdesc, new_attno))->attisdropped ||
+			strcmp(attname, NameStr(att->attname)) != 0)
+		{
+			HeapTuple	newtup;
+
+			newtup = SearchSysCacheAttName(to_rel, attname);
+			if (!newtup)
+				elog(ERROR, "could not find inherited attribute \"%s\" of relation \"%s\"",
+					 attname, get_rel_name(to_rel));
+			new_attno = ((Form_pg_attribute) GETSTRUCT(newtup))->attnum - 1;
+			ReleaseSysCache(newtup);
+
+			att = TupleDescAttr(new_tupdesc, new_attno);
+		}
+
+		/* Found it, check type and collation match */
+		if (atttypid != att->atttypid || atttypmod != att->atttypmod)
+			elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's type",
+				 attname, get_rel_name(to_rel));
+		if (attcollation != att->attcollation)
+			elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's collation",
+				 attname, get_rel_name(to_rel));
+
+		vars = lappend(vars, makeVar(newvarno,
+									 (AttrNumber) (new_attno + 1),
+									 atttypid,
+									 atttypmod,
+									 attcollation,
+									 0));
+		new_attno++;
+	}
+
+	*translated_vars = vars;
+}
+
+/*
+ * translate_col_privs
+ *	  Translate a bitmapset representing per-column privileges from the
+ *	  parent rel's attribute numbering to the child's.
+ *
+ * The only surprise here is that we don't translate a parent whole-row
+ * reference into a child whole-row reference.  That would mean requiring
+ * permissions on all child columns, which is overly strict, since the
+ * query is really only going to reference the inherited columns.  Instead
+ * we set the per-column bits for all inherited columns.
+ */
+Bitmapset *
+translate_col_privs(const Bitmapset *parent_privs,
+					List *translated_vars)
+{
+	Bitmapset  *child_privs = NULL;
+	bool		whole_row;
+	int			attno;
+	ListCell   *lc;
+
+	/* System attributes have the same numbers in all tables */
+	for (attno = FirstLowInvalidHeapAttributeNumber + 1; attno < 0; attno++)
+	{
+		if (bms_is_member(attno - FirstLowInvalidHeapAttributeNumber,
+						  parent_privs))
+			child_privs = bms_add_member(child_privs,
+										 attno - FirstLowInvalidHeapAttributeNumber);
+	}
+
+	/* Check if parent has whole-row reference */
+	whole_row = bms_is_member(InvalidAttrNumber - FirstLowInvalidHeapAttributeNumber,
+							  parent_privs);
+
+	/* And now translate the regular user attributes, using the vars list */
+	attno = InvalidAttrNumber;
+	foreach(lc, translated_vars)
+	{
+		Var		   *var = lfirst_node(Var, lc);
+
+		attno++;
+		if (var == NULL)		/* ignore dropped columns */
+			continue;
+		if (whole_row ||
+			bms_is_member(attno - FirstLowInvalidHeapAttributeNumber,
+						  parent_privs))
+			child_privs = bms_add_member(child_privs,
+										 var->varattno - FirstLowInvalidHeapAttributeNumber);
+	}
+
+	return child_privs;
+}
+
+/*
+ * 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.
+ */
+static List *
+adjust_inherited_tlist(List *tlist, AppendRelInfo *context)
+{
+	bool		changed_it = false;
+	ListCell   *tl;
+	List	   *new_tlist;
+	bool		more;
+	int			attrno;
+
+	/* 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)
+	{
+		TargetEntry *tle = (TargetEntry *) lfirst(tl);
+		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))
+			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);
+		if (childvar == NULL || !IsA(childvar, Var))
+			elog(ERROR, "attribute %d of relation \"%s\" does not exist",
+				 tle->resno, get_rel_name(context->parent_reloid));
+
+		if (tle->resno != childvar->varattno)
+		{
+			tle->resno = childvar->varattno;
+			changed_it = true;
+		}
+	}
+
+	/*
+	 * 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;
+
+	new_tlist = NIL;
+	more = true;
+	for (attrno = 1; more; attrno++)
+	{
+		more = false;
+		foreach(tl, tlist)
+		{
+			TargetEntry *tle = (TargetEntry *) lfirst(tl);
+
+			if (tle->resjunk)
+				continue;		/* ignore junk items */
+
+			if (tle->resno == attrno)
+				new_tlist = lappend(new_tlist, tle);
+			else if (tle->resno > attrno)
+				more = true;
+		}
+	}
+
+	foreach(tl, tlist)
+	{
+		TargetEntry *tle = (TargetEntry *) lfirst(tl);
+
+		if (!tle->resjunk)
+			continue;			/* here, ignore non-junk items */
+
+		tle->resno = attrno;
+		new_tlist = lappend(new_tlist, tle);
+		attrno++;
+	}
+
+	return new_tlist;
+}
diff --git a/src/backend/optimizer/util/inherit.c b/src/backend/optimizer/util/inherit.c
new file mode 100644
index 0000000000..38a0a7635c
--- /dev/null
+++ b/src/backend/optimizer/util/inherit.c
@@ -0,0 +1,776 @@
+/*-------------------------------------------------------------------------
+ *
+ * inherit.c
+ *	  Routines to process child relations in inheritance trees
+ *
+ * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/optimizer/path/inherit.c
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include <limits.h>
+
+#include "access/sysattr.h"
+#include "catalog/partition.h"
+#include "catalog/pg_class.h"
+#include "catalog/pg_inherits.h"
+#include "catalog/pg_type.h"
+#include "nodes/makefuncs.h"
+#include "optimizer/appendinfo.h"
+#include "optimizer/clauses.h"
+#include "optimizer/inherit.h"
+#include "optimizer/pathnode.h"
+#include "optimizer/paths.h"
+#include "optimizer/plancat.h"
+#include "optimizer/planmain.h"
+#include "optimizer/planner.h"
+#include "optimizer/prep.h"
+#include "optimizer/restrictinfo.h"
+#include "optimizer/tlist.h"
+#include "optimizer/var.h"
+#include "partitioning/partprune.h"
+#include "utils/rel.h"
+
+static void expand_append_rtentry(PlannerInfo *root, RelOptInfo *rel,
+					  RangeTblEntry *rte, Index rti);
+static void expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte,
+						 Index rti, RelOptInfo *rel);
+static void expand_partitioned_rtentry(PlannerInfo *root,
+						   RangeTblEntry *parentrte,
+						   Index parentRTindex, RelOptInfo *parentrel);
+static RelOptInfo *add_inheritance_child_rel(PlannerInfo *root,
+						  RangeTblEntry *parentrte,
+						  Index parentRTindex, RelOptInfo *parentrel,
+						  PlanRowMark *top_parentrc, Relation childrel,
+						  RangeTblEntry **childrte_p, Index *childRTindex_p);
+static RelOptInfo *build_append_child_rel(PlannerInfo *root,
+					   RelOptInfo *parent,
+					   Index childRTindex);
+static List *add_rowmark_junk_columns(PlannerInfo *root, PlanRowMark *rc);
+
+
+/*
+ * expand_inherited_tables
+ *		Expand each rangetable entry that represents an inheritance set
+ *		into an "append relation".  At the conclusion of this process,
+ *		the "inh" flag is set in all and only those RTEs that are append
+ *		relation parents.
+ */
+void
+expand_inherited_tables(PlannerInfo *root)
+{
+	int			orig_rtable_size;
+	Index		rti;
+
+	Assert(root->simple_rel_array_size > 0);
+	orig_rtable_size = root->simple_rel_array_size;
+
+	/*
+	 * expand_append_rtentry may add RTEs to parse->rtable. The function is
+	 * expected to recursively handle any RTEs that it creates with inh=true.
+	 * So just scan as far as the original end of the rtable list.
+	 */
+	for (rti = 1; rti < orig_rtable_size; rti++)
+	{
+		RelOptInfo *brel = root->simple_rel_array[rti];
+		RangeTblEntry *rte = root->simple_rte_array[rti];
+
+		/* there may be empty slots corresponding to non-baserel RTEs */
+		if (brel == NULL)
+			continue;
+
+		if (rte->inh)
+			expand_append_rtentry(root, brel, rte, rti);
+	}
+}
+
+/*
+ * expand_append_rtentry
+ *		This initializes RelOptInfos for an appendrel's child relations, if
+ *		any
+ *
+ * 'rel' is the appendrel parent, whose range table entry ('rte') has been
+ * marked to require adding children.  An appendrel parent could either
+ * be a subquery (if we flattened UNION ALL query) or a table that's known
+ * to have inheritance children.  The latter consists of both regular
+ * inheritance parents and partitioned tables.
+ *
+ * For a subquery parent, there is not much to be done here because the
+ * children's RTEs are already present in the query, so we just initialize
+ * RelOptInfos for them.  Also, the AppendRelInfos for child subqueries
+ * have already been added.
+ *
+ * For tables, we need to add the children to the range table and initialize
+ * AppendRelInfos, RelOptInfos, and PlanRowMarks (if any) for them.  For
+ * a partitioned parent, we only add the children remaining after pruning.
+ * For regular inheritance parents, we find the children using
+ * find_all_inheritors and add all of them.
+ *
+ * If it turns out that there are no children, then we set rte->inh to false
+ * to let the caller know that only the parent table needs to be scanned.  The
+ * caller can accordingly switch to a non-Append path.  For a partitioned
+ * parent, that means an empty relation because parents themselves contain no
+ * data.
+ *
+ * For the regular inheritance case, the parent also gets another RTE with
+ * inh = false to represent it as an appendrel child.  The original RTE is
+ * considered to represent the whole inheritance set.
+ */
+static void
+expand_append_rtentry(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte,
+					  Index rti)
+{
+	Assert(rte->inh);
+	/* Inheritance parent (partitioned or not) or UNION ALL parent subquery. */
+	Assert(rte->rtekind == RTE_RELATION || rte->rtekind == RTE_SUBQUERY);
+
+	/*
+	 * UNION ALL children already got RTEs and AppendRelInfos, so just build
+	 * RelOptInfos and return.
+	 *
+	 * It might be a bit odd that this code is in this, because there is
+	 * nothing to expand really.
+	 */
+	if (rte->rtekind == RTE_SUBQUERY)
+	{
+		ListCell   *l;
+
+		/*
+		 * We don't need to use expand_planner_arrays in this case, because
+		 * no new child RTEs are created.  setup_simple_rel_arrays() and
+		 * setup_append_rel_array would've considered these child RTEs when
+		 * allocating space for various arrays.
+		 */
+		foreach(l, root->append_rel_list)
+		{
+			AppendRelInfo *appinfo = lfirst(l);
+			Index		childRTindex = appinfo->child_relid;
+
+			if (appinfo->parent_relid != rti)
+				continue;
+
+			Assert(childRTindex < root->simple_rel_array_size);
+			Assert(root->simple_rte_array[childRTindex] != NULL);
+
+			/*
+			 * We set the correct value of baserestricinfo and
+			 * baserestrict_min_security below.
+			 */
+			root->simple_rel_array[childRTindex] =
+				build_append_child_rel(root, rel, appinfo->child_relid);
+		}
+	}
+	else
+	{
+		Assert(rte->rtekind == RTE_RELATION);
+		Assert(has_subclass(rte->relid));
+
+		/*
+		 * The rewriter should already have obtained an appropriate lock on
+		 * each relation named in the query.  However, for each child relation
+		 * we add to the query, we must obtain an appropriate lock, because
+		 * this will be the first use of those relations in the
+		 * parse/rewrite/plan pipeline.  Child rels should use the same
+		 * lockmode as their parent.
+		 */
+		Assert(rte->rellockmode != NoLock);
+
+		if (rte->relkind == RELKIND_PARTITIONED_TABLE)
+			expand_partitioned_rtentry(root, rte, rti, rel);
+		else
+			expand_inherited_rtentry(root, rte, rti, rel);
+	}
+}
+
+/*
+ * expand_inherited_rtentry
+ *		Add entries for all the child tables to the query's rangetable, and
+ *		build AppendRelInfo nodes for all the child tables and add them to
+ *		root->append_rel_list.
+ *
+ * Note that the original RTE is considered to represent the whole
+ * inheritance set.  The first of the generated RTEs is an RTE for the same
+ * table, but with inh = false, to represent the parent table in its role
+ * as a simple member of the inheritance set.
+ *
+ * A childless table is never considered to be an inheritance set. For
+ * regular inheritance, a parent RTE must always have at least two associated
+ * AppendRelInfos: one corresponding to the parent table as a simple member of
+ * inheritance set and one or more corresponding to the actual children.
+ */
+static void
+expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti,
+						 RelOptInfo *rel)
+{
+	Oid			parentOID;
+	PlanRowMark *oldrc;
+	LOCKMODE	lockmode = rte->rellockmode;
+	List	   *inhOIDs;
+	ListCell   *l;
+	int			num_children;
+	int			num_children_added = 0;
+
+	Assert(rte->rtekind == RTE_RELATION);
+	Assert(lockmode != NoLock);
+	parentOID = rte->relid;
+
+	/* Scan for all members of inheritance set, acquire needed locks */
+	inhOIDs = find_all_inheritors(parentOID, lockmode, NULL);
+
+	/*
+	 * Check that there's at least one descendant, else treat as no-child
+	 * case.  This could happen despite has_subclass() check performed by
+	 * subquery_planner, if table once had a child but no longer does.
+	 */
+	num_children = list_length(inhOIDs);
+	if (num_children < 2)
+	{
+		/* Clear flag before returning */
+		rte->inh = false;
+		return;
+	}
+
+	/*
+	 * If parent relation is selected FOR UPDATE/SHARE, preprocess_rowmarks
+	 * should've set isParent = true.  We'll generate a new PlanRowMark for
+	 * each child.
+	 */
+	oldrc = get_plan_rowmark(root->rowMarks, rti);
+	Assert(oldrc == NULL || oldrc->isParent);
+
+	/*
+	 * Must expand PlannerInfo arrays by num_children before we can add
+	 * children.
+	 */
+	expand_planner_arrays(root, num_children);
+
+	foreach(l, inhOIDs)
+	{
+		Oid			childOID = lfirst_oid(l);
+		Relation	newrelation;
+		RangeTblEntry *childrte;
+		Index		childRTindex;
+
+		/* Already locked above. */
+		newrelation = heap_open(childOID, NoLock);
+
+		/*
+		 * It is possible that the parent table has children that are temp
+		 * tables of other backends.  We cannot safely access such tables
+		 * (because of buffering issues), and the best thing to do seems
+		 * to be to silently ignore them.
+		 */
+		if (RELATION_IS_OTHER_TEMP(newrelation))
+		{
+			heap_close(newrelation, lockmode);
+			continue;
+		}
+
+		(void) add_inheritance_child_rel(root, rte, rti, rel, oldrc,
+										 newrelation, &childrte,
+										 &childRTindex);
+		Assert(childrte != NULL);
+		/* All regular inheritance children are leaf children. */
+		Assert(!childrte->inh);
+		Assert(childRTindex > 0);
+
+		/* Close child relations, but keep locks */
+		heap_close(newrelation, NoLock);
+		num_children_added++;
+	}
+
+	/*
+	 * If all children, including the parent (as child rel), were
+	 * excluded, mark the parent rel as empty.  If all the children were temp
+	 * tables, pretend it's a non-inheritance situation; we don't need Append
+	 * node in that case.  The duplicate RTE we added for the parent table is
+	 * harmless, so we don't bother to get rid of it; ditto for the useless
+	 * PlanRowMark node.
+	 */
+	if (num_children_added == 0)
+		mark_dummy_rel(rel);
+	else if (num_children_added == 1)
+		rte->inh = false;
+
+	/*
+	 * Add junk columns needed by the row mark if any and also add the
+	 * relevant expressions to the root parent's reltarget.
+	 */
+	if (oldrc)
+	{
+		List   *tlist = add_rowmark_junk_columns(root, oldrc);
+
+		build_base_rel_tlists(root, tlist);
+	}
+}
+
+/*
+ * expand_partitioned_rtentry
+ *		Prunes unnecessary partitions of a partitioned table and adds
+ *		remaining ones to the Query and the PlannerInfo
+ *
+ * Partitions are added to the query in order in which they are found in
+ * the parent's PartitionDesc.
+ *
+ * Note: even though only the unpruned partitions will be added to the
+ * resulting plan, this still locks *all* partitions via find_all_inheritors
+ * when this function is called for the root partitioned table.
+ */
+static void
+expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
+						   Index parentRTindex, RelOptInfo *parentrel)
+{
+	LOCKMODE	lockmode = parentrte->rellockmode;
+	PlanRowMark *rootrc = NULL;
+	int			i;
+	Bitmapset  *partindexes;
+	Index		rootParentRTindex = parentrel->inh_root_parent > 0 ?
+									parentrel->inh_root_parent :
+									parentRTindex;
+
+	/* If root partitioned table, lock *all* partitions in the tree. */
+	if (parentRTindex == rootParentRTindex)
+		(void) find_all_inheritors(parentrte->relid, lockmode, NULL);
+
+	/*
+	 * Initialize partitioned_child_rels to contain this RT index.
+	 *
+	 * Note that during the set_append_rel_pathlist() phase, values of the
+	 * indexes of partitioned relations that appear down in the tree will be
+	 * bubbled up into root parent's list so that when we've created Paths for
+	 * all the children, the root table's list will contain all such indexes.
+	 */
+	parentrel->partitioned_child_rels = list_make1_int(parentRTindex);
+
+	/* Perform pruning. */
+	partindexes = prune_append_rel_partitions(parentrel);
+
+	/* Must expand PlannerInfo arrays before we can add children. */
+	expand_planner_arrays(root, bms_num_members(partindexes));
+
+	/*
+	 * For partitioned tables, we also store the partition RelOptInfo
+	 * pointers in the parent's RelOptInfo.
+	 */
+	parentrel->part_rels = (RelOptInfo **) palloc0(sizeof(RelOptInfo *) *
+												   parentrel->nparts);
+
+	rootrc = get_plan_rowmark(root->rowMarks, rootParentRTindex);
+	Assert(rootrc == NULL || rootrc->isParent);
+	i = -1;
+	while ((i = bms_next_member(partindexes, i)) >= 0)
+	{
+		Oid		childOID = parentrel->part_oids[i];
+		Relation	newrelation;
+		RelOptInfo *childrel;
+		RangeTblEntry *childrte;
+		Index		childRTindex;
+
+		/* Already locked above. */
+		newrelation = heap_open(childOID, NoLock);
+		Assert(!RELATION_IS_OTHER_TEMP(newrelation));
+
+		/*
+		 * A partitioned child table with 0 children is a dummy rel, so don't
+		 * bother creating planner objects for it.
+		 */
+		if (newrelation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE &&
+			RelationGetPartitionDesc(newrelation)->nparts == 0)
+		{
+			heap_close(newrelation, NoLock);
+			continue;
+		}
+
+		childrel = add_inheritance_child_rel(root, parentrte, parentRTindex,
+											 parentrel, rootrc, newrelation,
+											 &childrte, &childRTindex);
+		Assert(childrel != NULL);
+		parentrel->part_rels[i] = childrel;
+
+		/* Close child relations, but keep locks */
+		heap_close(newrelation, NoLock);
+
+		/* If the child is partitioned itself, expand it too. */
+		if (childrel->part_scheme)
+		{
+			Assert(childrte->inh);
+			expand_partitioned_rtentry(root, childrte, childRTindex,
+									   childrel);
+		}
+	}
+
+	/*
+	 * Add junk columns needed by the row mark if any and also add the
+	 * relevant expressions to the root parent's reltarget.
+	 */
+	if (rootrc)
+	{
+		List   *tlist = add_rowmark_junk_columns(root, rootrc);
+
+		build_base_rel_tlists(root, tlist);
+	}
+}
+
+/*
+ * add_inheritance_child_rel
+ *		Build a RangeTblEntry, an AppendRelInfo, a PlanRowMark, and finally
+ *		a RelOptInfo for an inheritance child relation.
+ *
+ * The return value is the RelOptInfo that's added.
+ *
+ * PlanRowMarks still carry the top-parent's RTI, and the top-parent's
+ * allMarkTypes field still accumulates values from all descendents.
+ *
+ * "parentrte" and "parentRTindex" are immediate parent's RTE and
+ * RTI. "top_parentrc" is top parent's PlanRowMark.
+ */
+static RelOptInfo *
+add_inheritance_child_rel(PlannerInfo *root, RangeTblEntry *parentrte,
+						  Index parentRTindex, RelOptInfo *parentrel,
+						  PlanRowMark *top_parentrc, Relation childrel,
+						  RangeTblEntry **childrte_p, Index *childRTindex_p)
+{
+	Query	   *parse = root->parse;
+	Oid			childOID = RelationGetRelid(childrel);
+	RangeTblEntry *childrte;
+	Index		childRTindex;
+	AppendRelInfo *appinfo;
+	RelOptInfo *childrelopt;
+
+	/*
+	 * Build an RTE for the child, and attach to query's rangetable list. We
+	 * copy most fields of the parent's RTE, but replace relation OID and
+	 * relkind, and set inh appropriately.  Also, set requiredPerms to zero
+	 * since all required permissions checks are done on the original RTE.
+	 * Likewise, set the child's securityQuals to empty, because we only want
+	 * to apply the parent's RLS conditions regardless of what RLS properties
+	 * individual children may have.  (This is an intentional choice to make
+	 * inherited RLS work like regular permissions checks.) The parent
+	 * securityQuals will be propagated to children along with other base
+	 * restriction clauses, so we don't need to do it here.
+	 */
+	childrte = copyObject(parentrte);
+	*childrte_p = childrte;
+	childrte->relid = childOID;
+	childrte->relkind = childrel->rd_rel->relkind;
+	/*
+	 * A partitioned child will need to be expanded as an append parent
+	 * itself, so set its inh to true.
+	 */
+	childrte->inh = (childrte->relkind == RELKIND_PARTITIONED_TABLE);
+	childrte->requiredPerms = 0;
+	childrte->securityQuals = NIL;
+	parse->rtable = lappend(parse->rtable, childrte);
+	childRTindex = list_length(parse->rtable);
+	*childRTindex_p = childRTindex;
+
+	/* Create an AppendRelInfo and add it to planner's global list. */
+	appinfo = make_append_rel_info(parentrel, parentrte,
+								   childrel->rd_att,
+								   childOID,
+								   childrel->rd_rel->reltype,
+								   childRTindex);
+	root->append_rel_list = lappend(root->append_rel_list, appinfo);
+
+	/*
+	 * Translate the column permissions bitmaps to the child's attnums (we
+	 * have to build the translated_vars list before we can do this). But
+	 * if this is the parent table, leave copyObject's result alone.
+	 *
+	 * Note: we need to do this even though the executor won't run any
+	 * permissions checks on the child RTE.  The insertedCols/updatedCols
+	 * bitmaps may be examined for trigger-firing purposes.
+	 */
+	if (childrte->relid != parentrte->relid)
+	{
+		childrte->selectedCols = translate_col_privs(parentrte->selectedCols,
+													 appinfo->translated_vars);
+		childrte->insertedCols = translate_col_privs(parentrte->insertedCols,
+													 appinfo->translated_vars);
+		childrte->updatedCols = translate_col_privs(parentrte->updatedCols,
+													appinfo->translated_vars);
+	}
+
+	/*
+	 * Build a PlanRowMark if parent is marked FOR UPDATE/SHARE.
+	 */
+	if (top_parentrc)
+	{
+		PlanRowMark *childrc = makeNode(PlanRowMark);
+
+		childrc->rti = childRTindex;
+		childrc->prti = top_parentrc->rti;
+		childrc->rowmarkId = top_parentrc->rowmarkId;
+		/* Reselect rowmark type, because relkind might not match parent */
+		childrc->markType = select_rowmark_type(childrte,
+												top_parentrc->strength);
+		childrc->allMarkTypes = (1 << childrc->markType);
+		childrc->strength = top_parentrc->strength;
+		childrc->waitPolicy = top_parentrc->waitPolicy;
+
+		/*
+		 * We mark RowMarks for partitioned child tables as parent RowMarks so
+		 * that the executor ignores them (except their existence means that
+		 * the child tables be locked using appropriate mode).
+		 */
+		childrc->isParent = (childrte->relkind == RELKIND_PARTITIONED_TABLE);
+
+		/* Include child's rowmark type in top parent's allMarkTypes */
+		top_parentrc->allMarkTypes |= childrc->allMarkTypes;
+
+		root->rowMarks = lappend(root->rowMarks, childrc);
+	}
+
+	/*
+	 * Add the RelOptInfo.  Even though we may not really scan this relation
+	 * for reasons such as contradictory quals, we still need to create one,
+	 * because for every RTE in the query's range table, there must be an
+	 * accompanying RelOptInfo.
+	 */
+
+	/* First, store the RTE and appinfos into planner arrays. */
+	Assert(root->simple_rte_array[childRTindex] == NULL);
+	root->simple_rte_array[childRTindex] = childrte;
+	Assert(root->append_rel_array[childRTindex] == NULL);
+	root->append_rel_array[childRTindex] = appinfo;
+
+	childrelopt = build_append_child_rel(root, parentrel, childRTindex);
+	Assert(childrelopt != NULL);
+
+	return childrelopt;
+}
+
+/*
+ *	build_append_child_rel
+ *		Build a RelOptInfo for child relation of an append rel
+ *
+ * After creating the RelOptInfo for the given child RT index, it goes on to
+ * initialize some of its fields based on the parent RelOptInfo.
+ *
+ * If the quals in baserestrictinfo turn out to be self-contradictory, the
+ * RelOptInfo is marked dummy before returning.
+ */
+static RelOptInfo *
+build_append_child_rel(PlannerInfo *root,
+					   RelOptInfo *parent,
+					   Index childRTindex)
+{
+	RelOptInfo *childrel;
+	RangeTblEntry *childRTE = root->simple_rte_array[childRTindex];
+	AppendRelInfo *appinfo = root->append_rel_array[childRTindex];
+	List	   *childquals;
+	ListCell   *lc;
+	bool		have_const_false_cq;
+	Index		cq_min_security;
+
+	/* Build the RelOptInfo. */
+	childrel = build_simple_rel(root, childRTindex, parent);
+
+	/*
+	 * Propagate lateral_relids and lateral_referencers from appendrel
+	 * parent rels to their child rels.  We intentionally give each child rel
+	 * the same minimum parameterization, even though it's quite possible that
+	 * some don't reference all the lateral rels.  This is because any append
+	 * path for the parent will have to have the same parameterization for
+	 * every child anyway, and there's no value in forcing extra
+	 * reparameterize_path() calls.  Similarly, a lateral reference to the
+	 * parent prevents use of otherwise-movable join rels for each child.
+	 */
+	childrel->direct_lateral_relids = parent->direct_lateral_relids;
+	childrel->lateral_relids = parent->lateral_relids;
+	childrel->lateral_referencers = parent->lateral_referencers;
+
+	/*
+	 * We have to copy the parent's quals to the child, with appropriate
+	 * substitution of variables.  However, only the baserestrictinfo
+	 * quals are needed before we can check for constraint exclusion; so
+	 * do that first and then check to see if we can disregard this child.
+	 *
+	 * The child rel's targetlist might contain non-Var expressions, which
+	 * means that substitution into the quals could produce opportunities
+	 * for const-simplification, and perhaps even pseudoconstant quals.
+	 * Therefore, transform each RestrictInfo separately to see if it
+	 * reduces to a constant or pseudoconstant.  (We must process them
+	 * separately to keep track of the security level of each qual.)
+	 */
+	childquals = false;
+	cq_min_security = UINT_MAX;
+	have_const_false_cq = false;
+	foreach(lc, parent->baserestrictinfo)
+	{
+		RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
+		Node	   *childqual = (Node *) rinfo->clause;
+		ListCell   *lc2;
+
+		Assert(IsA(rinfo, RestrictInfo));
+		childqual = adjust_appendrel_attrs(root, childqual,
+										   1, &appinfo);
+		childqual = eval_const_expressions(root, childqual);
+		/* check for flat-out constant */
+		if (childqual && IsA(childqual, Const))
+		{
+			if (((Const *) childqual)->constisnull ||
+				!DatumGetBool(((Const *) childqual)->constvalue))
+			{
+				/* Restriction reduces to constant FALSE or NULL */
+				have_const_false_cq = true;
+				break;
+			}
+			/* Restriction reduces to constant TRUE, so drop it */
+			continue;
+		}
+		/* might have gotten an AND clause, if so flatten it */
+		foreach(lc2, make_ands_implicit((Expr *) childqual))
+		{
+			Node	   *onecq = (Node *) lfirst(lc2);
+			bool		pseudoconstant;
+
+			/* check for pseudoconstant (no Vars or volatile functions) */
+			pseudoconstant =
+					!contain_vars_of_level(onecq, 0) &&
+					!contain_volatile_functions(onecq);
+			if (pseudoconstant)
+			{
+				/* tell createplan.c to check for gating quals */
+				root->hasPseudoConstantQuals = true;
+			}
+			/* reconstitute RestrictInfo with appropriate properties */
+			childquals = lappend(childquals,
+								 make_restrictinfo((Expr *) onecq,
+												   rinfo->is_pushed_down,
+												   rinfo->outerjoin_delayed,
+												   pseudoconstant,
+												   rinfo->security_level,
+												   NULL, NULL, NULL));
+			cq_min_security = Min(cq_min_security, rinfo->security_level);
+		}
+	}
+
+	/*
+	 * In addition to the quals inherited from the parent, we might
+	 * have securityQuals associated with this particular child node.
+	 * (Currently this can only happen in appendrels originating from
+	 * UNION ALL; inheritance child tables don't have their own
+	 * securityQuals.)	Pull any such securityQuals up into the
+	 * baserestrictinfo for the child.  This is similar to
+	 * process_security_barrier_quals() for the parent rel, except
+	 * that we can't make any general deductions from such quals,
+	 * since they don't hold for the whole appendrel.
+	 */
+	if (childRTE->securityQuals)
+	{
+		Index		security_level = 0;
+
+		foreach(lc, childRTE->securityQuals)
+		{
+			List	   *qualset = (List *) lfirst(lc);
+			ListCell   *lc2;
+
+			foreach(lc2, qualset)
+			{
+				Expr	   *qual = (Expr *) lfirst(lc2);
+
+				/*
+				 * not likely that we'd see constants here, so no
+				 * check
+				 */
+				childquals = lappend(childquals,
+									 make_restrictinfo(qual,
+													   true,
+													   false,
+													   false,
+													   security_level,
+													   NULL, NULL,
+													   NULL));
+				cq_min_security = Min(cq_min_security, security_level);
+			}
+			security_level++;
+		}
+		Assert(security_level <= root->qual_security_level);
+	}
+
+	/* Set child's version of baserestrictinfo. */
+	childrel->baserestrictinfo = childquals;
+	childrel->baserestrict_min_security = cq_min_security;
+
+	if (have_const_false_cq)
+	{
+		/*
+		 * Some restriction clause reduced to constant FALSE or NULL after
+		 * substitution, so this child need not be scanned.
+		 */
+		set_dummy_rel_pathlist(childrel);
+	}
+
+	return childrel;
+}
+
+/*
+ * add_rowmark_junk_columns
+ * 		Add necessary junk columns for rowmarked inheritance parent rel.
+ *
+ * These values are needed for locking of rels selected FOR UPDATE/SHARE, and
+ * to do EvalPlanQual rechecking.  See comments for PlanRowMark in
+ * plannodes.h.
+ */
+static List *
+add_rowmark_junk_columns(PlannerInfo *root, PlanRowMark *rc)
+{
+	List   *tlist = root->processed_tlist;
+	Var		   *var;
+	char		resname[32];
+	TargetEntry *tle;
+
+	if (rc->allMarkTypes & ~(1 << ROW_MARK_COPY))
+	{
+		/* Need to fetch TID */
+		var = makeVar(rc->rti,
+					  SelfItemPointerAttributeNumber,
+					  TIDOID,
+					  -1,
+					  InvalidOid,
+					  0);
+		snprintf(resname, sizeof(resname), "ctid%u", rc->rowmarkId);
+		tle = makeTargetEntry((Expr *) var,
+							  list_length(tlist) + 1,
+							  pstrdup(resname),
+							  true);
+		tlist = lappend(tlist, tle);
+	}
+	if (rc->allMarkTypes & (1 << ROW_MARK_COPY))
+	{
+		/* Need the whole row as a junk var */
+		var = makeWholeRowVar(root->simple_rte_array[rc->rti],
+							  rc->rti,
+							  0,
+							  false);
+		snprintf(resname, sizeof(resname), "wholerow%u", rc->rowmarkId);
+		tle = makeTargetEntry((Expr *) var,
+							  list_length(tlist) + 1,
+							  pstrdup(resname),
+							  true);
+		tlist = lappend(tlist, tle);
+	}
+
+	/* For inheritance cases, always fetch the tableoid too. */
+	var = makeVar(rc->rti,
+				  TableOidAttributeNumber,
+				  OIDOID,
+				  -1,
+				  InvalidOid,
+				  0);
+	snprintf(resname, sizeof(resname), "tableoid%u", rc->rowmarkId);
+	tle = makeTargetEntry((Expr *) var,
+						  list_length(tlist) + 1,
+						  pstrdup(resname),
+						  true);
+	tlist = lappend(tlist, tle);
+
+	return tlist;
+}
diff --git a/src/backend/optimizer/util/pathnode.c b/src/backend/optimizer/util/pathnode.c
index d50d86b252..8ce88876c4 100644
--- a/src/backend/optimizer/util/pathnode.c
+++ b/src/backend/optimizer/util/pathnode.c
@@ -20,6 +20,7 @@
 #include "foreign/fdwapi.h"
 #include "nodes/extensible.h"
 #include "nodes/nodeFuncs.h"
+#include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index c23db9d78d..52a11f434f 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -17,6 +17,7 @@
 #include <limits.h>
 
 #include "miscadmin.h"
+#include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
diff --git a/src/backend/partitioning/partprune.c b/src/backend/partitioning/partprune.c
index fcf8d6032c..e76906da1f 100644
--- a/src/backend/partitioning/partprune.c
+++ b/src/backend/partitioning/partprune.c
@@ -44,6 +44,7 @@
 #include "miscadmin.h"
 #include "nodes/makefuncs.h"
 #include "nodes/nodeFuncs.h"
+#include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
diff --git a/src/include/optimizer/appendinfo.h b/src/include/optimizer/appendinfo.h
new file mode 100644
index 0000000000..e205e78e6d
--- /dev/null
+++ b/src/include/optimizer/appendinfo.h
@@ -0,0 +1,43 @@
+/*-------------------------------------------------------------------------
+ *
+ * appendinfo.h
+ *	  Routines for mapping expressions between append rel parent(s) and
+ *	  children
+ *
+ * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/optimizer/appendinfo.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef APPENDINFO_H
+#define APPENDINFO_H
+
+#include "nodes/plannodes.h"
+#include "nodes/relation.h"
+#include "utils/relcache.h"
+
+extern AppendRelInfo *make_append_rel_info(RelOptInfo *parentrel,
+					 RangeTblEntry *parentrte,
+					 TupleDesc childdesc, Oid childoid, Oid childreltype,
+					 Index childRTindex);
+extern Bitmapset *translate_col_privs(const Bitmapset *parent_privs,
+					List *translated_vars);
+extern Node *adjust_appendrel_attrs(PlannerInfo *root, Node *node,
+					   int nappinfos, AppendRelInfo **appinfos);
+
+extern Node *adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node,
+								  Relids child_relids,
+								  Relids top_parent_relids);
+
+extern AppendRelInfo **find_appinfos_by_relids(PlannerInfo *root,
+						Relids relids, int *nappinfos);
+
+extern SpecialJoinInfo *build_child_join_sjinfo(PlannerInfo *root,
+						SpecialJoinInfo *parent_sjinfo,
+						Relids left_relids, Relids right_relids);
+extern Relids adjust_child_relids_multilevel(PlannerInfo *root, Relids relids,
+							   Relids child_relids, Relids top_parent_relids);
+
+#endif							/* APPENDINFO_H */
diff --git a/src/include/optimizer/inherit.h b/src/include/optimizer/inherit.h
new file mode 100644
index 0000000000..97043e3561
--- /dev/null
+++ b/src/include/optimizer/inherit.h
@@ -0,0 +1,25 @@
+/*-------------------------------------------------------------------------
+ *
+ * inherit.h
+ *	  prototypes for inherit.c.
+ *
+ *
+ * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/optimizer/inherit.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef INHERIT_H
+#define INHERIT_H
+
+#include "nodes/relation.h"
+
+/*
+ * inherit.c
+ *	  utilities for dealing with append relations
+ */
+extern void expand_inherited_tables(PlannerInfo *root);
+
+#endif							/* INHERIT_H */
diff --git a/src/include/optimizer/prep.h b/src/include/optimizer/prep.h
index faae07d240..3ad9b4a77e 100644
--- a/src/include/optimizer/prep.h
+++ b/src/include/optimizer/prep.h
@@ -48,24 +48,5 @@ extern PlanRowMark *get_plan_rowmark(List *rowmarks, Index rtindex);
  */
 extern RelOptInfo *plan_set_operations(PlannerInfo *root);
 
-extern void expand_inherited_tables(PlannerInfo *root);
 
-extern Node *adjust_appendrel_attrs(PlannerInfo *root, Node *node,
-					   int nappinfos, AppendRelInfo **appinfos);
-extern AppendRelInfo *make_append_rel_info(RelOptInfo *parentrel,
-					 RangeTblEntry *parentrte,
-					 TupleDesc childdesc, Oid childoid, Oid childreltype,
-					 Index childRTindex);
-extern Node *adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node,
-								  Relids child_relids,
-								  Relids top_parent_relids);
-
-extern AppendRelInfo **find_appinfos_by_relids(PlannerInfo *root,
-						Relids relids, int *nappinfos);
-
-extern SpecialJoinInfo *build_child_join_sjinfo(PlannerInfo *root,
-						SpecialJoinInfo *parent_sjinfo,
-						Relids left_relids, Relids right_relids);
-extern Relids adjust_child_relids_multilevel(PlannerInfo *root, Relids relids,
-							   Relids child_relids, Relids top_parent_relids);
 #endif							/* PREP_H */
-- 
2.11.0

From a8222d2005bba6c588610340600e19ca47a0e78a Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Mon, 15 Oct 2018 10:59:24 +0900
Subject: [PATCH v10 5/6] Teach planner to only process unpruned partitions

This adds a bitmapset field live_parts to RelOptInfo and stores
the partition indexes of non-dummy partitions in it, meaning it
contains indexes of only those partitions that have a non-NULL
RelOptInfo present in its parent's RelOptInfo's part_rels array.

This speeds up processing partitioned table's partitions compared
to going through the whole part_rels array in a number of places.
---
 src/backend/optimizer/path/joinrels.c |  3 +++
 src/backend/optimizer/plan/planner.c  | 18 +++++++++---------
 src/backend/optimizer/util/inherit.c  |  1 +
 src/backend/optimizer/util/relnode.c  |  3 +++
 src/backend/partitioning/partprune.c  | 18 +++++-------------
 src/include/nodes/relation.h          |  4 ++++
 6 files changed, 25 insertions(+), 22 deletions(-)

diff --git a/src/backend/optimizer/path/joinrels.c b/src/backend/optimizer/path/joinrels.c
index 6e321ec9e7..76531a05cf 100644
--- a/src/backend/optimizer/path/joinrels.c
+++ b/src/backend/optimizer/path/joinrels.c
@@ -1424,6 +1424,9 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
 		populate_joinrel_with_paths(root, child_rel1, child_rel2,
 									child_joinrel, child_sjinfo,
 									child_restrictlist);
+		if (!IS_DUMMY_REL(child_joinrel))
+			joinrel->live_parts = bms_add_member(joinrel->live_parts,
+												 cnt_parts);
 	}
 }
 
diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index 85379a6c7d..431ed510a2 100644
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -6816,7 +6816,9 @@ apply_scanjoin_target_to_paths(PlannerInfo *root,
 		List	   *live_children = NIL;
 
 		/* Adjust each partition. */
-		for (partition_idx = 0; partition_idx < rel->nparts; partition_idx++)
+		partition_idx = -1;
+		while ((partition_idx = bms_next_member(rel->live_parts,
+												partition_idx)) >= 0)
 		{
 			RelOptInfo *child_rel = rel->part_rels[partition_idx];
 			ListCell   *lc;
@@ -6824,9 +6826,7 @@ apply_scanjoin_target_to_paths(PlannerInfo *root,
 			int			nappinfos;
 			List	   *child_scanjoin_targets = NIL;
 
-			/* Skip processing pruned partitions. */
-			if (child_rel == NULL)
-				continue;
+			Assert(child_rel != NULL);
 
 			/* Translate scan/join targets for this child. */
 			appinfos = find_appinfos_by_relids(root, child_rel->relids,
@@ -6907,7 +6907,6 @@ create_partitionwise_grouping_paths(PlannerInfo *root,
 									PartitionwiseAggregateType patype,
 									GroupPathExtraData *extra)
 {
-	int			nparts = input_rel->nparts;
 	int			cnt_parts;
 	List	   *grouped_live_children = NIL;
 	List	   *partially_grouped_live_children = NIL;
@@ -6919,7 +6918,9 @@ create_partitionwise_grouping_paths(PlannerInfo *root,
 		   partially_grouped_rel != NULL);
 
 	/* Add paths for partitionwise aggregation/grouping. */
-	for (cnt_parts = 0; cnt_parts < nparts; cnt_parts++)
+	cnt_parts = -1;
+	while ((cnt_parts = bms_next_member(input_rel->live_parts,
+										cnt_parts)) >= 0)
 	{
 		RelOptInfo *child_input_rel = input_rel->part_rels[cnt_parts];
 		PathTarget *child_target = copy_pathtarget(target);
@@ -6929,9 +6930,8 @@ create_partitionwise_grouping_paths(PlannerInfo *root,
 		RelOptInfo *child_grouped_rel;
 		RelOptInfo *child_partially_grouped_rel;
 
-		/* Skip processing pruned partitions. */
-		if (child_input_rel == NULL)
-			continue;
+		/* A live partition must have a RelOptInfo. */
+		Assert(child_input_rel != NULL);
 
 		/* Input child rel must have a path */
 		Assert(child_input_rel->pathlist != NIL);
diff --git a/src/backend/optimizer/util/inherit.c b/src/backend/optimizer/util/inherit.c
index 38a0a7635c..fd646c68f6 100644
--- a/src/backend/optimizer/util/inherit.c
+++ b/src/backend/optimizer/util/inherit.c
@@ -350,6 +350,7 @@ expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
 
 	/* Perform pruning. */
 	partindexes = prune_append_rel_partitions(parentrel);
+	parentrel->live_parts = partindexes;
 
 	/* Must expand PlannerInfo arrays before we can add children. */
 	expand_planner_arrays(root, bms_num_members(partindexes));
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index 52a11f434f..6c7eafe6db 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -1748,6 +1748,9 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
 		joinrel->partexprs[cnt] = partexpr;
 		joinrel->nullable_partexprs[cnt] = nullable_partexpr;
 	}
+
+	/* Partitions will be added by try_partitionwise_join. */
+	joinrel->live_parts = NULL;
 }
 
 /*
diff --git a/src/backend/partitioning/partprune.c b/src/backend/partitioning/partprune.c
index e76906da1f..8bc2f5c5c2 100644
--- a/src/backend/partitioning/partprune.c
+++ b/src/backend/partitioning/partprune.c
@@ -441,29 +441,21 @@ make_partitionedrel_pruneinfo(PlannerInfo *root, RelOptInfo *parentrel,
 		memset(subplan_map, -1, nparts * sizeof(int));
 		subpart_map = (int *) palloc(nparts * sizeof(int));
 		memset(subpart_map, -1, nparts * sizeof(int));
-		present_parts = NULL;
+		present_parts = bms_copy(subpart->live_parts);
 
-		for (i = 0; i < nparts; i++)
+		i = -1;
+		while ((i = bms_next_member(present_parts, i)) >= 0)
 		{
 			RelOptInfo *partrel = subpart->part_rels[i];
 			int			subplanidx;
 			int			subpartidx;
 
-			/* Skip processing pruned partitions. */
-			if (partrel == NULL)
-				continue;
-
+			Assert(partrel != NULL);
 			subplan_map[i] = subplanidx = relid_subplan_map[partrel->relid] - 1;
 			subpart_map[i] = subpartidx = relid_subpart_map[partrel->relid] - 1;
+			/* Record finding this subplan */
 			if (subplanidx >= 0)
-			{
-				present_parts = bms_add_member(present_parts, i);
-
-				/* Record finding this subplan  */
 				subplansfound = bms_add_member(subplansfound, subplanidx);
-			}
-			else if (subpartidx >= 0)
-				present_parts = bms_add_member(present_parts, i);
 		}
 
 		pinfo = makeNode(PartitionedRelPruneInfo);
diff --git a/src/include/nodes/relation.h b/src/include/nodes/relation.h
index 458be2769e..c73e7017f4 100644
--- a/src/include/nodes/relation.h
+++ b/src/include/nodes/relation.h
@@ -730,6 +730,10 @@ typedef struct RelOptInfo
 	Oid		   *part_oids;		/* partition OIDs */
 	struct RelOptInfo **part_rels;	/* Array of RelOptInfos of partitions,
 									 * stored in the same order of bounds */
+	Bitmapset  *live_parts;		/* Indexes into part_rels of the non-NULL
+								 * RelOptInfos of unpruned partitions; exists
+								 * to avoid having to iterate over the entire
+								 * part_rels array to filter NULL entries. */
 	List	  **partexprs;		/* Non-nullable partition key expressions. */
 	List	  **nullable_partexprs; /* Nullable partition key expressions. */
 	List	   *partitioned_child_rels; /* List of RT indexes. */
-- 
2.11.0

From 790f3adda9b39f84799b701ca36b8060c6b5ecba Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Fri, 12 Oct 2018 19:12:53 +0900
Subject: [PATCH v10 6/6] Do not lock all partitions at the beginning

---
 src/backend/optimizer/util/inherit.c | 11 +----------
 1 file changed, 1 insertion(+), 10 deletions(-)

diff --git a/src/backend/optimizer/util/inherit.c b/src/backend/optimizer/util/inherit.c
index fd646c68f6..9e104d809a 100644
--- a/src/backend/optimizer/util/inherit.c
+++ b/src/backend/optimizer/util/inherit.c
@@ -317,10 +317,6 @@ expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti,
  *
  * Partitions are added to the query in order in which they are found in
  * the parent's PartitionDesc.
- *
- * Note: even though only the unpruned partitions will be added to the
- * resulting plan, this still locks *all* partitions via find_all_inheritors
- * when this function is called for the root partitioned table.
  */
 static void
 expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
@@ -334,10 +330,6 @@ expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
 									parentrel->inh_root_parent :
 									parentRTindex;
 
-	/* If root partitioned table, lock *all* partitions in the tree. */
-	if (parentRTindex == rootParentRTindex)
-		(void) find_all_inheritors(parentrte->relid, lockmode, NULL);
-
 	/*
 	 * Initialize partitioned_child_rels to contain this RT index.
 	 *
@@ -373,8 +365,7 @@ expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
 		RangeTblEntry *childrte;
 		Index		childRTindex;
 
-		/* Already locked above. */
-		newrelation = heap_open(childOID, NoLock);
+		newrelation = heap_open(childOID, lockmode);
 		Assert(!RELATION_IS_OTHER_TEMP(newrelation));
 
 		/*
-- 
2.11.0

From 282383be9a015584e27de1c1ddc3c6bec747341e Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Wed, 17 Oct 2018 11:18:12 +0900
Subject: [PATCH v11 1/6] Overhaul inheritance update/delete planning

With the current method, inheritance_planner, which handles the
planning for update/delete commands targeting inheritance trees,
performs the *whole* planning for each child table.  That involves
translating the query tree to set a given child table in place of
the original inheritance root table as the query's target table,
followed by calling grouping_planner on the translated query, which
performs query planning and additional steps needed to apply correct
target list based on the child target table.

That's inefficient for two reasons:

 1. partprune.c cannot be used to perform partition pruning, because
    it can only be invoked from query_planner.  With the current
    approach, query_planner only sees the individual partitions in
    the query tree it receives, not the parent partitioned table.
    This leaves each partition to be pruned using constraint
    exclusion.  (constraint exclusion cannon prune hash partitions
    which means UPDATE/DELETE don't support hash partition pruning.)

 2. Repeated invocation of query_planner results in allocating large
    amounts of memory, especially if there are many child tables.
    Also, it involves repeatedly performing the same processing,
    such as jointree processing.

This commit addresses both of the issues by rewriting portions of
inheritance_planner and adding some supporting functionality to
allpath.c.

With the new implementation, inheritance_planner calls query_planner
only once at the beginning with the original unmodified query, which
creates the access paths of individual relations after pruning any
unnecessary partitions.  For each target child relation, it also
creates a sub-PartitionInfo containing translated version of the
query and a targetlist suitable for the child.  Child PlannerInfos
are saved in the top PlannerInfo for using later.  If the query
involves join against the target relation, join paths are created
for each target child relation by  replacing the original target
table in the join tree by a given child table.  Join relations
(RelOptInfos thereof) for all target child relations are collected
in a global list in the top PlannerInfo.

After creating the join paths for all target child relations,
inheritance_planner calls grouping_planner() on each child join
relation using the previously created child PlannerInfo to finish up
the paths such that they produce query's top-level target list
expanded according to a given child relation's descriptor.
grouping_planner()'s interface is modified so that we can pass it
what's called a 'planned_rel', a RelOptInfo that already contains
the necessary paths needed to produce its output.

This removes some existing code in inheritance_planner that dealt
with any subquery RTEs in the query.  The rationale of that code
was that the subquery RTEs may change during each iteration of
planning (that is, for different children), so different iterations
better use different copies of those RTEs.  That was handled by
making fresh copies of those RTEs for each iteration of planning
which were appended to the range table, accompanied by modifying all
expressions and auxiliary structures that referenced the original
subquery RTEs to instead reference the copies (that is, change the
varnos).  This copying meant we would end up adding S * N new entries
to the original range table by the time we got to the last unpruned
child, where S is the number of subquery RTEs in the original query
and N the number of unpruned children.  Since with the new code
we perform planning just once, I think we don't need this special
handling.  Actually, there is a regression test output change due
to no longer having copies of subquery RTEs (see the diff of
partition_join.out file.)

Also we no longer need the hack in relation_excluded_by_constraints()
involving setting PlannerInfo.inhTargetKind to enable constraint
exclusion for target child relation, which is no longer needed.
Constraint exclusion now runs during query_planner step described
above.

Regression test output change in partition_join.out is due to the fact
that we no longer create duplicates of subquery RTEs in child range
tables.
---
 doc/src/sgml/ddl.sgml                        |  14 +-
 src/backend/nodes/outfuncs.c                 |   1 -
 src/backend/optimizer/path/allpaths.c        | 602 +++++++++++++++++++++++++--
 src/backend/optimizer/path/equivclass.c      |  27 +-
 src/backend/optimizer/plan/createplan.c      |  10 -
 src/backend/optimizer/plan/planmain.c        | 166 +++++++-
 src/backend/optimizer/plan/planner.c         | 434 +++++--------------
 src/backend/optimizer/prep/prepjointree.c    |   1 -
 src/backend/optimizer/prep/prepunion.c       |  33 +-
 src/backend/optimizer/util/plancat.c         |  50 +--
 src/include/nodes/relation.h                 |  34 +-
 src/include/optimizer/paths.h                |   3 +-
 src/test/regress/expected/partition_join.out |   4 +-
 13 files changed, 937 insertions(+), 442 deletions(-)

diff --git a/doc/src/sgml/ddl.sgml b/doc/src/sgml/ddl.sgml
index 85e4358988..0333f673b3 100644
--- a/doc/src/sgml/ddl.sgml
+++ b/doc/src/sgml/ddl.sgml
@@ -4439,15 +4439,6 @@ EXPLAIN SELECT count(*) FROM measurement WHERE logdate &gt;= DATE '2008-01-01';
 
    <note>
     <para>
-     Currently, pruning of partitions during the planning of an
-     <command>UPDATE</command> or <command>DELETE</command> command is
-     implemented using the constraint exclusion method (however, it is
-     controlled by the <literal>enable_partition_pruning</literal> rather than
-     <literal>constraint_exclusion</literal>) &mdash; see the following section
-     for details and caveats that apply.
-    </para>
-
-    <para>
      Execution-time partition pruning currently only occurs for the
      <literal>Append</literal> and <literal>MergeAppend</literal> node types.
      It is not yet implemented for the <literal>ModifyTable</literal> node
@@ -4470,9 +4461,8 @@ EXPLAIN SELECT count(*) FROM measurement WHERE logdate &gt;= DATE '2008-01-01';
 
    <para>
     <firstterm>Constraint exclusion</firstterm> is a query optimization
-    technique similar to partition pruning.  While it is primarily used
-    for partitioning implemented using the legacy inheritance method, it can be
-    used for other purposes, including with declarative partitioning.
+    technique similar to partition pruning.  It is primarily used
+    for partitioning implemented using the legacy inheritance method.
    </para>
 
    <para>
diff --git a/src/backend/nodes/outfuncs.c b/src/backend/nodes/outfuncs.c
index 0fde876c77..f6112e1b4c 100644
--- a/src/backend/nodes/outfuncs.c
+++ b/src/backend/nodes/outfuncs.c
@@ -2210,7 +2210,6 @@ _outPlannerInfo(StringInfo str, const PlannerInfo *node)
 	WRITE_FLOAT_FIELD(tuple_fraction, "%.4f");
 	WRITE_FLOAT_FIELD(limit_tuples, "%.0f");
 	WRITE_UINT_FIELD(qual_security_level);
-	WRITE_ENUM_FIELD(inhTargetKind, InheritanceKind);
 	WRITE_BOOL_FIELD(hasJoinRTEs);
 	WRITE_BOOL_FIELD(hasLateralRTEs);
 	WRITE_BOOL_FIELD(hasDeletedRTEs);
diff --git a/src/backend/optimizer/path/allpaths.c b/src/backend/optimizer/path/allpaths.c
index 256fe16cdb..1e1dfaac47 100644
--- a/src/backend/optimizer/path/allpaths.c
+++ b/src/backend/optimizer/path/allpaths.c
@@ -36,6 +36,7 @@
 #include "optimizer/pathnode.h"
 #include "optimizer/paths.h"
 #include "optimizer/plancat.h"
+#include "optimizer/planmain.h"
 #include "optimizer/planner.h"
 #include "optimizer/prep.h"
 #include "optimizer/restrictinfo.h"
@@ -91,8 +92,12 @@ static void set_foreign_size(PlannerInfo *root, RelOptInfo *rel,
 				 RangeTblEntry *rte);
 static void set_foreign_pathlist(PlannerInfo *root, RelOptInfo *rel,
 					 RangeTblEntry *rte);
+static void set_inherit_target_rel_sizes(PlannerInfo *root, RelOptInfo *rel,
+							 Index rti, RangeTblEntry *rte);
 static void set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 					Index rti, RangeTblEntry *rte);
+static void set_inherit_target_rel_pathlists(PlannerInfo *root,
+							 RelOptInfo *rel, Index rti, RangeTblEntry *rte);
 static void set_append_rel_pathlist(PlannerInfo *root, RelOptInfo *rel,
 						Index rti, RangeTblEntry *rte);
 static void generate_mergeappend_paths(PlannerInfo *root, RelOptInfo *rel,
@@ -119,6 +124,8 @@ static void set_namedtuplestore_pathlist(PlannerInfo *root, RelOptInfo *rel,
 static void set_worktable_pathlist(PlannerInfo *root, RelOptInfo *rel,
 					   RangeTblEntry *rte);
 static RelOptInfo *make_rel_from_joinlist(PlannerInfo *root, List *joinlist);
+static void inheritance_make_rel_from_joinlist(PlannerInfo *root,
+						List *joinlist);
 static bool subquery_is_pushdown_safe(Query *subquery, Query *topquery,
 						  pushdown_safety_info *safetyInfo);
 static bool recurse_pushdown_safe(Node *setOp, Query *topquery,
@@ -149,27 +156,6 @@ make_one_rel(PlannerInfo *root, List *joinlist)
 	Index		rti;
 	double		total_pages;
 
-	/*
-	 * Construct the all_baserels Relids set.
-	 */
-	root->all_baserels = NULL;
-	for (rti = 1; rti < root->simple_rel_array_size; rti++)
-	{
-		RelOptInfo *brel = root->simple_rel_array[rti];
-
-		/* there may be empty slots corresponding to non-baserel RTEs */
-		if (brel == NULL)
-			continue;
-
-		Assert(brel->relid == rti); /* sanity check on array */
-
-		/* ignore RTEs that are "other rels" */
-		if (brel->reloptkind != RELOPT_BASEREL)
-			continue;
-
-		root->all_baserels = bms_add_member(root->all_baserels, brel->relid);
-	}
-
 	/* Mark base rels as to whether we care about fast-start plans */
 	set_base_rel_consider_startup(root);
 
@@ -217,13 +203,34 @@ make_one_rel(PlannerInfo *root, List *joinlist)
 
 	/*
 	 * Generate access paths for the entire join tree.
+	 *
+	 * For UPDATE/DELETE on an inheritance parent, join paths should be
+	 * generated for each child result rel separately.
 	 */
-	rel = make_rel_from_joinlist(root, joinlist);
+	if (root->parse->resultRelation &&
+		root->simple_rte_array[root->parse->resultRelation]->inh)
+	{
+		inheritance_make_rel_from_joinlist(root, joinlist);
 
-	/*
-	 * The result should join all and only the query's base rels.
-	 */
-	Assert(bms_equal(rel->relids, root->all_baserels));
+		/*
+		 * Return the RelOptInfo of original target relation, although this
+		 * doesn't really contain the final path.  inheritance_planner
+		 * from where we got here will generate the final path, but it will
+		 * do so by iterative over child subroots, not through this
+		 * RelOptInfo.
+		 */
+		rel = find_base_rel(root, root->parse->resultRelation);
+	}
+	else
+	{
+		rel = make_rel_from_joinlist(root, joinlist);
+
+		/*
+		 * The result should join all and only the query's base rels.
+		 */
+		Assert(bms_equal(rel->relids, root->all_baserels));
+
+	}
 
 	return rel;
 }
@@ -373,8 +380,15 @@ set_rel_size(PlannerInfo *root, RelOptInfo *rel,
 	}
 	else if (rte->inh)
 	{
-		/* It's an "append relation", process accordingly */
-		set_append_rel_size(root, rel, rti, rte);
+		/*
+		 * If it's a target relation, set the sizes of children instead.
+		 * Otherwise, we'll append the outputs of children, so process it as
+		 * an "append relation".
+		 */
+		if (rti == root->parse->resultRelation)
+			set_inherit_target_rel_sizes(root, rel, rti, rte);
+		else
+			set_append_rel_size(root, rel, rti, rte);
 	}
 	else
 	{
@@ -458,14 +472,26 @@ static void
 set_rel_pathlist(PlannerInfo *root, RelOptInfo *rel,
 				 Index rti, RangeTblEntry *rte)
 {
+	bool	inherited_update = false;
+
 	if (IS_DUMMY_REL(rel))
 	{
 		/* We already proved the relation empty, so nothing more to do */
 	}
 	else if (rte->inh)
 	{
-		/* It's an "append relation", process accordingly */
-		set_append_rel_pathlist(root, rel, rti, rte);
+		/*
+		 * If it's a target relation, set the pathlists of children instead.
+		 * Otherwise, we'll append the outputs of children, so process it as
+		 * an "append relation".
+		 */
+		if (rti == root->parse->resultRelation)
+		{
+			inherited_update = true;
+			set_inherit_target_rel_pathlists(root, rel, rti, rte);
+		}
+		else
+			set_append_rel_pathlist(root, rel, rti, rte);
 	}
 	else
 	{
@@ -540,8 +566,12 @@ set_rel_pathlist(PlannerInfo *root, RelOptInfo *rel,
 	if (set_rel_pathlist_hook)
 		(*set_rel_pathlist_hook) (root, rel, rti, rte);
 
-	/* Now find the cheapest of the paths for this rel */
-	set_cheapest(rel);
+	/*
+	 * Now find the cheapest of the paths for this rel, unless it's an
+	 * inheritance parent and this is an update/delete operation.
+	 */
+	if (!inherited_update)
+		set_cheapest(rel);
 
 #ifdef OPTIMIZER_DEBUG
 	debug_print_rel(root, rel);
@@ -903,6 +933,321 @@ set_foreign_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
 }
 
 /*
+ * set_inherit_target_rel_sizes
+ *	  Set size estimates for the child target relations
+ *
+ * The passed-in rel represents the target relation of the query that is
+ * known to have inheritance children. This is very much like
+ * set_append_rel_size, except it doesn't set the size estimates for the
+ * passed-in rel itself, because we don't need to "append" the children
+ * in this case.
+ */
+static void
+set_inherit_target_rel_sizes(PlannerInfo *root, RelOptInfo *rel,
+							 Index rti, RangeTblEntry *rte)
+{
+	int			parentRTindex = rti;
+	ListCell   *l;
+	bool		has_live_children;
+	Relids		live_children = NULL;
+	bool		did_pruning = false;
+
+	/* Guard against stack overflow due to overly deep inheritance tree. */
+	check_stack_depth();
+
+	Assert(IS_SIMPLE_REL(rel));
+
+	/*
+	 * If the partitioned relation has any baserestrictinfo quals then we
+	 * attempt to use these quals to prune away partitions that cannot
+	 * possibly contain any tuples matching these quals.  In this case we'll
+	 * store the relids of all partitions which could possibly contain a
+	 * matching tuple, and skip anything else in the loop below.
+	 */
+	if (enable_partition_pruning &&
+		rte->relkind == RELKIND_PARTITIONED_TABLE &&
+		rel->baserestrictinfo != NIL)
+	{
+		live_children = prune_append_rel_partitions(rel);
+		did_pruning = true;
+	}
+
+	foreach(l, root->append_rel_list)
+	{
+		AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(l);
+		int			childRTindex;
+		RangeTblEntry *childRTE;
+		RelOptInfo *childrel;
+		List	   *childquals;
+		Index		cq_min_security;
+		bool		have_const_false_cq;
+		PlannerInfo *subroot;
+		ListCell   *lc;
+		List	   *translated_exprs,
+				   *child_target_exprs;
+
+		/* append_rel_list contains all append rels; ignore others */
+		if (appinfo->parent_relid != parentRTindex)
+			continue;
+
+		childRTindex = appinfo->child_relid;
+		childRTE = root->simple_rte_array[childRTindex];
+		subroot = root->inh_target_child_roots[childRTindex];
+
+		/*
+		 * The child rel's RelOptInfo was already created during
+		 * add_base_rels_to_query.
+		 */
+		childrel = find_base_rel(root, childRTindex);
+		Assert(childrel->reloptkind == RELOPT_OTHER_MEMBER_REL);
+
+		/*
+		 * We have to copy the parent's quals to the child, with appropriate
+		 * substitution of variables.  However, only the baserestrictinfo
+		 * quals are needed before we can check for constraint exclusion; so
+		 * do that first and then check to see if we can disregard this child.
+		 *
+		 * The child rel's targetlist might contain non-Var expressions, which
+		 * means that substitution into the quals could produce opportunities
+		 * for const-simplification, and perhaps even pseudoconstant quals.
+		 * Therefore, transform each RestrictInfo separately to see if it
+		 * reduces to a constant or pseudoconstant.  (We must process them
+		 * separately to keep track of the security level of each qual.)
+		 */
+		childquals = NIL;
+		cq_min_security = UINT_MAX;
+		have_const_false_cq = false;
+		foreach(lc, rel->baserestrictinfo)
+		{
+			RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
+			Node	   *childqual;
+			ListCell   *lc2;
+
+			Assert(IsA(rinfo, RestrictInfo));
+			childqual = adjust_appendrel_attrs(root,
+											   (Node *) rinfo->clause,
+											   1, &appinfo);
+			childqual = eval_const_expressions(root, childqual);
+			/* check for flat-out constant */
+			if (childqual && IsA(childqual, Const))
+			{
+				if (((Const *) childqual)->constisnull ||
+					!DatumGetBool(((Const *) childqual)->constvalue))
+				{
+					/* Restriction reduces to constant FALSE or NULL */
+					have_const_false_cq = true;
+					break;
+				}
+				/* Restriction reduces to constant TRUE, so drop it */
+				continue;
+			}
+			/* might have gotten an AND clause, if so flatten it */
+			foreach(lc2, make_ands_implicit((Expr *) childqual))
+			{
+				Node	   *onecq = (Node *) lfirst(lc2);
+				bool		pseudoconstant;
+
+				/* check for pseudoconstant (no Vars or volatile functions) */
+				pseudoconstant =
+					!contain_vars_of_level(onecq, 0) &&
+					!contain_volatile_functions(onecq);
+				if (pseudoconstant)
+				{
+					/* tell createplan.c to check for gating quals */
+					root->hasPseudoConstantQuals = true;
+				}
+				/* reconstitute RestrictInfo with appropriate properties */
+				childquals = lappend(childquals,
+									 make_restrictinfo((Expr *) onecq,
+													   rinfo->is_pushed_down,
+													   rinfo->outerjoin_delayed,
+													   pseudoconstant,
+													   rinfo->security_level,
+													   NULL, NULL, NULL));
+				/* track minimum security level among child quals */
+				cq_min_security = Min(cq_min_security, rinfo->security_level);
+			}
+		}
+
+		/*
+		 * In addition to the quals inherited from the parent, we might have
+		 * securityQuals associated with this particular child node.
+		 * (Currently this can only happen in appendrels originating from
+		 * UNION ALL; inheritance child tables don't have their own
+		 * securityQuals, see expand_inherited_rtentry().)	Pull any such
+		 * securityQuals up into the baserestrictinfo for the child.  This is
+		 * similar to process_security_barrier_quals() for the parent rel,
+		 * except that we can't make any general deductions from such quals,
+		 * since they don't hold for the whole appendrel.
+		 */
+		if (childRTE->securityQuals)
+		{
+			Index		security_level = 0;
+
+			foreach(lc, childRTE->securityQuals)
+			{
+				List	   *qualset = (List *) lfirst(lc);
+				ListCell   *lc2;
+
+				foreach(lc2, qualset)
+				{
+					Expr	   *qual = (Expr *) lfirst(lc2);
+
+					/* not likely that we'd see constants here, so no check */
+					childquals = lappend(childquals,
+										 make_restrictinfo(qual,
+														   true, false, false,
+														   security_level,
+														   NULL, NULL, NULL));
+					cq_min_security = Min(cq_min_security, security_level);
+				}
+				security_level++;
+			}
+			Assert(security_level <= root->qual_security_level);
+		}
+
+		/*
+		 * OK, we've got all the baserestrictinfo quals for this child.
+		 */
+		childrel->baserestrictinfo = childquals;
+		childrel->baserestrict_min_security = cq_min_security;
+
+		if (have_const_false_cq)
+		{
+			/*
+			 * Some restriction clause reduced to constant FALSE or NULL after
+			 * substitution, so this child need not be scanned.
+			 */
+			set_dummy_rel_pathlist(childrel);
+			continue;
+		}
+
+		if (did_pruning && !bms_is_member(appinfo->child_relid, live_children))
+		{
+			/* This partition was pruned; skip it. */
+			set_dummy_rel_pathlist(childrel);
+			continue;
+		}
+
+		if (relation_excluded_by_constraints(root, childrel, childRTE))
+		{
+			/*
+			 * This child need not be scanned, so we can omit it from the
+			 * appendrel.
+			 */
+			set_dummy_rel_pathlist(childrel);
+			continue;
+		}
+
+		/*
+		 * Add missing Vars to child's reltarget.
+		 *
+		 * add_inherit_target_child_root() would've added only those that are
+		 * needed to be present in the top-level tlist (or ones that
+		 * preprocess_targetlist thinks are needed to be in the tlist.)  We
+		 * may need other attributes such as those contained in WHERE clauses,
+		 * which are already computed for the parent during
+		 * deconstruct_jointree processing of the original query (child's
+		 * query never goes through deconstruct_jointree.)
+		 */
+		translated_exprs = (List *)
+			adjust_appendrel_attrs(root,
+								   (Node *) rel->reltarget->exprs,
+								   1, &appinfo);
+		child_target_exprs = childrel->reltarget->exprs;
+		foreach(lc, translated_exprs)
+		{
+			Expr *expr = lfirst(lc);
+
+			if (!list_member(child_target_exprs, expr))
+				child_target_exprs = lappend(child_target_exprs, expr);
+		}
+
+		/*
+		 * We have to make child entries in the EquivalenceClass data
+		 * structures as well.  This is needed either if the parent
+		 * participates in some eclass joins (because we will want to consider
+		 * inner-indexscan joins on the individual children) or if the parent
+		 * has useful pathkeys (because we should try to build MergeAppend
+		 * paths that produce those sort orderings). Even if this child is
+		 * deemed dummy, it may fall on nullable side in a child-join, which
+		 * in turn may participate in a MergeAppend, where we will need the
+		 * EquivalenceClass data structures.
+		 */
+		if (rel->has_eclass_joins || has_useful_pathkeys(root, rel))
+			add_child_rel_equivalences(subroot, appinfo, rel, childrel, true);
+		childrel->has_eclass_joins = rel->has_eclass_joins;
+
+		/* CE failed, so finish copying/modifying join quals. */
+		childrel->joininfo = (List *)
+			adjust_appendrel_attrs(subroot,
+								   (Node *) rel->joininfo,
+								   1, &appinfo);
+
+		/*
+		 * If parallelism is allowable for this query in general, see whether
+		 * it's allowable for this childrel in particular.  But if we've
+		 * already decided the appendrel is not parallel-safe as a whole,
+		 * there's no point in considering parallelism for this child.  For
+		 * consistency, do this before calling set_rel_size() for the child.
+		 */
+		if (root->glob->parallelModeOK && rel->consider_parallel)
+			set_rel_consider_parallel(subroot, childrel, childRTE);
+
+		/*
+		 * Compute the child's size using possibly modified subroot.
+		 */
+		set_rel_size(subroot, childrel, childRTindex, childRTE);
+
+		/*
+		 * It is possible that constraint exclusion detected a contradiction
+		 * within a child subquery, even though we didn't prove one above. If
+		 * so, we can skip this child.
+		 */
+		if (IS_DUMMY_REL(childrel))
+			continue;
+
+		/*
+		 * If any live child is not parallel-safe, treat the whole appendrel
+		 * as not parallel-safe.  In future we might be able to generate plans
+		 * in which some children are farmed out to workers while others are
+		 * not; but we don't have that today, so it's a waste to consider
+		 * partial paths anywhere in the appendrel unless it's all safe.
+		 * (Child rels visited before this one will be unmarked in
+		 * set_append_rel_pathlist().)
+		 */
+		if (!childrel->consider_parallel)
+			rel->consider_parallel = false;
+
+		/*
+		 * Accumulate size information from each live child.
+		 */
+		Assert(childrel->rows > 0);
+
+		/* We have at least one live child. */
+		has_live_children = true;
+	}
+
+	if (!has_live_children)
+	{
+		/*
+		 * All children were excluded by constraints, so mark the relation
+		 * ass dummy.  We must do this in this phase so that the rel's
+		 * dummy-ness is visible when we generate paths for other rels.
+		 */
+		set_dummy_rel_pathlist(rel);
+	}
+	else
+		/*
+		 * Set a non-zero value here to cope with the caller's requirement
+		 * that non-dummy relations are actually not empty.  We don't try to
+		 * be accurate here, because we're not going to create a path that
+		 * combines the children outputs.
+		 */
+		rel->rows = 1;
+}
+
+/*
  * set_append_rel_size
  *	  Set size estimates for a simple "append relation"
  *
@@ -1045,7 +1390,8 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 		 * EquivalenceClass data structures.
 		 */
 		if (rel->has_eclass_joins || has_useful_pathkeys(root, rel))
-			add_child_rel_equivalences(root, appinfo, rel, childrel);
+			add_child_rel_equivalences(root, appinfo, rel, childrel,
+									   false);
 		childrel->has_eclass_joins = rel->has_eclass_joins;
 
 		/*
@@ -1327,6 +1673,63 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 }
 
 /*
+ * set_inherit_target_rel_pathlists
+ *	  Build access paths for the child target relations
+ *
+ * Similar to set_append_rel_pathlist, except that we build paths of the
+ * children, but don't build an Append path.
+ */
+static void
+set_inherit_target_rel_pathlists(PlannerInfo *root, RelOptInfo *rel,
+								 Index rti, RangeTblEntry *rte)
+{
+	int			parentRTindex = rti;
+	ListCell   *l;
+
+	/* Nothing to do if all the children were excluded. */
+	if (IS_DUMMY_REL(rel))
+		return;
+
+	/* Generate access paths for each of the children of passed-in rel */
+	foreach(l, root->append_rel_list)
+	{
+		AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(l);
+		int			childRTindex;
+		RangeTblEntry *childRTE;
+		RelOptInfo *childrel;
+
+		/* append_rel_list contains all append rels; ignore others */
+		if (appinfo->parent_relid != parentRTindex)
+			continue;
+
+		/* Re-locate the child RTE and RelOptInfo */
+		childRTindex = appinfo->child_relid;
+		childRTE = root->simple_rte_array[childRTindex];
+		childrel = root->simple_rel_array[childRTindex];
+
+		/*
+		 * If set_append_rel_size() decided the parent appendrel was
+		 * parallel-unsafe at some point after visiting this child rel, we
+		 * need to propagate the unsafety marking down to the child, so that
+		 * we don't generate useless partial paths for it.
+		 */
+		if (!rel->consider_parallel)
+			childrel->consider_parallel = false;
+
+		/*
+		 * Compute the child's access paths.
+		 */
+		set_rel_pathlist(root, childrel, childRTindex, childRTE);
+
+		/*
+		 * If child is dummy, ignore it.
+		 */
+		if (IS_DUMMY_REL(childrel))
+			continue;
+	}
+}
+
+/*
  * set_append_rel_pathlist
  *	  Build access paths for an "append relation"
  */
@@ -2624,6 +3027,139 @@ generate_gather_paths(PlannerInfo *root, RelOptInfo *rel, bool override_rows)
 }
 
 /*
+ * inheritance_make_rel_from_joinlist
+ *		Perform join planning for all non-dummy leaf inheritance children
+ *		in their role as an UPDATE/DELETE query's target relation
+ *
+ * If a child relation is a partitioned table, its children are processed in
+ * turn by recursively calling this function.
+ */
+static void
+inheritance_make_rel_from_joinlist(PlannerInfo *root, List *joinlist)
+{
+	Index		resultRelation = root->parse->resultRelation;
+	ListCell   *lc;
+#ifdef USE_ASSERT_CHECKING
+	Relids	all_baserels;
+#endif
+
+	/*
+	 * For UPDATE/DELETE queries, the top parent can only ever be a table.
+	 * As a contrast, it could be a UNION ALL subquery in the case of SELECT.
+	 */
+	Assert(root->parse->commandType == CMD_UPDATE ||
+		   root->parse->commandType == CMD_DELETE);
+	Assert(planner_rt_fetch(resultRelation, root)->rtekind == RTE_RELATION);
+
+	/* Nothing to do. */
+	if (IS_DUMMY_REL(find_base_rel(root, resultRelation)))
+		return;
+
+	foreach(lc, root->append_rel_list)
+	{
+		AppendRelInfo *appinfo = lfirst(lc);
+		PlannerInfo *subroot;
+		RelOptInfo *childrel;
+		List	   *translated_joinlist;
+
+		if (appinfo->parent_relid != resultRelation)
+			continue;
+
+		subroot = root->inh_target_child_roots[appinfo->child_relid];
+		Assert(subroot->parse->resultRelation > 0);
+		childrel = find_base_rel(root, appinfo->child_relid);
+
+		/* Ignore excluded/pruned children. */
+		if (IS_DUMMY_REL(childrel))
+			continue;
+
+		root->inh_target_child_rels = lappend_int(root->inh_target_child_rels,
+												  appinfo->child_relid);
+
+		/*
+		 * Modify joinlist such that relations joined to the top parent rel
+		 * appear to be joined to the child rel instead.  Do the same for
+		 * any SpecialJoinInfo structs.
+		 */
+		translated_joinlist = (List *)
+						adjust_appendrel_attrs(subroot,
+											   (Node *) joinlist,
+											   1, &appinfo);
+		subroot->join_info_list = (List *)
+						adjust_appendrel_attrs(subroot,
+											   (Node *) root->join_info_list,
+											   1, &appinfo);
+
+		/*
+		 * Sub-partitioned tables have to be processed recursively using the
+		 * translated subroot as the parent, because AppendRelInfos link
+		 * sub-partitions to their immediate parents, not the root partitioned
+		 * table.
+		 */
+		if (childrel->part_scheme != NULL)
+		{
+			inheritance_make_rel_from_joinlist(subroot, translated_joinlist);
+
+			/*
+			 * Add this child relation as a placeholder in the parent root's
+			 * inh_target_child_joinrels so that inheritance_planner see same
+			 * number of entries as inh_target_child_rels.
+			 */
+			root->inh_target_child_joinrels =
+					lappend(root->inh_target_child_joinrels, childrel);
+
+			/* Also propagate this child's own children into parent's list. */
+			if (subroot->inh_target_child_rels != NIL)
+			{
+				root->inh_target_child_rels =
+					list_concat(root->inh_target_child_rels,
+								subroot->inh_target_child_rels);
+				root->inh_target_child_joinrels =
+					list_concat(root->inh_target_child_joinrels,
+								subroot->inh_target_child_joinrels);
+			}
+			continue;
+		}
+
+		/*
+		 * Since we added the child rel directly into the join tree, we must
+		 * modify it to be a "base" rel instead of an "other" rel, which the
+		 * join planning code expects the relations being joined to be.
+		 */
+		childrel->reloptkind = RELOPT_BASEREL;
+
+		Assert(subroot->join_rel_list == NIL);
+		Assert(subroot->join_rel_hash == NULL);
+
+		/* Perform join planning and save the resulting RelOptInfo. */
+		childrel = make_rel_from_joinlist(subroot, translated_joinlist);
+
+		/*
+		 * Remember this child target rel.  inheritance_planner will perform
+		 * the remaining steps of planning for each child relation separately.
+		 * Specifically, it will call grouping_planner on every
+		 * RelOptInfo contained in the inh_target_child_rels list, each of
+		 * which represents the source of tuples to be modified for a given
+		 * target child rel.
+		 */
+		root->inh_target_child_joinrels =
+						lappend(root->inh_target_child_joinrels, childrel);
+#ifdef USE_ASSERT_CHECKING
+		/*
+		 * The following implements essentially the same Assert as in
+		 * make_one_rel, our caller.
+		 */
+		all_baserels = bms_copy(root->all_baserels);
+		all_baserels = bms_del_member(all_baserels,
+									  root->parse->resultRelation);
+		all_baserels = bms_add_member(all_baserels,
+									  subroot->parse->resultRelation);
+		Assert(bms_equal(childrel->relids, all_baserels));
+#endif
+	}
+}
+
+/*
  * make_rel_from_joinlist
  *	  Build access paths using a "joinlist" to guide the join path search.
  *
diff --git a/src/backend/optimizer/path/equivclass.c b/src/backend/optimizer/path/equivclass.c
index 0d994bd9ae..255e8f86a0 100644
--- a/src/backend/optimizer/path/equivclass.c
+++ b/src/backend/optimizer/path/equivclass.c
@@ -2104,12 +2104,18 @@ match_eclasses_to_foreign_key_col(PlannerInfo *root,
  *
  * parent_rel and child_rel could be derived from appinfo, but since the
  * caller has already computed them, we might as well just pass them in.
+ *
+ * If 'child_is_target' is true then the child EC members *replace* the
+ * corresponding parent members.  In that case, 'root' is the child target
+ * relation's dedicated PlannerInfo so it makes sense to remove the parent
+ * ECs altogether, because they're of no use.
  */
 void
 add_child_rel_equivalences(PlannerInfo *root,
 						   AppendRelInfo *appinfo,
 						   RelOptInfo *parent_rel,
-						   RelOptInfo *child_rel)
+						   RelOptInfo *child_rel,
+						   bool child_is_target)
 {
 	ListCell   *lc1;
 
@@ -2117,6 +2123,8 @@ add_child_rel_equivalences(PlannerInfo *root,
 	{
 		EquivalenceClass *cur_ec = (EquivalenceClass *) lfirst(lc1);
 		ListCell   *lc2;
+		ListCell   *prev;
+		ListCell   *next;
 
 		/*
 		 * If this EC contains a volatile expression, then generating child
@@ -2134,12 +2142,18 @@ add_child_rel_equivalences(PlannerInfo *root,
 			!bms_is_subset(parent_rel->relids, cur_ec->ec_relids))
 			continue;
 
-		foreach(lc2, cur_ec->ec_members)
+		prev = NULL;
+		for (lc2 = list_head(cur_ec->ec_members); lc2 != NULL; lc2 = next)
 		{
 			EquivalenceMember *cur_em = (EquivalenceMember *) lfirst(lc2);
 
+			next = lnext(lc2);
+
 			if (cur_em->em_is_const)
+			{
+				prev = lc2;
 				continue;		/* ignore consts here */
+			}
 
 			/* Does it reference parent_rel? */
 			if (bms_overlap(cur_em->em_relids, parent_rel->relids))
@@ -2177,10 +2191,17 @@ add_child_rel_equivalences(PlannerInfo *root,
 														  child_rel->relids);
 				}
 
+				/* Delete the parent EC member. */
+				if (child_is_target)
+					cur_ec->ec_members = list_delete_cell(cur_ec->ec_members,
+														  lc2, prev);
+
 				(void) add_eq_member(cur_ec, child_expr,
 									 new_relids, new_nullable_relids,
-									 true, cur_em->em_datatype);
+									 !child_is_target, cur_em->em_datatype);
 			}
+			else
+				prev = lc2;
 		}
 	}
 }
diff --git a/src/backend/optimizer/plan/createplan.c b/src/backend/optimizer/plan/createplan.c
index 066685c3c7..8f1769b5c6 100644
--- a/src/backend/optimizer/plan/createplan.c
+++ b/src/backend/optimizer/plan/createplan.c
@@ -2022,12 +2022,7 @@ create_groupingsets_plan(PlannerInfo *root, GroupingSetsPath *best_path)
 	/*
 	 * During setrefs.c, we'll need the grouping_map to fix up the cols lists
 	 * in GroupingFunc nodes.  Save it for setrefs.c to use.
-	 *
-	 * This doesn't work if we're in an inheritance subtree (see notes in
-	 * create_modifytable_plan).  Fortunately we can't be because there would
-	 * never be grouping in an UPDATE/DELETE; but let's Assert that.
 	 */
-	Assert(root->inhTargetKind == INHKIND_NONE);
 	Assert(root->grouping_map == NULL);
 	root->grouping_map = grouping_map;
 
@@ -2184,12 +2179,7 @@ create_minmaxagg_plan(PlannerInfo *root, MinMaxAggPath *best_path)
 	 * with InitPlan output params.  (We can't just do that locally in the
 	 * MinMaxAgg node, because path nodes above here may have Agg references
 	 * as well.)  Save the mmaggregates list to tell setrefs.c to do that.
-	 *
-	 * This doesn't work if we're in an inheritance subtree (see notes in
-	 * create_modifytable_plan).  Fortunately we can't be because there would
-	 * never be aggregates in an UPDATE/DELETE; but let's Assert that.
 	 */
-	Assert(root->inhTargetKind == INHKIND_NONE);
 	Assert(root->minmax_aggs == NIL);
 	root->minmax_aggs = best_path->mmaggregates;
 
diff --git a/src/backend/optimizer/plan/planmain.c b/src/backend/optimizer/plan/planmain.c
index 0e0a543708..04238ef047 100644
--- a/src/backend/optimizer/plan/planmain.c
+++ b/src/backend/optimizer/plan/planmain.c
@@ -26,7 +26,11 @@
 #include "optimizer/paths.h"
 #include "optimizer/placeholder.h"
 #include "optimizer/planmain.h"
+#include "optimizer/prep.h"
 
+static void add_inherited_target_child_roots(PlannerInfo *root);
+static PlannerInfo *adjust_inherited_target_child_root(PlannerInfo *root,
+									AppendRelInfo *appinfo);
 
 /*
  * query_planner
@@ -57,6 +61,8 @@ query_planner(PlannerInfo *root, List *tlist,
 	Query	   *parse = root->parse;
 	List	   *joinlist;
 	RelOptInfo *final_rel;
+	bool		inherited_update;
+	Index		rti;
 
 	/*
 	 * If the query has an empty join tree, then it's something easy like
@@ -230,14 +236,168 @@ query_planner(PlannerInfo *root, List *tlist,
 	extract_restriction_or_clauses(root);
 
 	/*
+	 * Construct the all_baserels Relids set.
+	 */
+	root->all_baserels = NULL;
+	for (rti = 1; rti < root->simple_rel_array_size; rti++)
+	{
+		RelOptInfo *brel = root->simple_rel_array[rti];
+
+		/* there may be empty slots corresponding to non-baserel RTEs */
+		if (brel == NULL)
+			continue;
+
+		Assert(brel->relid == rti); /* sanity check on array */
+
+		/* ignore RTEs that are "other rels" */
+		if (brel->reloptkind != RELOPT_BASEREL)
+			continue;
+
+		root->all_baserels = bms_add_member(root->all_baserels, brel->relid);
+	}
+
+	inherited_update = (parse->resultRelation &&
+						root->simple_rte_array[parse->resultRelation]->inh);
+
+	/*
+	 * Add child subroots needed to use during planning for individual child
+	 * targets
+	 */
+	if (inherited_update)
+	{
+		root->inh_target_child_roots = (PlannerInfo **)
+										palloc0(root->simple_rel_array_size *
+												sizeof(PlannerInfo *));
+		add_inherited_target_child_roots(root);
+	}
+
+	/*
 	 * Ready to do the primary planning.
 	 */
 	final_rel = make_one_rel(root, joinlist);
 
-	/* Check that we got at least one usable path */
-	if (!final_rel || !final_rel->cheapest_total_path ||
-		final_rel->cheapest_total_path->param_info != NULL)
+	/*
+	 * Check that we got at least one usable path.  In the case of an
+	 * inherited update/delete operation, no path has been created for
+	 * the query's actual target relation yet.
+	 */
+	if (!inherited_update &&
+		(!final_rel ||
+		 !final_rel->cheapest_total_path ||
+		 final_rel->cheapest_total_path->param_info != NULL))
 		elog(ERROR, "failed to construct the join relation");
 
 	return final_rel;
 }
+
+/*
+ * add_inherited_target_child_roots
+ *		Add PlannerInfos for inheritance target children
+ */
+static void
+add_inherited_target_child_roots(PlannerInfo *root)
+{
+	Index		resultRelation = root->parse->resultRelation;
+	ListCell   *lc;
+
+	Assert(root->inh_target_child_roots != NULL);
+
+	foreach(lc, root->append_rel_list)
+	{
+		AppendRelInfo *appinfo = lfirst(lc);
+		RangeTblEntry *childRTE;
+		PlannerInfo   *subroot;
+
+		if (appinfo->parent_relid != resultRelation)
+			continue;
+
+		childRTE = root->simple_rte_array[appinfo->child_relid];
+		subroot = adjust_inherited_target_child_root(root, appinfo);
+
+		if (childRTE->inh)
+			add_inherited_target_child_roots(subroot);
+
+		root->inh_target_child_roots[appinfo->child_relid] = subroot;
+	}
+}
+
+/*
+ * add_inherit_target_child_root
+ *		This translates query to match the child given by appinfo and
+ *		puts it in a PlannerInfo that will be used for planning the child
+ *
+ * The child PlannerInfo reuses most of the parent PlannerInfo's fields
+ * unchanged, except unexpanded_tlist and processed_tlist are based on the
+ * child relation.
+ */
+static PlannerInfo *
+adjust_inherited_target_child_root(PlannerInfo *root, AppendRelInfo *appinfo)
+{
+	PlannerInfo *subroot;
+	List	   *tlist;
+	ListCell   *lc;
+
+	Assert(root->parse->commandType == CMD_UPDATE ||
+		   root->parse->commandType == CMD_DELETE);
+
+	/* Translate the original query's expressions to this child. */
+	subroot = makeNode(PlannerInfo);
+	memcpy(subroot, root, sizeof(PlannerInfo));
+
+	/*
+	 * Restore the unexpanded tlist for translation, so that child's
+	 * query contains targetList numbered (resnos) per its own
+	 * TupleDesc, which adjust_inherited_tlist ensures.
+	 */
+	root->parse->targetList = root->unexpanded_tlist;
+	subroot->parse = (Query *) adjust_appendrel_attrs(root,
+													  (Node *) root->parse,
+													  1, &appinfo);
+
+	/*
+	 * Save the original unexpanded targetlist in child subroot, just as
+	 * we did for the parent root, so that this child's own children can use
+	 * it.  Must use copy because subroot->parse->targetList will be modified
+	 * soon.
+	 */
+	subroot->unexpanded_tlist = list_copy(subroot->parse->targetList);
+
+	/*
+	 * Apply planner's expansion of targetlist, such as adding various junk
+	 * column, filling placeholder entries for dropped columns, etc., all of
+	 * which occurs with the child's TupleDesc.
+	 */
+	tlist = preprocess_targetlist(subroot);
+	subroot->processed_tlist = tlist;
+
+	/* Add any newly added Vars to the child RelOptInfo. */
+	build_base_rel_tlists(subroot, tlist);
+
+	/*
+	 * Adjust all_baserels to replace the original target relation with the
+	 * child target relation.  Copy it before modifying though.
+	 */
+	subroot->all_baserels = bms_copy(root->all_baserels);
+	subroot->all_baserels = bms_del_member(subroot->all_baserels,
+										   root->parse->resultRelation);
+	subroot->all_baserels = bms_add_member(subroot->all_baserels,
+										   subroot->parse->resultRelation);
+
+	/*
+	 * Child root should get its own copy of ECs, because they'll be modified
+	 * to replace parent EC expressions by child expressions in
+	 * add_child_rel_equivalences.
+	 */
+	subroot->eq_classes = NIL;
+	foreach(lc, root->eq_classes)
+	{
+		EquivalenceClass *ec = lfirst(lc);
+		EquivalenceClass *new_ec = makeNode(EquivalenceClass);
+
+		memcpy(new_ec, ec, sizeof(EquivalenceClass));
+		new_ec->ec_members = list_copy(ec->ec_members);
+		subroot->eq_classes = lappend(subroot->eq_classes, new_ec);
+	}
+
+	return subroot;
+}
diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index 3e33a17a5b..2fb520f1fb 100644
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -37,6 +37,7 @@
 #ifdef OPTIMIZER_DEBUG
 #include "nodes/print.h"
 #endif
+#include "nodes/relation.h"
 #include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
@@ -126,7 +127,7 @@ static Node *preprocess_expression(PlannerInfo *root, Node *expr, int kind);
 static void preprocess_qual_conditions(PlannerInfo *root, Node *jtnode);
 static void inheritance_planner(PlannerInfo *root);
 static void grouping_planner(PlannerInfo *root, bool inheritance_update,
-				 double tuple_fraction);
+				 RelOptInfo *planned_rel, double tuple_fraction);
 static grouping_sets_data *preprocess_grouping_sets(PlannerInfo *root);
 static List *remap_to_groupclause_idx(List *groupClause, List *gsets,
 						 int *tleref_to_colnum_map);
@@ -630,7 +631,6 @@ subquery_planner(PlannerGlobal *glob, Query *parse,
 	root->grouping_map = NULL;
 	root->minmax_aggs = NIL;
 	root->qual_security_level = 0;
-	root->inhTargetKind = INHKIND_NONE;
 	root->hasRecursion = hasRecursion;
 	if (hasRecursion)
 		root->wt_param_id = SS_assign_special_param(root);
@@ -970,7 +970,7 @@ subquery_planner(PlannerGlobal *glob, Query *parse,
 		rt_fetch(parse->resultRelation, parse->rtable)->inh)
 		inheritance_planner(root);
 	else
-		grouping_planner(root, false, tuple_fraction);
+		grouping_planner(root, false, NULL, tuple_fraction);
 
 	/*
 	 * Capture the set of outer-level param IDs we have access to, for use in
@@ -1146,12 +1146,19 @@ preprocess_phv_expression(PlannerInfo *root, Expr *expr)
  *	  inheritance set.
  *
  * We have to handle this case differently from cases where a source relation
- * is an inheritance set. Source inheritance is expanded at the bottom of the
- * plan tree (see allpaths.c), but target inheritance has to be expanded at
- * the top.  The reason is that for UPDATE, each target relation needs a
- * different targetlist matching its own column set.  Fortunately,
- * the UPDATE/DELETE target can never be the nullable side of an outer join,
- * so it's OK to generate the plan this way.
+ * is an inheritance set.  That's mainly because for UPDATE, each target
+ * relation needs a different targetlist matching its own column set.  So, we
+ * must modify the source scan/join path for each target relation such that it
+ * produces the desired target list.
+ *
+ * The source scan/join paths for individual target relations are still
+ * created in allpaths.c by first expanding the inheritance in the usual way
+ * by set_append_rel_size, followed by join planning for each target relation
+ * separately in make_one_rel.  Finally, we apply grouping_planner here to each
+ * child scan/join path so that it produces the desired targetlist.
+ *
+ * Fortunately, the UPDATE/DELETE target can never be the nullable side of an
+ * outer join, so it's OK to generate the plan this way.
  *
  * Returns nothing; the useful output is in the Paths we attach to
  * the (UPPERREL_FINAL, NULL) upperrel stored in *root.
@@ -1164,14 +1171,8 @@ inheritance_planner(PlannerInfo *root)
 {
 	Query	   *parse = root->parse;
 	int			top_parentRTindex = parse->resultRelation;
-	Bitmapset  *subqueryRTindexes;
-	Bitmapset  *modifiableARIindexes;
 	int			nominalRelation = -1;
 	Index		rootRelation = 0;
-	List	   *final_rtable = NIL;
-	int			save_rel_array_size = 0;
-	RelOptInfo **save_rel_array = NULL;
-	AppendRelInfo **save_append_rel_array = NULL;
 	List	   *subpaths = NIL;
 	List	   *subroots = NIL;
 	List	   *resultRelations = NIL;
@@ -1179,70 +1180,59 @@ inheritance_planner(PlannerInfo *root)
 	List	   *returningLists = NIL;
 	List	   *rowMarks;
 	RelOptInfo *final_rel;
-	ListCell   *lc;
-	Index		rti;
+	ListCell   *lc1,
+			   *lc2;
 	RangeTblEntry *parent_rte;
-	PlannerInfo *parent_root;
-	Query	   *parent_parse;
-	Bitmapset  *parent_relids = bms_make_singleton(top_parentRTindex);
-	PlannerInfo **parent_roots = NULL;
+	List	   *tlist;
+	standard_qp_extra qp_extra;
+	RelOptInfo *planned_rel;
 
+	/* Inheritance is never used for insert. */
 	Assert(parse->commandType != CMD_INSERT);
+	parent_rte = planner_rt_fetch(top_parentRTindex, root);
 
 	/*
-	 * We generate a modified instance of the original Query for each target
-	 * relation, plan that, and put all the plans into a list that will be
-	 * controlled by a single ModifyTable node.  All the instances share the
-	 * same rangetable, but each instance must have its own set of subquery
-	 * RTEs within the finished rangetable because (1) they are likely to get
-	 * scribbled on during planning, and (2) it's not inconceivable that
-	 * subqueries could get planned differently in different cases.  We need
-	 * not create duplicate copies of other RTE kinds, in particular not the
-	 * target relations, because they don't have either of those issues.  Not
-	 * having to duplicate the target relations is important because doing so
-	 * (1) would result in a rangetable of length O(N^2) for N targets, with
-	 * at least O(N^3) work expended here; and (2) would greatly complicate
-	 * management of the rowMarks list.
+	 * Generate the access paths for all relations mentioned in the query,
+	 * including the target inheritance set.  When doing the join planning,
+	 * references in the join tree to the original target relation that's the
+	 * root parent of the inheritance tree is replaced by each of its
+	 * inheritance children and the resulting joinrel RelOptInfo's are
+	 * added to root->inh_target_child_rels.
 	 *
-	 * To begin with, generate a bitmapset of the relids of the subquery RTEs.
+	 * Final planning steps (grouping_planner) are applied to the best path
+	 * of each of those child joinrels using a modified instance of the
+	 * original query for a given child target rel.  All the paths so
+	 * generated are put into a list that will be controlled by a single
+	 * ModifyTable node.  All the instances share the same rangetable.
 	 */
-	subqueryRTindexes = NULL;
-	rti = 1;
-	foreach(lc, parse->rtable)
-	{
-		RangeTblEntry *rte = lfirst_node(RangeTblEntry, lc);
-
-		if (rte->rtekind == RTE_SUBQUERY)
-			subqueryRTindexes = bms_add_member(subqueryRTindexes, rti);
-		rti++;
-	}
 
 	/*
-	 * Next, we want to identify which AppendRelInfo items contain references
-	 * to any of the aforesaid subquery RTEs.  These items will need to be
-	 * copied and modified to adjust their subquery references; whereas the
-	 * other ones need not be touched.  It's worth being tense over this
-	 * because we can usually avoid processing most of the AppendRelInfo
-	 * items, thereby saving O(N^2) space and time when the target is a large
-	 * inheritance tree.  We can identify AppendRelInfo items by their
-	 * child_relid, since that should be unique within the list.
+	 * Save the unexpanded version of the query's targetlist to be used below
+	 * for passing to grouping_planner for each child target relation.
 	 */
-	modifiableARIindexes = NULL;
-	if (subqueryRTindexes != NULL)
-	{
-		foreach(lc, root->append_rel_list)
-		{
-			AppendRelInfo *appinfo = lfirst_node(AppendRelInfo, lc);
+	root->unexpanded_tlist = list_copy(root->parse->targetList);
 
-			if (bms_is_member(appinfo->parent_relid, subqueryRTindexes) ||
-				bms_is_member(appinfo->child_relid, subqueryRTindexes) ||
-				bms_overlap(pull_varnos((Node *) appinfo->translated_vars),
-							subqueryRTindexes))
-				modifiableARIindexes = bms_add_member(modifiableARIindexes,
-													  appinfo->child_relid);
-		}
+	/* Do the scan/join planning. */
+	tlist = preprocess_targetlist(root);
+	root->processed_tlist = tlist;
+	qp_extra.tlist = tlist;
+	qp_extra.activeWindows = qp_extra.groupClause = NIL;
+	planned_rel = query_planner(root, tlist, standard_qp_callback, &qp_extra);
+
+	/*
+	 * If it turned out during query planning that all the children are dummy
+	 * (pruned or excluded by constraints), no need to do the steps below.
+	 * Let grouping_planner finish up the final path.
+	 */
+	if (IS_DUMMY_REL(planned_rel))
+	{
+		grouping_planner(root, false, planned_rel, 0.0);
+		return;
 	}
 
+	Assert(planned_rel->relid == top_parentRTindex);
+	Assert(planned_rel->reloptkind == RELOPT_BASEREL);
+
 	/*
 	 * If the parent RTE is a partitioned table, we should use that as the
 	 * nominal target relation, because the RTEs added for partitioned tables
@@ -1250,7 +1240,6 @@ inheritance_planner(PlannerInfo *root)
 	 * not appear anywhere else in the plan, so the confusion explained below
 	 * for non-partitioning inheritance cases is not possible.
 	 */
-	parent_rte = rt_fetch(top_parentRTindex, root->parse->rtable);
 	if (parent_rte->relkind == RELKIND_PARTITIONED_TABLE)
 	{
 		nominalRelation = top_parentRTindex;
@@ -1258,95 +1247,42 @@ inheritance_planner(PlannerInfo *root)
 	}
 
 	/*
-	 * The PlannerInfo for each child is obtained by translating the relevant
-	 * members of the PlannerInfo for its immediate parent, which we find
-	 * using the parent_relid in its AppendRelInfo.  We save the PlannerInfo
-	 * for each parent in an array indexed by relid for fast retrieval. Since
-	 * the maximum number of parents is limited by the number of RTEs in the
-	 * query, we use that number to allocate the array. An extra entry is
-	 * needed since relids start from 1.
+	 * Get on with finalizing the path for each child target relation by
+	 * calling grouping_planner on its joinrel.  Note that we're restoring
+	 * the query's targetlist to the original one for grouping_planner's
+	 * targetlist expansion steps to perform the expansion with individual
+	 * child descriptors.
 	 */
-	parent_roots = (PlannerInfo **) palloc0((list_length(parse->rtable) + 1) *
-											sizeof(PlannerInfo *));
-	parent_roots[top_parentRTindex] = root;
-
-	/*
-	 * And now we can get on with generating a plan for each child table.
-	 */
-	foreach(lc, root->append_rel_list)
+	forboth(lc1, root->inh_target_child_rels,
+			lc2, root->inh_target_child_joinrels)
 	{
-		AppendRelInfo *appinfo = lfirst_node(AppendRelInfo, lc);
-		PlannerInfo *subroot;
+		Index		childRTindex = lfirst_int(lc1);
+		RelOptInfo *childrel = lfirst(lc2);
+		PlannerInfo *subroot = root->inh_target_child_roots[childRTindex];
+		AppendRelInfo *appinfo = root->append_rel_array[childRTindex];
 		RangeTblEntry *child_rte;
 		RelOptInfo *sub_final_rel;
 		Path	   *subpath;
 
-		/* append_rel_list contains all append rels; ignore others */
-		if (!bms_is_member(appinfo->parent_relid, parent_relids))
-			continue;
-
-		/*
-		 * expand_inherited_rtentry() always processes a parent before any of
-		 * that parent's children, so the parent_root for this relation should
-		 * already be available.
-		 */
-		parent_root = parent_roots[appinfo->parent_relid];
-		Assert(parent_root != NULL);
-		parent_parse = parent_root->parse;
-
-		/*
-		 * We need a working copy of the PlannerInfo so that we can control
-		 * propagation of information back to the main copy.
-		 */
-		subroot = makeNode(PlannerInfo);
-		memcpy(subroot, parent_root, sizeof(PlannerInfo));
-
-		/*
-		 * Generate modified query with this rel as target.  We first apply
-		 * adjust_appendrel_attrs, which copies the Query and changes
-		 * references to the parent RTE to refer to the current child RTE,
-		 * then fool around with subquery RTEs.
-		 */
-		subroot->parse = (Query *)
-			adjust_appendrel_attrs(parent_root,
-								   (Node *) parent_parse,
-								   1, &appinfo);
+		Assert(subroot != NULL);
+		Assert(subroot->parse->resultRelation == childRTindex);
 
 		/*
 		 * If there are securityQuals attached to the parent, move them to the
 		 * child rel (they've already been transformed properly for that).
 		 */
-		parent_rte = rt_fetch(appinfo->parent_relid, subroot->parse->rtable);
-		child_rte = rt_fetch(appinfo->child_relid, subroot->parse->rtable);
+		parent_rte = planner_rt_fetch(appinfo->parent_relid, subroot);
+		child_rte = planner_rt_fetch(appinfo->child_relid, subroot);
 		child_rte->securityQuals = parent_rte->securityQuals;
 		parent_rte->securityQuals = NIL;
 
 		/*
-		 * Mark whether we're planning a query to a partitioned table or an
-		 * inheritance parent.
+		 * Ignore a partitioned child.  Instead, the paths of its children will
+		 * be added to subpaths.
 		 */
-		subroot->inhTargetKind =
-			(rootRelation != 0) ? INHKIND_PARTITIONED : INHKIND_INHERITED;
-
-		/*
-		 * If this child is further partitioned, remember it as a parent.
-		 * Since a partitioned table does not have any data, we don't need to
-		 * create a plan for it, and we can stop processing it here.  We do,
-		 * however, need to remember its modified PlannerInfo for use when
-		 * processing its children, since we'll update their varnos based on
-		 * the delta from immediate parent to child, not from top to child.
-		 *
-		 * Note: a very non-obvious point is that we have not yet added
-		 * duplicate subquery RTEs to the subroot's rtable.  We mustn't,
-		 * because then its children would have two sets of duplicates,
-		 * confusing matters.
-		 */
-		if (child_rte->inh)
+		if (childrel->part_scheme)
 		{
-			Assert(child_rte->relkind == RELKIND_PARTITIONED_TABLE);
-			parent_relids = bms_add_member(parent_relids, appinfo->child_relid);
-			parent_roots[appinfo->child_relid] = subroot;
-
+			Assert(child_rte->inh);
 			continue;
 		}
 
@@ -1374,111 +1310,8 @@ inheritance_planner(PlannerInfo *root)
 		if (nominalRelation < 0)
 			nominalRelation = appinfo->child_relid;
 
-		/*
-		 * The rowMarks list might contain references to subquery RTEs, so
-		 * make a copy that we can apply ChangeVarNodes to.  (Fortunately, the
-		 * executor doesn't need to see the modified copies --- we can just
-		 * pass it the original rowMarks list.)
-		 */
-		subroot->rowMarks = copyObject(parent_root->rowMarks);
-
-		/*
-		 * The append_rel_list likewise might contain references to subquery
-		 * RTEs (if any subqueries were flattenable UNION ALLs).  So prepare
-		 * to apply ChangeVarNodes to that, too.  As explained above, we only
-		 * want to copy items that actually contain such references; the rest
-		 * can just get linked into the subroot's append_rel_list.
-		 *
-		 * If we know there are no such references, we can just use the outer
-		 * append_rel_list unmodified.
-		 */
-		if (modifiableARIindexes != NULL)
-		{
-			ListCell   *lc2;
-
-			subroot->append_rel_list = NIL;
-			foreach(lc2, parent_root->append_rel_list)
-			{
-				AppendRelInfo *appinfo2 = lfirst_node(AppendRelInfo, lc2);
-
-				if (bms_is_member(appinfo2->child_relid, modifiableARIindexes))
-					appinfo2 = copyObject(appinfo2);
-
-				subroot->append_rel_list = lappend(subroot->append_rel_list,
-												   appinfo2);
-			}
-		}
-
-		/*
-		 * Add placeholders to the child Query's rangetable list to fill the
-		 * RT indexes already reserved for subqueries in previous children.
-		 * These won't be referenced, so there's no need to make them very
-		 * valid-looking.
-		 */
-		while (list_length(subroot->parse->rtable) < list_length(final_rtable))
-			subroot->parse->rtable = lappend(subroot->parse->rtable,
-											 makeNode(RangeTblEntry));
-
-		/*
-		 * If this isn't the first child Query, generate duplicates of all
-		 * subquery RTEs, and adjust Var numbering to reference the
-		 * duplicates. To simplify the loop logic, we scan the original rtable
-		 * not the copy just made by adjust_appendrel_attrs; that should be OK
-		 * since subquery RTEs couldn't contain any references to the target
-		 * rel.
-		 */
-		if (final_rtable != NIL && subqueryRTindexes != NULL)
-		{
-			ListCell   *lr;
-
-			rti = 1;
-			foreach(lr, parent_parse->rtable)
-			{
-				RangeTblEntry *rte = lfirst_node(RangeTblEntry, lr);
-
-				if (bms_is_member(rti, subqueryRTindexes))
-				{
-					Index		newrti;
-
-					/*
-					 * The RTE can't contain any references to its own RT
-					 * index, except in its securityQuals, so we can save a
-					 * few cycles by applying ChangeVarNodes to the rest of
-					 * the rangetable before we append the RTE to it.
-					 */
-					newrti = list_length(subroot->parse->rtable) + 1;
-					ChangeVarNodes((Node *) subroot->parse, rti, newrti, 0);
-					ChangeVarNodes((Node *) subroot->rowMarks, rti, newrti, 0);
-					/* Skip processing unchanging parts of append_rel_list */
-					if (modifiableARIindexes != NULL)
-					{
-						ListCell   *lc2;
-
-						foreach(lc2, subroot->append_rel_list)
-						{
-							AppendRelInfo *appinfo2 = lfirst_node(AppendRelInfo, lc2);
-
-							if (bms_is_member(appinfo2->child_relid,
-											  modifiableARIindexes))
-								ChangeVarNodes((Node *) appinfo2, rti, newrti, 0);
-						}
-					}
-					rte = copyObject(rte);
-					ChangeVarNodes((Node *) rte->securityQuals, rti, newrti, 0);
-					subroot->parse->rtable = lappend(subroot->parse->rtable,
-													 rte);
-				}
-				rti++;
-			}
-		}
-
-		/* There shouldn't be any OJ info to translate, as yet */
-		Assert(subroot->join_info_list == NIL);
-		/* and we haven't created PlaceHolderInfos, either */
-		Assert(subroot->placeholder_list == NIL);
-
-		/* Generate Path(s) for accessing this result relation */
-		grouping_planner(subroot, true, 0.0 /* retrieve all tuples */ );
+		/* Apply the top-level targetlist to childrel's path. */
+		grouping_planner(subroot, true, childrel, 0.0);
 
 		/*
 		 * Select cheapest path in case there's more than one.  We always run
@@ -1490,45 +1323,10 @@ inheritance_planner(PlannerInfo *root)
 		subpath = sub_final_rel->cheapest_total_path;
 
 		/*
-		 * If this child rel was excluded by constraint exclusion, exclude it
-		 * from the result plan.
+		 * child rel cannot be empty, or inheritance_make_rel_from_joinlist
+		 * wouldn't have put it in the list to begin with.
 		 */
-		if (IS_DUMMY_PATH(subpath))
-			continue;
-
-		/*
-		 * If this is the first non-excluded child, its post-planning rtable
-		 * becomes the initial contents of final_rtable; otherwise, append
-		 * just its modified subquery RTEs to final_rtable.
-		 */
-		if (final_rtable == NIL)
-			final_rtable = subroot->parse->rtable;
-		else
-			final_rtable = list_concat(final_rtable,
-									   list_copy_tail(subroot->parse->rtable,
-													  list_length(final_rtable)));
-
-		/*
-		 * We need to collect all the RelOptInfos from all child plans into
-		 * the main PlannerInfo, since setrefs.c will need them.  We use the
-		 * last child's simple_rel_array (previous ones are too short), so we
-		 * have to propagate forward the RelOptInfos that were already built
-		 * in previous children.
-		 */
-		Assert(subroot->simple_rel_array_size >= save_rel_array_size);
-		for (rti = 1; rti < save_rel_array_size; rti++)
-		{
-			RelOptInfo *brel = save_rel_array[rti];
-
-			if (brel)
-				subroot->simple_rel_array[rti] = brel;
-		}
-		save_rel_array_size = subroot->simple_rel_array_size;
-		save_rel_array = subroot->simple_rel_array;
-		save_append_rel_array = subroot->append_rel_array;
-
-		/* Make sure any initplans from this rel get into the outer list */
-		root->init_plans = subroot->init_plans;
+		Assert(!IS_DUMMY_PATH(subpath));
 
 		/* Build list of sub-paths */
 		subpaths = lappend(subpaths, subpath);
@@ -1560,36 +1358,6 @@ inheritance_planner(PlannerInfo *root)
 	 */
 
 	/*
-	 * If we managed to exclude every child rel, return a dummy plan; it
-	 * doesn't even need a ModifyTable node.
-	 */
-	if (subpaths == NIL)
-	{
-		set_dummy_rel_pathlist(final_rel);
-		return;
-	}
-
-	/*
-	 * Put back the final adjusted rtable into the master copy of the Query.
-	 * (We mustn't do this if we found no non-excluded children.)
-	 */
-	parse->rtable = final_rtable;
-	root->simple_rel_array_size = save_rel_array_size;
-	root->simple_rel_array = save_rel_array;
-	root->append_rel_array = save_append_rel_array;
-
-	/* Must reconstruct master's simple_rte_array, too */
-	root->simple_rte_array = (RangeTblEntry **)
-		palloc0((list_length(final_rtable) + 1) * sizeof(RangeTblEntry *));
-	rti = 1;
-	foreach(lc, final_rtable)
-	{
-		RangeTblEntry *rte = lfirst_node(RangeTblEntry, lc);
-
-		root->simple_rte_array[rti++] = rte;
-	}
-
-	/*
 	 * If there was a FOR [KEY] UPDATE/SHARE clause, the LockRows node will
 	 * have dealt with fetching non-locked marked rows, else we need to have
 	 * ModifyTable do that.
@@ -1629,6 +1397,12 @@ inheritance_planner(PlannerInfo *root)
  * (inheritance_planner will create a single ModifyTable node covering all the
  * target tables.)
  *
+ * If non-NULL, planned_rel is a RelOptInfo containing paths for the query's
+ * top-level joinrel, which the caller produced by itself.  In that case, this
+ * function only needs to adjust the targetlist of its cheapest_total_path.
+ * The only caller that may pass such a RelOptInfo currently is
+ * inheritance_planner.
+ *
  * tuple_fraction is the fraction of tuples we expect will be retrieved.
  * tuple_fraction is interpreted as follows:
  *	  0: expect all tuples to be retrieved (normal case)
@@ -1647,6 +1421,7 @@ inheritance_planner(PlannerInfo *root)
  */
 static void
 grouping_planner(PlannerInfo *root, bool inheritance_update,
+				 RelOptInfo *planned_rel,
 				 double tuple_fraction)
 {
 	Query	   *parse = root->parse;
@@ -1659,7 +1434,7 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 	List	   *final_targets;
 	List	   *final_targets_contain_srfs;
 	bool		final_target_parallel_safe;
-	RelOptInfo *current_rel;
+	RelOptInfo *current_rel = planned_rel;
 	RelOptInfo *final_rel;
 	ListCell   *lc;
 
@@ -1699,6 +1474,7 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 		 * special work for recursive unions is the responsibility of
 		 * plan_set_operations.
 		 */
+		Assert(current_rel == NULL);
 		current_rel = plan_set_operations(root);
 
 		/*
@@ -1788,17 +1564,26 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 				parse->groupClause = preprocess_groupclause(root, NIL);
 		}
 
-		/* Preprocess targetlist */
-		tlist = preprocess_targetlist(root);
-
 		/*
-		 * We are now done hacking up the query's targetlist.  Most of the
-		 * remaining planning work will be done with the PathTarget
-		 * representation of tlists, but save aside the full representation so
-		 * that we can transfer its decoration (resnames etc) to the topmost
-		 * tlist of the finished Plan.
+		 * Preprocess targetlist, if needed.  If the caller has already done
+		 * query planning, root->processed_tlist already contains the desired
+		 * targetlist.
 		 */
-		root->processed_tlist = tlist;
+		if (planned_rel == NULL)
+		{
+			tlist = preprocess_targetlist(root);
+
+			/*
+			 * We are now done hacking up the query's targetlist.  Most of the
+			 * remaining planning work will be done with the PathTarget
+			 * representation of tlists, but save aside the full representation
+			 * so that we can transfer its decoration (resnames etc) to the
+			 * topmost tlist of the finished Plan.
+			 */
+			root->processed_tlist = tlist;
+		}
+		else
+			tlist = root->processed_tlist;
 
 		/*
 		 * Collect statistics about aggregates for estimating costs, and mark
@@ -1878,8 +1663,9 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 		 * We also generate (in standard_qp_callback) pathkey representations
 		 * of the query's sort clause, distinct clause, etc.
 		 */
-		current_rel = query_planner(root, tlist,
-									standard_qp_callback, &qp_extra);
+		if (current_rel == NULL)
+			current_rel = query_planner(root, tlist,
+										standard_qp_callback, &qp_extra);
 
 		/*
 		 * Convert the query's result tlist into PathTarget format.
diff --git a/src/backend/optimizer/prep/prepjointree.c b/src/backend/optimizer/prep/prepjointree.c
index 77dbf4eba3..87adfa02b1 100644
--- a/src/backend/optimizer/prep/prepjointree.c
+++ b/src/backend/optimizer/prep/prepjointree.c
@@ -917,7 +917,6 @@ pull_up_simple_subquery(PlannerInfo *root, Node *jtnode, RangeTblEntry *rte,
 	subroot->grouping_map = NULL;
 	subroot->minmax_aggs = NIL;
 	subroot->qual_security_level = 0;
-	subroot->inhTargetKind = INHKIND_NONE;
 	subroot->hasRecursion = false;
 	subroot->wt_param_id = -1;
 	subroot->non_recursive_path = NULL;
diff --git a/src/backend/optimizer/prep/prepunion.c b/src/backend/optimizer/prep/prepunion.c
index 1d280c205e..6b62f8e9cf 100644
--- a/src/backend/optimizer/prep/prepunion.c
+++ b/src/backend/optimizer/prep/prepunion.c
@@ -2250,8 +2250,39 @@ adjust_appendrel_attrs_mutator(Node *node,
 											  context->appinfos);
 		return (Node *) phv;
 	}
+
+	/*
+	 * This is needed, because inheritance_make_rel_from_joinlist needs to
+	 * translate root->join_info_list executing make_rel_from_joinlist for a
+	 * given child.
+	 */
+	if (IsA(node, SpecialJoinInfo))
+	{
+		SpecialJoinInfo *oldinfo = (SpecialJoinInfo *) node;
+		SpecialJoinInfo *newinfo = makeNode(SpecialJoinInfo);
+
+		memcpy(newinfo, oldinfo, sizeof(SpecialJoinInfo));
+		newinfo->min_lefthand = adjust_child_relids(oldinfo->min_lefthand,
+													context->nappinfos,
+													context->appinfos);
+		newinfo->min_righthand = adjust_child_relids(oldinfo->min_righthand,
+													 context->nappinfos,
+													 context->appinfos);
+		newinfo->syn_lefthand = adjust_child_relids(oldinfo->syn_lefthand,
+													context->nappinfos,
+													context->appinfos);
+		newinfo->syn_righthand = adjust_child_relids(oldinfo->syn_righthand,
+													 context->nappinfos,
+													 context->appinfos);
+		newinfo->semi_rhs_exprs =
+					(List *) expression_tree_mutator((Node *)
+													 oldinfo->semi_rhs_exprs,
+													 adjust_appendrel_attrs_mutator,
+													 (void *) context);
+		return (Node *) newinfo;
+	}
+
 	/* 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));
diff --git a/src/backend/optimizer/util/plancat.c b/src/backend/optimizer/util/plancat.c
index 48ffc5f254..51d8faf2dd 100644
--- a/src/backend/optimizer/util/plancat.c
+++ b/src/backend/optimizer/util/plancat.c
@@ -1264,36 +1264,6 @@ get_relation_constraints(PlannerInfo *root,
 		}
 	}
 
-	/*
-	 * Append partition predicates, if any.
-	 *
-	 * For selects, partition pruning uses the parent table's partition bound
-	 * descriptor, instead of constraint exclusion which is driven by the
-	 * individual partition's partition constraint.
-	 */
-	if (enable_partition_pruning && root->parse->commandType != CMD_SELECT)
-	{
-		List	   *pcqual = RelationGetPartitionQual(relation);
-
-		if (pcqual)
-		{
-			/*
-			 * Run the partition quals through const-simplification similar to
-			 * check constraints.  We skip canonicalize_qual, though, because
-			 * partition quals should be in canonical form already; also,
-			 * since the qual is in implicit-AND format, we'd have to
-			 * explicitly convert it to explicit-AND format and back again.
-			 */
-			pcqual = (List *) eval_const_expressions(root, (Node *) pcqual);
-
-			/* Fix Vars to have the desired varno */
-			if (varno != 1)
-				ChangeVarNodes((Node *) pcqual, 1, varno, 0);
-
-			result = list_concat(result, pcqual);
-		}
-	}
-
 	heap_close(relation, NoLock);
 
 	return result;
@@ -1420,31 +1390,15 @@ relation_excluded_by_constraints(PlannerInfo *root,
 	switch (constraint_exclusion)
 	{
 		case CONSTRAINT_EXCLUSION_OFF:
-
-			/*
-			 * Don't prune if feature turned off -- except if the relation is
-			 * a partition.  While partprune.c-style partition pruning is not
-			 * yet in use for all cases (update/delete is not handled), it
-			 * would be a UI horror to use different user-visible controls
-			 * depending on such a volatile implementation detail.  Therefore,
-			 * for partitioned tables we use enable_partition_pruning to
-			 * control this behavior.
-			 */
-			if (root->inhTargetKind == INHKIND_PARTITIONED)
-				break;
 			return false;
 
 		case CONSTRAINT_EXCLUSION_PARTITION:
 
 			/*
 			 * When constraint_exclusion is set to 'partition' we only handle
-			 * OTHER_MEMBER_RELs, or BASERELs in cases where the result target
-			 * is an inheritance parent or a partitioned table.
+			 * OTHER_MEMBER_RELs.
 			 */
-			if ((rel->reloptkind != RELOPT_OTHER_MEMBER_REL) &&
-				!(rel->reloptkind == RELOPT_BASEREL &&
-				  root->inhTargetKind != INHKIND_NONE &&
-				  rel->relid == root->parse->resultRelation))
+			if (rel->reloptkind != RELOPT_OTHER_MEMBER_REL)
 				return false;
 			break;
 
diff --git a/src/include/nodes/relation.h b/src/include/nodes/relation.h
index 3430061361..2fde95de7b 100644
--- a/src/include/nodes/relation.h
+++ b/src/include/nodes/relation.h
@@ -319,9 +319,6 @@ typedef struct PlannerInfo
 	Index		qual_security_level;	/* minimum security_level for quals */
 	/* Note: qual_security_level is zero if there are no securityQuals */
 
-	InheritanceKind inhTargetKind;	/* indicates if the target relation is an
-									 * inheritance child or partition or a
-									 * partitioned table */
 	bool		hasJoinRTEs;	/* true if any RTEs are RTE_JOIN kind */
 	bool		hasLateralRTEs; /* true if any RTEs are marked LATERAL */
 	bool		hasDeletedRTEs; /* true if any RTE was deleted from jointree */
@@ -343,6 +340,37 @@ typedef struct PlannerInfo
 
 	/* Does this query modify any partition key columns? */
 	bool		partColsUpdated;
+
+	/*
+	 * The following fields are set during query planning portion of an
+	 * inherited UPDATE/DEELETE operation.
+	 */
+
+	/*
+	 * This stores the original version of the query's targetlist that's
+	 * not modified by the planner.
+	 */
+	List	   *unexpanded_tlist;
+
+	/*
+	 * PlannerInfos corresponding to each inheritance child targets.
+	 * Content of each PlannerInfo is same as the parent PlannerInfo, except
+	 * for the parse tree which is a translated copy of the parent's parse
+	 * tree.
+	 */
+	struct PlannerInfo **inh_target_child_roots;
+
+	/* List of RT indexes of child RT indexes. */
+	List	   *inh_target_child_rels;
+
+	/*
+	 * RelOptInfos corresponding to each child target rel.  For leaf children,
+	 * it's the RelOptInfo representing the output of make_rel_from_joinlist()
+	 * called with the parent rel in the original join tree replaced by a
+	 * given leaf child.  For non-leaf children, it's the baserel RelOptInfo
+	 * itself, left as a placeholder.
+	 */
+	List	   *inh_target_child_joinrels;
 } PlannerInfo;
 
 
diff --git a/src/include/optimizer/paths.h b/src/include/optimizer/paths.h
index 666217c189..a39a0a3a74 100644
--- a/src/include/optimizer/paths.h
+++ b/src/include/optimizer/paths.h
@@ -161,7 +161,8 @@ extern EquivalenceClass *match_eclasses_to_foreign_key_col(PlannerInfo *root,
 extern void add_child_rel_equivalences(PlannerInfo *root,
 						   AppendRelInfo *appinfo,
 						   RelOptInfo *parent_rel,
-						   RelOptInfo *child_rel);
+						   RelOptInfo *child_rel,
+						   bool child_is_target);
 extern List *generate_implied_equalities_for_column(PlannerInfo *root,
 									   RelOptInfo *rel,
 									   ec_matches_callback_type callback,
diff --git a/src/test/regress/expected/partition_join.out b/src/test/regress/expected/partition_join.out
index c55de5d476..c9f02c1fb0 100644
--- a/src/test/regress/expected/partition_join.out
+++ b/src/test/regress/expected/partition_join.out
@@ -1780,7 +1780,7 @@ WHERE EXISTS (
                Filter: (c IS NULL)
          ->  Nested Loop
                ->  Seq Scan on int4_tbl
-               ->  Subquery Scan on ss_1
+               ->  Subquery Scan on ss
                      ->  Limit
                            ->  Seq Scan on int8_tbl int8_tbl_1
    ->  Nested Loop Semi Join
@@ -1788,7 +1788,7 @@ WHERE EXISTS (
                Filter: (c IS NULL)
          ->  Nested Loop
                ->  Seq Scan on int4_tbl
-               ->  Subquery Scan on ss_2
+               ->  Subquery Scan on ss
                      ->  Limit
                            ->  Seq Scan on int8_tbl int8_tbl_2
 (28 rows)
-- 
2.11.0

From 398a793c14de90729730ffb926ebc5f42b6e9b9f Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Fri, 26 Oct 2018 16:45:59 +0900
Subject: [PATCH v11 2/6] Store inheritance root parent index in otherrel's
 RelOptInfo

Although it's set by build_simple_rel, it's not being used by any
code yet.
---
 src/backend/nodes/outfuncs.c         |  1 +
 src/backend/optimizer/util/relnode.c | 14 ++++++++++++++
 src/include/nodes/relation.h         |  4 ++++
 3 files changed, 19 insertions(+)

diff --git a/src/backend/nodes/outfuncs.c b/src/backend/nodes/outfuncs.c
index f6112e1b4c..5248b5a764 100644
--- a/src/backend/nodes/outfuncs.c
+++ b/src/backend/nodes/outfuncs.c
@@ -2271,6 +2271,7 @@ _outRelOptInfo(StringInfo str, const RelOptInfo *node)
 	WRITE_BOOL_FIELD(consider_partitionwise_join);
 	WRITE_BITMAPSET_FIELD(top_parent_relids);
 	WRITE_NODE_FIELD(partitioned_child_rels);
+	WRITE_UINT_FIELD(inh_root_parent);
 }
 
 static void
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index 111b42d654..e079a2469d 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -215,9 +215,23 @@ build_simple_rel(PlannerInfo *root, int relid, RelOptInfo *parent)
 			rel->top_parent_relids = parent->top_parent_relids;
 		else
 			rel->top_parent_relids = bms_copy(parent->relids);
+
+		/*
+		 * For inheritance child relations, we also set inh_root_parent.
+		 * Note that 'parent' might itself be a child (a sub-partitioned
+		 * partition), in which case we simply use its value of
+		 * inh_root_parent.
+		 */
+		if (parent->rtekind == RTE_RELATION)
+			rel->inh_root_parent = parent->inh_root_parent > 0 ?
+										parent->inh_root_parent :
+										parent->relid;
 	}
 	else
+	{
 		rel->top_parent_relids = NULL;
+		rel->inh_root_parent = 0;
+	}
 
 	/* Check type of rtable entry */
 	switch (rte->rtekind)
diff --git a/src/include/nodes/relation.h b/src/include/nodes/relation.h
index 2fde95de7b..a2adbfc3b8 100644
--- a/src/include/nodes/relation.h
+++ b/src/include/nodes/relation.h
@@ -731,6 +731,10 @@ typedef struct RelOptInfo
 	List	  **partexprs;		/* Non-nullable partition key expressions. */
 	List	  **nullable_partexprs; /* Nullable partition key expressions. */
 	List	   *partitioned_child_rels; /* List of RT indexes. */
+
+	Index		inh_root_parent;	/* For otherrels, this is the RT index of
+									 * inheritance table mentioned in the query
+									 * from which this relation originated */
 } RelOptInfo;
 
 /*
-- 
2.11.0

From af059709d568dafc2409db2b3038e773be3f72d8 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Wed, 17 Oct 2018 18:14:13 +0900
Subject: [PATCH v11 3/6] Lazy creation of RTEs for inheritance children

Currently, expand_inherited_tables called from subquery_planner opens
all inheritance child tables and adds them to the query's range
table and PlannerInfo in the form of AppendRelInfo's initially and
later RelOptInfo's.  For partitioning, that's pretty wasteful, because
it's possible to determine only the partitions that will need to be
scanned using partition pruning, which doesn't require opening the
partitions themselves.  However, the point at which the above
processing happens is too early to perform partition pruning.

This commit rearranges things within the planner so that inheritance
child relations can be added to the Query and PlannerInfo during
make_one_rel, just before set_base_rel_sizes is called.  Although the
late initialization approach only benefits the partitioning case, it
seems undesirable to do it only for partitioned tables, because it
means adding code to handle partitions specially at various places
within the planner.  So, *all* inheritance parent tables are expanded
in make_one_rel.  All unpruned partitions are added to Query in the
form of their RangeTblEntry's being added to the range table and to
PlannerInfo in the form of an AppendRelInfo and a RelOptInfo for each.

For partitioning, although we don't create a RangeTblEntry and
RelOptInfo for pruned partitions at make_one_rel time, partitionwise
join code relies on the fact that even though partitions may have
been pruned, they'd still own a RelOptInfo to handle the outer join
case where the pruned partition appears on the nullable side of join.
Partitionwise join code deals with that by allocating dummy
RelOptInfos for pruned partitions that are based mostly on their
parent's properties.

There are some regression test diffs:

 1. Caused by the fact that we no longer allocate a duplicate RT
    entry for a partitioned table in its role as child, as seen in
    the partition_aggregate.out test output.

 2. Those in postgres_fdw.out are caused by the fact that junk columns
    required for row marking are added to reltarget->exprs later than
    user columns, because the row marking junk columns arent added
    until after the inheritance is expanded which as of this commit
    is later than it used to be.
---
 contrib/postgres_fdw/expected/postgres_fdw.out    |  32 +-
 src/backend/optimizer/path/allpaths.c             | 355 +--------
 src/backend/optimizer/path/joinrels.c             |  62 ++
 src/backend/optimizer/plan/initsplan.c            |  58 --
 src/backend/optimizer/plan/planmain.c             |  12 +-
 src/backend/optimizer/plan/planner.c              |  65 +-
 src/backend/optimizer/plan/setrefs.c              |   6 +
 src/backend/optimizer/prep/preptlist.c            |  15 +-
 src/backend/optimizer/prep/prepunion.c            | 854 +++++++++++++++-------
 src/backend/optimizer/util/Makefile               |   2 +-
 src/backend/optimizer/util/plancat.c              |  40 +-
 src/backend/optimizer/util/relnode.c              |  80 +-
 src/backend/partitioning/partprune.c              |  43 +-
 src/include/nodes/relation.h                      |   8 +
 src/include/optimizer/pathnode.h                  |   1 +
 src/include/optimizer/plancat.h                   |   2 +-
 src/include/optimizer/prep.h                      |   9 +-
 src/include/partitioning/partprune.h              |   2 +-
 src/test/regress/expected/partition_aggregate.out |   4 +-
 19 files changed, 886 insertions(+), 764 deletions(-)

diff --git a/contrib/postgres_fdw/expected/postgres_fdw.out b/contrib/postgres_fdw/expected/postgres_fdw.out
index bb92d9d37a..33a33606ef 100644
--- a/contrib/postgres_fdw/expected/postgres_fdw.out
+++ b/contrib/postgres_fdw/expected/postgres_fdw.out
@@ -7072,15 +7072,15 @@ select * from bar where f1 in (select f1 from foo) for update;
                      Output: bar2.f1, bar2.f2, bar2.ctid, bar2.*, bar2.tableoid
                      Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct2 FOR UPDATE
          ->  Hash
-               Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+               Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                ->  HashAggregate
-                     Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                     Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                      Group Key: foo.f1
                      ->  Append
                            ->  Seq Scan on public.foo
-                                 Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                                 Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                            ->  Foreign Scan on public.foo2
-                                 Output: foo2.ctid, foo2.*, foo2.tableoid, foo2.f1
+                                 Output: foo2.f1, foo2.ctid, foo2.*, foo2.tableoid
                                  Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct1
 (23 rows)
 
@@ -7110,15 +7110,15 @@ select * from bar where f1 in (select f1 from foo) for share;
                      Output: bar2.f1, bar2.f2, bar2.ctid, bar2.*, bar2.tableoid
                      Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct2 FOR SHARE
          ->  Hash
-               Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+               Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                ->  HashAggregate
-                     Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                     Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                      Group Key: foo.f1
                      ->  Append
                            ->  Seq Scan on public.foo
-                                 Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                                 Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                            ->  Foreign Scan on public.foo2
-                                 Output: foo2.ctid, foo2.*, foo2.tableoid, foo2.f1
+                                 Output: foo2.f1, foo2.ctid, foo2.*, foo2.tableoid
                                  Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct1
 (23 rows)
 
@@ -7147,15 +7147,15 @@ update bar set f2 = f2 + 100 where f1 in (select f1 from foo);
          ->  Seq Scan on public.bar
                Output: bar.f1, bar.f2, bar.ctid
          ->  Hash
-               Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+               Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                ->  HashAggregate
-                     Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                     Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                      Group Key: foo.f1
                      ->  Append
                            ->  Seq Scan on public.foo
-                                 Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                                 Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                            ->  Foreign Scan on public.foo2
-                                 Output: foo2.ctid, foo2.*, foo2.tableoid, foo2.f1
+                                 Output: foo2.f1, foo2.ctid, foo2.*, foo2.tableoid
                                  Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct1
    ->  Hash Join
          Output: bar2.f1, (bar2.f2 + 100), bar2.f3, bar2.ctid, foo.ctid, foo.*, foo.tableoid
@@ -7165,15 +7165,15 @@ update bar set f2 = f2 + 100 where f1 in (select f1 from foo);
                Output: bar2.f1, bar2.f2, bar2.f3, bar2.ctid
                Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct2 FOR UPDATE
          ->  Hash
-               Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+               Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                ->  HashAggregate
-                     Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                     Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                      Group Key: foo.f1
                      ->  Append
                            ->  Seq Scan on public.foo
-                                 Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                                 Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                            ->  Foreign Scan on public.foo2
-                                 Output: foo2.ctid, foo2.*, foo2.tableoid, foo2.f1
+                                 Output: foo2.f1, foo2.ctid, foo2.*, foo2.tableoid
                                  Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct1
 (39 rows)
 
diff --git a/src/backend/optimizer/path/allpaths.c b/src/backend/optimizer/path/allpaths.c
index 1e1dfaac47..be7b8a717e 100644
--- a/src/backend/optimizer/path/allpaths.c
+++ b/src/backend/optimizer/path/allpaths.c
@@ -44,7 +44,6 @@
 #include "optimizer/var.h"
 #include "parser/parse_clause.h"
 #include "parser/parsetree.h"
-#include "partitioning/partprune.h"
 #include "rewrite/rewriteManip.h"
 #include "utils/lsyscache.h"
 
@@ -378,7 +377,11 @@ set_rel_size(PlannerInfo *root, RelOptInfo *rel,
 		 */
 		set_dummy_rel_pathlist(rel);
 	}
-	else if (rte->inh)
+	/*
+	 * expand_inherited_tables may have proved that the relation is empty, so
+	 * check if it's so.
+	 */
+	else if (rte->inh && !IS_DUMMY_REL(rel))
 	{
 		/*
 		 * If it's a target relation, set the sizes of children instead.
@@ -949,38 +952,18 @@ set_inherit_target_rel_sizes(PlannerInfo *root, RelOptInfo *rel,
 	int			parentRTindex = rti;
 	ListCell   *l;
 	bool		has_live_children;
-	Relids		live_children = NULL;
-	bool		did_pruning = false;
 
 	/* Guard against stack overflow due to overly deep inheritance tree. */
 	check_stack_depth();
 
 	Assert(IS_SIMPLE_REL(rel));
 
-	/*
-	 * If the partitioned relation has any baserestrictinfo quals then we
-	 * attempt to use these quals to prune away partitions that cannot
-	 * possibly contain any tuples matching these quals.  In this case we'll
-	 * store the relids of all partitions which could possibly contain a
-	 * matching tuple, and skip anything else in the loop below.
-	 */
-	if (enable_partition_pruning &&
-		rte->relkind == RELKIND_PARTITIONED_TABLE &&
-		rel->baserestrictinfo != NIL)
-	{
-		live_children = prune_append_rel_partitions(rel);
-		did_pruning = true;
-	}
-
 	foreach(l, root->append_rel_list)
 	{
 		AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(l);
 		int			childRTindex;
 		RangeTblEntry *childRTE;
 		RelOptInfo *childrel;
-		List	   *childquals;
-		Index		cq_min_security;
-		bool		have_const_false_cq;
 		PlannerInfo *subroot;
 		ListCell   *lc;
 		List	   *translated_exprs,
@@ -995,139 +978,18 @@ set_inherit_target_rel_sizes(PlannerInfo *root, RelOptInfo *rel,
 		subroot = root->inh_target_child_roots[childRTindex];
 
 		/*
-		 * The child rel's RelOptInfo was already created during
-		 * add_base_rels_to_query.
+		 * The child rel's RelOptInfo is created during
+		 * expand_inherited_tables().
 		 */
 		childrel = find_base_rel(root, childRTindex);
 		Assert(childrel->reloptkind == RELOPT_OTHER_MEMBER_REL);
 
 		/*
-		 * We have to copy the parent's quals to the child, with appropriate
-		 * substitution of variables.  However, only the baserestrictinfo
-		 * quals are needed before we can check for constraint exclusion; so
-		 * do that first and then check to see if we can disregard this child.
-		 *
-		 * The child rel's targetlist might contain non-Var expressions, which
-		 * means that substitution into the quals could produce opportunities
-		 * for const-simplification, and perhaps even pseudoconstant quals.
-		 * Therefore, transform each RestrictInfo separately to see if it
-		 * reduces to a constant or pseudoconstant.  (We must process them
-		 * separately to keep track of the security level of each qual.)
+		 * Child relation may have been marked dummy if build_append_child_rel
+		 * found self-contradictory quals.
 		 */
-		childquals = NIL;
-		cq_min_security = UINT_MAX;
-		have_const_false_cq = false;
-		foreach(lc, rel->baserestrictinfo)
-		{
-			RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
-			Node	   *childqual;
-			ListCell   *lc2;
-
-			Assert(IsA(rinfo, RestrictInfo));
-			childqual = adjust_appendrel_attrs(root,
-											   (Node *) rinfo->clause,
-											   1, &appinfo);
-			childqual = eval_const_expressions(root, childqual);
-			/* check for flat-out constant */
-			if (childqual && IsA(childqual, Const))
-			{
-				if (((Const *) childqual)->constisnull ||
-					!DatumGetBool(((Const *) childqual)->constvalue))
-				{
-					/* Restriction reduces to constant FALSE or NULL */
-					have_const_false_cq = true;
-					break;
-				}
-				/* Restriction reduces to constant TRUE, so drop it */
-				continue;
-			}
-			/* might have gotten an AND clause, if so flatten it */
-			foreach(lc2, make_ands_implicit((Expr *) childqual))
-			{
-				Node	   *onecq = (Node *) lfirst(lc2);
-				bool		pseudoconstant;
-
-				/* check for pseudoconstant (no Vars or volatile functions) */
-				pseudoconstant =
-					!contain_vars_of_level(onecq, 0) &&
-					!contain_volatile_functions(onecq);
-				if (pseudoconstant)
-				{
-					/* tell createplan.c to check for gating quals */
-					root->hasPseudoConstantQuals = true;
-				}
-				/* reconstitute RestrictInfo with appropriate properties */
-				childquals = lappend(childquals,
-									 make_restrictinfo((Expr *) onecq,
-													   rinfo->is_pushed_down,
-													   rinfo->outerjoin_delayed,
-													   pseudoconstant,
-													   rinfo->security_level,
-													   NULL, NULL, NULL));
-				/* track minimum security level among child quals */
-				cq_min_security = Min(cq_min_security, rinfo->security_level);
-			}
-		}
-
-		/*
-		 * In addition to the quals inherited from the parent, we might have
-		 * securityQuals associated with this particular child node.
-		 * (Currently this can only happen in appendrels originating from
-		 * UNION ALL; inheritance child tables don't have their own
-		 * securityQuals, see expand_inherited_rtentry().)	Pull any such
-		 * securityQuals up into the baserestrictinfo for the child.  This is
-		 * similar to process_security_barrier_quals() for the parent rel,
-		 * except that we can't make any general deductions from such quals,
-		 * since they don't hold for the whole appendrel.
-		 */
-		if (childRTE->securityQuals)
-		{
-			Index		security_level = 0;
-
-			foreach(lc, childRTE->securityQuals)
-			{
-				List	   *qualset = (List *) lfirst(lc);
-				ListCell   *lc2;
-
-				foreach(lc2, qualset)
-				{
-					Expr	   *qual = (Expr *) lfirst(lc2);
-
-					/* not likely that we'd see constants here, so no check */
-					childquals = lappend(childquals,
-										 make_restrictinfo(qual,
-														   true, false, false,
-														   security_level,
-														   NULL, NULL, NULL));
-					cq_min_security = Min(cq_min_security, security_level);
-				}
-				security_level++;
-			}
-			Assert(security_level <= root->qual_security_level);
-		}
-
-		/*
-		 * OK, we've got all the baserestrictinfo quals for this child.
-		 */
-		childrel->baserestrictinfo = childquals;
-		childrel->baserestrict_min_security = cq_min_security;
-
-		if (have_const_false_cq)
-		{
-			/*
-			 * Some restriction clause reduced to constant FALSE or NULL after
-			 * substitution, so this child need not be scanned.
-			 */
-			set_dummy_rel_pathlist(childrel);
+		if (IS_DUMMY_REL(childrel))
 			continue;
-		}
-
-		if (did_pruning && !bms_is_member(appinfo->child_relid, live_children))
-		{
-			/* This partition was pruned; skip it. */
-			set_dummy_rel_pathlist(childrel);
-			continue;
-		}
 
 		if (relation_excluded_by_constraints(root, childrel, childRTE))
 		{
@@ -1269,8 +1131,6 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 	double	   *parent_attrsizes;
 	int			nattrs;
 	ListCell   *l;
-	Relids		live_children = NULL;
-	bool		did_pruning = false;
 
 	/* Guard against stack overflow due to overly deep inheritance tree. */
 	check_stack_depth();
@@ -1278,32 +1138,6 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 	Assert(IS_SIMPLE_REL(rel));
 
 	/*
-	 * Initialize partitioned_child_rels to contain this RT index.
-	 *
-	 * Note that during the set_append_rel_pathlist() phase, we will bubble up
-	 * the indexes of partitioned relations that appear down in the tree, so
-	 * that when we've created Paths for all the children, the root
-	 * partitioned table's list will contain all such indexes.
-	 */
-	if (rte->relkind == RELKIND_PARTITIONED_TABLE)
-		rel->partitioned_child_rels = list_make1_int(rti);
-
-	/*
-	 * If the partitioned relation has any baserestrictinfo quals then we
-	 * attempt to use these quals to prune away partitions that cannot
-	 * possibly contain any tuples matching these quals.  In this case we'll
-	 * store the relids of all partitions which could possibly contain a
-	 * matching tuple, and skip anything else in the loop below.
-	 */
-	if (enable_partition_pruning &&
-		rte->relkind == RELKIND_PARTITIONED_TABLE &&
-		rel->baserestrictinfo != NIL)
-	{
-		live_children = prune_append_rel_partitions(rel);
-		did_pruning = true;
-	}
-
-	/*
 	 * If this is a partitioned baserel, set the consider_partitionwise_join
 	 * flag; currently, we only consider partitionwise joins with the baserel
 	 * if its targetlist doesn't contain a whole-row Var.
@@ -1340,12 +1174,8 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 		int			childRTindex;
 		RangeTblEntry *childRTE;
 		RelOptInfo *childrel;
-		List	   *childquals;
-		Index		cq_min_security;
-		bool		have_const_false_cq;
 		ListCell   *parentvars;
 		ListCell   *childvars;
-		ListCell   *lc;
 
 		/* append_rel_list contains all append rels; ignore others */
 		if (appinfo->parent_relid != parentRTindex)
@@ -1353,18 +1183,34 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 
 		childRTindex = appinfo->child_relid;
 		childRTE = root->simple_rte_array[childRTindex];
+		Assert(childRTE != NULL);
 
 		/*
-		 * The child rel's RelOptInfo was already created during
-		 * add_base_rels_to_query.
+		 * The child rel's RelOptInfo is created during
+		 * expand_inherited_tables().
 		 */
 		childrel = find_base_rel(root, childRTindex);
 		Assert(childrel->reloptkind == RELOPT_OTHER_MEMBER_REL);
 
 		/*
-		 * Copy/Modify targetlist. Even if this child is deemed empty, we need
-		 * its targetlist in case it falls on nullable side in a child-join
-		 * because of partitionwise join.
+		 * Child relation may have been marked dummy if build_append_child_rel
+		 * found self-contradictory quals.
+		 */
+		if (IS_DUMMY_REL(childrel))
+			continue;
+
+		if (relation_excluded_by_constraints(root, childrel, childRTE))
+		{
+			/*
+			 * This child need not be scanned, so we can omit it from the
+			 * appendrel.
+			 */
+			set_dummy_rel_pathlist(childrel);
+			continue;
+		}
+
+		/*
+		 * Copy/Modify targetlist.
 		 *
 		 * NB: the resulting childrel->reltarget->exprs may contain arbitrary
 		 * expressions, which otherwise would not occur in a rel's targetlist.
@@ -1394,144 +1240,6 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 									   false);
 		childrel->has_eclass_joins = rel->has_eclass_joins;
 
-		/*
-		 * We have to copy the parent's quals to the child, with appropriate
-		 * substitution of variables.  However, only the baserestrictinfo
-		 * quals are needed before we can check for constraint exclusion; so
-		 * do that first and then check to see if we can disregard this child.
-		 *
-		 * The child rel's targetlist might contain non-Var expressions, which
-		 * means that substitution into the quals could produce opportunities
-		 * for const-simplification, and perhaps even pseudoconstant quals.
-		 * Therefore, transform each RestrictInfo separately to see if it
-		 * reduces to a constant or pseudoconstant.  (We must process them
-		 * separately to keep track of the security level of each qual.)
-		 */
-		childquals = NIL;
-		cq_min_security = UINT_MAX;
-		have_const_false_cq = false;
-		foreach(lc, rel->baserestrictinfo)
-		{
-			RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
-			Node	   *childqual;
-			ListCell   *lc2;
-
-			Assert(IsA(rinfo, RestrictInfo));
-			childqual = adjust_appendrel_attrs(root,
-											   (Node *) rinfo->clause,
-											   1, &appinfo);
-			childqual = eval_const_expressions(root, childqual);
-			/* check for flat-out constant */
-			if (childqual && IsA(childqual, Const))
-			{
-				if (((Const *) childqual)->constisnull ||
-					!DatumGetBool(((Const *) childqual)->constvalue))
-				{
-					/* Restriction reduces to constant FALSE or NULL */
-					have_const_false_cq = true;
-					break;
-				}
-				/* Restriction reduces to constant TRUE, so drop it */
-				continue;
-			}
-			/* might have gotten an AND clause, if so flatten it */
-			foreach(lc2, make_ands_implicit((Expr *) childqual))
-			{
-				Node	   *onecq = (Node *) lfirst(lc2);
-				bool		pseudoconstant;
-
-				/* check for pseudoconstant (no Vars or volatile functions) */
-				pseudoconstant =
-					!contain_vars_of_level(onecq, 0) &&
-					!contain_volatile_functions(onecq);
-				if (pseudoconstant)
-				{
-					/* tell createplan.c to check for gating quals */
-					root->hasPseudoConstantQuals = true;
-				}
-				/* reconstitute RestrictInfo with appropriate properties */
-				childquals = lappend(childquals,
-									 make_restrictinfo((Expr *) onecq,
-													   rinfo->is_pushed_down,
-													   rinfo->outerjoin_delayed,
-													   pseudoconstant,
-													   rinfo->security_level,
-													   NULL, NULL, NULL));
-				/* track minimum security level among child quals */
-				cq_min_security = Min(cq_min_security, rinfo->security_level);
-			}
-		}
-
-		/*
-		 * In addition to the quals inherited from the parent, we might have
-		 * securityQuals associated with this particular child node.
-		 * (Currently this can only happen in appendrels originating from
-		 * UNION ALL; inheritance child tables don't have their own
-		 * securityQuals, see expand_inherited_rtentry().)	Pull any such
-		 * securityQuals up into the baserestrictinfo for the child.  This is
-		 * similar to process_security_barrier_quals() for the parent rel,
-		 * except that we can't make any general deductions from such quals,
-		 * since they don't hold for the whole appendrel.
-		 */
-		if (childRTE->securityQuals)
-		{
-			Index		security_level = 0;
-
-			foreach(lc, childRTE->securityQuals)
-			{
-				List	   *qualset = (List *) lfirst(lc);
-				ListCell   *lc2;
-
-				foreach(lc2, qualset)
-				{
-					Expr	   *qual = (Expr *) lfirst(lc2);
-
-					/* not likely that we'd see constants here, so no check */
-					childquals = lappend(childquals,
-										 make_restrictinfo(qual,
-														   true, false, false,
-														   security_level,
-														   NULL, NULL, NULL));
-					cq_min_security = Min(cq_min_security, security_level);
-				}
-				security_level++;
-			}
-			Assert(security_level <= root->qual_security_level);
-		}
-
-		/*
-		 * OK, we've got all the baserestrictinfo quals for this child.
-		 */
-		childrel->baserestrictinfo = childquals;
-		childrel->baserestrict_min_security = cq_min_security;
-
-		if (have_const_false_cq)
-		{
-			/*
-			 * Some restriction clause reduced to constant FALSE or NULL after
-			 * substitution, so this child need not be scanned.
-			 */
-			set_dummy_rel_pathlist(childrel);
-			continue;
-		}
-
-		if (did_pruning && !bms_is_member(appinfo->child_relid, live_children))
-		{
-			/* This partition was pruned; skip it. */
-			set_dummy_rel_pathlist(childrel);
-			continue;
-		}
-
-		if (relation_excluded_by_constraints(root, childrel, childRTE))
-		{
-			/*
-			 * This child need not be scanned, so we can omit it from the
-			 * appendrel.
-			 */
-			set_dummy_rel_pathlist(childrel);
-			continue;
-		}
-
 		/* CE failed, so finish copying/modifying join quals. */
 		childrel->joininfo = (List *)
 			adjust_appendrel_attrs(root,
@@ -3068,6 +2776,7 @@ inheritance_make_rel_from_joinlist(PlannerInfo *root, List *joinlist)
 		subroot = root->inh_target_child_roots[appinfo->child_relid];
 		Assert(subroot->parse->resultRelation > 0);
 		childrel = find_base_rel(root, appinfo->child_relid);
+		Assert(childrel != NULL);
 
 		/* Ignore excluded/pruned children. */
 		if (IS_DUMMY_REL(childrel))
diff --git a/src/backend/optimizer/path/joinrels.c b/src/backend/optimizer/path/joinrels.c
index 67b9ca83a7..be2e39fd4b 100644
--- a/src/backend/optimizer/path/joinrels.c
+++ b/src/backend/optimizer/path/joinrels.c
@@ -20,6 +20,7 @@
 #include "optimizer/pathnode.h"
 #include "optimizer/paths.h"
 #include "optimizer/prep.h"
+#include "optimizer/tlist.h"
 #include "partitioning/partbounds.h"
 #include "utils/lsyscache.h"
 #include "utils/memutils.h"
@@ -46,6 +47,9 @@ static void try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1,
 					   List *parent_restrictlist);
 static int match_expr_to_partition_keys(Expr *expr, RelOptInfo *rel,
 							 bool strict_op);
+static RelOptInfo *build_dummy_partition_rel(PlannerInfo *root,
+									RelOptInfo *parent,
+									int partidx);
 
 
 /*
@@ -1376,6 +1380,11 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
 		AppendRelInfo **appinfos;
 		int			nappinfos;
 
+		if (child_rel1 == NULL)
+			child_rel1 = build_dummy_partition_rel(root, rel1, cnt_parts);
+		if (child_rel2 == NULL)
+			child_rel2 = build_dummy_partition_rel(root, rel2, cnt_parts);
+
 		/* We should never try to join two overlapping sets of rels. */
 		Assert(!bms_overlap(child_rel1->relids, child_rel2->relids));
 		child_joinrelids = bms_union(child_rel1->relids, child_rel2->relids);
@@ -1582,3 +1591,56 @@ match_expr_to_partition_keys(Expr *expr, RelOptInfo *rel, bool strict_op)
 
 	return -1;
 }
+
+/*
+ * build_dummy_partition_rel
+ *		Build a RelOptInfo and AppendRelInfo for a pruned partition
+ *
+ * This does not result in opening the relation or a range table entry being
+ * created.  Also, the RelOptInfo thus created is not stored anywhere else
+ * beside the parent's part_rels array.
+ *
+ * The only reason this exists is because partition-wise join, in some cases,
+ * needs a RelOptInfo to represent an empty relation that's on the nullable
+ * side of an outer join, so that a Path representing the outer join can be
+ * created.
+ */
+RelOptInfo *
+build_dummy_partition_rel(PlannerInfo *root, RelOptInfo *parent, int partidx)
+{
+	RangeTblEntry *parentrte = root->simple_rte_array[parent->relid];
+	RelOptInfo *rel;
+
+	Assert(parent->part_rels[partidx] == NULL);
+
+	/* Create minimally valid-looking RelOptInfo with parent's relid. */
+	rel = makeNode(RelOptInfo);
+	rel->reloptkind = RELOPT_OTHER_MEMBER_REL;
+	rel->relid = parent->relid;
+	rel->relids = bms_copy(parent->relids);
+	if (parent->top_parent_relids)
+		rel->top_parent_relids = parent->top_parent_relids;
+	else
+		rel->top_parent_relids = bms_copy(parent->relids);
+	rel->reltarget = copy_pathtarget(parent->reltarget);
+	parent->part_rels[partidx] = rel;
+	mark_dummy_rel(rel);
+
+	/*
+	 * Now we'll need a (no-op) AppendRelInfo for parent, because we're
+	 * setting the dummy partition's relid to be same as the parent's.
+	 */
+	if (root->append_rel_array[parent->relid] == NULL)
+	{
+		/* Pass parent's info as for both the parent rel and child rel. */
+		AppendRelInfo *appinfo = make_append_rel_info(parent, parentrte,
+													  parent->tupdesc,
+													  parentrte->relid,
+													  parent->reltype,
+													  parent->relid);
+
+		root->append_rel_array[parent->relid] = appinfo;
+	}
+
+	return rel;
+}
diff --git a/src/backend/optimizer/plan/initsplan.c b/src/backend/optimizer/plan/initsplan.c
index a66374094f..c628f3d9e7 100644
--- a/src/backend/optimizer/plan/initsplan.c
+++ b/src/backend/optimizer/plan/initsplan.c
@@ -616,64 +616,6 @@ create_lateral_join_info(PlannerInfo *root)
 				bms_add_member(brel2->lateral_referencers, rti);
 		}
 	}
-
-	/*
-	 * Lastly, propagate lateral_relids and lateral_referencers from appendrel
-	 * parent rels to their child rels.  We intentionally give each child rel
-	 * the same minimum parameterization, even though it's quite possible that
-	 * some don't reference all the lateral rels.  This is because any append
-	 * path for the parent will have to have the same parameterization for
-	 * every child anyway, and there's no value in forcing extra
-	 * reparameterize_path() calls.  Similarly, a lateral reference to the
-	 * parent prevents use of otherwise-movable join rels for each child.
-	 */
-	for (rti = 1; rti < root->simple_rel_array_size; rti++)
-	{
-		RelOptInfo *brel = root->simple_rel_array[rti];
-		RangeTblEntry *brte = root->simple_rte_array[rti];
-
-		/*
-		 * Skip empty slots. Also skip non-simple relations i.e. dead
-		 * relations.
-		 */
-		if (brel == NULL || !IS_SIMPLE_REL(brel))
-			continue;
-
-		/*
-		 * In the case of table inheritance, the parent RTE is directly linked
-		 * to every child table via an AppendRelInfo.  In the case of table
-		 * partitioning, the inheritance hierarchy is expanded one level at a
-		 * time rather than flattened.  Therefore, an other member rel that is
-		 * a partitioned table may have children of its own, and must
-		 * therefore be marked with the appropriate lateral info so that those
-		 * children eventually get marked also.
-		 */
-		Assert(brte);
-		if (brel->reloptkind == RELOPT_OTHER_MEMBER_REL &&
-			(brte->rtekind != RTE_RELATION ||
-			 brte->relkind != RELKIND_PARTITIONED_TABLE))
-			continue;
-
-		if (brte->inh)
-		{
-			foreach(lc, root->append_rel_list)
-			{
-				AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(lc);
-				RelOptInfo *childrel;
-
-				if (appinfo->parent_relid != rti)
-					continue;
-				childrel = root->simple_rel_array[appinfo->child_relid];
-				Assert(childrel->reloptkind == RELOPT_OTHER_MEMBER_REL);
-				Assert(childrel->direct_lateral_relids == NULL);
-				childrel->direct_lateral_relids = brel->direct_lateral_relids;
-				Assert(childrel->lateral_relids == NULL);
-				childrel->lateral_relids = brel->lateral_relids;
-				Assert(childrel->lateral_referencers == NULL);
-				childrel->lateral_referencers = brel->lateral_referencers;
-			}
-		}
-	}
 }
 
 
diff --git a/src/backend/optimizer/plan/planmain.c b/src/backend/optimizer/plan/planmain.c
index 04238ef047..3f060927cc 100644
--- a/src/backend/optimizer/plan/planmain.c
+++ b/src/backend/optimizer/plan/planmain.c
@@ -256,6 +256,16 @@ query_planner(PlannerInfo *root, List *tlist,
 		root->all_baserels = bms_add_member(root->all_baserels, brel->relid);
 	}
 
+	/*
+	 * Expand RT entries that represent inherited or partitioned tables.
+	 * This will perform partition pruning on partitioned tables in the
+	 * original range table and also recursively on any child partitioned
+	 * tables that were added by the expansion of the original parent(s).
+	 * As new entries are added to the range table, various arrays in the
+	 * PlannerInfo will be expanded accordingly.
+	 */
+	expand_inherited_tables(root);
+
 	inherited_update = (parse->resultRelation &&
 						root->simple_rte_array[parse->resultRelation]->inh);
 
@@ -367,7 +377,7 @@ adjust_inherited_target_child_root(PlannerInfo *root, AppendRelInfo *appinfo)
 	 * column, filling placeholder entries for dropped columns, etc., all of
 	 * which occurs with the child's TupleDesc.
 	 */
-	tlist = preprocess_targetlist(subroot);
+	tlist = preprocess_targetlist(subroot, true);
 	subroot->processed_tlist = tlist;
 
 	/* Add any newly added Vars to the child RelOptInfo. */
diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index 2fb520f1fb..b9b56d9280 100644
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -23,6 +23,7 @@
 #include "access/sysattr.h"
 #include "access/xact.h"
 #include "catalog/pg_constraint.h"
+#include "catalog/pg_inherits.h"
 #include "catalog/pg_proc.h"
 #include "catalog/pg_type.h"
 #include "executor/executor.h"
@@ -699,27 +700,24 @@ subquery_planner(PlannerGlobal *glob, Query *parse,
 		}
 		if (rte->lateral)
 			root->hasLateralRTEs = true;
+
+		/*
+		 * While at it, also update the inh status.  If the relation doesn't
+		 * or can't have any children, there is no point in letting inh be set
+		 * to true.  Note that we do this before processing rowmarks, so that
+		 * the correct information for setting isParent field of PlanRowMarks.
+		 */
+		if (rte->rtekind == RTE_RELATION)
+			rte->inh = rte->inh && has_subclass(rte->relid);
 	}
 
 	/*
 	 * Preprocess RowMark information.  We need to do this after subquery
-	 * pullup (so that all non-inherited RTEs are present) and before
-	 * inheritance expansion (so that the info is available for
-	 * expand_inherited_tables to examine and modify).
+	 * pullup (so that all non-inherited RTEs are present).
 	 */
 	preprocess_rowmarks(root);
 
 	/*
-	 * Expand any rangetable entries that are inheritance sets into "append
-	 * relations".  This can add entries to the rangetable, but they must be
-	 * plain base relations not joins, so it's OK (and marginally more
-	 * efficient) to do it after checking for join RTEs.  We must do it after
-	 * pulling up subqueries, else we'd fail to handle inherited tables in
-	 * subqueries.
-	 */
-	expand_inherited_tables(root);
-
-	/*
 	 * Set hasHavingQual to remember if HAVING clause is present.  Needed
 	 * because preprocess_expression will reduce a constant-true condition to
 	 * an empty qual list ... but "HAVING TRUE" is not a semantic no-op.
@@ -1212,8 +1210,11 @@ inheritance_planner(PlannerInfo *root)
 	 */
 	root->unexpanded_tlist = list_copy(root->parse->targetList);
 
-	/* Do the scan/join planning. */
-	tlist = preprocess_targetlist(root);
+	/*
+	 * Do the scan/join planning.  We haven't expanded inheritance yet, so
+	 * pass false.
+	 */
+	tlist = preprocess_targetlist(root, false);
 	root->processed_tlist = tlist;
 	qp_extra.tlist = tlist;
 	qp_extra.activeWindows = qp_extra.groupClause = NIL;
@@ -1222,9 +1223,10 @@ inheritance_planner(PlannerInfo *root)
 	/*
 	 * If it turned out during query planning that all the children are dummy
 	 * (pruned or excluded by constraints), no need to do the steps below.
-	 * Let grouping_planner finish up the final path.
+	 * For regular inheritance case, it's possible that we only need to modify
+	 * the parent table.  Let grouping_planner finish up the final path.
 	 */
-	if (IS_DUMMY_REL(planned_rel))
+	if (!parent_rte->inh || IS_DUMMY_REL(planned_rel))
 	{
 		grouping_planner(root, false, planned_rel, 0.0);
 		return;
@@ -1571,14 +1573,19 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 		 */
 		if (planned_rel == NULL)
 		{
-			tlist = preprocess_targetlist(root);
+			/* We haven't expanded inheritance yet, so pass false. */
+			tlist = preprocess_targetlist(root, false);
 
 			/*
-			 * We are now done hacking up the query's targetlist.  Most of the
-			 * remaining planning work will be done with the PathTarget
-			 * representation of tlists, but save aside the full representation
-			 * so that we can transfer its decoration (resnames etc) to the
-			 * topmost tlist of the finished Plan.
+			 * We are now mostly done hacking up the query's targetlist.  More
+			 * columns might be added during query_planner after inheritance
+			 * expansion in make_one_rel, because some children may require
+			 * different column than the parent for row mark handling; see
+			 * add_rowmark_junk_columns().  Most of the remaining planning
+			 * work will be done with the PathTarget representation of tlists,
+			 * but save aside the full representation so that we can transfer
+			 * its decoration (resnames etc) to the topmost tlist of the
+			 * finished Plan.
 			 */
 			root->processed_tlist = tlist;
 		}
@@ -2354,7 +2361,7 @@ preprocess_rowmarks(PlannerInfo *root)
 		newrc->allMarkTypes = (1 << newrc->markType);
 		newrc->strength = rc->strength;
 		newrc->waitPolicy = rc->waitPolicy;
-		newrc->isParent = false;
+		newrc->isParent = rte->inh;
 
 		prowmarks = lappend(prowmarks, newrc);
 	}
@@ -2379,7 +2386,7 @@ preprocess_rowmarks(PlannerInfo *root)
 		newrc->allMarkTypes = (1 << newrc->markType);
 		newrc->strength = LCS_NONE;
 		newrc->waitPolicy = LockWaitBlock;	/* doesn't matter */
-		newrc->isParent = false;
+		newrc->isParent = rte->rtekind == RTE_RELATION ? rte->inh : false;
 
 		prowmarks = lappend(prowmarks, newrc);
 	}
@@ -6816,6 +6823,10 @@ apply_scanjoin_target_to_paths(PlannerInfo *root,
 			int			nappinfos;
 			List	   *child_scanjoin_targets = NIL;
 
+			/* Skip processing pruned partitions. */
+			if (child_rel == NULL)
+				continue;
+
 			/* Translate scan/join targets for this child. */
 			appinfos = find_appinfos_by_relids(root, child_rel->relids,
 											   &nappinfos);
@@ -6917,6 +6928,10 @@ create_partitionwise_grouping_paths(PlannerInfo *root,
 		RelOptInfo *child_grouped_rel;
 		RelOptInfo *child_partially_grouped_rel;
 
+		/* Skip processing pruned partitions. */
+		if (child_input_rel == NULL)
+			continue;
+
 		/* Input child rel must have a path */
 		Assert(child_input_rel->pathlist != NIL);
 
diff --git a/src/backend/optimizer/plan/setrefs.c b/src/backend/optimizer/plan/setrefs.c
index fc7ba0dea2..baced8126c 100644
--- a/src/backend/optimizer/plan/setrefs.c
+++ b/src/backend/optimizer/plan/setrefs.c
@@ -325,6 +325,12 @@ add_rtes_to_flat_rtable(PlannerInfo *root, bool recursing)
 													  UPPERREL_FINAL, NULL)))
 					add_rtes_to_flat_rtable(rel->subroot, true);
 			}
+			/*
+			 * A NULL rel also means an unplanned subquery rte, so apply
+			 * flatten_unplanned_rtes.
+			 */
+			else
+				flatten_unplanned_rtes(glob, rte);
 		}
 		rti++;
 	}
diff --git a/src/backend/optimizer/prep/preptlist.c b/src/backend/optimizer/prep/preptlist.c
index f8bc2dd257..a55949c305 100644
--- a/src/backend/optimizer/prep/preptlist.c
+++ b/src/backend/optimizer/prep/preptlist.c
@@ -65,9 +65,13 @@ static List *expand_targetlist(List *tlist, int command_type,
  *
  * As a side effect, if there's an ON CONFLICT UPDATE clause, its targetlist
  * is also preprocessed (and updated in-place).
+ *
+ * inheritance_expanded specifies whether inheritance tables are expanded
+ * as of calling this function.  Caller must specify it because that affects
+ * which row marking related junk columns get added to the targetlist.
  */
 List *
-preprocess_targetlist(PlannerInfo *root)
+preprocess_targetlist(PlannerInfo *root, bool inheritance_expanded)
 {
 	Query	   *parse = root->parse;
 	int			result_relation = parse->resultRelation;
@@ -134,6 +138,15 @@ preprocess_targetlist(PlannerInfo *root)
 		if (rc->rti != rc->prti)
 			continue;
 
+		/*
+		 * For inheritance parent row marks, we defer adding junk columns
+		 * until we've added child row marks, because some children might
+		 * require different row mark types which will change the parent row
+		 * mark's allMarkTypes fields.
+		 */
+		if (rc->isParent && !inheritance_expanded)
+			continue;
+
 		if (rc->allMarkTypes & ~(1 << ROW_MARK_COPY))
 		{
 			/* Need to fetch TID */
diff --git a/src/backend/optimizer/prep/prepunion.c b/src/backend/optimizer/prep/prepunion.c
index 6b62f8e9cf..632781acc2 100644
--- a/src/backend/optimizer/prep/prepunion.c
+++ b/src/backend/optimizer/prep/prepunion.c
@@ -39,15 +39,19 @@
 #include "miscadmin.h"
 #include "nodes/makefuncs.h"
 #include "nodes/nodeFuncs.h"
+#include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
 #include "optimizer/paths.h"
 #include "optimizer/planmain.h"
 #include "optimizer/planner.h"
 #include "optimizer/prep.h"
+#include "optimizer/restrictinfo.h"
 #include "optimizer/tlist.h"
+#include "optimizer/var.h"
 #include "parser/parse_coerce.h"
 #include "parser/parsetree.h"
+#include "partitioning/partprune.h"
 #include "utils/lsyscache.h"
 #include "utils/rel.h"
 #include "utils/selfuncs.h"
@@ -99,23 +103,26 @@ static List *generate_append_tlist(List *colTypes, List *colCollations,
 					  List *input_tlists,
 					  List *refnames_tlist);
 static List *generate_setop_grouplist(SetOperationStmt *op, List *targetlist);
+static void expand_append_rtentry(PlannerInfo *root, RelOptInfo *rel,
+					  RangeTblEntry *rte, Index rti);
 static void expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte,
-						 Index rti);
+						 Index rti, RelOptInfo *rel);
 static void expand_partitioned_rtentry(PlannerInfo *root,
 						   RangeTblEntry *parentrte,
-						   Index parentRTindex, Relation parentrel,
-						   PlanRowMark *top_parentrc, LOCKMODE lockmode,
-						   List **appinfos);
-static void expand_single_inheritance_child(PlannerInfo *root,
-								RangeTblEntry *parentrte,
-								Index parentRTindex, Relation parentrel,
-								PlanRowMark *top_parentrc, Relation childrel,
-								List **appinfos, RangeTblEntry **childrte_p,
-								Index *childRTindex_p);
-static void make_inh_translation_list(Relation oldrelation,
-						  Relation newrelation,
-						  Index newvarno,
-						  List **translated_vars);
+						   Index parentRTindex, RelOptInfo *parentrel);
+static RelOptInfo *add_inheritance_child_rel(PlannerInfo *root,
+						  RangeTblEntry *parentrte,
+						  Index parentRTindex, RelOptInfo *parentrel,
+						  PlanRowMark *top_parentrc, Relation childrel,
+						  RangeTblEntry **childrte_p, Index *childRTindex_p);
+static void make_inh_translation_list(TupleDesc old_tupdesc,
+						  TupleDesc new_tupdesc,
+						  Oid from_rel, Oid to_rel,
+						  Index newvarno, List **translated_vars);
+static RelOptInfo *build_append_child_rel(PlannerInfo *root,
+					   RelOptInfo *parent,
+					   Index childRTindex);
+static List *add_rowmark_junk_columns(PlannerInfo *root, PlanRowMark *rc);
 static Bitmapset *translate_col_privs(const Bitmapset *parent_privs,
 					List *translated_vars);
 static Node *adjust_appendrel_attrs_mutator(Node *node,
@@ -1472,33 +1479,134 @@ generate_setop_grouplist(SetOperationStmt *op, List *targetlist)
 void
 expand_inherited_tables(PlannerInfo *root)
 {
-	Index		nrtes;
+	int			orig_rtable_size;
 	Index		rti;
-	ListCell   *rl;
+
+	Assert(root->simple_rel_array_size > 0);
+	orig_rtable_size = root->simple_rel_array_size;
 
 	/*
-	 * expand_inherited_rtentry may add RTEs to parse->rtable. The function is
+	 * expand_append_rtentry may add RTEs to parse->rtable. The function is
 	 * expected to recursively handle any RTEs that it creates with inh=true.
 	 * So just scan as far as the original end of the rtable list.
 	 */
-	nrtes = list_length(root->parse->rtable);
-	rl = list_head(root->parse->rtable);
-	for (rti = 1; rti <= nrtes; rti++)
+	for (rti = 1; rti < orig_rtable_size; rti++)
 	{
-		RangeTblEntry *rte = (RangeTblEntry *) lfirst(rl);
+		RelOptInfo *brel = root->simple_rel_array[rti];
+		RangeTblEntry *rte = root->simple_rte_array[rti];
 
-		expand_inherited_rtentry(root, rte, rti);
-		rl = lnext(rl);
+		/* there may be empty slots corresponding to non-baserel RTEs */
+		if (brel == NULL)
+			continue;
+
+		if (rte->inh)
+			expand_append_rtentry(root, brel, rte, rti);
+	}
+}
+
+/*
+ * expand_append_rtentry
+ *		This initializes RelOptInfos for an appendrel's child relations, if
+ *		any
+ *
+ * 'rel' is the appendrel parent, whose range table entry ('rte') has been
+ * marked to require adding children.  An appendrel parent could either
+ * be a subquery (if we flattened UNION ALL query) or a table that's known
+ * to have inheritance children.  The latter consists of both regular
+ * inheritance parents and partitioned tables.
+ *
+ * For a subquery parent, there is not much to be done here because the
+ * children's RTEs are already present in the query, so we just initialize
+ * RelOptInfos for them.  Also, the AppendRelInfos for child subqueries
+ * have already been added.
+ *
+ * For tables, we need to add the children to the range table and initialize
+ * AppendRelInfos, RelOptInfos, and PlanRowMarks (if any) for them.  For
+ * a partitioned parent, we only add the children remaining after pruning.
+ * For regular inheritance parents, we find the children using
+ * find_all_inheritors and add all of them.
+ *
+ * If it turns out that there are no children, then we set rte->inh to false
+ * to let the caller know that only the parent table needs to be scanned.  The
+ * caller can accordingly switch to a non-Append path.  For a partitioned
+ * parent, that means an empty relation because parents themselves contain no
+ * data.
+ *
+ * For the regular inheritance case, the parent also gets another RTE with
+ * inh = false to represent it as an appendrel child.  The original RTE is
+ * considered to represent the whole inheritance set.
+ */
+static void
+expand_append_rtentry(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte,
+					  Index rti)
+{
+	Assert(rte->inh);
+	/* Inheritance parent (partitioned or not) or UNION ALL parent subquery. */
+	Assert(rte->rtekind == RTE_RELATION || rte->rtekind == RTE_SUBQUERY);
+
+	/*
+	 * UNION ALL children already got RTEs and AppendRelInfos, so just build
+	 * RelOptInfos and return.
+	 *
+	 * It might be a bit odd that this code is in this, because there is
+	 * nothing to expand really.
+	 */
+	if (rte->rtekind == RTE_SUBQUERY)
+	{
+		ListCell   *l;
+
+		/*
+		 * We don't need to use expand_planner_arrays in this case, because
+		 * no new child RTEs are created.  setup_simple_rel_arrays() and
+		 * setup_append_rel_array would've considered these child RTEs when
+		 * allocating space for various arrays.
+		 */
+		foreach(l, root->append_rel_list)
+		{
+			AppendRelInfo *appinfo = lfirst(l);
+			Index		childRTindex = appinfo->child_relid;
+
+			if (appinfo->parent_relid != rti)
+				continue;
+
+			Assert(childRTindex < root->simple_rel_array_size);
+			Assert(root->simple_rte_array[childRTindex] != NULL);
+
+			/*
+			 * We set the correct value of baserestricinfo and
+			 * baserestrict_min_security below.
+			 */
+			root->simple_rel_array[childRTindex] =
+				build_append_child_rel(root, rel, appinfo->child_relid);
+		}
+	}
+	else
+	{
+		Assert(rte->rtekind == RTE_RELATION);
+		Assert(has_subclass(rte->relid));
+
+		/*
+		 * The rewriter should already have obtained an appropriate lock on
+		 * each relation named in the query.  However, for each child relation
+		 * we add to the query, we must obtain an appropriate lock, because
+		 * this will be the first use of those relations in the
+		 * parse/rewrite/plan pipeline.  Child rels should use the same
+		 * lockmode as their parent.
+		 */
+		Assert(rte->rellockmode != NoLock);
+
+		if (rte->relkind == RELKIND_PARTITIONED_TABLE)
+			expand_partitioned_rtentry(root, rte, rti, rel);
+		else
+			expand_inherited_rtentry(root, rte, rti, rel);
 	}
 }
 
 /*
  * expand_inherited_rtentry
- *		Check whether a rangetable entry represents an inheritance set.
- *		If so, add entries for all the child tables to the query's
- *		rangetable, and build AppendRelInfo nodes for all the child tables
- *		and add them to root->append_rel_list.  If not, clear the entry's
- *		"inh" flag to prevent later code from looking for AppendRelInfos.
+ *		Add entries for all the child tables to the query's rangetable, and
+ *		build AppendRelInfo nodes for all the child tables and add them to
+ *		root->append_rel_list.
  *
  * Note that the original RTE is considered to represent the whole
  * inheritance set.  The first of the generated RTEs is an RTE for the same
@@ -1509,55 +1617,33 @@ expand_inherited_tables(PlannerInfo *root)
  * regular inheritance, a parent RTE must always have at least two associated
  * AppendRelInfos: one corresponding to the parent table as a simple member of
  * inheritance set and one or more corresponding to the actual children.
- * Since a partitioned table is not scanned, it might have only one associated
- * AppendRelInfo.
  */
 static void
-expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti)
+expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti,
+						 RelOptInfo *rel)
 {
 	Oid			parentOID;
 	PlanRowMark *oldrc;
-	Relation	oldrelation;
-	LOCKMODE	lockmode;
+	LOCKMODE	lockmode = rte->rellockmode;
 	List	   *inhOIDs;
 	ListCell   *l;
+	int			num_children;
+	int			num_children_added = 0;
 
-	/* Does RT entry allow inheritance? */
-	if (!rte->inh)
-		return;
-	/* Ignore any already-expanded UNION ALL nodes */
-	if (rte->rtekind != RTE_RELATION)
-	{
-		Assert(rte->rtekind == RTE_SUBQUERY);
-		return;
-	}
-	/* Fast path for common case of childless table */
+	Assert(rte->rtekind == RTE_RELATION);
+	Assert(lockmode != NoLock);
 	parentOID = rte->relid;
-	if (!has_subclass(parentOID))
-	{
-		/* Clear flag before returning */
-		rte->inh = false;
-		return;
-	}
-
-	/*
-	 * The rewriter should already have obtained an appropriate lock on each
-	 * relation named in the query.  However, for each child relation we add
-	 * to the query, we must obtain an appropriate lock, because this will be
-	 * the first use of those relations in the parse/rewrite/plan pipeline.
-	 * Child rels should use the same lockmode as their parent.
-	 */
-	lockmode = rte->rellockmode;
 
 	/* Scan for all members of inheritance set, acquire needed locks */
 	inhOIDs = find_all_inheritors(parentOID, lockmode, NULL);
 
 	/*
 	 * Check that there's at least one descendant, else treat as no-child
-	 * case.  This could happen despite above has_subclass() check, if table
-	 * once had a child but no longer does.
+	 * case.  This could happen despite has_subclass() check performed by
+	 * subquery_planner, if table once had a child but no longer does.
 	 */
-	if (list_length(inhOIDs) < 2)
+	num_children = list_length(inhOIDs);
+	if (num_children < 2)
 	{
 		/* Clear flag before returning */
 		rte->inh = false;
@@ -1565,216 +1651,219 @@ expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti)
 	}
 
 	/*
-	 * If parent relation is selected FOR UPDATE/SHARE, we need to mark its
-	 * PlanRowMark as isParent = true, and generate a new PlanRowMark for each
-	 * child.
+	 * If parent relation is selected FOR UPDATE/SHARE, preprocess_rowmarks
+	 * should've set isParent = true.  We'll generate a new PlanRowMark for
+	 * each child.
 	 */
 	oldrc = get_plan_rowmark(root->rowMarks, rti);
-	if (oldrc)
-		oldrc->isParent = true;
+	Assert(oldrc == NULL || oldrc->isParent);
 
 	/*
-	 * Must open the parent relation to examine its tupdesc.  We need not lock
-	 * it; we assume the rewriter already did.
+	 * Must expand PlannerInfo arrays by num_children before we can add
+	 * children.
 	 */
-	oldrelation = heap_open(parentOID, NoLock);
+	expand_planner_arrays(root, num_children);
 
-	/* Scan the inheritance set and expand it */
-	if (RelationGetPartitionDesc(oldrelation) != NULL)
+	foreach(l, inhOIDs)
 	{
-		Assert(rte->relkind == RELKIND_PARTITIONED_TABLE);
-
-		/*
-		 * If this table has partitions, recursively expand them in the order
-		 * in which they appear in the PartitionDesc.  While at it, also
-		 * extract the partition key columns of all the partitioned tables.
-		 */
-		expand_partitioned_rtentry(root, rte, rti, oldrelation, oldrc,
-								   lockmode, &root->append_rel_list);
-	}
-	else
-	{
-		List	   *appinfos = NIL;
+		Oid			childOID = lfirst_oid(l);
+		Relation	newrelation;
 		RangeTblEntry *childrte;
 		Index		childRTindex;
 
+		/* Already locked above. */
+		newrelation = heap_open(childOID, NoLock);
+
 		/*
-		 * This table has no partitions.  Expand any plain inheritance
-		 * children in the order the OIDs were returned by
-		 * find_all_inheritors.
+		 * It is possible that the parent table has children that are temp
+		 * tables of other backends.  We cannot safely access such tables
+		 * (because of buffering issues), and the best thing to do seems
+		 * to be to silently ignore them.
 		 */
-		foreach(l, inhOIDs)
+		if (RELATION_IS_OTHER_TEMP(newrelation))
 		{
-			Oid			childOID = lfirst_oid(l);
-			Relation	newrelation;
-
-			/* Open rel if needed; we already have required locks */
-			if (childOID != parentOID)
-				newrelation = heap_open(childOID, NoLock);
-			else
-				newrelation = oldrelation;
-
-			/*
-			 * It is possible that the parent table has children that are temp
-			 * tables of other backends.  We cannot safely access such tables
-			 * (because of buffering issues), and the best thing to do seems
-			 * to be to silently ignore them.
-			 */
-			if (childOID != parentOID && RELATION_IS_OTHER_TEMP(newrelation))
-			{
-				heap_close(newrelation, lockmode);
-				continue;
-			}
-
-			expand_single_inheritance_child(root, rte, rti, oldrelation, oldrc,
-											newrelation,
-											&appinfos, &childrte,
-											&childRTindex);
-
-			/* Close child relations, but keep locks */
-			if (childOID != parentOID)
-				heap_close(newrelation, NoLock);
+			heap_close(newrelation, lockmode);
+			continue;
 		}
 
-		/*
-		 * If all the children were temp tables, pretend it's a
-		 * non-inheritance situation; we don't need Append node in that case.
-		 * The duplicate RTE we added for the parent table is harmless, so we
-		 * don't bother to get rid of it; ditto for the useless PlanRowMark
-		 * node.
-		 */
-		if (list_length(appinfos) < 2)
-			rte->inh = false;
-		else
-			root->append_rel_list = list_concat(root->append_rel_list,
-												appinfos);
+		(void) add_inheritance_child_rel(root, rte, rti, rel, oldrc,
+										 newrelation, &childrte,
+										 &childRTindex);
+		Assert(childrte != NULL);
+		/* All regular inheritance children are leaf children. */
+		Assert(!childrte->inh);
+		Assert(childRTindex > 0);
 
+		/* Close child relations, but keep locks */
+		heap_close(newrelation, NoLock);
+		num_children_added++;
 	}
 
-	heap_close(oldrelation, NoLock);
+	/*
+	 * If all children, including the parent (as child rel), were
+	 * excluded, mark the parent rel as empty.  If all the children were temp
+	 * tables, pretend it's a non-inheritance situation; we don't need Append
+	 * node in that case.  The duplicate RTE we added for the parent table is
+	 * harmless, so we don't bother to get rid of it; ditto for the useless
+	 * PlanRowMark node.
+	 */
+	if (num_children_added == 0)
+		mark_dummy_rel(rel);
+	else if (num_children_added == 1)
+		rte->inh = false;
+
+	/*
+	 * Add junk columns needed by the row mark if any and also add the
+	 * relevant expressions to the root parent's reltarget.
+	 */
+	if (oldrc)
+	{
+		List   *tlist = add_rowmark_junk_columns(root, oldrc);
+
+		build_base_rel_tlists(root, tlist);
+	}
 }
 
 /*
  * expand_partitioned_rtentry
- *		Recursively expand an RTE for a partitioned table.
+ *		Prunes unnecessary partitions of a partitioned table and adds
+ *		remaining ones to the Query and the PlannerInfo
+ *
+ * Partitions are added to the query in order in which they are found in
+ * the parent's PartitionDesc.
+ *
+ * Note: even though only the unpruned partitions will be added to the
+ * resulting plan, this still locks *all* partitions via find_all_inheritors
+ * when this function is called for the root partitioned table.
  */
 static void
 expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
-						   Index parentRTindex, Relation parentrel,
-						   PlanRowMark *top_parentrc, LOCKMODE lockmode,
-						   List **appinfos)
+						   Index parentRTindex, RelOptInfo *parentrel)
 {
+	LOCKMODE	lockmode = parentrte->rellockmode;
+	PlanRowMark *rootrc = NULL;
 	int			i;
-	RangeTblEntry *childrte;
-	Index		childRTindex;
-	PartitionDesc partdesc = RelationGetPartitionDesc(parentrel);
+	Bitmapset  *partindexes;
+	Index		rootParentRTindex = parentrel->inh_root_parent > 0 ?
+									parentrel->inh_root_parent :
+									parentRTindex;
 
-	check_stack_depth();
-
-	/* A partitioned table should always have a partition descriptor. */
-	Assert(partdesc);
-
-	Assert(parentrte->inh);
+	/* If root partitioned table, lock *all* partitions in the tree. */
+	if (parentRTindex == rootParentRTindex)
+		(void) find_all_inheritors(parentrte->relid, lockmode, NULL);
 
 	/*
-	 * Note down whether any partition key cols are being updated. Though it's
-	 * the root partitioned table's updatedCols we are interested in, we
-	 * instead use parentrte to get the updatedCols. This is convenient
-	 * because parentrte already has the root partrel's updatedCols translated
-	 * to match the attribute ordering of parentrel.
+	 * Initialize partitioned_child_rels to contain this RT index.
+	 *
+	 * Note that during the set_append_rel_pathlist() phase, values of the
+	 * indexes of partitioned relations that appear down in the tree will be
+	 * bubbled up into root parent's list so that when we've created Paths for
+	 * all the children, the root table's list will contain all such indexes.
 	 */
-	if (!root->partColsUpdated)
-		root->partColsUpdated =
-			has_partition_attrs(parentrel, parentrte->updatedCols, NULL);
+	parentrel->partitioned_child_rels = list_make1_int(parentRTindex);
 
-	/* First expand the partitioned table itself. */
-	expand_single_inheritance_child(root, parentrte, parentRTindex, parentrel,
-									top_parentrc, parentrel,
-									appinfos, &childrte, &childRTindex);
+	/* Perform pruning. */
+	partindexes = prune_append_rel_partitions(parentrel);
+
+	/* Must expand PlannerInfo arrays before we can add children. */
+	expand_planner_arrays(root, bms_num_members(partindexes));
 
 	/*
-	 * If the partitioned table has no partitions, treat this as the
-	 * non-inheritance case.
+	 * For partitioned tables, we also store the partition RelOptInfo
+	 * pointers in the parent's RelOptInfo.
 	 */
-	if (partdesc->nparts == 0)
-	{
-		parentrte->inh = false;
-		return;
-	}
+	parentrel->part_rels = (RelOptInfo **) palloc0(sizeof(RelOptInfo *) *
+												   parentrel->nparts);
 
-	for (i = 0; i < partdesc->nparts; i++)
+	rootrc = get_plan_rowmark(root->rowMarks, rootParentRTindex);
+	Assert(rootrc == NULL || rootrc->isParent);
+	i = -1;
+	while ((i = bms_next_member(partindexes, i)) >= 0)
 	{
-		Oid			childOID = partdesc->oids[i];
-		Relation	childrel;
+		Oid		childOID = parentrel->part_oids[i];
+		Relation	newrelation;
+		RelOptInfo *childrel;
+		RangeTblEntry *childrte;
+		Index		childRTindex;
 
-		/* Open rel; we already have required locks */
-		childrel = heap_open(childOID, NoLock);
+		/* Already locked above. */
+		newrelation = heap_open(childOID, NoLock);
+		Assert(!RELATION_IS_OTHER_TEMP(newrelation));
 
 		/*
-		 * Temporary partitions belonging to other sessions should have been
-		 * disallowed at definition, but for paranoia's sake, let's double
-		 * check.
+		 * A partitioned child table with 0 children is a dummy rel, so don't
+		 * bother creating planner objects for it.
 		 */
-		if (RELATION_IS_OTHER_TEMP(childrel))
-			elog(ERROR, "temporary relation from another session found as partition");
+		if (newrelation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE &&
+			RelationGetPartitionDesc(newrelation)->nparts == 0)
+		{
+			heap_close(newrelation, NoLock);
+			continue;
+		}
 
-		expand_single_inheritance_child(root, parentrte, parentRTindex,
-										parentrel, top_parentrc, childrel,
-										appinfos, &childrte, &childRTindex);
+		childrel = add_inheritance_child_rel(root, parentrte, parentRTindex,
+											 parentrel, rootrc, newrelation,
+											 &childrte, &childRTindex);
+		Assert(childrel != NULL);
+		parentrel->part_rels[i] = childrel;
 
-		/* If this child is itself partitioned, recurse */
-		if (childrel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
+		/* Close child relations, but keep locks */
+		heap_close(newrelation, NoLock);
+
+		/* If the child is partitioned itself, expand it too. */
+		if (childrel->part_scheme)
+		{
+			Assert(childrte->inh);
 			expand_partitioned_rtentry(root, childrte, childRTindex,
-									   childrel, top_parentrc, lockmode,
-									   appinfos);
+									   childrel);
+		}
+	}
 
-		/* Close child relation, but keep locks */
-		heap_close(childrel, NoLock);
+	/*
+	 * Add junk columns needed by the row mark if any and also add the
+	 * relevant expressions to the root parent's reltarget.
+	 */
+	if (rootrc)
+	{
+		List   *tlist = add_rowmark_junk_columns(root, rootrc);
+
+		build_base_rel_tlists(root, tlist);
 	}
 }
 
 /*
- * expand_single_inheritance_child
- *		Build a RangeTblEntry and an AppendRelInfo, if appropriate, plus
- *		maybe a PlanRowMark.
+ * add_inheritance_child_rel
+ *		Build a RangeTblEntry, an AppendRelInfo, a PlanRowMark, and finally
+ *		a RelOptInfo for an inheritance child relation.
  *
- * We now expand the partition hierarchy level by level, creating a
- * corresponding hierarchy of AppendRelInfos and RelOptInfos, where each
- * partitioned descendant acts as a parent of its immediate partitions.
- * (This is a difference from what older versions of PostgreSQL did and what
- * is still done in the case of table inheritance for unpartitioned tables,
- * where the hierarchy is flattened during RTE expansion.)
+ * The return value is the RelOptInfo that's added.
  *
  * PlanRowMarks still carry the top-parent's RTI, and the top-parent's
  * allMarkTypes field still accumulates values from all descendents.
  *
  * "parentrte" and "parentRTindex" are immediate parent's RTE and
  * RTI. "top_parentrc" is top parent's PlanRowMark.
- *
- * The child RangeTblEntry and its RTI are returned in "childrte_p" and
- * "childRTindex_p" resp.
  */
-static void
-expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte,
-								Index parentRTindex, Relation parentrel,
-								PlanRowMark *top_parentrc, Relation childrel,
-								List **appinfos, RangeTblEntry **childrte_p,
-								Index *childRTindex_p)
+static RelOptInfo *
+add_inheritance_child_rel(PlannerInfo *root, RangeTblEntry *parentrte,
+						  Index parentRTindex, RelOptInfo *parentrel,
+						  PlanRowMark *top_parentrc, Relation childrel,
+						  RangeTblEntry **childrte_p, Index *childRTindex_p)
 {
 	Query	   *parse = root->parse;
-	Oid			parentOID = RelationGetRelid(parentrel);
 	Oid			childOID = RelationGetRelid(childrel);
 	RangeTblEntry *childrte;
 	Index		childRTindex;
 	AppendRelInfo *appinfo;
+	RelOptInfo *childrelopt;
 
 	/*
 	 * Build an RTE for the child, and attach to query's rangetable list. We
 	 * copy most fields of the parent's RTE, but replace relation OID and
-	 * relkind, and set inh = false.  Also, set requiredPerms to zero since
-	 * all required permissions checks are done on the original RTE. Likewise,
-	 * set the child's securityQuals to empty, because we only want to apply
-	 * the parent's RLS conditions regardless of what RLS properties
+	 * relkind, and set inh appropriately.  Also, set requiredPerms to zero
+	 * since all required permissions checks are done on the original RTE.
+	 * Likewise, set the child's securityQuals to empty, because we only want
+	 * to apply the parent's RLS conditions regardless of what RLS properties
 	 * individual children may have.  (This is an intentional choice to make
 	 * inherited RLS work like regular permissions checks.) The parent
 	 * securityQuals will be propagated to children along with other base
@@ -1784,55 +1873,42 @@ expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte,
 	*childrte_p = childrte;
 	childrte->relid = childOID;
 	childrte->relkind = childrel->rd_rel->relkind;
-	/* A partitioned child will need to be expanded further. */
-	if (childOID != parentOID &&
-		childrte->relkind == RELKIND_PARTITIONED_TABLE)
-		childrte->inh = true;
-	else
-		childrte->inh = false;
+	/*
+	 * A partitioned child will need to be expanded as an append parent
+	 * itself, so set its inh to true.
+	 */
+	childrte->inh = (childrte->relkind == RELKIND_PARTITIONED_TABLE);
 	childrte->requiredPerms = 0;
 	childrte->securityQuals = NIL;
 	parse->rtable = lappend(parse->rtable, childrte);
 	childRTindex = list_length(parse->rtable);
 	*childRTindex_p = childRTindex;
 
-	/*
-	 * We need an AppendRelInfo if paths will be built for the child RTE. If
-	 * childrte->inh is true, then we'll always need to generate append paths
-	 * for it.  If childrte->inh is false, we must scan it if it's not a
-	 * partitioned table; but if it is a partitioned table, then it never has
-	 * any data of its own and need not be scanned.
-	 */
-	if (childrte->relkind != RELKIND_PARTITIONED_TABLE || childrte->inh)
-	{
-		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->translated_vars);
-		appinfo->parent_reloid = parentOID;
-		*appinfos = lappend(*appinfos, appinfo);
+	/* Create an AppendRelInfo and add it to planner's global list. */
+	appinfo = make_append_rel_info(parentrel, parentrte,
+								   childrel->rd_att,
+								   childOID,
+								   childrel->rd_rel->reltype,
+								   childRTindex);
+	root->append_rel_list = lappend(root->append_rel_list, appinfo);
 
-		/*
-		 * Translate the column permissions bitmaps to the child's attnums (we
-		 * have to build the translated_vars list before we can do this). But
-		 * if this is the parent table, leave copyObject's result alone.
-		 *
-		 * Note: we need to do this even though the executor won't run any
-		 * permissions checks on the child RTE.  The insertedCols/updatedCols
-		 * bitmaps may be examined for trigger-firing purposes.
-		 */
-		if (childOID != parentOID)
-		{
-			childrte->selectedCols = translate_col_privs(parentrte->selectedCols,
-														 appinfo->translated_vars);
-			childrte->insertedCols = translate_col_privs(parentrte->insertedCols,
-														 appinfo->translated_vars);
-			childrte->updatedCols = translate_col_privs(parentrte->updatedCols,
-														appinfo->translated_vars);
-		}
+	/*
+	 * Translate the column permissions bitmaps to the child's attnums (we
+	 * have to build the translated_vars list before we can do this). But
+	 * if this is the parent table, leave copyObject's result alone.
+	 *
+	 * Note: we need to do this even though the executor won't run any
+	 * permissions checks on the child RTE.  The insertedCols/updatedCols
+	 * bitmaps may be examined for trigger-firing purposes.
+	 */
+	if (childrte->relid != parentrte->relid)
+	{
+		childrte->selectedCols = translate_col_privs(parentrte->selectedCols,
+													 appinfo->translated_vars);
+		childrte->insertedCols = translate_col_privs(parentrte->insertedCols,
+													 appinfo->translated_vars);
+		childrte->updatedCols = translate_col_privs(parentrte->updatedCols,
+													appinfo->translated_vars);
 	}
 
 	/*
@@ -1864,6 +1940,24 @@ expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte,
 
 		root->rowMarks = lappend(root->rowMarks, childrc);
 	}
+
+	/*
+	 * Add the RelOptInfo.  Even though we may not really scan this relation
+	 * for reasons such as contradictory quals, we still need to create one,
+	 * because for every RTE in the query's range table, there must be an
+	 * accompanying RelOptInfo.
+	 */
+
+	/* First, store the RTE and appinfos into planner arrays. */
+	Assert(root->simple_rte_array[childRTindex] == NULL);
+	root->simple_rte_array[childRTindex] = childrte;
+	Assert(root->append_rel_array[childRTindex] == NULL);
+	root->append_rel_array[childRTindex] = appinfo;
+
+	childrelopt = build_append_child_rel(root, parentrel, childRTindex);
+	Assert(childrelopt != NULL);
+
+	return childrelopt;
 }
 
 /*
@@ -1874,14 +1968,11 @@ expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte,
  * For paranoia's sake, we match type/collation as well as attribute name.
  */
 static void
-make_inh_translation_list(Relation oldrelation, Relation newrelation,
-						  Index newvarno,
-						  List **translated_vars)
+make_inh_translation_list(TupleDesc old_tupdesc, TupleDesc new_tupdesc,
+						  Oid from_rel, Oid to_rel,
+						  Index newvarno, List **translated_vars)
 {
 	List	   *vars = NIL;
-	TupleDesc	old_tupdesc = RelationGetDescr(oldrelation);
-	TupleDesc	new_tupdesc = RelationGetDescr(newrelation);
-	Oid			new_relid = RelationGetRelid(newrelation);
 	int			oldnatts = old_tupdesc->natts;
 	int			newnatts = new_tupdesc->natts;
 	int			old_attno;
@@ -1911,7 +2002,7 @@ make_inh_translation_list(Relation oldrelation, Relation newrelation,
 		 * When we are generating the "translation list" for the parent table
 		 * of an inheritance set, no need to search for matches.
 		 */
-		if (oldrelation == newrelation)
+		if (from_rel == to_rel)
 		{
 			vars = lappend(vars, makeVar(newvarno,
 										 (AttrNumber) (old_attno + 1),
@@ -1937,10 +2028,10 @@ make_inh_translation_list(Relation oldrelation, Relation newrelation,
 		{
 			HeapTuple	newtup;
 
-			newtup = SearchSysCacheAttName(new_relid, attname);
+			newtup = SearchSysCacheAttName(to_rel, attname);
 			if (!newtup)
 				elog(ERROR, "could not find inherited attribute \"%s\" of relation \"%s\"",
-					 attname, RelationGetRelationName(newrelation));
+					 attname, get_rel_name(to_rel));
 			new_attno = ((Form_pg_attribute) GETSTRUCT(newtup))->attnum - 1;
 			ReleaseSysCache(newtup);
 
@@ -1950,10 +2041,10 @@ make_inh_translation_list(Relation oldrelation, Relation newrelation,
 		/* Found it, check type and collation match */
 		if (atttypid != att->atttypid || atttypmod != att->atttypmod)
 			elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's type",
-				 attname, RelationGetRelationName(newrelation));
+				 attname, get_rel_name(to_rel));
 		if (attcollation != att->attcollation)
 			elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's collation",
-				 attname, RelationGetRelationName(newrelation));
+				 attname, get_rel_name(to_rel));
 
 		vars = lappend(vars, makeVar(newvarno,
 									 (AttrNumber) (new_attno + 1),
@@ -2020,6 +2111,255 @@ translate_col_privs(const Bitmapset *parent_privs,
 }
 
 /*
+ *	build_append_child_rel
+ *		Build a RelOptInfo for child relation of an append rel
+ *
+ * After creating the RelOptInfo for the given child RT index, it goes on to
+ * initialize some of its fields based on the parent RelOptInfo.
+ *
+ * If the quals in baserestrictinfo turn out to be self-contradictory,
+ * RelOptInfo is marked dummy before returning.
+ */
+static RelOptInfo *
+build_append_child_rel(PlannerInfo *root,
+					   RelOptInfo *parent,
+					   Index childRTindex)
+{
+	RelOptInfo *childrel;
+	RangeTblEntry *childRTE = root->simple_rte_array[childRTindex];
+	AppendRelInfo *appinfo = root->append_rel_array[childRTindex];
+	List	   *childquals;
+	ListCell   *lc;
+	bool		have_const_false_cq;
+	Index		cq_min_security;
+
+	/* Build the RelOptInfo. */
+	childrel = build_simple_rel(root, childRTindex, parent);
+
+	/*
+	 * Propagate lateral_relids and lateral_referencers from appendrel
+	 * parent rels to their child rels.  We intentionally give each child rel
+	 * the same minimum parameterization, even though it's quite possible that
+	 * some don't reference all the lateral rels.  This is because any append
+	 * path for the parent will have to have the same parameterization for
+	 * every child anyway, and there's no value in forcing extra
+	 * reparameterize_path() calls.  Similarly, a lateral reference to the
+	 * parent prevents use of otherwise-movable join rels for each child.
+	 */
+	childrel->direct_lateral_relids = parent->direct_lateral_relids;
+	childrel->lateral_relids = parent->lateral_relids;
+	childrel->lateral_referencers = parent->lateral_referencers;
+
+	/*
+	 * We have to copy the parent's quals to the child, with appropriate
+	 * substitution of variables.  However, only the baserestrictinfo
+	 * quals are needed before we can check for constraint exclusion; so
+	 * do that first and then check to see if we can disregard this child.
+	 *
+	 * The child rel's targetlist might contain non-Var expressions, which
+	 * means that substitution into the quals could produce opportunities
+	 * for const-simplification, and perhaps even pseudoconstant quals.
+	 * Therefore, transform each RestrictInfo separately to see if it
+	 * reduces to a constant or pseudoconstant.  (We must process them
+	 * separately to keep track of the security level of each qual.)
+	 */
+	childquals = false;
+	cq_min_security = UINT_MAX;
+	have_const_false_cq = false;
+	foreach(lc, parent->baserestrictinfo)
+	{
+		RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
+		Node	   *childqual = (Node *) rinfo->clause;
+		ListCell   *lc2;
+
+		Assert(IsA(rinfo, RestrictInfo));
+		childqual = adjust_appendrel_attrs(root, childqual,
+										   1, &appinfo);
+		childqual = eval_const_expressions(root, childqual);
+		/* check for flat-out constant */
+		if (childqual && IsA(childqual, Const))
+		{
+			if (((Const *) childqual)->constisnull ||
+				!DatumGetBool(((Const *) childqual)->constvalue))
+			{
+				/* Restriction reduces to constant FALSE or NULL */
+				have_const_false_cq = true;
+				break;
+			}
+			/* Restriction reduces to constant TRUE, so drop it */
+			continue;
+		}
+		/* might have gotten an AND clause, if so flatten it */
+		foreach(lc2, make_ands_implicit((Expr *) childqual))
+		{
+			Node	   *onecq = (Node *) lfirst(lc2);
+			bool		pseudoconstant;
+
+			/* check for pseudoconstant (no Vars or volatile functions) */
+			pseudoconstant =
+					!contain_vars_of_level(onecq, 0) &&
+					!contain_volatile_functions(onecq);
+			if (pseudoconstant)
+			{
+				/* tell createplan.c to check for gating quals */
+				root->hasPseudoConstantQuals = true;
+			}
+			/* reconstitute RestrictInfo with appropriate properties */
+			childquals = lappend(childquals,
+								 make_restrictinfo((Expr *) onecq,
+												   rinfo->is_pushed_down,
+												   rinfo->outerjoin_delayed,
+												   pseudoconstant,
+												   rinfo->security_level,
+												   NULL, NULL, NULL));
+			cq_min_security = Min(cq_min_security, rinfo->security_level);
+		}
+	}
+
+	/*
+	 * In addition to the quals inherited from the parent, we might
+	 * have securityQuals associated with this particular child node.
+	 * (Currently this can only happen in appendrels originating from
+	 * UNION ALL; inheritance child tables don't have their own
+	 * securityQuals.)	Pull any such securityQuals up into the
+	 * baserestrictinfo for the child.  This is similar to
+	 * process_security_barrier_quals() for the parent rel, except
+	 * that we can't make any general deductions from such quals,
+	 * since they don't hold for the whole appendrel.
+	 */
+	if (childRTE->securityQuals)
+	{
+		Index		security_level = 0;
+
+		foreach(lc, childRTE->securityQuals)
+		{
+			List	   *qualset = (List *) lfirst(lc);
+			ListCell   *lc2;
+
+			foreach(lc2, qualset)
+			{
+				Expr	   *qual = (Expr *) lfirst(lc2);
+
+				/*
+				 * not likely that we'd see constants here, so no
+				 * check
+				 */
+				childquals = lappend(childquals,
+									 make_restrictinfo(qual,
+													   true,
+													   false,
+													   false,
+													   security_level,
+													   NULL, NULL,
+													   NULL));
+				cq_min_security = Min(cq_min_security, security_level);
+			}
+			security_level++;
+		}
+		Assert(security_level <= root->qual_security_level);
+	}
+
+	/* Set child's version of baserestrictinfo. */
+	childrel->baserestrictinfo = childquals;
+	childrel->baserestrict_min_security = cq_min_security;
+
+	if (have_const_false_cq)
+	{
+		/*
+		 * Some restriction clause reduced to constant FALSE or NULL after
+		 * substitution, so this child need not be scanned.
+		 */
+		set_dummy_rel_pathlist(childrel);
+	}
+
+	return childrel;
+}
+
+/*
+ * add_rowmark_junk_columns
+ * 		Add necessary junk columns for rowmarked inheritance parent rel.
+ *
+ * These values are needed for locking of rels selected FOR UPDATE/SHARE, and
+ * to do EvalPlanQual rechecking.  See comments for PlanRowMark in
+ * plannodes.h.
+ */
+static List *
+add_rowmark_junk_columns(PlannerInfo *root, PlanRowMark *rc)
+{
+	List   *tlist = root->processed_tlist;
+	Var		   *var;
+	char		resname[32];
+	TargetEntry *tle;
+
+	if (rc->allMarkTypes & ~(1 << ROW_MARK_COPY))
+	{
+		/* Need to fetch TID */
+		var = makeVar(rc->rti,
+					  SelfItemPointerAttributeNumber,
+					  TIDOID,
+					  -1,
+					  InvalidOid,
+					  0);
+		snprintf(resname, sizeof(resname), "ctid%u", rc->rowmarkId);
+		tle = makeTargetEntry((Expr *) var,
+							  list_length(tlist) + 1,
+							  pstrdup(resname),
+							  true);
+		tlist = lappend(tlist, tle);
+	}
+	if (rc->allMarkTypes & (1 << ROW_MARK_COPY))
+	{
+		/* Need the whole row as a junk var */
+		var = makeWholeRowVar(root->simple_rte_array[rc->rti],
+							  rc->rti,
+							  0,
+							  false);
+		snprintf(resname, sizeof(resname), "wholerow%u", rc->rowmarkId);
+		tle = makeTargetEntry((Expr *) var,
+							  list_length(tlist) + 1,
+							  pstrdup(resname),
+							  true);
+		tlist = lappend(tlist, tle);
+	}
+
+	/* For inheritance cases, always fetch the tableoid too. */
+	var = makeVar(rc->rti,
+				  TableOidAttributeNumber,
+				  OIDOID,
+				  -1,
+				  InvalidOid,
+				  0);
+	snprintf(resname, sizeof(resname), "tableoid%u", rc->rowmarkId);
+	tle = makeTargetEntry((Expr *) var,
+						  list_length(tlist) + 1,
+						  pstrdup(resname),
+						  true);
+	tlist = lappend(tlist, tle);
+
+	return tlist;
+}
+
+AppendRelInfo *
+make_append_rel_info(RelOptInfo *parentrel, RangeTblEntry *parentrte,
+					 TupleDesc childdesc, Oid childoid, Oid childreltype,
+					 Index childRTindex)
+{
+	AppendRelInfo  *appinfo = makeNode(AppendRelInfo);
+
+	appinfo->parent_relid = parentrel->relid;
+	appinfo->child_relid = childRTindex;
+	appinfo->parent_reltype = parentrel->reltype;
+	appinfo->child_reltype = childreltype;
+	make_inh_translation_list(parentrel->tupdesc, childdesc,
+							  parentrte->relid, childoid,
+							  childRTindex,
+							  &appinfo->translated_vars);
+	appinfo->parent_reloid = parentrte->relid;
+
+	return appinfo;
+}
+
+/*
  * adjust_appendrel_attrs
  *	  Copy the specified query or expression and translate Vars referring to a
  *	  parent rel to refer to the corresponding child rel instead.  We also
diff --git a/src/backend/optimizer/util/Makefile b/src/backend/optimizer/util/Makefile
index c54d0a690d..da9ccf32b4 100644
--- a/src/backend/optimizer/util/Makefile
+++ b/src/backend/optimizer/util/Makefile
@@ -13,6 +13,6 @@ top_builddir = ../../../..
 include $(top_builddir)/src/Makefile.global
 
 OBJS = clauses.o joininfo.o orclauses.o pathnode.o placeholder.o \
-       plancat.o predtest.o relnode.o restrictinfo.o tlist.o var.o
+	   plancat.o predtest.o relnode.o restrictinfo.o tlist.o var.o
 
 include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/optimizer/util/plancat.c b/src/backend/optimizer/util/plancat.c
index 51d8faf2dd..6562d3f4ff 100644
--- a/src/backend/optimizer/util/plancat.c
+++ b/src/backend/optimizer/util/plancat.c
@@ -106,7 +106,7 @@ static void set_baserel_partition_key_exprs(Relation relation,
  */
 void
 get_relation_info(PlannerInfo *root, Oid relationObjectId, bool inhparent,
-				  RelOptInfo *rel)
+				  Bitmapset *updatedCols, RelOptInfo *rel)
 {
 	Index		varno = rel->relid;
 	Relation	relation;
@@ -444,11 +444,31 @@ get_relation_info(PlannerInfo *root, Oid relationObjectId, bool inhparent,
 	get_relation_foreign_keys(root, rel, relation, inhparent);
 
 	/*
-	 * Collect info about relation's partitioning scheme, if any. Only
-	 * inheritance parents may be partitioned.
+	 * Collect some additional information for inheritance parents.
 	 */
-	if (inhparent && relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
-		set_relation_partition_info(root, rel, relation);
+	if (inhparent)
+	{
+		/*
+		 * We'll need the TupleDesc when initializing the child relation.
+		 * A copy is being made because concurrent changes might drop
+		 * the relcache entry.  That's possible because ALTER TABLE
+		 * child_table NO INHERIT parent_table only requires an
+		 * AccessShareLock on parent_table.
+		 */
+		rel->tupdesc = CreateTupleDescCopy(RelationGetDescr(relation));
+		rel->reltype = RelationGetForm(relation)->reltype;
+
+		/*
+		 * If partitioned, also save the information of partitioning scheme,
+		 * and whether the query updates any of the partition key columns.
+		 */
+		if (relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
+		{
+			set_relation_partition_info(root, rel, relation);
+			root->partColsUpdated |= has_partition_attrs(relation, updatedCols,
+														 NULL);
+		}
+	}
 
 	heap_close(relation, NoLock);
 
@@ -1853,16 +1873,20 @@ set_relation_partition_info(PlannerInfo *root, RelOptInfo *rel,
 							Relation relation)
 {
 	PartitionDesc partdesc;
-	PartitionKey partkey;
 
 	Assert(relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE);
 
 	partdesc = RelationGetPartitionDesc(relation);
-	partkey = RelationGetPartitionKey(relation);
 	rel->part_scheme = find_partition_scheme(root, relation);
 	Assert(partdesc != NULL && rel->part_scheme != NULL);
-	rel->boundinfo = partition_bounds_copy(partdesc->boundinfo, partkey);
 	rel->nparts = partdesc->nparts;
+
+	/*
+	 * Since we must've taken a lock on the table, it's okay to simply copy
+	 * the pointers to relcache data here.
+	 */
+	rel->part_oids = partdesc->oids;
+	rel->boundinfo = partdesc->boundinfo;
 	set_baserel_partition_key_exprs(relation, rel);
 	rel->partition_qual = RelationGetPartitionQual(relation);
 }
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index e079a2469d..fa39afcfe6 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -130,6 +130,37 @@ setup_append_rel_array(PlannerInfo *root)
 	}
 }
 
+/* Expand the PlannerInfo arrays by add_size members and zero-init it. */
+void
+expand_planner_arrays(PlannerInfo *root, int add_size)
+{
+	int		new_size = root->simple_rel_array_size + add_size;
+
+	root->simple_rte_array = (RangeTblEntry **)
+							repalloc(root->simple_rte_array,
+									 sizeof(RangeTblEntry *) * new_size);
+	root->simple_rel_array = (RelOptInfo **)
+								repalloc(root->simple_rel_array,
+										 sizeof(RelOptInfo *) * new_size);
+	if (root->append_rel_array)
+		root->append_rel_array = (AppendRelInfo **)
+									repalloc(root->append_rel_array,
+									 sizeof(AppendRelInfo *) * new_size);
+	else
+		root->append_rel_array = (AppendRelInfo **)
+									palloc0(sizeof(AppendRelInfo *) *
+											new_size);
+
+	/* Set the contents of just allocated memory to 0. */
+	MemSet(root->simple_rte_array + root->simple_rel_array_size,
+		   0, sizeof(RangeTblEntry *) * add_size);
+	MemSet(root->simple_rel_array + root->simple_rel_array_size,
+		   0, sizeof(RelOptInfo *) * add_size);
+	MemSet(root->append_rel_array + root->simple_rel_array_size,
+		   0, sizeof(AppendRelInfo *) * add_size);
+	root->simple_rel_array_size = new_size;
+}
+
 /*
  * build_simple_rel
  *	  Construct a new RelOptInfo for a base relation or 'other' relation.
@@ -238,7 +269,8 @@ build_simple_rel(PlannerInfo *root, int relid, RelOptInfo *parent)
 	{
 		case RTE_RELATION:
 			/* Table --- retrieve statistics from the system catalogs */
-			get_relation_info(root, rte->relid, rte->inh, rel);
+			get_relation_info(root, rte->relid, rte->inh, rte->updatedCols,
+							  rel);
 			break;
 		case RTE_SUBQUERY:
 		case RTE_FUNCTION:
@@ -279,52 +311,6 @@ build_simple_rel(PlannerInfo *root, int relid, RelOptInfo *parent)
 		root->qual_security_level = Max(root->qual_security_level,
 										list_length(rte->securityQuals));
 
-	/*
-	 * If this rel is an appendrel parent, recurse to build "other rel"
-	 * RelOptInfos for its children.  They are "other rels" because they are
-	 * not in the main join tree, but we will need RelOptInfos to plan access
-	 * to them.
-	 */
-	if (rte->inh)
-	{
-		ListCell   *l;
-		int			nparts = rel->nparts;
-		int			cnt_parts = 0;
-
-		if (nparts > 0)
-			rel->part_rels = (RelOptInfo **)
-				palloc(sizeof(RelOptInfo *) * nparts);
-
-		foreach(l, root->append_rel_list)
-		{
-			AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(l);
-			RelOptInfo *childrel;
-
-			/* append_rel_list contains all append rels; ignore others */
-			if (appinfo->parent_relid != relid)
-				continue;
-
-			childrel = build_simple_rel(root, appinfo->child_relid,
-										rel);
-
-			/* Nothing more to do for an unpartitioned table. */
-			if (!rel->part_scheme)
-				continue;
-
-			/*
-			 * The order of partition OIDs in append_rel_list is the same as
-			 * the order in the PartitionDesc, so the order of part_rels will
-			 * also match the PartitionDesc.  See expand_partitioned_rtentry.
-			 */
-			Assert(cnt_parts < nparts);
-			rel->part_rels[cnt_parts] = childrel;
-			cnt_parts++;
-		}
-
-		/* We should have seen all the child partitions. */
-		Assert(cnt_parts == nparts);
-	}
-
 	return rel;
 }
 
diff --git a/src/backend/partitioning/partprune.c b/src/backend/partitioning/partprune.c
index 0684083a8d..64787de16f 100644
--- a/src/backend/partitioning/partprune.c
+++ b/src/backend/partitioning/partprune.c
@@ -45,6 +45,7 @@
 #include "nodes/makefuncs.h"
 #include "nodes/nodeFuncs.h"
 #include "optimizer/clauses.h"
+#include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
 #include "optimizer/planner.h"
 #include "optimizer/predtest.h"
@@ -436,17 +437,23 @@ make_partitionedrel_pruneinfo(PlannerInfo *root, RelOptInfo *parentrel,
 		 * is, not pruned already).
 		 */
 		subplan_map = (int *) palloc(nparts * sizeof(int));
+		memset(subplan_map, -1, nparts * sizeof(int));
 		subpart_map = (int *) palloc(nparts * sizeof(int));
+		memset(subpart_map, -1, nparts * sizeof(int));
 		present_parts = NULL;
 
 		for (i = 0; i < nparts; i++)
 		{
 			RelOptInfo *partrel = subpart->part_rels[i];
-			int			subplanidx = relid_subplan_map[partrel->relid] - 1;
-			int			subpartidx = relid_subpart_map[partrel->relid] - 1;
+			int			subplanidx;
+			int			subpartidx;
 
-			subplan_map[i] = subplanidx;
-			subpart_map[i] = subpartidx;
+			/* Skip processing pruned partitions. */
+			if (partrel == NULL)
+				continue;
+
+			subplan_map[i] = subplanidx = relid_subplan_map[partrel->relid] - 1;
+			subpart_map[i] = subpartidx = relid_subpart_map[partrel->relid] - 1;
 			if (subplanidx >= 0)
 			{
 				present_parts = bms_add_member(present_parts, i);
@@ -540,23 +547,20 @@ gen_partprune_steps(RelOptInfo *rel, List *clauses, bool *contradictory)
 
 /*
  * prune_append_rel_partitions
- *		Returns RT indexes of the minimum set of child partitions which must
- *		be scanned to satisfy rel's baserestrictinfo quals.
+ *		Returns indexes into rel->part_rels of the minimum set of child
+ *		partitions which must be scanned to satisfy rel's baserestrictinfo
+ *		quals.
  *
  * Callers must ensure that 'rel' is a partitioned table.
  */
-Relids
+Bitmapset *
 prune_append_rel_partitions(RelOptInfo *rel)
 {
-	Relids		result;
 	List	   *clauses = rel->baserestrictinfo;
 	List	   *pruning_steps;
 	bool		contradictory;
 	PartitionPruneContext context;
-	Bitmapset  *partindexes;
-	int			i;
 
-	Assert(clauses != NIL);
 	Assert(rel->part_scheme != NULL);
 
 	/* If there are no partitions, return the empty set */
@@ -564,6 +568,13 @@ prune_append_rel_partitions(RelOptInfo *rel)
 		return NULL;
 
 	/*
+	 * If pruning is disabled or if there are no clauses to prune with,
+	 * return all partitions.
+	 */
+	if (!enable_partition_pruning || clauses == NIL)
+		return bms_add_range(NULL, 0, rel->nparts - 1);
+
+	/*
 	 * Process clauses.  If the clauses are found to be contradictory, we can
 	 * return the empty set.
 	 */
@@ -590,15 +601,7 @@ prune_append_rel_partitions(RelOptInfo *rel)
 	context.evalexecparams = false;
 
 	/* Actual pruning happens here. */
-	partindexes = get_matching_partitions(&context, pruning_steps);
-
-	/* Add selected partitions' RT indexes to result. */
-	i = -1;
-	result = NULL;
-	while ((i = bms_next_member(partindexes, i)) >= 0)
-		result = bms_add_member(result, rel->part_rels[i]->relid);
-
-	return result;
+	return get_matching_partitions(&context, pruning_steps);
 }
 
 /*
diff --git a/src/include/nodes/relation.h b/src/include/nodes/relation.h
index a2adbfc3b8..0303a454ce 100644
--- a/src/include/nodes/relation.h
+++ b/src/include/nodes/relation.h
@@ -15,6 +15,7 @@
 #define RELATION_H
 
 #include "access/sdir.h"
+#include "access/tupdesc.h"
 #include "fmgr.h"
 #include "lib/stringinfo.h"
 #include "nodes/params.h"
@@ -726,6 +727,7 @@ typedef struct RelOptInfo
 	int			nparts;			/* number of partitions */
 	struct PartitionBoundInfoData *boundinfo;	/* Partition bounds */
 	List	   *partition_qual; /* partition constraint */
+	Oid		   *part_oids;		/* partition OIDs */
 	struct RelOptInfo **part_rels;	/* Array of RelOptInfos of partitions,
 									 * stored in the same order of bounds */
 	List	  **partexprs;		/* Non-nullable partition key expressions. */
@@ -735,6 +737,12 @@ typedef struct RelOptInfo
 	Index		inh_root_parent;	/* For otherrels, this is the RT index of
 									 * inheritance table mentioned in the query
 									 * from which this relation originated */
+	/*
+	 * Set only if this is an inheritance parent relation.  This information
+	 * is needed when initializing the planning info for children.
+	 */
+	TupleDesc	tupdesc;		/* A "copy" of the table's tuple desriptor */
+	Oid			reltype;		/* Table's reltype */
 } RelOptInfo;
 
 /*
diff --git a/src/include/optimizer/pathnode.h b/src/include/optimizer/pathnode.h
index bd905d3328..e7d0a20c54 100644
--- a/src/include/optimizer/pathnode.h
+++ b/src/include/optimizer/pathnode.h
@@ -261,6 +261,7 @@ extern Path *reparameterize_path_by_child(PlannerInfo *root, Path *path,
  */
 extern void setup_simple_rel_arrays(PlannerInfo *root);
 extern void setup_append_rel_array(PlannerInfo *root);
+extern void expand_planner_arrays(PlannerInfo *root, int add_size);
 extern RelOptInfo *build_simple_rel(PlannerInfo *root, int relid,
 				 RelOptInfo *parent);
 extern RelOptInfo *find_base_rel(PlannerInfo *root, int relid);
diff --git a/src/include/optimizer/plancat.h b/src/include/optimizer/plancat.h
index a1b23251a1..ce666b56ad 100644
--- a/src/include/optimizer/plancat.h
+++ b/src/include/optimizer/plancat.h
@@ -26,7 +26,7 @@ extern PGDLLIMPORT get_relation_info_hook_type get_relation_info_hook;
 
 
 extern void get_relation_info(PlannerInfo *root, Oid relationObjectId,
-				  bool inhparent, RelOptInfo *rel);
+				  bool inhparent, Bitmapset *updatedCols, RelOptInfo *rel);
 
 extern List *infer_arbiter_indexes(PlannerInfo *root);
 
diff --git a/src/include/optimizer/prep.h b/src/include/optimizer/prep.h
index d6991d5690..9c0795262f 100644
--- a/src/include/optimizer/prep.h
+++ b/src/include/optimizer/prep.h
@@ -38,7 +38,8 @@ extern Expr *canonicalize_qual(Expr *qual, bool is_check);
 /*
  * prototypes for preptlist.c
  */
-extern List *preprocess_targetlist(PlannerInfo *root);
+extern List *preprocess_targetlist(PlannerInfo *root,
+							bool inheritance_expanded);
 
 extern PlanRowMark *get_plan_rowmark(List *rowmarks, Index rtindex);
 
@@ -51,7 +52,10 @@ extern void expand_inherited_tables(PlannerInfo *root);
 
 extern Node *adjust_appendrel_attrs(PlannerInfo *root, Node *node,
 					   int nappinfos, AppendRelInfo **appinfos);
-
+extern AppendRelInfo *make_append_rel_info(RelOptInfo *parentrel,
+					 RangeTblEntry *parentrte,
+					 TupleDesc childdesc, Oid childoid, Oid childreltype,
+					 Index childRTindex);
 extern Node *adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node,
 								  Relids child_relids,
 								  Relids top_parent_relids);
@@ -64,5 +68,4 @@ extern SpecialJoinInfo *build_child_join_sjinfo(PlannerInfo *root,
 						Relids left_relids, Relids right_relids);
 extern Relids adjust_child_relids_multilevel(PlannerInfo *root, Relids relids,
 							   Relids child_relids, Relids top_parent_relids);
-
 #endif							/* PREP_H */
diff --git a/src/include/partitioning/partprune.h b/src/include/partitioning/partprune.h
index ce9bc8d9fd..5c5d27d040 100644
--- a/src/include/partitioning/partprune.h
+++ b/src/include/partitioning/partprune.h
@@ -76,7 +76,7 @@ extern PartitionPruneInfo *make_partition_pruneinfo(PlannerInfo *root,
 						 List *subpaths,
 						 List *partitioned_rels,
 						 List *prunequal);
-extern Relids prune_append_rel_partitions(RelOptInfo *rel);
+extern Bitmapset *prune_append_rel_partitions(RelOptInfo *rel);
 extern Bitmapset *get_matching_partitions(PartitionPruneContext *context,
 						List *pruning_steps);
 
diff --git a/src/test/regress/expected/partition_aggregate.out b/src/test/regress/expected/partition_aggregate.out
index 6bc106831e..1450cef057 100644
--- a/src/test/regress/expected/partition_aggregate.out
+++ b/src/test/regress/expected/partition_aggregate.out
@@ -144,7 +144,7 @@ SELECT c, sum(a) FROM pagg_tab WHERE 1 = 2 GROUP BY c;
            QUERY PLAN           
 --------------------------------
  HashAggregate
-   Group Key: pagg_tab.c
+   Group Key: c
    ->  Result
          One-Time Filter: false
 (4 rows)
@@ -159,7 +159,7 @@ SELECT c, sum(a) FROM pagg_tab WHERE c = 'x' GROUP BY c;
            QUERY PLAN           
 --------------------------------
  GroupAggregate
-   Group Key: pagg_tab.c
+   Group Key: c
    ->  Result
          One-Time Filter: false
 (4 rows)
-- 
2.11.0

From 3b86331dd5a2368adc39c9fef92f3dd09d817a08 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Wed, 7 Nov 2018 16:51:31 +0900
Subject: [PATCH v11 4/6] Move inheritance expansion code into its own file

This commit moves expand_inherited_tables and underlings currently
in optimizer/prep/prepunionc.c to optimizer/utils/inherit.c.

All of the AppendRelInfo based expression manipulation routines
are moved to optimizer/utils/appendinfo.c.

This commit only moves the code and contains no functional changes.
---
 src/backend/optimizer/path/allpaths.c   |    2 +
 src/backend/optimizer/path/equivclass.c |    1 +
 src/backend/optimizer/path/joinrels.c   |    1 +
 src/backend/optimizer/plan/planmain.c   |    2 +
 src/backend/optimizer/plan/planner.c    |    1 +
 src/backend/optimizer/prep/prepunion.c  | 1573 -------------------------------
 src/backend/optimizer/util/Makefile     |    5 +-
 src/backend/optimizer/util/appendinfo.c |  851 +++++++++++++++++
 src/backend/optimizer/util/inherit.c    |  776 +++++++++++++++
 src/backend/optimizer/util/pathnode.c   |    1 +
 src/backend/optimizer/util/relnode.c    |    1 +
 src/backend/partitioning/partprune.c    |    1 +
 src/include/optimizer/appendinfo.h      |   43 +
 src/include/optimizer/inherit.h         |   25 +
 src/include/optimizer/prep.h            |   19 -
 15 files changed, 1708 insertions(+), 1594 deletions(-)
 create mode 100644 src/backend/optimizer/util/appendinfo.c
 create mode 100644 src/backend/optimizer/util/inherit.c
 create mode 100644 src/include/optimizer/appendinfo.h
 create mode 100644 src/include/optimizer/inherit.h

diff --git a/src/backend/optimizer/path/allpaths.c b/src/backend/optimizer/path/allpaths.c
index be7b8a717e..a3a686a153 100644
--- a/src/backend/optimizer/path/allpaths.c
+++ b/src/backend/optimizer/path/allpaths.c
@@ -30,6 +30,8 @@
 #ifdef OPTIMIZER_DEBUG
 #include "nodes/print.h"
 #endif
+#include "optimizer/inherit.h"
+#include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/geqo.h"
diff --git a/src/backend/optimizer/path/equivclass.c b/src/backend/optimizer/path/equivclass.c
index 255e8f86a0..8b4ba1a828 100644
--- a/src/backend/optimizer/path/equivclass.c
+++ b/src/backend/optimizer/path/equivclass.c
@@ -22,6 +22,7 @@
 #include "catalog/pg_type.h"
 #include "nodes/makefuncs.h"
 #include "nodes/nodeFuncs.h"
+#include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
 #include "optimizer/pathnode.h"
 #include "optimizer/paths.h"
diff --git a/src/backend/optimizer/path/joinrels.c b/src/backend/optimizer/path/joinrels.c
index be2e39fd4b..23335a1c2d 100644
--- a/src/backend/optimizer/path/joinrels.c
+++ b/src/backend/optimizer/path/joinrels.c
@@ -15,6 +15,7 @@
 #include "postgres.h"
 
 #include "miscadmin.h"
+#include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
 #include "optimizer/joininfo.h"
 #include "optimizer/pathnode.h"
diff --git a/src/backend/optimizer/plan/planmain.c b/src/backend/optimizer/plan/planmain.c
index 3f060927cc..825998ad51 100644
--- a/src/backend/optimizer/plan/planmain.c
+++ b/src/backend/optimizer/plan/planmain.c
@@ -20,7 +20,9 @@
  */
 #include "postgres.h"
 
+#include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
+#include "optimizer/inherit.h"
 #include "optimizer/orclauses.h"
 #include "optimizer/pathnode.h"
 #include "optimizer/paths.h"
diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index b9b56d9280..db277385d5 100644
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -39,6 +39,7 @@
 #include "nodes/print.h"
 #endif
 #include "nodes/relation.h"
+#include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
diff --git a/src/backend/optimizer/prep/prepunion.c b/src/backend/optimizer/prep/prepunion.c
index 632781acc2..5d59385ef7 100644
--- a/src/backend/optimizer/prep/prepunion.c
+++ b/src/backend/optimizer/prep/prepunion.c
@@ -12,11 +12,6 @@
  * case, but most of the heavy lifting for that is done elsewhere,
  * notably in prepjointree.c and allpaths.c.
  *
- * There is also some code here to support planning of queries that use
- * inheritance (SELECT FROM foo*).  Inheritance trees are converted into
- * append relations, and thenceforth share code with the UNION ALL case.
- *
- *
  * Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
@@ -39,32 +34,21 @@
 #include "miscadmin.h"
 #include "nodes/makefuncs.h"
 #include "nodes/nodeFuncs.h"
-#include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
 #include "optimizer/paths.h"
 #include "optimizer/planmain.h"
 #include "optimizer/planner.h"
 #include "optimizer/prep.h"
-#include "optimizer/restrictinfo.h"
 #include "optimizer/tlist.h"
-#include "optimizer/var.h"
 #include "parser/parse_coerce.h"
 #include "parser/parsetree.h"
-#include "partitioning/partprune.h"
 #include "utils/lsyscache.h"
 #include "utils/rel.h"
 #include "utils/selfuncs.h"
 #include "utils/syscache.h"
 
 
-typedef struct
-{
-	PlannerInfo *root;
-	int			nappinfos;
-	AppendRelInfo **appinfos;
-} adjust_appendrel_attrs_context;
-
 static RelOptInfo *recurse_set_operations(Node *setOp, PlannerInfo *root,
 					   List *colTypes, List *colCollations,
 					   bool junkOK,
@@ -103,34 +87,6 @@ static List *generate_append_tlist(List *colTypes, List *colCollations,
 					  List *input_tlists,
 					  List *refnames_tlist);
 static List *generate_setop_grouplist(SetOperationStmt *op, List *targetlist);
-static void expand_append_rtentry(PlannerInfo *root, RelOptInfo *rel,
-					  RangeTblEntry *rte, Index rti);
-static void expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte,
-						 Index rti, RelOptInfo *rel);
-static void expand_partitioned_rtentry(PlannerInfo *root,
-						   RangeTblEntry *parentrte,
-						   Index parentRTindex, RelOptInfo *parentrel);
-static RelOptInfo *add_inheritance_child_rel(PlannerInfo *root,
-						  RangeTblEntry *parentrte,
-						  Index parentRTindex, RelOptInfo *parentrel,
-						  PlanRowMark *top_parentrc, Relation childrel,
-						  RangeTblEntry **childrte_p, Index *childRTindex_p);
-static void make_inh_translation_list(TupleDesc old_tupdesc,
-						  TupleDesc new_tupdesc,
-						  Oid from_rel, Oid to_rel,
-						  Index newvarno, List **translated_vars);
-static RelOptInfo *build_append_child_rel(PlannerInfo *root,
-					   RelOptInfo *parent,
-					   Index childRTindex);
-static List *add_rowmark_junk_columns(PlannerInfo *root, PlanRowMark *rc);
-static Bitmapset *translate_col_privs(const Bitmapset *parent_privs,
-					List *translated_vars);
-static Node *adjust_appendrel_attrs_mutator(Node *node,
-							   adjust_appendrel_attrs_context *context);
-static Relids adjust_child_relids(Relids relids, int nappinfos,
-					AppendRelInfo **appinfos);
-static List *adjust_inherited_tlist(List *tlist,
-					   AppendRelInfo *context);
 
 
 /*
@@ -1467,1532 +1423,3 @@ generate_setop_grouplist(SetOperationStmt *op, List *targetlist)
 	Assert(lg == NULL);
 	return grouplist;
 }
-
-
-/*
- * expand_inherited_tables
- *		Expand each rangetable entry that represents an inheritance set
- *		into an "append relation".  At the conclusion of this process,
- *		the "inh" flag is set in all and only those RTEs that are append
- *		relation parents.
- */
-void
-expand_inherited_tables(PlannerInfo *root)
-{
-	int			orig_rtable_size;
-	Index		rti;
-
-	Assert(root->simple_rel_array_size > 0);
-	orig_rtable_size = root->simple_rel_array_size;
-
-	/*
-	 * expand_append_rtentry may add RTEs to parse->rtable. The function is
-	 * expected to recursively handle any RTEs that it creates with inh=true.
-	 * So just scan as far as the original end of the rtable list.
-	 */
-	for (rti = 1; rti < orig_rtable_size; rti++)
-	{
-		RelOptInfo *brel = root->simple_rel_array[rti];
-		RangeTblEntry *rte = root->simple_rte_array[rti];
-
-		/* there may be empty slots corresponding to non-baserel RTEs */
-		if (brel == NULL)
-			continue;
-
-		if (rte->inh)
-			expand_append_rtentry(root, brel, rte, rti);
-	}
-}
-
-/*
- * expand_append_rtentry
- *		This initializes RelOptInfos for an appendrel's child relations, if
- *		any
- *
- * 'rel' is the appendrel parent, whose range table entry ('rte') has been
- * marked to require adding children.  An appendrel parent could either
- * be a subquery (if we flattened UNION ALL query) or a table that's known
- * to have inheritance children.  The latter consists of both regular
- * inheritance parents and partitioned tables.
- *
- * For a subquery parent, there is not much to be done here because the
- * children's RTEs are already present in the query, so we just initialize
- * RelOptInfos for them.  Also, the AppendRelInfos for child subqueries
- * have already been added.
- *
- * For tables, we need to add the children to the range table and initialize
- * AppendRelInfos, RelOptInfos, and PlanRowMarks (if any) for them.  For
- * a partitioned parent, we only add the children remaining after pruning.
- * For regular inheritance parents, we find the children using
- * find_all_inheritors and add all of them.
- *
- * If it turns out that there are no children, then we set rte->inh to false
- * to let the caller know that only the parent table needs to be scanned.  The
- * caller can accordingly switch to a non-Append path.  For a partitioned
- * parent, that means an empty relation because parents themselves contain no
- * data.
- *
- * For the regular inheritance case, the parent also gets another RTE with
- * inh = false to represent it as an appendrel child.  The original RTE is
- * considered to represent the whole inheritance set.
- */
-static void
-expand_append_rtentry(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte,
-					  Index rti)
-{
-	Assert(rte->inh);
-	/* Inheritance parent (partitioned or not) or UNION ALL parent subquery. */
-	Assert(rte->rtekind == RTE_RELATION || rte->rtekind == RTE_SUBQUERY);
-
-	/*
-	 * UNION ALL children already got RTEs and AppendRelInfos, so just build
-	 * RelOptInfos and return.
-	 *
-	 * It might be a bit odd that this code is in this, because there is
-	 * nothing to expand really.
-	 */
-	if (rte->rtekind == RTE_SUBQUERY)
-	{
-		ListCell   *l;
-
-		/*
-		 * We don't need to use expand_planner_arrays in this case, because
-		 * no new child RTEs are created.  setup_simple_rel_arrays() and
-		 * setup_append_rel_array would've considered these child RTEs when
-		 * allocating space for various arrays.
-		 */
-		foreach(l, root->append_rel_list)
-		{
-			AppendRelInfo *appinfo = lfirst(l);
-			Index		childRTindex = appinfo->child_relid;
-
-			if (appinfo->parent_relid != rti)
-				continue;
-
-			Assert(childRTindex < root->simple_rel_array_size);
-			Assert(root->simple_rte_array[childRTindex] != NULL);
-
-			/*
-			 * We set the correct value of baserestricinfo and
-			 * baserestrict_min_security below.
-			 */
-			root->simple_rel_array[childRTindex] =
-				build_append_child_rel(root, rel, appinfo->child_relid);
-		}
-	}
-	else
-	{
-		Assert(rte->rtekind == RTE_RELATION);
-		Assert(has_subclass(rte->relid));
-
-		/*
-		 * The rewriter should already have obtained an appropriate lock on
-		 * each relation named in the query.  However, for each child relation
-		 * we add to the query, we must obtain an appropriate lock, because
-		 * this will be the first use of those relations in the
-		 * parse/rewrite/plan pipeline.  Child rels should use the same
-		 * lockmode as their parent.
-		 */
-		Assert(rte->rellockmode != NoLock);
-
-		if (rte->relkind == RELKIND_PARTITIONED_TABLE)
-			expand_partitioned_rtentry(root, rte, rti, rel);
-		else
-			expand_inherited_rtentry(root, rte, rti, rel);
-	}
-}
-
-/*
- * expand_inherited_rtentry
- *		Add entries for all the child tables to the query's rangetable, and
- *		build AppendRelInfo nodes for all the child tables and add them to
- *		root->append_rel_list.
- *
- * Note that the original RTE is considered to represent the whole
- * inheritance set.  The first of the generated RTEs is an RTE for the same
- * table, but with inh = false, to represent the parent table in its role
- * as a simple member of the inheritance set.
- *
- * A childless table is never considered to be an inheritance set. For
- * regular inheritance, a parent RTE must always have at least two associated
- * AppendRelInfos: one corresponding to the parent table as a simple member of
- * inheritance set and one or more corresponding to the actual children.
- */
-static void
-expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti,
-						 RelOptInfo *rel)
-{
-	Oid			parentOID;
-	PlanRowMark *oldrc;
-	LOCKMODE	lockmode = rte->rellockmode;
-	List	   *inhOIDs;
-	ListCell   *l;
-	int			num_children;
-	int			num_children_added = 0;
-
-	Assert(rte->rtekind == RTE_RELATION);
-	Assert(lockmode != NoLock);
-	parentOID = rte->relid;
-
-	/* Scan for all members of inheritance set, acquire needed locks */
-	inhOIDs = find_all_inheritors(parentOID, lockmode, NULL);
-
-	/*
-	 * Check that there's at least one descendant, else treat as no-child
-	 * case.  This could happen despite has_subclass() check performed by
-	 * subquery_planner, if table once had a child but no longer does.
-	 */
-	num_children = list_length(inhOIDs);
-	if (num_children < 2)
-	{
-		/* Clear flag before returning */
-		rte->inh = false;
-		return;
-	}
-
-	/*
-	 * If parent relation is selected FOR UPDATE/SHARE, preprocess_rowmarks
-	 * should've set isParent = true.  We'll generate a new PlanRowMark for
-	 * each child.
-	 */
-	oldrc = get_plan_rowmark(root->rowMarks, rti);
-	Assert(oldrc == NULL || oldrc->isParent);
-
-	/*
-	 * Must expand PlannerInfo arrays by num_children before we can add
-	 * children.
-	 */
-	expand_planner_arrays(root, num_children);
-
-	foreach(l, inhOIDs)
-	{
-		Oid			childOID = lfirst_oid(l);
-		Relation	newrelation;
-		RangeTblEntry *childrte;
-		Index		childRTindex;
-
-		/* Already locked above. */
-		newrelation = heap_open(childOID, NoLock);
-
-		/*
-		 * It is possible that the parent table has children that are temp
-		 * tables of other backends.  We cannot safely access such tables
-		 * (because of buffering issues), and the best thing to do seems
-		 * to be to silently ignore them.
-		 */
-		if (RELATION_IS_OTHER_TEMP(newrelation))
-		{
-			heap_close(newrelation, lockmode);
-			continue;
-		}
-
-		(void) add_inheritance_child_rel(root, rte, rti, rel, oldrc,
-										 newrelation, &childrte,
-										 &childRTindex);
-		Assert(childrte != NULL);
-		/* All regular inheritance children are leaf children. */
-		Assert(!childrte->inh);
-		Assert(childRTindex > 0);
-
-		/* Close child relations, but keep locks */
-		heap_close(newrelation, NoLock);
-		num_children_added++;
-	}
-
-	/*
-	 * If all children, including the parent (as child rel), were
-	 * excluded, mark the parent rel as empty.  If all the children were temp
-	 * tables, pretend it's a non-inheritance situation; we don't need Append
-	 * node in that case.  The duplicate RTE we added for the parent table is
-	 * harmless, so we don't bother to get rid of it; ditto for the useless
-	 * PlanRowMark node.
-	 */
-	if (num_children_added == 0)
-		mark_dummy_rel(rel);
-	else if (num_children_added == 1)
-		rte->inh = false;
-
-	/*
-	 * Add junk columns needed by the row mark if any and also add the
-	 * relevant expressions to the root parent's reltarget.
-	 */
-	if (oldrc)
-	{
-		List   *tlist = add_rowmark_junk_columns(root, oldrc);
-
-		build_base_rel_tlists(root, tlist);
-	}
-}
-
-/*
- * expand_partitioned_rtentry
- *		Prunes unnecessary partitions of a partitioned table and adds
- *		remaining ones to the Query and the PlannerInfo
- *
- * Partitions are added to the query in order in which they are found in
- * the parent's PartitionDesc.
- *
- * Note: even though only the unpruned partitions will be added to the
- * resulting plan, this still locks *all* partitions via find_all_inheritors
- * when this function is called for the root partitioned table.
- */
-static void
-expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
-						   Index parentRTindex, RelOptInfo *parentrel)
-{
-	LOCKMODE	lockmode = parentrte->rellockmode;
-	PlanRowMark *rootrc = NULL;
-	int			i;
-	Bitmapset  *partindexes;
-	Index		rootParentRTindex = parentrel->inh_root_parent > 0 ?
-									parentrel->inh_root_parent :
-									parentRTindex;
-
-	/* If root partitioned table, lock *all* partitions in the tree. */
-	if (parentRTindex == rootParentRTindex)
-		(void) find_all_inheritors(parentrte->relid, lockmode, NULL);
-
-	/*
-	 * Initialize partitioned_child_rels to contain this RT index.
-	 *
-	 * Note that during the set_append_rel_pathlist() phase, values of the
-	 * indexes of partitioned relations that appear down in the tree will be
-	 * bubbled up into root parent's list so that when we've created Paths for
-	 * all the children, the root table's list will contain all such indexes.
-	 */
-	parentrel->partitioned_child_rels = list_make1_int(parentRTindex);
-
-	/* Perform pruning. */
-	partindexes = prune_append_rel_partitions(parentrel);
-
-	/* Must expand PlannerInfo arrays before we can add children. */
-	expand_planner_arrays(root, bms_num_members(partindexes));
-
-	/*
-	 * For partitioned tables, we also store the partition RelOptInfo
-	 * pointers in the parent's RelOptInfo.
-	 */
-	parentrel->part_rels = (RelOptInfo **) palloc0(sizeof(RelOptInfo *) *
-												   parentrel->nparts);
-
-	rootrc = get_plan_rowmark(root->rowMarks, rootParentRTindex);
-	Assert(rootrc == NULL || rootrc->isParent);
-	i = -1;
-	while ((i = bms_next_member(partindexes, i)) >= 0)
-	{
-		Oid		childOID = parentrel->part_oids[i];
-		Relation	newrelation;
-		RelOptInfo *childrel;
-		RangeTblEntry *childrte;
-		Index		childRTindex;
-
-		/* Already locked above. */
-		newrelation = heap_open(childOID, NoLock);
-		Assert(!RELATION_IS_OTHER_TEMP(newrelation));
-
-		/*
-		 * A partitioned child table with 0 children is a dummy rel, so don't
-		 * bother creating planner objects for it.
-		 */
-		if (newrelation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE &&
-			RelationGetPartitionDesc(newrelation)->nparts == 0)
-		{
-			heap_close(newrelation, NoLock);
-			continue;
-		}
-
-		childrel = add_inheritance_child_rel(root, parentrte, parentRTindex,
-											 parentrel, rootrc, newrelation,
-											 &childrte, &childRTindex);
-		Assert(childrel != NULL);
-		parentrel->part_rels[i] = childrel;
-
-		/* Close child relations, but keep locks */
-		heap_close(newrelation, NoLock);
-
-		/* If the child is partitioned itself, expand it too. */
-		if (childrel->part_scheme)
-		{
-			Assert(childrte->inh);
-			expand_partitioned_rtentry(root, childrte, childRTindex,
-									   childrel);
-		}
-	}
-
-	/*
-	 * Add junk columns needed by the row mark if any and also add the
-	 * relevant expressions to the root parent's reltarget.
-	 */
-	if (rootrc)
-	{
-		List   *tlist = add_rowmark_junk_columns(root, rootrc);
-
-		build_base_rel_tlists(root, tlist);
-	}
-}
-
-/*
- * add_inheritance_child_rel
- *		Build a RangeTblEntry, an AppendRelInfo, a PlanRowMark, and finally
- *		a RelOptInfo for an inheritance child relation.
- *
- * The return value is the RelOptInfo that's added.
- *
- * PlanRowMarks still carry the top-parent's RTI, and the top-parent's
- * allMarkTypes field still accumulates values from all descendents.
- *
- * "parentrte" and "parentRTindex" are immediate parent's RTE and
- * RTI. "top_parentrc" is top parent's PlanRowMark.
- */
-static RelOptInfo *
-add_inheritance_child_rel(PlannerInfo *root, RangeTblEntry *parentrte,
-						  Index parentRTindex, RelOptInfo *parentrel,
-						  PlanRowMark *top_parentrc, Relation childrel,
-						  RangeTblEntry **childrte_p, Index *childRTindex_p)
-{
-	Query	   *parse = root->parse;
-	Oid			childOID = RelationGetRelid(childrel);
-	RangeTblEntry *childrte;
-	Index		childRTindex;
-	AppendRelInfo *appinfo;
-	RelOptInfo *childrelopt;
-
-	/*
-	 * Build an RTE for the child, and attach to query's rangetable list. We
-	 * copy most fields of the parent's RTE, but replace relation OID and
-	 * relkind, and set inh appropriately.  Also, set requiredPerms to zero
-	 * since all required permissions checks are done on the original RTE.
-	 * Likewise, set the child's securityQuals to empty, because we only want
-	 * to apply the parent's RLS conditions regardless of what RLS properties
-	 * individual children may have.  (This is an intentional choice to make
-	 * inherited RLS work like regular permissions checks.) The parent
-	 * securityQuals will be propagated to children along with other base
-	 * restriction clauses, so we don't need to do it here.
-	 */
-	childrte = copyObject(parentrte);
-	*childrte_p = childrte;
-	childrte->relid = childOID;
-	childrte->relkind = childrel->rd_rel->relkind;
-	/*
-	 * A partitioned child will need to be expanded as an append parent
-	 * itself, so set its inh to true.
-	 */
-	childrte->inh = (childrte->relkind == RELKIND_PARTITIONED_TABLE);
-	childrte->requiredPerms = 0;
-	childrte->securityQuals = NIL;
-	parse->rtable = lappend(parse->rtable, childrte);
-	childRTindex = list_length(parse->rtable);
-	*childRTindex_p = childRTindex;
-
-	/* Create an AppendRelInfo and add it to planner's global list. */
-	appinfo = make_append_rel_info(parentrel, parentrte,
-								   childrel->rd_att,
-								   childOID,
-								   childrel->rd_rel->reltype,
-								   childRTindex);
-	root->append_rel_list = lappend(root->append_rel_list, appinfo);
-
-	/*
-	 * Translate the column permissions bitmaps to the child's attnums (we
-	 * have to build the translated_vars list before we can do this). But
-	 * if this is the parent table, leave copyObject's result alone.
-	 *
-	 * Note: we need to do this even though the executor won't run any
-	 * permissions checks on the child RTE.  The insertedCols/updatedCols
-	 * bitmaps may be examined for trigger-firing purposes.
-	 */
-	if (childrte->relid != parentrte->relid)
-	{
-		childrte->selectedCols = translate_col_privs(parentrte->selectedCols,
-													 appinfo->translated_vars);
-		childrte->insertedCols = translate_col_privs(parentrte->insertedCols,
-													 appinfo->translated_vars);
-		childrte->updatedCols = translate_col_privs(parentrte->updatedCols,
-													appinfo->translated_vars);
-	}
-
-	/*
-	 * Build a PlanRowMark if parent is marked FOR UPDATE/SHARE.
-	 */
-	if (top_parentrc)
-	{
-		PlanRowMark *childrc = makeNode(PlanRowMark);
-
-		childrc->rti = childRTindex;
-		childrc->prti = top_parentrc->rti;
-		childrc->rowmarkId = top_parentrc->rowmarkId;
-		/* Reselect rowmark type, because relkind might not match parent */
-		childrc->markType = select_rowmark_type(childrte,
-												top_parentrc->strength);
-		childrc->allMarkTypes = (1 << childrc->markType);
-		childrc->strength = top_parentrc->strength;
-		childrc->waitPolicy = top_parentrc->waitPolicy;
-
-		/*
-		 * We mark RowMarks for partitioned child tables as parent RowMarks so
-		 * that the executor ignores them (except their existence means that
-		 * the child tables be locked using appropriate mode).
-		 */
-		childrc->isParent = (childrte->relkind == RELKIND_PARTITIONED_TABLE);
-
-		/* Include child's rowmark type in top parent's allMarkTypes */
-		top_parentrc->allMarkTypes |= childrc->allMarkTypes;
-
-		root->rowMarks = lappend(root->rowMarks, childrc);
-	}
-
-	/*
-	 * Add the RelOptInfo.  Even though we may not really scan this relation
-	 * for reasons such as contradictory quals, we still need to create one,
-	 * because for every RTE in the query's range table, there must be an
-	 * accompanying RelOptInfo.
-	 */
-
-	/* First, store the RTE and appinfos into planner arrays. */
-	Assert(root->simple_rte_array[childRTindex] == NULL);
-	root->simple_rte_array[childRTindex] = childrte;
-	Assert(root->append_rel_array[childRTindex] == NULL);
-	root->append_rel_array[childRTindex] = appinfo;
-
-	childrelopt = build_append_child_rel(root, parentrel, childRTindex);
-	Assert(childrelopt != NULL);
-
-	return childrelopt;
-}
-
-/*
- * make_inh_translation_list
- *	  Build the list of translations from parent Vars to child Vars for
- *	  an inheritance child.
- *
- * For paranoia's sake, we match type/collation as well as attribute name.
- */
-static void
-make_inh_translation_list(TupleDesc old_tupdesc, TupleDesc new_tupdesc,
-						  Oid from_rel, Oid to_rel,
-						  Index newvarno, List **translated_vars)
-{
-	List	   *vars = NIL;
-	int			oldnatts = old_tupdesc->natts;
-	int			newnatts = new_tupdesc->natts;
-	int			old_attno;
-	int			new_attno = 0;
-
-	for (old_attno = 0; old_attno < oldnatts; old_attno++)
-	{
-		Form_pg_attribute att;
-		char	   *attname;
-		Oid			atttypid;
-		int32		atttypmod;
-		Oid			attcollation;
-
-		att = TupleDescAttr(old_tupdesc, old_attno);
-		if (att->attisdropped)
-		{
-			/* Just put NULL into this list entry */
-			vars = lappend(vars, NULL);
-			continue;
-		}
-		attname = NameStr(att->attname);
-		atttypid = att->atttypid;
-		atttypmod = att->atttypmod;
-		attcollation = att->attcollation;
-
-		/*
-		 * When we are generating the "translation list" for the parent table
-		 * of an inheritance set, no need to search for matches.
-		 */
-		if (from_rel == to_rel)
-		{
-			vars = lappend(vars, makeVar(newvarno,
-										 (AttrNumber) (old_attno + 1),
-										 atttypid,
-										 atttypmod,
-										 attcollation,
-										 0));
-			continue;
-		}
-
-		/*
-		 * Otherwise we have to search for the matching column by name.
-		 * There's no guarantee it'll have the same column position, because
-		 * of cases like ALTER TABLE ADD COLUMN and multiple inheritance.
-		 * However, in simple cases, the relative order of columns is mostly
-		 * the same in both relations, so try the column of newrelation that
-		 * follows immediately after the one that we just found, and if that
-		 * fails, let syscache handle it.
-		 */
-		if (new_attno >= newnatts ||
-			(att = TupleDescAttr(new_tupdesc, new_attno))->attisdropped ||
-			strcmp(attname, NameStr(att->attname)) != 0)
-		{
-			HeapTuple	newtup;
-
-			newtup = SearchSysCacheAttName(to_rel, attname);
-			if (!newtup)
-				elog(ERROR, "could not find inherited attribute \"%s\" of relation \"%s\"",
-					 attname, get_rel_name(to_rel));
-			new_attno = ((Form_pg_attribute) GETSTRUCT(newtup))->attnum - 1;
-			ReleaseSysCache(newtup);
-
-			att = TupleDescAttr(new_tupdesc, new_attno);
-		}
-
-		/* Found it, check type and collation match */
-		if (atttypid != att->atttypid || atttypmod != att->atttypmod)
-			elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's type",
-				 attname, get_rel_name(to_rel));
-		if (attcollation != att->attcollation)
-			elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's collation",
-				 attname, get_rel_name(to_rel));
-
-		vars = lappend(vars, makeVar(newvarno,
-									 (AttrNumber) (new_attno + 1),
-									 atttypid,
-									 atttypmod,
-									 attcollation,
-									 0));
-		new_attno++;
-	}
-
-	*translated_vars = vars;
-}
-
-/*
- * translate_col_privs
- *	  Translate a bitmapset representing per-column privileges from the
- *	  parent rel's attribute numbering to the child's.
- *
- * The only surprise here is that we don't translate a parent whole-row
- * reference into a child whole-row reference.  That would mean requiring
- * permissions on all child columns, which is overly strict, since the
- * query is really only going to reference the inherited columns.  Instead
- * we set the per-column bits for all inherited columns.
- */
-static Bitmapset *
-translate_col_privs(const Bitmapset *parent_privs,
-					List *translated_vars)
-{
-	Bitmapset  *child_privs = NULL;
-	bool		whole_row;
-	int			attno;
-	ListCell   *lc;
-
-	/* System attributes have the same numbers in all tables */
-	for (attno = FirstLowInvalidHeapAttributeNumber + 1; attno < 0; attno++)
-	{
-		if (bms_is_member(attno - FirstLowInvalidHeapAttributeNumber,
-						  parent_privs))
-			child_privs = bms_add_member(child_privs,
-										 attno - FirstLowInvalidHeapAttributeNumber);
-	}
-
-	/* Check if parent has whole-row reference */
-	whole_row = bms_is_member(InvalidAttrNumber - FirstLowInvalidHeapAttributeNumber,
-							  parent_privs);
-
-	/* And now translate the regular user attributes, using the vars list */
-	attno = InvalidAttrNumber;
-	foreach(lc, translated_vars)
-	{
-		Var		   *var = lfirst_node(Var, lc);
-
-		attno++;
-		if (var == NULL)		/* ignore dropped columns */
-			continue;
-		if (whole_row ||
-			bms_is_member(attno - FirstLowInvalidHeapAttributeNumber,
-						  parent_privs))
-			child_privs = bms_add_member(child_privs,
-										 var->varattno - FirstLowInvalidHeapAttributeNumber);
-	}
-
-	return child_privs;
-}
-
-/*
- *	build_append_child_rel
- *		Build a RelOptInfo for child relation of an append rel
- *
- * After creating the RelOptInfo for the given child RT index, it goes on to
- * initialize some of its fields based on the parent RelOptInfo.
- *
- * If the quals in baserestrictinfo turn out to be self-contradictory,
- * RelOptInfo is marked dummy before returning.
- */
-static RelOptInfo *
-build_append_child_rel(PlannerInfo *root,
-					   RelOptInfo *parent,
-					   Index childRTindex)
-{
-	RelOptInfo *childrel;
-	RangeTblEntry *childRTE = root->simple_rte_array[childRTindex];
-	AppendRelInfo *appinfo = root->append_rel_array[childRTindex];
-	List	   *childquals;
-	ListCell   *lc;
-	bool		have_const_false_cq;
-	Index		cq_min_security;
-
-	/* Build the RelOptInfo. */
-	childrel = build_simple_rel(root, childRTindex, parent);
-
-	/*
-	 * Propagate lateral_relids and lateral_referencers from appendrel
-	 * parent rels to their child rels.  We intentionally give each child rel
-	 * the same minimum parameterization, even though it's quite possible that
-	 * some don't reference all the lateral rels.  This is because any append
-	 * path for the parent will have to have the same parameterization for
-	 * every child anyway, and there's no value in forcing extra
-	 * reparameterize_path() calls.  Similarly, a lateral reference to the
-	 * parent prevents use of otherwise-movable join rels for each child.
-	 */
-	childrel->direct_lateral_relids = parent->direct_lateral_relids;
-	childrel->lateral_relids = parent->lateral_relids;
-	childrel->lateral_referencers = parent->lateral_referencers;
-
-	/*
-	 * We have to copy the parent's quals to the child, with appropriate
-	 * substitution of variables.  However, only the baserestrictinfo
-	 * quals are needed before we can check for constraint exclusion; so
-	 * do that first and then check to see if we can disregard this child.
-	 *
-	 * The child rel's targetlist might contain non-Var expressions, which
-	 * means that substitution into the quals could produce opportunities
-	 * for const-simplification, and perhaps even pseudoconstant quals.
-	 * Therefore, transform each RestrictInfo separately to see if it
-	 * reduces to a constant or pseudoconstant.  (We must process them
-	 * separately to keep track of the security level of each qual.)
-	 */
-	childquals = false;
-	cq_min_security = UINT_MAX;
-	have_const_false_cq = false;
-	foreach(lc, parent->baserestrictinfo)
-	{
-		RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
-		Node	   *childqual = (Node *) rinfo->clause;
-		ListCell   *lc2;
-
-		Assert(IsA(rinfo, RestrictInfo));
-		childqual = adjust_appendrel_attrs(root, childqual,
-										   1, &appinfo);
-		childqual = eval_const_expressions(root, childqual);
-		/* check for flat-out constant */
-		if (childqual && IsA(childqual, Const))
-		{
-			if (((Const *) childqual)->constisnull ||
-				!DatumGetBool(((Const *) childqual)->constvalue))
-			{
-				/* Restriction reduces to constant FALSE or NULL */
-				have_const_false_cq = true;
-				break;
-			}
-			/* Restriction reduces to constant TRUE, so drop it */
-			continue;
-		}
-		/* might have gotten an AND clause, if so flatten it */
-		foreach(lc2, make_ands_implicit((Expr *) childqual))
-		{
-			Node	   *onecq = (Node *) lfirst(lc2);
-			bool		pseudoconstant;
-
-			/* check for pseudoconstant (no Vars or volatile functions) */
-			pseudoconstant =
-					!contain_vars_of_level(onecq, 0) &&
-					!contain_volatile_functions(onecq);
-			if (pseudoconstant)
-			{
-				/* tell createplan.c to check for gating quals */
-				root->hasPseudoConstantQuals = true;
-			}
-			/* reconstitute RestrictInfo with appropriate properties */
-			childquals = lappend(childquals,
-								 make_restrictinfo((Expr *) onecq,
-												   rinfo->is_pushed_down,
-												   rinfo->outerjoin_delayed,
-												   pseudoconstant,
-												   rinfo->security_level,
-												   NULL, NULL, NULL));
-			cq_min_security = Min(cq_min_security, rinfo->security_level);
-		}
-	}
-
-	/*
-	 * In addition to the quals inherited from the parent, we might
-	 * have securityQuals associated with this particular child node.
-	 * (Currently this can only happen in appendrels originating from
-	 * UNION ALL; inheritance child tables don't have their own
-	 * securityQuals.)	Pull any such securityQuals up into the
-	 * baserestrictinfo for the child.  This is similar to
-	 * process_security_barrier_quals() for the parent rel, except
-	 * that we can't make any general deductions from such quals,
-	 * since they don't hold for the whole appendrel.
-	 */
-	if (childRTE->securityQuals)
-	{
-		Index		security_level = 0;
-
-		foreach(lc, childRTE->securityQuals)
-		{
-			List	   *qualset = (List *) lfirst(lc);
-			ListCell   *lc2;
-
-			foreach(lc2, qualset)
-			{
-				Expr	   *qual = (Expr *) lfirst(lc2);
-
-				/*
-				 * not likely that we'd see constants here, so no
-				 * check
-				 */
-				childquals = lappend(childquals,
-									 make_restrictinfo(qual,
-													   true,
-													   false,
-													   false,
-													   security_level,
-													   NULL, NULL,
-													   NULL));
-				cq_min_security = Min(cq_min_security, security_level);
-			}
-			security_level++;
-		}
-		Assert(security_level <= root->qual_security_level);
-	}
-
-	/* Set child's version of baserestrictinfo. */
-	childrel->baserestrictinfo = childquals;
-	childrel->baserestrict_min_security = cq_min_security;
-
-	if (have_const_false_cq)
-	{
-		/*
-		 * Some restriction clause reduced to constant FALSE or NULL after
-		 * substitution, so this child need not be scanned.
-		 */
-		set_dummy_rel_pathlist(childrel);
-	}
-
-	return childrel;
-}
-
-/*
- * add_rowmark_junk_columns
- * 		Add necessary junk columns for rowmarked inheritance parent rel.
- *
- * These values are needed for locking of rels selected FOR UPDATE/SHARE, and
- * to do EvalPlanQual rechecking.  See comments for PlanRowMark in
- * plannodes.h.
- */
-static List *
-add_rowmark_junk_columns(PlannerInfo *root, PlanRowMark *rc)
-{
-	List   *tlist = root->processed_tlist;
-	Var		   *var;
-	char		resname[32];
-	TargetEntry *tle;
-
-	if (rc->allMarkTypes & ~(1 << ROW_MARK_COPY))
-	{
-		/* Need to fetch TID */
-		var = makeVar(rc->rti,
-					  SelfItemPointerAttributeNumber,
-					  TIDOID,
-					  -1,
-					  InvalidOid,
-					  0);
-		snprintf(resname, sizeof(resname), "ctid%u", rc->rowmarkId);
-		tle = makeTargetEntry((Expr *) var,
-							  list_length(tlist) + 1,
-							  pstrdup(resname),
-							  true);
-		tlist = lappend(tlist, tle);
-	}
-	if (rc->allMarkTypes & (1 << ROW_MARK_COPY))
-	{
-		/* Need the whole row as a junk var */
-		var = makeWholeRowVar(root->simple_rte_array[rc->rti],
-							  rc->rti,
-							  0,
-							  false);
-		snprintf(resname, sizeof(resname), "wholerow%u", rc->rowmarkId);
-		tle = makeTargetEntry((Expr *) var,
-							  list_length(tlist) + 1,
-							  pstrdup(resname),
-							  true);
-		tlist = lappend(tlist, tle);
-	}
-
-	/* For inheritance cases, always fetch the tableoid too. */
-	var = makeVar(rc->rti,
-				  TableOidAttributeNumber,
-				  OIDOID,
-				  -1,
-				  InvalidOid,
-				  0);
-	snprintf(resname, sizeof(resname), "tableoid%u", rc->rowmarkId);
-	tle = makeTargetEntry((Expr *) var,
-						  list_length(tlist) + 1,
-						  pstrdup(resname),
-						  true);
-	tlist = lappend(tlist, tle);
-
-	return tlist;
-}
-
-AppendRelInfo *
-make_append_rel_info(RelOptInfo *parentrel, RangeTblEntry *parentrte,
-					 TupleDesc childdesc, Oid childoid, Oid childreltype,
-					 Index childRTindex)
-{
-	AppendRelInfo  *appinfo = makeNode(AppendRelInfo);
-
-	appinfo->parent_relid = parentrel->relid;
-	appinfo->child_relid = childRTindex;
-	appinfo->parent_reltype = parentrel->reltype;
-	appinfo->child_reltype = childreltype;
-	make_inh_translation_list(parentrel->tupdesc, childdesc,
-							  parentrte->relid, childoid,
-							  childRTindex,
-							  &appinfo->translated_vars);
-	appinfo->parent_reloid = parentrte->relid;
-
-	return appinfo;
-}
-
-/*
- * adjust_appendrel_attrs
- *	  Copy the specified query or expression and translate Vars referring to a
- *	  parent rel to refer to the corresponding child rel instead.  We also
- *	  update rtindexes appearing outside Vars, such as resultRelation and
- *	  jointree relids.
- *
- * Note: this is only applied after conversion of sublinks to subplans,
- * so we don't need to cope with recursion into sub-queries.
- *
- * Note: this is not hugely different from what pullup_replace_vars() does;
- * maybe we should try to fold the two routines together.
- */
-Node *
-adjust_appendrel_attrs(PlannerInfo *root, Node *node, int nappinfos,
-					   AppendRelInfo **appinfos)
-{
-	Node	   *result;
-	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);
-
-	/*
-	 * Must be prepared to start with a Query or a bare expression tree.
-	 */
-	if (node && IsA(node, Query))
-	{
-		Query	   *newnode;
-		int			cnt;
-
-		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;
-}
-
-static Node *
-adjust_appendrel_attrs_mutator(Node *node,
-							   adjust_appendrel_attrs_context *context)
-{
-	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;
-
-		for (cnt = 0; cnt < nappinfos; cnt++)
-		{
-			if (var->varno == appinfos[cnt]->parent_relid)
-			{
-				appinfo = appinfos[cnt];
-				break;
-			}
-		}
-
-		if (var->varlevelsup == 0 && appinfo)
-		{
-			var->varno = appinfo->child_relid;
-			var->varnoold = appinfo->child_relid;
-			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));
-				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;
-
-					return (Node *) rowexpr;
-				}
-			}
-			/* system attributes don't need any other translation */
-		}
-		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, 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 */
-		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, context->nappinfos,
-											  context->appinfos);
-		return (Node *) phv;
-	}
-
-	/*
-	 * This is needed, because inheritance_make_rel_from_joinlist needs to
-	 * translate root->join_info_list executing make_rel_from_joinlist for a
-	 * given child.
-	 */
-	if (IsA(node, SpecialJoinInfo))
-	{
-		SpecialJoinInfo *oldinfo = (SpecialJoinInfo *) node;
-		SpecialJoinInfo *newinfo = makeNode(SpecialJoinInfo);
-
-		memcpy(newinfo, oldinfo, sizeof(SpecialJoinInfo));
-		newinfo->min_lefthand = adjust_child_relids(oldinfo->min_lefthand,
-													context->nappinfos,
-													context->appinfos);
-		newinfo->min_righthand = adjust_child_relids(oldinfo->min_righthand,
-													 context->nappinfos,
-													 context->appinfos);
-		newinfo->syn_lefthand = adjust_child_relids(oldinfo->syn_lefthand,
-													context->nappinfos,
-													context->appinfos);
-		newinfo->syn_righthand = adjust_child_relids(oldinfo->syn_righthand,
-													 context->nappinfos,
-													 context->appinfos);
-		newinfo->semi_rhs_exprs =
-					(List *) expression_tree_mutator((Node *)
-													 oldinfo->semi_rhs_exprs,
-													 adjust_appendrel_attrs_mutator,
-													 (void *) context);
-		return (Node *) newinfo;
-	}
-
-	/* Shouldn't need to handle planner auxiliary nodes here */
-	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 */
-		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->nullable_relids = adjust_child_relids(oldinfo->nullable_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));
-
-	return expression_tree_mutator(node, adjust_appendrel_attrs_mutator,
-								   (void *) context);
-}
-
-/*
- * Substitute child relids for parent relids in a Relid set.  The array of
- * appinfos specifies the substitutions to be performed.
- */
-static Relids
-adjust_child_relids(Relids relids, int nappinfos, AppendRelInfo **appinfos)
-{
-	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;
-}
-
-/*
- * Replace any relid present in top_parent_relids with its child in
- * child_relids. Members of child_relids can be multiple levels below top
- * parent in the partition hierarchy.
- */
-Relids
-adjust_child_relids_multilevel(PlannerInfo *root, Relids relids,
-							   Relids child_relids, Relids top_parent_relids)
-{
-	AppendRelInfo **appinfos;
-	int			nappinfos;
-	Relids		parent_relids = NULL;
-	Relids		result;
-	Relids		tmp_result = NULL;
-	int			cnt;
-
-	/*
-	 * If the given relids set doesn't contain any of the top parent relids,
-	 * it will remain unchanged.
-	 */
-	if (!bms_overlap(relids, top_parent_relids))
-		return relids;
-
-	appinfos = find_appinfos_by_relids(root, child_relids, &nappinfos);
-
-	/* Construct relids set for the immediate parent of the given child. */
-	for (cnt = 0; cnt < nappinfos; cnt++)
-	{
-		AppendRelInfo *appinfo = appinfos[cnt];
-
-		parent_relids = bms_add_member(parent_relids, appinfo->parent_relid);
-	}
-
-	/* Recurse if immediate parent is not the top parent. */
-	if (!bms_equal(parent_relids, top_parent_relids))
-	{
-		tmp_result = adjust_child_relids_multilevel(root, relids,
-													parent_relids,
-													top_parent_relids);
-		relids = tmp_result;
-	}
-
-	result = adjust_child_relids(relids, nappinfos, appinfos);
-
-	/* Free memory consumed by any intermediate result. */
-	if (tmp_result)
-		bms_free(tmp_result);
-	bms_free(parent_relids);
-	pfree(appinfos);
-
-	return result;
-}
-
-/*
- * 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.
- */
-static List *
-adjust_inherited_tlist(List *tlist, AppendRelInfo *context)
-{
-	bool		changed_it = false;
-	ListCell   *tl;
-	List	   *new_tlist;
-	bool		more;
-	int			attrno;
-
-	/* 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)
-	{
-		TargetEntry *tle = (TargetEntry *) lfirst(tl);
-		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))
-			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);
-		if (childvar == NULL || !IsA(childvar, Var))
-			elog(ERROR, "attribute %d of relation \"%s\" does not exist",
-				 tle->resno, get_rel_name(context->parent_reloid));
-
-		if (tle->resno != childvar->varattno)
-		{
-			tle->resno = childvar->varattno;
-			changed_it = true;
-		}
-	}
-
-	/*
-	 * 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;
-
-	new_tlist = NIL;
-	more = true;
-	for (attrno = 1; more; attrno++)
-	{
-		more = false;
-		foreach(tl, tlist)
-		{
-			TargetEntry *tle = (TargetEntry *) lfirst(tl);
-
-			if (tle->resjunk)
-				continue;		/* ignore junk items */
-
-			if (tle->resno == attrno)
-				new_tlist = lappend(new_tlist, tle);
-			else if (tle->resno > attrno)
-				more = true;
-		}
-	}
-
-	foreach(tl, tlist)
-	{
-		TargetEntry *tle = (TargetEntry *) lfirst(tl);
-
-		if (!tle->resjunk)
-			continue;			/* here, ignore non-junk items */
-
-		tle->resno = attrno;
-		new_tlist = lappend(new_tlist, tle);
-		attrno++;
-	}
-
-	return new_tlist;
-}
-
-/*
- * adjust_appendrel_attrs_multilevel
- *	  Apply Var translations from a toplevel appendrel parent down to a child.
- *
- * In some cases we need to translate expressions referencing a parent relation
- * to reference an appendrel child that's multiple levels removed from it.
- */
-Node *
-adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node,
-								  Relids child_relids,
-								  Relids top_parent_relids)
-{
-	AppendRelInfo **appinfos;
-	Bitmapset  *parent_relids = NULL;
-	int			nappinfos;
-	int			cnt;
-
-	Assert(bms_num_members(child_relids) == bms_num_members(top_parent_relids));
-
-	appinfos = find_appinfos_by_relids(root, child_relids, &nappinfos);
-
-	/* Construct relids set for the immediate parent of given child. */
-	for (cnt = 0; cnt < nappinfos; cnt++)
-	{
-		AppendRelInfo *appinfo = appinfos[cnt];
-
-		parent_relids = bms_add_member(parent_relids, appinfo->parent_relid);
-	}
-
-	/* Recurse if immediate parent is not the top parent. */
-	if (!bms_equal(parent_relids, top_parent_relids))
-		node = adjust_appendrel_attrs_multilevel(root, node, parent_relids,
-												 top_parent_relids);
-
-	/* Now translate for this child */
-	node = adjust_appendrel_attrs(root, node, nappinfos, appinfos);
-
-	pfree(appinfos);
-
-	return node;
-}
-
-/*
- * Construct the SpecialJoinInfo for a child-join by translating
- * SpecialJoinInfo for the join between parents. left_relids and right_relids
- * are the relids of left and right side of the join respectively.
- */
-SpecialJoinInfo *
-build_child_join_sjinfo(PlannerInfo *root, SpecialJoinInfo *parent_sjinfo,
-						Relids left_relids, Relids right_relids)
-{
-	SpecialJoinInfo *sjinfo = makeNode(SpecialJoinInfo);
-	AppendRelInfo **left_appinfos;
-	int			left_nappinfos;
-	AppendRelInfo **right_appinfos;
-	int			right_nappinfos;
-
-	memcpy(sjinfo, parent_sjinfo, sizeof(SpecialJoinInfo));
-	left_appinfos = find_appinfos_by_relids(root, left_relids,
-											&left_nappinfos);
-	right_appinfos = find_appinfos_by_relids(root, right_relids,
-											 &right_nappinfos);
-
-	sjinfo->min_lefthand = adjust_child_relids(sjinfo->min_lefthand,
-											   left_nappinfos, left_appinfos);
-	sjinfo->min_righthand = adjust_child_relids(sjinfo->min_righthand,
-												right_nappinfos,
-												right_appinfos);
-	sjinfo->syn_lefthand = adjust_child_relids(sjinfo->syn_lefthand,
-											   left_nappinfos, left_appinfos);
-	sjinfo->syn_righthand = adjust_child_relids(sjinfo->syn_righthand,
-												right_nappinfos,
-												right_appinfos);
-	sjinfo->semi_rhs_exprs = (List *) adjust_appendrel_attrs(root,
-															 (Node *) sjinfo->semi_rhs_exprs,
-															 right_nappinfos,
-															 right_appinfos);
-
-	pfree(left_appinfos);
-	pfree(right_appinfos);
-
-	return sjinfo;
-}
-
-/*
- * find_appinfos_by_relids
- * 		Find AppendRelInfo structures for all relations specified by relids.
- *
- * The AppendRelInfos are returned in an array, which can be pfree'd by the
- * caller. *nappinfos is set to the number of entries in the array.
- */
-AppendRelInfo **
-find_appinfos_by_relids(PlannerInfo *root, Relids relids, int *nappinfos)
-{
-	AppendRelInfo **appinfos;
-	int			cnt = 0;
-	int			i;
-
-	*nappinfos = bms_num_members(relids);
-	appinfos = (AppendRelInfo **) palloc(sizeof(AppendRelInfo *) * *nappinfos);
-
-	i = -1;
-	while ((i = bms_next_member(relids, i)) >= 0)
-	{
-		AppendRelInfo *appinfo = root->append_rel_array[i];
-
-		if (!appinfo)
-			elog(ERROR, "child rel %d not found in append_rel_array", i);
-
-		appinfos[cnt++] = appinfo;
-	}
-	return appinfos;
-}
diff --git a/src/backend/optimizer/util/Makefile b/src/backend/optimizer/util/Makefile
index da9ccf32b4..8a5e2ad1bd 100644
--- a/src/backend/optimizer/util/Makefile
+++ b/src/backend/optimizer/util/Makefile
@@ -12,7 +12,8 @@ subdir = src/backend/optimizer/util
 top_builddir = ../../../..
 include $(top_builddir)/src/Makefile.global
 
-OBJS = clauses.o joininfo.o orclauses.o pathnode.o placeholder.o \
-	   plancat.o predtest.o relnode.o restrictinfo.o tlist.o var.o
+OBJS = appendinfo.o clauses.o inherit.o joininfo.o orclauses.o pathnode.o \
+	   placeholder.o plancat.o predtest.o relnode.o restrictinfo.o tlist.o \
+	   var.o
 
 include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/optimizer/util/appendinfo.c b/src/backend/optimizer/util/appendinfo.c
new file mode 100644
index 0000000000..7d3937b3ce
--- /dev/null
+++ b/src/backend/optimizer/util/appendinfo.c
@@ -0,0 +1,851 @@
+/*-------------------------------------------------------------------------
+ *
+ * appendinfo.c
+ *	  Routines for mapping between append parent(s) and children
+ *
+ * Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/optimizer/path/appendinfo.c
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include "access/htup_details.h"
+#include "access/sysattr.h"
+#include "nodes/makefuncs.h"
+#include "nodes/nodeFuncs.h"
+#include "optimizer/appendinfo.h"
+#include "parser/parsetree.h"
+#include "utils/rel.h"
+#include "utils/lsyscache.h"
+#include "utils/syscache.h"
+
+typedef struct
+{
+	PlannerInfo *root;
+	int			nappinfos;
+	AppendRelInfo **appinfos;
+} adjust_appendrel_attrs_context;
+
+static void make_inh_translation_list(TupleDesc old_tupdesc,
+						  TupleDesc new_tupdesc,
+						  Oid from_rel, Oid to_rel,
+						  Index newvarno, List **translated_vars);
+static Node *adjust_appendrel_attrs_mutator(Node *node,
+							   adjust_appendrel_attrs_context *context);
+static Relids adjust_child_relids(Relids relids, int nappinfos,
+					AppendRelInfo **appinfos);
+static List *adjust_inherited_tlist(List *tlist,
+					   AppendRelInfo *context);
+
+AppendRelInfo *
+make_append_rel_info(RelOptInfo *parentrel, RangeTblEntry *parentrte,
+					 TupleDesc childdesc, Oid childoid, Oid childreltype,
+					 Index childRTindex)
+{
+	AppendRelInfo  *appinfo = makeNode(AppendRelInfo);
+
+	appinfo->parent_relid = parentrel->relid;
+	appinfo->child_relid = childRTindex;
+	appinfo->parent_reltype = parentrel->reltype;
+	appinfo->child_reltype = childreltype;
+	make_inh_translation_list(parentrel->tupdesc, childdesc,
+							  parentrte->relid, childoid,
+							  childRTindex,
+							  &appinfo->translated_vars);
+	appinfo->parent_reloid = parentrte->relid;
+
+	return appinfo;
+}
+
+/*
+ * adjust_appendrel_attrs
+ *	  Copy the specified query or expression and translate Vars referring to a
+ *	  parent rel to refer to the corresponding child rel instead.  We also
+ *	  update rtindexes appearing outside Vars, such as resultRelation and
+ *	  jointree relids.
+ *
+ * Note: this is only applied after conversion of sublinks to subplans,
+ * so we don't need to cope with recursion into sub-queries.
+ *
+ * Note: this is not hugely different from what pullup_replace_vars() does;
+ * maybe we should try to fold the two routines together.
+ */
+Node *
+adjust_appendrel_attrs(PlannerInfo *root, Node *node, int nappinfos,
+					   AppendRelInfo **appinfos)
+{
+	Node	   *result;
+	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);
+
+	/*
+	 * Must be prepared to start with a Query or a bare expression tree.
+	 */
+	if (node && IsA(node, Query))
+	{
+		Query	   *newnode;
+		int			cnt;
+
+		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;
+}
+
+static Node *
+adjust_appendrel_attrs_mutator(Node *node,
+							   adjust_appendrel_attrs_context *context)
+{
+	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;
+
+		for (cnt = 0; cnt < nappinfos; cnt++)
+		{
+			if (var->varno == appinfos[cnt]->parent_relid)
+			{
+				appinfo = appinfos[cnt];
+				break;
+			}
+		}
+
+		if (var->varlevelsup == 0 && appinfo)
+		{
+			var->varno = appinfo->child_relid;
+			var->varnoold = appinfo->child_relid;
+			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));
+				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;
+
+					return (Node *) rowexpr;
+				}
+			}
+			/* system attributes don't need any other translation */
+		}
+		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, 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 */
+		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, context->nappinfos,
+											  context->appinfos);
+		return (Node *) phv;
+	}
+
+	/*
+	 * This is needed, because inheritance_make_rel_from_joinlist needs to
+	 * translate root->join_info_list executing make_rel_from_joinlist for a
+	 * given child.
+	 */
+	if (IsA(node, SpecialJoinInfo))
+	{
+		SpecialJoinInfo *oldinfo = (SpecialJoinInfo *) node;
+		SpecialJoinInfo *newinfo = makeNode(SpecialJoinInfo);
+
+		memcpy(newinfo, oldinfo, sizeof(SpecialJoinInfo));
+		newinfo->min_lefthand = adjust_child_relids(oldinfo->min_lefthand,
+													context->nappinfos,
+													context->appinfos);
+		newinfo->min_righthand = adjust_child_relids(oldinfo->min_righthand,
+													 context->nappinfos,
+													 context->appinfos);
+		newinfo->syn_lefthand = adjust_child_relids(oldinfo->syn_lefthand,
+													context->nappinfos,
+													context->appinfos);
+		newinfo->syn_righthand = adjust_child_relids(oldinfo->syn_righthand,
+													 context->nappinfos,
+													 context->appinfos);
+		newinfo->semi_rhs_exprs =
+					(List *) expression_tree_mutator((Node *)
+													 oldinfo->semi_rhs_exprs,
+													 adjust_appendrel_attrs_mutator,
+													 (void *) context);
+		return (Node *) newinfo;
+	}
+
+	/* Shouldn't need to handle planner auxiliary nodes here */
+	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 */
+		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->nullable_relids = adjust_child_relids(oldinfo->nullable_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));
+
+	return expression_tree_mutator(node, adjust_appendrel_attrs_mutator,
+								   (void *) context);
+}
+
+/*
+ * Substitute child relids for parent relids in a Relid set.  The array of
+ * appinfos specifies the substitutions to be performed.
+ */
+static Relids
+adjust_child_relids(Relids relids, int nappinfos, AppendRelInfo **appinfos)
+{
+	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;
+}
+
+/*
+ * Replace any relid present in top_parent_relids with its child in
+ * child_relids. Members of child_relids can be multiple levels below top
+ * parent in the partition hierarchy.
+ */
+Relids
+adjust_child_relids_multilevel(PlannerInfo *root, Relids relids,
+							   Relids child_relids, Relids top_parent_relids)
+{
+	AppendRelInfo **appinfos;
+	int			nappinfos;
+	Relids		parent_relids = NULL;
+	Relids		result;
+	Relids		tmp_result = NULL;
+	int			cnt;
+
+	/*
+	 * If the given relids set doesn't contain any of the top parent relids,
+	 * it will remain unchanged.
+	 */
+	if (!bms_overlap(relids, top_parent_relids))
+		return relids;
+
+	appinfos = find_appinfos_by_relids(root, child_relids, &nappinfos);
+
+	/* Construct relids set for the immediate parent of the given child. */
+	for (cnt = 0; cnt < nappinfos; cnt++)
+	{
+		AppendRelInfo *appinfo = appinfos[cnt];
+
+		parent_relids = bms_add_member(parent_relids, appinfo->parent_relid);
+	}
+
+	/* Recurse if immediate parent is not the top parent. */
+	if (!bms_equal(parent_relids, top_parent_relids))
+	{
+		tmp_result = adjust_child_relids_multilevel(root, relids,
+													parent_relids,
+													top_parent_relids);
+		relids = tmp_result;
+	}
+
+	result = adjust_child_relids(relids, nappinfos, appinfos);
+
+	/* Free memory consumed by any intermediate result. */
+	if (tmp_result)
+		bms_free(tmp_result);
+	bms_free(parent_relids);
+	pfree(appinfos);
+
+	return result;
+}
+
+/*
+ * adjust_appendrel_attrs_multilevel
+ *	  Apply Var translations from a toplevel appendrel parent down to a child.
+ *
+ * In some cases we need to translate expressions referencing a parent relation
+ * to reference an appendrel child that's multiple levels removed from it.
+ */
+Node *
+adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node,
+								  Relids child_relids,
+								  Relids top_parent_relids)
+{
+	AppendRelInfo **appinfos;
+	Bitmapset  *parent_relids = NULL;
+	int			nappinfos;
+	int			cnt;
+
+	Assert(bms_num_members(child_relids) == bms_num_members(top_parent_relids));
+
+	appinfos = find_appinfos_by_relids(root, child_relids, &nappinfos);
+
+	/* Construct relids set for the immediate parent of given child. */
+	for (cnt = 0; cnt < nappinfos; cnt++)
+	{
+		AppendRelInfo *appinfo = appinfos[cnt];
+
+		parent_relids = bms_add_member(parent_relids, appinfo->parent_relid);
+	}
+
+	/* Recurse if immediate parent is not the top parent. */
+	if (!bms_equal(parent_relids, top_parent_relids))
+		node = adjust_appendrel_attrs_multilevel(root, node, parent_relids,
+												 top_parent_relids);
+
+	/* Now translate for this child */
+	node = adjust_appendrel_attrs(root, node, nappinfos, appinfos);
+
+	pfree(appinfos);
+
+	return node;
+}
+
+/*
+ * Construct the SpecialJoinInfo for a child-join by translating
+ * SpecialJoinInfo for the join between parents. left_relids and right_relids
+ * are the relids of left and right side of the join respectively.
+ */
+SpecialJoinInfo *
+build_child_join_sjinfo(PlannerInfo *root, SpecialJoinInfo *parent_sjinfo,
+						Relids left_relids, Relids right_relids)
+{
+	SpecialJoinInfo *sjinfo = makeNode(SpecialJoinInfo);
+	AppendRelInfo **left_appinfos;
+	int			left_nappinfos;
+	AppendRelInfo **right_appinfos;
+	int			right_nappinfos;
+
+	memcpy(sjinfo, parent_sjinfo, sizeof(SpecialJoinInfo));
+	left_appinfos = find_appinfos_by_relids(root, left_relids,
+											&left_nappinfos);
+	right_appinfos = find_appinfos_by_relids(root, right_relids,
+											 &right_nappinfos);
+
+	sjinfo->min_lefthand = adjust_child_relids(sjinfo->min_lefthand,
+											   left_nappinfos, left_appinfos);
+	sjinfo->min_righthand = adjust_child_relids(sjinfo->min_righthand,
+												right_nappinfos,
+												right_appinfos);
+	sjinfo->syn_lefthand = adjust_child_relids(sjinfo->syn_lefthand,
+											   left_nappinfos, left_appinfos);
+	sjinfo->syn_righthand = adjust_child_relids(sjinfo->syn_righthand,
+												right_nappinfos,
+												right_appinfos);
+	sjinfo->semi_rhs_exprs = (List *) adjust_appendrel_attrs(root,
+															 (Node *) sjinfo->semi_rhs_exprs,
+															 right_nappinfos,
+															 right_appinfos);
+
+	pfree(left_appinfos);
+	pfree(right_appinfos);
+
+	return sjinfo;
+}
+
+/*
+ * find_appinfos_by_relids
+ * 		Find AppendRelInfo structures for all relations specified by relids.
+ *
+ * The AppendRelInfos are returned in an array, which can be pfree'd by the
+ * caller. *nappinfos is set to the number of entries in the array.
+ */
+AppendRelInfo **
+find_appinfos_by_relids(PlannerInfo *root, Relids relids, int *nappinfos)
+{
+	AppendRelInfo **appinfos;
+	int			cnt = 0;
+	int			i;
+
+	*nappinfos = bms_num_members(relids);
+	appinfos = (AppendRelInfo **) palloc(sizeof(AppendRelInfo *) * *nappinfos);
+
+	i = -1;
+	while ((i = bms_next_member(relids, i)) >= 0)
+	{
+		AppendRelInfo *appinfo = root->append_rel_array[i];
+
+		if (!appinfo)
+			elog(ERROR, "child rel %d not found in append_rel_array", i);
+
+		appinfos[cnt++] = appinfo;
+	}
+	return appinfos;
+}
+
+/*
+ * make_inh_translation_list
+ *	  Build the list of translations from parent Vars to child Vars for
+ *	  an inheritance child.
+ *
+ * For paranoia's sake, we match type/collation as well as attribute name.
+ */
+static void
+make_inh_translation_list(TupleDesc old_tupdesc, TupleDesc new_tupdesc,
+						  Oid from_rel, Oid to_rel,
+						  Index newvarno, List **translated_vars)
+{
+	List	   *vars = NIL;
+	int			oldnatts = old_tupdesc->natts;
+	int			newnatts = new_tupdesc->natts;
+	int			old_attno;
+	int			new_attno = 0;
+
+	for (old_attno = 0; old_attno < oldnatts; old_attno++)
+	{
+		Form_pg_attribute att;
+		char	   *attname;
+		Oid			atttypid;
+		int32		atttypmod;
+		Oid			attcollation;
+
+		att = TupleDescAttr(old_tupdesc, old_attno);
+		if (att->attisdropped)
+		{
+			/* Just put NULL into this list entry */
+			vars = lappend(vars, NULL);
+			continue;
+		}
+		attname = NameStr(att->attname);
+		atttypid = att->atttypid;
+		atttypmod = att->atttypmod;
+		attcollation = att->attcollation;
+
+		/*
+		 * When we are generating the "translation list" for the parent table
+		 * of an inheritance set, no need to search for matches.
+		 */
+		if (from_rel == to_rel)
+		{
+			vars = lappend(vars, makeVar(newvarno,
+										 (AttrNumber) (old_attno + 1),
+										 atttypid,
+										 atttypmod,
+										 attcollation,
+										 0));
+			continue;
+		}
+
+		/*
+		 * Otherwise we have to search for the matching column by name.
+		 * There's no guarantee it'll have the same column position, because
+		 * of cases like ALTER TABLE ADD COLUMN and multiple inheritance.
+		 * However, in simple cases, the relative order of columns is mostly
+		 * the same in both relations, so try the column of newrelation that
+		 * follows immediately after the one that we just found, and if that
+		 * fails, let syscache handle it.
+		 */
+		if (new_attno >= newnatts ||
+			(att = TupleDescAttr(new_tupdesc, new_attno))->attisdropped ||
+			strcmp(attname, NameStr(att->attname)) != 0)
+		{
+			HeapTuple	newtup;
+
+			newtup = SearchSysCacheAttName(to_rel, attname);
+			if (!newtup)
+				elog(ERROR, "could not find inherited attribute \"%s\" of relation \"%s\"",
+					 attname, get_rel_name(to_rel));
+			new_attno = ((Form_pg_attribute) GETSTRUCT(newtup))->attnum - 1;
+			ReleaseSysCache(newtup);
+
+			att = TupleDescAttr(new_tupdesc, new_attno);
+		}
+
+		/* Found it, check type and collation match */
+		if (atttypid != att->atttypid || atttypmod != att->atttypmod)
+			elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's type",
+				 attname, get_rel_name(to_rel));
+		if (attcollation != att->attcollation)
+			elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's collation",
+				 attname, get_rel_name(to_rel));
+
+		vars = lappend(vars, makeVar(newvarno,
+									 (AttrNumber) (new_attno + 1),
+									 atttypid,
+									 atttypmod,
+									 attcollation,
+									 0));
+		new_attno++;
+	}
+
+	*translated_vars = vars;
+}
+
+/*
+ * translate_col_privs
+ *	  Translate a bitmapset representing per-column privileges from the
+ *	  parent rel's attribute numbering to the child's.
+ *
+ * The only surprise here is that we don't translate a parent whole-row
+ * reference into a child whole-row reference.  That would mean requiring
+ * permissions on all child columns, which is overly strict, since the
+ * query is really only going to reference the inherited columns.  Instead
+ * we set the per-column bits for all inherited columns.
+ */
+Bitmapset *
+translate_col_privs(const Bitmapset *parent_privs,
+					List *translated_vars)
+{
+	Bitmapset  *child_privs = NULL;
+	bool		whole_row;
+	int			attno;
+	ListCell   *lc;
+
+	/* System attributes have the same numbers in all tables */
+	for (attno = FirstLowInvalidHeapAttributeNumber + 1; attno < 0; attno++)
+	{
+		if (bms_is_member(attno - FirstLowInvalidHeapAttributeNumber,
+						  parent_privs))
+			child_privs = bms_add_member(child_privs,
+										 attno - FirstLowInvalidHeapAttributeNumber);
+	}
+
+	/* Check if parent has whole-row reference */
+	whole_row = bms_is_member(InvalidAttrNumber - FirstLowInvalidHeapAttributeNumber,
+							  parent_privs);
+
+	/* And now translate the regular user attributes, using the vars list */
+	attno = InvalidAttrNumber;
+	foreach(lc, translated_vars)
+	{
+		Var		   *var = lfirst_node(Var, lc);
+
+		attno++;
+		if (var == NULL)		/* ignore dropped columns */
+			continue;
+		if (whole_row ||
+			bms_is_member(attno - FirstLowInvalidHeapAttributeNumber,
+						  parent_privs))
+			child_privs = bms_add_member(child_privs,
+										 var->varattno - FirstLowInvalidHeapAttributeNumber);
+	}
+
+	return child_privs;
+}
+
+/*
+ * 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.
+ */
+static List *
+adjust_inherited_tlist(List *tlist, AppendRelInfo *context)
+{
+	bool		changed_it = false;
+	ListCell   *tl;
+	List	   *new_tlist;
+	bool		more;
+	int			attrno;
+
+	/* 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)
+	{
+		TargetEntry *tle = (TargetEntry *) lfirst(tl);
+		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))
+			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);
+		if (childvar == NULL || !IsA(childvar, Var))
+			elog(ERROR, "attribute %d of relation \"%s\" does not exist",
+				 tle->resno, get_rel_name(context->parent_reloid));
+
+		if (tle->resno != childvar->varattno)
+		{
+			tle->resno = childvar->varattno;
+			changed_it = true;
+		}
+	}
+
+	/*
+	 * 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;
+
+	new_tlist = NIL;
+	more = true;
+	for (attrno = 1; more; attrno++)
+	{
+		more = false;
+		foreach(tl, tlist)
+		{
+			TargetEntry *tle = (TargetEntry *) lfirst(tl);
+
+			if (tle->resjunk)
+				continue;		/* ignore junk items */
+
+			if (tle->resno == attrno)
+				new_tlist = lappend(new_tlist, tle);
+			else if (tle->resno > attrno)
+				more = true;
+		}
+	}
+
+	foreach(tl, tlist)
+	{
+		TargetEntry *tle = (TargetEntry *) lfirst(tl);
+
+		if (!tle->resjunk)
+			continue;			/* here, ignore non-junk items */
+
+		tle->resno = attrno;
+		new_tlist = lappend(new_tlist, tle);
+		attrno++;
+	}
+
+	return new_tlist;
+}
diff --git a/src/backend/optimizer/util/inherit.c b/src/backend/optimizer/util/inherit.c
new file mode 100644
index 0000000000..2224c5911f
--- /dev/null
+++ b/src/backend/optimizer/util/inherit.c
@@ -0,0 +1,776 @@
+/*-------------------------------------------------------------------------
+ *
+ * inherit.c
+ *	  Routines to process child relations in inheritance trees
+ *
+ * Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/optimizer/path/inherit.c
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include <limits.h>
+
+#include "access/sysattr.h"
+#include "catalog/partition.h"
+#include "catalog/pg_class.h"
+#include "catalog/pg_inherits.h"
+#include "catalog/pg_type.h"
+#include "nodes/makefuncs.h"
+#include "optimizer/appendinfo.h"
+#include "optimizer/clauses.h"
+#include "optimizer/inherit.h"
+#include "optimizer/pathnode.h"
+#include "optimizer/paths.h"
+#include "optimizer/plancat.h"
+#include "optimizer/planmain.h"
+#include "optimizer/planner.h"
+#include "optimizer/prep.h"
+#include "optimizer/restrictinfo.h"
+#include "optimizer/tlist.h"
+#include "optimizer/var.h"
+#include "partitioning/partprune.h"
+#include "utils/rel.h"
+
+static void expand_append_rtentry(PlannerInfo *root, RelOptInfo *rel,
+					  RangeTblEntry *rte, Index rti);
+static void expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte,
+						 Index rti, RelOptInfo *rel);
+static void expand_partitioned_rtentry(PlannerInfo *root,
+						   RangeTblEntry *parentrte,
+						   Index parentRTindex, RelOptInfo *parentrel);
+static RelOptInfo *add_inheritance_child_rel(PlannerInfo *root,
+						  RangeTblEntry *parentrte,
+						  Index parentRTindex, RelOptInfo *parentrel,
+						  PlanRowMark *top_parentrc, Relation childrel,
+						  RangeTblEntry **childrte_p, Index *childRTindex_p);
+static RelOptInfo *build_append_child_rel(PlannerInfo *root,
+					   RelOptInfo *parent,
+					   Index childRTindex);
+static List *add_rowmark_junk_columns(PlannerInfo *root, PlanRowMark *rc);
+
+
+/*
+ * expand_inherited_tables
+ *		Expand each rangetable entry that represents an inheritance set
+ *		into an "append relation".  At the conclusion of this process,
+ *		the "inh" flag is set in all and only those RTEs that are append
+ *		relation parents.
+ */
+void
+expand_inherited_tables(PlannerInfo *root)
+{
+	int			orig_rtable_size;
+	Index		rti;
+
+	Assert(root->simple_rel_array_size > 0);
+	orig_rtable_size = root->simple_rel_array_size;
+
+	/*
+	 * expand_append_rtentry may add RTEs to parse->rtable. The function is
+	 * expected to recursively handle any RTEs that it creates with inh=true.
+	 * So just scan as far as the original end of the rtable list.
+	 */
+	for (rti = 1; rti < orig_rtable_size; rti++)
+	{
+		RelOptInfo *brel = root->simple_rel_array[rti];
+		RangeTblEntry *rte = root->simple_rte_array[rti];
+
+		/* there may be empty slots corresponding to non-baserel RTEs */
+		if (brel == NULL)
+			continue;
+
+		if (rte->inh)
+			expand_append_rtentry(root, brel, rte, rti);
+	}
+}
+
+/*
+ * expand_append_rtentry
+ *		This initializes RelOptInfos for an appendrel's child relations, if
+ *		any
+ *
+ * 'rel' is the appendrel parent, whose range table entry ('rte') has been
+ * marked to require adding children.  An appendrel parent could either
+ * be a subquery (if we flattened UNION ALL query) or a table that's known
+ * to have inheritance children.  The latter consists of both regular
+ * inheritance parents and partitioned tables.
+ *
+ * For a subquery parent, there is not much to be done here because the
+ * children's RTEs are already present in the query, so we just initialize
+ * RelOptInfos for them.  Also, the AppendRelInfos for child subqueries
+ * have already been added.
+ *
+ * For tables, we need to add the children to the range table and initialize
+ * AppendRelInfos, RelOptInfos, and PlanRowMarks (if any) for them.  For
+ * a partitioned parent, we only add the children remaining after pruning.
+ * For regular inheritance parents, we find the children using
+ * find_all_inheritors and add all of them.
+ *
+ * If it turns out that there are no children, then we set rte->inh to false
+ * to let the caller know that only the parent table needs to be scanned.  The
+ * caller can accordingly switch to a non-Append path.  For a partitioned
+ * parent, that means an empty relation because parents themselves contain no
+ * data.
+ *
+ * For the regular inheritance case, the parent also gets another RTE with
+ * inh = false to represent it as an appendrel child.  The original RTE is
+ * considered to represent the whole inheritance set.
+ */
+static void
+expand_append_rtentry(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte,
+					  Index rti)
+{
+	Assert(rte->inh);
+	/* Inheritance parent (partitioned or not) or UNION ALL parent subquery. */
+	Assert(rte->rtekind == RTE_RELATION || rte->rtekind == RTE_SUBQUERY);
+
+	/*
+	 * UNION ALL children already got RTEs and AppendRelInfos, so just build
+	 * RelOptInfos and return.
+	 *
+	 * It might be a bit odd that this code is in this, because there is
+	 * nothing to expand really.
+	 */
+	if (rte->rtekind == RTE_SUBQUERY)
+	{
+		ListCell   *l;
+
+		/*
+		 * We don't need to use expand_planner_arrays in this case, because
+		 * no new child RTEs are created.  setup_simple_rel_arrays() and
+		 * setup_append_rel_array would've considered these child RTEs when
+		 * allocating space for various arrays.
+		 */
+		foreach(l, root->append_rel_list)
+		{
+			AppendRelInfo *appinfo = lfirst(l);
+			Index		childRTindex = appinfo->child_relid;
+
+			if (appinfo->parent_relid != rti)
+				continue;
+
+			Assert(childRTindex < root->simple_rel_array_size);
+			Assert(root->simple_rte_array[childRTindex] != NULL);
+
+			/*
+			 * We set the correct value of baserestricinfo and
+			 * baserestrict_min_security below.
+			 */
+			root->simple_rel_array[childRTindex] =
+				build_append_child_rel(root, rel, appinfo->child_relid);
+		}
+	}
+	else
+	{
+		Assert(rte->rtekind == RTE_RELATION);
+		Assert(has_subclass(rte->relid));
+
+		/*
+		 * The rewriter should already have obtained an appropriate lock on
+		 * each relation named in the query.  However, for each child relation
+		 * we add to the query, we must obtain an appropriate lock, because
+		 * this will be the first use of those relations in the
+		 * parse/rewrite/plan pipeline.  Child rels should use the same
+		 * lockmode as their parent.
+		 */
+		Assert(rte->rellockmode != NoLock);
+
+		if (rte->relkind == RELKIND_PARTITIONED_TABLE)
+			expand_partitioned_rtentry(root, rte, rti, rel);
+		else
+			expand_inherited_rtentry(root, rte, rti, rel);
+	}
+}
+
+/*
+ * expand_inherited_rtentry
+ *		Add entries for all the child tables to the query's rangetable, and
+ *		build AppendRelInfo nodes for all the child tables and add them to
+ *		root->append_rel_list.
+ *
+ * Note that the original RTE is considered to represent the whole
+ * inheritance set.  The first of the generated RTEs is an RTE for the same
+ * table, but with inh = false, to represent the parent table in its role
+ * as a simple member of the inheritance set.
+ *
+ * A childless table is never considered to be an inheritance set. For
+ * regular inheritance, a parent RTE must always have at least two associated
+ * AppendRelInfos: one corresponding to the parent table as a simple member of
+ * inheritance set and one or more corresponding to the actual children.
+ */
+static void
+expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti,
+						 RelOptInfo *rel)
+{
+	Oid			parentOID;
+	PlanRowMark *oldrc;
+	LOCKMODE	lockmode = rte->rellockmode;
+	List	   *inhOIDs;
+	ListCell   *l;
+	int			num_children;
+	int			num_children_added = 0;
+
+	Assert(rte->rtekind == RTE_RELATION);
+	Assert(lockmode != NoLock);
+	parentOID = rte->relid;
+
+	/* Scan for all members of inheritance set, acquire needed locks */
+	inhOIDs = find_all_inheritors(parentOID, lockmode, NULL);
+
+	/*
+	 * Check that there's at least one descendant, else treat as no-child
+	 * case.  This could happen despite has_subclass() check performed by
+	 * subquery_planner, if table once had a child but no longer does.
+	 */
+	num_children = list_length(inhOIDs);
+	if (num_children < 2)
+	{
+		/* Clear flag before returning */
+		rte->inh = false;
+		return;
+	}
+
+	/*
+	 * If parent relation is selected FOR UPDATE/SHARE, preprocess_rowmarks
+	 * should've set isParent = true.  We'll generate a new PlanRowMark for
+	 * each child.
+	 */
+	oldrc = get_plan_rowmark(root->rowMarks, rti);
+	Assert(oldrc == NULL || oldrc->isParent);
+
+	/*
+	 * Must expand PlannerInfo arrays by num_children before we can add
+	 * children.
+	 */
+	expand_planner_arrays(root, num_children);
+
+	foreach(l, inhOIDs)
+	{
+		Oid			childOID = lfirst_oid(l);
+		Relation	newrelation;
+		RangeTblEntry *childrte;
+		Index		childRTindex;
+
+		/* Already locked above. */
+		newrelation = heap_open(childOID, NoLock);
+
+		/*
+		 * It is possible that the parent table has children that are temp
+		 * tables of other backends.  We cannot safely access such tables
+		 * (because of buffering issues), and the best thing to do seems
+		 * to be to silently ignore them.
+		 */
+		if (RELATION_IS_OTHER_TEMP(newrelation))
+		{
+			heap_close(newrelation, lockmode);
+			continue;
+		}
+
+		(void) add_inheritance_child_rel(root, rte, rti, rel, oldrc,
+										 newrelation, &childrte,
+										 &childRTindex);
+		Assert(childrte != NULL);
+		/* All regular inheritance children are leaf children. */
+		Assert(!childrte->inh);
+		Assert(childRTindex > 0);
+
+		/* Close child relations, but keep locks */
+		heap_close(newrelation, NoLock);
+		num_children_added++;
+	}
+
+	/*
+	 * If all children, including the parent (as child rel), were
+	 * excluded, mark the parent rel as empty.  If all the children were temp
+	 * tables, pretend it's a non-inheritance situation; we don't need Append
+	 * node in that case.  The duplicate RTE we added for the parent table is
+	 * harmless, so we don't bother to get rid of it; ditto for the useless
+	 * PlanRowMark node.
+	 */
+	if (num_children_added == 0)
+		mark_dummy_rel(rel);
+	else if (num_children_added == 1)
+		rte->inh = false;
+
+	/*
+	 * Add junk columns needed by the row mark if any and also add the
+	 * relevant expressions to the root parent's reltarget.
+	 */
+	if (oldrc)
+	{
+		List   *tlist = add_rowmark_junk_columns(root, oldrc);
+
+		build_base_rel_tlists(root, tlist);
+	}
+}
+
+/*
+ * expand_partitioned_rtentry
+ *		Prunes unnecessary partitions of a partitioned table and adds
+ *		remaining ones to the Query and the PlannerInfo
+ *
+ * Partitions are added to the query in order in which they are found in
+ * the parent's PartitionDesc.
+ *
+ * Note: even though only the unpruned partitions will be added to the
+ * resulting plan, this still locks *all* partitions via find_all_inheritors
+ * when this function is called for the root partitioned table.
+ */
+static void
+expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
+						   Index parentRTindex, RelOptInfo *parentrel)
+{
+	LOCKMODE	lockmode = parentrte->rellockmode;
+	PlanRowMark *rootrc = NULL;
+	int			i;
+	Bitmapset  *partindexes;
+	Index		rootParentRTindex = parentrel->inh_root_parent > 0 ?
+									parentrel->inh_root_parent :
+									parentRTindex;
+
+	/* If root partitioned table, lock *all* partitions in the tree. */
+	if (parentRTindex == rootParentRTindex)
+		(void) find_all_inheritors(parentrte->relid, lockmode, NULL);
+
+	/*
+	 * Initialize partitioned_child_rels to contain this RT index.
+	 *
+	 * Note that during the set_append_rel_pathlist() phase, values of the
+	 * indexes of partitioned relations that appear down in the tree will be
+	 * bubbled up into root parent's list so that when we've created Paths for
+	 * all the children, the root table's list will contain all such indexes.
+	 */
+	parentrel->partitioned_child_rels = list_make1_int(parentRTindex);
+
+	/* Perform pruning. */
+	partindexes = prune_append_rel_partitions(parentrel);
+
+	/* Must expand PlannerInfo arrays before we can add children. */
+	expand_planner_arrays(root, bms_num_members(partindexes));
+
+	/*
+	 * For partitioned tables, we also store the partition RelOptInfo
+	 * pointers in the parent's RelOptInfo.
+	 */
+	parentrel->part_rels = (RelOptInfo **) palloc0(sizeof(RelOptInfo *) *
+												   parentrel->nparts);
+
+	rootrc = get_plan_rowmark(root->rowMarks, rootParentRTindex);
+	Assert(rootrc == NULL || rootrc->isParent);
+	i = -1;
+	while ((i = bms_next_member(partindexes, i)) >= 0)
+	{
+		Oid		childOID = parentrel->part_oids[i];
+		Relation	newrelation;
+		RelOptInfo *childrel;
+		RangeTblEntry *childrte;
+		Index		childRTindex;
+
+		/* Already locked above. */
+		newrelation = heap_open(childOID, NoLock);
+		Assert(!RELATION_IS_OTHER_TEMP(newrelation));
+
+		/*
+		 * A partitioned child table with 0 children is a dummy rel, so don't
+		 * bother creating planner objects for it.
+		 */
+		if (newrelation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE &&
+			RelationGetPartitionDesc(newrelation)->nparts == 0)
+		{
+			heap_close(newrelation, NoLock);
+			continue;
+		}
+
+		childrel = add_inheritance_child_rel(root, parentrte, parentRTindex,
+											 parentrel, rootrc, newrelation,
+											 &childrte, &childRTindex);
+		Assert(childrel != NULL);
+		parentrel->part_rels[i] = childrel;
+
+		/* Close child relations, but keep locks */
+		heap_close(newrelation, NoLock);
+
+		/* If the child is partitioned itself, expand it too. */
+		if (childrel->part_scheme)
+		{
+			Assert(childrte->inh);
+			expand_partitioned_rtentry(root, childrte, childRTindex,
+									   childrel);
+		}
+	}
+
+	/*
+	 * Add junk columns needed by the row mark if any and also add the
+	 * relevant expressions to the root parent's reltarget.
+	 */
+	if (rootrc)
+	{
+		List   *tlist = add_rowmark_junk_columns(root, rootrc);
+
+		build_base_rel_tlists(root, tlist);
+	}
+}
+
+/*
+ * add_inheritance_child_rel
+ *		Build a RangeTblEntry, an AppendRelInfo, a PlanRowMark, and finally
+ *		a RelOptInfo for an inheritance child relation.
+ *
+ * The return value is the RelOptInfo that's added.
+ *
+ * PlanRowMarks still carry the top-parent's RTI, and the top-parent's
+ * allMarkTypes field still accumulates values from all descendents.
+ *
+ * "parentrte" and "parentRTindex" are immediate parent's RTE and
+ * RTI. "top_parentrc" is top parent's PlanRowMark.
+ */
+static RelOptInfo *
+add_inheritance_child_rel(PlannerInfo *root, RangeTblEntry *parentrte,
+						  Index parentRTindex, RelOptInfo *parentrel,
+						  PlanRowMark *top_parentrc, Relation childrel,
+						  RangeTblEntry **childrte_p, Index *childRTindex_p)
+{
+	Query	   *parse = root->parse;
+	Oid			childOID = RelationGetRelid(childrel);
+	RangeTblEntry *childrte;
+	Index		childRTindex;
+	AppendRelInfo *appinfo;
+	RelOptInfo *childrelopt;
+
+	/*
+	 * Build an RTE for the child, and attach to query's rangetable list. We
+	 * copy most fields of the parent's RTE, but replace relation OID and
+	 * relkind, and set inh appropriately.  Also, set requiredPerms to zero
+	 * since all required permissions checks are done on the original RTE.
+	 * Likewise, set the child's securityQuals to empty, because we only want
+	 * to apply the parent's RLS conditions regardless of what RLS properties
+	 * individual children may have.  (This is an intentional choice to make
+	 * inherited RLS work like regular permissions checks.) The parent
+	 * securityQuals will be propagated to children along with other base
+	 * restriction clauses, so we don't need to do it here.
+	 */
+	childrte = copyObject(parentrte);
+	*childrte_p = childrte;
+	childrte->relid = childOID;
+	childrte->relkind = childrel->rd_rel->relkind;
+	/*
+	 * A partitioned child will need to be expanded as an append parent
+	 * itself, so set its inh to true.
+	 */
+	childrte->inh = (childrte->relkind == RELKIND_PARTITIONED_TABLE);
+	childrte->requiredPerms = 0;
+	childrte->securityQuals = NIL;
+	parse->rtable = lappend(parse->rtable, childrte);
+	childRTindex = list_length(parse->rtable);
+	*childRTindex_p = childRTindex;
+
+	/* Create an AppendRelInfo and add it to planner's global list. */
+	appinfo = make_append_rel_info(parentrel, parentrte,
+								   childrel->rd_att,
+								   childOID,
+								   childrel->rd_rel->reltype,
+								   childRTindex);
+	root->append_rel_list = lappend(root->append_rel_list, appinfo);
+
+	/*
+	 * Translate the column permissions bitmaps to the child's attnums (we
+	 * have to build the translated_vars list before we can do this). But
+	 * if this is the parent table, leave copyObject's result alone.
+	 *
+	 * Note: we need to do this even though the executor won't run any
+	 * permissions checks on the child RTE.  The insertedCols/updatedCols
+	 * bitmaps may be examined for trigger-firing purposes.
+	 */
+	if (childrte->relid != parentrte->relid)
+	{
+		childrte->selectedCols = translate_col_privs(parentrte->selectedCols,
+													 appinfo->translated_vars);
+		childrte->insertedCols = translate_col_privs(parentrte->insertedCols,
+													 appinfo->translated_vars);
+		childrte->updatedCols = translate_col_privs(parentrte->updatedCols,
+													appinfo->translated_vars);
+	}
+
+	/*
+	 * Build a PlanRowMark if parent is marked FOR UPDATE/SHARE.
+	 */
+	if (top_parentrc)
+	{
+		PlanRowMark *childrc = makeNode(PlanRowMark);
+
+		childrc->rti = childRTindex;
+		childrc->prti = top_parentrc->rti;
+		childrc->rowmarkId = top_parentrc->rowmarkId;
+		/* Reselect rowmark type, because relkind might not match parent */
+		childrc->markType = select_rowmark_type(childrte,
+												top_parentrc->strength);
+		childrc->allMarkTypes = (1 << childrc->markType);
+		childrc->strength = top_parentrc->strength;
+		childrc->waitPolicy = top_parentrc->waitPolicy;
+
+		/*
+		 * We mark RowMarks for partitioned child tables as parent RowMarks so
+		 * that the executor ignores them (except their existence means that
+		 * the child tables be locked using appropriate mode).
+		 */
+		childrc->isParent = (childrte->relkind == RELKIND_PARTITIONED_TABLE);
+
+		/* Include child's rowmark type in top parent's allMarkTypes */
+		top_parentrc->allMarkTypes |= childrc->allMarkTypes;
+
+		root->rowMarks = lappend(root->rowMarks, childrc);
+	}
+
+	/*
+	 * Add the RelOptInfo.  Even though we may not really scan this relation
+	 * for reasons such as contradictory quals, we still need to create one,
+	 * because for every RTE in the query's range table, there must be an
+	 * accompanying RelOptInfo.
+	 */
+
+	/* First, store the RTE and appinfos into planner arrays. */
+	Assert(root->simple_rte_array[childRTindex] == NULL);
+	root->simple_rte_array[childRTindex] = childrte;
+	Assert(root->append_rel_array[childRTindex] == NULL);
+	root->append_rel_array[childRTindex] = appinfo;
+
+	childrelopt = build_append_child_rel(root, parentrel, childRTindex);
+	Assert(childrelopt != NULL);
+
+	return childrelopt;
+}
+
+/*
+ *	build_append_child_rel
+ *		Build a RelOptInfo for child relation of an append rel
+ *
+ * After creating the RelOptInfo for the given child RT index, it goes on to
+ * initialize some of its fields based on the parent RelOptInfo.
+ *
+ * If the quals in baserestrictinfo turn out to be self-contradictory, the
+ * RelOptInfo is marked dummy before returning.
+ */
+static RelOptInfo *
+build_append_child_rel(PlannerInfo *root,
+					   RelOptInfo *parent,
+					   Index childRTindex)
+{
+	RelOptInfo *childrel;
+	RangeTblEntry *childRTE = root->simple_rte_array[childRTindex];
+	AppendRelInfo *appinfo = root->append_rel_array[childRTindex];
+	List	   *childquals;
+	ListCell   *lc;
+	bool		have_const_false_cq;
+	Index		cq_min_security;
+
+	/* Build the RelOptInfo. */
+	childrel = build_simple_rel(root, childRTindex, parent);
+
+	/*
+	 * Propagate lateral_relids and lateral_referencers from appendrel
+	 * parent rels to their child rels.  We intentionally give each child rel
+	 * the same minimum parameterization, even though it's quite possible that
+	 * some don't reference all the lateral rels.  This is because any append
+	 * path for the parent will have to have the same parameterization for
+	 * every child anyway, and there's no value in forcing extra
+	 * reparameterize_path() calls.  Similarly, a lateral reference to the
+	 * parent prevents use of otherwise-movable join rels for each child.
+	 */
+	childrel->direct_lateral_relids = parent->direct_lateral_relids;
+	childrel->lateral_relids = parent->lateral_relids;
+	childrel->lateral_referencers = parent->lateral_referencers;
+
+	/*
+	 * We have to copy the parent's quals to the child, with appropriate
+	 * substitution of variables.  However, only the baserestrictinfo
+	 * quals are needed before we can check for constraint exclusion; so
+	 * do that first and then check to see if we can disregard this child.
+	 *
+	 * The child rel's targetlist might contain non-Var expressions, which
+	 * means that substitution into the quals could produce opportunities
+	 * for const-simplification, and perhaps even pseudoconstant quals.
+	 * Therefore, transform each RestrictInfo separately to see if it
+	 * reduces to a constant or pseudoconstant.  (We must process them
+	 * separately to keep track of the security level of each qual.)
+	 */
+	childquals = false;
+	cq_min_security = UINT_MAX;
+	have_const_false_cq = false;
+	foreach(lc, parent->baserestrictinfo)
+	{
+		RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
+		Node	   *childqual = (Node *) rinfo->clause;
+		ListCell   *lc2;
+
+		Assert(IsA(rinfo, RestrictInfo));
+		childqual = adjust_appendrel_attrs(root, childqual,
+										   1, &appinfo);
+		childqual = eval_const_expressions(root, childqual);
+		/* check for flat-out constant */
+		if (childqual && IsA(childqual, Const))
+		{
+			if (((Const *) childqual)->constisnull ||
+				!DatumGetBool(((Const *) childqual)->constvalue))
+			{
+				/* Restriction reduces to constant FALSE or NULL */
+				have_const_false_cq = true;
+				break;
+			}
+			/* Restriction reduces to constant TRUE, so drop it */
+			continue;
+		}
+		/* might have gotten an AND clause, if so flatten it */
+		foreach(lc2, make_ands_implicit((Expr *) childqual))
+		{
+			Node	   *onecq = (Node *) lfirst(lc2);
+			bool		pseudoconstant;
+
+			/* check for pseudoconstant (no Vars or volatile functions) */
+			pseudoconstant =
+					!contain_vars_of_level(onecq, 0) &&
+					!contain_volatile_functions(onecq);
+			if (pseudoconstant)
+			{
+				/* tell createplan.c to check for gating quals */
+				root->hasPseudoConstantQuals = true;
+			}
+			/* reconstitute RestrictInfo with appropriate properties */
+			childquals = lappend(childquals,
+								 make_restrictinfo((Expr *) onecq,
+												   rinfo->is_pushed_down,
+												   rinfo->outerjoin_delayed,
+												   pseudoconstant,
+												   rinfo->security_level,
+												   NULL, NULL, NULL));
+			cq_min_security = Min(cq_min_security, rinfo->security_level);
+		}
+	}
+
+	/*
+	 * In addition to the quals inherited from the parent, we might
+	 * have securityQuals associated with this particular child node.
+	 * (Currently this can only happen in appendrels originating from
+	 * UNION ALL; inheritance child tables don't have their own
+	 * securityQuals.)	Pull any such securityQuals up into the
+	 * baserestrictinfo for the child.  This is similar to
+	 * process_security_barrier_quals() for the parent rel, except
+	 * that we can't make any general deductions from such quals,
+	 * since they don't hold for the whole appendrel.
+	 */
+	if (childRTE->securityQuals)
+	{
+		Index		security_level = 0;
+
+		foreach(lc, childRTE->securityQuals)
+		{
+			List	   *qualset = (List *) lfirst(lc);
+			ListCell   *lc2;
+
+			foreach(lc2, qualset)
+			{
+				Expr	   *qual = (Expr *) lfirst(lc2);
+
+				/*
+				 * not likely that we'd see constants here, so no
+				 * check
+				 */
+				childquals = lappend(childquals,
+									 make_restrictinfo(qual,
+													   true,
+													   false,
+													   false,
+													   security_level,
+													   NULL, NULL,
+													   NULL));
+				cq_min_security = Min(cq_min_security, security_level);
+			}
+			security_level++;
+		}
+		Assert(security_level <= root->qual_security_level);
+	}
+
+	/* Set child's version of baserestrictinfo. */
+	childrel->baserestrictinfo = childquals;
+	childrel->baserestrict_min_security = cq_min_security;
+
+	if (have_const_false_cq)
+	{
+		/*
+		 * Some restriction clause reduced to constant FALSE or NULL after
+		 * substitution, so this child need not be scanned.
+		 */
+		set_dummy_rel_pathlist(childrel);
+	}
+
+	return childrel;
+}
+
+/*
+ * add_rowmark_junk_columns
+ * 		Add necessary junk columns for rowmarked inheritance parent rel.
+ *
+ * These values are needed for locking of rels selected FOR UPDATE/SHARE, and
+ * to do EvalPlanQual rechecking.  See comments for PlanRowMark in
+ * plannodes.h.
+ */
+static List *
+add_rowmark_junk_columns(PlannerInfo *root, PlanRowMark *rc)
+{
+	List   *tlist = root->processed_tlist;
+	Var		   *var;
+	char		resname[32];
+	TargetEntry *tle;
+
+	if (rc->allMarkTypes & ~(1 << ROW_MARK_COPY))
+	{
+		/* Need to fetch TID */
+		var = makeVar(rc->rti,
+					  SelfItemPointerAttributeNumber,
+					  TIDOID,
+					  -1,
+					  InvalidOid,
+					  0);
+		snprintf(resname, sizeof(resname), "ctid%u", rc->rowmarkId);
+		tle = makeTargetEntry((Expr *) var,
+							  list_length(tlist) + 1,
+							  pstrdup(resname),
+							  true);
+		tlist = lappend(tlist, tle);
+	}
+	if (rc->allMarkTypes & (1 << ROW_MARK_COPY))
+	{
+		/* Need the whole row as a junk var */
+		var = makeWholeRowVar(root->simple_rte_array[rc->rti],
+							  rc->rti,
+							  0,
+							  false);
+		snprintf(resname, sizeof(resname), "wholerow%u", rc->rowmarkId);
+		tle = makeTargetEntry((Expr *) var,
+							  list_length(tlist) + 1,
+							  pstrdup(resname),
+							  true);
+		tlist = lappend(tlist, tle);
+	}
+
+	/* For inheritance cases, always fetch the tableoid too. */
+	var = makeVar(rc->rti,
+				  TableOidAttributeNumber,
+				  OIDOID,
+				  -1,
+				  InvalidOid,
+				  0);
+	snprintf(resname, sizeof(resname), "tableoid%u", rc->rowmarkId);
+	tle = makeTargetEntry((Expr *) var,
+						  list_length(tlist) + 1,
+						  pstrdup(resname),
+						  true);
+	tlist = lappend(tlist, tle);
+
+	return tlist;
+}
diff --git a/src/backend/optimizer/util/pathnode.c b/src/backend/optimizer/util/pathnode.c
index 5921e893c1..b2637d0e89 100644
--- a/src/backend/optimizer/util/pathnode.c
+++ b/src/backend/optimizer/util/pathnode.c
@@ -20,6 +20,7 @@
 #include "foreign/fdwapi.h"
 #include "nodes/extensible.h"
 #include "nodes/nodeFuncs.h"
+#include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index fa39afcfe6..8ac73b4c34 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -17,6 +17,7 @@
 #include <limits.h>
 
 #include "miscadmin.h"
+#include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
diff --git a/src/backend/partitioning/partprune.c b/src/backend/partitioning/partprune.c
index 64787de16f..9bb472fd98 100644
--- a/src/backend/partitioning/partprune.c
+++ b/src/backend/partitioning/partprune.c
@@ -44,6 +44,7 @@
 #include "miscadmin.h"
 #include "nodes/makefuncs.h"
 #include "nodes/nodeFuncs.h"
+#include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
diff --git a/src/include/optimizer/appendinfo.h b/src/include/optimizer/appendinfo.h
new file mode 100644
index 0000000000..31011922f0
--- /dev/null
+++ b/src/include/optimizer/appendinfo.h
@@ -0,0 +1,43 @@
+/*-------------------------------------------------------------------------
+ *
+ * appendinfo.h
+ *	  Routines for mapping expressions between append rel parent(s) and
+ *	  children
+ *
+ * Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/optimizer/appendinfo.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef APPENDINFO_H
+#define APPENDINFO_H
+
+#include "nodes/plannodes.h"
+#include "nodes/relation.h"
+#include "utils/relcache.h"
+
+extern AppendRelInfo *make_append_rel_info(RelOptInfo *parentrel,
+					 RangeTblEntry *parentrte,
+					 TupleDesc childdesc, Oid childoid, Oid childreltype,
+					 Index childRTindex);
+extern Bitmapset *translate_col_privs(const Bitmapset *parent_privs,
+					List *translated_vars);
+extern Node *adjust_appendrel_attrs(PlannerInfo *root, Node *node,
+					   int nappinfos, AppendRelInfo **appinfos);
+
+extern Node *adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node,
+								  Relids child_relids,
+								  Relids top_parent_relids);
+
+extern AppendRelInfo **find_appinfos_by_relids(PlannerInfo *root,
+						Relids relids, int *nappinfos);
+
+extern SpecialJoinInfo *build_child_join_sjinfo(PlannerInfo *root,
+						SpecialJoinInfo *parent_sjinfo,
+						Relids left_relids, Relids right_relids);
+extern Relids adjust_child_relids_multilevel(PlannerInfo *root, Relids relids,
+							   Relids child_relids, Relids top_parent_relids);
+
+#endif							/* APPENDINFO_H */
diff --git a/src/include/optimizer/inherit.h b/src/include/optimizer/inherit.h
new file mode 100644
index 0000000000..c0bd54d9ca
--- /dev/null
+++ b/src/include/optimizer/inherit.h
@@ -0,0 +1,25 @@
+/*-------------------------------------------------------------------------
+ *
+ * inherit.h
+ *	  prototypes for inherit.c.
+ *
+ *
+ * Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/optimizer/inherit.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef INHERIT_H
+#define INHERIT_H
+
+#include "nodes/relation.h"
+
+/*
+ * inherit.c
+ *	  utilities for dealing with append relations
+ */
+extern void expand_inherited_tables(PlannerInfo *root);
+
+#endif							/* INHERIT_H */
diff --git a/src/include/optimizer/prep.h b/src/include/optimizer/prep.h
index 9c0795262f..55a69267c6 100644
--- a/src/include/optimizer/prep.h
+++ b/src/include/optimizer/prep.h
@@ -48,24 +48,5 @@ extern PlanRowMark *get_plan_rowmark(List *rowmarks, Index rtindex);
  */
 extern RelOptInfo *plan_set_operations(PlannerInfo *root);
 
-extern void expand_inherited_tables(PlannerInfo *root);
 
-extern Node *adjust_appendrel_attrs(PlannerInfo *root, Node *node,
-					   int nappinfos, AppendRelInfo **appinfos);
-extern AppendRelInfo *make_append_rel_info(RelOptInfo *parentrel,
-					 RangeTblEntry *parentrte,
-					 TupleDesc childdesc, Oid childoid, Oid childreltype,
-					 Index childRTindex);
-extern Node *adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node,
-								  Relids child_relids,
-								  Relids top_parent_relids);
-
-extern AppendRelInfo **find_appinfos_by_relids(PlannerInfo *root,
-						Relids relids, int *nappinfos);
-
-extern SpecialJoinInfo *build_child_join_sjinfo(PlannerInfo *root,
-						SpecialJoinInfo *parent_sjinfo,
-						Relids left_relids, Relids right_relids);
-extern Relids adjust_child_relids_multilevel(PlannerInfo *root, Relids relids,
-							   Relids child_relids, Relids top_parent_relids);
 #endif							/* PREP_H */
-- 
2.11.0

From 3f1a01e84d1ca093561804dbd137d3ef735e4bd6 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Mon, 15 Oct 2018 10:59:24 +0900
Subject: [PATCH v11 5/6] Teach planner to only process unpruned partitions

This adds a bitmapset field live_parts to RelOptInfo and stores
the partition indexes of non-dummy partitions in it, meaning it
contains indexes of only those partitions that have a non-NULL
RelOptInfo present in its parent's RelOptInfo's part_rels array.

This speeds up processing partitioned table's partitions compared
to going through the whole part_rels array in a number of places.
---
 src/backend/optimizer/path/joinrels.c |  3 +++
 src/backend/optimizer/plan/planner.c  | 18 +++++++++---------
 src/backend/optimizer/util/inherit.c  |  1 +
 src/backend/optimizer/util/relnode.c  |  3 +++
 src/backend/partitioning/partprune.c  | 18 +++++-------------
 src/include/nodes/relation.h          |  4 ++++
 6 files changed, 25 insertions(+), 22 deletions(-)

diff --git a/src/backend/optimizer/path/joinrels.c b/src/backend/optimizer/path/joinrels.c
index 23335a1c2d..4526299dbd 100644
--- a/src/backend/optimizer/path/joinrels.c
+++ b/src/backend/optimizer/path/joinrels.c
@@ -1424,6 +1424,9 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
 		populate_joinrel_with_paths(root, child_rel1, child_rel2,
 									child_joinrel, child_sjinfo,
 									child_restrictlist);
+		if (!IS_DUMMY_REL(child_joinrel))
+			joinrel->live_parts = bms_add_member(joinrel->live_parts,
+												 cnt_parts);
 	}
 }
 
diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index db277385d5..32c6cac5c3 100644
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -6816,7 +6816,9 @@ apply_scanjoin_target_to_paths(PlannerInfo *root,
 		List	   *live_children = NIL;
 
 		/* Adjust each partition. */
-		for (partition_idx = 0; partition_idx < rel->nparts; partition_idx++)
+		partition_idx = -1;
+		while ((partition_idx = bms_next_member(rel->live_parts,
+												partition_idx)) >= 0)
 		{
 			RelOptInfo *child_rel = rel->part_rels[partition_idx];
 			ListCell   *lc;
@@ -6824,9 +6826,7 @@ apply_scanjoin_target_to_paths(PlannerInfo *root,
 			int			nappinfos;
 			List	   *child_scanjoin_targets = NIL;
 
-			/* Skip processing pruned partitions. */
-			if (child_rel == NULL)
-				continue;
+			Assert(child_rel != NULL);
 
 			/* Translate scan/join targets for this child. */
 			appinfos = find_appinfos_by_relids(root, child_rel->relids,
@@ -6907,7 +6907,6 @@ create_partitionwise_grouping_paths(PlannerInfo *root,
 									PartitionwiseAggregateType patype,
 									GroupPathExtraData *extra)
 {
-	int			nparts = input_rel->nparts;
 	int			cnt_parts;
 	List	   *grouped_live_children = NIL;
 	List	   *partially_grouped_live_children = NIL;
@@ -6919,7 +6918,9 @@ create_partitionwise_grouping_paths(PlannerInfo *root,
 		   partially_grouped_rel != NULL);
 
 	/* Add paths for partitionwise aggregation/grouping. */
-	for (cnt_parts = 0; cnt_parts < nparts; cnt_parts++)
+	cnt_parts = -1;
+	while ((cnt_parts = bms_next_member(input_rel->live_parts,
+										cnt_parts)) >= 0)
 	{
 		RelOptInfo *child_input_rel = input_rel->part_rels[cnt_parts];
 		PathTarget *child_target = copy_pathtarget(target);
@@ -6929,9 +6930,8 @@ create_partitionwise_grouping_paths(PlannerInfo *root,
 		RelOptInfo *child_grouped_rel;
 		RelOptInfo *child_partially_grouped_rel;
 
-		/* Skip processing pruned partitions. */
-		if (child_input_rel == NULL)
-			continue;
+		/* A live partition must have a RelOptInfo. */
+		Assert(child_input_rel != NULL);
 
 		/* Input child rel must have a path */
 		Assert(child_input_rel->pathlist != NIL);
diff --git a/src/backend/optimizer/util/inherit.c b/src/backend/optimizer/util/inherit.c
index 2224c5911f..b3da21e6e8 100644
--- a/src/backend/optimizer/util/inherit.c
+++ b/src/backend/optimizer/util/inherit.c
@@ -350,6 +350,7 @@ expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
 
 	/* Perform pruning. */
 	partindexes = prune_append_rel_partitions(parentrel);
+	parentrel->live_parts = partindexes;
 
 	/* Must expand PlannerInfo arrays before we can add children. */
 	expand_planner_arrays(root, bms_num_members(partindexes));
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index 8ac73b4c34..74d1dcaa20 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -1748,6 +1748,9 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
 		joinrel->partexprs[cnt] = partexpr;
 		joinrel->nullable_partexprs[cnt] = nullable_partexpr;
 	}
+
+	/* Partitions will be added by try_partitionwise_join. */
+	joinrel->live_parts = NULL;
 }
 
 /*
diff --git a/src/backend/partitioning/partprune.c b/src/backend/partitioning/partprune.c
index 9bb472fd98..088b191bdd 100644
--- a/src/backend/partitioning/partprune.c
+++ b/src/backend/partitioning/partprune.c
@@ -441,29 +441,21 @@ make_partitionedrel_pruneinfo(PlannerInfo *root, RelOptInfo *parentrel,
 		memset(subplan_map, -1, nparts * sizeof(int));
 		subpart_map = (int *) palloc(nparts * sizeof(int));
 		memset(subpart_map, -1, nparts * sizeof(int));
-		present_parts = NULL;
+		present_parts = bms_copy(subpart->live_parts);
 
-		for (i = 0; i < nparts; i++)
+		i = -1;
+		while ((i = bms_next_member(present_parts, i)) >= 0)
 		{
 			RelOptInfo *partrel = subpart->part_rels[i];
 			int			subplanidx;
 			int			subpartidx;
 
-			/* Skip processing pruned partitions. */
-			if (partrel == NULL)
-				continue;
-
+			Assert(partrel != NULL);
 			subplan_map[i] = subplanidx = relid_subplan_map[partrel->relid] - 1;
 			subpart_map[i] = subpartidx = relid_subpart_map[partrel->relid] - 1;
+			/* Record finding this subplan */
 			if (subplanidx >= 0)
-			{
-				present_parts = bms_add_member(present_parts, i);
-
-				/* Record finding this subplan  */
 				subplansfound = bms_add_member(subplansfound, subplanidx);
-			}
-			else if (subpartidx >= 0)
-				present_parts = bms_add_member(present_parts, i);
 		}
 
 		pinfo = makeNode(PartitionedRelPruneInfo);
diff --git a/src/include/nodes/relation.h b/src/include/nodes/relation.h
index 0303a454ce..a0a71fcd62 100644
--- a/src/include/nodes/relation.h
+++ b/src/include/nodes/relation.h
@@ -730,6 +730,10 @@ typedef struct RelOptInfo
 	Oid		   *part_oids;		/* partition OIDs */
 	struct RelOptInfo **part_rels;	/* Array of RelOptInfos of partitions,
 									 * stored in the same order of bounds */
+	Bitmapset  *live_parts;		/* Indexes into part_rels of the non-NULL
+								 * RelOptInfos of unpruned partitions; exists
+								 * to avoid having to iterate over the entire
+								 * part_rels array to filter NULL entries. */
 	List	  **partexprs;		/* Non-nullable partition key expressions. */
 	List	  **nullable_partexprs; /* Nullable partition key expressions. */
 	List	   *partitioned_child_rels; /* List of RT indexes. */
-- 
2.11.0

From bb09283379485fef01e94009c121181d4e086aa5 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Fri, 12 Oct 2018 19:12:53 +0900
Subject: [PATCH v11 6/6] Do not lock all partitions at the beginning

---
 src/backend/optimizer/util/inherit.c | 11 +----------
 1 file changed, 1 insertion(+), 10 deletions(-)

diff --git a/src/backend/optimizer/util/inherit.c b/src/backend/optimizer/util/inherit.c
index b3da21e6e8..9aeba5897d 100644
--- a/src/backend/optimizer/util/inherit.c
+++ b/src/backend/optimizer/util/inherit.c
@@ -317,10 +317,6 @@ expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti,
  *
  * Partitions are added to the query in order in which they are found in
  * the parent's PartitionDesc.
- *
- * Note: even though only the unpruned partitions will be added to the
- * resulting plan, this still locks *all* partitions via find_all_inheritors
- * when this function is called for the root partitioned table.
  */
 static void
 expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
@@ -334,10 +330,6 @@ expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
 									parentrel->inh_root_parent :
 									parentRTindex;
 
-	/* If root partitioned table, lock *all* partitions in the tree. */
-	if (parentRTindex == rootParentRTindex)
-		(void) find_all_inheritors(parentrte->relid, lockmode, NULL);
-
 	/*
 	 * Initialize partitioned_child_rels to contain this RT index.
 	 *
@@ -373,8 +365,7 @@ expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
 		RangeTblEntry *childrte;
 		Index		childRTindex;
 
-		/* Already locked above. */
-		newrelation = heap_open(childOID, NoLock);
+		newrelation = heap_open(childOID, lockmode);
 		Assert(!RELATION_IS_OTHER_TEMP(newrelation));
 
 		/*
-- 
2.11.0

From bc6f2af5d9fb09d2fb29cd2ac07ffdaa2fbaef26 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Thu, 10 Jan 2019 13:36:46 +0900
Subject: [PATCH v12 1/6] Move inheritance expansion code into its own file

This commit moves expand_inherited_tables and underlings currently
in optimizer/prep/prepunionc.c to optimizer/utils/inherit.c.

All of the AppendRelInfo based expression manipulation routines
are moved to optimizer/utils/appendinfo.c.

This commit mostly moves the code and contains no functional changes.
One exception though is the introduction of make_append_rel_info, but
it's still just moving around code.
---
 src/backend/optimizer/path/allpaths.c   |    2 +
 src/backend/optimizer/path/equivclass.c |    1 +
 src/backend/optimizer/path/joinrels.c   |    1 +
 src/backend/optimizer/plan/planmain.c   |    2 +
 src/backend/optimizer/plan/planner.c    |    2 +
 src/backend/optimizer/prep/prepunion.c  | 1202 -------------------------------
 src/backend/optimizer/util/Makefile     |    5 +-
 src/backend/optimizer/util/appendinfo.c |  824 +++++++++++++++++++++
 src/backend/optimizer/util/inherit.c    |  451 ++++++++++++
 src/backend/optimizer/util/pathnode.c   |    1 +
 src/backend/optimizer/util/relnode.c    |    1 +
 src/backend/partitioning/partprune.c    |    1 +
 src/include/optimizer/appendinfo.h      |   42 ++
 src/include/optimizer/inherit.h         |   25 +
 src/include/optimizer/prep.h            |   18 -
 15 files changed, 1356 insertions(+), 1222 deletions(-)
 create mode 100644 src/backend/optimizer/util/appendinfo.c
 create mode 100644 src/backend/optimizer/util/inherit.c
 create mode 100644 src/include/optimizer/appendinfo.h
 create mode 100644 src/include/optimizer/inherit.h

diff --git a/src/backend/optimizer/path/allpaths.c b/src/backend/optimizer/path/allpaths.c
index 256fe16cdb..8bd71a9825 100644
--- a/src/backend/optimizer/path/allpaths.c
+++ b/src/backend/optimizer/path/allpaths.c
@@ -30,6 +30,8 @@
 #ifdef OPTIMIZER_DEBUG
 #include "nodes/print.h"
 #endif
+#include "optimizer/inherit.h"
+#include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/geqo.h"
diff --git a/src/backend/optimizer/path/equivclass.c b/src/backend/optimizer/path/equivclass.c
index 0d994bd9ae..7fad7ad1bf 100644
--- a/src/backend/optimizer/path/equivclass.c
+++ b/src/backend/optimizer/path/equivclass.c
@@ -22,6 +22,7 @@
 #include "catalog/pg_type.h"
 #include "nodes/makefuncs.h"
 #include "nodes/nodeFuncs.h"
+#include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
 #include "optimizer/pathnode.h"
 #include "optimizer/paths.h"
diff --git a/src/backend/optimizer/path/joinrels.c b/src/backend/optimizer/path/joinrels.c
index 67b9ca83a7..22ca4d999a 100644
--- a/src/backend/optimizer/path/joinrels.c
+++ b/src/backend/optimizer/path/joinrels.c
@@ -15,6 +15,7 @@
 #include "postgres.h"
 
 #include "miscadmin.h"
+#include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
 #include "optimizer/joininfo.h"
 #include "optimizer/pathnode.h"
diff --git a/src/backend/optimizer/plan/planmain.c b/src/backend/optimizer/plan/planmain.c
index 0e0a543708..fc97a1bb50 100644
--- a/src/backend/optimizer/plan/planmain.c
+++ b/src/backend/optimizer/plan/planmain.c
@@ -20,7 +20,9 @@
  */
 #include "postgres.h"
 
+#include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
+#include "optimizer/inherit.h"
 #include "optimizer/orclauses.h"
 #include "optimizer/pathnode.h"
 #include "optimizer/paths.h"
diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index 3e33a17a5b..98acb58304 100644
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -37,8 +37,10 @@
 #ifdef OPTIMIZER_DEBUG
 #include "nodes/print.h"
 #endif
+#include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
 #include "optimizer/cost.h"
+#include "optimizer/inherit.h"
 #include "optimizer/pathnode.h"
 #include "optimizer/paths.h"
 #include "optimizer/plancat.h"
diff --git a/src/backend/optimizer/prep/prepunion.c b/src/backend/optimizer/prep/prepunion.c
index 1d280c205e..5d59385ef7 100644
--- a/src/backend/optimizer/prep/prepunion.c
+++ b/src/backend/optimizer/prep/prepunion.c
@@ -12,11 +12,6 @@
  * case, but most of the heavy lifting for that is done elsewhere,
  * notably in prepjointree.c and allpaths.c.
  *
- * There is also some code here to support planning of queries that use
- * inheritance (SELECT FROM foo*).  Inheritance trees are converted into
- * append relations, and thenceforth share code with the UNION ALL case.
- *
- *
  * Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
@@ -54,13 +49,6 @@
 #include "utils/syscache.h"
 
 
-typedef struct
-{
-	PlannerInfo *root;
-	int			nappinfos;
-	AppendRelInfo **appinfos;
-} adjust_appendrel_attrs_context;
-
 static RelOptInfo *recurse_set_operations(Node *setOp, PlannerInfo *root,
 					   List *colTypes, List *colCollations,
 					   bool junkOK,
@@ -99,31 +87,6 @@ static List *generate_append_tlist(List *colTypes, List *colCollations,
 					  List *input_tlists,
 					  List *refnames_tlist);
 static List *generate_setop_grouplist(SetOperationStmt *op, List *targetlist);
-static void expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte,
-						 Index rti);
-static void expand_partitioned_rtentry(PlannerInfo *root,
-						   RangeTblEntry *parentrte,
-						   Index parentRTindex, Relation parentrel,
-						   PlanRowMark *top_parentrc, LOCKMODE lockmode,
-						   List **appinfos);
-static void expand_single_inheritance_child(PlannerInfo *root,
-								RangeTblEntry *parentrte,
-								Index parentRTindex, Relation parentrel,
-								PlanRowMark *top_parentrc, Relation childrel,
-								List **appinfos, RangeTblEntry **childrte_p,
-								Index *childRTindex_p);
-static void make_inh_translation_list(Relation oldrelation,
-						  Relation newrelation,
-						  Index newvarno,
-						  List **translated_vars);
-static Bitmapset *translate_col_privs(const Bitmapset *parent_privs,
-					List *translated_vars);
-static Node *adjust_appendrel_attrs_mutator(Node *node,
-							   adjust_appendrel_attrs_context *context);
-static Relids adjust_child_relids(Relids relids, int nappinfos,
-					AppendRelInfo **appinfos);
-static List *adjust_inherited_tlist(List *tlist,
-					   AppendRelInfo *context);
 
 
 /*
@@ -1460,1168 +1423,3 @@ generate_setop_grouplist(SetOperationStmt *op, List *targetlist)
 	Assert(lg == NULL);
 	return grouplist;
 }
-
-
-/*
- * expand_inherited_tables
- *		Expand each rangetable entry that represents an inheritance set
- *		into an "append relation".  At the conclusion of this process,
- *		the "inh" flag is set in all and only those RTEs that are append
- *		relation parents.
- */
-void
-expand_inherited_tables(PlannerInfo *root)
-{
-	Index		nrtes;
-	Index		rti;
-	ListCell   *rl;
-
-	/*
-	 * expand_inherited_rtentry may add RTEs to parse->rtable. The function is
-	 * expected to recursively handle any RTEs that it creates with inh=true.
-	 * So just scan as far as the original end of the rtable list.
-	 */
-	nrtes = list_length(root->parse->rtable);
-	rl = list_head(root->parse->rtable);
-	for (rti = 1; rti <= nrtes; rti++)
-	{
-		RangeTblEntry *rte = (RangeTblEntry *) lfirst(rl);
-
-		expand_inherited_rtentry(root, rte, rti);
-		rl = lnext(rl);
-	}
-}
-
-/*
- * expand_inherited_rtentry
- *		Check whether a rangetable entry represents an inheritance set.
- *		If so, add entries for all the child tables to the query's
- *		rangetable, and build AppendRelInfo nodes for all the child tables
- *		and add them to root->append_rel_list.  If not, clear the entry's
- *		"inh" flag to prevent later code from looking for AppendRelInfos.
- *
- * Note that the original RTE is considered to represent the whole
- * inheritance set.  The first of the generated RTEs is an RTE for the same
- * table, but with inh = false, to represent the parent table in its role
- * as a simple member of the inheritance set.
- *
- * A childless table is never considered to be an inheritance set. For
- * regular inheritance, a parent RTE must always have at least two associated
- * AppendRelInfos: one corresponding to the parent table as a simple member of
- * inheritance set and one or more corresponding to the actual children.
- * Since a partitioned table is not scanned, it might have only one associated
- * AppendRelInfo.
- */
-static void
-expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti)
-{
-	Oid			parentOID;
-	PlanRowMark *oldrc;
-	Relation	oldrelation;
-	LOCKMODE	lockmode;
-	List	   *inhOIDs;
-	ListCell   *l;
-
-	/* Does RT entry allow inheritance? */
-	if (!rte->inh)
-		return;
-	/* Ignore any already-expanded UNION ALL nodes */
-	if (rte->rtekind != RTE_RELATION)
-	{
-		Assert(rte->rtekind == RTE_SUBQUERY);
-		return;
-	}
-	/* Fast path for common case of childless table */
-	parentOID = rte->relid;
-	if (!has_subclass(parentOID))
-	{
-		/* Clear flag before returning */
-		rte->inh = false;
-		return;
-	}
-
-	/*
-	 * The rewriter should already have obtained an appropriate lock on each
-	 * relation named in the query.  However, for each child relation we add
-	 * to the query, we must obtain an appropriate lock, because this will be
-	 * the first use of those relations in the parse/rewrite/plan pipeline.
-	 * Child rels should use the same lockmode as their parent.
-	 */
-	lockmode = rte->rellockmode;
-
-	/* Scan for all members of inheritance set, acquire needed locks */
-	inhOIDs = find_all_inheritors(parentOID, lockmode, NULL);
-
-	/*
-	 * Check that there's at least one descendant, else treat as no-child
-	 * case.  This could happen despite above has_subclass() check, if table
-	 * once had a child but no longer does.
-	 */
-	if (list_length(inhOIDs) < 2)
-	{
-		/* Clear flag before returning */
-		rte->inh = false;
-		return;
-	}
-
-	/*
-	 * If parent relation is selected FOR UPDATE/SHARE, we need to mark its
-	 * PlanRowMark as isParent = true, and generate a new PlanRowMark for each
-	 * child.
-	 */
-	oldrc = get_plan_rowmark(root->rowMarks, rti);
-	if (oldrc)
-		oldrc->isParent = true;
-
-	/*
-	 * Must open the parent relation to examine its tupdesc.  We need not lock
-	 * it; we assume the rewriter already did.
-	 */
-	oldrelation = heap_open(parentOID, NoLock);
-
-	/* Scan the inheritance set and expand it */
-	if (RelationGetPartitionDesc(oldrelation) != NULL)
-	{
-		Assert(rte->relkind == RELKIND_PARTITIONED_TABLE);
-
-		/*
-		 * If this table has partitions, recursively expand them in the order
-		 * in which they appear in the PartitionDesc.  While at it, also
-		 * extract the partition key columns of all the partitioned tables.
-		 */
-		expand_partitioned_rtentry(root, rte, rti, oldrelation, oldrc,
-								   lockmode, &root->append_rel_list);
-	}
-	else
-	{
-		List	   *appinfos = NIL;
-		RangeTblEntry *childrte;
-		Index		childRTindex;
-
-		/*
-		 * This table has no partitions.  Expand any plain inheritance
-		 * children in the order the OIDs were returned by
-		 * find_all_inheritors.
-		 */
-		foreach(l, inhOIDs)
-		{
-			Oid			childOID = lfirst_oid(l);
-			Relation	newrelation;
-
-			/* Open rel if needed; we already have required locks */
-			if (childOID != parentOID)
-				newrelation = heap_open(childOID, NoLock);
-			else
-				newrelation = oldrelation;
-
-			/*
-			 * It is possible that the parent table has children that are temp
-			 * tables of other backends.  We cannot safely access such tables
-			 * (because of buffering issues), and the best thing to do seems
-			 * to be to silently ignore them.
-			 */
-			if (childOID != parentOID && RELATION_IS_OTHER_TEMP(newrelation))
-			{
-				heap_close(newrelation, lockmode);
-				continue;
-			}
-
-			expand_single_inheritance_child(root, rte, rti, oldrelation, oldrc,
-											newrelation,
-											&appinfos, &childrte,
-											&childRTindex);
-
-			/* Close child relations, but keep locks */
-			if (childOID != parentOID)
-				heap_close(newrelation, NoLock);
-		}
-
-		/*
-		 * If all the children were temp tables, pretend it's a
-		 * non-inheritance situation; we don't need Append node in that case.
-		 * The duplicate RTE we added for the parent table is harmless, so we
-		 * don't bother to get rid of it; ditto for the useless PlanRowMark
-		 * node.
-		 */
-		if (list_length(appinfos) < 2)
-			rte->inh = false;
-		else
-			root->append_rel_list = list_concat(root->append_rel_list,
-												appinfos);
-
-	}
-
-	heap_close(oldrelation, NoLock);
-}
-
-/*
- * expand_partitioned_rtentry
- *		Recursively expand an RTE for a partitioned table.
- */
-static void
-expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
-						   Index parentRTindex, Relation parentrel,
-						   PlanRowMark *top_parentrc, LOCKMODE lockmode,
-						   List **appinfos)
-{
-	int			i;
-	RangeTblEntry *childrte;
-	Index		childRTindex;
-	PartitionDesc partdesc = RelationGetPartitionDesc(parentrel);
-
-	check_stack_depth();
-
-	/* A partitioned table should always have a partition descriptor. */
-	Assert(partdesc);
-
-	Assert(parentrte->inh);
-
-	/*
-	 * Note down whether any partition key cols are being updated. Though it's
-	 * the root partitioned table's updatedCols we are interested in, we
-	 * instead use parentrte to get the updatedCols. This is convenient
-	 * because parentrte already has the root partrel's updatedCols translated
-	 * to match the attribute ordering of parentrel.
-	 */
-	if (!root->partColsUpdated)
-		root->partColsUpdated =
-			has_partition_attrs(parentrel, parentrte->updatedCols, NULL);
-
-	/* First expand the partitioned table itself. */
-	expand_single_inheritance_child(root, parentrte, parentRTindex, parentrel,
-									top_parentrc, parentrel,
-									appinfos, &childrte, &childRTindex);
-
-	/*
-	 * If the partitioned table has no partitions, treat this as the
-	 * non-inheritance case.
-	 */
-	if (partdesc->nparts == 0)
-	{
-		parentrte->inh = false;
-		return;
-	}
-
-	for (i = 0; i < partdesc->nparts; i++)
-	{
-		Oid			childOID = partdesc->oids[i];
-		Relation	childrel;
-
-		/* Open rel; we already have required locks */
-		childrel = heap_open(childOID, NoLock);
-
-		/*
-		 * Temporary partitions belonging to other sessions should have been
-		 * disallowed at definition, but for paranoia's sake, let's double
-		 * check.
-		 */
-		if (RELATION_IS_OTHER_TEMP(childrel))
-			elog(ERROR, "temporary relation from another session found as partition");
-
-		expand_single_inheritance_child(root, parentrte, parentRTindex,
-										parentrel, top_parentrc, childrel,
-										appinfos, &childrte, &childRTindex);
-
-		/* If this child is itself partitioned, recurse */
-		if (childrel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
-			expand_partitioned_rtentry(root, childrte, childRTindex,
-									   childrel, top_parentrc, lockmode,
-									   appinfos);
-
-		/* Close child relation, but keep locks */
-		heap_close(childrel, NoLock);
-	}
-}
-
-/*
- * expand_single_inheritance_child
- *		Build a RangeTblEntry and an AppendRelInfo, if appropriate, plus
- *		maybe a PlanRowMark.
- *
- * We now expand the partition hierarchy level by level, creating a
- * corresponding hierarchy of AppendRelInfos and RelOptInfos, where each
- * partitioned descendant acts as a parent of its immediate partitions.
- * (This is a difference from what older versions of PostgreSQL did and what
- * is still done in the case of table inheritance for unpartitioned tables,
- * where the hierarchy is flattened during RTE expansion.)
- *
- * PlanRowMarks still carry the top-parent's RTI, and the top-parent's
- * allMarkTypes field still accumulates values from all descendents.
- *
- * "parentrte" and "parentRTindex" are immediate parent's RTE and
- * RTI. "top_parentrc" is top parent's PlanRowMark.
- *
- * The child RangeTblEntry and its RTI are returned in "childrte_p" and
- * "childRTindex_p" resp.
- */
-static void
-expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte,
-								Index parentRTindex, Relation parentrel,
-								PlanRowMark *top_parentrc, Relation childrel,
-								List **appinfos, RangeTblEntry **childrte_p,
-								Index *childRTindex_p)
-{
-	Query	   *parse = root->parse;
-	Oid			parentOID = RelationGetRelid(parentrel);
-	Oid			childOID = RelationGetRelid(childrel);
-	RangeTblEntry *childrte;
-	Index		childRTindex;
-	AppendRelInfo *appinfo;
-
-	/*
-	 * Build an RTE for the child, and attach to query's rangetable list. We
-	 * copy most fields of the parent's RTE, but replace relation OID and
-	 * relkind, and set inh = false.  Also, set requiredPerms to zero since
-	 * all required permissions checks are done on the original RTE. Likewise,
-	 * set the child's securityQuals to empty, because we only want to apply
-	 * the parent's RLS conditions regardless of what RLS properties
-	 * individual children may have.  (This is an intentional choice to make
-	 * inherited RLS work like regular permissions checks.) The parent
-	 * securityQuals will be propagated to children along with other base
-	 * restriction clauses, so we don't need to do it here.
-	 */
-	childrte = copyObject(parentrte);
-	*childrte_p = childrte;
-	childrte->relid = childOID;
-	childrte->relkind = childrel->rd_rel->relkind;
-	/* A partitioned child will need to be expanded further. */
-	if (childOID != parentOID &&
-		childrte->relkind == RELKIND_PARTITIONED_TABLE)
-		childrte->inh = true;
-	else
-		childrte->inh = false;
-	childrte->requiredPerms = 0;
-	childrte->securityQuals = NIL;
-	parse->rtable = lappend(parse->rtable, childrte);
-	childRTindex = list_length(parse->rtable);
-	*childRTindex_p = childRTindex;
-
-	/*
-	 * We need an AppendRelInfo if paths will be built for the child RTE. If
-	 * childrte->inh is true, then we'll always need to generate append paths
-	 * for it.  If childrte->inh is false, we must scan it if it's not a
-	 * partitioned table; but if it is a partitioned table, then it never has
-	 * any data of its own and need not be scanned.
-	 */
-	if (childrte->relkind != RELKIND_PARTITIONED_TABLE || childrte->inh)
-	{
-		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->translated_vars);
-		appinfo->parent_reloid = parentOID;
-		*appinfos = lappend(*appinfos, appinfo);
-
-		/*
-		 * Translate the column permissions bitmaps to the child's attnums (we
-		 * have to build the translated_vars list before we can do this). But
-		 * if this is the parent table, leave copyObject's result alone.
-		 *
-		 * Note: we need to do this even though the executor won't run any
-		 * permissions checks on the child RTE.  The insertedCols/updatedCols
-		 * bitmaps may be examined for trigger-firing purposes.
-		 */
-		if (childOID != parentOID)
-		{
-			childrte->selectedCols = translate_col_privs(parentrte->selectedCols,
-														 appinfo->translated_vars);
-			childrte->insertedCols = translate_col_privs(parentrte->insertedCols,
-														 appinfo->translated_vars);
-			childrte->updatedCols = translate_col_privs(parentrte->updatedCols,
-														appinfo->translated_vars);
-		}
-	}
-
-	/*
-	 * Build a PlanRowMark if parent is marked FOR UPDATE/SHARE.
-	 */
-	if (top_parentrc)
-	{
-		PlanRowMark *childrc = makeNode(PlanRowMark);
-
-		childrc->rti = childRTindex;
-		childrc->prti = top_parentrc->rti;
-		childrc->rowmarkId = top_parentrc->rowmarkId;
-		/* Reselect rowmark type, because relkind might not match parent */
-		childrc->markType = select_rowmark_type(childrte,
-												top_parentrc->strength);
-		childrc->allMarkTypes = (1 << childrc->markType);
-		childrc->strength = top_parentrc->strength;
-		childrc->waitPolicy = top_parentrc->waitPolicy;
-
-		/*
-		 * We mark RowMarks for partitioned child tables as parent RowMarks so
-		 * that the executor ignores them (except their existence means that
-		 * the child tables be locked using appropriate mode).
-		 */
-		childrc->isParent = (childrte->relkind == RELKIND_PARTITIONED_TABLE);
-
-		/* Include child's rowmark type in top parent's allMarkTypes */
-		top_parentrc->allMarkTypes |= childrc->allMarkTypes;
-
-		root->rowMarks = lappend(root->rowMarks, childrc);
-	}
-}
-
-/*
- * make_inh_translation_list
- *	  Build the list of translations from parent Vars to child Vars for
- *	  an inheritance child.
- *
- * For paranoia's sake, we match type/collation as well as attribute name.
- */
-static void
-make_inh_translation_list(Relation oldrelation, Relation newrelation,
-						  Index newvarno,
-						  List **translated_vars)
-{
-	List	   *vars = NIL;
-	TupleDesc	old_tupdesc = RelationGetDescr(oldrelation);
-	TupleDesc	new_tupdesc = RelationGetDescr(newrelation);
-	Oid			new_relid = RelationGetRelid(newrelation);
-	int			oldnatts = old_tupdesc->natts;
-	int			newnatts = new_tupdesc->natts;
-	int			old_attno;
-	int			new_attno = 0;
-
-	for (old_attno = 0; old_attno < oldnatts; old_attno++)
-	{
-		Form_pg_attribute att;
-		char	   *attname;
-		Oid			atttypid;
-		int32		atttypmod;
-		Oid			attcollation;
-
-		att = TupleDescAttr(old_tupdesc, old_attno);
-		if (att->attisdropped)
-		{
-			/* Just put NULL into this list entry */
-			vars = lappend(vars, NULL);
-			continue;
-		}
-		attname = NameStr(att->attname);
-		atttypid = att->atttypid;
-		atttypmod = att->atttypmod;
-		attcollation = att->attcollation;
-
-		/*
-		 * When we are generating the "translation list" for the parent table
-		 * of an inheritance set, no need to search for matches.
-		 */
-		if (oldrelation == newrelation)
-		{
-			vars = lappend(vars, makeVar(newvarno,
-										 (AttrNumber) (old_attno + 1),
-										 atttypid,
-										 atttypmod,
-										 attcollation,
-										 0));
-			continue;
-		}
-
-		/*
-		 * Otherwise we have to search for the matching column by name.
-		 * There's no guarantee it'll have the same column position, because
-		 * of cases like ALTER TABLE ADD COLUMN and multiple inheritance.
-		 * However, in simple cases, the relative order of columns is mostly
-		 * the same in both relations, so try the column of newrelation that
-		 * follows immediately after the one that we just found, and if that
-		 * fails, let syscache handle it.
-		 */
-		if (new_attno >= newnatts ||
-			(att = TupleDescAttr(new_tupdesc, new_attno))->attisdropped ||
-			strcmp(attname, NameStr(att->attname)) != 0)
-		{
-			HeapTuple	newtup;
-
-			newtup = SearchSysCacheAttName(new_relid, attname);
-			if (!newtup)
-				elog(ERROR, "could not find inherited attribute \"%s\" of relation \"%s\"",
-					 attname, RelationGetRelationName(newrelation));
-			new_attno = ((Form_pg_attribute) GETSTRUCT(newtup))->attnum - 1;
-			ReleaseSysCache(newtup);
-
-			att = TupleDescAttr(new_tupdesc, new_attno);
-		}
-
-		/* Found it, check type and collation match */
-		if (atttypid != att->atttypid || atttypmod != att->atttypmod)
-			elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's type",
-				 attname, RelationGetRelationName(newrelation));
-		if (attcollation != att->attcollation)
-			elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's collation",
-				 attname, RelationGetRelationName(newrelation));
-
-		vars = lappend(vars, makeVar(newvarno,
-									 (AttrNumber) (new_attno + 1),
-									 atttypid,
-									 atttypmod,
-									 attcollation,
-									 0));
-		new_attno++;
-	}
-
-	*translated_vars = vars;
-}
-
-/*
- * translate_col_privs
- *	  Translate a bitmapset representing per-column privileges from the
- *	  parent rel's attribute numbering to the child's.
- *
- * The only surprise here is that we don't translate a parent whole-row
- * reference into a child whole-row reference.  That would mean requiring
- * permissions on all child columns, which is overly strict, since the
- * query is really only going to reference the inherited columns.  Instead
- * we set the per-column bits for all inherited columns.
- */
-static Bitmapset *
-translate_col_privs(const Bitmapset *parent_privs,
-					List *translated_vars)
-{
-	Bitmapset  *child_privs = NULL;
-	bool		whole_row;
-	int			attno;
-	ListCell   *lc;
-
-	/* System attributes have the same numbers in all tables */
-	for (attno = FirstLowInvalidHeapAttributeNumber + 1; attno < 0; attno++)
-	{
-		if (bms_is_member(attno - FirstLowInvalidHeapAttributeNumber,
-						  parent_privs))
-			child_privs = bms_add_member(child_privs,
-										 attno - FirstLowInvalidHeapAttributeNumber);
-	}
-
-	/* Check if parent has whole-row reference */
-	whole_row = bms_is_member(InvalidAttrNumber - FirstLowInvalidHeapAttributeNumber,
-							  parent_privs);
-
-	/* And now translate the regular user attributes, using the vars list */
-	attno = InvalidAttrNumber;
-	foreach(lc, translated_vars)
-	{
-		Var		   *var = lfirst_node(Var, lc);
-
-		attno++;
-		if (var == NULL)		/* ignore dropped columns */
-			continue;
-		if (whole_row ||
-			bms_is_member(attno - FirstLowInvalidHeapAttributeNumber,
-						  parent_privs))
-			child_privs = bms_add_member(child_privs,
-										 var->varattno - FirstLowInvalidHeapAttributeNumber);
-	}
-
-	return child_privs;
-}
-
-/*
- * adjust_appendrel_attrs
- *	  Copy the specified query or expression and translate Vars referring to a
- *	  parent rel to refer to the corresponding child rel instead.  We also
- *	  update rtindexes appearing outside Vars, such as resultRelation and
- *	  jointree relids.
- *
- * Note: this is only applied after conversion of sublinks to subplans,
- * so we don't need to cope with recursion into sub-queries.
- *
- * Note: this is not hugely different from what pullup_replace_vars() does;
- * maybe we should try to fold the two routines together.
- */
-Node *
-adjust_appendrel_attrs(PlannerInfo *root, Node *node, int nappinfos,
-					   AppendRelInfo **appinfos)
-{
-	Node	   *result;
-	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);
-
-	/*
-	 * Must be prepared to start with a Query or a bare expression tree.
-	 */
-	if (node && IsA(node, Query))
-	{
-		Query	   *newnode;
-		int			cnt;
-
-		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;
-}
-
-static Node *
-adjust_appendrel_attrs_mutator(Node *node,
-							   adjust_appendrel_attrs_context *context)
-{
-	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;
-
-		for (cnt = 0; cnt < nappinfos; cnt++)
-		{
-			if (var->varno == appinfos[cnt]->parent_relid)
-			{
-				appinfo = appinfos[cnt];
-				break;
-			}
-		}
-
-		if (var->varlevelsup == 0 && appinfo)
-		{
-			var->varno = appinfo->child_relid;
-			var->varnoold = appinfo->child_relid;
-			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));
-				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;
-
-					return (Node *) rowexpr;
-				}
-			}
-			/* system attributes don't need any other translation */
-		}
-		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, 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 */
-		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, context->nappinfos,
-											  context->appinfos);
-		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 */
-		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->nullable_relids = adjust_child_relids(oldinfo->nullable_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));
-
-	return expression_tree_mutator(node, adjust_appendrel_attrs_mutator,
-								   (void *) context);
-}
-
-/*
- * Substitute child relids for parent relids in a Relid set.  The array of
- * appinfos specifies the substitutions to be performed.
- */
-static Relids
-adjust_child_relids(Relids relids, int nappinfos, AppendRelInfo **appinfos)
-{
-	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;
-}
-
-/*
- * Replace any relid present in top_parent_relids with its child in
- * child_relids. Members of child_relids can be multiple levels below top
- * parent in the partition hierarchy.
- */
-Relids
-adjust_child_relids_multilevel(PlannerInfo *root, Relids relids,
-							   Relids child_relids, Relids top_parent_relids)
-{
-	AppendRelInfo **appinfos;
-	int			nappinfos;
-	Relids		parent_relids = NULL;
-	Relids		result;
-	Relids		tmp_result = NULL;
-	int			cnt;
-
-	/*
-	 * If the given relids set doesn't contain any of the top parent relids,
-	 * it will remain unchanged.
-	 */
-	if (!bms_overlap(relids, top_parent_relids))
-		return relids;
-
-	appinfos = find_appinfos_by_relids(root, child_relids, &nappinfos);
-
-	/* Construct relids set for the immediate parent of the given child. */
-	for (cnt = 0; cnt < nappinfos; cnt++)
-	{
-		AppendRelInfo *appinfo = appinfos[cnt];
-
-		parent_relids = bms_add_member(parent_relids, appinfo->parent_relid);
-	}
-
-	/* Recurse if immediate parent is not the top parent. */
-	if (!bms_equal(parent_relids, top_parent_relids))
-	{
-		tmp_result = adjust_child_relids_multilevel(root, relids,
-													parent_relids,
-													top_parent_relids);
-		relids = tmp_result;
-	}
-
-	result = adjust_child_relids(relids, nappinfos, appinfos);
-
-	/* Free memory consumed by any intermediate result. */
-	if (tmp_result)
-		bms_free(tmp_result);
-	bms_free(parent_relids);
-	pfree(appinfos);
-
-	return result;
-}
-
-/*
- * 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.
- */
-static List *
-adjust_inherited_tlist(List *tlist, AppendRelInfo *context)
-{
-	bool		changed_it = false;
-	ListCell   *tl;
-	List	   *new_tlist;
-	bool		more;
-	int			attrno;
-
-	/* 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)
-	{
-		TargetEntry *tle = (TargetEntry *) lfirst(tl);
-		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))
-			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);
-		if (childvar == NULL || !IsA(childvar, Var))
-			elog(ERROR, "attribute %d of relation \"%s\" does not exist",
-				 tle->resno, get_rel_name(context->parent_reloid));
-
-		if (tle->resno != childvar->varattno)
-		{
-			tle->resno = childvar->varattno;
-			changed_it = true;
-		}
-	}
-
-	/*
-	 * 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;
-
-	new_tlist = NIL;
-	more = true;
-	for (attrno = 1; more; attrno++)
-	{
-		more = false;
-		foreach(tl, tlist)
-		{
-			TargetEntry *tle = (TargetEntry *) lfirst(tl);
-
-			if (tle->resjunk)
-				continue;		/* ignore junk items */
-
-			if (tle->resno == attrno)
-				new_tlist = lappend(new_tlist, tle);
-			else if (tle->resno > attrno)
-				more = true;
-		}
-	}
-
-	foreach(tl, tlist)
-	{
-		TargetEntry *tle = (TargetEntry *) lfirst(tl);
-
-		if (!tle->resjunk)
-			continue;			/* here, ignore non-junk items */
-
-		tle->resno = attrno;
-		new_tlist = lappend(new_tlist, tle);
-		attrno++;
-	}
-
-	return new_tlist;
-}
-
-/*
- * adjust_appendrel_attrs_multilevel
- *	  Apply Var translations from a toplevel appendrel parent down to a child.
- *
- * In some cases we need to translate expressions referencing a parent relation
- * to reference an appendrel child that's multiple levels removed from it.
- */
-Node *
-adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node,
-								  Relids child_relids,
-								  Relids top_parent_relids)
-{
-	AppendRelInfo **appinfos;
-	Bitmapset  *parent_relids = NULL;
-	int			nappinfos;
-	int			cnt;
-
-	Assert(bms_num_members(child_relids) == bms_num_members(top_parent_relids));
-
-	appinfos = find_appinfos_by_relids(root, child_relids, &nappinfos);
-
-	/* Construct relids set for the immediate parent of given child. */
-	for (cnt = 0; cnt < nappinfos; cnt++)
-	{
-		AppendRelInfo *appinfo = appinfos[cnt];
-
-		parent_relids = bms_add_member(parent_relids, appinfo->parent_relid);
-	}
-
-	/* Recurse if immediate parent is not the top parent. */
-	if (!bms_equal(parent_relids, top_parent_relids))
-		node = adjust_appendrel_attrs_multilevel(root, node, parent_relids,
-												 top_parent_relids);
-
-	/* Now translate for this child */
-	node = adjust_appendrel_attrs(root, node, nappinfos, appinfos);
-
-	pfree(appinfos);
-
-	return node;
-}
-
-/*
- * Construct the SpecialJoinInfo for a child-join by translating
- * SpecialJoinInfo for the join between parents. left_relids and right_relids
- * are the relids of left and right side of the join respectively.
- */
-SpecialJoinInfo *
-build_child_join_sjinfo(PlannerInfo *root, SpecialJoinInfo *parent_sjinfo,
-						Relids left_relids, Relids right_relids)
-{
-	SpecialJoinInfo *sjinfo = makeNode(SpecialJoinInfo);
-	AppendRelInfo **left_appinfos;
-	int			left_nappinfos;
-	AppendRelInfo **right_appinfos;
-	int			right_nappinfos;
-
-	memcpy(sjinfo, parent_sjinfo, sizeof(SpecialJoinInfo));
-	left_appinfos = find_appinfos_by_relids(root, left_relids,
-											&left_nappinfos);
-	right_appinfos = find_appinfos_by_relids(root, right_relids,
-											 &right_nappinfos);
-
-	sjinfo->min_lefthand = adjust_child_relids(sjinfo->min_lefthand,
-											   left_nappinfos, left_appinfos);
-	sjinfo->min_righthand = adjust_child_relids(sjinfo->min_righthand,
-												right_nappinfos,
-												right_appinfos);
-	sjinfo->syn_lefthand = adjust_child_relids(sjinfo->syn_lefthand,
-											   left_nappinfos, left_appinfos);
-	sjinfo->syn_righthand = adjust_child_relids(sjinfo->syn_righthand,
-												right_nappinfos,
-												right_appinfos);
-	sjinfo->semi_rhs_exprs = (List *) adjust_appendrel_attrs(root,
-															 (Node *) sjinfo->semi_rhs_exprs,
-															 right_nappinfos,
-															 right_appinfos);
-
-	pfree(left_appinfos);
-	pfree(right_appinfos);
-
-	return sjinfo;
-}
-
-/*
- * find_appinfos_by_relids
- * 		Find AppendRelInfo structures for all relations specified by relids.
- *
- * The AppendRelInfos are returned in an array, which can be pfree'd by the
- * caller. *nappinfos is set to the number of entries in the array.
- */
-AppendRelInfo **
-find_appinfos_by_relids(PlannerInfo *root, Relids relids, int *nappinfos)
-{
-	AppendRelInfo **appinfos;
-	int			cnt = 0;
-	int			i;
-
-	*nappinfos = bms_num_members(relids);
-	appinfos = (AppendRelInfo **) palloc(sizeof(AppendRelInfo *) * *nappinfos);
-
-	i = -1;
-	while ((i = bms_next_member(relids, i)) >= 0)
-	{
-		AppendRelInfo *appinfo = root->append_rel_array[i];
-
-		if (!appinfo)
-			elog(ERROR, "child rel %d not found in append_rel_array", i);
-
-		appinfos[cnt++] = appinfo;
-	}
-	return appinfos;
-}
diff --git a/src/backend/optimizer/util/Makefile b/src/backend/optimizer/util/Makefile
index c54d0a690d..adffb01226 100644
--- a/src/backend/optimizer/util/Makefile
+++ b/src/backend/optimizer/util/Makefile
@@ -12,7 +12,8 @@ subdir = src/backend/optimizer/util
 top_builddir = ../../../..
 include $(top_builddir)/src/Makefile.global
 
-OBJS = clauses.o joininfo.o orclauses.o pathnode.o placeholder.o \
-       plancat.o predtest.o relnode.o restrictinfo.o tlist.o var.o
+OBJS = appendinfo.o clauses.o inherit.o joininfo.o orclauses.o pathnode.o \
+       placeholder.o plancat.o predtest.o relnode.o restrictinfo.o tlist.o \
+       var.o
 
 include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/optimizer/util/appendinfo.c b/src/backend/optimizer/util/appendinfo.c
new file mode 100644
index 0000000000..01040c5cfe
--- /dev/null
+++ b/src/backend/optimizer/util/appendinfo.c
@@ -0,0 +1,824 @@
+/*-------------------------------------------------------------------------
+ *
+ * appendinfo.c
+ *	  Routines for mapping between append parent(s) and children
+ *
+ * Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/optimizer/path/appendinfo.c
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include "access/htup_details.h"
+#include "access/sysattr.h"
+#include "nodes/makefuncs.h"
+#include "nodes/nodeFuncs.h"
+#include "optimizer/appendinfo.h"
+#include "parser/parsetree.h"
+#include "utils/rel.h"
+#include "utils/lsyscache.h"
+#include "utils/syscache.h"
+
+typedef struct
+{
+	PlannerInfo *root;
+	int			nappinfos;
+	AppendRelInfo **appinfos;
+} adjust_appendrel_attrs_context;
+
+static void make_inh_translation_list(Relation oldrelation,
+						  Relation newrelation,
+						  Index newvarno,
+						  List **translated_vars);
+static Node *adjust_appendrel_attrs_mutator(Node *node,
+							   adjust_appendrel_attrs_context *context);
+static Relids adjust_child_relids(Relids relids, int nappinfos,
+					AppendRelInfo **appinfos);
+static List *adjust_inherited_tlist(List *tlist,
+					   AppendRelInfo *context);
+
+/*
+ * make_append_rel_info
+ *	  Build an AppendRelInfo for the parent-child pair
+ */
+AppendRelInfo *
+make_append_rel_info(Relation parentrel, Relation childrel,
+					 Index parentRTindex, Index childRTindex)
+{
+	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->translated_vars);
+	appinfo->parent_reloid = RelationGetRelid(parentrel);
+
+	return appinfo;
+}
+
+/*
+ * make_inh_translation_list
+ *	  Build the list of translations from parent Vars to child Vars for
+ *	  an inheritance child.
+ *
+ * For paranoia's sake, we match type/collation as well as attribute name.
+ */
+static void
+make_inh_translation_list(Relation oldrelation, Relation newrelation,
+						  Index newvarno,
+						  List **translated_vars)
+{
+	List	   *vars = NIL;
+	TupleDesc	old_tupdesc = RelationGetDescr(oldrelation);
+	TupleDesc	new_tupdesc = RelationGetDescr(newrelation);
+	Oid			new_relid = RelationGetRelid(newrelation);
+	int			oldnatts = old_tupdesc->natts;
+	int			newnatts = new_tupdesc->natts;
+	int			old_attno;
+	int			new_attno = 0;
+
+	for (old_attno = 0; old_attno < oldnatts; old_attno++)
+	{
+		Form_pg_attribute att;
+		char	   *attname;
+		Oid			atttypid;
+		int32		atttypmod;
+		Oid			attcollation;
+
+		att = TupleDescAttr(old_tupdesc, old_attno);
+		if (att->attisdropped)
+		{
+			/* Just put NULL into this list entry */
+			vars = lappend(vars, NULL);
+			continue;
+		}
+		attname = NameStr(att->attname);
+		atttypid = att->atttypid;
+		atttypmod = att->atttypmod;
+		attcollation = att->attcollation;
+
+		/*
+		 * When we are generating the "translation list" for the parent table
+		 * of an inheritance set, no need to search for matches.
+		 */
+		if (oldrelation == newrelation)
+		{
+			vars = lappend(vars, makeVar(newvarno,
+										 (AttrNumber) (old_attno + 1),
+										 atttypid,
+										 atttypmod,
+										 attcollation,
+										 0));
+			continue;
+		}
+
+		/*
+		 * Otherwise we have to search for the matching column by name.
+		 * There's no guarantee it'll have the same column position, because
+		 * of cases like ALTER TABLE ADD COLUMN and multiple inheritance.
+		 * However, in simple cases, the relative order of columns is mostly
+		 * the same in both relations, so try the column of newrelation that
+		 * follows immediately after the one that we just found, and if that
+		 * fails, let syscache handle it.
+		 */
+		if (new_attno >= newnatts ||
+			(att = TupleDescAttr(new_tupdesc, new_attno))->attisdropped ||
+			strcmp(attname, NameStr(att->attname)) != 0)
+		{
+			HeapTuple	newtup;
+
+			newtup = SearchSysCacheAttName(new_relid, attname);
+			if (!newtup)
+				elog(ERROR, "could not find inherited attribute \"%s\" of relation \"%s\"",
+					 attname, RelationGetRelationName(newrelation));
+			new_attno = ((Form_pg_attribute) GETSTRUCT(newtup))->attnum - 1;
+			ReleaseSysCache(newtup);
+
+			att = TupleDescAttr(new_tupdesc, new_attno);
+		}
+
+		/* Found it, check type and collation match */
+		if (atttypid != att->atttypid || atttypmod != att->atttypmod)
+			elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's type",
+				 attname, RelationGetRelationName(newrelation));
+		if (attcollation != att->attcollation)
+			elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's collation",
+				 attname, RelationGetRelationName(newrelation));
+
+		vars = lappend(vars, makeVar(newvarno,
+									 (AttrNumber) (new_attno + 1),
+									 atttypid,
+									 atttypmod,
+									 attcollation,
+									 0));
+		new_attno++;
+	}
+
+	*translated_vars = vars;
+}
+
+/*
+ * translate_col_privs
+ *	  Translate a bitmapset representing per-column privileges from the
+ *	  parent rel's attribute numbering to the child's.
+ *
+ * The only surprise here is that we don't translate a parent whole-row
+ * reference into a child whole-row reference.  That would mean requiring
+ * permissions on all child columns, which is overly strict, since the
+ * query is really only going to reference the inherited columns.  Instead
+ * we set the per-column bits for all inherited columns.
+ */
+Bitmapset *
+translate_col_privs(const Bitmapset *parent_privs,
+					List *translated_vars)
+{
+	Bitmapset  *child_privs = NULL;
+	bool		whole_row;
+	int			attno;
+	ListCell   *lc;
+
+	/* System attributes have the same numbers in all tables */
+	for (attno = FirstLowInvalidHeapAttributeNumber + 1; attno < 0; attno++)
+	{
+		if (bms_is_member(attno - FirstLowInvalidHeapAttributeNumber,
+						  parent_privs))
+			child_privs = bms_add_member(child_privs,
+										 attno - FirstLowInvalidHeapAttributeNumber);
+	}
+
+	/* Check if parent has whole-row reference */
+	whole_row = bms_is_member(InvalidAttrNumber - FirstLowInvalidHeapAttributeNumber,
+							  parent_privs);
+
+	/* And now translate the regular user attributes, using the vars list */
+	attno = InvalidAttrNumber;
+	foreach(lc, translated_vars)
+	{
+		Var		   *var = lfirst_node(Var, lc);
+
+		attno++;
+		if (var == NULL)		/* ignore dropped columns */
+			continue;
+		if (whole_row ||
+			bms_is_member(attno - FirstLowInvalidHeapAttributeNumber,
+						  parent_privs))
+			child_privs = bms_add_member(child_privs,
+										 var->varattno - FirstLowInvalidHeapAttributeNumber);
+	}
+
+	return child_privs;
+}
+
+/*
+ * adjust_appendrel_attrs
+ *	  Copy the specified query or expression and translate Vars referring to a
+ *	  parent rel to refer to the corresponding child rel instead.  We also
+ *	  update rtindexes appearing outside Vars, such as resultRelation and
+ *	  jointree relids.
+ *
+ * Note: this is only applied after conversion of sublinks to subplans,
+ * so we don't need to cope with recursion into sub-queries.
+ *
+ * Note: this is not hugely different from what pullup_replace_vars() does;
+ * maybe we should try to fold the two routines together.
+ */
+Node *
+adjust_appendrel_attrs(PlannerInfo *root, Node *node, int nappinfos,
+					   AppendRelInfo **appinfos)
+{
+	Node	   *result;
+	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);
+
+	/*
+	 * Must be prepared to start with a Query or a bare expression tree.
+	 */
+	if (node && IsA(node, Query))
+	{
+		Query	   *newnode;
+		int			cnt;
+
+		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;
+}
+
+static Node *
+adjust_appendrel_attrs_mutator(Node *node,
+							   adjust_appendrel_attrs_context *context)
+{
+	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;
+
+		for (cnt = 0; cnt < nappinfos; cnt++)
+		{
+			if (var->varno == appinfos[cnt]->parent_relid)
+			{
+				appinfo = appinfos[cnt];
+				break;
+			}
+		}
+
+		if (var->varlevelsup == 0 && appinfo)
+		{
+			var->varno = appinfo->child_relid;
+			var->varnoold = appinfo->child_relid;
+			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));
+				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;
+
+					return (Node *) rowexpr;
+				}
+			}
+			/* system attributes don't need any other translation */
+		}
+		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, 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 */
+		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, context->nappinfos,
+											  context->appinfos);
+		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 */
+		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->nullable_relids = adjust_child_relids(oldinfo->nullable_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));
+
+	return expression_tree_mutator(node, adjust_appendrel_attrs_mutator,
+								   (void *) context);
+}
+
+/*
+ * Substitute child relids for parent relids in a Relid set.  The array of
+ * appinfos specifies the substitutions to be performed.
+ */
+static Relids
+adjust_child_relids(Relids relids, int nappinfos, AppendRelInfo **appinfos)
+{
+	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;
+}
+
+/*
+ * Replace any relid present in top_parent_relids with its child in
+ * child_relids. Members of child_relids can be multiple levels below top
+ * parent in the partition hierarchy.
+ */
+Relids
+adjust_child_relids_multilevel(PlannerInfo *root, Relids relids,
+							   Relids child_relids, Relids top_parent_relids)
+{
+	AppendRelInfo **appinfos;
+	int			nappinfos;
+	Relids		parent_relids = NULL;
+	Relids		result;
+	Relids		tmp_result = NULL;
+	int			cnt;
+
+	/*
+	 * If the given relids set doesn't contain any of the top parent relids,
+	 * it will remain unchanged.
+	 */
+	if (!bms_overlap(relids, top_parent_relids))
+		return relids;
+
+	appinfos = find_appinfos_by_relids(root, child_relids, &nappinfos);
+
+	/* Construct relids set for the immediate parent of the given child. */
+	for (cnt = 0; cnt < nappinfos; cnt++)
+	{
+		AppendRelInfo *appinfo = appinfos[cnt];
+
+		parent_relids = bms_add_member(parent_relids, appinfo->parent_relid);
+	}
+
+	/* Recurse if immediate parent is not the top parent. */
+	if (!bms_equal(parent_relids, top_parent_relids))
+	{
+		tmp_result = adjust_child_relids_multilevel(root, relids,
+													parent_relids,
+													top_parent_relids);
+		relids = tmp_result;
+	}
+
+	result = adjust_child_relids(relids, nappinfos, appinfos);
+
+	/* Free memory consumed by any intermediate result. */
+	if (tmp_result)
+		bms_free(tmp_result);
+	bms_free(parent_relids);
+	pfree(appinfos);
+
+	return result;
+}
+
+/*
+ * 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.
+ */
+static List *
+adjust_inherited_tlist(List *tlist, AppendRelInfo *context)
+{
+	bool		changed_it = false;
+	ListCell   *tl;
+	List	   *new_tlist;
+	bool		more;
+	int			attrno;
+
+	/* 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)
+	{
+		TargetEntry *tle = (TargetEntry *) lfirst(tl);
+		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))
+			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);
+		if (childvar == NULL || !IsA(childvar, Var))
+			elog(ERROR, "attribute %d of relation \"%s\" does not exist",
+				 tle->resno, get_rel_name(context->parent_reloid));
+
+		if (tle->resno != childvar->varattno)
+		{
+			tle->resno = childvar->varattno;
+			changed_it = true;
+		}
+	}
+
+	/*
+	 * 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;
+
+	new_tlist = NIL;
+	more = true;
+	for (attrno = 1; more; attrno++)
+	{
+		more = false;
+		foreach(tl, tlist)
+		{
+			TargetEntry *tle = (TargetEntry *) lfirst(tl);
+
+			if (tle->resjunk)
+				continue;		/* ignore junk items */
+
+			if (tle->resno == attrno)
+				new_tlist = lappend(new_tlist, tle);
+			else if (tle->resno > attrno)
+				more = true;
+		}
+	}
+
+	foreach(tl, tlist)
+	{
+		TargetEntry *tle = (TargetEntry *) lfirst(tl);
+
+		if (!tle->resjunk)
+			continue;			/* here, ignore non-junk items */
+
+		tle->resno = attrno;
+		new_tlist = lappend(new_tlist, tle);
+		attrno++;
+	}
+
+	return new_tlist;
+}
+
+/*
+ * adjust_appendrel_attrs_multilevel
+ *	  Apply Var translations from a toplevel appendrel parent down to a child.
+ *
+ * In some cases we need to translate expressions referencing a parent relation
+ * to reference an appendrel child that's multiple levels removed from it.
+ */
+Node *
+adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node,
+								  Relids child_relids,
+								  Relids top_parent_relids)
+{
+	AppendRelInfo **appinfos;
+	Bitmapset  *parent_relids = NULL;
+	int			nappinfos;
+	int			cnt;
+
+	Assert(bms_num_members(child_relids) == bms_num_members(top_parent_relids));
+
+	appinfos = find_appinfos_by_relids(root, child_relids, &nappinfos);
+
+	/* Construct relids set for the immediate parent of given child. */
+	for (cnt = 0; cnt < nappinfos; cnt++)
+	{
+		AppendRelInfo *appinfo = appinfos[cnt];
+
+		parent_relids = bms_add_member(parent_relids, appinfo->parent_relid);
+	}
+
+	/* Recurse if immediate parent is not the top parent. */
+	if (!bms_equal(parent_relids, top_parent_relids))
+		node = adjust_appendrel_attrs_multilevel(root, node, parent_relids,
+												 top_parent_relids);
+
+	/* Now translate for this child */
+	node = adjust_appendrel_attrs(root, node, nappinfos, appinfos);
+
+	pfree(appinfos);
+
+	return node;
+}
+
+/*
+ * Construct the SpecialJoinInfo for a child-join by translating
+ * SpecialJoinInfo for the join between parents. left_relids and right_relids
+ * are the relids of left and right side of the join respectively.
+ */
+SpecialJoinInfo *
+build_child_join_sjinfo(PlannerInfo *root, SpecialJoinInfo *parent_sjinfo,
+						Relids left_relids, Relids right_relids)
+{
+	SpecialJoinInfo *sjinfo = makeNode(SpecialJoinInfo);
+	AppendRelInfo **left_appinfos;
+	int			left_nappinfos;
+	AppendRelInfo **right_appinfos;
+	int			right_nappinfos;
+
+	memcpy(sjinfo, parent_sjinfo, sizeof(SpecialJoinInfo));
+	left_appinfos = find_appinfos_by_relids(root, left_relids,
+											&left_nappinfos);
+	right_appinfos = find_appinfos_by_relids(root, right_relids,
+											 &right_nappinfos);
+
+	sjinfo->min_lefthand = adjust_child_relids(sjinfo->min_lefthand,
+											   left_nappinfos, left_appinfos);
+	sjinfo->min_righthand = adjust_child_relids(sjinfo->min_righthand,
+												right_nappinfos,
+												right_appinfos);
+	sjinfo->syn_lefthand = adjust_child_relids(sjinfo->syn_lefthand,
+											   left_nappinfos, left_appinfos);
+	sjinfo->syn_righthand = adjust_child_relids(sjinfo->syn_righthand,
+												right_nappinfos,
+												right_appinfos);
+	sjinfo->semi_rhs_exprs = (List *) adjust_appendrel_attrs(root,
+															 (Node *) sjinfo->semi_rhs_exprs,
+															 right_nappinfos,
+															 right_appinfos);
+
+	pfree(left_appinfos);
+	pfree(right_appinfos);
+
+	return sjinfo;
+}
+
+/*
+ * find_appinfos_by_relids
+ * 		Find AppendRelInfo structures for all relations specified by relids.
+ *
+ * The AppendRelInfos are returned in an array, which can be pfree'd by the
+ * caller. *nappinfos is set to the number of entries in the array.
+ */
+AppendRelInfo **
+find_appinfos_by_relids(PlannerInfo *root, Relids relids, int *nappinfos)
+{
+	AppendRelInfo **appinfos;
+	int			cnt = 0;
+	int			i;
+
+	*nappinfos = bms_num_members(relids);
+	appinfos = (AppendRelInfo **) palloc(sizeof(AppendRelInfo *) * *nappinfos);
+
+	i = -1;
+	while ((i = bms_next_member(relids, i)) >= 0)
+	{
+		AppendRelInfo *appinfo = root->append_rel_array[i];
+
+		if (!appinfo)
+			elog(ERROR, "child rel %d not found in append_rel_array", i);
+
+		appinfos[cnt++] = appinfo;
+	}
+	return appinfos;
+}
diff --git a/src/backend/optimizer/util/inherit.c b/src/backend/optimizer/util/inherit.c
new file mode 100644
index 0000000000..243d61da8f
--- /dev/null
+++ b/src/backend/optimizer/util/inherit.c
@@ -0,0 +1,451 @@
+/*-------------------------------------------------------------------------
+ *
+ * inherit.c
+ *	  Routines to process child relations in inheritance trees
+ *
+ * Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/optimizer/path/inherit.c
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include <limits.h>
+
+#include "access/sysattr.h"
+#include "catalog/partition.h"
+#include "catalog/pg_class.h"
+#include "catalog/pg_inherits.h"
+#include "catalog/pg_type.h"
+#include "miscadmin.h"
+#include "nodes/makefuncs.h"
+#include "optimizer/appendinfo.h"
+#include "optimizer/clauses.h"
+#include "optimizer/inherit.h"
+#include "optimizer/pathnode.h"
+#include "optimizer/paths.h"
+#include "optimizer/plancat.h"
+#include "optimizer/planmain.h"
+#include "optimizer/planner.h"
+#include "optimizer/prep.h"
+#include "optimizer/restrictinfo.h"
+#include "optimizer/tlist.h"
+#include "optimizer/var.h"
+#include "partitioning/partprune.h"
+#include "utils/rel.h"
+
+static void expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte,
+						 Index rti);
+static void expand_partitioned_rtentry(PlannerInfo *root,
+						   RangeTblEntry *parentrte,
+						   Index parentRTindex, Relation parentrel,
+						   PlanRowMark *top_parentrc, LOCKMODE lockmode,
+						   List **appinfos);
+static void expand_single_inheritance_child(PlannerInfo *root,
+								RangeTblEntry *parentrte,
+								Index parentRTindex, Relation parentrel,
+								PlanRowMark *top_parentrc, Relation childrel,
+								List **appinfos, RangeTblEntry **childrte_p,
+								Index *childRTindex_p);
+
+/*
+ * expand_inherited_tables
+ *		Expand each rangetable entry that represents an inheritance set
+ *		into an "append relation".  At the conclusion of this process,
+ *		the "inh" flag is set in all and only those RTEs that are append
+ *		relation parents.
+ */
+void
+expand_inherited_tables(PlannerInfo *root)
+{
+	Index		nrtes;
+	Index		rti;
+	ListCell   *rl;
+
+	/*
+	 * expand_inherited_rtentry may add RTEs to parse->rtable. The function is
+	 * expected to recursively handle any RTEs that it creates with inh=true.
+	 * So just scan as far as the original end of the rtable list.
+	 */
+	nrtes = list_length(root->parse->rtable);
+	rl = list_head(root->parse->rtable);
+	for (rti = 1; rti <= nrtes; rti++)
+	{
+		RangeTblEntry *rte = (RangeTblEntry *) lfirst(rl);
+
+		expand_inherited_rtentry(root, rte, rti);
+		rl = lnext(rl);
+	}
+}
+
+/*
+ * expand_inherited_rtentry
+ *		Check whether a rangetable entry represents an inheritance set.
+ *		If so, add entries for all the child tables to the query's
+ *		rangetable, and build AppendRelInfo nodes for all the child tables
+ *		and add them to root->append_rel_list.  If not, clear the entry's
+ *		"inh" flag to prevent later code from looking for AppendRelInfos.
+ *
+ * Note that the original RTE is considered to represent the whole
+ * inheritance set.  The first of the generated RTEs is an RTE for the same
+ * table, but with inh = false, to represent the parent table in its role
+ * as a simple member of the inheritance set.
+ *
+ * A childless table is never considered to be an inheritance set. For
+ * regular inheritance, a parent RTE must always have at least two associated
+ * AppendRelInfos: one corresponding to the parent table as a simple member of
+ * inheritance set and one or more corresponding to the actual children.
+ * Since a partitioned table is not scanned, it might have only one associated
+ * AppendRelInfo.
+ */
+static void
+expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti)
+{
+	Oid			parentOID;
+	PlanRowMark *oldrc;
+	Relation	oldrelation;
+	LOCKMODE	lockmode;
+	List	   *inhOIDs;
+	ListCell   *l;
+
+	/* Does RT entry allow inheritance? */
+	if (!rte->inh)
+		return;
+	/* Ignore any already-expanded UNION ALL nodes */
+	if (rte->rtekind != RTE_RELATION)
+	{
+		Assert(rte->rtekind == RTE_SUBQUERY);
+		return;
+	}
+	/* Fast path for common case of childless table */
+	parentOID = rte->relid;
+	if (!has_subclass(parentOID))
+	{
+		/* Clear flag before returning */
+		rte->inh = false;
+		return;
+	}
+
+	/*
+	 * The rewriter should already have obtained an appropriate lock on each
+	 * relation named in the query.  However, for each child relation we add
+	 * to the query, we must obtain an appropriate lock, because this will be
+	 * the first use of those relations in the parse/rewrite/plan pipeline.
+	 * Child rels should use the same lockmode as their parent.
+	 */
+	lockmode = rte->rellockmode;
+
+	/* Scan for all members of inheritance set, acquire needed locks */
+	inhOIDs = find_all_inheritors(parentOID, lockmode, NULL);
+
+	/*
+	 * Check that there's at least one descendant, else treat as no-child
+	 * case.  This could happen despite above has_subclass() check, if table
+	 * once had a child but no longer does.
+	 */
+	if (list_length(inhOIDs) < 2)
+	{
+		/* Clear flag before returning */
+		rte->inh = false;
+		return;
+	}
+
+	/*
+	 * If parent relation is selected FOR UPDATE/SHARE, we need to mark its
+	 * PlanRowMark as isParent = true, and generate a new PlanRowMark for each
+	 * child.
+	 */
+	oldrc = get_plan_rowmark(root->rowMarks, rti);
+	if (oldrc)
+		oldrc->isParent = true;
+
+	/*
+	 * Must open the parent relation to examine its tupdesc.  We need not lock
+	 * it; we assume the rewriter already did.
+	 */
+	oldrelation = heap_open(parentOID, NoLock);
+
+	/* Scan the inheritance set and expand it */
+	if (RelationGetPartitionDesc(oldrelation) != NULL)
+	{
+		Assert(rte->relkind == RELKIND_PARTITIONED_TABLE);
+
+		/*
+		 * If this table has partitions, recursively expand them in the order
+		 * in which they appear in the PartitionDesc.  While at it, also
+		 * extract the partition key columns of all the partitioned tables.
+		 */
+		expand_partitioned_rtentry(root, rte, rti, oldrelation, oldrc,
+								   lockmode, &root->append_rel_list);
+	}
+	else
+	{
+		List	   *appinfos = NIL;
+		RangeTblEntry *childrte;
+		Index		childRTindex;
+
+		/*
+		 * This table has no partitions.  Expand any plain inheritance
+		 * children in the order the OIDs were returned by
+		 * find_all_inheritors.
+		 */
+		foreach(l, inhOIDs)
+		{
+			Oid			childOID = lfirst_oid(l);
+			Relation	newrelation;
+
+			/* Open rel if needed; we already have required locks */
+			if (childOID != parentOID)
+				newrelation = heap_open(childOID, NoLock);
+			else
+				newrelation = oldrelation;
+
+			/*
+			 * It is possible that the parent table has children that are temp
+			 * tables of other backends.  We cannot safely access such tables
+			 * (because of buffering issues), and the best thing to do seems
+			 * to be to silently ignore them.
+			 */
+			if (childOID != parentOID && RELATION_IS_OTHER_TEMP(newrelation))
+			{
+				heap_close(newrelation, lockmode);
+				continue;
+			}
+
+			expand_single_inheritance_child(root, rte, rti, oldrelation, oldrc,
+											newrelation,
+											&appinfos, &childrte,
+											&childRTindex);
+
+			/* Close child relations, but keep locks */
+			if (childOID != parentOID)
+				heap_close(newrelation, NoLock);
+		}
+
+		/*
+		 * If all the children were temp tables, pretend it's a
+		 * non-inheritance situation; we don't need Append node in that case.
+		 * The duplicate RTE we added for the parent table is harmless, so we
+		 * don't bother to get rid of it; ditto for the useless PlanRowMark
+		 * node.
+		 */
+		if (list_length(appinfos) < 2)
+			rte->inh = false;
+		else
+			root->append_rel_list = list_concat(root->append_rel_list,
+												appinfos);
+
+	}
+
+	heap_close(oldrelation, NoLock);
+}
+
+/*
+ * expand_partitioned_rtentry
+ *		Recursively expand an RTE for a partitioned table.
+ */
+static void
+expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
+						   Index parentRTindex, Relation parentrel,
+						   PlanRowMark *top_parentrc, LOCKMODE lockmode,
+						   List **appinfos)
+{
+	int			i;
+	RangeTblEntry *childrte;
+	Index		childRTindex;
+	PartitionDesc partdesc = RelationGetPartitionDesc(parentrel);
+
+	check_stack_depth();
+
+	/* A partitioned table should always have a partition descriptor. */
+	Assert(partdesc);
+
+	Assert(parentrte->inh);
+
+	/*
+	 * Note down whether any partition key cols are being updated. Though it's
+	 * the root partitioned table's updatedCols we are interested in, we
+	 * instead use parentrte to get the updatedCols. This is convenient
+	 * because parentrte already has the root partrel's updatedCols translated
+	 * to match the attribute ordering of parentrel.
+	 */
+	if (!root->partColsUpdated)
+		root->partColsUpdated =
+			has_partition_attrs(parentrel, parentrte->updatedCols, NULL);
+
+	/* First expand the partitioned table itself. */
+	expand_single_inheritance_child(root, parentrte, parentRTindex, parentrel,
+									top_parentrc, parentrel,
+									appinfos, &childrte, &childRTindex);
+
+	/*
+	 * If the partitioned table has no partitions, treat this as the
+	 * non-inheritance case.
+	 */
+	if (partdesc->nparts == 0)
+	{
+		parentrte->inh = false;
+		return;
+	}
+
+	for (i = 0; i < partdesc->nparts; i++)
+	{
+		Oid			childOID = partdesc->oids[i];
+		Relation	childrel;
+
+		/* Open rel; we already have required locks */
+		childrel = heap_open(childOID, NoLock);
+
+		/*
+		 * Temporary partitions belonging to other sessions should have been
+		 * disallowed at definition, but for paranoia's sake, let's double
+		 * check.
+		 */
+		if (RELATION_IS_OTHER_TEMP(childrel))
+			elog(ERROR, "temporary relation from another session found as partition");
+
+		expand_single_inheritance_child(root, parentrte, parentRTindex,
+										parentrel, top_parentrc, childrel,
+										appinfos, &childrte, &childRTindex);
+
+		/* If this child is itself partitioned, recurse */
+		if (childrel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
+			expand_partitioned_rtentry(root, childrte, childRTindex,
+									   childrel, top_parentrc, lockmode,
+									   appinfos);
+
+		/* Close child relation, but keep locks */
+		heap_close(childrel, NoLock);
+	}
+}
+
+/*
+ * expand_single_inheritance_child
+ *		Build a RangeTblEntry and an AppendRelInfo, if appropriate, plus
+ *		maybe a PlanRowMark.
+ *
+ * We now expand the partition hierarchy level by level, creating a
+ * corresponding hierarchy of AppendRelInfos and RelOptInfos, where each
+ * partitioned descendant acts as a parent of its immediate partitions.
+ * (This is a difference from what older versions of PostgreSQL did and what
+ * is still done in the case of table inheritance for unpartitioned tables,
+ * where the hierarchy is flattened during RTE expansion.)
+ *
+ * PlanRowMarks still carry the top-parent's RTI, and the top-parent's
+ * allMarkTypes field still accumulates values from all descendents.
+ *
+ * "parentrte" and "parentRTindex" are immediate parent's RTE and
+ * RTI. "top_parentrc" is top parent's PlanRowMark.
+ *
+ * The child RangeTblEntry and its RTI are returned in "childrte_p" and
+ * "childRTindex_p" resp.
+ */
+static void
+expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte,
+								Index parentRTindex, Relation parentrel,
+								PlanRowMark *top_parentrc, Relation childrel,
+								List **appinfos, RangeTblEntry **childrte_p,
+								Index *childRTindex_p)
+{
+	Query	   *parse = root->parse;
+	Oid			parentOID = RelationGetRelid(parentrel);
+	Oid			childOID = RelationGetRelid(childrel);
+	RangeTblEntry *childrte;
+	Index		childRTindex;
+	AppendRelInfo *appinfo;
+
+	/*
+	 * Build an RTE for the child, and attach to query's rangetable list. We
+	 * copy most fields of the parent's RTE, but replace relation OID and
+	 * relkind, and set inh = false.  Also, set requiredPerms to zero since
+	 * all required permissions checks are done on the original RTE. Likewise,
+	 * set the child's securityQuals to empty, because we only want to apply
+	 * the parent's RLS conditions regardless of what RLS properties
+	 * individual children may have.  (This is an intentional choice to make
+	 * inherited RLS work like regular permissions checks.) The parent
+	 * securityQuals will be propagated to children along with other base
+	 * restriction clauses, so we don't need to do it here.
+	 */
+	childrte = copyObject(parentrte);
+	*childrte_p = childrte;
+	childrte->relid = childOID;
+	childrte->relkind = childrel->rd_rel->relkind;
+	/* A partitioned child will need to be expanded further. */
+	if (childOID != parentOID &&
+		childrte->relkind == RELKIND_PARTITIONED_TABLE)
+		childrte->inh = true;
+	else
+		childrte->inh = false;
+	childrte->requiredPerms = 0;
+	childrte->securityQuals = NIL;
+	parse->rtable = lappend(parse->rtable, childrte);
+	childRTindex = list_length(parse->rtable);
+	*childRTindex_p = childRTindex;
+
+	/*
+	 * We need an AppendRelInfo if paths will be built for the child RTE. If
+	 * childrte->inh is true, then we'll always need to generate append paths
+	 * for it.  If childrte->inh is false, we must scan it if it's not a
+	 * partitioned table; but if it is a partitioned table, then it never has
+	 * any data of its own and need not be scanned.
+	 */
+	if (childrte->relkind != RELKIND_PARTITIONED_TABLE || childrte->inh)
+	{
+		appinfo = make_append_rel_info(parentrel, childrel,
+									   parentRTindex, childRTindex);
+		*appinfos = lappend(*appinfos, appinfo);
+
+		/*
+		 * Translate the column permissions bitmaps to the child's attnums (we
+		 * have to build the translated_vars list before we can do this). But
+		 * if this is the parent table, leave copyObject's result alone.
+		 *
+		 * Note: we need to do this even though the executor won't run any
+		 * permissions checks on the child RTE.  The insertedCols/updatedCols
+		 * bitmaps may be examined for trigger-firing purposes.
+		 */
+		if (childOID != parentOID)
+		{
+			childrte->selectedCols = translate_col_privs(parentrte->selectedCols,
+														 appinfo->translated_vars);
+			childrte->insertedCols = translate_col_privs(parentrte->insertedCols,
+														 appinfo->translated_vars);
+			childrte->updatedCols = translate_col_privs(parentrte->updatedCols,
+														appinfo->translated_vars);
+		}
+	}
+
+	/*
+	 * Build a PlanRowMark if parent is marked FOR UPDATE/SHARE.
+	 */
+	if (top_parentrc)
+	{
+		PlanRowMark *childrc = makeNode(PlanRowMark);
+
+		childrc->rti = childRTindex;
+		childrc->prti = top_parentrc->rti;
+		childrc->rowmarkId = top_parentrc->rowmarkId;
+		/* Reselect rowmark type, because relkind might not match parent */
+		childrc->markType = select_rowmark_type(childrte,
+												top_parentrc->strength);
+		childrc->allMarkTypes = (1 << childrc->markType);
+		childrc->strength = top_parentrc->strength;
+		childrc->waitPolicy = top_parentrc->waitPolicy;
+
+		/*
+		 * We mark RowMarks for partitioned child tables as parent RowMarks so
+		 * that the executor ignores them (except their existence means that
+		 * the child tables be locked using appropriate mode).
+		 */
+		childrc->isParent = (childrte->relkind == RELKIND_PARTITIONED_TABLE);
+
+		/* Include child's rowmark type in top parent's allMarkTypes */
+		top_parentrc->allMarkTypes |= childrc->allMarkTypes;
+
+		root->rowMarks = lappend(root->rowMarks, childrc);
+	}
+}
diff --git a/src/backend/optimizer/util/pathnode.c b/src/backend/optimizer/util/pathnode.c
index 5921e893c1..b2637d0e89 100644
--- a/src/backend/optimizer/util/pathnode.c
+++ b/src/backend/optimizer/util/pathnode.c
@@ -20,6 +20,7 @@
 #include "foreign/fdwapi.h"
 #include "nodes/extensible.h"
 #include "nodes/nodeFuncs.h"
+#include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index 111b42d654..fe83ec4519 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -17,6 +17,7 @@
 #include <limits.h>
 
 #include "miscadmin.h"
+#include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
diff --git a/src/backend/partitioning/partprune.c b/src/backend/partitioning/partprune.c
index 0684083a8d..901433c68c 100644
--- a/src/backend/partitioning/partprune.c
+++ b/src/backend/partitioning/partprune.c
@@ -44,6 +44,7 @@
 #include "miscadmin.h"
 #include "nodes/makefuncs.h"
 #include "nodes/nodeFuncs.h"
+#include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
 #include "optimizer/pathnode.h"
 #include "optimizer/planner.h"
diff --git a/src/include/optimizer/appendinfo.h b/src/include/optimizer/appendinfo.h
new file mode 100644
index 0000000000..2348c9c13a
--- /dev/null
+++ b/src/include/optimizer/appendinfo.h
@@ -0,0 +1,42 @@
+/*-------------------------------------------------------------------------
+ *
+ * appendinfo.h
+ *	  Routines for mapping expressions between append rel parent(s) and
+ *	  children
+ *
+ * Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/optimizer/appendinfo.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef APPENDINFO_H
+#define APPENDINFO_H
+
+#include "nodes/plannodes.h"
+#include "nodes/relation.h"
+#include "utils/relcache.h"
+
+extern AppendRelInfo *make_append_rel_info(Relation parentrel,
+					 Relation childrel,
+					 Index parentRTindex, Index childRTindex);
+extern Bitmapset *translate_col_privs(const Bitmapset *parent_privs,
+					List *translated_vars);
+extern Node *adjust_appendrel_attrs(PlannerInfo *root, Node *node,
+					   int nappinfos, AppendRelInfo **appinfos);
+
+extern Node *adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node,
+								  Relids child_relids,
+								  Relids top_parent_relids);
+
+extern AppendRelInfo **find_appinfos_by_relids(PlannerInfo *root,
+						Relids relids, int *nappinfos);
+
+extern SpecialJoinInfo *build_child_join_sjinfo(PlannerInfo *root,
+						SpecialJoinInfo *parent_sjinfo,
+						Relids left_relids, Relids right_relids);
+extern Relids adjust_child_relids_multilevel(PlannerInfo *root, Relids relids,
+							   Relids child_relids, Relids top_parent_relids);
+
+#endif							/* APPENDINFO_H */
diff --git a/src/include/optimizer/inherit.h b/src/include/optimizer/inherit.h
new file mode 100644
index 0000000000..c0bd54d9ca
--- /dev/null
+++ b/src/include/optimizer/inherit.h
@@ -0,0 +1,25 @@
+/*-------------------------------------------------------------------------
+ *
+ * inherit.h
+ *	  prototypes for inherit.c.
+ *
+ *
+ * Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/optimizer/inherit.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef INHERIT_H
+#define INHERIT_H
+
+#include "nodes/relation.h"
+
+/*
+ * inherit.c
+ *	  utilities for dealing with append relations
+ */
+extern void expand_inherited_tables(PlannerInfo *root);
+
+#endif							/* INHERIT_H */
diff --git a/src/include/optimizer/prep.h b/src/include/optimizer/prep.h
index d6991d5690..62d45dd142 100644
--- a/src/include/optimizer/prep.h
+++ b/src/include/optimizer/prep.h
@@ -47,22 +47,4 @@ extern PlanRowMark *get_plan_rowmark(List *rowmarks, Index rtindex);
  */
 extern RelOptInfo *plan_set_operations(PlannerInfo *root);
 
-extern void expand_inherited_tables(PlannerInfo *root);
-
-extern Node *adjust_appendrel_attrs(PlannerInfo *root, Node *node,
-					   int nappinfos, AppendRelInfo **appinfos);
-
-extern Node *adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node,
-								  Relids child_relids,
-								  Relids top_parent_relids);
-
-extern AppendRelInfo **find_appinfos_by_relids(PlannerInfo *root,
-						Relids relids, int *nappinfos);
-
-extern SpecialJoinInfo *build_child_join_sjinfo(PlannerInfo *root,
-						SpecialJoinInfo *parent_sjinfo,
-						Relids left_relids, Relids right_relids);
-extern Relids adjust_child_relids_multilevel(PlannerInfo *root, Relids relids,
-							   Relids child_relids, Relids top_parent_relids);
-
 #endif							/* PREP_H */
-- 
2.11.0

From 5ef4e04a6196302bf58d9dd0643421e551babdbc Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Wed, 17 Oct 2018 11:18:12 +0900
Subject: [PATCH v12 2/6] Overhaul inheritance update/delete planning

With the current method, inheritance_planner, which handles the
planning for update/delete commands targeting inheritance trees,
performs the *whole* planning for each child table.  That involves
translating the query tree to set a given child table in place of
the original inheritance root table as the query's target table,
followed by calling grouping_planner on the translated query, which
performs query planning and additional steps needed to apply correct
target list based on the child target table.

That's inefficient for two reasons:

 1. partprune.c cannot be used to perform partition pruning, because
    it can only be invoked from query_planner.  With the current
    approach, query_planner only sees the individual partitions in
    the query tree it receives, not the parent partitioned table.
    This leaves each partition to be pruned using constraint
    exclusion.  (constraint exclusion cannon prune hash partitions
    which means UPDATE/DELETE don't support hash partition pruning.)

 2. Repeated invocation of query_planner results in allocating large
    amounts of memory, especially if there are many child tables.
    Also, it involves repeatedly performing the same processing,
    such as jointree processing.

This commit addresses both of the issues by rewriting portions of
inheritance_planner and adding some supporting functionality to
allpath.c.

With the new implementation, inheritance_planner calls query_planner
only once at the beginning with the original unmodified query, which
creates the access paths of individual relations after pruning any
unnecessary partitions.  For each target child relation, it also
creates a sub-PartitionInfo containing translated version of the
query and a targetlist suitable for the child.  Child PlannerInfos
are saved in the top PlannerInfo for using later.  If the query
involves join against the target relation, join paths are created
for each target child relation by  replacing the original target
table in the join tree by a given child table.  Join relations
(RelOptInfos thereof) for all target child relations are collected
in a global list in the top PlannerInfo.

After creating the join paths for all target child relations,
inheritance_planner calls grouping_planner() on each child join
relation using the previously created child PlannerInfo to finish up
the paths such that they produce query's top-level target list
expanded according to a given child relation's descriptor.
grouping_planner()'s interface is modified so that we can pass it
what's called a 'planned_rel', a RelOptInfo that already contains
the necessary paths needed to produce its output.

This removes some existing code in inheritance_planner that dealt
with any subquery RTEs in the query.  The rationale of that code
was that the subquery RTEs may change during each iteration of
planning (that is, for different children), so different iterations
better use different copies of those RTEs.  That was handled by
making fresh copies of those RTEs for each iteration of planning
which were appended to the range table, accompanied by modifying all
expressions and auxiliary structures that referenced the original
subquery RTEs to instead reference the copies (that is, change the
varnos).  This copying meant we would end up adding S * N new entries
to the original range table by the time we got to the last unpruned
child, where S is the number of subquery RTEs in the original query
and N the number of unpruned children.  Since with the new code
we perform planning just once, I think we don't need this special
handling.  Actually, there is a regression test output change due
to no longer having copies of subquery RTEs (see the diff of
partition_join.out file.)

Also we no longer need the hack in relation_excluded_by_constraints()
involving setting PlannerInfo.inhTargetKind to enable constraint
exclusion for target child relation, which is no longer needed.
Constraint exclusion now runs during query_planner step described
above.

Regression test output change in partition_join.out is due to the fact
that we no longer create duplicates of subquery RTEs in child range
tables.
---
 doc/src/sgml/ddl.sgml                        |  14 +-
 src/backend/nodes/outfuncs.c                 |   1 -
 src/backend/optimizer/path/allpaths.c        | 602 +++++++++++++++++++++++++--
 src/backend/optimizer/path/equivclass.c      |  27 +-
 src/backend/optimizer/plan/createplan.c      |  10 -
 src/backend/optimizer/plan/planmain.c        | 166 +++++++-
 src/backend/optimizer/plan/planner.c         | 434 +++++--------------
 src/backend/optimizer/prep/prepjointree.c    |   1 -
 src/backend/optimizer/util/appendinfo.c      |  33 +-
 src/backend/optimizer/util/plancat.c         |  50 +--
 src/include/nodes/relation.h                 |  34 +-
 src/include/optimizer/paths.h                |   3 +-
 src/test/regress/expected/partition_join.out |   4 +-
 13 files changed, 937 insertions(+), 442 deletions(-)

diff --git a/doc/src/sgml/ddl.sgml b/doc/src/sgml/ddl.sgml
index 85e4358988..0333f673b3 100644
--- a/doc/src/sgml/ddl.sgml
+++ b/doc/src/sgml/ddl.sgml
@@ -4439,15 +4439,6 @@ EXPLAIN SELECT count(*) FROM measurement WHERE logdate &gt;= DATE '2008-01-01';
 
    <note>
     <para>
-     Currently, pruning of partitions during the planning of an
-     <command>UPDATE</command> or <command>DELETE</command> command is
-     implemented using the constraint exclusion method (however, it is
-     controlled by the <literal>enable_partition_pruning</literal> rather than
-     <literal>constraint_exclusion</literal>) &mdash; see the following section
-     for details and caveats that apply.
-    </para>
-
-    <para>
      Execution-time partition pruning currently only occurs for the
      <literal>Append</literal> and <literal>MergeAppend</literal> node types.
      It is not yet implemented for the <literal>ModifyTable</literal> node
@@ -4470,9 +4461,8 @@ EXPLAIN SELECT count(*) FROM measurement WHERE logdate &gt;= DATE '2008-01-01';
 
    <para>
     <firstterm>Constraint exclusion</firstterm> is a query optimization
-    technique similar to partition pruning.  While it is primarily used
-    for partitioning implemented using the legacy inheritance method, it can be
-    used for other purposes, including with declarative partitioning.
+    technique similar to partition pruning.  It is primarily used
+    for partitioning implemented using the legacy inheritance method.
    </para>
 
    <para>
diff --git a/src/backend/nodes/outfuncs.c b/src/backend/nodes/outfuncs.c
index 0fde876c77..f6112e1b4c 100644
--- a/src/backend/nodes/outfuncs.c
+++ b/src/backend/nodes/outfuncs.c
@@ -2210,7 +2210,6 @@ _outPlannerInfo(StringInfo str, const PlannerInfo *node)
 	WRITE_FLOAT_FIELD(tuple_fraction, "%.4f");
 	WRITE_FLOAT_FIELD(limit_tuples, "%.0f");
 	WRITE_UINT_FIELD(qual_security_level);
-	WRITE_ENUM_FIELD(inhTargetKind, InheritanceKind);
 	WRITE_BOOL_FIELD(hasJoinRTEs);
 	WRITE_BOOL_FIELD(hasLateralRTEs);
 	WRITE_BOOL_FIELD(hasDeletedRTEs);
diff --git a/src/backend/optimizer/path/allpaths.c b/src/backend/optimizer/path/allpaths.c
index 8bd71a9825..8c72cab9c9 100644
--- a/src/backend/optimizer/path/allpaths.c
+++ b/src/backend/optimizer/path/allpaths.c
@@ -38,6 +38,7 @@
 #include "optimizer/pathnode.h"
 #include "optimizer/paths.h"
 #include "optimizer/plancat.h"
+#include "optimizer/planmain.h"
 #include "optimizer/planner.h"
 #include "optimizer/prep.h"
 #include "optimizer/restrictinfo.h"
@@ -93,8 +94,12 @@ static void set_foreign_size(PlannerInfo *root, RelOptInfo *rel,
 				 RangeTblEntry *rte);
 static void set_foreign_pathlist(PlannerInfo *root, RelOptInfo *rel,
 					 RangeTblEntry *rte);
+static void set_inherit_target_rel_sizes(PlannerInfo *root, RelOptInfo *rel,
+							 Index rti, RangeTblEntry *rte);
 static void set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 					Index rti, RangeTblEntry *rte);
+static void set_inherit_target_rel_pathlists(PlannerInfo *root,
+							 RelOptInfo *rel, Index rti, RangeTblEntry *rte);
 static void set_append_rel_pathlist(PlannerInfo *root, RelOptInfo *rel,
 						Index rti, RangeTblEntry *rte);
 static void generate_mergeappend_paths(PlannerInfo *root, RelOptInfo *rel,
@@ -121,6 +126,8 @@ static void set_namedtuplestore_pathlist(PlannerInfo *root, RelOptInfo *rel,
 static void set_worktable_pathlist(PlannerInfo *root, RelOptInfo *rel,
 					   RangeTblEntry *rte);
 static RelOptInfo *make_rel_from_joinlist(PlannerInfo *root, List *joinlist);
+static void inheritance_make_rel_from_joinlist(PlannerInfo *root,
+						List *joinlist);
 static bool subquery_is_pushdown_safe(Query *subquery, Query *topquery,
 						  pushdown_safety_info *safetyInfo);
 static bool recurse_pushdown_safe(Node *setOp, Query *topquery,
@@ -151,27 +158,6 @@ make_one_rel(PlannerInfo *root, List *joinlist)
 	Index		rti;
 	double		total_pages;
 
-	/*
-	 * Construct the all_baserels Relids set.
-	 */
-	root->all_baserels = NULL;
-	for (rti = 1; rti < root->simple_rel_array_size; rti++)
-	{
-		RelOptInfo *brel = root->simple_rel_array[rti];
-
-		/* there may be empty slots corresponding to non-baserel RTEs */
-		if (brel == NULL)
-			continue;
-
-		Assert(brel->relid == rti); /* sanity check on array */
-
-		/* ignore RTEs that are "other rels" */
-		if (brel->reloptkind != RELOPT_BASEREL)
-			continue;
-
-		root->all_baserels = bms_add_member(root->all_baserels, brel->relid);
-	}
-
 	/* Mark base rels as to whether we care about fast-start plans */
 	set_base_rel_consider_startup(root);
 
@@ -219,13 +205,34 @@ make_one_rel(PlannerInfo *root, List *joinlist)
 
 	/*
 	 * Generate access paths for the entire join tree.
+	 *
+	 * For UPDATE/DELETE on an inheritance parent, join paths should be
+	 * generated for each child result rel separately.
 	 */
-	rel = make_rel_from_joinlist(root, joinlist);
+	if (root->parse->resultRelation &&
+		root->simple_rte_array[root->parse->resultRelation]->inh)
+	{
+		inheritance_make_rel_from_joinlist(root, joinlist);
 
-	/*
-	 * The result should join all and only the query's base rels.
-	 */
-	Assert(bms_equal(rel->relids, root->all_baserels));
+		/*
+		 * Return the RelOptInfo of original target relation, although this
+		 * doesn't really contain the final path.  inheritance_planner
+		 * from where we got here will generate the final path, but it will
+		 * do so by iterative over child subroots, not through this
+		 * RelOptInfo.
+		 */
+		rel = find_base_rel(root, root->parse->resultRelation);
+	}
+	else
+	{
+		rel = make_rel_from_joinlist(root, joinlist);
+
+		/*
+		 * The result should join all and only the query's base rels.
+		 */
+		Assert(bms_equal(rel->relids, root->all_baserels));
+
+	}
 
 	return rel;
 }
@@ -375,8 +382,15 @@ set_rel_size(PlannerInfo *root, RelOptInfo *rel,
 	}
 	else if (rte->inh)
 	{
-		/* It's an "append relation", process accordingly */
-		set_append_rel_size(root, rel, rti, rte);
+		/*
+		 * If it's a target relation, set the sizes of children instead.
+		 * Otherwise, we'll append the outputs of children, so process it as
+		 * an "append relation".
+		 */
+		if (rti == root->parse->resultRelation)
+			set_inherit_target_rel_sizes(root, rel, rti, rte);
+		else
+			set_append_rel_size(root, rel, rti, rte);
 	}
 	else
 	{
@@ -460,14 +474,26 @@ static void
 set_rel_pathlist(PlannerInfo *root, RelOptInfo *rel,
 				 Index rti, RangeTblEntry *rte)
 {
+	bool	inherited_update = false;
+
 	if (IS_DUMMY_REL(rel))
 	{
 		/* We already proved the relation empty, so nothing more to do */
 	}
 	else if (rte->inh)
 	{
-		/* It's an "append relation", process accordingly */
-		set_append_rel_pathlist(root, rel, rti, rte);
+		/*
+		 * If it's a target relation, set the pathlists of children instead.
+		 * Otherwise, we'll append the outputs of children, so process it as
+		 * an "append relation".
+		 */
+		if (rti == root->parse->resultRelation)
+		{
+			inherited_update = true;
+			set_inherit_target_rel_pathlists(root, rel, rti, rte);
+		}
+		else
+			set_append_rel_pathlist(root, rel, rti, rte);
 	}
 	else
 	{
@@ -542,8 +568,12 @@ set_rel_pathlist(PlannerInfo *root, RelOptInfo *rel,
 	if (set_rel_pathlist_hook)
 		(*set_rel_pathlist_hook) (root, rel, rti, rte);
 
-	/* Now find the cheapest of the paths for this rel */
-	set_cheapest(rel);
+	/*
+	 * Now find the cheapest of the paths for this rel, unless it's an
+	 * inheritance parent and this is an update/delete operation.
+	 */
+	if (!inherited_update)
+		set_cheapest(rel);
 
 #ifdef OPTIMIZER_DEBUG
 	debug_print_rel(root, rel);
@@ -905,6 +935,321 @@ set_foreign_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
 }
 
 /*
+ * set_inherit_target_rel_sizes
+ *	  Set size estimates for the child target relations
+ *
+ * The passed-in rel represents the target relation of the query that is
+ * known to have inheritance children. This is very much like
+ * set_append_rel_size, except it doesn't set the size estimates for the
+ * passed-in rel itself, because we don't need to "append" the children
+ * in this case.
+ */
+static void
+set_inherit_target_rel_sizes(PlannerInfo *root, RelOptInfo *rel,
+							 Index rti, RangeTblEntry *rte)
+{
+	int			parentRTindex = rti;
+	ListCell   *l;
+	bool		has_live_children;
+	Relids		live_children = NULL;
+	bool		did_pruning = false;
+
+	/* Guard against stack overflow due to overly deep inheritance tree. */
+	check_stack_depth();
+
+	Assert(IS_SIMPLE_REL(rel));
+
+	/*
+	 * If the partitioned relation has any baserestrictinfo quals then we
+	 * attempt to use these quals to prune away partitions that cannot
+	 * possibly contain any tuples matching these quals.  In this case we'll
+	 * store the relids of all partitions which could possibly contain a
+	 * matching tuple, and skip anything else in the loop below.
+	 */
+	if (enable_partition_pruning &&
+		rte->relkind == RELKIND_PARTITIONED_TABLE &&
+		rel->baserestrictinfo != NIL)
+	{
+		live_children = prune_append_rel_partitions(rel);
+		did_pruning = true;
+	}
+
+	foreach(l, root->append_rel_list)
+	{
+		AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(l);
+		int			childRTindex;
+		RangeTblEntry *childRTE;
+		RelOptInfo *childrel;
+		List	   *childquals;
+		Index		cq_min_security;
+		bool		have_const_false_cq;
+		PlannerInfo *subroot;
+		ListCell   *lc;
+		List	   *translated_exprs,
+				   *child_target_exprs;
+
+		/* append_rel_list contains all append rels; ignore others */
+		if (appinfo->parent_relid != parentRTindex)
+			continue;
+
+		childRTindex = appinfo->child_relid;
+		childRTE = root->simple_rte_array[childRTindex];
+		subroot = root->inh_target_child_roots[childRTindex];
+
+		/*
+		 * The child rel's RelOptInfo was already created during
+		 * add_base_rels_to_query.
+		 */
+		childrel = find_base_rel(root, childRTindex);
+		Assert(childrel->reloptkind == RELOPT_OTHER_MEMBER_REL);
+
+		/*
+		 * We have to copy the parent's quals to the child, with appropriate
+		 * substitution of variables.  However, only the baserestrictinfo
+		 * quals are needed before we can check for constraint exclusion; so
+		 * do that first and then check to see if we can disregard this child.
+		 *
+		 * The child rel's targetlist might contain non-Var expressions, which
+		 * means that substitution into the quals could produce opportunities
+		 * for const-simplification, and perhaps even pseudoconstant quals.
+		 * Therefore, transform each RestrictInfo separately to see if it
+		 * reduces to a constant or pseudoconstant.  (We must process them
+		 * separately to keep track of the security level of each qual.)
+		 */
+		childquals = NIL;
+		cq_min_security = UINT_MAX;
+		have_const_false_cq = false;
+		foreach(lc, rel->baserestrictinfo)
+		{
+			RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
+			Node	   *childqual;
+			ListCell   *lc2;
+
+			Assert(IsA(rinfo, RestrictInfo));
+			childqual = adjust_appendrel_attrs(root,
+											   (Node *) rinfo->clause,
+											   1, &appinfo);
+			childqual = eval_const_expressions(root, childqual);
+			/* check for flat-out constant */
+			if (childqual && IsA(childqual, Const))
+			{
+				if (((Const *) childqual)->constisnull ||
+					!DatumGetBool(((Const *) childqual)->constvalue))
+				{
+					/* Restriction reduces to constant FALSE or NULL */
+					have_const_false_cq = true;
+					break;
+				}
+				/* Restriction reduces to constant TRUE, so drop it */
+				continue;
+			}
+			/* might have gotten an AND clause, if so flatten it */
+			foreach(lc2, make_ands_implicit((Expr *) childqual))
+			{
+				Node	   *onecq = (Node *) lfirst(lc2);
+				bool		pseudoconstant;
+
+				/* check for pseudoconstant (no Vars or volatile functions) */
+				pseudoconstant =
+					!contain_vars_of_level(onecq, 0) &&
+					!contain_volatile_functions(onecq);
+				if (pseudoconstant)
+				{
+					/* tell createplan.c to check for gating quals */
+					root->hasPseudoConstantQuals = true;
+				}
+				/* reconstitute RestrictInfo with appropriate properties */
+				childquals = lappend(childquals,
+									 make_restrictinfo((Expr *) onecq,
+													   rinfo->is_pushed_down,
+													   rinfo->outerjoin_delayed,
+													   pseudoconstant,
+													   rinfo->security_level,
+													   NULL, NULL, NULL));
+				/* track minimum security level among child quals */
+				cq_min_security = Min(cq_min_security, rinfo->security_level);
+			}
+		}
+
+		/*
+		 * In addition to the quals inherited from the parent, we might have
+		 * securityQuals associated with this particular child node.
+		 * (Currently this can only happen in appendrels originating from
+		 * UNION ALL; inheritance child tables don't have their own
+		 * securityQuals, see expand_inherited_rtentry().)	Pull any such
+		 * securityQuals up into the baserestrictinfo for the child.  This is
+		 * similar to process_security_barrier_quals() for the parent rel,
+		 * except that we can't make any general deductions from such quals,
+		 * since they don't hold for the whole appendrel.
+		 */
+		if (childRTE->securityQuals)
+		{
+			Index		security_level = 0;
+
+			foreach(lc, childRTE->securityQuals)
+			{
+				List	   *qualset = (List *) lfirst(lc);
+				ListCell   *lc2;
+
+				foreach(lc2, qualset)
+				{
+					Expr	   *qual = (Expr *) lfirst(lc2);
+
+					/* not likely that we'd see constants here, so no check */
+					childquals = lappend(childquals,
+										 make_restrictinfo(qual,
+														   true, false, false,
+														   security_level,
+														   NULL, NULL, NULL));
+					cq_min_security = Min(cq_min_security, security_level);
+				}
+				security_level++;
+			}
+			Assert(security_level <= root->qual_security_level);
+		}
+
+		/*
+		 * OK, we've got all the baserestrictinfo quals for this child.
+		 */
+		childrel->baserestrictinfo = childquals;
+		childrel->baserestrict_min_security = cq_min_security;
+
+		if (have_const_false_cq)
+		{
+			/*
+			 * Some restriction clause reduced to constant FALSE or NULL after
+			 * substitution, so this child need not be scanned.
+			 */
+			set_dummy_rel_pathlist(childrel);
+			continue;
+		}
+
+		if (did_pruning && !bms_is_member(appinfo->child_relid, live_children))
+		{
+			/* This partition was pruned; skip it. */
+			set_dummy_rel_pathlist(childrel);
+			continue;
+		}
+
+		if (relation_excluded_by_constraints(root, childrel, childRTE))
+		{
+			/*
+			 * This child need not be scanned, so we can omit it from the
+			 * appendrel.
+			 */
+			set_dummy_rel_pathlist(childrel);
+			continue;
+		}
+
+		/*
+		 * Add missing Vars to child's reltarget.
+		 *
+		 * add_inherit_target_child_root() would've added only those that are
+		 * needed to be present in the top-level tlist (or ones that
+		 * preprocess_targetlist thinks are needed to be in the tlist.)  We
+		 * may need other attributes such as those contained in WHERE clauses,
+		 * which are already computed for the parent during
+		 * deconstruct_jointree processing of the original query (child's
+		 * query never goes through deconstruct_jointree.)
+		 */
+		translated_exprs = (List *)
+			adjust_appendrel_attrs(root,
+								   (Node *) rel->reltarget->exprs,
+								   1, &appinfo);
+		child_target_exprs = childrel->reltarget->exprs;
+		foreach(lc, translated_exprs)
+		{
+			Expr *expr = lfirst(lc);
+
+			if (!list_member(child_target_exprs, expr))
+				child_target_exprs = lappend(child_target_exprs, expr);
+		}
+
+		/*
+		 * We have to make child entries in the EquivalenceClass data
+		 * structures as well.  This is needed either if the parent
+		 * participates in some eclass joins (because we will want to consider
+		 * inner-indexscan joins on the individual children) or if the parent
+		 * has useful pathkeys (because we should try to build MergeAppend
+		 * paths that produce those sort orderings). Even if this child is
+		 * deemed dummy, it may fall on nullable side in a child-join, which
+		 * in turn may participate in a MergeAppend, where we will need the
+		 * EquivalenceClass data structures.
+		 */
+		if (rel->has_eclass_joins || has_useful_pathkeys(root, rel))
+			add_child_rel_equivalences(subroot, appinfo, rel, childrel, true);
+		childrel->has_eclass_joins = rel->has_eclass_joins;
+
+		/* CE failed, so finish copying/modifying join quals. */
+		childrel->joininfo = (List *)
+			adjust_appendrel_attrs(subroot,
+								   (Node *) rel->joininfo,
+								   1, &appinfo);
+
+		/*
+		 * If parallelism is allowable for this query in general, see whether
+		 * it's allowable for this childrel in particular.  But if we've
+		 * already decided the appendrel is not parallel-safe as a whole,
+		 * there's no point in considering parallelism for this child.  For
+		 * consistency, do this before calling set_rel_size() for the child.
+		 */
+		if (root->glob->parallelModeOK && rel->consider_parallel)
+			set_rel_consider_parallel(subroot, childrel, childRTE);
+
+		/*
+		 * Compute the child's size using possibly modified subroot.
+		 */
+		set_rel_size(subroot, childrel, childRTindex, childRTE);
+
+		/*
+		 * It is possible that constraint exclusion detected a contradiction
+		 * within a child subquery, even though we didn't prove one above. If
+		 * so, we can skip this child.
+		 */
+		if (IS_DUMMY_REL(childrel))
+			continue;
+
+		/*
+		 * If any live child is not parallel-safe, treat the whole appendrel
+		 * as not parallel-safe.  In future we might be able to generate plans
+		 * in which some children are farmed out to workers while others are
+		 * not; but we don't have that today, so it's a waste to consider
+		 * partial paths anywhere in the appendrel unless it's all safe.
+		 * (Child rels visited before this one will be unmarked in
+		 * set_append_rel_pathlist().)
+		 */
+		if (!childrel->consider_parallel)
+			rel->consider_parallel = false;
+
+		/*
+		 * Accumulate size information from each live child.
+		 */
+		Assert(childrel->rows > 0);
+
+		/* We have at least one live child. */
+		has_live_children = true;
+	}
+
+	if (!has_live_children)
+	{
+		/*
+		 * All children were excluded by constraints, so mark the relation
+		 * ass dummy.  We must do this in this phase so that the rel's
+		 * dummy-ness is visible when we generate paths for other rels.
+		 */
+		set_dummy_rel_pathlist(rel);
+	}
+	else
+		/*
+		 * Set a non-zero value here to cope with the caller's requirement
+		 * that non-dummy relations are actually not empty.  We don't try to
+		 * be accurate here, because we're not going to create a path that
+		 * combines the children outputs.
+		 */
+		rel->rows = 1;
+}
+
+/*
  * set_append_rel_size
  *	  Set size estimates for a simple "append relation"
  *
@@ -1047,7 +1392,8 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 		 * EquivalenceClass data structures.
 		 */
 		if (rel->has_eclass_joins || has_useful_pathkeys(root, rel))
-			add_child_rel_equivalences(root, appinfo, rel, childrel);
+			add_child_rel_equivalences(root, appinfo, rel, childrel,
+									   false);
 		childrel->has_eclass_joins = rel->has_eclass_joins;
 
 		/*
@@ -1329,6 +1675,63 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 }
 
 /*
+ * set_inherit_target_rel_pathlists
+ *	  Build access paths for the child target relations
+ *
+ * Similar to set_append_rel_pathlist, except that we build paths of the
+ * children, but don't build an Append path.
+ */
+static void
+set_inherit_target_rel_pathlists(PlannerInfo *root, RelOptInfo *rel,
+								 Index rti, RangeTblEntry *rte)
+{
+	int			parentRTindex = rti;
+	ListCell   *l;
+
+	/* Nothing to do if all the children were excluded. */
+	if (IS_DUMMY_REL(rel))
+		return;
+
+	/* Generate access paths for each of the children of passed-in rel */
+	foreach(l, root->append_rel_list)
+	{
+		AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(l);
+		int			childRTindex;
+		RangeTblEntry *childRTE;
+		RelOptInfo *childrel;
+
+		/* append_rel_list contains all append rels; ignore others */
+		if (appinfo->parent_relid != parentRTindex)
+			continue;
+
+		/* Re-locate the child RTE and RelOptInfo */
+		childRTindex = appinfo->child_relid;
+		childRTE = root->simple_rte_array[childRTindex];
+		childrel = root->simple_rel_array[childRTindex];
+
+		/*
+		 * If set_append_rel_size() decided the parent appendrel was
+		 * parallel-unsafe at some point after visiting this child rel, we
+		 * need to propagate the unsafety marking down to the child, so that
+		 * we don't generate useless partial paths for it.
+		 */
+		if (!rel->consider_parallel)
+			childrel->consider_parallel = false;
+
+		/*
+		 * Compute the child's access paths.
+		 */
+		set_rel_pathlist(root, childrel, childRTindex, childRTE);
+
+		/*
+		 * If child is dummy, ignore it.
+		 */
+		if (IS_DUMMY_REL(childrel))
+			continue;
+	}
+}
+
+/*
  * set_append_rel_pathlist
  *	  Build access paths for an "append relation"
  */
@@ -2626,6 +3029,139 @@ generate_gather_paths(PlannerInfo *root, RelOptInfo *rel, bool override_rows)
 }
 
 /*
+ * inheritance_make_rel_from_joinlist
+ *		Perform join planning for all non-dummy leaf inheritance children
+ *		in their role as an UPDATE/DELETE query's target relation
+ *
+ * If a child relation is a partitioned table, its children are processed in
+ * turn by recursively calling this function.
+ */
+static void
+inheritance_make_rel_from_joinlist(PlannerInfo *root, List *joinlist)
+{
+	Index		resultRelation = root->parse->resultRelation;
+	ListCell   *lc;
+#ifdef USE_ASSERT_CHECKING
+	Relids	all_baserels;
+#endif
+
+	/*
+	 * For UPDATE/DELETE queries, the top parent can only ever be a table.
+	 * As a contrast, it could be a UNION ALL subquery in the case of SELECT.
+	 */
+	Assert(root->parse->commandType == CMD_UPDATE ||
+		   root->parse->commandType == CMD_DELETE);
+	Assert(planner_rt_fetch(resultRelation, root)->rtekind == RTE_RELATION);
+
+	/* Nothing to do. */
+	if (IS_DUMMY_REL(find_base_rel(root, resultRelation)))
+		return;
+
+	foreach(lc, root->append_rel_list)
+	{
+		AppendRelInfo *appinfo = lfirst(lc);
+		PlannerInfo *subroot;
+		RelOptInfo *childrel;
+		List	   *translated_joinlist;
+
+		if (appinfo->parent_relid != resultRelation)
+			continue;
+
+		subroot = root->inh_target_child_roots[appinfo->child_relid];
+		Assert(subroot->parse->resultRelation > 0);
+		childrel = find_base_rel(root, appinfo->child_relid);
+
+		/* Ignore excluded/pruned children. */
+		if (IS_DUMMY_REL(childrel))
+			continue;
+
+		root->inh_target_child_rels = lappend_int(root->inh_target_child_rels,
+												  appinfo->child_relid);
+
+		/*
+		 * Modify joinlist such that relations joined to the top parent rel
+		 * appear to be joined to the child rel instead.  Do the same for
+		 * any SpecialJoinInfo structs.
+		 */
+		translated_joinlist = (List *)
+						adjust_appendrel_attrs(subroot,
+											   (Node *) joinlist,
+											   1, &appinfo);
+		subroot->join_info_list = (List *)
+						adjust_appendrel_attrs(subroot,
+											   (Node *) root->join_info_list,
+											   1, &appinfo);
+
+		/*
+		 * Sub-partitioned tables have to be processed recursively using the
+		 * translated subroot as the parent, because AppendRelInfos link
+		 * sub-partitions to their immediate parents, not the root partitioned
+		 * table.
+		 */
+		if (childrel->part_scheme != NULL)
+		{
+			inheritance_make_rel_from_joinlist(subroot, translated_joinlist);
+
+			/*
+			 * Add this child relation as a placeholder in the parent root's
+			 * inh_target_child_joinrels so that inheritance_planner see same
+			 * number of entries as inh_target_child_rels.
+			 */
+			root->inh_target_child_joinrels =
+					lappend(root->inh_target_child_joinrels, childrel);
+
+			/* Also propagate this child's own children into parent's list. */
+			if (subroot->inh_target_child_rels != NIL)
+			{
+				root->inh_target_child_rels =
+					list_concat(root->inh_target_child_rels,
+								subroot->inh_target_child_rels);
+				root->inh_target_child_joinrels =
+					list_concat(root->inh_target_child_joinrels,
+								subroot->inh_target_child_joinrels);
+			}
+			continue;
+		}
+
+		/*
+		 * Since we added the child rel directly into the join tree, we must
+		 * modify it to be a "base" rel instead of an "other" rel, which the
+		 * join planning code expects the relations being joined to be.
+		 */
+		childrel->reloptkind = RELOPT_BASEREL;
+
+		Assert(subroot->join_rel_list == NIL);
+		Assert(subroot->join_rel_hash == NULL);
+
+		/* Perform join planning and save the resulting RelOptInfo. */
+		childrel = make_rel_from_joinlist(subroot, translated_joinlist);
+
+		/*
+		 * Remember this child target rel.  inheritance_planner will perform
+		 * the remaining steps of planning for each child relation separately.
+		 * Specifically, it will call grouping_planner on every
+		 * RelOptInfo contained in the inh_target_child_rels list, each of
+		 * which represents the source of tuples to be modified for a given
+		 * target child rel.
+		 */
+		root->inh_target_child_joinrels =
+						lappend(root->inh_target_child_joinrels, childrel);
+#ifdef USE_ASSERT_CHECKING
+		/*
+		 * The following implements essentially the same Assert as in
+		 * make_one_rel, our caller.
+		 */
+		all_baserels = bms_copy(root->all_baserels);
+		all_baserels = bms_del_member(all_baserels,
+									  root->parse->resultRelation);
+		all_baserels = bms_add_member(all_baserels,
+									  subroot->parse->resultRelation);
+		Assert(bms_equal(childrel->relids, all_baserels));
+#endif
+	}
+}
+
+/*
  * make_rel_from_joinlist
  *	  Build access paths using a "joinlist" to guide the join path search.
  *
diff --git a/src/backend/optimizer/path/equivclass.c b/src/backend/optimizer/path/equivclass.c
index 7fad7ad1bf..8b4ba1a828 100644
--- a/src/backend/optimizer/path/equivclass.c
+++ b/src/backend/optimizer/path/equivclass.c
@@ -2105,12 +2105,18 @@ match_eclasses_to_foreign_key_col(PlannerInfo *root,
  *
  * parent_rel and child_rel could be derived from appinfo, but since the
  * caller has already computed them, we might as well just pass them in.
+ *
+ * If 'child_is_target' is true then the child EC members *replace* the
+ * corresponding parent members.  In that case, 'root' is the child target
+ * relation's dedicated PlannerInfo so it makes sense to remove the parent
+ * ECs altogether, because they're of no use.
  */
 void
 add_child_rel_equivalences(PlannerInfo *root,
 						   AppendRelInfo *appinfo,
 						   RelOptInfo *parent_rel,
-						   RelOptInfo *child_rel)
+						   RelOptInfo *child_rel,
+						   bool child_is_target)
 {
 	ListCell   *lc1;
 
@@ -2118,6 +2124,8 @@ add_child_rel_equivalences(PlannerInfo *root,
 	{
 		EquivalenceClass *cur_ec = (EquivalenceClass *) lfirst(lc1);
 		ListCell   *lc2;
+		ListCell   *prev;
+		ListCell   *next;
 
 		/*
 		 * If this EC contains a volatile expression, then generating child
@@ -2135,12 +2143,18 @@ add_child_rel_equivalences(PlannerInfo *root,
 			!bms_is_subset(parent_rel->relids, cur_ec->ec_relids))
 			continue;
 
-		foreach(lc2, cur_ec->ec_members)
+		prev = NULL;
+		for (lc2 = list_head(cur_ec->ec_members); lc2 != NULL; lc2 = next)
 		{
 			EquivalenceMember *cur_em = (EquivalenceMember *) lfirst(lc2);
 
+			next = lnext(lc2);
+
 			if (cur_em->em_is_const)
+			{
+				prev = lc2;
 				continue;		/* ignore consts here */
+			}
 
 			/* Does it reference parent_rel? */
 			if (bms_overlap(cur_em->em_relids, parent_rel->relids))
@@ -2178,10 +2192,17 @@ add_child_rel_equivalences(PlannerInfo *root,
 														  child_rel->relids);
 				}
 
+				/* Delete the parent EC member. */
+				if (child_is_target)
+					cur_ec->ec_members = list_delete_cell(cur_ec->ec_members,
+														  lc2, prev);
+
 				(void) add_eq_member(cur_ec, child_expr,
 									 new_relids, new_nullable_relids,
-									 true, cur_em->em_datatype);
+									 !child_is_target, cur_em->em_datatype);
 			}
+			else
+				prev = lc2;
 		}
 	}
 }
diff --git a/src/backend/optimizer/plan/createplan.c b/src/backend/optimizer/plan/createplan.c
index 066685c3c7..8f1769b5c6 100644
--- a/src/backend/optimizer/plan/createplan.c
+++ b/src/backend/optimizer/plan/createplan.c
@@ -2022,12 +2022,7 @@ create_groupingsets_plan(PlannerInfo *root, GroupingSetsPath *best_path)
 	/*
 	 * During setrefs.c, we'll need the grouping_map to fix up the cols lists
 	 * in GroupingFunc nodes.  Save it for setrefs.c to use.
-	 *
-	 * This doesn't work if we're in an inheritance subtree (see notes in
-	 * create_modifytable_plan).  Fortunately we can't be because there would
-	 * never be grouping in an UPDATE/DELETE; but let's Assert that.
 	 */
-	Assert(root->inhTargetKind == INHKIND_NONE);
 	Assert(root->grouping_map == NULL);
 	root->grouping_map = grouping_map;
 
@@ -2184,12 +2179,7 @@ create_minmaxagg_plan(PlannerInfo *root, MinMaxAggPath *best_path)
 	 * with InitPlan output params.  (We can't just do that locally in the
 	 * MinMaxAgg node, because path nodes above here may have Agg references
 	 * as well.)  Save the mmaggregates list to tell setrefs.c to do that.
-	 *
-	 * This doesn't work if we're in an inheritance subtree (see notes in
-	 * create_modifytable_plan).  Fortunately we can't be because there would
-	 * never be aggregates in an UPDATE/DELETE; but let's Assert that.
 	 */
-	Assert(root->inhTargetKind == INHKIND_NONE);
 	Assert(root->minmax_aggs == NIL);
 	root->minmax_aggs = best_path->mmaggregates;
 
diff --git a/src/backend/optimizer/plan/planmain.c b/src/backend/optimizer/plan/planmain.c
index fc97a1bb50..4f68ad9907 100644
--- a/src/backend/optimizer/plan/planmain.c
+++ b/src/backend/optimizer/plan/planmain.c
@@ -28,7 +28,11 @@
 #include "optimizer/paths.h"
 #include "optimizer/placeholder.h"
 #include "optimizer/planmain.h"
+#include "optimizer/prep.h"
 
+static void add_inherited_target_child_roots(PlannerInfo *root);
+static PlannerInfo *adjust_inherited_target_child_root(PlannerInfo *root,
+									AppendRelInfo *appinfo);
 
 /*
  * query_planner
@@ -59,6 +63,8 @@ query_planner(PlannerInfo *root, List *tlist,
 	Query	   *parse = root->parse;
 	List	   *joinlist;
 	RelOptInfo *final_rel;
+	bool		inherited_update;
+	Index		rti;
 
 	/*
 	 * If the query has an empty join tree, then it's something easy like
@@ -232,14 +238,168 @@ query_planner(PlannerInfo *root, List *tlist,
 	extract_restriction_or_clauses(root);
 
 	/*
+	 * Construct the all_baserels Relids set.
+	 */
+	root->all_baserels = NULL;
+	for (rti = 1; rti < root->simple_rel_array_size; rti++)
+	{
+		RelOptInfo *brel = root->simple_rel_array[rti];
+
+		/* there may be empty slots corresponding to non-baserel RTEs */
+		if (brel == NULL)
+			continue;
+
+		Assert(brel->relid == rti); /* sanity check on array */
+
+		/* ignore RTEs that are "other rels" */
+		if (brel->reloptkind != RELOPT_BASEREL)
+			continue;
+
+		root->all_baserels = bms_add_member(root->all_baserels, brel->relid);
+	}
+
+	inherited_update = (parse->resultRelation &&
+						root->simple_rte_array[parse->resultRelation]->inh);
+
+	/*
+	 * Add child subroots needed to use during planning for individual child
+	 * targets
+	 */
+	if (inherited_update)
+	{
+		root->inh_target_child_roots = (PlannerInfo **)
+										palloc0(root->simple_rel_array_size *
+												sizeof(PlannerInfo *));
+		add_inherited_target_child_roots(root);
+	}
+
+	/*
 	 * Ready to do the primary planning.
 	 */
 	final_rel = make_one_rel(root, joinlist);
 
-	/* Check that we got at least one usable path */
-	if (!final_rel || !final_rel->cheapest_total_path ||
-		final_rel->cheapest_total_path->param_info != NULL)
+	/*
+	 * Check that we got at least one usable path.  In the case of an
+	 * inherited update/delete operation, no path has been created for
+	 * the query's actual target relation yet.
+	 */
+	if (!inherited_update &&
+		(!final_rel ||
+		 !final_rel->cheapest_total_path ||
+		 final_rel->cheapest_total_path->param_info != NULL))
 		elog(ERROR, "failed to construct the join relation");
 
 	return final_rel;
 }
+
+/*
+ * add_inherited_target_child_roots
+ *		Add PlannerInfos for inheritance target children
+ */
+static void
+add_inherited_target_child_roots(PlannerInfo *root)
+{
+	Index		resultRelation = root->parse->resultRelation;
+	ListCell   *lc;
+
+	Assert(root->inh_target_child_roots != NULL);
+
+	foreach(lc, root->append_rel_list)
+	{
+		AppendRelInfo *appinfo = lfirst(lc);
+		RangeTblEntry *childRTE;
+		PlannerInfo   *subroot;
+
+		if (appinfo->parent_relid != resultRelation)
+			continue;
+
+		childRTE = root->simple_rte_array[appinfo->child_relid];
+		subroot = adjust_inherited_target_child_root(root, appinfo);
+
+		if (childRTE->inh)
+			add_inherited_target_child_roots(subroot);
+
+		root->inh_target_child_roots[appinfo->child_relid] = subroot;
+	}
+}
+
+/*
+ * add_inherit_target_child_root
+ *		This translates query to match the child given by appinfo and
+ *		puts it in a PlannerInfo that will be used for planning the child
+ *
+ * The child PlannerInfo reuses most of the parent PlannerInfo's fields
+ * unchanged, except unexpanded_tlist and processed_tlist are based on the
+ * child relation.
+ */
+static PlannerInfo *
+adjust_inherited_target_child_root(PlannerInfo *root, AppendRelInfo *appinfo)
+{
+	PlannerInfo *subroot;
+	List	   *tlist;
+	ListCell   *lc;
+
+	Assert(root->parse->commandType == CMD_UPDATE ||
+		   root->parse->commandType == CMD_DELETE);
+
+	/* Translate the original query's expressions to this child. */
+	subroot = makeNode(PlannerInfo);
+	memcpy(subroot, root, sizeof(PlannerInfo));
+
+	/*
+	 * Restore the unexpanded tlist for translation, so that child's
+	 * query contains targetList numbered (resnos) per its own
+	 * TupleDesc, which adjust_inherited_tlist ensures.
+	 */
+	root->parse->targetList = root->unexpanded_tlist;
+	subroot->parse = (Query *) adjust_appendrel_attrs(root,
+													  (Node *) root->parse,
+													  1, &appinfo);
+
+	/*
+	 * Save the original unexpanded targetlist in child subroot, just as
+	 * we did for the parent root, so that this child's own children can use
+	 * it.  Must use copy because subroot->parse->targetList will be modified
+	 * soon.
+	 */
+	subroot->unexpanded_tlist = list_copy(subroot->parse->targetList);
+
+	/*
+	 * Apply planner's expansion of targetlist, such as adding various junk
+	 * column, filling placeholder entries for dropped columns, etc., all of
+	 * which occurs with the child's TupleDesc.
+	 */
+	tlist = preprocess_targetlist(subroot);
+	subroot->processed_tlist = tlist;
+
+	/* Add any newly added Vars to the child RelOptInfo. */
+	build_base_rel_tlists(subroot, tlist);
+
+	/*
+	 * Adjust all_baserels to replace the original target relation with the
+	 * child target relation.  Copy it before modifying though.
+	 */
+	subroot->all_baserels = bms_copy(root->all_baserels);
+	subroot->all_baserels = bms_del_member(subroot->all_baserels,
+										   root->parse->resultRelation);
+	subroot->all_baserels = bms_add_member(subroot->all_baserels,
+										   subroot->parse->resultRelation);
+
+	/*
+	 * Child root should get its own copy of ECs, because they'll be modified
+	 * to replace parent EC expressions by child expressions in
+	 * add_child_rel_equivalences.
+	 */
+	subroot->eq_classes = NIL;
+	foreach(lc, root->eq_classes)
+	{
+		EquivalenceClass *ec = lfirst(lc);
+		EquivalenceClass *new_ec = makeNode(EquivalenceClass);
+
+		memcpy(new_ec, ec, sizeof(EquivalenceClass));
+		new_ec->ec_members = list_copy(ec->ec_members);
+		subroot->eq_classes = lappend(subroot->eq_classes, new_ec);
+	}
+
+	return subroot;
+}
diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index 98acb58304..bea89dd8dd 100644
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -37,6 +37,7 @@
 #ifdef OPTIMIZER_DEBUG
 #include "nodes/print.h"
 #endif
+#include "nodes/relation.h"
 #include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
 #include "optimizer/cost.h"
@@ -128,7 +129,7 @@ static Node *preprocess_expression(PlannerInfo *root, Node *expr, int kind);
 static void preprocess_qual_conditions(PlannerInfo *root, Node *jtnode);
 static void inheritance_planner(PlannerInfo *root);
 static void grouping_planner(PlannerInfo *root, bool inheritance_update,
-				 double tuple_fraction);
+				 RelOptInfo *planned_rel, double tuple_fraction);
 static grouping_sets_data *preprocess_grouping_sets(PlannerInfo *root);
 static List *remap_to_groupclause_idx(List *groupClause, List *gsets,
 						 int *tleref_to_colnum_map);
@@ -632,7 +633,6 @@ subquery_planner(PlannerGlobal *glob, Query *parse,
 	root->grouping_map = NULL;
 	root->minmax_aggs = NIL;
 	root->qual_security_level = 0;
-	root->inhTargetKind = INHKIND_NONE;
 	root->hasRecursion = hasRecursion;
 	if (hasRecursion)
 		root->wt_param_id = SS_assign_special_param(root);
@@ -972,7 +972,7 @@ subquery_planner(PlannerGlobal *glob, Query *parse,
 		rt_fetch(parse->resultRelation, parse->rtable)->inh)
 		inheritance_planner(root);
 	else
-		grouping_planner(root, false, tuple_fraction);
+		grouping_planner(root, false, NULL, tuple_fraction);
 
 	/*
 	 * Capture the set of outer-level param IDs we have access to, for use in
@@ -1148,12 +1148,19 @@ preprocess_phv_expression(PlannerInfo *root, Expr *expr)
  *	  inheritance set.
  *
  * We have to handle this case differently from cases where a source relation
- * is an inheritance set. Source inheritance is expanded at the bottom of the
- * plan tree (see allpaths.c), but target inheritance has to be expanded at
- * the top.  The reason is that for UPDATE, each target relation needs a
- * different targetlist matching its own column set.  Fortunately,
- * the UPDATE/DELETE target can never be the nullable side of an outer join,
- * so it's OK to generate the plan this way.
+ * is an inheritance set.  That's mainly because for UPDATE, each target
+ * relation needs a different targetlist matching its own column set.  So, we
+ * must modify the source scan/join path for each target relation such that it
+ * produces the desired target list.
+ *
+ * The source scan/join paths for individual target relations are still
+ * created in allpaths.c by first expanding the inheritance in the usual way
+ * by set_append_rel_size, followed by join planning for each target relation
+ * separately in make_one_rel.  Finally, we apply grouping_planner here to each
+ * child scan/join path so that it produces the desired targetlist.
+ *
+ * Fortunately, the UPDATE/DELETE target can never be the nullable side of an
+ * outer join, so it's OK to generate the plan this way.
  *
  * Returns nothing; the useful output is in the Paths we attach to
  * the (UPPERREL_FINAL, NULL) upperrel stored in *root.
@@ -1166,14 +1173,8 @@ inheritance_planner(PlannerInfo *root)
 {
 	Query	   *parse = root->parse;
 	int			top_parentRTindex = parse->resultRelation;
-	Bitmapset  *subqueryRTindexes;
-	Bitmapset  *modifiableARIindexes;
 	int			nominalRelation = -1;
 	Index		rootRelation = 0;
-	List	   *final_rtable = NIL;
-	int			save_rel_array_size = 0;
-	RelOptInfo **save_rel_array = NULL;
-	AppendRelInfo **save_append_rel_array = NULL;
 	List	   *subpaths = NIL;
 	List	   *subroots = NIL;
 	List	   *resultRelations = NIL;
@@ -1181,70 +1182,59 @@ inheritance_planner(PlannerInfo *root)
 	List	   *returningLists = NIL;
 	List	   *rowMarks;
 	RelOptInfo *final_rel;
-	ListCell   *lc;
-	Index		rti;
+	ListCell   *lc1,
+			   *lc2;
 	RangeTblEntry *parent_rte;
-	PlannerInfo *parent_root;
-	Query	   *parent_parse;
-	Bitmapset  *parent_relids = bms_make_singleton(top_parentRTindex);
-	PlannerInfo **parent_roots = NULL;
+	List	   *tlist;
+	standard_qp_extra qp_extra;
+	RelOptInfo *planned_rel;
 
+	/* Inheritance is never used for insert. */
 	Assert(parse->commandType != CMD_INSERT);
+	parent_rte = planner_rt_fetch(top_parentRTindex, root);
 
 	/*
-	 * We generate a modified instance of the original Query for each target
-	 * relation, plan that, and put all the plans into a list that will be
-	 * controlled by a single ModifyTable node.  All the instances share the
-	 * same rangetable, but each instance must have its own set of subquery
-	 * RTEs within the finished rangetable because (1) they are likely to get
-	 * scribbled on during planning, and (2) it's not inconceivable that
-	 * subqueries could get planned differently in different cases.  We need
-	 * not create duplicate copies of other RTE kinds, in particular not the
-	 * target relations, because they don't have either of those issues.  Not
-	 * having to duplicate the target relations is important because doing so
-	 * (1) would result in a rangetable of length O(N^2) for N targets, with
-	 * at least O(N^3) work expended here; and (2) would greatly complicate
-	 * management of the rowMarks list.
+	 * Generate the access paths for all relations mentioned in the query,
+	 * including the target inheritance set.  When doing the join planning,
+	 * references in the join tree to the original target relation that's the
+	 * root parent of the inheritance tree is replaced by each of its
+	 * inheritance children and the resulting joinrel RelOptInfo's are
+	 * added to root->inh_target_child_rels.
 	 *
-	 * To begin with, generate a bitmapset of the relids of the subquery RTEs.
+	 * Final planning steps (grouping_planner) are applied to the best path
+	 * of each of those child joinrels using a modified instance of the
+	 * original query for a given child target rel.  All the paths so
+	 * generated are put into a list that will be controlled by a single
+	 * ModifyTable node.  All the instances share the same rangetable.
 	 */
-	subqueryRTindexes = NULL;
-	rti = 1;
-	foreach(lc, parse->rtable)
-	{
-		RangeTblEntry *rte = lfirst_node(RangeTblEntry, lc);
-
-		if (rte->rtekind == RTE_SUBQUERY)
-			subqueryRTindexes = bms_add_member(subqueryRTindexes, rti);
-		rti++;
-	}
 
 	/*
-	 * Next, we want to identify which AppendRelInfo items contain references
-	 * to any of the aforesaid subquery RTEs.  These items will need to be
-	 * copied and modified to adjust their subquery references; whereas the
-	 * other ones need not be touched.  It's worth being tense over this
-	 * because we can usually avoid processing most of the AppendRelInfo
-	 * items, thereby saving O(N^2) space and time when the target is a large
-	 * inheritance tree.  We can identify AppendRelInfo items by their
-	 * child_relid, since that should be unique within the list.
+	 * Save the unexpanded version of the query's targetlist to be used below
+	 * for passing to grouping_planner for each child target relation.
 	 */
-	modifiableARIindexes = NULL;
-	if (subqueryRTindexes != NULL)
-	{
-		foreach(lc, root->append_rel_list)
-		{
-			AppendRelInfo *appinfo = lfirst_node(AppendRelInfo, lc);
+	root->unexpanded_tlist = list_copy(root->parse->targetList);
 
-			if (bms_is_member(appinfo->parent_relid, subqueryRTindexes) ||
-				bms_is_member(appinfo->child_relid, subqueryRTindexes) ||
-				bms_overlap(pull_varnos((Node *) appinfo->translated_vars),
-							subqueryRTindexes))
-				modifiableARIindexes = bms_add_member(modifiableARIindexes,
-													  appinfo->child_relid);
-		}
+	/* Do the scan/join planning. */
+	tlist = preprocess_targetlist(root);
+	root->processed_tlist = tlist;
+	qp_extra.tlist = tlist;
+	qp_extra.activeWindows = qp_extra.groupClause = NIL;
+	planned_rel = query_planner(root, tlist, standard_qp_callback, &qp_extra);
+
+	/*
+	 * If it turned out during query planning that all the children are dummy
+	 * (pruned or excluded by constraints), no need to do the steps below.
+	 * Let grouping_planner finish up the final path.
+	 */
+	if (IS_DUMMY_REL(planned_rel))
+	{
+		grouping_planner(root, false, planned_rel, 0.0);
+		return;
 	}
 
+	Assert(planned_rel->relid == top_parentRTindex);
+	Assert(planned_rel->reloptkind == RELOPT_BASEREL);
+
 	/*
 	 * If the parent RTE is a partitioned table, we should use that as the
 	 * nominal target relation, because the RTEs added for partitioned tables
@@ -1252,7 +1242,6 @@ inheritance_planner(PlannerInfo *root)
 	 * not appear anywhere else in the plan, so the confusion explained below
 	 * for non-partitioning inheritance cases is not possible.
 	 */
-	parent_rte = rt_fetch(top_parentRTindex, root->parse->rtable);
 	if (parent_rte->relkind == RELKIND_PARTITIONED_TABLE)
 	{
 		nominalRelation = top_parentRTindex;
@@ -1260,95 +1249,42 @@ inheritance_planner(PlannerInfo *root)
 	}
 
 	/*
-	 * The PlannerInfo for each child is obtained by translating the relevant
-	 * members of the PlannerInfo for its immediate parent, which we find
-	 * using the parent_relid in its AppendRelInfo.  We save the PlannerInfo
-	 * for each parent in an array indexed by relid for fast retrieval. Since
-	 * the maximum number of parents is limited by the number of RTEs in the
-	 * query, we use that number to allocate the array. An extra entry is
-	 * needed since relids start from 1.
+	 * Get on with finalizing the path for each child target relation by
+	 * calling grouping_planner on its joinrel.  Note that we're restoring
+	 * the query's targetlist to the original one for grouping_planner's
+	 * targetlist expansion steps to perform the expansion with individual
+	 * child descriptors.
 	 */
-	parent_roots = (PlannerInfo **) palloc0((list_length(parse->rtable) + 1) *
-											sizeof(PlannerInfo *));
-	parent_roots[top_parentRTindex] = root;
-
-	/*
-	 * And now we can get on with generating a plan for each child table.
-	 */
-	foreach(lc, root->append_rel_list)
+	forboth(lc1, root->inh_target_child_rels,
+			lc2, root->inh_target_child_joinrels)
 	{
-		AppendRelInfo *appinfo = lfirst_node(AppendRelInfo, lc);
-		PlannerInfo *subroot;
+		Index		childRTindex = lfirst_int(lc1);
+		RelOptInfo *childrel = lfirst(lc2);
+		PlannerInfo *subroot = root->inh_target_child_roots[childRTindex];
+		AppendRelInfo *appinfo = root->append_rel_array[childRTindex];
 		RangeTblEntry *child_rte;
 		RelOptInfo *sub_final_rel;
 		Path	   *subpath;
 
-		/* append_rel_list contains all append rels; ignore others */
-		if (!bms_is_member(appinfo->parent_relid, parent_relids))
-			continue;
-
-		/*
-		 * expand_inherited_rtentry() always processes a parent before any of
-		 * that parent's children, so the parent_root for this relation should
-		 * already be available.
-		 */
-		parent_root = parent_roots[appinfo->parent_relid];
-		Assert(parent_root != NULL);
-		parent_parse = parent_root->parse;
-
-		/*
-		 * We need a working copy of the PlannerInfo so that we can control
-		 * propagation of information back to the main copy.
-		 */
-		subroot = makeNode(PlannerInfo);
-		memcpy(subroot, parent_root, sizeof(PlannerInfo));
-
-		/*
-		 * Generate modified query with this rel as target.  We first apply
-		 * adjust_appendrel_attrs, which copies the Query and changes
-		 * references to the parent RTE to refer to the current child RTE,
-		 * then fool around with subquery RTEs.
-		 */
-		subroot->parse = (Query *)
-			adjust_appendrel_attrs(parent_root,
-								   (Node *) parent_parse,
-								   1, &appinfo);
+		Assert(subroot != NULL);
+		Assert(subroot->parse->resultRelation == childRTindex);
 
 		/*
 		 * If there are securityQuals attached to the parent, move them to the
 		 * child rel (they've already been transformed properly for that).
 		 */
-		parent_rte = rt_fetch(appinfo->parent_relid, subroot->parse->rtable);
-		child_rte = rt_fetch(appinfo->child_relid, subroot->parse->rtable);
+		parent_rte = planner_rt_fetch(appinfo->parent_relid, subroot);
+		child_rte = planner_rt_fetch(appinfo->child_relid, subroot);
 		child_rte->securityQuals = parent_rte->securityQuals;
 		parent_rte->securityQuals = NIL;
 
 		/*
-		 * Mark whether we're planning a query to a partitioned table or an
-		 * inheritance parent.
+		 * Ignore a partitioned child.  Instead, the paths of its children will
+		 * be added to subpaths.
 		 */
-		subroot->inhTargetKind =
-			(rootRelation != 0) ? INHKIND_PARTITIONED : INHKIND_INHERITED;
-
-		/*
-		 * If this child is further partitioned, remember it as a parent.
-		 * Since a partitioned table does not have any data, we don't need to
-		 * create a plan for it, and we can stop processing it here.  We do,
-		 * however, need to remember its modified PlannerInfo for use when
-		 * processing its children, since we'll update their varnos based on
-		 * the delta from immediate parent to child, not from top to child.
-		 *
-		 * Note: a very non-obvious point is that we have not yet added
-		 * duplicate subquery RTEs to the subroot's rtable.  We mustn't,
-		 * because then its children would have two sets of duplicates,
-		 * confusing matters.
-		 */
-		if (child_rte->inh)
+		if (childrel->part_scheme)
 		{
-			Assert(child_rte->relkind == RELKIND_PARTITIONED_TABLE);
-			parent_relids = bms_add_member(parent_relids, appinfo->child_relid);
-			parent_roots[appinfo->child_relid] = subroot;
-
+			Assert(child_rte->inh);
 			continue;
 		}
 
@@ -1376,111 +1312,8 @@ inheritance_planner(PlannerInfo *root)
 		if (nominalRelation < 0)
 			nominalRelation = appinfo->child_relid;
 
-		/*
-		 * The rowMarks list might contain references to subquery RTEs, so
-		 * make a copy that we can apply ChangeVarNodes to.  (Fortunately, the
-		 * executor doesn't need to see the modified copies --- we can just
-		 * pass it the original rowMarks list.)
-		 */
-		subroot->rowMarks = copyObject(parent_root->rowMarks);
-
-		/*
-		 * The append_rel_list likewise might contain references to subquery
-		 * RTEs (if any subqueries were flattenable UNION ALLs).  So prepare
-		 * to apply ChangeVarNodes to that, too.  As explained above, we only
-		 * want to copy items that actually contain such references; the rest
-		 * can just get linked into the subroot's append_rel_list.
-		 *
-		 * If we know there are no such references, we can just use the outer
-		 * append_rel_list unmodified.
-		 */
-		if (modifiableARIindexes != NULL)
-		{
-			ListCell   *lc2;
-
-			subroot->append_rel_list = NIL;
-			foreach(lc2, parent_root->append_rel_list)
-			{
-				AppendRelInfo *appinfo2 = lfirst_node(AppendRelInfo, lc2);
-
-				if (bms_is_member(appinfo2->child_relid, modifiableARIindexes))
-					appinfo2 = copyObject(appinfo2);
-
-				subroot->append_rel_list = lappend(subroot->append_rel_list,
-												   appinfo2);
-			}
-		}
-
-		/*
-		 * Add placeholders to the child Query's rangetable list to fill the
-		 * RT indexes already reserved for subqueries in previous children.
-		 * These won't be referenced, so there's no need to make them very
-		 * valid-looking.
-		 */
-		while (list_length(subroot->parse->rtable) < list_length(final_rtable))
-			subroot->parse->rtable = lappend(subroot->parse->rtable,
-											 makeNode(RangeTblEntry));
-
-		/*
-		 * If this isn't the first child Query, generate duplicates of all
-		 * subquery RTEs, and adjust Var numbering to reference the
-		 * duplicates. To simplify the loop logic, we scan the original rtable
-		 * not the copy just made by adjust_appendrel_attrs; that should be OK
-		 * since subquery RTEs couldn't contain any references to the target
-		 * rel.
-		 */
-		if (final_rtable != NIL && subqueryRTindexes != NULL)
-		{
-			ListCell   *lr;
-
-			rti = 1;
-			foreach(lr, parent_parse->rtable)
-			{
-				RangeTblEntry *rte = lfirst_node(RangeTblEntry, lr);
-
-				if (bms_is_member(rti, subqueryRTindexes))
-				{
-					Index		newrti;
-
-					/*
-					 * The RTE can't contain any references to its own RT
-					 * index, except in its securityQuals, so we can save a
-					 * few cycles by applying ChangeVarNodes to the rest of
-					 * the rangetable before we append the RTE to it.
-					 */
-					newrti = list_length(subroot->parse->rtable) + 1;
-					ChangeVarNodes((Node *) subroot->parse, rti, newrti, 0);
-					ChangeVarNodes((Node *) subroot->rowMarks, rti, newrti, 0);
-					/* Skip processing unchanging parts of append_rel_list */
-					if (modifiableARIindexes != NULL)
-					{
-						ListCell   *lc2;
-
-						foreach(lc2, subroot->append_rel_list)
-						{
-							AppendRelInfo *appinfo2 = lfirst_node(AppendRelInfo, lc2);
-
-							if (bms_is_member(appinfo2->child_relid,
-											  modifiableARIindexes))
-								ChangeVarNodes((Node *) appinfo2, rti, newrti, 0);
-						}
-					}
-					rte = copyObject(rte);
-					ChangeVarNodes((Node *) rte->securityQuals, rti, newrti, 0);
-					subroot->parse->rtable = lappend(subroot->parse->rtable,
-													 rte);
-				}
-				rti++;
-			}
-		}
-
-		/* There shouldn't be any OJ info to translate, as yet */
-		Assert(subroot->join_info_list == NIL);
-		/* and we haven't created PlaceHolderInfos, either */
-		Assert(subroot->placeholder_list == NIL);
-
-		/* Generate Path(s) for accessing this result relation */
-		grouping_planner(subroot, true, 0.0 /* retrieve all tuples */ );
+		/* Apply the top-level targetlist to childrel's path. */
+		grouping_planner(subroot, true, childrel, 0.0);
 
 		/*
 		 * Select cheapest path in case there's more than one.  We always run
@@ -1492,45 +1325,10 @@ inheritance_planner(PlannerInfo *root)
 		subpath = sub_final_rel->cheapest_total_path;
 
 		/*
-		 * If this child rel was excluded by constraint exclusion, exclude it
-		 * from the result plan.
+		 * child rel cannot be empty, or inheritance_make_rel_from_joinlist
+		 * wouldn't have put it in the list to begin with.
 		 */
-		if (IS_DUMMY_PATH(subpath))
-			continue;
-
-		/*
-		 * If this is the first non-excluded child, its post-planning rtable
-		 * becomes the initial contents of final_rtable; otherwise, append
-		 * just its modified subquery RTEs to final_rtable.
-		 */
-		if (final_rtable == NIL)
-			final_rtable = subroot->parse->rtable;
-		else
-			final_rtable = list_concat(final_rtable,
-									   list_copy_tail(subroot->parse->rtable,
-													  list_length(final_rtable)));
-
-		/*
-		 * We need to collect all the RelOptInfos from all child plans into
-		 * the main PlannerInfo, since setrefs.c will need them.  We use the
-		 * last child's simple_rel_array (previous ones are too short), so we
-		 * have to propagate forward the RelOptInfos that were already built
-		 * in previous children.
-		 */
-		Assert(subroot->simple_rel_array_size >= save_rel_array_size);
-		for (rti = 1; rti < save_rel_array_size; rti++)
-		{
-			RelOptInfo *brel = save_rel_array[rti];
-
-			if (brel)
-				subroot->simple_rel_array[rti] = brel;
-		}
-		save_rel_array_size = subroot->simple_rel_array_size;
-		save_rel_array = subroot->simple_rel_array;
-		save_append_rel_array = subroot->append_rel_array;
-
-		/* Make sure any initplans from this rel get into the outer list */
-		root->init_plans = subroot->init_plans;
+		Assert(!IS_DUMMY_PATH(subpath));
 
 		/* Build list of sub-paths */
 		subpaths = lappend(subpaths, subpath);
@@ -1562,36 +1360,6 @@ inheritance_planner(PlannerInfo *root)
 	 */
 
 	/*
-	 * If we managed to exclude every child rel, return a dummy plan; it
-	 * doesn't even need a ModifyTable node.
-	 */
-	if (subpaths == NIL)
-	{
-		set_dummy_rel_pathlist(final_rel);
-		return;
-	}
-
-	/*
-	 * Put back the final adjusted rtable into the master copy of the Query.
-	 * (We mustn't do this if we found no non-excluded children.)
-	 */
-	parse->rtable = final_rtable;
-	root->simple_rel_array_size = save_rel_array_size;
-	root->simple_rel_array = save_rel_array;
-	root->append_rel_array = save_append_rel_array;
-
-	/* Must reconstruct master's simple_rte_array, too */
-	root->simple_rte_array = (RangeTblEntry **)
-		palloc0((list_length(final_rtable) + 1) * sizeof(RangeTblEntry *));
-	rti = 1;
-	foreach(lc, final_rtable)
-	{
-		RangeTblEntry *rte = lfirst_node(RangeTblEntry, lc);
-
-		root->simple_rte_array[rti++] = rte;
-	}
-
-	/*
 	 * If there was a FOR [KEY] UPDATE/SHARE clause, the LockRows node will
 	 * have dealt with fetching non-locked marked rows, else we need to have
 	 * ModifyTable do that.
@@ -1631,6 +1399,12 @@ inheritance_planner(PlannerInfo *root)
  * (inheritance_planner will create a single ModifyTable node covering all the
  * target tables.)
  *
+ * If non-NULL, planned_rel is a RelOptInfo containing paths for the query's
+ * top-level joinrel, which the caller produced by itself.  In that case, this
+ * function only needs to adjust the targetlist of its cheapest_total_path.
+ * The only caller that may pass such a RelOptInfo currently is
+ * inheritance_planner.
+ *
  * tuple_fraction is the fraction of tuples we expect will be retrieved.
  * tuple_fraction is interpreted as follows:
  *	  0: expect all tuples to be retrieved (normal case)
@@ -1649,6 +1423,7 @@ inheritance_planner(PlannerInfo *root)
  */
 static void
 grouping_planner(PlannerInfo *root, bool inheritance_update,
+				 RelOptInfo *planned_rel,
 				 double tuple_fraction)
 {
 	Query	   *parse = root->parse;
@@ -1661,7 +1436,7 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 	List	   *final_targets;
 	List	   *final_targets_contain_srfs;
 	bool		final_target_parallel_safe;
-	RelOptInfo *current_rel;
+	RelOptInfo *current_rel = planned_rel;
 	RelOptInfo *final_rel;
 	ListCell   *lc;
 
@@ -1701,6 +1476,7 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 		 * special work for recursive unions is the responsibility of
 		 * plan_set_operations.
 		 */
+		Assert(current_rel == NULL);
 		current_rel = plan_set_operations(root);
 
 		/*
@@ -1790,17 +1566,26 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 				parse->groupClause = preprocess_groupclause(root, NIL);
 		}
 
-		/* Preprocess targetlist */
-		tlist = preprocess_targetlist(root);
-
 		/*
-		 * We are now done hacking up the query's targetlist.  Most of the
-		 * remaining planning work will be done with the PathTarget
-		 * representation of tlists, but save aside the full representation so
-		 * that we can transfer its decoration (resnames etc) to the topmost
-		 * tlist of the finished Plan.
+		 * Preprocess targetlist, if needed.  If the caller has already done
+		 * query planning, root->processed_tlist already contains the desired
+		 * targetlist.
 		 */
-		root->processed_tlist = tlist;
+		if (planned_rel == NULL)
+		{
+			tlist = preprocess_targetlist(root);
+
+			/*
+			 * We are now done hacking up the query's targetlist.  Most of the
+			 * remaining planning work will be done with the PathTarget
+			 * representation of tlists, but save aside the full representation
+			 * so that we can transfer its decoration (resnames etc) to the
+			 * topmost tlist of the finished Plan.
+			 */
+			root->processed_tlist = tlist;
+		}
+		else
+			tlist = root->processed_tlist;
 
 		/*
 		 * Collect statistics about aggregates for estimating costs, and mark
@@ -1880,8 +1665,9 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 		 * We also generate (in standard_qp_callback) pathkey representations
 		 * of the query's sort clause, distinct clause, etc.
 		 */
-		current_rel = query_planner(root, tlist,
-									standard_qp_callback, &qp_extra);
+		if (current_rel == NULL)
+			current_rel = query_planner(root, tlist,
+										standard_qp_callback, &qp_extra);
 
 		/*
 		 * Convert the query's result tlist into PathTarget format.
diff --git a/src/backend/optimizer/prep/prepjointree.c b/src/backend/optimizer/prep/prepjointree.c
index 77dbf4eba3..87adfa02b1 100644
--- a/src/backend/optimizer/prep/prepjointree.c
+++ b/src/backend/optimizer/prep/prepjointree.c
@@ -917,7 +917,6 @@ pull_up_simple_subquery(PlannerInfo *root, Node *jtnode, RangeTblEntry *rte,
 	subroot->grouping_map = NULL;
 	subroot->minmax_aggs = NIL;
 	subroot->qual_security_level = 0;
-	subroot->inhTargetKind = INHKIND_NONE;
 	subroot->hasRecursion = false;
 	subroot->wt_param_id = -1;
 	subroot->non_recursive_path = NULL;
diff --git a/src/backend/optimizer/util/appendinfo.c b/src/backend/optimizer/util/appendinfo.c
index 01040c5cfe..be6ce11da4 100644
--- a/src/backend/optimizer/util/appendinfo.c
+++ b/src/backend/optimizer/util/appendinfo.c
@@ -447,8 +447,39 @@ adjust_appendrel_attrs_mutator(Node *node,
 											  context->appinfos);
 		return (Node *) phv;
 	}
+
+	/*
+	 * This is needed, because inheritance_make_rel_from_joinlist needs to
+	 * translate root->join_info_list executing make_rel_from_joinlist for a
+	 * given child.
+	 */
+	if (IsA(node, SpecialJoinInfo))
+	{
+		SpecialJoinInfo *oldinfo = (SpecialJoinInfo *) node;
+		SpecialJoinInfo *newinfo = makeNode(SpecialJoinInfo);
+
+		memcpy(newinfo, oldinfo, sizeof(SpecialJoinInfo));
+		newinfo->min_lefthand = adjust_child_relids(oldinfo->min_lefthand,
+													context->nappinfos,
+													context->appinfos);
+		newinfo->min_righthand = adjust_child_relids(oldinfo->min_righthand,
+													 context->nappinfos,
+													 context->appinfos);
+		newinfo->syn_lefthand = adjust_child_relids(oldinfo->syn_lefthand,
+													context->nappinfos,
+													context->appinfos);
+		newinfo->syn_righthand = adjust_child_relids(oldinfo->syn_righthand,
+													 context->nappinfos,
+													 context->appinfos);
+		newinfo->semi_rhs_exprs =
+			(List *) expression_tree_mutator((Node *)
+											 oldinfo->semi_rhs_exprs,
+											 adjust_appendrel_attrs_mutator,
+											 (void *) context);
+		return (Node *) newinfo;
+	}
+
 	/* 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));
diff --git a/src/backend/optimizer/util/plancat.c b/src/backend/optimizer/util/plancat.c
index 48ffc5f254..51d8faf2dd 100644
--- a/src/backend/optimizer/util/plancat.c
+++ b/src/backend/optimizer/util/plancat.c
@@ -1264,36 +1264,6 @@ get_relation_constraints(PlannerInfo *root,
 		}
 	}
 
-	/*
-	 * Append partition predicates, if any.
-	 *
-	 * For selects, partition pruning uses the parent table's partition bound
-	 * descriptor, instead of constraint exclusion which is driven by the
-	 * individual partition's partition constraint.
-	 */
-	if (enable_partition_pruning && root->parse->commandType != CMD_SELECT)
-	{
-		List	   *pcqual = RelationGetPartitionQual(relation);
-
-		if (pcqual)
-		{
-			/*
-			 * Run the partition quals through const-simplification similar to
-			 * check constraints.  We skip canonicalize_qual, though, because
-			 * partition quals should be in canonical form already; also,
-			 * since the qual is in implicit-AND format, we'd have to
-			 * explicitly convert it to explicit-AND format and back again.
-			 */
-			pcqual = (List *) eval_const_expressions(root, (Node *) pcqual);
-
-			/* Fix Vars to have the desired varno */
-			if (varno != 1)
-				ChangeVarNodes((Node *) pcqual, 1, varno, 0);
-
-			result = list_concat(result, pcqual);
-		}
-	}
-
 	heap_close(relation, NoLock);
 
 	return result;
@@ -1420,31 +1390,15 @@ relation_excluded_by_constraints(PlannerInfo *root,
 	switch (constraint_exclusion)
 	{
 		case CONSTRAINT_EXCLUSION_OFF:
-
-			/*
-			 * Don't prune if feature turned off -- except if the relation is
-			 * a partition.  While partprune.c-style partition pruning is not
-			 * yet in use for all cases (update/delete is not handled), it
-			 * would be a UI horror to use different user-visible controls
-			 * depending on such a volatile implementation detail.  Therefore,
-			 * for partitioned tables we use enable_partition_pruning to
-			 * control this behavior.
-			 */
-			if (root->inhTargetKind == INHKIND_PARTITIONED)
-				break;
 			return false;
 
 		case CONSTRAINT_EXCLUSION_PARTITION:
 
 			/*
 			 * When constraint_exclusion is set to 'partition' we only handle
-			 * OTHER_MEMBER_RELs, or BASERELs in cases where the result target
-			 * is an inheritance parent or a partitioned table.
+			 * OTHER_MEMBER_RELs.
 			 */
-			if ((rel->reloptkind != RELOPT_OTHER_MEMBER_REL) &&
-				!(rel->reloptkind == RELOPT_BASEREL &&
-				  root->inhTargetKind != INHKIND_NONE &&
-				  rel->relid == root->parse->resultRelation))
+			if (rel->reloptkind != RELOPT_OTHER_MEMBER_REL)
 				return false;
 			break;
 
diff --git a/src/include/nodes/relation.h b/src/include/nodes/relation.h
index 3430061361..2fde95de7b 100644
--- a/src/include/nodes/relation.h
+++ b/src/include/nodes/relation.h
@@ -319,9 +319,6 @@ typedef struct PlannerInfo
 	Index		qual_security_level;	/* minimum security_level for quals */
 	/* Note: qual_security_level is zero if there are no securityQuals */
 
-	InheritanceKind inhTargetKind;	/* indicates if the target relation is an
-									 * inheritance child or partition or a
-									 * partitioned table */
 	bool		hasJoinRTEs;	/* true if any RTEs are RTE_JOIN kind */
 	bool		hasLateralRTEs; /* true if any RTEs are marked LATERAL */
 	bool		hasDeletedRTEs; /* true if any RTE was deleted from jointree */
@@ -343,6 +340,37 @@ typedef struct PlannerInfo
 
 	/* Does this query modify any partition key columns? */
 	bool		partColsUpdated;
+
+	/*
+	 * The following fields are set during query planning portion of an
+	 * inherited UPDATE/DEELETE operation.
+	 */
+
+	/*
+	 * This stores the original version of the query's targetlist that's
+	 * not modified by the planner.
+	 */
+	List	   *unexpanded_tlist;
+
+	/*
+	 * PlannerInfos corresponding to each inheritance child targets.
+	 * Content of each PlannerInfo is same as the parent PlannerInfo, except
+	 * for the parse tree which is a translated copy of the parent's parse
+	 * tree.
+	 */
+	struct PlannerInfo **inh_target_child_roots;
+
+	/* List of RT indexes of child RT indexes. */
+	List	   *inh_target_child_rels;
+
+	/*
+	 * RelOptInfos corresponding to each child target rel.  For leaf children,
+	 * it's the RelOptInfo representing the output of make_rel_from_joinlist()
+	 * called with the parent rel in the original join tree replaced by a
+	 * given leaf child.  For non-leaf children, it's the baserel RelOptInfo
+	 * itself, left as a placeholder.
+	 */
+	List	   *inh_target_child_joinrels;
 } PlannerInfo;
 
 
diff --git a/src/include/optimizer/paths.h b/src/include/optimizer/paths.h
index 666217c189..a39a0a3a74 100644
--- a/src/include/optimizer/paths.h
+++ b/src/include/optimizer/paths.h
@@ -161,7 +161,8 @@ extern EquivalenceClass *match_eclasses_to_foreign_key_col(PlannerInfo *root,
 extern void add_child_rel_equivalences(PlannerInfo *root,
 						   AppendRelInfo *appinfo,
 						   RelOptInfo *parent_rel,
-						   RelOptInfo *child_rel);
+						   RelOptInfo *child_rel,
+						   bool child_is_target);
 extern List *generate_implied_equalities_for_column(PlannerInfo *root,
 									   RelOptInfo *rel,
 									   ec_matches_callback_type callback,
diff --git a/src/test/regress/expected/partition_join.out b/src/test/regress/expected/partition_join.out
index c55de5d476..c9f02c1fb0 100644
--- a/src/test/regress/expected/partition_join.out
+++ b/src/test/regress/expected/partition_join.out
@@ -1780,7 +1780,7 @@ WHERE EXISTS (
                Filter: (c IS NULL)
          ->  Nested Loop
                ->  Seq Scan on int4_tbl
-               ->  Subquery Scan on ss_1
+               ->  Subquery Scan on ss
                      ->  Limit
                            ->  Seq Scan on int8_tbl int8_tbl_1
    ->  Nested Loop Semi Join
@@ -1788,7 +1788,7 @@ WHERE EXISTS (
                Filter: (c IS NULL)
          ->  Nested Loop
                ->  Seq Scan on int4_tbl
-               ->  Subquery Scan on ss_2
+               ->  Subquery Scan on ss
                      ->  Limit
                            ->  Seq Scan on int8_tbl int8_tbl_2
 (28 rows)
-- 
2.11.0

From b38220a1ebb112701dd1fe3ba378486e89d55a6f Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Fri, 26 Oct 2018 16:45:59 +0900
Subject: [PATCH v12 3/6] Store inheritance root parent index in otherrel's
 RelOptInfo

Although it's set by build_simple_rel, it's not being used by any
code yet.
---
 src/backend/nodes/outfuncs.c         |  1 +
 src/backend/optimizer/util/relnode.c | 14 ++++++++++++++
 src/include/nodes/relation.h         |  4 ++++
 3 files changed, 19 insertions(+)

diff --git a/src/backend/nodes/outfuncs.c b/src/backend/nodes/outfuncs.c
index f6112e1b4c..5248b5a764 100644
--- a/src/backend/nodes/outfuncs.c
+++ b/src/backend/nodes/outfuncs.c
@@ -2271,6 +2271,7 @@ _outRelOptInfo(StringInfo str, const RelOptInfo *node)
 	WRITE_BOOL_FIELD(consider_partitionwise_join);
 	WRITE_BITMAPSET_FIELD(top_parent_relids);
 	WRITE_NODE_FIELD(partitioned_child_rels);
+	WRITE_UINT_FIELD(inh_root_parent);
 }
 
 static void
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index fe83ec4519..678da0ce55 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -216,9 +216,23 @@ build_simple_rel(PlannerInfo *root, int relid, RelOptInfo *parent)
 			rel->top_parent_relids = parent->top_parent_relids;
 		else
 			rel->top_parent_relids = bms_copy(parent->relids);
+
+		/*
+		 * For inheritance child relations, we also set inh_root_parent.
+		 * Note that 'parent' might itself be a child (a sub-partitioned
+		 * partition), in which case we simply use its value of
+		 * inh_root_parent.
+		 */
+		if (parent->rtekind == RTE_RELATION)
+			rel->inh_root_parent = parent->inh_root_parent > 0 ?
+										parent->inh_root_parent :
+										parent->relid;
 	}
 	else
+	{
 		rel->top_parent_relids = NULL;
+		rel->inh_root_parent = 0;
+	}
 
 	/* Check type of rtable entry */
 	switch (rte->rtekind)
diff --git a/src/include/nodes/relation.h b/src/include/nodes/relation.h
index 2fde95de7b..a2adbfc3b8 100644
--- a/src/include/nodes/relation.h
+++ b/src/include/nodes/relation.h
@@ -731,6 +731,10 @@ typedef struct RelOptInfo
 	List	  **partexprs;		/* Non-nullable partition key expressions. */
 	List	  **nullable_partexprs; /* Nullable partition key expressions. */
 	List	   *partitioned_child_rels; /* List of RT indexes. */
+
+	Index		inh_root_parent;	/* For otherrels, this is the RT index of
+									 * inheritance table mentioned in the query
+									 * from which this relation originated */
 } RelOptInfo;
 
 /*
-- 
2.11.0

From fd629f03b3ba94ace91ceb3ccfd7866f74f484d3 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Wed, 17 Oct 2018 18:14:13 +0900
Subject: [PATCH v12 4/6] Lazy creation of RTEs for inheritance children

Currently, expand_inherited_tables called from subquery_planner opens
all inheritance child tables and adds them to the query's range
table and PlannerInfo in the form of AppendRelInfo's initially and
later RelOptInfo's.  For partitioning, that's pretty wasteful, because
it's possible to determine only the partitions that will need to be
scanned using partition pruning, which doesn't require opening the
partitions themselves.  However, the point at which the above
processing happens is too early to perform partition pruning.

This commit rearranges things within the planner so that inheritance
child relations can be added to the Query and PlannerInfo during
make_one_rel, just before set_base_rel_sizes is called.  Although the
late initialization approach only benefits the partitioning case, it
seems undesirable to do it only for partitioned tables, because it
means adding code to handle partitions specially at various places
within the planner.  So, *all* inheritance parent tables are expanded
in make_one_rel.  All unpruned partitions are added to Query in the
form of their RangeTblEntry's being added to the range table and to
PlannerInfo in the form of an AppendRelInfo and a RelOptInfo for each.

For partitioning, although we don't create a RangeTblEntry and
RelOptInfo for pruned partitions at make_one_rel time, partitionwise
join code relies on the fact that even though partitions may have
been pruned, they'd still own a RelOptInfo to handle the outer join
case where the pruned partition appears on the nullable side of join.
Partitionwise join code deals with that by allocating dummy
RelOptInfos for pruned partitions that are based mostly on their
parent's properties.

There are some regression test diffs:

 1. Caused by the fact that we no longer allocate a duplicate RT
    entry for a partitioned table in its role as child, as seen in
    the partition_aggregate.out test output.

 2. Those in postgres_fdw.out are caused by the fact that junk columns
    required for row marking are added to reltarget->exprs later than
    user columns, because the row marking junk columns arent added
    until after the inheritance is expanded which as of this commit
    is later than it used to be.
---
 contrib/postgres_fdw/expected/postgres_fdw.out    |  32 +-
 src/backend/optimizer/path/allpaths.c             | 355 +---------
 src/backend/optimizer/path/joinrels.c             |  61 ++
 src/backend/optimizer/plan/initsplan.c            |  58 --
 src/backend/optimizer/plan/planmain.c             |  12 +-
 src/backend/optimizer/plan/planner.c              |  65 +-
 src/backend/optimizer/plan/setrefs.c              |   6 +
 src/backend/optimizer/prep/preptlist.c            |  15 +-
 src/backend/optimizer/prep/prepunion.c            |   4 +
 src/backend/optimizer/util/appendinfo.c           |  45 +-
 src/backend/optimizer/util/inherit.c              | 797 +++++++++++++++-------
 src/backend/optimizer/util/plancat.c              |  40 +-
 src/backend/optimizer/util/relnode.c              |  80 +--
 src/backend/partitioning/partprune.c              |  43 +-
 src/include/nodes/relation.h                      |   8 +
 src/include/optimizer/appendinfo.h                |   7 +-
 src/include/optimizer/pathnode.h                  |   1 +
 src/include/optimizer/plancat.h                   |   2 +-
 src/include/optimizer/prep.h                      |   3 +-
 src/include/partitioning/partprune.h              |   2 +-
 src/test/regress/expected/partition_aggregate.out |   4 +-
 21 files changed, 874 insertions(+), 766 deletions(-)

diff --git a/contrib/postgres_fdw/expected/postgres_fdw.out b/contrib/postgres_fdw/expected/postgres_fdw.out
index bb92d9d37a..33a33606ef 100644
--- a/contrib/postgres_fdw/expected/postgres_fdw.out
+++ b/contrib/postgres_fdw/expected/postgres_fdw.out
@@ -7072,15 +7072,15 @@ select * from bar where f1 in (select f1 from foo) for update;
                      Output: bar2.f1, bar2.f2, bar2.ctid, bar2.*, bar2.tableoid
                      Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct2 FOR UPDATE
          ->  Hash
-               Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+               Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                ->  HashAggregate
-                     Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                     Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                      Group Key: foo.f1
                      ->  Append
                            ->  Seq Scan on public.foo
-                                 Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                                 Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                            ->  Foreign Scan on public.foo2
-                                 Output: foo2.ctid, foo2.*, foo2.tableoid, foo2.f1
+                                 Output: foo2.f1, foo2.ctid, foo2.*, foo2.tableoid
                                  Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct1
 (23 rows)
 
@@ -7110,15 +7110,15 @@ select * from bar where f1 in (select f1 from foo) for share;
                      Output: bar2.f1, bar2.f2, bar2.ctid, bar2.*, bar2.tableoid
                      Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct2 FOR SHARE
          ->  Hash
-               Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+               Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                ->  HashAggregate
-                     Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                     Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                      Group Key: foo.f1
                      ->  Append
                            ->  Seq Scan on public.foo
-                                 Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                                 Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                            ->  Foreign Scan on public.foo2
-                                 Output: foo2.ctid, foo2.*, foo2.tableoid, foo2.f1
+                                 Output: foo2.f1, foo2.ctid, foo2.*, foo2.tableoid
                                  Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct1
 (23 rows)
 
@@ -7147,15 +7147,15 @@ update bar set f2 = f2 + 100 where f1 in (select f1 from foo);
          ->  Seq Scan on public.bar
                Output: bar.f1, bar.f2, bar.ctid
          ->  Hash
-               Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+               Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                ->  HashAggregate
-                     Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                     Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                      Group Key: foo.f1
                      ->  Append
                            ->  Seq Scan on public.foo
-                                 Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                                 Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                            ->  Foreign Scan on public.foo2
-                                 Output: foo2.ctid, foo2.*, foo2.tableoid, foo2.f1
+                                 Output: foo2.f1, foo2.ctid, foo2.*, foo2.tableoid
                                  Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct1
    ->  Hash Join
          Output: bar2.f1, (bar2.f2 + 100), bar2.f3, bar2.ctid, foo.ctid, foo.*, foo.tableoid
@@ -7165,15 +7165,15 @@ update bar set f2 = f2 + 100 where f1 in (select f1 from foo);
                Output: bar2.f1, bar2.f2, bar2.f3, bar2.ctid
                Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct2 FOR UPDATE
          ->  Hash
-               Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+               Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                ->  HashAggregate
-                     Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                     Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                      Group Key: foo.f1
                      ->  Append
                            ->  Seq Scan on public.foo
-                                 Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                                 Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                            ->  Foreign Scan on public.foo2
-                                 Output: foo2.ctid, foo2.*, foo2.tableoid, foo2.f1
+                                 Output: foo2.f1, foo2.ctid, foo2.*, foo2.tableoid
                                  Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct1
 (39 rows)
 
diff --git a/src/backend/optimizer/path/allpaths.c b/src/backend/optimizer/path/allpaths.c
index 8c72cab9c9..a3a686a153 100644
--- a/src/backend/optimizer/path/allpaths.c
+++ b/src/backend/optimizer/path/allpaths.c
@@ -46,7 +46,6 @@
 #include "optimizer/var.h"
 #include "parser/parse_clause.h"
 #include "parser/parsetree.h"
-#include "partitioning/partprune.h"
 #include "rewrite/rewriteManip.h"
 #include "utils/lsyscache.h"
 
@@ -380,7 +379,11 @@ set_rel_size(PlannerInfo *root, RelOptInfo *rel,
 		 */
 		set_dummy_rel_pathlist(rel);
 	}
-	else if (rte->inh)
+	/*
+	 * expand_inherited_tables may have proved that the relation is empty, so
+	 * check if it's so.
+	 */
+	else if (rte->inh && !IS_DUMMY_REL(rel))
 	{
 		/*
 		 * If it's a target relation, set the sizes of children instead.
@@ -951,38 +954,18 @@ set_inherit_target_rel_sizes(PlannerInfo *root, RelOptInfo *rel,
 	int			parentRTindex = rti;
 	ListCell   *l;
 	bool		has_live_children;
-	Relids		live_children = NULL;
-	bool		did_pruning = false;
 
 	/* Guard against stack overflow due to overly deep inheritance tree. */
 	check_stack_depth();
 
 	Assert(IS_SIMPLE_REL(rel));
 
-	/*
-	 * If the partitioned relation has any baserestrictinfo quals then we
-	 * attempt to use these quals to prune away partitions that cannot
-	 * possibly contain any tuples matching these quals.  In this case we'll
-	 * store the relids of all partitions which could possibly contain a
-	 * matching tuple, and skip anything else in the loop below.
-	 */
-	if (enable_partition_pruning &&
-		rte->relkind == RELKIND_PARTITIONED_TABLE &&
-		rel->baserestrictinfo != NIL)
-	{
-		live_children = prune_append_rel_partitions(rel);
-		did_pruning = true;
-	}
-
 	foreach(l, root->append_rel_list)
 	{
 		AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(l);
 		int			childRTindex;
 		RangeTblEntry *childRTE;
 		RelOptInfo *childrel;
-		List	   *childquals;
-		Index		cq_min_security;
-		bool		have_const_false_cq;
 		PlannerInfo *subroot;
 		ListCell   *lc;
 		List	   *translated_exprs,
@@ -997,139 +980,18 @@ set_inherit_target_rel_sizes(PlannerInfo *root, RelOptInfo *rel,
 		subroot = root->inh_target_child_roots[childRTindex];
 
 		/*
-		 * The child rel's RelOptInfo was already created during
-		 * add_base_rels_to_query.
+		 * The child rel's RelOptInfo is created during
+		 * expand_inherited_tables().
 		 */
 		childrel = find_base_rel(root, childRTindex);
 		Assert(childrel->reloptkind == RELOPT_OTHER_MEMBER_REL);
 
 		/*
-		 * We have to copy the parent's quals to the child, with appropriate
-		 * substitution of variables.  However, only the baserestrictinfo
-		 * quals are needed before we can check for constraint exclusion; so
-		 * do that first and then check to see if we can disregard this child.
-		 *
-		 * The child rel's targetlist might contain non-Var expressions, which
-		 * means that substitution into the quals could produce opportunities
-		 * for const-simplification, and perhaps even pseudoconstant quals.
-		 * Therefore, transform each RestrictInfo separately to see if it
-		 * reduces to a constant or pseudoconstant.  (We must process them
-		 * separately to keep track of the security level of each qual.)
+		 * Child relation may have been marked dummy if build_append_child_rel
+		 * found self-contradictory quals.
 		 */
-		childquals = NIL;
-		cq_min_security = UINT_MAX;
-		have_const_false_cq = false;
-		foreach(lc, rel->baserestrictinfo)
-		{
-			RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
-			Node	   *childqual;
-			ListCell   *lc2;
-
-			Assert(IsA(rinfo, RestrictInfo));
-			childqual = adjust_appendrel_attrs(root,
-											   (Node *) rinfo->clause,
-											   1, &appinfo);
-			childqual = eval_const_expressions(root, childqual);
-			/* check for flat-out constant */
-			if (childqual && IsA(childqual, Const))
-			{
-				if (((Const *) childqual)->constisnull ||
-					!DatumGetBool(((Const *) childqual)->constvalue))
-				{
-					/* Restriction reduces to constant FALSE or NULL */
-					have_const_false_cq = true;
-					break;
-				}
-				/* Restriction reduces to constant TRUE, so drop it */
-				continue;
-			}
-			/* might have gotten an AND clause, if so flatten it */
-			foreach(lc2, make_ands_implicit((Expr *) childqual))
-			{
-				Node	   *onecq = (Node *) lfirst(lc2);
-				bool		pseudoconstant;
-
-				/* check for pseudoconstant (no Vars or volatile functions) */
-				pseudoconstant =
-					!contain_vars_of_level(onecq, 0) &&
-					!contain_volatile_functions(onecq);
-				if (pseudoconstant)
-				{
-					/* tell createplan.c to check for gating quals */
-					root->hasPseudoConstantQuals = true;
-				}
-				/* reconstitute RestrictInfo with appropriate properties */
-				childquals = lappend(childquals,
-									 make_restrictinfo((Expr *) onecq,
-													   rinfo->is_pushed_down,
-													   rinfo->outerjoin_delayed,
-													   pseudoconstant,
-													   rinfo->security_level,
-													   NULL, NULL, NULL));
-				/* track minimum security level among child quals */
-				cq_min_security = Min(cq_min_security, rinfo->security_level);
-			}
-		}
-
-		/*
-		 * In addition to the quals inherited from the parent, we might have
-		 * securityQuals associated with this particular child node.
-		 * (Currently this can only happen in appendrels originating from
-		 * UNION ALL; inheritance child tables don't have their own
-		 * securityQuals, see expand_inherited_rtentry().)	Pull any such
-		 * securityQuals up into the baserestrictinfo for the child.  This is
-		 * similar to process_security_barrier_quals() for the parent rel,
-		 * except that we can't make any general deductions from such quals,
-		 * since they don't hold for the whole appendrel.
-		 */
-		if (childRTE->securityQuals)
-		{
-			Index		security_level = 0;
-
-			foreach(lc, childRTE->securityQuals)
-			{
-				List	   *qualset = (List *) lfirst(lc);
-				ListCell   *lc2;
-
-				foreach(lc2, qualset)
-				{
-					Expr	   *qual = (Expr *) lfirst(lc2);
-
-					/* not likely that we'd see constants here, so no check */
-					childquals = lappend(childquals,
-										 make_restrictinfo(qual,
-														   true, false, false,
-														   security_level,
-														   NULL, NULL, NULL));
-					cq_min_security = Min(cq_min_security, security_level);
-				}
-				security_level++;
-			}
-			Assert(security_level <= root->qual_security_level);
-		}
-
-		/*
-		 * OK, we've got all the baserestrictinfo quals for this child.
-		 */
-		childrel->baserestrictinfo = childquals;
-		childrel->baserestrict_min_security = cq_min_security;
-
-		if (have_const_false_cq)
-		{
-			/*
-			 * Some restriction clause reduced to constant FALSE or NULL after
-			 * substitution, so this child need not be scanned.
-			 */
-			set_dummy_rel_pathlist(childrel);
+		if (IS_DUMMY_REL(childrel))
 			continue;
-		}
-
-		if (did_pruning && !bms_is_member(appinfo->child_relid, live_children))
-		{
-			/* This partition was pruned; skip it. */
-			set_dummy_rel_pathlist(childrel);
-			continue;
-		}
 
 		if (relation_excluded_by_constraints(root, childrel, childRTE))
 		{
@@ -1271,8 +1133,6 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 	double	   *parent_attrsizes;
 	int			nattrs;
 	ListCell   *l;
-	Relids		live_children = NULL;
-	bool		did_pruning = false;
 
 	/* Guard against stack overflow due to overly deep inheritance tree. */
 	check_stack_depth();
@@ -1280,32 +1140,6 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 	Assert(IS_SIMPLE_REL(rel));
 
 	/*
-	 * Initialize partitioned_child_rels to contain this RT index.
-	 *
-	 * Note that during the set_append_rel_pathlist() phase, we will bubble up
-	 * the indexes of partitioned relations that appear down in the tree, so
-	 * that when we've created Paths for all the children, the root
-	 * partitioned table's list will contain all such indexes.
-	 */
-	if (rte->relkind == RELKIND_PARTITIONED_TABLE)
-		rel->partitioned_child_rels = list_make1_int(rti);
-
-	/*
-	 * If the partitioned relation has any baserestrictinfo quals then we
-	 * attempt to use these quals to prune away partitions that cannot
-	 * possibly contain any tuples matching these quals.  In this case we'll
-	 * store the relids of all partitions which could possibly contain a
-	 * matching tuple, and skip anything else in the loop below.
-	 */
-	if (enable_partition_pruning &&
-		rte->relkind == RELKIND_PARTITIONED_TABLE &&
-		rel->baserestrictinfo != NIL)
-	{
-		live_children = prune_append_rel_partitions(rel);
-		did_pruning = true;
-	}
-
-	/*
 	 * If this is a partitioned baserel, set the consider_partitionwise_join
 	 * flag; currently, we only consider partitionwise joins with the baserel
 	 * if its targetlist doesn't contain a whole-row Var.
@@ -1342,12 +1176,8 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 		int			childRTindex;
 		RangeTblEntry *childRTE;
 		RelOptInfo *childrel;
-		List	   *childquals;
-		Index		cq_min_security;
-		bool		have_const_false_cq;
 		ListCell   *parentvars;
 		ListCell   *childvars;
-		ListCell   *lc;
 
 		/* append_rel_list contains all append rels; ignore others */
 		if (appinfo->parent_relid != parentRTindex)
@@ -1355,18 +1185,34 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 
 		childRTindex = appinfo->child_relid;
 		childRTE = root->simple_rte_array[childRTindex];
+		Assert(childRTE != NULL);
 
 		/*
-		 * The child rel's RelOptInfo was already created during
-		 * add_base_rels_to_query.
+		 * The child rel's RelOptInfo is created during
+		 * expand_inherited_tables().
 		 */
 		childrel = find_base_rel(root, childRTindex);
 		Assert(childrel->reloptkind == RELOPT_OTHER_MEMBER_REL);
 
 		/*
-		 * Copy/Modify targetlist. Even if this child is deemed empty, we need
-		 * its targetlist in case it falls on nullable side in a child-join
-		 * because of partitionwise join.
+		 * Child relation may have been marked dummy if build_append_child_rel
+		 * found self-contradictory quals.
+		 */
+		if (IS_DUMMY_REL(childrel))
+			continue;
+
+		if (relation_excluded_by_constraints(root, childrel, childRTE))
+		{
+			/*
+			 * This child need not be scanned, so we can omit it from the
+			 * appendrel.
+			 */
+			set_dummy_rel_pathlist(childrel);
+			continue;
+		}
+
+		/*
+		 * Copy/Modify targetlist.
 		 *
 		 * NB: the resulting childrel->reltarget->exprs may contain arbitrary
 		 * expressions, which otherwise would not occur in a rel's targetlist.
@@ -1396,144 +1242,6 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 									   false);
 		childrel->has_eclass_joins = rel->has_eclass_joins;
 
-		/*
-		 * We have to copy the parent's quals to the child, with appropriate
-		 * substitution of variables.  However, only the baserestrictinfo
-		 * quals are needed before we can check for constraint exclusion; so
-		 * do that first and then check to see if we can disregard this child.
-		 *
-		 * The child rel's targetlist might contain non-Var expressions, which
-		 * means that substitution into the quals could produce opportunities
-		 * for const-simplification, and perhaps even pseudoconstant quals.
-		 * Therefore, transform each RestrictInfo separately to see if it
-		 * reduces to a constant or pseudoconstant.  (We must process them
-		 * separately to keep track of the security level of each qual.)
-		 */
-		childquals = NIL;
-		cq_min_security = UINT_MAX;
-		have_const_false_cq = false;
-		foreach(lc, rel->baserestrictinfo)
-		{
-			RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
-			Node	   *childqual;
-			ListCell   *lc2;
-
-			Assert(IsA(rinfo, RestrictInfo));
-			childqual = adjust_appendrel_attrs(root,
-											   (Node *) rinfo->clause,
-											   1, &appinfo);
-			childqual = eval_const_expressions(root, childqual);
-			/* check for flat-out constant */
-			if (childqual && IsA(childqual, Const))
-			{
-				if (((Const *) childqual)->constisnull ||
-					!DatumGetBool(((Const *) childqual)->constvalue))
-				{
-					/* Restriction reduces to constant FALSE or NULL */
-					have_const_false_cq = true;
-					break;
-				}
-				/* Restriction reduces to constant TRUE, so drop it */
-				continue;
-			}
-			/* might have gotten an AND clause, if so flatten it */
-			foreach(lc2, make_ands_implicit((Expr *) childqual))
-			{
-				Node	   *onecq = (Node *) lfirst(lc2);
-				bool		pseudoconstant;
-
-				/* check for pseudoconstant (no Vars or volatile functions) */
-				pseudoconstant =
-					!contain_vars_of_level(onecq, 0) &&
-					!contain_volatile_functions(onecq);
-				if (pseudoconstant)
-				{
-					/* tell createplan.c to check for gating quals */
-					root->hasPseudoConstantQuals = true;
-				}
-				/* reconstitute RestrictInfo with appropriate properties */
-				childquals = lappend(childquals,
-									 make_restrictinfo((Expr *) onecq,
-													   rinfo->is_pushed_down,
-													   rinfo->outerjoin_delayed,
-													   pseudoconstant,
-													   rinfo->security_level,
-													   NULL, NULL, NULL));
-				/* track minimum security level among child quals */
-				cq_min_security = Min(cq_min_security, rinfo->security_level);
-			}
-		}
-
-		/*
-		 * In addition to the quals inherited from the parent, we might have
-		 * securityQuals associated with this particular child node.
-		 * (Currently this can only happen in appendrels originating from
-		 * UNION ALL; inheritance child tables don't have their own
-		 * securityQuals, see expand_inherited_rtentry().)	Pull any such
-		 * securityQuals up into the baserestrictinfo for the child.  This is
-		 * similar to process_security_barrier_quals() for the parent rel,
-		 * except that we can't make any general deductions from such quals,
-		 * since they don't hold for the whole appendrel.
-		 */
-		if (childRTE->securityQuals)
-		{
-			Index		security_level = 0;
-
-			foreach(lc, childRTE->securityQuals)
-			{
-				List	   *qualset = (List *) lfirst(lc);
-				ListCell   *lc2;
-
-				foreach(lc2, qualset)
-				{
-					Expr	   *qual = (Expr *) lfirst(lc2);
-
-					/* not likely that we'd see constants here, so no check */
-					childquals = lappend(childquals,
-										 make_restrictinfo(qual,
-														   true, false, false,
-														   security_level,
-														   NULL, NULL, NULL));
-					cq_min_security = Min(cq_min_security, security_level);
-				}
-				security_level++;
-			}
-			Assert(security_level <= root->qual_security_level);
-		}
-
-		/*
-		 * OK, we've got all the baserestrictinfo quals for this child.
-		 */
-		childrel->baserestrictinfo = childquals;
-		childrel->baserestrict_min_security = cq_min_security;
-
-		if (have_const_false_cq)
-		{
-			/*
-			 * Some restriction clause reduced to constant FALSE or NULL after
-			 * substitution, so this child need not be scanned.
-			 */
-			set_dummy_rel_pathlist(childrel);
-			continue;
-		}
-
-		if (did_pruning && !bms_is_member(appinfo->child_relid, live_children))
-		{
-			/* This partition was pruned; skip it. */
-			set_dummy_rel_pathlist(childrel);
-			continue;
-		}
-
-		if (relation_excluded_by_constraints(root, childrel, childRTE))
-		{
-			/*
-			 * This child need not be scanned, so we can omit it from the
-			 * appendrel.
-			 */
-			set_dummy_rel_pathlist(childrel);
-			continue;
-		}
-
 		/* CE failed, so finish copying/modifying join quals. */
 		childrel->joininfo = (List *)
 			adjust_appendrel_attrs(root,
@@ -3070,6 +2778,7 @@ inheritance_make_rel_from_joinlist(PlannerInfo *root, List *joinlist)
 		subroot = root->inh_target_child_roots[appinfo->child_relid];
 		Assert(subroot->parse->resultRelation > 0);
 		childrel = find_base_rel(root, appinfo->child_relid);
+		Assert(childrel != NULL);
 
 		/* Ignore excluded/pruned children. */
 		if (IS_DUMMY_REL(childrel))
diff --git a/src/backend/optimizer/path/joinrels.c b/src/backend/optimizer/path/joinrels.c
index 22ca4d999a..297e47b424 100644
--- a/src/backend/optimizer/path/joinrels.c
+++ b/src/backend/optimizer/path/joinrels.c
@@ -21,6 +21,7 @@
 #include "optimizer/pathnode.h"
 #include "optimizer/paths.h"
 #include "optimizer/prep.h"
+#include "optimizer/tlist.h"
 #include "partitioning/partbounds.h"
 #include "utils/lsyscache.h"
 #include "utils/memutils.h"
@@ -47,6 +48,9 @@ static void try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1,
 					   List *parent_restrictlist);
 static int match_expr_to_partition_keys(Expr *expr, RelOptInfo *rel,
 							 bool strict_op);
+static RelOptInfo *build_dummy_partition_rel(PlannerInfo *root,
+									RelOptInfo *parent,
+									int partidx);
 
 
 /*
@@ -1377,6 +1381,11 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
 		AppendRelInfo **appinfos;
 		int			nappinfos;
 
+		if (child_rel1 == NULL)
+			child_rel1 = build_dummy_partition_rel(root, rel1, cnt_parts);
+		if (child_rel2 == NULL)
+			child_rel2 = build_dummy_partition_rel(root, rel2, cnt_parts);
+
 		/* We should never try to join two overlapping sets of rels. */
 		Assert(!bms_overlap(child_rel1->relids, child_rel2->relids));
 		child_joinrelids = bms_union(child_rel1->relids, child_rel2->relids);
@@ -1583,3 +1592,55 @@ match_expr_to_partition_keys(Expr *expr, RelOptInfo *rel, bool strict_op)
 
 	return -1;
 }
+
+/*
+ * build_dummy_partition_rel
+ *		Build a RelOptInfo and AppendRelInfo for a pruned partition
+ *
+ * This does not result in opening the relation or a range table entry being
+ * created.  Also, the RelOptInfo thus created is not stored anywhere else
+ * beside the parent's part_rels array.
+ *
+ * The only reason this exists is because partition-wise join, in some cases,
+ * needs a RelOptInfo to represent an empty relation that's on the nullable
+ * side of an outer join, so that a Path representing the outer join can be
+ * created.
+ */
+RelOptInfo *
+build_dummy_partition_rel(PlannerInfo *root, RelOptInfo *parent, int partidx)
+{
+	RangeTblEntry *parentrte = root->simple_rte_array[parent->relid];
+	RelOptInfo *rel;
+
+	Assert(parent->part_rels[partidx] == NULL);
+
+	/* Create minimally valid-looking RelOptInfo with parent's relid. */
+	rel = makeNode(RelOptInfo);
+	rel->reloptkind = RELOPT_OTHER_MEMBER_REL;
+	rel->relid = parent->relid;
+	rel->relids = bms_copy(parent->relids);
+	if (parent->top_parent_relids)
+		rel->top_parent_relids = parent->top_parent_relids;
+	else
+		rel->top_parent_relids = bms_copy(parent->relids);
+	rel->reltarget = copy_pathtarget(parent->reltarget);
+	parent->part_rels[partidx] = rel;
+	mark_dummy_rel(rel);
+
+	/*
+	 * Now we'll need a (no-op) AppendRelInfo for parent, because we're
+	 * setting the dummy partition's relid to be same as the parent's.
+	 */
+	if (root->append_rel_array[parent->relid] == NULL)
+	{
+		AppendRelInfo *appinfo = make_append_rel_info(parent, parentrte,
+													  parent->tupdesc,
+													  parentrte->relid,
+													  parent->reltype,
+													  parent->relid);
+
+		root->append_rel_array[parent->relid] = appinfo;
+	}
+
+	return rel;
+}
diff --git a/src/backend/optimizer/plan/initsplan.c b/src/backend/optimizer/plan/initsplan.c
index a66374094f..c628f3d9e7 100644
--- a/src/backend/optimizer/plan/initsplan.c
+++ b/src/backend/optimizer/plan/initsplan.c
@@ -616,64 +616,6 @@ create_lateral_join_info(PlannerInfo *root)
 				bms_add_member(brel2->lateral_referencers, rti);
 		}
 	}
-
-	/*
-	 * Lastly, propagate lateral_relids and lateral_referencers from appendrel
-	 * parent rels to their child rels.  We intentionally give each child rel
-	 * the same minimum parameterization, even though it's quite possible that
-	 * some don't reference all the lateral rels.  This is because any append
-	 * path for the parent will have to have the same parameterization for
-	 * every child anyway, and there's no value in forcing extra
-	 * reparameterize_path() calls.  Similarly, a lateral reference to the
-	 * parent prevents use of otherwise-movable join rels for each child.
-	 */
-	for (rti = 1; rti < root->simple_rel_array_size; rti++)
-	{
-		RelOptInfo *brel = root->simple_rel_array[rti];
-		RangeTblEntry *brte = root->simple_rte_array[rti];
-
-		/*
-		 * Skip empty slots. Also skip non-simple relations i.e. dead
-		 * relations.
-		 */
-		if (brel == NULL || !IS_SIMPLE_REL(brel))
-			continue;
-
-		/*
-		 * In the case of table inheritance, the parent RTE is directly linked
-		 * to every child table via an AppendRelInfo.  In the case of table
-		 * partitioning, the inheritance hierarchy is expanded one level at a
-		 * time rather than flattened.  Therefore, an other member rel that is
-		 * a partitioned table may have children of its own, and must
-		 * therefore be marked with the appropriate lateral info so that those
-		 * children eventually get marked also.
-		 */
-		Assert(brte);
-		if (brel->reloptkind == RELOPT_OTHER_MEMBER_REL &&
-			(brte->rtekind != RTE_RELATION ||
-			 brte->relkind != RELKIND_PARTITIONED_TABLE))
-			continue;
-
-		if (brte->inh)
-		{
-			foreach(lc, root->append_rel_list)
-			{
-				AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(lc);
-				RelOptInfo *childrel;
-
-				if (appinfo->parent_relid != rti)
-					continue;
-				childrel = root->simple_rel_array[appinfo->child_relid];
-				Assert(childrel->reloptkind == RELOPT_OTHER_MEMBER_REL);
-				Assert(childrel->direct_lateral_relids == NULL);
-				childrel->direct_lateral_relids = brel->direct_lateral_relids;
-				Assert(childrel->lateral_relids == NULL);
-				childrel->lateral_relids = brel->lateral_relids;
-				Assert(childrel->lateral_referencers == NULL);
-				childrel->lateral_referencers = brel->lateral_referencers;
-			}
-		}
-	}
 }
 
 
diff --git a/src/backend/optimizer/plan/planmain.c b/src/backend/optimizer/plan/planmain.c
index 4f68ad9907..825998ad51 100644
--- a/src/backend/optimizer/plan/planmain.c
+++ b/src/backend/optimizer/plan/planmain.c
@@ -258,6 +258,16 @@ query_planner(PlannerInfo *root, List *tlist,
 		root->all_baserels = bms_add_member(root->all_baserels, brel->relid);
 	}
 
+	/*
+	 * Expand RT entries that represent inherited or partitioned tables.
+	 * This will perform partition pruning on partitioned tables in the
+	 * original range table and also recursively on any child partitioned
+	 * tables that were added by the expansion of the original parent(s).
+	 * As new entries are added to the range table, various arrays in the
+	 * PlannerInfo will be expanded accordingly.
+	 */
+	expand_inherited_tables(root);
+
 	inherited_update = (parse->resultRelation &&
 						root->simple_rte_array[parse->resultRelation]->inh);
 
@@ -369,7 +379,7 @@ adjust_inherited_target_child_root(PlannerInfo *root, AppendRelInfo *appinfo)
 	 * column, filling placeholder entries for dropped columns, etc., all of
 	 * which occurs with the child's TupleDesc.
 	 */
-	tlist = preprocess_targetlist(subroot);
+	tlist = preprocess_targetlist(subroot, true);
 	subroot->processed_tlist = tlist;
 
 	/* Add any newly added Vars to the child RelOptInfo. */
diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index bea89dd8dd..648858237a 100644
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -23,6 +23,7 @@
 #include "access/sysattr.h"
 #include "access/xact.h"
 #include "catalog/pg_constraint.h"
+#include "catalog/pg_inherits.h"
 #include "catalog/pg_proc.h"
 #include "catalog/pg_type.h"
 #include "executor/executor.h"
@@ -701,27 +702,24 @@ subquery_planner(PlannerGlobal *glob, Query *parse,
 		}
 		if (rte->lateral)
 			root->hasLateralRTEs = true;
+
+		/*
+		 * While at it, also update the inh status.  If the relation doesn't
+		 * or can't have any children, there is no point in letting inh be set
+		 * to true.  Note that we do this before processing rowmarks, so that
+		 * the correct information for setting isParent field of PlanRowMarks.
+		 */
+		if (rte->rtekind == RTE_RELATION)
+			rte->inh = rte->inh && has_subclass(rte->relid);
 	}
 
 	/*
 	 * Preprocess RowMark information.  We need to do this after subquery
-	 * pullup (so that all non-inherited RTEs are present) and before
-	 * inheritance expansion (so that the info is available for
-	 * expand_inherited_tables to examine and modify).
+	 * pullup (so that all non-inherited RTEs are present).
 	 */
 	preprocess_rowmarks(root);
 
 	/*
-	 * Expand any rangetable entries that are inheritance sets into "append
-	 * relations".  This can add entries to the rangetable, but they must be
-	 * plain base relations not joins, so it's OK (and marginally more
-	 * efficient) to do it after checking for join RTEs.  We must do it after
-	 * pulling up subqueries, else we'd fail to handle inherited tables in
-	 * subqueries.
-	 */
-	expand_inherited_tables(root);
-
-	/*
 	 * Set hasHavingQual to remember if HAVING clause is present.  Needed
 	 * because preprocess_expression will reduce a constant-true condition to
 	 * an empty qual list ... but "HAVING TRUE" is not a semantic no-op.
@@ -1214,8 +1212,11 @@ inheritance_planner(PlannerInfo *root)
 	 */
 	root->unexpanded_tlist = list_copy(root->parse->targetList);
 
-	/* Do the scan/join planning. */
-	tlist = preprocess_targetlist(root);
+	/*
+	 * Do the scan/join planning.  We haven't expanded inheritance yet, so
+	 * pass false.
+	 */
+	tlist = preprocess_targetlist(root, false);
 	root->processed_tlist = tlist;
 	qp_extra.tlist = tlist;
 	qp_extra.activeWindows = qp_extra.groupClause = NIL;
@@ -1224,9 +1225,10 @@ inheritance_planner(PlannerInfo *root)
 	/*
 	 * If it turned out during query planning that all the children are dummy
 	 * (pruned or excluded by constraints), no need to do the steps below.
-	 * Let grouping_planner finish up the final path.
+	 * For regular inheritance case, it's possible that we only need to modify
+	 * the parent table.  Let grouping_planner finish up the final path.
 	 */
-	if (IS_DUMMY_REL(planned_rel))
+	if (!parent_rte->inh || IS_DUMMY_REL(planned_rel))
 	{
 		grouping_planner(root, false, planned_rel, 0.0);
 		return;
@@ -1573,14 +1575,19 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 		 */
 		if (planned_rel == NULL)
 		{
-			tlist = preprocess_targetlist(root);
+			/* We haven't expanded inheritance yet, so pass false. */
+			tlist = preprocess_targetlist(root, false);
 
 			/*
-			 * We are now done hacking up the query's targetlist.  Most of the
-			 * remaining planning work will be done with the PathTarget
-			 * representation of tlists, but save aside the full representation
-			 * so that we can transfer its decoration (resnames etc) to the
-			 * topmost tlist of the finished Plan.
+			 * We are now mostly done hacking up the query's targetlist.  More
+			 * columns might be added during query_planner after inheritance
+			 * expansion in make_one_rel, because some children may require
+			 * different column than the parent for row mark handling; see
+			 * add_rowmark_junk_columns().  Most of the remaining planning
+			 * work will be done with the PathTarget representation of tlists,
+			 * but save aside the full representation so that we can transfer
+			 * its decoration (resnames etc) to the topmost tlist of the
+			 * finished Plan.
 			 */
 			root->processed_tlist = tlist;
 		}
@@ -2356,7 +2363,7 @@ preprocess_rowmarks(PlannerInfo *root)
 		newrc->allMarkTypes = (1 << newrc->markType);
 		newrc->strength = rc->strength;
 		newrc->waitPolicy = rc->waitPolicy;
-		newrc->isParent = false;
+		newrc->isParent = rte->inh;
 
 		prowmarks = lappend(prowmarks, newrc);
 	}
@@ -2381,7 +2388,7 @@ preprocess_rowmarks(PlannerInfo *root)
 		newrc->allMarkTypes = (1 << newrc->markType);
 		newrc->strength = LCS_NONE;
 		newrc->waitPolicy = LockWaitBlock;	/* doesn't matter */
-		newrc->isParent = false;
+		newrc->isParent = rte->rtekind == RTE_RELATION ? rte->inh : false;
 
 		prowmarks = lappend(prowmarks, newrc);
 	}
@@ -6818,6 +6825,10 @@ apply_scanjoin_target_to_paths(PlannerInfo *root,
 			int			nappinfos;
 			List	   *child_scanjoin_targets = NIL;
 
+			/* Skip processing pruned partitions. */
+			if (child_rel == NULL)
+				continue;
+
 			/* Translate scan/join targets for this child. */
 			appinfos = find_appinfos_by_relids(root, child_rel->relids,
 											   &nappinfos);
@@ -6919,6 +6930,10 @@ create_partitionwise_grouping_paths(PlannerInfo *root,
 		RelOptInfo *child_grouped_rel;
 		RelOptInfo *child_partially_grouped_rel;
 
+		/* Skip processing pruned partitions. */
+		if (child_input_rel == NULL)
+			continue;
+
 		/* Input child rel must have a path */
 		Assert(child_input_rel->pathlist != NIL);
 
diff --git a/src/backend/optimizer/plan/setrefs.c b/src/backend/optimizer/plan/setrefs.c
index fc7ba0dea2..baced8126c 100644
--- a/src/backend/optimizer/plan/setrefs.c
+++ b/src/backend/optimizer/plan/setrefs.c
@@ -325,6 +325,12 @@ add_rtes_to_flat_rtable(PlannerInfo *root, bool recursing)
 													  UPPERREL_FINAL, NULL)))
 					add_rtes_to_flat_rtable(rel->subroot, true);
 			}
+			/*
+			 * A NULL rel also means an unplanned subquery rte, so apply
+			 * flatten_unplanned_rtes.
+			 */
+			else
+				flatten_unplanned_rtes(glob, rte);
 		}
 		rti++;
 	}
diff --git a/src/backend/optimizer/prep/preptlist.c b/src/backend/optimizer/prep/preptlist.c
index f8bc2dd257..a55949c305 100644
--- a/src/backend/optimizer/prep/preptlist.c
+++ b/src/backend/optimizer/prep/preptlist.c
@@ -65,9 +65,13 @@ static List *expand_targetlist(List *tlist, int command_type,
  *
  * As a side effect, if there's an ON CONFLICT UPDATE clause, its targetlist
  * is also preprocessed (and updated in-place).
+ *
+ * inheritance_expanded specifies whether inheritance tables are expanded
+ * as of calling this function.  Caller must specify it because that affects
+ * which row marking related junk columns get added to the targetlist.
  */
 List *
-preprocess_targetlist(PlannerInfo *root)
+preprocess_targetlist(PlannerInfo *root, bool inheritance_expanded)
 {
 	Query	   *parse = root->parse;
 	int			result_relation = parse->resultRelation;
@@ -134,6 +138,15 @@ preprocess_targetlist(PlannerInfo *root)
 		if (rc->rti != rc->prti)
 			continue;
 
+		/*
+		 * For inheritance parent row marks, we defer adding junk columns
+		 * until we've added child row marks, because some children might
+		 * require different row mark types which will change the parent row
+		 * mark's allMarkTypes fields.
+		 */
+		if (rc->isParent && !inheritance_expanded)
+			continue;
+
 		if (rc->allMarkTypes & ~(1 << ROW_MARK_COPY))
 		{
 			/* Need to fetch TID */
diff --git a/src/backend/optimizer/prep/prepunion.c b/src/backend/optimizer/prep/prepunion.c
index 5d59385ef7..ba8e88c672 100644
--- a/src/backend/optimizer/prep/prepunion.c
+++ b/src/backend/optimizer/prep/prepunion.c
@@ -34,15 +34,19 @@
 #include "miscadmin.h"
 #include "nodes/makefuncs.h"
 #include "nodes/nodeFuncs.h"
+#include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
 #include "optimizer/paths.h"
 #include "optimizer/planmain.h"
 #include "optimizer/planner.h"
 #include "optimizer/prep.h"
+#include "optimizer/restrictinfo.h"
 #include "optimizer/tlist.h"
+#include "optimizer/var.h"
 #include "parser/parse_coerce.h"
 #include "parser/parsetree.h"
+#include "partitioning/partprune.h"
 #include "utils/lsyscache.h"
 #include "utils/rel.h"
 #include "utils/selfuncs.h"
diff --git a/src/backend/optimizer/util/appendinfo.c b/src/backend/optimizer/util/appendinfo.c
index be6ce11da4..06a39bb92d 100644
--- a/src/backend/optimizer/util/appendinfo.c
+++ b/src/backend/optimizer/util/appendinfo.c
@@ -31,10 +31,10 @@ typedef struct
 	AppendRelInfo **appinfos;
 } adjust_appendrel_attrs_context;
 
-static void make_inh_translation_list(Relation oldrelation,
-						  Relation newrelation,
-						  Index newvarno,
-						  List **translated_vars);
+static void make_inh_translation_list(TupleDesc old_tupdesc,
+						  TupleDesc new_tupdesc,
+						  Oid from_rel, Oid to_rel,
+						  Index newvarno, List **translated_vars);
 static Node *adjust_appendrel_attrs_mutator(Node *node,
 							   adjust_appendrel_attrs_context *context);
 static Relids adjust_child_relids(Relids relids, int nappinfos,
@@ -47,18 +47,20 @@ static List *adjust_inherited_tlist(List *tlist,
  *	  Build an AppendRelInfo for the parent-child pair
  */
 AppendRelInfo *
-make_append_rel_info(Relation parentrel, Relation childrel,
-					 Index parentRTindex, Index childRTindex)
+make_append_rel_info(RelOptInfo *parent, RangeTblEntry *parentrte,
+					 TupleDesc childdesc, Oid childoid, Oid childtype,
+					 Index childRTindex)
 {
 	AppendRelInfo  *appinfo = makeNode(AppendRelInfo);
 
-	appinfo->parent_relid = parentRTindex;
+	appinfo->parent_relid = parent->relid;
 	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->translated_vars);
-	appinfo->parent_reloid = RelationGetRelid(parentrel);
+	appinfo->parent_reltype = parent->reltype;
+	appinfo->child_reltype = childtype;
+	make_inh_translation_list(parent->tupdesc, childdesc,
+							  parentrte->relid, childoid,
+							  childRTindex, &appinfo->translated_vars);
+	appinfo->parent_reloid = parentrte->relid;
 
 	return appinfo;
 }
@@ -71,14 +73,11 @@ make_append_rel_info(Relation parentrel, Relation childrel,
  * For paranoia's sake, we match type/collation as well as attribute name.
  */
 static void
-make_inh_translation_list(Relation oldrelation, Relation newrelation,
-						  Index newvarno,
-						  List **translated_vars)
+make_inh_translation_list(TupleDesc old_tupdesc, TupleDesc new_tupdesc,
+						  Oid from_rel, Oid to_rel,
+						  Index newvarno, List **translated_vars)
 {
 	List	   *vars = NIL;
-	TupleDesc	old_tupdesc = RelationGetDescr(oldrelation);
-	TupleDesc	new_tupdesc = RelationGetDescr(newrelation);
-	Oid			new_relid = RelationGetRelid(newrelation);
 	int			oldnatts = old_tupdesc->natts;
 	int			newnatts = new_tupdesc->natts;
 	int			old_attno;
@@ -108,7 +107,7 @@ make_inh_translation_list(Relation oldrelation, Relation newrelation,
 		 * When we are generating the "translation list" for the parent table
 		 * of an inheritance set, no need to search for matches.
 		 */
-		if (oldrelation == newrelation)
+		if (from_rel == to_rel)
 		{
 			vars = lappend(vars, makeVar(newvarno,
 										 (AttrNumber) (old_attno + 1),
@@ -134,10 +133,10 @@ make_inh_translation_list(Relation oldrelation, Relation newrelation,
 		{
 			HeapTuple	newtup;
 
-			newtup = SearchSysCacheAttName(new_relid, attname);
+			newtup = SearchSysCacheAttName(to_rel, attname);
 			if (!newtup)
 				elog(ERROR, "could not find inherited attribute \"%s\" of relation \"%s\"",
-					 attname, RelationGetRelationName(newrelation));
+					 attname, get_rel_name(to_rel));
 			new_attno = ((Form_pg_attribute) GETSTRUCT(newtup))->attnum - 1;
 			ReleaseSysCache(newtup);
 
@@ -147,10 +146,10 @@ make_inh_translation_list(Relation oldrelation, Relation newrelation,
 		/* Found it, check type and collation match */
 		if (atttypid != att->atttypid || atttypmod != att->atttypmod)
 			elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's type",
-				 attname, RelationGetRelationName(newrelation));
+				 attname, get_rel_name(to_rel));
 		if (attcollation != att->attcollation)
 			elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's collation",
-				 attname, RelationGetRelationName(newrelation));
+				 attname, get_rel_name(to_rel));
 
 		vars = lappend(vars, makeVar(newvarno,
 									 (AttrNumber) (new_attno + 1),
diff --git a/src/backend/optimizer/util/inherit.c b/src/backend/optimizer/util/inherit.c
index 243d61da8f..0412917fc1 100644
--- a/src/backend/optimizer/util/inherit.c
+++ b/src/backend/optimizer/util/inherit.c
@@ -38,19 +38,22 @@
 #include "partitioning/partprune.h"
 #include "utils/rel.h"
 
+static void expand_append_rtentry(PlannerInfo *root, RelOptInfo *rel,
+					  RangeTblEntry *rte, Index rti);
 static void expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte,
-						 Index rti);
+						 Index rti, RelOptInfo *rel);
 static void expand_partitioned_rtentry(PlannerInfo *root,
 						   RangeTblEntry *parentrte,
-						   Index parentRTindex, Relation parentrel,
-						   PlanRowMark *top_parentrc, LOCKMODE lockmode,
-						   List **appinfos);
-static void expand_single_inheritance_child(PlannerInfo *root,
-								RangeTblEntry *parentrte,
-								Index parentRTindex, Relation parentrel,
-								PlanRowMark *top_parentrc, Relation childrel,
-								List **appinfos, RangeTblEntry **childrte_p,
-								Index *childRTindex_p);
+						   Index parentRTindex, RelOptInfo *parentrel);
+static RelOptInfo *add_inheritance_child_rel(PlannerInfo *root,
+						  RangeTblEntry *parentrte,
+						  Index parentRTindex, RelOptInfo *parentrel,
+						  PlanRowMark *top_parentrc, Relation childrel,
+						  RangeTblEntry **childrte_p, Index *childRTindex_p);
+static RelOptInfo *build_append_child_rel(PlannerInfo *root,
+					   RelOptInfo *parent,
+					   Index childRTindex);
+static List *add_rowmark_junk_columns(PlannerInfo *root, PlanRowMark *rc);
 
 /*
  * expand_inherited_tables
@@ -62,33 +65,134 @@ static void expand_single_inheritance_child(PlannerInfo *root,
 void
 expand_inherited_tables(PlannerInfo *root)
 {
-	Index		nrtes;
+	int			orig_rtable_size;
 	Index		rti;
-	ListCell   *rl;
+
+	Assert(root->simple_rel_array_size > 0);
+	orig_rtable_size = root->simple_rel_array_size;
 
 	/*
-	 * expand_inherited_rtentry may add RTEs to parse->rtable. The function is
+	 * expand_append_rtentry may add RTEs to parse->rtable. The function is
 	 * expected to recursively handle any RTEs that it creates with inh=true.
 	 * So just scan as far as the original end of the rtable list.
 	 */
-	nrtes = list_length(root->parse->rtable);
-	rl = list_head(root->parse->rtable);
-	for (rti = 1; rti <= nrtes; rti++)
+	for (rti = 1; rti < orig_rtable_size; rti++)
 	{
-		RangeTblEntry *rte = (RangeTblEntry *) lfirst(rl);
+		RelOptInfo *brel = root->simple_rel_array[rti];
+		RangeTblEntry *rte = root->simple_rte_array[rti];
 
-		expand_inherited_rtentry(root, rte, rti);
-		rl = lnext(rl);
+		/* there may be empty slots corresponding to non-baserel RTEs */
+		if (brel == NULL)
+			continue;
+
+		if (rte->inh)
+			expand_append_rtentry(root, brel, rte, rti);
+	}
+}
+
+/*
+ * expand_append_rtentry
+ *		This initializes RelOptInfos for an appendrel's child relations, if
+ *		any
+ *
+ * 'rel' is the appendrel parent, whose range table entry ('rte') has been
+ * marked to require adding children.  An appendrel parent could either
+ * be a subquery (if we flattened UNION ALL query) or a table that's known
+ * to have inheritance children.  The latter consists of both regular
+ * inheritance parents and partitioned tables.
+ *
+ * For a subquery parent, there is not much to be done here because the
+ * children's RTEs are already present in the query, so we just initialize
+ * RelOptInfos for them.  Also, the AppendRelInfos for child subqueries
+ * have already been added.
+ *
+ * For tables, we need to add the children to the range table and initialize
+ * AppendRelInfos, RelOptInfos, and PlanRowMarks (if any) for them.  For
+ * a partitioned parent, we only add the children remaining after pruning.
+ * For regular inheritance parents, we find the children using
+ * find_all_inheritors and add all of them.
+ *
+ * If it turns out that there are no children, then we set rte->inh to false
+ * to let the caller know that only the parent table needs to be scanned.  The
+ * caller can accordingly switch to a non-Append path.  For a partitioned
+ * parent, that means an empty relation because parents themselves contain no
+ * data.
+ *
+ * For the regular inheritance case, the parent also gets another RTE with
+ * inh = false to represent it as an appendrel child.  The original RTE is
+ * considered to represent the whole inheritance set.
+ */
+static void
+expand_append_rtentry(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte,
+					  Index rti)
+{
+	Assert(rte->inh);
+	/* Inheritance parent (partitioned or not) or UNION ALL parent subquery. */
+	Assert(rte->rtekind == RTE_RELATION || rte->rtekind == RTE_SUBQUERY);
+
+	/*
+	 * UNION ALL children already got RTEs and AppendRelInfos, so just build
+	 * RelOptInfos and return.
+	 *
+	 * It might be a bit odd that this code is in this, because there is
+	 * nothing to expand really.
+	 */
+	if (rte->rtekind == RTE_SUBQUERY)
+	{
+		ListCell   *l;
+
+		/*
+		 * We don't need to use expand_planner_arrays in this case, because
+		 * no new child RTEs are created.  setup_simple_rel_arrays() and
+		 * setup_append_rel_array would've considered these child RTEs when
+		 * allocating space for various arrays.
+		 */
+		foreach(l, root->append_rel_list)
+		{
+			AppendRelInfo *appinfo = lfirst(l);
+			Index		childRTindex = appinfo->child_relid;
+
+			if (appinfo->parent_relid != rti)
+				continue;
+
+			Assert(childRTindex < root->simple_rel_array_size);
+			Assert(root->simple_rte_array[childRTindex] != NULL);
+
+			/*
+			 * We set the correct value of baserestricinfo and
+			 * baserestrict_min_security below.
+			 */
+			root->simple_rel_array[childRTindex] =
+				build_append_child_rel(root, rel, appinfo->child_relid);
+		}
+	}
+	else
+	{
+		Assert(rte->rtekind == RTE_RELATION);
+		Assert(has_subclass(rte->relid));
+
+		/*
+		 * The rewriter should already have obtained an appropriate lock on
+		 * each relation named in the query.  However, for each child relation
+		 * we add to the query, we must obtain an appropriate lock, because
+		 * this will be the first use of those relations in the
+		 * parse/rewrite/plan pipeline.  Child rels should use the same
+		 * lockmode as their parent.
+		 */
+		Assert(rte->rellockmode != NoLock);
+
+		if (rte->relkind == RELKIND_PARTITIONED_TABLE)
+			expand_partitioned_rtentry(root, rte, rti, rel);
+		else
+			expand_inherited_rtentry(root, rte, rti, rel);
 	}
 }
 
 /*
  * expand_inherited_rtentry
- *		Check whether a rangetable entry represents an inheritance set.
- *		If so, add entries for all the child tables to the query's
- *		rangetable, and build AppendRelInfo nodes for all the child tables
- *		and add them to root->append_rel_list.  If not, clear the entry's
- *		"inh" flag to prevent later code from looking for AppendRelInfos.
+ *		Add entries for all the child tables to the query's rangetable, and
+ *		build AppendRelInfo nodes for all the child tables and add them to
+ *		root->append_rel_list.
  *
  * Note that the original RTE is considered to represent the whole
  * inheritance set.  The first of the generated RTEs is an RTE for the same
@@ -99,55 +203,33 @@ expand_inherited_tables(PlannerInfo *root)
  * regular inheritance, a parent RTE must always have at least two associated
  * AppendRelInfos: one corresponding to the parent table as a simple member of
  * inheritance set and one or more corresponding to the actual children.
- * Since a partitioned table is not scanned, it might have only one associated
- * AppendRelInfo.
  */
 static void
-expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti)
+expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti,
+						 RelOptInfo *rel)
 {
 	Oid			parentOID;
 	PlanRowMark *oldrc;
-	Relation	oldrelation;
-	LOCKMODE	lockmode;
+	LOCKMODE	lockmode = rte->rellockmode;
 	List	   *inhOIDs;
 	ListCell   *l;
+	int			num_children;
+	int			num_children_added = 0;
 
-	/* Does RT entry allow inheritance? */
-	if (!rte->inh)
-		return;
-	/* Ignore any already-expanded UNION ALL nodes */
-	if (rte->rtekind != RTE_RELATION)
-	{
-		Assert(rte->rtekind == RTE_SUBQUERY);
-		return;
-	}
-	/* Fast path for common case of childless table */
+	Assert(rte->rtekind == RTE_RELATION);
+	Assert(lockmode != NoLock);
 	parentOID = rte->relid;
-	if (!has_subclass(parentOID))
-	{
-		/* Clear flag before returning */
-		rte->inh = false;
-		return;
-	}
-
-	/*
-	 * The rewriter should already have obtained an appropriate lock on each
-	 * relation named in the query.  However, for each child relation we add
-	 * to the query, we must obtain an appropriate lock, because this will be
-	 * the first use of those relations in the parse/rewrite/plan pipeline.
-	 * Child rels should use the same lockmode as their parent.
-	 */
-	lockmode = rte->rellockmode;
 
 	/* Scan for all members of inheritance set, acquire needed locks */
 	inhOIDs = find_all_inheritors(parentOID, lockmode, NULL);
 
 	/*
 	 * Check that there's at least one descendant, else treat as no-child
-	 * case.  This could happen despite above has_subclass() check, if table
-	 * once had a child but no longer does.
+	 * case.  This could happen despite has_subclass() check performed by
+	 * subquery_planner, if table once had a child but no longer does.
 	 */
-	if (list_length(inhOIDs) < 2)
+	num_children = list_length(inhOIDs);
+	if (num_children < 2)
 	{
 		/* Clear flag before returning */
 		rte->inh = false;
@@ -155,216 +237,219 @@ expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti)
 	}
 
 	/*
-	 * If parent relation is selected FOR UPDATE/SHARE, we need to mark its
-	 * PlanRowMark as isParent = true, and generate a new PlanRowMark for each
-	 * child.
+	 * If parent relation is selected FOR UPDATE/SHARE, preprocess_rowmarks
+	 * should've set isParent = true.  We'll generate a new PlanRowMark for
+	 * each child.
 	 */
 	oldrc = get_plan_rowmark(root->rowMarks, rti);
-	if (oldrc)
-		oldrc->isParent = true;
+	Assert(oldrc == NULL || oldrc->isParent);
 
 	/*
-	 * Must open the parent relation to examine its tupdesc.  We need not lock
-	 * it; we assume the rewriter already did.
+	 * Must expand PlannerInfo arrays by num_children before we can add
+	 * children.
 	 */
-	oldrelation = heap_open(parentOID, NoLock);
+	expand_planner_arrays(root, num_children);
 
-	/* Scan the inheritance set and expand it */
-	if (RelationGetPartitionDesc(oldrelation) != NULL)
+	foreach(l, inhOIDs)
 	{
-		Assert(rte->relkind == RELKIND_PARTITIONED_TABLE);
-
-		/*
-		 * If this table has partitions, recursively expand them in the order
-		 * in which they appear in the PartitionDesc.  While at it, also
-		 * extract the partition key columns of all the partitioned tables.
-		 */
-		expand_partitioned_rtentry(root, rte, rti, oldrelation, oldrc,
-								   lockmode, &root->append_rel_list);
-	}
-	else
-	{
-		List	   *appinfos = NIL;
+		Oid			childOID = lfirst_oid(l);
+		Relation	newrelation;
 		RangeTblEntry *childrte;
 		Index		childRTindex;
 
+		/* Already locked above. */
+		newrelation = heap_open(childOID, NoLock);
+
 		/*
-		 * This table has no partitions.  Expand any plain inheritance
-		 * children in the order the OIDs were returned by
-		 * find_all_inheritors.
+		 * It is possible that the parent table has children that are temp
+		 * tables of other backends.  We cannot safely access such tables
+		 * (because of buffering issues), and the best thing to do seems
+		 * to be to silently ignore them.
 		 */
-		foreach(l, inhOIDs)
+		if (RELATION_IS_OTHER_TEMP(newrelation))
 		{
-			Oid			childOID = lfirst_oid(l);
-			Relation	newrelation;
-
-			/* Open rel if needed; we already have required locks */
-			if (childOID != parentOID)
-				newrelation = heap_open(childOID, NoLock);
-			else
-				newrelation = oldrelation;
-
-			/*
-			 * It is possible that the parent table has children that are temp
-			 * tables of other backends.  We cannot safely access such tables
-			 * (because of buffering issues), and the best thing to do seems
-			 * to be to silently ignore them.
-			 */
-			if (childOID != parentOID && RELATION_IS_OTHER_TEMP(newrelation))
-			{
-				heap_close(newrelation, lockmode);
-				continue;
-			}
-
-			expand_single_inheritance_child(root, rte, rti, oldrelation, oldrc,
-											newrelation,
-											&appinfos, &childrte,
-											&childRTindex);
-
-			/* Close child relations, but keep locks */
-			if (childOID != parentOID)
-				heap_close(newrelation, NoLock);
+			heap_close(newrelation, lockmode);
+			continue;
 		}
 
-		/*
-		 * If all the children were temp tables, pretend it's a
-		 * non-inheritance situation; we don't need Append node in that case.
-		 * The duplicate RTE we added for the parent table is harmless, so we
-		 * don't bother to get rid of it; ditto for the useless PlanRowMark
-		 * node.
-		 */
-		if (list_length(appinfos) < 2)
-			rte->inh = false;
-		else
-			root->append_rel_list = list_concat(root->append_rel_list,
-												appinfos);
+		(void) add_inheritance_child_rel(root, rte, rti, rel, oldrc,
+										 newrelation, &childrte,
+										 &childRTindex);
+		Assert(childrte != NULL);
+		/* All regular inheritance children are leaf children. */
+		Assert(!childrte->inh);
+		Assert(childRTindex > 0);
 
+		/* Close child relations, but keep locks */
+		heap_close(newrelation, NoLock);
+		num_children_added++;
 	}
 
-	heap_close(oldrelation, NoLock);
+	/*
+	 * If all children, including the parent (as child rel), were
+	 * excluded, mark the parent rel as empty.  If all the children were temp
+	 * tables, pretend it's a non-inheritance situation; we don't need Append
+	 * node in that case.  The duplicate RTE we added for the parent table is
+	 * harmless, so we don't bother to get rid of it; ditto for the useless
+	 * PlanRowMark node.
+	 */
+	if (num_children_added == 0)
+		mark_dummy_rel(rel);
+	else if (num_children_added == 1)
+		rte->inh = false;
+
+	/*
+	 * Add junk columns needed by the row mark if any and also add the
+	 * relevant expressions to the root parent's reltarget.
+	 */
+	if (oldrc)
+	{
+		List   *tlist = add_rowmark_junk_columns(root, oldrc);
+
+		build_base_rel_tlists(root, tlist);
+	}
 }
 
 /*
  * expand_partitioned_rtentry
- *		Recursively expand an RTE for a partitioned table.
+ *		Prunes unnecessary partitions of a partitioned table and adds
+ *		remaining ones to the Query and the PlannerInfo
+ *
+ * Partitions are added to the query in order in which they are found in
+ * the parent's PartitionDesc.
+ *
+ * Note: even though only the unpruned partitions will be added to the
+ * resulting plan, this still locks *all* partitions via find_all_inheritors
+ * when this function is called for the root partitioned table.
  */
 static void
 expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
-						   Index parentRTindex, Relation parentrel,
-						   PlanRowMark *top_parentrc, LOCKMODE lockmode,
-						   List **appinfos)
+						   Index parentRTindex, RelOptInfo *parentrel)
 {
+	LOCKMODE	lockmode = parentrte->rellockmode;
+	PlanRowMark *rootrc = NULL;
 	int			i;
-	RangeTblEntry *childrte;
-	Index		childRTindex;
-	PartitionDesc partdesc = RelationGetPartitionDesc(parentrel);
+	Bitmapset  *partindexes;
+	Index		rootParentRTindex = parentrel->inh_root_parent > 0 ?
+									parentrel->inh_root_parent :
+									parentRTindex;
 
-	check_stack_depth();
-
-	/* A partitioned table should always have a partition descriptor. */
-	Assert(partdesc);
-
-	Assert(parentrte->inh);
+	/* If root partitioned table, lock *all* partitions in the tree. */
+	if (parentRTindex == rootParentRTindex)
+		(void) find_all_inheritors(parentrte->relid, lockmode, NULL);
 
 	/*
-	 * Note down whether any partition key cols are being updated. Though it's
-	 * the root partitioned table's updatedCols we are interested in, we
-	 * instead use parentrte to get the updatedCols. This is convenient
-	 * because parentrte already has the root partrel's updatedCols translated
-	 * to match the attribute ordering of parentrel.
+	 * Initialize partitioned_child_rels to contain this RT index.
+	 *
+	 * Note that during the set_append_rel_pathlist() phase, values of the
+	 * indexes of partitioned relations that appear down in the tree will be
+	 * bubbled up into root parent's list so that when we've created Paths for
+	 * all the children, the root table's list will contain all such indexes.
 	 */
-	if (!root->partColsUpdated)
-		root->partColsUpdated =
-			has_partition_attrs(parentrel, parentrte->updatedCols, NULL);
+	parentrel->partitioned_child_rels = list_make1_int(parentRTindex);
 
-	/* First expand the partitioned table itself. */
-	expand_single_inheritance_child(root, parentrte, parentRTindex, parentrel,
-									top_parentrc, parentrel,
-									appinfos, &childrte, &childRTindex);
+	/* Perform pruning. */
+	partindexes = prune_append_rel_partitions(parentrel);
+
+	/* Must expand PlannerInfo arrays before we can add children. */
+	expand_planner_arrays(root, bms_num_members(partindexes));
 
 	/*
-	 * If the partitioned table has no partitions, treat this as the
-	 * non-inheritance case.
+	 * For partitioned tables, we also store the partition RelOptInfo
+	 * pointers in the parent's RelOptInfo.
 	 */
-	if (partdesc->nparts == 0)
-	{
-		parentrte->inh = false;
-		return;
-	}
+	parentrel->part_rels = (RelOptInfo **) palloc0(sizeof(RelOptInfo *) *
+												   parentrel->nparts);
 
-	for (i = 0; i < partdesc->nparts; i++)
+	rootrc = get_plan_rowmark(root->rowMarks, rootParentRTindex);
+	Assert(rootrc == NULL || rootrc->isParent);
+	i = -1;
+	while ((i = bms_next_member(partindexes, i)) >= 0)
 	{
-		Oid			childOID = partdesc->oids[i];
-		Relation	childrel;
+		Oid		childOID = parentrel->part_oids[i];
+		Relation	newrelation;
+		RelOptInfo *childrel;
+		RangeTblEntry *childrte;
+		Index		childRTindex;
 
-		/* Open rel; we already have required locks */
-		childrel = heap_open(childOID, NoLock);
+		/* Already locked above. */
+		newrelation = heap_open(childOID, NoLock);
+		Assert(!RELATION_IS_OTHER_TEMP(newrelation));
 
 		/*
-		 * Temporary partitions belonging to other sessions should have been
-		 * disallowed at definition, but for paranoia's sake, let's double
-		 * check.
+		 * A partitioned child table with 0 children is a dummy rel, so don't
+		 * bother creating planner objects for it.
 		 */
-		if (RELATION_IS_OTHER_TEMP(childrel))
-			elog(ERROR, "temporary relation from another session found as partition");
+		if (newrelation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE &&
+			RelationGetPartitionDesc(newrelation)->nparts == 0)
+		{
+			heap_close(newrelation, NoLock);
+			continue;
+		}
 
-		expand_single_inheritance_child(root, parentrte, parentRTindex,
-										parentrel, top_parentrc, childrel,
-										appinfos, &childrte, &childRTindex);
+		childrel = add_inheritance_child_rel(root, parentrte, parentRTindex,
+											 parentrel, rootrc, newrelation,
+											 &childrte, &childRTindex);
+		Assert(childrel != NULL);
+		parentrel->part_rels[i] = childrel;
 
-		/* If this child is itself partitioned, recurse */
-		if (childrel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
+		/* Close child relations, but keep locks */
+		heap_close(newrelation, NoLock);
+
+		/* If the child is partitioned itself, expand it too. */
+		if (childrel->part_scheme)
+		{
+			Assert(childrte->inh);
 			expand_partitioned_rtentry(root, childrte, childRTindex,
-									   childrel, top_parentrc, lockmode,
-									   appinfos);
+									   childrel);
+		}
+	}
 
-		/* Close child relation, but keep locks */
-		heap_close(childrel, NoLock);
+	/*
+	 * Add junk columns needed by the row mark if any and also add the
+	 * relevant expressions to the root parent's reltarget.
+	 */
+	if (rootrc)
+	{
+		List   *tlist = add_rowmark_junk_columns(root, rootrc);
+
+		build_base_rel_tlists(root, tlist);
 	}
 }
 
 /*
- * expand_single_inheritance_child
- *		Build a RangeTblEntry and an AppendRelInfo, if appropriate, plus
- *		maybe a PlanRowMark.
+ * add_inheritance_child_rel
+ *		Build a RangeTblEntry, an AppendRelInfo, a PlanRowMark, and finally
+ *		a RelOptInfo for an inheritance child relation.
  *
- * We now expand the partition hierarchy level by level, creating a
- * corresponding hierarchy of AppendRelInfos and RelOptInfos, where each
- * partitioned descendant acts as a parent of its immediate partitions.
- * (This is a difference from what older versions of PostgreSQL did and what
- * is still done in the case of table inheritance for unpartitioned tables,
- * where the hierarchy is flattened during RTE expansion.)
+ * The return value is the RelOptInfo that's added.
  *
  * PlanRowMarks still carry the top-parent's RTI, and the top-parent's
  * allMarkTypes field still accumulates values from all descendents.
  *
  * "parentrte" and "parentRTindex" are immediate parent's RTE and
  * RTI. "top_parentrc" is top parent's PlanRowMark.
- *
- * The child RangeTblEntry and its RTI are returned in "childrte_p" and
- * "childRTindex_p" resp.
  */
-static void
-expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte,
-								Index parentRTindex, Relation parentrel,
-								PlanRowMark *top_parentrc, Relation childrel,
-								List **appinfos, RangeTblEntry **childrte_p,
-								Index *childRTindex_p)
+static RelOptInfo *
+add_inheritance_child_rel(PlannerInfo *root, RangeTblEntry *parentrte,
+						  Index parentRTindex, RelOptInfo *parentrel,
+						  PlanRowMark *top_parentrc, Relation childrel,
+						  RangeTblEntry **childrte_p, Index *childRTindex_p)
 {
 	Query	   *parse = root->parse;
-	Oid			parentOID = RelationGetRelid(parentrel);
 	Oid			childOID = RelationGetRelid(childrel);
 	RangeTblEntry *childrte;
 	Index		childRTindex;
 	AppendRelInfo *appinfo;
+	RelOptInfo *childrelopt;
 
 	/*
 	 * Build an RTE for the child, and attach to query's rangetable list. We
 	 * copy most fields of the parent's RTE, but replace relation OID and
-	 * relkind, and set inh = false.  Also, set requiredPerms to zero since
-	 * all required permissions checks are done on the original RTE. Likewise,
-	 * set the child's securityQuals to empty, because we only want to apply
-	 * the parent's RLS conditions regardless of what RLS properties
+	 * relkind, and set inh appropriately.  Also, set requiredPerms to zero
+	 * since all required permissions checks are done on the original RTE.
+	 * Likewise, set the child's securityQuals to empty, because we only want
+	 * to apply the parent's RLS conditions regardless of what RLS properties
 	 * individual children may have.  (This is an intentional choice to make
 	 * inherited RLS work like regular permissions checks.) The parent
 	 * securityQuals will be propagated to children along with other base
@@ -374,49 +459,42 @@ expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte,
 	*childrte_p = childrte;
 	childrte->relid = childOID;
 	childrte->relkind = childrel->rd_rel->relkind;
-	/* A partitioned child will need to be expanded further. */
-	if (childOID != parentOID &&
-		childrte->relkind == RELKIND_PARTITIONED_TABLE)
-		childrte->inh = true;
-	else
-		childrte->inh = false;
+	/*
+	 * A partitioned child will need to be expanded as an append parent
+	 * itself, so set its inh to true.
+	 */
+	childrte->inh = (childrte->relkind == RELKIND_PARTITIONED_TABLE);
 	childrte->requiredPerms = 0;
 	childrte->securityQuals = NIL;
 	parse->rtable = lappend(parse->rtable, childrte);
 	childRTindex = list_length(parse->rtable);
 	*childRTindex_p = childRTindex;
 
-	/*
-	 * We need an AppendRelInfo if paths will be built for the child RTE. If
-	 * childrte->inh is true, then we'll always need to generate append paths
-	 * for it.  If childrte->inh is false, we must scan it if it's not a
-	 * partitioned table; but if it is a partitioned table, then it never has
-	 * any data of its own and need not be scanned.
-	 */
-	if (childrte->relkind != RELKIND_PARTITIONED_TABLE || childrte->inh)
-	{
-		appinfo = make_append_rel_info(parentrel, childrel,
-									   parentRTindex, childRTindex);
-		*appinfos = lappend(*appinfos, appinfo);
+	/* Create an AppendRelInfo and add it to planner's global list. */
+	appinfo = make_append_rel_info(parentrel, parentrte,
+								   RelationGetDescr(childrel),
+								   RelationGetRelid(childrel),
+								   RelationGetForm(childrel)->reltype,
+								   childRTindex);
+	root->append_rel_list = lappend(root->append_rel_list, appinfo);
 
-		/*
-		 * Translate the column permissions bitmaps to the child's attnums (we
-		 * have to build the translated_vars list before we can do this). But
-		 * if this is the parent table, leave copyObject's result alone.
-		 *
-		 * Note: we need to do this even though the executor won't run any
-		 * permissions checks on the child RTE.  The insertedCols/updatedCols
-		 * bitmaps may be examined for trigger-firing purposes.
-		 */
-		if (childOID != parentOID)
-		{
-			childrte->selectedCols = translate_col_privs(parentrte->selectedCols,
-														 appinfo->translated_vars);
-			childrte->insertedCols = translate_col_privs(parentrte->insertedCols,
-														 appinfo->translated_vars);
-			childrte->updatedCols = translate_col_privs(parentrte->updatedCols,
-														appinfo->translated_vars);
-		}
+	/*
+	 * Translate the column permissions bitmaps to the child's attnums (we
+	 * have to build the translated_vars list before we can do this). But
+	 * if this is the parent table, leave copyObject's result alone.
+	 *
+	 * Note: we need to do this even though the executor won't run any
+	 * permissions checks on the child RTE.  The insertedCols/updatedCols
+	 * bitmaps may be examined for trigger-firing purposes.
+	 */
+	if (childrte->relid != parentrte->relid)
+	{
+		childrte->selectedCols = translate_col_privs(parentrte->selectedCols,
+													 appinfo->translated_vars);
+		childrte->insertedCols = translate_col_privs(parentrte->insertedCols,
+													 appinfo->translated_vars);
+		childrte->updatedCols = translate_col_privs(parentrte->updatedCols,
+													appinfo->translated_vars);
 	}
 
 	/*
@@ -448,4 +526,251 @@ expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte,
 
 		root->rowMarks = lappend(root->rowMarks, childrc);
 	}
+
+	/*
+	 * Add the RelOptInfo.  Even though we may not really scan this relation
+	 * for reasons such as contradictory quals, we still need to create one,
+	 * because for every RTE in the query's range table, there must be an
+	 * accompanying RelOptInfo.
+	 */
+
+	/* First, store the RTE and appinfos into planner arrays. */
+	Assert(root->simple_rte_array[childRTindex] == NULL);
+	root->simple_rte_array[childRTindex] = childrte;
+	Assert(root->append_rel_array[childRTindex] == NULL);
+	root->append_rel_array[childRTindex] = appinfo;
+
+	childrelopt = build_append_child_rel(root, parentrel, childRTindex);
+	Assert(childrelopt != NULL);
+
+	return childrelopt;
+}
+
+/*
+ *	build_append_child_rel
+ *		Build a RelOptInfo for child relation of an append rel
+ *
+ * After creating the RelOptInfo for the given child RT index, it goes on to
+ * initialize some of its fields based on the parent RelOptInfo.
+ *
+ * If the quals in baserestrictinfo turn out to be self-contradictory,
+ * RelOptInfo is marked dummy before returning.
+ */
+static RelOptInfo *
+build_append_child_rel(PlannerInfo *root,
+					   RelOptInfo *parent,
+					   Index childRTindex)
+{
+	RelOptInfo *childrel;
+	RangeTblEntry *childRTE = root->simple_rte_array[childRTindex];
+	AppendRelInfo *appinfo = root->append_rel_array[childRTindex];
+	List	   *childquals;
+	ListCell   *lc;
+	bool		have_const_false_cq;
+	Index		cq_min_security;
+
+	/* Build the RelOptInfo. */
+	childrel = build_simple_rel(root, childRTindex, parent);
+
+	/*
+	 * Propagate lateral_relids and lateral_referencers from appendrel
+	 * parent rels to their child rels.  We intentionally give each child rel
+	 * the same minimum parameterization, even though it's quite possible that
+	 * some don't reference all the lateral rels.  This is because any append
+	 * path for the parent will have to have the same parameterization for
+	 * every child anyway, and there's no value in forcing extra
+	 * reparameterize_path() calls.  Similarly, a lateral reference to the
+	 * parent prevents use of otherwise-movable join rels for each child.
+	 */
+	childrel->direct_lateral_relids = parent->direct_lateral_relids;
+	childrel->lateral_relids = parent->lateral_relids;
+	childrel->lateral_referencers = parent->lateral_referencers;
+
+	/*
+	 * We have to copy the parent's quals to the child, with appropriate
+	 * substitution of variables.  However, only the baserestrictinfo
+	 * quals are needed before we can check for constraint exclusion; so
+	 * do that first and then check to see if we can disregard this child.
+	 *
+	 * The child rel's targetlist might contain non-Var expressions, which
+	 * means that substitution into the quals could produce opportunities
+	 * for const-simplification, and perhaps even pseudoconstant quals.
+	 * Therefore, transform each RestrictInfo separately to see if it
+	 * reduces to a constant or pseudoconstant.  (We must process them
+	 * separately to keep track of the security level of each qual.)
+	 */
+	childquals = false;
+	cq_min_security = UINT_MAX;
+	have_const_false_cq = false;
+	foreach(lc, parent->baserestrictinfo)
+	{
+		RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
+		Node	   *childqual = (Node *) rinfo->clause;
+		ListCell   *lc2;
+
+		Assert(IsA(rinfo, RestrictInfo));
+		childqual = adjust_appendrel_attrs(root, childqual,
+										   1, &appinfo);
+		childqual = eval_const_expressions(root, childqual);
+		/* check for flat-out constant */
+		if (childqual && IsA(childqual, Const))
+		{
+			if (((Const *) childqual)->constisnull ||
+				!DatumGetBool(((Const *) childqual)->constvalue))
+			{
+				/* Restriction reduces to constant FALSE or NULL */
+				have_const_false_cq = true;
+				break;
+			}
+			/* Restriction reduces to constant TRUE, so drop it */
+			continue;
+		}
+		/* might have gotten an AND clause, if so flatten it */
+		foreach(lc2, make_ands_implicit((Expr *) childqual))
+		{
+			Node	   *onecq = (Node *) lfirst(lc2);
+			bool		pseudoconstant;
+
+			/* check for pseudoconstant (no Vars or volatile functions) */
+			pseudoconstant =
+					!contain_vars_of_level(onecq, 0) &&
+					!contain_volatile_functions(onecq);
+			if (pseudoconstant)
+			{
+				/* tell createplan.c to check for gating quals */
+				root->hasPseudoConstantQuals = true;
+			}
+			/* reconstitute RestrictInfo with appropriate properties */
+			childquals = lappend(childquals,
+								 make_restrictinfo((Expr *) onecq,
+												   rinfo->is_pushed_down,
+												   rinfo->outerjoin_delayed,
+												   pseudoconstant,
+												   rinfo->security_level,
+												   NULL, NULL, NULL));
+			cq_min_security = Min(cq_min_security, rinfo->security_level);
+		}
+	}
+
+	/*
+	 * In addition to the quals inherited from the parent, we might
+	 * have securityQuals associated with this particular child node.
+	 * (Currently this can only happen in appendrels originating from
+	 * UNION ALL; inheritance child tables don't have their own
+	 * securityQuals.)	Pull any such securityQuals up into the
+	 * baserestrictinfo for the child.  This is similar to
+	 * process_security_barrier_quals() for the parent rel, except
+	 * that we can't make any general deductions from such quals,
+	 * since they don't hold for the whole appendrel.
+	 */
+	if (childRTE->securityQuals)
+	{
+		Index		security_level = 0;
+
+		foreach(lc, childRTE->securityQuals)
+		{
+			List	   *qualset = (List *) lfirst(lc);
+			ListCell   *lc2;
+
+			foreach(lc2, qualset)
+			{
+				Expr	   *qual = (Expr *) lfirst(lc2);
+
+				/*
+				 * not likely that we'd see constants here, so no
+				 * check
+				 */
+				childquals = lappend(childquals,
+									 make_restrictinfo(qual,
+													   true,
+													   false,
+													   false,
+													   security_level,
+													   NULL, NULL,
+													   NULL));
+				cq_min_security = Min(cq_min_security, security_level);
+			}
+			security_level++;
+		}
+		Assert(security_level <= root->qual_security_level);
+	}
+
+	/* Set child's version of baserestrictinfo. */
+	childrel->baserestrictinfo = childquals;
+	childrel->baserestrict_min_security = cq_min_security;
+
+	if (have_const_false_cq)
+	{
+		/*
+		 * Some restriction clause reduced to constant FALSE or NULL after
+		 * substitution, so this child need not be scanned.
+		 */
+		set_dummy_rel_pathlist(childrel);
+	}
+
+	return childrel;
+}
+
+/*
+ * add_rowmark_junk_columns
+ * 		Add necessary junk columns for rowmarked inheritance parent rel.
+ *
+ * These values are needed for locking of rels selected FOR UPDATE/SHARE, and
+ * to do EvalPlanQual rechecking.  See comments for PlanRowMark in
+ * plannodes.h.
+ */
+static List *
+add_rowmark_junk_columns(PlannerInfo *root, PlanRowMark *rc)
+{
+	List   *tlist = root->processed_tlist;
+	Var		   *var;
+	char		resname[32];
+	TargetEntry *tle;
+
+	if (rc->allMarkTypes & ~(1 << ROW_MARK_COPY))
+	{
+		/* Need to fetch TID */
+		var = makeVar(rc->rti,
+					  SelfItemPointerAttributeNumber,
+					  TIDOID,
+					  -1,
+					  InvalidOid,
+					  0);
+		snprintf(resname, sizeof(resname), "ctid%u", rc->rowmarkId);
+		tle = makeTargetEntry((Expr *) var,
+							  list_length(tlist) + 1,
+							  pstrdup(resname),
+							  true);
+		tlist = lappend(tlist, tle);
+	}
+	if (rc->allMarkTypes & (1 << ROW_MARK_COPY))
+	{
+		/* Need the whole row as a junk var */
+		var = makeWholeRowVar(root->simple_rte_array[rc->rti],
+							  rc->rti,
+							  0,
+							  false);
+		snprintf(resname, sizeof(resname), "wholerow%u", rc->rowmarkId);
+		tle = makeTargetEntry((Expr *) var,
+							  list_length(tlist) + 1,
+							  pstrdup(resname),
+							  true);
+		tlist = lappend(tlist, tle);
+	}
+
+	/* For inheritance cases, always fetch the tableoid too. */
+	var = makeVar(rc->rti,
+				  TableOidAttributeNumber,
+				  OIDOID,
+				  -1,
+				  InvalidOid,
+				  0);
+	snprintf(resname, sizeof(resname), "tableoid%u", rc->rowmarkId);
+	tle = makeTargetEntry((Expr *) var,
+						  list_length(tlist) + 1,
+						  pstrdup(resname),
+						  true);
+	tlist = lappend(tlist, tle);
+
+	return tlist;
 }
diff --git a/src/backend/optimizer/util/plancat.c b/src/backend/optimizer/util/plancat.c
index 51d8faf2dd..6562d3f4ff 100644
--- a/src/backend/optimizer/util/plancat.c
+++ b/src/backend/optimizer/util/plancat.c
@@ -106,7 +106,7 @@ static void set_baserel_partition_key_exprs(Relation relation,
  */
 void
 get_relation_info(PlannerInfo *root, Oid relationObjectId, bool inhparent,
-				  RelOptInfo *rel)
+				  Bitmapset *updatedCols, RelOptInfo *rel)
 {
 	Index		varno = rel->relid;
 	Relation	relation;
@@ -444,11 +444,31 @@ get_relation_info(PlannerInfo *root, Oid relationObjectId, bool inhparent,
 	get_relation_foreign_keys(root, rel, relation, inhparent);
 
 	/*
-	 * Collect info about relation's partitioning scheme, if any. Only
-	 * inheritance parents may be partitioned.
+	 * Collect some additional information for inheritance parents.
 	 */
-	if (inhparent && relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
-		set_relation_partition_info(root, rel, relation);
+	if (inhparent)
+	{
+		/*
+		 * We'll need the TupleDesc when initializing the child relation.
+		 * A copy is being made because concurrent changes might drop
+		 * the relcache entry.  That's possible because ALTER TABLE
+		 * child_table NO INHERIT parent_table only requires an
+		 * AccessShareLock on parent_table.
+		 */
+		rel->tupdesc = CreateTupleDescCopy(RelationGetDescr(relation));
+		rel->reltype = RelationGetForm(relation)->reltype;
+
+		/*
+		 * If partitioned, also save the information of partitioning scheme,
+		 * and whether the query updates any of the partition key columns.
+		 */
+		if (relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
+		{
+			set_relation_partition_info(root, rel, relation);
+			root->partColsUpdated |= has_partition_attrs(relation, updatedCols,
+														 NULL);
+		}
+	}
 
 	heap_close(relation, NoLock);
 
@@ -1853,16 +1873,20 @@ set_relation_partition_info(PlannerInfo *root, RelOptInfo *rel,
 							Relation relation)
 {
 	PartitionDesc partdesc;
-	PartitionKey partkey;
 
 	Assert(relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE);
 
 	partdesc = RelationGetPartitionDesc(relation);
-	partkey = RelationGetPartitionKey(relation);
 	rel->part_scheme = find_partition_scheme(root, relation);
 	Assert(partdesc != NULL && rel->part_scheme != NULL);
-	rel->boundinfo = partition_bounds_copy(partdesc->boundinfo, partkey);
 	rel->nparts = partdesc->nparts;
+
+	/*
+	 * Since we must've taken a lock on the table, it's okay to simply copy
+	 * the pointers to relcache data here.
+	 */
+	rel->part_oids = partdesc->oids;
+	rel->boundinfo = partdesc->boundinfo;
 	set_baserel_partition_key_exprs(relation, rel);
 	rel->partition_qual = RelationGetPartitionQual(relation);
 }
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index 678da0ce55..8ac73b4c34 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -131,6 +131,37 @@ setup_append_rel_array(PlannerInfo *root)
 	}
 }
 
+/* Expand the PlannerInfo arrays by add_size members and zero-init it. */
+void
+expand_planner_arrays(PlannerInfo *root, int add_size)
+{
+	int		new_size = root->simple_rel_array_size + add_size;
+
+	root->simple_rte_array = (RangeTblEntry **)
+							repalloc(root->simple_rte_array,
+									 sizeof(RangeTblEntry *) * new_size);
+	root->simple_rel_array = (RelOptInfo **)
+								repalloc(root->simple_rel_array,
+										 sizeof(RelOptInfo *) * new_size);
+	if (root->append_rel_array)
+		root->append_rel_array = (AppendRelInfo **)
+									repalloc(root->append_rel_array,
+									 sizeof(AppendRelInfo *) * new_size);
+	else
+		root->append_rel_array = (AppendRelInfo **)
+									palloc0(sizeof(AppendRelInfo *) *
+											new_size);
+
+	/* Set the contents of just allocated memory to 0. */
+	MemSet(root->simple_rte_array + root->simple_rel_array_size,
+		   0, sizeof(RangeTblEntry *) * add_size);
+	MemSet(root->simple_rel_array + root->simple_rel_array_size,
+		   0, sizeof(RelOptInfo *) * add_size);
+	MemSet(root->append_rel_array + root->simple_rel_array_size,
+		   0, sizeof(AppendRelInfo *) * add_size);
+	root->simple_rel_array_size = new_size;
+}
+
 /*
  * build_simple_rel
  *	  Construct a new RelOptInfo for a base relation or 'other' relation.
@@ -239,7 +270,8 @@ build_simple_rel(PlannerInfo *root, int relid, RelOptInfo *parent)
 	{
 		case RTE_RELATION:
 			/* Table --- retrieve statistics from the system catalogs */
-			get_relation_info(root, rte->relid, rte->inh, rel);
+			get_relation_info(root, rte->relid, rte->inh, rte->updatedCols,
+							  rel);
 			break;
 		case RTE_SUBQUERY:
 		case RTE_FUNCTION:
@@ -280,52 +312,6 @@ build_simple_rel(PlannerInfo *root, int relid, RelOptInfo *parent)
 		root->qual_security_level = Max(root->qual_security_level,
 										list_length(rte->securityQuals));
 
-	/*
-	 * If this rel is an appendrel parent, recurse to build "other rel"
-	 * RelOptInfos for its children.  They are "other rels" because they are
-	 * not in the main join tree, but we will need RelOptInfos to plan access
-	 * to them.
-	 */
-	if (rte->inh)
-	{
-		ListCell   *l;
-		int			nparts = rel->nparts;
-		int			cnt_parts = 0;
-
-		if (nparts > 0)
-			rel->part_rels = (RelOptInfo **)
-				palloc(sizeof(RelOptInfo *) * nparts);
-
-		foreach(l, root->append_rel_list)
-		{
-			AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(l);
-			RelOptInfo *childrel;
-
-			/* append_rel_list contains all append rels; ignore others */
-			if (appinfo->parent_relid != relid)
-				continue;
-
-			childrel = build_simple_rel(root, appinfo->child_relid,
-										rel);
-
-			/* Nothing more to do for an unpartitioned table. */
-			if (!rel->part_scheme)
-				continue;
-
-			/*
-			 * The order of partition OIDs in append_rel_list is the same as
-			 * the order in the PartitionDesc, so the order of part_rels will
-			 * also match the PartitionDesc.  See expand_partitioned_rtentry.
-			 */
-			Assert(cnt_parts < nparts);
-			rel->part_rels[cnt_parts] = childrel;
-			cnt_parts++;
-		}
-
-		/* We should have seen all the child partitions. */
-		Assert(cnt_parts == nparts);
-	}
-
 	return rel;
 }
 
diff --git a/src/backend/partitioning/partprune.c b/src/backend/partitioning/partprune.c
index 901433c68c..9bb472fd98 100644
--- a/src/backend/partitioning/partprune.c
+++ b/src/backend/partitioning/partprune.c
@@ -46,6 +46,7 @@
 #include "nodes/nodeFuncs.h"
 #include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
+#include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
 #include "optimizer/planner.h"
 #include "optimizer/predtest.h"
@@ -437,17 +438,23 @@ make_partitionedrel_pruneinfo(PlannerInfo *root, RelOptInfo *parentrel,
 		 * is, not pruned already).
 		 */
 		subplan_map = (int *) palloc(nparts * sizeof(int));
+		memset(subplan_map, -1, nparts * sizeof(int));
 		subpart_map = (int *) palloc(nparts * sizeof(int));
+		memset(subpart_map, -1, nparts * sizeof(int));
 		present_parts = NULL;
 
 		for (i = 0; i < nparts; i++)
 		{
 			RelOptInfo *partrel = subpart->part_rels[i];
-			int			subplanidx = relid_subplan_map[partrel->relid] - 1;
-			int			subpartidx = relid_subpart_map[partrel->relid] - 1;
+			int			subplanidx;
+			int			subpartidx;
 
-			subplan_map[i] = subplanidx;
-			subpart_map[i] = subpartidx;
+			/* Skip processing pruned partitions. */
+			if (partrel == NULL)
+				continue;
+
+			subplan_map[i] = subplanidx = relid_subplan_map[partrel->relid] - 1;
+			subpart_map[i] = subpartidx = relid_subpart_map[partrel->relid] - 1;
 			if (subplanidx >= 0)
 			{
 				present_parts = bms_add_member(present_parts, i);
@@ -541,23 +548,20 @@ gen_partprune_steps(RelOptInfo *rel, List *clauses, bool *contradictory)
 
 /*
  * prune_append_rel_partitions
- *		Returns RT indexes of the minimum set of child partitions which must
- *		be scanned to satisfy rel's baserestrictinfo quals.
+ *		Returns indexes into rel->part_rels of the minimum set of child
+ *		partitions which must be scanned to satisfy rel's baserestrictinfo
+ *		quals.
  *
  * Callers must ensure that 'rel' is a partitioned table.
  */
-Relids
+Bitmapset *
 prune_append_rel_partitions(RelOptInfo *rel)
 {
-	Relids		result;
 	List	   *clauses = rel->baserestrictinfo;
 	List	   *pruning_steps;
 	bool		contradictory;
 	PartitionPruneContext context;
-	Bitmapset  *partindexes;
-	int			i;
 
-	Assert(clauses != NIL);
 	Assert(rel->part_scheme != NULL);
 
 	/* If there are no partitions, return the empty set */
@@ -565,6 +569,13 @@ prune_append_rel_partitions(RelOptInfo *rel)
 		return NULL;
 
 	/*
+	 * If pruning is disabled or if there are no clauses to prune with,
+	 * return all partitions.
+	 */
+	if (!enable_partition_pruning || clauses == NIL)
+		return bms_add_range(NULL, 0, rel->nparts - 1);
+
+	/*
 	 * Process clauses.  If the clauses are found to be contradictory, we can
 	 * return the empty set.
 	 */
@@ -591,15 +602,7 @@ prune_append_rel_partitions(RelOptInfo *rel)
 	context.evalexecparams = false;
 
 	/* Actual pruning happens here. */
-	partindexes = get_matching_partitions(&context, pruning_steps);
-
-	/* Add selected partitions' RT indexes to result. */
-	i = -1;
-	result = NULL;
-	while ((i = bms_next_member(partindexes, i)) >= 0)
-		result = bms_add_member(result, rel->part_rels[i]->relid);
-
-	return result;
+	return get_matching_partitions(&context, pruning_steps);
 }
 
 /*
diff --git a/src/include/nodes/relation.h b/src/include/nodes/relation.h
index a2adbfc3b8..0303a454ce 100644
--- a/src/include/nodes/relation.h
+++ b/src/include/nodes/relation.h
@@ -15,6 +15,7 @@
 #define RELATION_H
 
 #include "access/sdir.h"
+#include "access/tupdesc.h"
 #include "fmgr.h"
 #include "lib/stringinfo.h"
 #include "nodes/params.h"
@@ -726,6 +727,7 @@ typedef struct RelOptInfo
 	int			nparts;			/* number of partitions */
 	struct PartitionBoundInfoData *boundinfo;	/* Partition bounds */
 	List	   *partition_qual; /* partition constraint */
+	Oid		   *part_oids;		/* partition OIDs */
 	struct RelOptInfo **part_rels;	/* Array of RelOptInfos of partitions,
 									 * stored in the same order of bounds */
 	List	  **partexprs;		/* Non-nullable partition key expressions. */
@@ -735,6 +737,12 @@ typedef struct RelOptInfo
 	Index		inh_root_parent;	/* For otherrels, this is the RT index of
 									 * inheritance table mentioned in the query
 									 * from which this relation originated */
+	/*
+	 * Set only if this is an inheritance parent relation.  This information
+	 * is needed when initializing the planning info for children.
+	 */
+	TupleDesc	tupdesc;		/* A "copy" of the table's tuple desriptor */
+	Oid			reltype;		/* Table's reltype */
 } RelOptInfo;
 
 /*
diff --git a/src/include/optimizer/appendinfo.h b/src/include/optimizer/appendinfo.h
index 2348c9c13a..bbed1fc73b 100644
--- a/src/include/optimizer/appendinfo.h
+++ b/src/include/optimizer/appendinfo.h
@@ -18,9 +18,10 @@
 #include "nodes/relation.h"
 #include "utils/relcache.h"
 
-extern AppendRelInfo *make_append_rel_info(Relation parentrel,
-					 Relation childrel,
-					 Index parentRTindex, Index childRTindex);
+extern AppendRelInfo *make_append_rel_info(RelOptInfo *parent,
+					 RangeTblEntry *parentrte,
+					 TupleDesc childdesc, Oid childoid, Oid childtype,
+					 Index childRTindex);
 extern Bitmapset *translate_col_privs(const Bitmapset *parent_privs,
 					List *translated_vars);
 extern Node *adjust_appendrel_attrs(PlannerInfo *root, Node *node,
diff --git a/src/include/optimizer/pathnode.h b/src/include/optimizer/pathnode.h
index bd905d3328..e7d0a20c54 100644
--- a/src/include/optimizer/pathnode.h
+++ b/src/include/optimizer/pathnode.h
@@ -261,6 +261,7 @@ extern Path *reparameterize_path_by_child(PlannerInfo *root, Path *path,
  */
 extern void setup_simple_rel_arrays(PlannerInfo *root);
 extern void setup_append_rel_array(PlannerInfo *root);
+extern void expand_planner_arrays(PlannerInfo *root, int add_size);
 extern RelOptInfo *build_simple_rel(PlannerInfo *root, int relid,
 				 RelOptInfo *parent);
 extern RelOptInfo *find_base_rel(PlannerInfo *root, int relid);
diff --git a/src/include/optimizer/plancat.h b/src/include/optimizer/plancat.h
index a1b23251a1..ce666b56ad 100644
--- a/src/include/optimizer/plancat.h
+++ b/src/include/optimizer/plancat.h
@@ -26,7 +26,7 @@ extern PGDLLIMPORT get_relation_info_hook_type get_relation_info_hook;
 
 
 extern void get_relation_info(PlannerInfo *root, Oid relationObjectId,
-				  bool inhparent, RelOptInfo *rel);
+				  bool inhparent, Bitmapset *updatedCols, RelOptInfo *rel);
 
 extern List *infer_arbiter_indexes(PlannerInfo *root);
 
diff --git a/src/include/optimizer/prep.h b/src/include/optimizer/prep.h
index 62d45dd142..a329e87fc2 100644
--- a/src/include/optimizer/prep.h
+++ b/src/include/optimizer/prep.h
@@ -38,7 +38,8 @@ extern Expr *canonicalize_qual(Expr *qual, bool is_check);
 /*
  * prototypes for preptlist.c
  */
-extern List *preprocess_targetlist(PlannerInfo *root);
+extern List *preprocess_targetlist(PlannerInfo *root,
+							bool inheritance_expanded);
 
 extern PlanRowMark *get_plan_rowmark(List *rowmarks, Index rtindex);
 
diff --git a/src/include/partitioning/partprune.h b/src/include/partitioning/partprune.h
index ce9bc8d9fd..5c5d27d040 100644
--- a/src/include/partitioning/partprune.h
+++ b/src/include/partitioning/partprune.h
@@ -76,7 +76,7 @@ extern PartitionPruneInfo *make_partition_pruneinfo(PlannerInfo *root,
 						 List *subpaths,
 						 List *partitioned_rels,
 						 List *prunequal);
-extern Relids prune_append_rel_partitions(RelOptInfo *rel);
+extern Bitmapset *prune_append_rel_partitions(RelOptInfo *rel);
 extern Bitmapset *get_matching_partitions(PartitionPruneContext *context,
 						List *pruning_steps);
 
diff --git a/src/test/regress/expected/partition_aggregate.out b/src/test/regress/expected/partition_aggregate.out
index 6bc106831e..1450cef057 100644
--- a/src/test/regress/expected/partition_aggregate.out
+++ b/src/test/regress/expected/partition_aggregate.out
@@ -144,7 +144,7 @@ SELECT c, sum(a) FROM pagg_tab WHERE 1 = 2 GROUP BY c;
            QUERY PLAN           
 --------------------------------
  HashAggregate
-   Group Key: pagg_tab.c
+   Group Key: c
    ->  Result
          One-Time Filter: false
 (4 rows)
@@ -159,7 +159,7 @@ SELECT c, sum(a) FROM pagg_tab WHERE c = 'x' GROUP BY c;
            QUERY PLAN           
 --------------------------------
  GroupAggregate
-   Group Key: pagg_tab.c
+   Group Key: c
    ->  Result
          One-Time Filter: false
 (4 rows)
-- 
2.11.0

From 0ac44556cc549ae51361b220cfade01ebdf76eda Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Mon, 15 Oct 2018 10:59:24 +0900
Subject: [PATCH v12 5/6] Teach planner to only process unpruned partitions

This adds a bitmapset field live_parts to RelOptInfo and stores
the partition indexes of non-dummy partitions in it, meaning it
contains indexes of only those partitions that have a non-NULL
RelOptInfo present in its parent's RelOptInfo's part_rels array.

This speeds up processing partitioned table's partitions compared
to going through the whole part_rels array in a number of places.
---
 src/backend/optimizer/path/joinrels.c |  3 +++
 src/backend/optimizer/plan/planner.c  | 18 +++++++++---------
 src/backend/optimizer/util/inherit.c  |  1 +
 src/backend/optimizer/util/relnode.c  |  3 +++
 src/backend/partitioning/partprune.c  | 18 +++++-------------
 src/include/nodes/relation.h          |  4 ++++
 6 files changed, 25 insertions(+), 22 deletions(-)

diff --git a/src/backend/optimizer/path/joinrels.c b/src/backend/optimizer/path/joinrels.c
index 297e47b424..a0902b5525 100644
--- a/src/backend/optimizer/path/joinrels.c
+++ b/src/backend/optimizer/path/joinrels.c
@@ -1424,6 +1424,9 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
 		populate_joinrel_with_paths(root, child_rel1, child_rel2,
 									child_joinrel, child_sjinfo,
 									child_restrictlist);
+		if (!IS_DUMMY_REL(child_joinrel))
+			joinrel->live_parts = bms_add_member(joinrel->live_parts,
+												 cnt_parts);
 	}
 }
 
diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index 648858237a..c7d07aab7f 100644
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -6817,7 +6817,9 @@ apply_scanjoin_target_to_paths(PlannerInfo *root,
 		List	   *live_children = NIL;
 
 		/* Adjust each partition. */
-		for (partition_idx = 0; partition_idx < rel->nparts; partition_idx++)
+		partition_idx = -1;
+		while ((partition_idx = bms_next_member(rel->live_parts,
+												partition_idx)) >= 0)
 		{
 			RelOptInfo *child_rel = rel->part_rels[partition_idx];
 			ListCell   *lc;
@@ -6825,9 +6827,7 @@ apply_scanjoin_target_to_paths(PlannerInfo *root,
 			int			nappinfos;
 			List	   *child_scanjoin_targets = NIL;
 
-			/* Skip processing pruned partitions. */
-			if (child_rel == NULL)
-				continue;
+			Assert(child_rel != NULL);
 
 			/* Translate scan/join targets for this child. */
 			appinfos = find_appinfos_by_relids(root, child_rel->relids,
@@ -6908,7 +6908,6 @@ create_partitionwise_grouping_paths(PlannerInfo *root,
 									PartitionwiseAggregateType patype,
 									GroupPathExtraData *extra)
 {
-	int			nparts = input_rel->nparts;
 	int			cnt_parts;
 	List	   *grouped_live_children = NIL;
 	List	   *partially_grouped_live_children = NIL;
@@ -6920,7 +6919,9 @@ create_partitionwise_grouping_paths(PlannerInfo *root,
 		   partially_grouped_rel != NULL);
 
 	/* Add paths for partitionwise aggregation/grouping. */
-	for (cnt_parts = 0; cnt_parts < nparts; cnt_parts++)
+	cnt_parts = -1;
+	while ((cnt_parts = bms_next_member(input_rel->live_parts,
+										cnt_parts)) >= 0)
 	{
 		RelOptInfo *child_input_rel = input_rel->part_rels[cnt_parts];
 		PathTarget *child_target = copy_pathtarget(target);
@@ -6930,9 +6931,8 @@ create_partitionwise_grouping_paths(PlannerInfo *root,
 		RelOptInfo *child_grouped_rel;
 		RelOptInfo *child_partially_grouped_rel;
 
-		/* Skip processing pruned partitions. */
-		if (child_input_rel == NULL)
-			continue;
+		/* A live partition must have a RelOptInfo. */
+		Assert(child_input_rel != NULL);
 
 		/* Input child rel must have a path */
 		Assert(child_input_rel->pathlist != NIL);
diff --git a/src/backend/optimizer/util/inherit.c b/src/backend/optimizer/util/inherit.c
index 0412917fc1..1a18f51e81 100644
--- a/src/backend/optimizer/util/inherit.c
+++ b/src/backend/optimizer/util/inherit.c
@@ -350,6 +350,7 @@ expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
 
 	/* Perform pruning. */
 	partindexes = prune_append_rel_partitions(parentrel);
+	parentrel->live_parts = partindexes;
 
 	/* Must expand PlannerInfo arrays before we can add children. */
 	expand_planner_arrays(root, bms_num_members(partindexes));
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index 8ac73b4c34..74d1dcaa20 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -1748,6 +1748,9 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
 		joinrel->partexprs[cnt] = partexpr;
 		joinrel->nullable_partexprs[cnt] = nullable_partexpr;
 	}
+
+	/* Partitions will be added by try_partitionwise_join. */
+	joinrel->live_parts = NULL;
 }
 
 /*
diff --git a/src/backend/partitioning/partprune.c b/src/backend/partitioning/partprune.c
index 9bb472fd98..088b191bdd 100644
--- a/src/backend/partitioning/partprune.c
+++ b/src/backend/partitioning/partprune.c
@@ -441,29 +441,21 @@ make_partitionedrel_pruneinfo(PlannerInfo *root, RelOptInfo *parentrel,
 		memset(subplan_map, -1, nparts * sizeof(int));
 		subpart_map = (int *) palloc(nparts * sizeof(int));
 		memset(subpart_map, -1, nparts * sizeof(int));
-		present_parts = NULL;
+		present_parts = bms_copy(subpart->live_parts);
 
-		for (i = 0; i < nparts; i++)
+		i = -1;
+		while ((i = bms_next_member(present_parts, i)) >= 0)
 		{
 			RelOptInfo *partrel = subpart->part_rels[i];
 			int			subplanidx;
 			int			subpartidx;
 
-			/* Skip processing pruned partitions. */
-			if (partrel == NULL)
-				continue;
-
+			Assert(partrel != NULL);
 			subplan_map[i] = subplanidx = relid_subplan_map[partrel->relid] - 1;
 			subpart_map[i] = subpartidx = relid_subpart_map[partrel->relid] - 1;
+			/* Record finding this subplan */
 			if (subplanidx >= 0)
-			{
-				present_parts = bms_add_member(present_parts, i);
-
-				/* Record finding this subplan  */
 				subplansfound = bms_add_member(subplansfound, subplanidx);
-			}
-			else if (subpartidx >= 0)
-				present_parts = bms_add_member(present_parts, i);
 		}
 
 		pinfo = makeNode(PartitionedRelPruneInfo);
diff --git a/src/include/nodes/relation.h b/src/include/nodes/relation.h
index 0303a454ce..a0a71fcd62 100644
--- a/src/include/nodes/relation.h
+++ b/src/include/nodes/relation.h
@@ -730,6 +730,10 @@ typedef struct RelOptInfo
 	Oid		   *part_oids;		/* partition OIDs */
 	struct RelOptInfo **part_rels;	/* Array of RelOptInfos of partitions,
 									 * stored in the same order of bounds */
+	Bitmapset  *live_parts;		/* Indexes into part_rels of the non-NULL
+								 * RelOptInfos of unpruned partitions; exists
+								 * to avoid having to iterate over the entire
+								 * part_rels array to filter NULL entries. */
 	List	  **partexprs;		/* Non-nullable partition key expressions. */
 	List	  **nullable_partexprs; /* Nullable partition key expressions. */
 	List	   *partitioned_child_rels; /* List of RT indexes. */
-- 
2.11.0

From 12416be040e2ed00257dc1ee6553ea06adf8c0d1 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Fri, 12 Oct 2018 19:12:53 +0900
Subject: [PATCH v12 6/6] Do not lock all partitions at the beginning

---
 src/backend/optimizer/util/inherit.c | 11 +----------
 1 file changed, 1 insertion(+), 10 deletions(-)

diff --git a/src/backend/optimizer/util/inherit.c b/src/backend/optimizer/util/inherit.c
index 1a18f51e81..f798003aaa 100644
--- a/src/backend/optimizer/util/inherit.c
+++ b/src/backend/optimizer/util/inherit.c
@@ -317,10 +317,6 @@ expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti,
  *
  * Partitions are added to the query in order in which they are found in
  * the parent's PartitionDesc.
- *
- * Note: even though only the unpruned partitions will be added to the
- * resulting plan, this still locks *all* partitions via find_all_inheritors
- * when this function is called for the root partitioned table.
  */
 static void
 expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
@@ -334,10 +330,6 @@ expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
 									parentrel->inh_root_parent :
 									parentRTindex;
 
-	/* If root partitioned table, lock *all* partitions in the tree. */
-	if (parentRTindex == rootParentRTindex)
-		(void) find_all_inheritors(parentrte->relid, lockmode, NULL);
-
 	/*
 	 * Initialize partitioned_child_rels to contain this RT index.
 	 *
@@ -373,8 +365,7 @@ expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
 		RangeTblEntry *childrte;
 		Index		childRTindex;
 
-		/* Already locked above. */
-		newrelation = heap_open(childOID, NoLock);
+		newrelation = heap_open(childOID, lockmode);
 		Assert(!RELATION_IS_OTHER_TEMP(newrelation));
 
 		/*
-- 
2.11.0

diff --git a/src/backend/optimizer/util/appendinfo.c b/src/backend/optimizer/util/appendinfo.c
index d48e3a09b3..2f23e7bf49 100644
--- a/src/backend/optimizer/util/appendinfo.c
+++ b/src/backend/optimizer/util/appendinfo.c
@@ -15,13 +15,12 @@
 #include "postgres.h"
 
 #include "access/htup_details.h"
-#include "access/sysattr.h"
 #include "nodes/makefuncs.h"
 #include "nodes/nodeFuncs.h"
 #include "optimizer/appendinfo.h"
 #include "parser/parsetree.h"
-#include "utils/rel.h"
 #include "utils/lsyscache.h"
+#include "utils/rel.h"
 #include "utils/syscache.h"
 
 
@@ -167,58 +166,6 @@ make_inh_translation_list(Relation oldrelation, Relation newrelation,
 }
 
 /*
- * translate_col_privs
- *	  Translate a bitmapset representing per-column privileges from the
- *	  parent rel's attribute numbering to the child's.
- *
- * The only surprise here is that we don't translate a parent whole-row
- * reference into a child whole-row reference.  That would mean requiring
- * permissions on all child columns, which is overly strict, since the
- * query is really only going to reference the inherited columns.  Instead
- * we set the per-column bits for all inherited columns.
- */
-Bitmapset *
-translate_col_privs(const Bitmapset *parent_privs,
-					List *translated_vars)
-{
-	Bitmapset  *child_privs = NULL;
-	bool		whole_row;
-	int			attno;
-	ListCell   *lc;
-
-	/* System attributes have the same numbers in all tables */
-	for (attno = FirstLowInvalidHeapAttributeNumber + 1; attno < 0; attno++)
-	{
-		if (bms_is_member(attno - FirstLowInvalidHeapAttributeNumber,
-						  parent_privs))
-			child_privs = bms_add_member(child_privs,
-										 attno - FirstLowInvalidHeapAttributeNumber);
-	}
-
-	/* Check if parent has whole-row reference */
-	whole_row = bms_is_member(InvalidAttrNumber - FirstLowInvalidHeapAttributeNumber,
-							  parent_privs);
-
-	/* And now translate the regular user attributes, using the vars list */
-	attno = InvalidAttrNumber;
-	foreach(lc, translated_vars)
-	{
-		Var		   *var = lfirst_node(Var, lc);
-
-		attno++;
-		if (var == NULL)		/* ignore dropped columns */
-			continue;
-		if (whole_row ||
-			bms_is_member(attno - FirstLowInvalidHeapAttributeNumber,
-						  parent_privs))
-			child_privs = bms_add_member(child_privs,
-										 var->varattno - FirstLowInvalidHeapAttributeNumber);
-	}
-
-	return child_privs;
-}
-
-/*
  * adjust_appendrel_attrs
  *	  Copy the specified query or expression and translate Vars referring to a
  *	  parent rel to refer to the corresponding child rel instead.  We also
diff --git a/src/backend/optimizer/util/inherit.c b/src/backend/optimizer/util/inherit.c
index 350e6afe27..db474acbc5 100644
--- a/src/backend/optimizer/util/inherit.c
+++ b/src/backend/optimizer/util/inherit.c
@@ -15,6 +15,7 @@
 #include "postgres.h"
 
 #include "access/heapam.h"
+#include "access/sysattr.h"
 #include "catalog/partition.h"
 #include "catalog/pg_inherits.h"
 #include "miscadmin.h"
@@ -38,6 +39,8 @@ static void expand_single_inheritance_child(PlannerInfo *root,
 								PlanRowMark *top_parentrc, Relation childrel,
 								List **appinfos, RangeTblEntry **childrte_p,
 								Index *childRTindex_p);
+static Bitmapset *translate_col_privs(const Bitmapset *parent_privs,
+					List *translated_vars);
 
 
 /*
@@ -437,3 +440,55 @@ expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte,
 		root->rowMarks = lappend(root->rowMarks, childrc);
 	}
 }
+
+/*
+ * translate_col_privs
+ *	  Translate a bitmapset representing per-column privileges from the
+ *	  parent rel's attribute numbering to the child's.
+ *
+ * The only surprise here is that we don't translate a parent whole-row
+ * reference into a child whole-row reference.  That would mean requiring
+ * permissions on all child columns, which is overly strict, since the
+ * query is really only going to reference the inherited columns.  Instead
+ * we set the per-column bits for all inherited columns.
+ */
+static Bitmapset *
+translate_col_privs(const Bitmapset *parent_privs,
+					List *translated_vars)
+{
+	Bitmapset  *child_privs = NULL;
+	bool		whole_row;
+	int			attno;
+	ListCell   *lc;
+
+	/* System attributes have the same numbers in all tables */
+	for (attno = FirstLowInvalidHeapAttributeNumber + 1; attno < 0; attno++)
+	{
+		if (bms_is_member(attno - FirstLowInvalidHeapAttributeNumber,
+						  parent_privs))
+			child_privs = bms_add_member(child_privs,
+										 attno - FirstLowInvalidHeapAttributeNumber);
+	}
+
+	/* Check if parent has whole-row reference */
+	whole_row = bms_is_member(InvalidAttrNumber - FirstLowInvalidHeapAttributeNumber,
+							  parent_privs);
+
+	/* And now translate the regular user attributes, using the vars list */
+	attno = InvalidAttrNumber;
+	foreach(lc, translated_vars)
+	{
+		Var		   *var = lfirst_node(Var, lc);
+
+		attno++;
+		if (var == NULL)		/* ignore dropped columns */
+			continue;
+		if (whole_row ||
+			bms_is_member(attno - FirstLowInvalidHeapAttributeNumber,
+						  parent_privs))
+			child_privs = bms_add_member(child_privs,
+										 var->varattno - FirstLowInvalidHeapAttributeNumber);
+	}
+
+	return child_privs;
+}
diff --git a/src/include/optimizer/appendinfo.h b/src/include/optimizer/appendinfo.h
index 16705da780..56f7192d71 100644
--- a/src/include/optimizer/appendinfo.h
+++ b/src/include/optimizer/appendinfo.h
@@ -20,8 +20,6 @@
 extern AppendRelInfo *make_append_rel_info(Relation parentrel,
 					 Relation childrel,
 					 Index parentRTindex, Index childRTindex);
-extern Bitmapset *translate_col_privs(const Bitmapset *parent_privs,
-					List *translated_vars);
 extern Node *adjust_appendrel_attrs(PlannerInfo *root, Node *node,
 					   int nappinfos, AppendRelInfo **appinfos);
 

diff --git a/src/backend/optimizer/path/joinrels.c b/src/backend/optimizer/path/joinrels.c
index 38eeb23d81..db18feccfe 100644
--- a/src/backend/optimizer/path/joinrels.c
+++ b/src/backend/optimizer/path/joinrels.c
@@ -46,6 +46,9 @@ static void try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1,
 					   List *parent_restrictlist);
 static int match_expr_to_partition_keys(Expr *expr, RelOptInfo *rel,
 							 bool strict_op);
+static SpecialJoinInfo *build_child_join_sjinfo(PlannerInfo *root,
+						SpecialJoinInfo *parent_sjinfo,
+						Relids left_relids, Relids right_relids);
 
 
 /*
@@ -1582,3 +1585,45 @@ match_expr_to_partition_keys(Expr *expr, RelOptInfo *rel, bool strict_op)
 
 	return -1;
 }
+
+/*
+ * Construct the SpecialJoinInfo for a child-join by translating
+ * SpecialJoinInfo for the join between parents. left_relids and right_relids
+ * are the relids of left and right side of the join respectively.
+ */
+static SpecialJoinInfo *
+build_child_join_sjinfo(PlannerInfo *root, SpecialJoinInfo *parent_sjinfo,
+						Relids left_relids, Relids right_relids)
+{
+	SpecialJoinInfo *sjinfo = makeNode(SpecialJoinInfo);
+	AppendRelInfo **left_appinfos;
+	int			left_nappinfos;
+	AppendRelInfo **right_appinfos;
+	int			right_nappinfos;
+
+	memcpy(sjinfo, parent_sjinfo, sizeof(SpecialJoinInfo));
+	left_appinfos = find_appinfos_by_relids(root, left_relids,
+											&left_nappinfos);
+	right_appinfos = find_appinfos_by_relids(root, right_relids,
+											 &right_nappinfos);
+
+	sjinfo->min_lefthand = adjust_child_relids(sjinfo->min_lefthand,
+											   left_nappinfos, left_appinfos);
+	sjinfo->min_righthand = adjust_child_relids(sjinfo->min_righthand,
+												right_nappinfos,
+												right_appinfos);
+	sjinfo->syn_lefthand = adjust_child_relids(sjinfo->syn_lefthand,
+											   left_nappinfos, left_appinfos);
+	sjinfo->syn_righthand = adjust_child_relids(sjinfo->syn_righthand,
+												right_nappinfos,
+												right_appinfos);
+	sjinfo->semi_rhs_exprs = (List *) adjust_appendrel_attrs(root,
+															 (Node *) sjinfo->semi_rhs_exprs,
+															 right_nappinfos,
+															 right_appinfos);
+
+	pfree(left_appinfos);
+	pfree(right_appinfos);
+
+	return sjinfo;
+}
diff --git a/src/backend/optimizer/util/appendinfo.c b/src/backend/optimizer/util/appendinfo.c
index d48e3a09b3..37fbc3a117 100644
--- a/src/backend/optimizer/util/appendinfo.c
+++ b/src/backend/optimizer/util/appendinfo.c
@@ -15,13 +15,12 @@
 #include "postgres.h"
 
 #include "access/htup_details.h"
-#include "access/sysattr.h"
 #include "nodes/makefuncs.h"
 #include "nodes/nodeFuncs.h"
 #include "optimizer/appendinfo.h"
 #include "parser/parsetree.h"
-#include "utils/rel.h"
 #include "utils/lsyscache.h"
+#include "utils/rel.h"
 #include "utils/syscache.h"
 
 
@@ -38,8 +37,6 @@ static void make_inh_translation_list(Relation oldrelation,
 						  List **translated_vars);
 static Node *adjust_appendrel_attrs_mutator(Node *node,
 							   adjust_appendrel_attrs_context *context);
-static Relids adjust_child_relids(Relids relids, int nappinfos,
-					AppendRelInfo **appinfos);
 static List *adjust_inherited_tlist(List *tlist,
 					   AppendRelInfo *context);
 
@@ -167,58 +164,6 @@ make_inh_translation_list(Relation oldrelation, Relation newrelation,
 }
 
 /*
- * translate_col_privs
- *	  Translate a bitmapset representing per-column privileges from the
- *	  parent rel's attribute numbering to the child's.
- *
- * The only surprise here is that we don't translate a parent whole-row
- * reference into a child whole-row reference.  That would mean requiring
- * permissions on all child columns, which is overly strict, since the
- * query is really only going to reference the inherited columns.  Instead
- * we set the per-column bits for all inherited columns.
- */
-Bitmapset *
-translate_col_privs(const Bitmapset *parent_privs,
-					List *translated_vars)
-{
-	Bitmapset  *child_privs = NULL;
-	bool		whole_row;
-	int			attno;
-	ListCell   *lc;
-
-	/* System attributes have the same numbers in all tables */
-	for (attno = FirstLowInvalidHeapAttributeNumber + 1; attno < 0; attno++)
-	{
-		if (bms_is_member(attno - FirstLowInvalidHeapAttributeNumber,
-						  parent_privs))
-			child_privs = bms_add_member(child_privs,
-										 attno - FirstLowInvalidHeapAttributeNumber);
-	}
-
-	/* Check if parent has whole-row reference */
-	whole_row = bms_is_member(InvalidAttrNumber - FirstLowInvalidHeapAttributeNumber,
-							  parent_privs);
-
-	/* And now translate the regular user attributes, using the vars list */
-	attno = InvalidAttrNumber;
-	foreach(lc, translated_vars)
-	{
-		Var		   *var = lfirst_node(Var, lc);
-
-		attno++;
-		if (var == NULL)		/* ignore dropped columns */
-			continue;
-		if (whole_row ||
-			bms_is_member(attno - FirstLowInvalidHeapAttributeNumber,
-						  parent_privs))
-			child_privs = bms_add_member(child_privs,
-										 var->varattno - FirstLowInvalidHeapAttributeNumber);
-	}
-
-	return child_privs;
-}
-
-/*
  * adjust_appendrel_attrs
  *	  Copy the specified query or expression and translate Vars referring to a
  *	  parent rel to refer to the corresponding child rel instead.  We also
@@ -531,7 +476,7 @@ adjust_appendrel_attrs_mutator(Node *node,
  * Substitute child relids for parent relids in a Relid set.  The array of
  * appinfos specifies the substitutions to be performed.
  */
-static Relids
+Relids
 adjust_child_relids(Relids relids, int nappinfos, AppendRelInfo **appinfos)
 {
 	Bitmapset  *result = NULL;
@@ -754,48 +699,6 @@ adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node,
 }
 
 /*
- * Construct the SpecialJoinInfo for a child-join by translating
- * SpecialJoinInfo for the join between parents. left_relids and right_relids
- * are the relids of left and right side of the join respectively.
- */
-SpecialJoinInfo *
-build_child_join_sjinfo(PlannerInfo *root, SpecialJoinInfo *parent_sjinfo,
-						Relids left_relids, Relids right_relids)
-{
-	SpecialJoinInfo *sjinfo = makeNode(SpecialJoinInfo);
-	AppendRelInfo **left_appinfos;
-	int			left_nappinfos;
-	AppendRelInfo **right_appinfos;
-	int			right_nappinfos;
-
-	memcpy(sjinfo, parent_sjinfo, sizeof(SpecialJoinInfo));
-	left_appinfos = find_appinfos_by_relids(root, left_relids,
-											&left_nappinfos);
-	right_appinfos = find_appinfos_by_relids(root, right_relids,
-											 &right_nappinfos);
-
-	sjinfo->min_lefthand = adjust_child_relids(sjinfo->min_lefthand,
-											   left_nappinfos, left_appinfos);
-	sjinfo->min_righthand = adjust_child_relids(sjinfo->min_righthand,
-												right_nappinfos,
-												right_appinfos);
-	sjinfo->syn_lefthand = adjust_child_relids(sjinfo->syn_lefthand,
-											   left_nappinfos, left_appinfos);
-	sjinfo->syn_righthand = adjust_child_relids(sjinfo->syn_righthand,
-												right_nappinfos,
-												right_appinfos);
-	sjinfo->semi_rhs_exprs = (List *) adjust_appendrel_attrs(root,
-															 (Node *) sjinfo->semi_rhs_exprs,
-															 right_nappinfos,
-															 right_appinfos);
-
-	pfree(left_appinfos);
-	pfree(right_appinfos);
-
-	return sjinfo;
-}
-
-/*
  * find_appinfos_by_relids
  * 		Find AppendRelInfo structures for all relations specified by relids.
  *
diff --git a/src/backend/optimizer/util/inherit.c b/src/backend/optimizer/util/inherit.c
index 350e6afe27..db474acbc5 100644
--- a/src/backend/optimizer/util/inherit.c
+++ b/src/backend/optimizer/util/inherit.c
@@ -15,6 +15,7 @@
 #include "postgres.h"
 
 #include "access/heapam.h"
+#include "access/sysattr.h"
 #include "catalog/partition.h"
 #include "catalog/pg_inherits.h"
 #include "miscadmin.h"
@@ -38,6 +39,8 @@ static void expand_single_inheritance_child(PlannerInfo *root,
 								PlanRowMark *top_parentrc, Relation childrel,
 								List **appinfos, RangeTblEntry **childrte_p,
 								Index *childRTindex_p);
+static Bitmapset *translate_col_privs(const Bitmapset *parent_privs,
+					List *translated_vars);
 
 
 /*
@@ -437,3 +440,55 @@ expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte,
 		root->rowMarks = lappend(root->rowMarks, childrc);
 	}
 }
+
+/*
+ * translate_col_privs
+ *	  Translate a bitmapset representing per-column privileges from the
+ *	  parent rel's attribute numbering to the child's.
+ *
+ * The only surprise here is that we don't translate a parent whole-row
+ * reference into a child whole-row reference.  That would mean requiring
+ * permissions on all child columns, which is overly strict, since the
+ * query is really only going to reference the inherited columns.  Instead
+ * we set the per-column bits for all inherited columns.
+ */
+static Bitmapset *
+translate_col_privs(const Bitmapset *parent_privs,
+					List *translated_vars)
+{
+	Bitmapset  *child_privs = NULL;
+	bool		whole_row;
+	int			attno;
+	ListCell   *lc;
+
+	/* System attributes have the same numbers in all tables */
+	for (attno = FirstLowInvalidHeapAttributeNumber + 1; attno < 0; attno++)
+	{
+		if (bms_is_member(attno - FirstLowInvalidHeapAttributeNumber,
+						  parent_privs))
+			child_privs = bms_add_member(child_privs,
+										 attno - FirstLowInvalidHeapAttributeNumber);
+	}
+
+	/* Check if parent has whole-row reference */
+	whole_row = bms_is_member(InvalidAttrNumber - FirstLowInvalidHeapAttributeNumber,
+							  parent_privs);
+
+	/* And now translate the regular user attributes, using the vars list */
+	attno = InvalidAttrNumber;
+	foreach(lc, translated_vars)
+	{
+		Var		   *var = lfirst_node(Var, lc);
+
+		attno++;
+		if (var == NULL)		/* ignore dropped columns */
+			continue;
+		if (whole_row ||
+			bms_is_member(attno - FirstLowInvalidHeapAttributeNumber,
+						  parent_privs))
+			child_privs = bms_add_member(child_privs,
+										 var->varattno - FirstLowInvalidHeapAttributeNumber);
+	}
+
+	return child_privs;
+}
diff --git a/src/include/optimizer/appendinfo.h b/src/include/optimizer/appendinfo.h
index 16705da780..156a0e077d 100644
--- a/src/include/optimizer/appendinfo.h
+++ b/src/include/optimizer/appendinfo.h
@@ -20,21 +20,15 @@
 extern AppendRelInfo *make_append_rel_info(Relation parentrel,
 					 Relation childrel,
 					 Index parentRTindex, Index childRTindex);
-extern Bitmapset *translate_col_privs(const Bitmapset *parent_privs,
-					List *translated_vars);
 extern Node *adjust_appendrel_attrs(PlannerInfo *root, Node *node,
 					   int nappinfos, AppendRelInfo **appinfos);
-
 extern Node *adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node,
 								  Relids child_relids,
 								  Relids top_parent_relids);
-
 extern AppendRelInfo **find_appinfos_by_relids(PlannerInfo *root,
 						Relids relids, int *nappinfos);
-
-extern SpecialJoinInfo *build_child_join_sjinfo(PlannerInfo *root,
-						SpecialJoinInfo *parent_sjinfo,
-						Relids left_relids, Relids right_relids);
+extern Relids adjust_child_relids(Relids relids, int nappinfos,
+					AppendRelInfo **appinfos);
 extern Relids adjust_child_relids_multilevel(PlannerInfo *root, Relids relids,
 							   Relids child_relids, Relids top_parent_relids);
 

From d9b349c42eab901680ec755239ff45bb3c97ba6a Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Fri, 11 Jan 2019 11:11:30 +0900
Subject: [PATCH v13 1/6] Some fixups for b60c397599 (v2)

---
 src/backend/optimizer/path/joinrels.c   |  45 ++++++++++++++
 src/backend/optimizer/util/appendinfo.c | 101 +-------------------------------
 src/backend/optimizer/util/inherit.c    |  55 +++++++++++++++++
 src/include/optimizer/appendinfo.h      |  10 +---
 4 files changed, 104 insertions(+), 107 deletions(-)

diff --git a/src/backend/optimizer/path/joinrels.c b/src/backend/optimizer/path/joinrels.c
index 38eeb23d81..db18feccfe 100644
--- a/src/backend/optimizer/path/joinrels.c
+++ b/src/backend/optimizer/path/joinrels.c
@@ -46,6 +46,9 @@ static void try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1,
 					   List *parent_restrictlist);
 static int match_expr_to_partition_keys(Expr *expr, RelOptInfo *rel,
 							 bool strict_op);
+static SpecialJoinInfo *build_child_join_sjinfo(PlannerInfo *root,
+						SpecialJoinInfo *parent_sjinfo,
+						Relids left_relids, Relids right_relids);
 
 
 /*
@@ -1582,3 +1585,45 @@ match_expr_to_partition_keys(Expr *expr, RelOptInfo *rel, bool strict_op)
 
 	return -1;
 }
+
+/*
+ * Construct the SpecialJoinInfo for a child-join by translating
+ * SpecialJoinInfo for the join between parents. left_relids and right_relids
+ * are the relids of left and right side of the join respectively.
+ */
+static SpecialJoinInfo *
+build_child_join_sjinfo(PlannerInfo *root, SpecialJoinInfo *parent_sjinfo,
+						Relids left_relids, Relids right_relids)
+{
+	SpecialJoinInfo *sjinfo = makeNode(SpecialJoinInfo);
+	AppendRelInfo **left_appinfos;
+	int			left_nappinfos;
+	AppendRelInfo **right_appinfos;
+	int			right_nappinfos;
+
+	memcpy(sjinfo, parent_sjinfo, sizeof(SpecialJoinInfo));
+	left_appinfos = find_appinfos_by_relids(root, left_relids,
+											&left_nappinfos);
+	right_appinfos = find_appinfos_by_relids(root, right_relids,
+											 &right_nappinfos);
+
+	sjinfo->min_lefthand = adjust_child_relids(sjinfo->min_lefthand,
+											   left_nappinfos, left_appinfos);
+	sjinfo->min_righthand = adjust_child_relids(sjinfo->min_righthand,
+												right_nappinfos,
+												right_appinfos);
+	sjinfo->syn_lefthand = adjust_child_relids(sjinfo->syn_lefthand,
+											   left_nappinfos, left_appinfos);
+	sjinfo->syn_righthand = adjust_child_relids(sjinfo->syn_righthand,
+												right_nappinfos,
+												right_appinfos);
+	sjinfo->semi_rhs_exprs = (List *) adjust_appendrel_attrs(root,
+															 (Node *) sjinfo->semi_rhs_exprs,
+															 right_nappinfos,
+															 right_appinfos);
+
+	pfree(left_appinfos);
+	pfree(right_appinfos);
+
+	return sjinfo;
+}
diff --git a/src/backend/optimizer/util/appendinfo.c b/src/backend/optimizer/util/appendinfo.c
index d48e3a09b3..37fbc3a117 100644
--- a/src/backend/optimizer/util/appendinfo.c
+++ b/src/backend/optimizer/util/appendinfo.c
@@ -15,13 +15,12 @@
 #include "postgres.h"
 
 #include "access/htup_details.h"
-#include "access/sysattr.h"
 #include "nodes/makefuncs.h"
 #include "nodes/nodeFuncs.h"
 #include "optimizer/appendinfo.h"
 #include "parser/parsetree.h"
-#include "utils/rel.h"
 #include "utils/lsyscache.h"
+#include "utils/rel.h"
 #include "utils/syscache.h"
 
 
@@ -38,8 +37,6 @@ static void make_inh_translation_list(Relation oldrelation,
 						  List **translated_vars);
 static Node *adjust_appendrel_attrs_mutator(Node *node,
 							   adjust_appendrel_attrs_context *context);
-static Relids adjust_child_relids(Relids relids, int nappinfos,
-					AppendRelInfo **appinfos);
 static List *adjust_inherited_tlist(List *tlist,
 					   AppendRelInfo *context);
 
@@ -167,58 +164,6 @@ make_inh_translation_list(Relation oldrelation, Relation newrelation,
 }
 
 /*
- * translate_col_privs
- *	  Translate a bitmapset representing per-column privileges from the
- *	  parent rel's attribute numbering to the child's.
- *
- * The only surprise here is that we don't translate a parent whole-row
- * reference into a child whole-row reference.  That would mean requiring
- * permissions on all child columns, which is overly strict, since the
- * query is really only going to reference the inherited columns.  Instead
- * we set the per-column bits for all inherited columns.
- */
-Bitmapset *
-translate_col_privs(const Bitmapset *parent_privs,
-					List *translated_vars)
-{
-	Bitmapset  *child_privs = NULL;
-	bool		whole_row;
-	int			attno;
-	ListCell   *lc;
-
-	/* System attributes have the same numbers in all tables */
-	for (attno = FirstLowInvalidHeapAttributeNumber + 1; attno < 0; attno++)
-	{
-		if (bms_is_member(attno - FirstLowInvalidHeapAttributeNumber,
-						  parent_privs))
-			child_privs = bms_add_member(child_privs,
-										 attno - FirstLowInvalidHeapAttributeNumber);
-	}
-
-	/* Check if parent has whole-row reference */
-	whole_row = bms_is_member(InvalidAttrNumber - FirstLowInvalidHeapAttributeNumber,
-							  parent_privs);
-
-	/* And now translate the regular user attributes, using the vars list */
-	attno = InvalidAttrNumber;
-	foreach(lc, translated_vars)
-	{
-		Var		   *var = lfirst_node(Var, lc);
-
-		attno++;
-		if (var == NULL)		/* ignore dropped columns */
-			continue;
-		if (whole_row ||
-			bms_is_member(attno - FirstLowInvalidHeapAttributeNumber,
-						  parent_privs))
-			child_privs = bms_add_member(child_privs,
-										 var->varattno - FirstLowInvalidHeapAttributeNumber);
-	}
-
-	return child_privs;
-}
-
-/*
  * adjust_appendrel_attrs
  *	  Copy the specified query or expression and translate Vars referring to a
  *	  parent rel to refer to the corresponding child rel instead.  We also
@@ -531,7 +476,7 @@ adjust_appendrel_attrs_mutator(Node *node,
  * Substitute child relids for parent relids in a Relid set.  The array of
  * appinfos specifies the substitutions to be performed.
  */
-static Relids
+Relids
 adjust_child_relids(Relids relids, int nappinfos, AppendRelInfo **appinfos)
 {
 	Bitmapset  *result = NULL;
@@ -754,48 +699,6 @@ adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node,
 }
 
 /*
- * Construct the SpecialJoinInfo for a child-join by translating
- * SpecialJoinInfo for the join between parents. left_relids and right_relids
- * are the relids of left and right side of the join respectively.
- */
-SpecialJoinInfo *
-build_child_join_sjinfo(PlannerInfo *root, SpecialJoinInfo *parent_sjinfo,
-						Relids left_relids, Relids right_relids)
-{
-	SpecialJoinInfo *sjinfo = makeNode(SpecialJoinInfo);
-	AppendRelInfo **left_appinfos;
-	int			left_nappinfos;
-	AppendRelInfo **right_appinfos;
-	int			right_nappinfos;
-
-	memcpy(sjinfo, parent_sjinfo, sizeof(SpecialJoinInfo));
-	left_appinfos = find_appinfos_by_relids(root, left_relids,
-											&left_nappinfos);
-	right_appinfos = find_appinfos_by_relids(root, right_relids,
-											 &right_nappinfos);
-
-	sjinfo->min_lefthand = adjust_child_relids(sjinfo->min_lefthand,
-											   left_nappinfos, left_appinfos);
-	sjinfo->min_righthand = adjust_child_relids(sjinfo->min_righthand,
-												right_nappinfos,
-												right_appinfos);
-	sjinfo->syn_lefthand = adjust_child_relids(sjinfo->syn_lefthand,
-											   left_nappinfos, left_appinfos);
-	sjinfo->syn_righthand = adjust_child_relids(sjinfo->syn_righthand,
-												right_nappinfos,
-												right_appinfos);
-	sjinfo->semi_rhs_exprs = (List *) adjust_appendrel_attrs(root,
-															 (Node *) sjinfo->semi_rhs_exprs,
-															 right_nappinfos,
-															 right_appinfos);
-
-	pfree(left_appinfos);
-	pfree(right_appinfos);
-
-	return sjinfo;
-}
-
-/*
  * find_appinfos_by_relids
  * 		Find AppendRelInfo structures for all relations specified by relids.
  *
diff --git a/src/backend/optimizer/util/inherit.c b/src/backend/optimizer/util/inherit.c
index 350e6afe27..db474acbc5 100644
--- a/src/backend/optimizer/util/inherit.c
+++ b/src/backend/optimizer/util/inherit.c
@@ -15,6 +15,7 @@
 #include "postgres.h"
 
 #include "access/heapam.h"
+#include "access/sysattr.h"
 #include "catalog/partition.h"
 #include "catalog/pg_inherits.h"
 #include "miscadmin.h"
@@ -38,6 +39,8 @@ static void expand_single_inheritance_child(PlannerInfo *root,
 								PlanRowMark *top_parentrc, Relation childrel,
 								List **appinfos, RangeTblEntry **childrte_p,
 								Index *childRTindex_p);
+static Bitmapset *translate_col_privs(const Bitmapset *parent_privs,
+					List *translated_vars);
 
 
 /*
@@ -437,3 +440,55 @@ expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte,
 		root->rowMarks = lappend(root->rowMarks, childrc);
 	}
 }
+
+/*
+ * translate_col_privs
+ *	  Translate a bitmapset representing per-column privileges from the
+ *	  parent rel's attribute numbering to the child's.
+ *
+ * The only surprise here is that we don't translate a parent whole-row
+ * reference into a child whole-row reference.  That would mean requiring
+ * permissions on all child columns, which is overly strict, since the
+ * query is really only going to reference the inherited columns.  Instead
+ * we set the per-column bits for all inherited columns.
+ */
+static Bitmapset *
+translate_col_privs(const Bitmapset *parent_privs,
+					List *translated_vars)
+{
+	Bitmapset  *child_privs = NULL;
+	bool		whole_row;
+	int			attno;
+	ListCell   *lc;
+
+	/* System attributes have the same numbers in all tables */
+	for (attno = FirstLowInvalidHeapAttributeNumber + 1; attno < 0; attno++)
+	{
+		if (bms_is_member(attno - FirstLowInvalidHeapAttributeNumber,
+						  parent_privs))
+			child_privs = bms_add_member(child_privs,
+										 attno - FirstLowInvalidHeapAttributeNumber);
+	}
+
+	/* Check if parent has whole-row reference */
+	whole_row = bms_is_member(InvalidAttrNumber - FirstLowInvalidHeapAttributeNumber,
+							  parent_privs);
+
+	/* And now translate the regular user attributes, using the vars list */
+	attno = InvalidAttrNumber;
+	foreach(lc, translated_vars)
+	{
+		Var		   *var = lfirst_node(Var, lc);
+
+		attno++;
+		if (var == NULL)		/* ignore dropped columns */
+			continue;
+		if (whole_row ||
+			bms_is_member(attno - FirstLowInvalidHeapAttributeNumber,
+						  parent_privs))
+			child_privs = bms_add_member(child_privs,
+										 var->varattno - FirstLowInvalidHeapAttributeNumber);
+	}
+
+	return child_privs;
+}
diff --git a/src/include/optimizer/appendinfo.h b/src/include/optimizer/appendinfo.h
index 16705da780..156a0e077d 100644
--- a/src/include/optimizer/appendinfo.h
+++ b/src/include/optimizer/appendinfo.h
@@ -20,21 +20,15 @@
 extern AppendRelInfo *make_append_rel_info(Relation parentrel,
 					 Relation childrel,
 					 Index parentRTindex, Index childRTindex);
-extern Bitmapset *translate_col_privs(const Bitmapset *parent_privs,
-					List *translated_vars);
 extern Node *adjust_appendrel_attrs(PlannerInfo *root, Node *node,
 					   int nappinfos, AppendRelInfo **appinfos);
-
 extern Node *adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node,
 								  Relids child_relids,
 								  Relids top_parent_relids);
-
 extern AppendRelInfo **find_appinfos_by_relids(PlannerInfo *root,
 						Relids relids, int *nappinfos);
-
-extern SpecialJoinInfo *build_child_join_sjinfo(PlannerInfo *root,
-						SpecialJoinInfo *parent_sjinfo,
-						Relids left_relids, Relids right_relids);
+extern Relids adjust_child_relids(Relids relids, int nappinfos,
+					AppendRelInfo **appinfos);
 extern Relids adjust_child_relids_multilevel(PlannerInfo *root, Relids relids,
 							   Relids child_relids, Relids top_parent_relids);
 
-- 
2.11.0

From 5eb9e0aa4d9e7a6f3eb7a2e9a380ebd28b821169 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Wed, 17 Oct 2018 11:18:12 +0900
Subject: [PATCH v13 2/6] Overhaul inheritance update/delete planning

With the current method, inheritance_planner, which handles the
planning for update/delete commands targeting inheritance trees,
performs the *whole* planning for each child table.  That involves
translating the query tree to set a given child table in place of
the original inheritance root table as the query's target table,
followed by calling grouping_planner on the translated query, which
performs query planning and additional steps needed to apply correct
target list based on the child target table.

That's inefficient for two reasons:

 1. partprune.c cannot be used to perform partition pruning, because
    it can only be invoked from query_planner.  With the current
    approach, query_planner only sees the individual partitions in
    the query tree it receives, not the parent partitioned table.
    This leaves each partition to be pruned using constraint
    exclusion.  (constraint exclusion cannon prune hash partitions
    which means UPDATE/DELETE don't support hash partition pruning.)

 2. Repeated invocation of query_planner results in allocating large
    amounts of memory, especially if there are many child tables.
    Also, it involves repeatedly performing the same processing,
    such as jointree processing.

This commit addresses both of the issues by rewriting portions of
inheritance_planner and adding some supporting functionality to
allpath.c.

With the new implementation, inheritance_planner calls query_planner
only once at the beginning with the original unmodified query, which
creates the access paths of individual relations after pruning any
unnecessary partitions.  For each target child relation, it also
creates a sub-PartitionInfo containing translated version of the
query and a targetlist suitable for the child.  Child PlannerInfos
are saved in the top PlannerInfo for using later.  If the query
involves join against the target relation, join paths are created
for each target child relation by  replacing the original target
table in the join tree by a given child table.  Join relations
(RelOptInfos thereof) for all target child relations are collected
in a global list in the top PlannerInfo.

After creating the join paths for all target child relations,
inheritance_planner calls grouping_planner() on each child join
relation using the previously created child PlannerInfo to finish up
the paths such that they produce query's top-level target list
expanded according to a given child relation's descriptor.
grouping_planner()'s interface is modified so that we can pass it
what's called a 'planned_rel', a RelOptInfo that already contains
the necessary paths needed to produce its output.

This removes some existing code in inheritance_planner that dealt
with any subquery RTEs in the query.  The rationale of that code
was that the subquery RTEs may change during each iteration of
planning (that is, for different children), so different iterations
better use different copies of those RTEs.  That was handled by
making fresh copies of those RTEs for each iteration of planning
which were appended to the range table, accompanied by modifying all
expressions and auxiliary structures that referenced the original
subquery RTEs to instead reference the copies (that is, change the
varnos).  This copying meant we would end up adding S * N new entries
to the original range table by the time we got to the last unpruned
child, where S is the number of subquery RTEs in the original query
and N the number of unpruned children.  Since with the new code
we perform planning just once, I think we don't need this special
handling.  Actually, there is a regression test output change due
to no longer having copies of subquery RTEs (see the diff of
partition_join.out file.)

Also we no longer need the hack in relation_excluded_by_constraints()
involving setting PlannerInfo.inhTargetKind to enable constraint
exclusion for target child relation, which is no longer needed.
Constraint exclusion now runs during query_planner step described
above.

Regression test output change in partition_join.out is due to the fact
that we no longer create duplicates of subquery RTEs in child range
tables.
---
 doc/src/sgml/ddl.sgml                        |  17 +-
 src/backend/nodes/outfuncs.c                 |   2 +-
 src/backend/optimizer/path/allpaths.c        | 579 +++++++++++++++++++++++++--
 src/backend/optimizer/path/equivclass.c      |  57 ++-
 src/backend/optimizer/plan/createplan.c      |  10 -
 src/backend/optimizer/plan/planmain.c        | 167 +++++++-
 src/backend/optimizer/plan/planner.c         | 441 ++++++--------------
 src/backend/optimizer/prep/prepjointree.c    |   1 -
 src/backend/optimizer/util/appendinfo.c      |  33 +-
 src/backend/optimizer/util/plancat.c         |  73 +---
 src/include/nodes/relation.h                 |  37 +-
 src/include/optimizer/paths.h                |   3 +-
 src/test/regress/expected/partition_join.out |   4 +-
 13 files changed, 958 insertions(+), 466 deletions(-)

diff --git a/doc/src/sgml/ddl.sgml b/doc/src/sgml/ddl.sgml
index 85e4358988..1bb5ca6b08 100644
--- a/doc/src/sgml/ddl.sgml
+++ b/doc/src/sgml/ddl.sgml
@@ -4439,24 +4439,11 @@ EXPLAIN SELECT count(*) FROM measurement WHERE logdate &gt;= DATE '2008-01-01';
 
    <note>
     <para>
-     Currently, pruning of partitions during the planning of an
-     <command>UPDATE</command> or <command>DELETE</command> command is
-     implemented using the constraint exclusion method (however, it is
-     controlled by the <literal>enable_partition_pruning</literal> rather than
-     <literal>constraint_exclusion</literal>) &mdash; see the following section
-     for details and caveats that apply.
-    </para>
-
-    <para>
      Execution-time partition pruning currently only occurs for the
      <literal>Append</literal> and <literal>MergeAppend</literal> node types.
      It is not yet implemented for the <literal>ModifyTable</literal> node
-     type.
-    </para>
-
-    <para>
-     Both of these behaviors are likely to be changed in a future release
-     of <productname>PostgreSQL</productname>.
+     type, but that is likely to be changed in a future release of
+     <productname>PostgreSQL</productname>.
     </para>
    </note>
   </sect2>
diff --git a/src/backend/nodes/outfuncs.c b/src/backend/nodes/outfuncs.c
index 0fde876c77..158da68925 100644
--- a/src/backend/nodes/outfuncs.c
+++ b/src/backend/nodes/outfuncs.c
@@ -2210,7 +2210,6 @@ _outPlannerInfo(StringInfo str, const PlannerInfo *node)
 	WRITE_FLOAT_FIELD(tuple_fraction, "%.4f");
 	WRITE_FLOAT_FIELD(limit_tuples, "%.0f");
 	WRITE_UINT_FIELD(qual_security_level);
-	WRITE_ENUM_FIELD(inhTargetKind, InheritanceKind);
 	WRITE_BOOL_FIELD(hasJoinRTEs);
 	WRITE_BOOL_FIELD(hasLateralRTEs);
 	WRITE_BOOL_FIELD(hasDeletedRTEs);
@@ -2221,6 +2220,7 @@ _outPlannerInfo(StringInfo str, const PlannerInfo *node)
 	WRITE_BITMAPSET_FIELD(curOuterRels);
 	WRITE_NODE_FIELD(curOuterParams);
 	WRITE_BOOL_FIELD(partColsUpdated);
+	WRITE_BOOL_FIELD(inherited_update);
 }
 
 static void
diff --git a/src/backend/optimizer/path/allpaths.c b/src/backend/optimizer/path/allpaths.c
index bc389b52e4..35dba9c7ce 100644
--- a/src/backend/optimizer/path/allpaths.c
+++ b/src/backend/optimizer/path/allpaths.c
@@ -38,6 +38,7 @@
 #include "optimizer/pathnode.h"
 #include "optimizer/paths.h"
 #include "optimizer/plancat.h"
+#include "optimizer/planmain.h"
 #include "optimizer/planner.h"
 #include "optimizer/restrictinfo.h"
 #include "optimizer/tlist.h"
@@ -92,8 +93,12 @@ static void set_foreign_size(PlannerInfo *root, RelOptInfo *rel,
 				 RangeTblEntry *rte);
 static void set_foreign_pathlist(PlannerInfo *root, RelOptInfo *rel,
 					 RangeTblEntry *rte);
+static void set_inherit_target_rel_sizes(PlannerInfo *root, RelOptInfo *rel,
+							 Index rti, RangeTblEntry *rte);
 static void set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 					Index rti, RangeTblEntry *rte);
+static void set_inherit_target_rel_pathlists(PlannerInfo *root,
+							 RelOptInfo *rel, Index rti, RangeTblEntry *rte);
 static void set_append_rel_pathlist(PlannerInfo *root, RelOptInfo *rel,
 						Index rti, RangeTblEntry *rte);
 static void generate_mergeappend_paths(PlannerInfo *root, RelOptInfo *rel,
@@ -120,6 +125,8 @@ static void set_namedtuplestore_pathlist(PlannerInfo *root, RelOptInfo *rel,
 static void set_worktable_pathlist(PlannerInfo *root, RelOptInfo *rel,
 					   RangeTblEntry *rte);
 static RelOptInfo *make_rel_from_joinlist(PlannerInfo *root, List *joinlist);
+static void inheritance_make_rel_from_joinlist(PlannerInfo *root,
+						List *joinlist);
 static bool subquery_is_pushdown_safe(Query *subquery, Query *topquery,
 						  pushdown_safety_info *safetyInfo);
 static bool recurse_pushdown_safe(Node *setOp, Query *topquery,
@@ -150,27 +157,6 @@ make_one_rel(PlannerInfo *root, List *joinlist)
 	Index		rti;
 	double		total_pages;
 
-	/*
-	 * Construct the all_baserels Relids set.
-	 */
-	root->all_baserels = NULL;
-	for (rti = 1; rti < root->simple_rel_array_size; rti++)
-	{
-		RelOptInfo *brel = root->simple_rel_array[rti];
-
-		/* there may be empty slots corresponding to non-baserel RTEs */
-		if (brel == NULL)
-			continue;
-
-		Assert(brel->relid == rti); /* sanity check on array */
-
-		/* ignore RTEs that are "other rels" */
-		if (brel->reloptkind != RELOPT_BASEREL)
-			continue;
-
-		root->all_baserels = bms_add_member(root->all_baserels, brel->relid);
-	}
-
 	/* Mark base rels as to whether we care about fast-start plans */
 	set_base_rel_consider_startup(root);
 
@@ -218,13 +204,34 @@ make_one_rel(PlannerInfo *root, List *joinlist)
 
 	/*
 	 * Generate access paths for the entire join tree.
+	 *
+	 * For UPDATE/DELETE on an inheritance parent, join paths should be
+	 * generated for each child result rel separately.
 	 */
-	rel = make_rel_from_joinlist(root, joinlist);
+	if (root->parse->resultRelation &&
+		root->simple_rte_array[root->parse->resultRelation]->inh)
+	{
+		inheritance_make_rel_from_joinlist(root, joinlist);
 
-	/*
-	 * The result should join all and only the query's base rels.
-	 */
-	Assert(bms_equal(rel->relids, root->all_baserels));
+		/*
+		 * Return the RelOptInfo of original target relation, although this
+		 * doesn't really contain the final path.  inheritance_planner
+		 * from where we got here will generate the final path, but it will
+		 * do so by iterative over child subroots, not through this
+		 * RelOptInfo.
+		 */
+		rel = find_base_rel(root, root->parse->resultRelation);
+	}
+	else
+	{
+		rel = make_rel_from_joinlist(root, joinlist);
+
+		/*
+		 * The result should join all and only the query's base rels.
+		 */
+		Assert(bms_equal(rel->relids, root->all_baserels));
+
+	}
 
 	return rel;
 }
@@ -308,9 +315,10 @@ set_base_rel_sizes(PlannerInfo *root)
 		 * If parallelism is allowable for this query in general, see whether
 		 * it's allowable for this rel in particular.  We have to do this
 		 * before set_rel_size(), because (a) if this rel is an inheritance
-		 * parent, set_append_rel_size() will use and perhaps change the rel's
-		 * consider_parallel flag, and (b) for some RTE types, set_rel_size()
-		 * goes ahead and makes paths immediately.
+		 * parent, set_append_rel_size() or set_inherit_target_rel_sizes()
+		 * will use and perhaps change the rel's consider_parallel flag, and
+		 * (b) for some RTE types, set_rel_size() goes ahead and makes paths
+		 * immediately.
 		 */
 		if (root->glob->parallelModeOK)
 			set_rel_consider_parallel(root, rel, rte);
@@ -374,8 +382,15 @@ set_rel_size(PlannerInfo *root, RelOptInfo *rel,
 	}
 	else if (rte->inh)
 	{
-		/* It's an "append relation", process accordingly */
-		set_append_rel_size(root, rel, rti, rte);
+		/*
+		 * If it's a target relation, set the sizes of children instead.
+		 * Otherwise, we'll append the outputs of children, so process it as
+		 * an "append relation".
+		 */
+		if (rti == root->parse->resultRelation)
+			set_inherit_target_rel_sizes(root, rel, rti, rte);
+		else
+			set_append_rel_size(root, rel, rti, rte);
 	}
 	else
 	{
@@ -459,14 +474,26 @@ static void
 set_rel_pathlist(PlannerInfo *root, RelOptInfo *rel,
 				 Index rti, RangeTblEntry *rte)
 {
+	bool	inherited_update = false;
+
 	if (IS_DUMMY_REL(rel))
 	{
 		/* We already proved the relation empty, so nothing more to do */
 	}
 	else if (rte->inh)
 	{
-		/* It's an "append relation", process accordingly */
-		set_append_rel_pathlist(root, rel, rti, rte);
+		/*
+		 * If it's a target relation, set the pathlists of children instead.
+		 * Otherwise, we'll append the outputs of children, so process it as
+		 * an "append relation".
+		 */
+		if (root->inherited_update && root->parse->resultRelation == rti)
+		{
+			inherited_update = true;
+			set_inherit_target_rel_pathlists(root, rel, rti, rte);
+		}
+		else
+			set_append_rel_pathlist(root, rel, rti, rte);
 	}
 	else
 	{
@@ -541,8 +568,12 @@ set_rel_pathlist(PlannerInfo *root, RelOptInfo *rel,
 	if (set_rel_pathlist_hook)
 		(*set_rel_pathlist_hook) (root, rel, rti, rte);
 
-	/* Now find the cheapest of the paths for this rel */
-	set_cheapest(rel);
+	/*
+	 * Now find the cheapest of the paths for this rel, unless it's an
+	 * inheritance parent and this is an update/delete operation.
+	 */
+	if (!inherited_update)
+		set_cheapest(rel);
 
 #ifdef OPTIMIZER_DEBUG
 	debug_print_rel(root, rel);
@@ -904,6 +935,347 @@ set_foreign_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
 }
 
 /*
+ * set_inherit_target_rel_sizes
+ *	  Set size estimates for the child target relations
+ *
+ * The passed-in rel represents the target relation of the query that is
+ * known to have inheritance children.  This is very much like
+ * set_append_rel_size, except it doesn't set the size estimates for the
+ * passed-in rel itself, because we don't need to "append" the children
+ * in this case.
+ */
+static void
+set_inherit_target_rel_sizes(PlannerInfo *root, RelOptInfo *rel,
+							 Index rti, RangeTblEntry *rte)
+{
+	int			parentRTindex = rti;
+	bool		has_live_children;
+	ListCell   *l;
+	Relids		live_children = NULL;
+	bool		did_pruning = false;
+
+	/* Guard against stack overflow due to overly deep inheritance tree. */
+	check_stack_depth();
+
+	Assert(IS_SIMPLE_REL(rel));
+
+	/*
+	 * If the partitioned relation has any baserestrictinfo quals then we
+	 * attempt to use these quals to prune away partitions that cannot
+	 * possibly contain any tuples matching these quals.  In this case we'll
+	 * store the relids of all partitions which could possibly contain a
+	 * matching tuple, and skip anything else in the loop below.
+	 */
+	if (enable_partition_pruning &&
+		rte->relkind == RELKIND_PARTITIONED_TABLE &&
+		rel->baserestrictinfo != NIL)
+	{
+		live_children = prune_append_rel_partitions(rel);
+		did_pruning = true;
+	}
+
+	foreach(l, root->append_rel_list)
+	{
+		AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(l);
+		int			childRTindex;
+		RangeTblEntry *childRTE;
+		RelOptInfo *childrel;
+		List	   *childquals;
+		Index		cq_min_security;
+		bool		have_const_false_cq;
+		PlannerInfo *subroot;
+		ListCell   *lc;
+		List	   *translated_exprs,
+				   *child_target_exprs;
+
+		/* append_rel_list contains all append rels; ignore others */
+		if (appinfo->parent_relid != parentRTindex)
+			continue;
+
+		childRTindex = appinfo->child_relid;
+		childRTE = root->simple_rte_array[childRTindex];
+		subroot = root->inh_target_child_roots[childRTindex];
+
+		/*
+		 * The child rel's RelOptInfo was already created during
+		 * add_base_rels_to_query.
+		 */
+		childrel = find_base_rel(root, childRTindex);
+		Assert(childrel->reloptkind == RELOPT_OTHER_MEMBER_REL);
+
+		/*
+		 * We have to copy the parent's quals to the child, with appropriate
+		 * substitution of variables.  However, only the baserestrictinfo
+		 * quals are needed before we can check for constraint exclusion; so
+		 * do that first and then check to see if we can disregard this child.
+		 *
+		 * The child rel's targetlist might contain non-Var expressions, which
+		 * means that substitution into the quals could produce opportunities
+		 * for const-simplification, and perhaps even pseudoconstant quals.
+		 * Therefore, transform each RestrictInfo separately to see if it
+		 * reduces to a constant or pseudoconstant.  (We must process them
+		 * separately to keep track of the security level of each qual.)
+		 */
+		childquals = NIL;
+		cq_min_security = UINT_MAX;
+		have_const_false_cq = false;
+		foreach(lc, rel->baserestrictinfo)
+		{
+			RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
+			Node	   *childqual;
+			ListCell   *lc2;
+
+			Assert(IsA(rinfo, RestrictInfo));
+			childqual = adjust_appendrel_attrs(root,
+											   (Node *) rinfo->clause,
+											   1, &appinfo);
+			childqual = eval_const_expressions(root, childqual);
+			/* check for flat-out constant */
+			if (childqual && IsA(childqual, Const))
+			{
+				if (((Const *) childqual)->constisnull ||
+					!DatumGetBool(((Const *) childqual)->constvalue))
+				{
+					/* Restriction reduces to constant FALSE or NULL */
+					have_const_false_cq = true;
+					break;
+				}
+				/* Restriction reduces to constant TRUE, so drop it */
+				continue;
+			}
+			/* might have gotten an AND clause, if so flatten it */
+			foreach(lc2, make_ands_implicit((Expr *) childqual))
+			{
+				Node	   *onecq = (Node *) lfirst(lc2);
+				bool		pseudoconstant;
+
+				/* check for pseudoconstant (no Vars or volatile functions) */
+				pseudoconstant =
+					!contain_vars_of_level(onecq, 0) &&
+					!contain_volatile_functions(onecq);
+				if (pseudoconstant)
+				{
+					/* tell createplan.c to check for gating quals */
+					root->hasPseudoConstantQuals = true;
+				}
+				/* reconstitute RestrictInfo with appropriate properties */
+				childquals = lappend(childquals,
+									 make_restrictinfo((Expr *) onecq,
+													   rinfo->is_pushed_down,
+													   rinfo->outerjoin_delayed,
+													   pseudoconstant,
+													   rinfo->security_level,
+													   NULL, NULL, NULL));
+				/* track minimum security level among child quals */
+				cq_min_security = Min(cq_min_security, rinfo->security_level);
+			}
+		}
+
+		/*
+		 * In addition to the quals inherited from the parent, we might have
+		 * securityQuals associated with this particular child node.
+		 * (Currently this can only happen in appendrels originating from
+		 * UNION ALL; inheritance child tables don't have their own
+		 * securityQuals, see expand_inherited_rtentry().)	Pull any such
+		 * securityQuals up into the baserestrictinfo for the child.  This is
+		 * similar to process_security_barrier_quals() for the parent rel,
+		 * except that we can't make any general deductions from such quals,
+		 * since they don't hold for the whole appendrel.
+		 */
+		if (childRTE->securityQuals)
+		{
+			Index		security_level = 0;
+
+			foreach(lc, childRTE->securityQuals)
+			{
+				List	   *qualset = (List *) lfirst(lc);
+				ListCell   *lc2;
+
+				foreach(lc2, qualset)
+				{
+					Expr	   *qual = (Expr *) lfirst(lc2);
+
+					/* not likely that we'd see constants here, so no check */
+					childquals = lappend(childquals,
+										 make_restrictinfo(qual,
+														   true, false, false,
+														   security_level,
+														   NULL, NULL, NULL));
+					cq_min_security = Min(cq_min_security, security_level);
+				}
+				security_level++;
+			}
+			Assert(security_level <= root->qual_security_level);
+		}
+
+		/*
+		 * OK, we've got all the baserestrictinfo quals for this child.
+		 */
+		childrel->baserestrictinfo = childquals;
+		childrel->baserestrict_min_security = cq_min_security;
+
+		if (have_const_false_cq)
+		{
+			/*
+			 * Some restriction clause reduced to constant FALSE or NULL after
+			 * substitution, so this child need not be scanned.
+			 */
+			set_dummy_rel_pathlist(childrel);
+			continue;
+		}
+
+		if (did_pruning && !bms_is_member(appinfo->child_relid, live_children))
+		{
+			/* This partition was pruned; skip it. */
+			set_dummy_rel_pathlist(childrel);
+			continue;
+		}
+
+		if (relation_excluded_by_constraints(root, childrel, childRTE))
+		{
+			/* This child is excluded; skip it. */
+			set_dummy_rel_pathlist(childrel);
+			continue;
+		}
+
+		/*
+		 * Add missing Vars to child's reltarget.
+		 *
+		 * add_inherit_target_child_root() would've added only those that are
+		 * needed to be present in the top-level tlist (or ones that
+		 * preprocess_targetlist thinks are needed to be in the tlist.)  We
+		 * may need other attributes such as those contained in WHERE clauses,
+		 * which are already computed for the parent during
+		 * deconstruct_jointree processing of the original query (child's
+		 * query never goes through deconstruct_jointree.)
+		 */
+		translated_exprs = (List *)
+			adjust_appendrel_attrs(root,
+								   (Node *) rel->reltarget->exprs,
+								   1, &appinfo);
+		child_target_exprs = childrel->reltarget->exprs;
+		foreach(lc, translated_exprs)
+		{
+			Expr *expr = lfirst(lc);
+
+			if (!list_member(child_target_exprs, expr))
+				child_target_exprs = lappend(child_target_exprs, expr);
+		}
+
+		/*
+		 * Also, We have to find any ECs containing parent's expressions and
+		 * *replace* them with their copies containing child expressions.
+		 */
+		if (rel->has_eclass_joins || has_useful_pathkeys(root, rel))
+			add_child_rel_equivalences(subroot, appinfo, rel, childrel, true);
+		childrel->has_eclass_joins = rel->has_eclass_joins;
+
+		/* Translate join quals. */
+		childrel->joininfo = (List *)
+			adjust_appendrel_attrs(subroot,
+								   (Node *) rel->joininfo,
+								   1, &appinfo);
+
+		/*
+		 * If parallelism is allowable for this query in general, see whether
+		 * it's allowable for this childrel in particular.  For consistency,
+		 * do this before calling set_rel_size() for the child.
+		 */
+		if (root->glob->parallelModeOK)
+			set_rel_consider_parallel(subroot, childrel, childRTE);
+
+		/*
+		 * Compute the child's size using possibly modified subroot.
+		 */
+		set_rel_size(subroot, childrel, childRTindex, childRTE);
+
+		/* If the child itself is partitioned it may turn into a dummy rel. */
+		if (IS_DUMMY_REL(childrel))
+			continue;
+
+		/* We have at least one live child. */
+		has_live_children = true;
+
+		Assert(childrel->rows > 0);
+	}
+
+	if (has_live_children)
+	{
+		/*
+		 * Set a non-zero value here to cope with the caller's requirement
+		 * that non-dummy relations are actually not empty.  We don't try to
+		 * be accurate here, because we're not going to create a path that
+		 * combines the children outputs.
+		 */
+		rel->rows = 1;
+	}
+	else
+	{
+		/*
+		 * All children were excluded by constraints, so mark the relation
+		 * ass dummy.  We must do this in this phase so that the rel's
+		 * dummy-ness is visible when we generate paths for other rels.
+		 */
+		set_dummy_rel_pathlist(rel);
+	}
+}
+
+/*
+ * set_inherit_target_rel_pathlists
+ *	  Build access paths for the child target relations
+ *
+ * Similar to set_append_rel_pathlist, except that we build paths of the
+ * children, but don't build an Append path.
+ */
+static void
+set_inherit_target_rel_pathlists(PlannerInfo *root, RelOptInfo *rel,
+								 Index rti, RangeTblEntry *rte)
+{
+	int			parentRTindex = rti;
+	ListCell   *l;
+
+	/* Nothing to do if all the children were excluded. */
+	if (IS_DUMMY_REL(rel))
+		return;
+
+	/* Generate access paths for each of the children of passed-in rel */
+	foreach(l, root->append_rel_list)
+	{
+		AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(l);
+		int			childRTindex;
+		RangeTblEntry *childRTE;
+		RelOptInfo *childrel;
+		PlannerInfo *subroot;
+
+		/* append_rel_list contains all append rels; ignore others */
+		if (appinfo->parent_relid != parentRTindex)
+			continue;
+
+		/* Re-locate the child RTE and RelOptInfo */
+		childRTindex = appinfo->child_relid;
+		childRTE = root->simple_rte_array[childRTindex];
+		childrel = root->simple_rel_array[childRTindex];
+		subroot = root->inh_target_child_roots[childRTindex];
+		/* Transfer the value from main root to subroot. */
+		subroot->total_table_pages = root->total_table_pages;
+
+		/*
+		 * If set_append_rel_size() decided the parent appendrel was
+		 * parallel-unsafe at some point after visiting this child rel, we
+		 * need to propagate the unsafety marking down to the child, so that
+		 * we don't generate useless partial paths for it.
+		 */
+		if (!rel->consider_parallel)
+			childrel->consider_parallel = false;
+
+		/*
+		 * Compute the child's access paths.
+		 */
+		set_rel_pathlist(subroot, childrel, childRTindex, childRTE);
+	}
+}
+
+/*
  * set_append_rel_size
  *	  Set size estimates for a simple "append relation"
  *
@@ -1046,7 +1418,8 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 		 * EquivalenceClass data structures.
 		 */
 		if (rel->has_eclass_joins || has_useful_pathkeys(root, rel))
-			add_child_rel_equivalences(root, appinfo, rel, childrel);
+			add_child_rel_equivalences(root, appinfo, rel, childrel,
+									   false);
 		childrel->has_eclass_joins = rel->has_eclass_joins;
 
 		/*
@@ -2625,6 +2998,140 @@ generate_gather_paths(PlannerInfo *root, RelOptInfo *rel, bool override_rows)
 }
 
 /*
+ * inheritance_make_rel_from_joinlist
+ *		Perform join planning for all non-dummy leaf inheritance children
+ *		in their role as an UPDATE/DELETE query's target relation
+ *
+ * If a child relation is a partitioned table, its children are processed in
+ * turn by recursively calling this function.
+ */
+static void
+inheritance_make_rel_from_joinlist(PlannerInfo *root, List *joinlist)
+{
+	Index		resultRelation = root->parse->resultRelation;
+	ListCell   *lc;
+#ifdef USE_ASSERT_CHECKING
+	Relids	all_baserels;
+#endif
+
+	/* For UPDATE/DELETE queries, the top parent can only ever be a table. */
+	Assert(root->parse->commandType == CMD_UPDATE ||
+		   root->parse->commandType == CMD_DELETE);
+	Assert(planner_rt_fetch(resultRelation, root)->rtekind == RTE_RELATION);
+
+	/* Nothing to do. */
+	if (IS_DUMMY_REL(find_base_rel(root, resultRelation)))
+		return;
+
+	foreach(lc, root->append_rel_list)
+	{
+		AppendRelInfo *appinfo = lfirst(lc);
+		PlannerInfo *subroot;
+		RelOptInfo *childrel;
+		RelOptInfo *childjoinrel;
+		List	   *translated_joinlist;
+
+		if (appinfo->parent_relid != resultRelation)
+			continue;
+
+		childrel = find_base_rel(root, appinfo->child_relid);
+
+		/* Ignore excluded/pruned children. */
+		if (IS_DUMMY_REL(childrel))
+			continue;
+
+		/* Add this child. */
+		root->inh_target_child_rels = lappend_int(root->inh_target_child_rels,
+												  appinfo->child_relid);
+
+		/* Perform join planning with child subroot. */
+		subroot = root->inh_target_child_roots[appinfo->child_relid];
+		Assert(subroot->parse->resultRelation > 0);
+
+		/*
+		 * Modify joinlist such that relations joined to the top parent rel
+		 * appear to be joined to the child rel instead.  Do the same for
+		 * any SpecialJoinInfo structs.
+		 */
+		translated_joinlist = (List *)
+						adjust_appendrel_attrs(subroot,
+											   (Node *) joinlist,
+											   1, &appinfo);
+		subroot->join_info_list = (List *)
+						adjust_appendrel_attrs(subroot,
+											   (Node *) root->join_info_list,
+											   1, &appinfo);
+
+		/*
+		 * Sub-partitioned tables have to be processed recursively using the
+		 * translated subroot as the parent, because AppendRelInfos link
+		 * sub-partitions to their immediate parents, not the root partitioned
+		 * table.
+		 */
+		if (childrel->part_scheme != NULL)
+		{
+			inheritance_make_rel_from_joinlist(subroot, translated_joinlist);
+
+			/*
+			 * Add this child relation as a placeholder in the parent root's
+			 * inh_target_child_joinrels so that inheritance_planner see same
+			 * number of entries as inh_target_child_rels.
+			 */
+			root->inh_target_child_joinrels =
+					lappend(root->inh_target_child_joinrels, childrel);
+
+			/* Also propagate this child's own children into parent's list. */
+			if (subroot->inh_target_child_rels != NIL)
+			{
+				root->inh_target_child_rels =
+					list_concat(root->inh_target_child_rels,
+								subroot->inh_target_child_rels);
+				root->inh_target_child_joinrels =
+					list_concat(root->inh_target_child_joinrels,
+								subroot->inh_target_child_joinrels);
+			}
+			continue;
+		}
+
+		/*
+		 * Since we added the child rel directly into the join tree, we must
+		 * modify it to be a "base" rel instead of an "other" rel, which the
+		 * join planning code expects the relations being joined to be.
+		 */
+		childrel->reloptkind = RELOPT_BASEREL;
+
+		Assert(subroot->join_rel_list == NIL);
+		Assert(subroot->join_rel_hash == NULL);
+
+		/* Perform join planning and save the resulting RelOptInfo. */
+		childjoinrel = make_rel_from_joinlist(subroot, translated_joinlist);
+
+		/*
+		 * Remember this child target rel.  inheritance_planner will perform
+		 * the remaining steps of planning for each child relation separately.
+		 * Specifically, it will call grouping_planner on every
+		 * RelOptInfo contained in the inh_target_child_rels list, each of
+		 * which represents the source of tuples to be modified for a given
+		 * target child rel.
+		 */
+		root->inh_target_child_joinrels =
+					lappend(root->inh_target_child_joinrels, childjoinrel);
+#ifdef USE_ASSERT_CHECKING
+		/*
+		 * The following implements essentially the same Assert as in
+		 * make_one_rel, our caller.
+		 */
+		all_baserels = bms_copy(root->all_baserels);
+		all_baserels = bms_del_member(all_baserels,
+									  root->parse->resultRelation);
+		all_baserels = bms_add_member(all_baserels,
+									  subroot->parse->resultRelation);
+		Assert(bms_equal(childjoinrel->relids, all_baserels));
+#endif
+	}
+}
+
+/*
  * make_rel_from_joinlist
  *	  Build access paths using a "joinlist" to guide the join path search.
  *
diff --git a/src/backend/optimizer/path/equivclass.c b/src/backend/optimizer/path/equivclass.c
index 6e134ae1d2..10136ef940 100644
--- a/src/backend/optimizer/path/equivclass.c
+++ b/src/backend/optimizer/path/equivclass.c
@@ -2104,12 +2104,16 @@ match_eclasses_to_foreign_key_col(PlannerInfo *root,
  *
  * parent_rel and child_rel could be derived from appinfo, but since the
  * caller has already computed them, we might as well just pass them in.
+ *
+ * If 'replace' is true then the child EC members *replace* the corresponding
+ * parent members.
  */
 void
 add_child_rel_equivalences(PlannerInfo *root,
 						   AppendRelInfo *appinfo,
 						   RelOptInfo *parent_rel,
-						   RelOptInfo *child_rel)
+						   RelOptInfo *child_rel,
+						   bool replace)
 {
 	ListCell   *lc1;
 
@@ -2117,14 +2121,23 @@ add_child_rel_equivalences(PlannerInfo *root,
 	{
 		EquivalenceClass *cur_ec = (EquivalenceClass *) lfirst(lc1);
 		ListCell   *lc2;
+		ListCell   *prev;
+		ListCell   *next;
 
 		/*
 		 * If this EC contains a volatile expression, then generating child
 		 * EMs would be downright dangerous, so skip it.  We rely on a
-		 * volatile EC having only one EM.
+		 * volatile EC having only one EM.  If the caller asked to *replace*
+		 * the original parent expression with the child one, then it's
+		 * okay to proceed, because we wouldn't be adding another expression
+		 * as being equivalent in that case.
 		 */
 		if (cur_ec->ec_has_volatile)
-			continue;
+		{
+			Assert(list_length(cur_ec->ec_members) == 1);
+			if (!replace)
+				continue;
+		}
 
 		/*
 		 * No point in searching if parent rel not mentioned in eclass; but we
@@ -2134,12 +2147,18 @@ add_child_rel_equivalences(PlannerInfo *root,
 			!bms_is_subset(parent_rel->relids, cur_ec->ec_relids))
 			continue;
 
-		foreach(lc2, cur_ec->ec_members)
+		prev = NULL;
+		for (lc2 = list_head(cur_ec->ec_members); lc2 != NULL; lc2 = next)
 		{
 			EquivalenceMember *cur_em = (EquivalenceMember *) lfirst(lc2);
 
+			next = lnext(lc2);
+
 			if (cur_em->em_is_const)
+			{
+				prev = lc2;
 				continue;		/* ignore consts here */
+			}
 
 			/* Does it reference parent_rel? */
 			if (bms_overlap(cur_em->em_relids, parent_rel->relids))
@@ -2177,10 +2196,38 @@ add_child_rel_equivalences(PlannerInfo *root,
 														  child_rel->relids);
 				}
 
+				/*
+				 * Caller may have asked us to replace the parent expression
+				 * with the child expression, so delete the parent expression
+				 * first.
+				 */
+				if (replace)
+					cur_ec->ec_members = list_delete_cell(cur_ec->ec_members,
+														  lc2, prev);
+
+				/*
+				 * If we're replacing, then the new member isn't really a
+				 * a child, so em_is_child should be set to false.
+				 */
 				(void) add_eq_member(cur_ec, child_expr,
 									 new_relids, new_nullable_relids,
-									 true, cur_em->em_datatype);
+									 !replace, cur_em->em_datatype);
 			}
+			else
+				prev = lc2;
+		}
+
+		if (replace)
+		{
+			/*
+			 * Now fix up EC's relids set.  It's OK to modify EC like this,
+			 * because caller must have made a copy of the original EC.
+			 * For example, see adjust_inherited_target_child_root.
+			 */
+			cur_ec->ec_relids = bms_difference(cur_ec->ec_relids,
+											   parent_rel->relids);
+			cur_ec->ec_relids = bms_add_members(cur_ec->ec_relids,
+												child_rel->relids);
 		}
 	}
 }
diff --git a/src/backend/optimizer/plan/createplan.c b/src/backend/optimizer/plan/createplan.c
index 066685c3c7..8f1769b5c6 100644
--- a/src/backend/optimizer/plan/createplan.c
+++ b/src/backend/optimizer/plan/createplan.c
@@ -2022,12 +2022,7 @@ create_groupingsets_plan(PlannerInfo *root, GroupingSetsPath *best_path)
 	/*
 	 * During setrefs.c, we'll need the grouping_map to fix up the cols lists
 	 * in GroupingFunc nodes.  Save it for setrefs.c to use.
-	 *
-	 * This doesn't work if we're in an inheritance subtree (see notes in
-	 * create_modifytable_plan).  Fortunately we can't be because there would
-	 * never be grouping in an UPDATE/DELETE; but let's Assert that.
 	 */
-	Assert(root->inhTargetKind == INHKIND_NONE);
 	Assert(root->grouping_map == NULL);
 	root->grouping_map = grouping_map;
 
@@ -2184,12 +2179,7 @@ create_minmaxagg_plan(PlannerInfo *root, MinMaxAggPath *best_path)
 	 * with InitPlan output params.  (We can't just do that locally in the
 	 * MinMaxAgg node, because path nodes above here may have Agg references
 	 * as well.)  Save the mmaggregates list to tell setrefs.c to do that.
-	 *
-	 * This doesn't work if we're in an inheritance subtree (see notes in
-	 * create_modifytable_plan).  Fortunately we can't be because there would
-	 * never be aggregates in an UPDATE/DELETE; but let's Assert that.
 	 */
-	Assert(root->inhTargetKind == INHKIND_NONE);
 	Assert(root->minmax_aggs == NIL);
 	root->minmax_aggs = best_path->mmaggregates;
 
diff --git a/src/backend/optimizer/plan/planmain.c b/src/backend/optimizer/plan/planmain.c
index fc97a1bb50..96a09bb134 100644
--- a/src/backend/optimizer/plan/planmain.c
+++ b/src/backend/optimizer/plan/planmain.c
@@ -28,7 +28,11 @@
 #include "optimizer/paths.h"
 #include "optimizer/placeholder.h"
 #include "optimizer/planmain.h"
+#include "optimizer/prep.h"
 
+static void add_inherited_target_child_roots(PlannerInfo *root);
+static PlannerInfo *adjust_inherited_target_child_root(PlannerInfo *root,
+									AppendRelInfo *appinfo);
 
 /*
  * query_planner
@@ -59,6 +63,7 @@ query_planner(PlannerInfo *root, List *tlist,
 	Query	   *parse = root->parse;
 	List	   *joinlist;
 	RelOptInfo *final_rel;
+	Index		rti;
 
 	/*
 	 * If the query has an empty join tree, then it's something easy like
@@ -232,14 +237,170 @@ query_planner(PlannerInfo *root, List *tlist,
 	extract_restriction_or_clauses(root);
 
 	/*
+	 * Construct the all_baserels Relids set.
+	 */
+	root->all_baserels = NULL;
+	for (rti = 1; rti < root->simple_rel_array_size; rti++)
+	{
+		RelOptInfo *brel = root->simple_rel_array[rti];
+
+		/* there may be empty slots corresponding to non-baserel RTEs */
+		if (brel == NULL)
+			continue;
+
+		Assert(brel->relid == rti); /* sanity check on array */
+
+		/* ignore RTEs that are "other rels" */
+		if (brel->reloptkind != RELOPT_BASEREL)
+			continue;
+
+		root->all_baserels = bms_add_member(root->all_baserels, brel->relid);
+	}
+
+	/*
+	 * Add child subroots needed to use during planning for individual child
+	 * targets
+	 */
+	if (root->inherited_update)
+	{
+		root->inh_target_child_roots = (PlannerInfo **)
+										palloc0(root->simple_rel_array_size *
+												sizeof(PlannerInfo *));
+		add_inherited_target_child_roots(root);
+	}
+
+	/*
 	 * Ready to do the primary planning.
 	 */
 	final_rel = make_one_rel(root, joinlist);
 
-	/* Check that we got at least one usable path */
-	if (!final_rel || !final_rel->cheapest_total_path ||
-		final_rel->cheapest_total_path->param_info != NULL)
+	/*
+	 * Check that we got at least one usable path.  In the case of an
+	 * inherited update/delete operation, no path has been created for
+	 * the query's actual target relation yet.
+	 */
+	if (!root->inherited_update &&
+		(!final_rel ||
+		 !final_rel->cheapest_total_path ||
+		 final_rel->cheapest_total_path->param_info != NULL))
 		elog(ERROR, "failed to construct the join relation");
 
 	return final_rel;
 }
+
+/*
+ * add_inherited_target_child_roots
+ *		Add PlannerInfos for inheritance target children
+ */
+static void
+add_inherited_target_child_roots(PlannerInfo *root)
+{
+	Index		resultRelation = root->parse->resultRelation;
+	ListCell   *lc;
+
+	Assert(root->inh_target_child_roots != NULL);
+
+	foreach(lc, root->append_rel_list)
+	{
+		AppendRelInfo *appinfo = lfirst(lc);
+		RangeTblEntry *childRTE;
+		PlannerInfo   *subroot;
+
+		if (appinfo->parent_relid != resultRelation)
+			continue;
+
+		childRTE = root->simple_rte_array[appinfo->child_relid];
+
+		/*
+		 * Create a PlannerInfo for processing this child target relation
+		 * with.
+		 */
+		subroot = adjust_inherited_target_child_root(root, appinfo);
+
+		if (childRTE->inh)
+			add_inherited_target_child_roots(subroot);
+
+		root->inh_target_child_roots[appinfo->child_relid] = subroot;
+	}
+}
+
+/*
+ * add_inherit_target_child_root
+ *		This translates query to match the child given by appinfo and
+ *		puts it in a PlannerInfo that will be used for planning the child
+ *
+ * The child PlannerInfo reuses most of the parent PlannerInfo's fields
+ * unchanged, except unexpanded_tlist and processed_tlist are based on the
+ * child relation.
+ */
+static PlannerInfo *
+adjust_inherited_target_child_root(PlannerInfo *root, AppendRelInfo *appinfo)
+{
+	PlannerInfo *subroot;
+	List	   *tlist;
+	ListCell   *lc;
+
+	Assert(root->parse->commandType == CMD_UPDATE ||
+		   root->parse->commandType == CMD_DELETE);
+
+	/* Translate the original query's expressions to this child. */
+	subroot = makeNode(PlannerInfo);
+	memcpy(subroot, root, sizeof(PlannerInfo));
+
+	/*
+	 * Restore the unexpanded tlist for translation, so that child's
+	 * query contains targetList numbered (resnos) per its own
+	 * TupleDesc, which adjust_inherited_tlist ensures.
+	 */
+	root->parse->targetList = root->unexpanded_tlist;
+	subroot->parse = (Query *) adjust_appendrel_attrs(root,
+													  (Node *) root->parse,
+													  1, &appinfo);
+
+	/*
+	 * Save the original unexpanded targetlist in child subroot, just as
+	 * we did for the parent root, so that this child's own children can use
+	 * it.  Must use copy because subroot->parse->targetList will be modified
+	 * soon.
+	 */
+	subroot->unexpanded_tlist = list_copy(subroot->parse->targetList);
+
+	/*
+	 * Apply planner's expansion of targetlist, such as adding various junk
+	 * column, filling placeholder entries for dropped columns, etc., all of
+	 * which occurs with the child's TupleDesc.
+	 */
+	tlist = preprocess_targetlist(subroot);
+	subroot->processed_tlist = tlist;
+
+	/* Add any newly added Vars to the child RelOptInfo. */
+	build_base_rel_tlists(subroot, tlist);
+
+	/*
+	 * Adjust all_baserels to replace the original target relation with the
+	 * child target relation.  Copy it before modifying though.
+	 */
+	subroot->all_baserels = bms_copy(root->all_baserels);
+	subroot->all_baserels = bms_del_member(subroot->all_baserels,
+										   root->parse->resultRelation);
+	subroot->all_baserels = bms_add_member(subroot->all_baserels,
+										   subroot->parse->resultRelation);
+
+	/*
+	 * Child root should get its own copy of ECs, because they'll be modified
+	 * to replace parent EC expressions by child expressions in
+	 * add_child_rel_equivalences.
+	 */
+	subroot->eq_classes = NIL;
+	foreach(lc, root->eq_classes)
+	{
+		EquivalenceClass *ec = lfirst(lc);
+		EquivalenceClass *new_ec = makeNode(EquivalenceClass);
+
+		memcpy(new_ec, ec, sizeof(EquivalenceClass));
+		new_ec->ec_members = list_copy(ec->ec_members);
+		subroot->eq_classes = lappend(subroot->eq_classes, new_ec);
+	}
+
+	return subroot;
+}
diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index 98acb58304..a0bb61af41 100644
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -37,6 +37,7 @@
 #ifdef OPTIMIZER_DEBUG
 #include "nodes/print.h"
 #endif
+#include "nodes/relation.h"
 #include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
 #include "optimizer/cost.h"
@@ -128,7 +129,7 @@ static Node *preprocess_expression(PlannerInfo *root, Node *expr, int kind);
 static void preprocess_qual_conditions(PlannerInfo *root, Node *jtnode);
 static void inheritance_planner(PlannerInfo *root);
 static void grouping_planner(PlannerInfo *root, bool inheritance_update,
-				 double tuple_fraction);
+				 RelOptInfo *planned_rel, double tuple_fraction);
 static grouping_sets_data *preprocess_grouping_sets(PlannerInfo *root);
 static List *remap_to_groupclause_idx(List *groupClause, List *gsets,
 						 int *tleref_to_colnum_map);
@@ -632,7 +633,6 @@ subquery_planner(PlannerGlobal *glob, Query *parse,
 	root->grouping_map = NULL;
 	root->minmax_aggs = NIL;
 	root->qual_security_level = 0;
-	root->inhTargetKind = INHKIND_NONE;
 	root->hasRecursion = hasRecursion;
 	if (hasRecursion)
 		root->wt_param_id = SS_assign_special_param(root);
@@ -722,6 +722,13 @@ subquery_planner(PlannerGlobal *glob, Query *parse,
 	expand_inherited_tables(root);
 
 	/*
+	 * Now that we have figured out "actual" inheritance situation of the
+	 * relations, set whether the query is an inherited UPDATE/DELETE.
+	 */
+	root->inherited_update = (parse->resultRelation &&
+					  rt_fetch(parse->resultRelation, parse->rtable)->inh);
+
+	/*
 	 * Set hasHavingQual to remember if HAVING clause is present.  Needed
 	 * because preprocess_expression will reduce a constant-true condition to
 	 * an empty qual list ... but "HAVING TRUE" is not a semantic no-op.
@@ -972,7 +979,7 @@ subquery_planner(PlannerGlobal *glob, Query *parse,
 		rt_fetch(parse->resultRelation, parse->rtable)->inh)
 		inheritance_planner(root);
 	else
-		grouping_planner(root, false, tuple_fraction);
+		grouping_planner(root, false, NULL, tuple_fraction);
 
 	/*
 	 * Capture the set of outer-level param IDs we have access to, for use in
@@ -1148,12 +1155,19 @@ preprocess_phv_expression(PlannerInfo *root, Expr *expr)
  *	  inheritance set.
  *
  * We have to handle this case differently from cases where a source relation
- * is an inheritance set. Source inheritance is expanded at the bottom of the
- * plan tree (see allpaths.c), but target inheritance has to be expanded at
- * the top.  The reason is that for UPDATE, each target relation needs a
- * different targetlist matching its own column set.  Fortunately,
- * the UPDATE/DELETE target can never be the nullable side of an outer join,
- * so it's OK to generate the plan this way.
+ * is an inheritance set.  That's mainly because for UPDATE, each target
+ * relation needs a different targetlist matching its own column set.  So, we
+ * must modify the source scan/join path for each target relation such that it
+ * produces the desired target list.
+ *
+ * The source scan/join paths for individual target relations are still
+ * created in allpaths.c (see set_inherit_target_rel_sizes,
+ * set_inherit_target_rel_pathlists, and inherit_make_rel_from_joinlist).
+ * Here we apply grouping_planner to each child scan/join path so that it
+ * produces the desired targetlist.
+ *
+ * Fortunately, the UPDATE/DELETE target can never be the nullable side of an
+ * outer join, so it's OK to generate the plan this way.
  *
  * Returns nothing; the useful output is in the Paths we attach to
  * the (UPPERREL_FINAL, NULL) upperrel stored in *root.
@@ -1166,14 +1180,8 @@ inheritance_planner(PlannerInfo *root)
 {
 	Query	   *parse = root->parse;
 	int			top_parentRTindex = parse->resultRelation;
-	Bitmapset  *subqueryRTindexes;
-	Bitmapset  *modifiableARIindexes;
 	int			nominalRelation = -1;
 	Index		rootRelation = 0;
-	List	   *final_rtable = NIL;
-	int			save_rel_array_size = 0;
-	RelOptInfo **save_rel_array = NULL;
-	AppendRelInfo **save_append_rel_array = NULL;
 	List	   *subpaths = NIL;
 	List	   *subroots = NIL;
 	List	   *resultRelations = NIL;
@@ -1181,70 +1189,58 @@ inheritance_planner(PlannerInfo *root)
 	List	   *returningLists = NIL;
 	List	   *rowMarks;
 	RelOptInfo *final_rel;
-	ListCell   *lc;
-	Index		rti;
+	ListCell   *lc1,
+			   *lc2;
 	RangeTblEntry *parent_rte;
-	PlannerInfo *parent_root;
-	Query	   *parent_parse;
-	Bitmapset  *parent_relids = bms_make_singleton(top_parentRTindex);
-	PlannerInfo **parent_roots = NULL;
+	List	   *tlist;
+	standard_qp_extra qp_extra;
+	RelOptInfo *planned_rel;
 
+	/* Inheritance is never used for insert. */
 	Assert(parse->commandType != CMD_INSERT);
 
 	/*
-	 * We generate a modified instance of the original Query for each target
-	 * relation, plan that, and put all the plans into a list that will be
-	 * controlled by a single ModifyTable node.  All the instances share the
-	 * same rangetable, but each instance must have its own set of subquery
-	 * RTEs within the finished rangetable because (1) they are likely to get
-	 * scribbled on during planning, and (2) it's not inconceivable that
-	 * subqueries could get planned differently in different cases.  We need
-	 * not create duplicate copies of other RTE kinds, in particular not the
-	 * target relations, because they don't have either of those issues.  Not
-	 * having to duplicate the target relations is important because doing so
-	 * (1) would result in a rangetable of length O(N^2) for N targets, with
-	 * at least O(N^3) work expended here; and (2) would greatly complicate
-	 * management of the rowMarks list.
+	 * Generate the access paths for all relations mentioned in the query,
+	 * including the target inheritance set.  When doing the join planning,
+	 * references in the join tree to the original target relation that's the
+	 * root parent of the inheritance tree are replaced by each of its
+	 * inheritance children and the resulting joinrel RelOptInfo's are
+	 * added to root->inh_target_child_rels.
 	 *
-	 * To begin with, generate a bitmapset of the relids of the subquery RTEs.
+	 * Final planning steps (grouping_planner) are applied to the best path
+	 * of each of those child joinrels using a modified instance of the
+	 * original query for a given child target rel.  All the paths so
+	 * generated are put into a list that will be controlled by a single
+	 * ModifyTable node.  All the instances share the same rangetable.
 	 */
-	subqueryRTindexes = NULL;
-	rti = 1;
-	foreach(lc, parse->rtable)
-	{
-		RangeTblEntry *rte = lfirst_node(RangeTblEntry, lc);
-
-		if (rte->rtekind == RTE_SUBQUERY)
-			subqueryRTindexes = bms_add_member(subqueryRTindexes, rti);
-		rti++;
-	}
 
 	/*
-	 * Next, we want to identify which AppendRelInfo items contain references
-	 * to any of the aforesaid subquery RTEs.  These items will need to be
-	 * copied and modified to adjust their subquery references; whereas the
-	 * other ones need not be touched.  It's worth being tense over this
-	 * because we can usually avoid processing most of the AppendRelInfo
-	 * items, thereby saving O(N^2) space and time when the target is a large
-	 * inheritance tree.  We can identify AppendRelInfo items by their
-	 * child_relid, since that should be unique within the list.
+	 * Save the unexpanded version of the query's targetlist to be used below
+	 * for passing to grouping_planner for each child target relation.
 	 */
-	modifiableARIindexes = NULL;
-	if (subqueryRTindexes != NULL)
-	{
-		foreach(lc, root->append_rel_list)
-		{
-			AppendRelInfo *appinfo = lfirst_node(AppendRelInfo, lc);
+	root->unexpanded_tlist = list_copy(root->parse->targetList);
 
-			if (bms_is_member(appinfo->parent_relid, subqueryRTindexes) ||
-				bms_is_member(appinfo->child_relid, subqueryRTindexes) ||
-				bms_overlap(pull_varnos((Node *) appinfo->translated_vars),
-							subqueryRTindexes))
-				modifiableARIindexes = bms_add_member(modifiableARIindexes,
-													  appinfo->child_relid);
-		}
+	/* Do the scan/join planning. */
+	tlist = preprocess_targetlist(root);
+	root->processed_tlist = tlist;
+	qp_extra.tlist = tlist;
+	qp_extra.activeWindows = qp_extra.groupClause = NIL;
+	planned_rel = query_planner(root, tlist, standard_qp_callback, &qp_extra);
+
+	/*
+	 * If it turned out during query planning that all the children are dummy
+	 * (pruned or excluded by constraints), no need to do the steps below.
+	 * Let grouping_planner finish up the final path.
+	 */
+	if (IS_DUMMY_REL(planned_rel))
+	{
+		grouping_planner(root, false, planned_rel, 0.0);
+		return;
 	}
 
+	Assert(planned_rel->relid == top_parentRTindex);
+	Assert(planned_rel->reloptkind == RELOPT_BASEREL);
+
 	/*
 	 * If the parent RTE is a partitioned table, we should use that as the
 	 * nominal target relation, because the RTEs added for partitioned tables
@@ -1252,7 +1248,7 @@ inheritance_planner(PlannerInfo *root)
 	 * not appear anywhere else in the plan, so the confusion explained below
 	 * for non-partitioning inheritance cases is not possible.
 	 */
-	parent_rte = rt_fetch(top_parentRTindex, root->parse->rtable);
+	parent_rte = planner_rt_fetch(top_parentRTindex, root);
 	if (parent_rte->relkind == RELKIND_PARTITIONED_TABLE)
 	{
 		nominalRelation = top_parentRTindex;
@@ -1260,95 +1256,42 @@ inheritance_planner(PlannerInfo *root)
 	}
 
 	/*
-	 * The PlannerInfo for each child is obtained by translating the relevant
-	 * members of the PlannerInfo for its immediate parent, which we find
-	 * using the parent_relid in its AppendRelInfo.  We save the PlannerInfo
-	 * for each parent in an array indexed by relid for fast retrieval. Since
-	 * the maximum number of parents is limited by the number of RTEs in the
-	 * query, we use that number to allocate the array. An extra entry is
-	 * needed since relids start from 1.
+	 * Get on with finalizing the path for each child target relation by
+	 * calling grouping_planner on its joinrel.  Note that we're restoring
+	 * the query's targetlist to the original one for grouping_planner's
+	 * targetlist expansion steps to perform the expansion with individual
+	 * child descriptors.
 	 */
-	parent_roots = (PlannerInfo **) palloc0((list_length(parse->rtable) + 1) *
-											sizeof(PlannerInfo *));
-	parent_roots[top_parentRTindex] = root;
-
-	/*
-	 * And now we can get on with generating a plan for each child table.
-	 */
-	foreach(lc, root->append_rel_list)
+	forboth(lc1, root->inh_target_child_rels,
+			lc2, root->inh_target_child_joinrels)
 	{
-		AppendRelInfo *appinfo = lfirst_node(AppendRelInfo, lc);
-		PlannerInfo *subroot;
+		Index		childRTindex = lfirst_int(lc1);
+		RelOptInfo *childrel = lfirst(lc2);
+		PlannerInfo *subroot = root->inh_target_child_roots[childRTindex];
+		AppendRelInfo *appinfo = root->append_rel_array[childRTindex];
 		RangeTblEntry *child_rte;
 		RelOptInfo *sub_final_rel;
 		Path	   *subpath;
 
-		/* append_rel_list contains all append rels; ignore others */
-		if (!bms_is_member(appinfo->parent_relid, parent_relids))
-			continue;
-
-		/*
-		 * expand_inherited_rtentry() always processes a parent before any of
-		 * that parent's children, so the parent_root for this relation should
-		 * already be available.
-		 */
-		parent_root = parent_roots[appinfo->parent_relid];
-		Assert(parent_root != NULL);
-		parent_parse = parent_root->parse;
-
-		/*
-		 * We need a working copy of the PlannerInfo so that we can control
-		 * propagation of information back to the main copy.
-		 */
-		subroot = makeNode(PlannerInfo);
-		memcpy(subroot, parent_root, sizeof(PlannerInfo));
-
-		/*
-		 * Generate modified query with this rel as target.  We first apply
-		 * adjust_appendrel_attrs, which copies the Query and changes
-		 * references to the parent RTE to refer to the current child RTE,
-		 * then fool around with subquery RTEs.
-		 */
-		subroot->parse = (Query *)
-			adjust_appendrel_attrs(parent_root,
-								   (Node *) parent_parse,
-								   1, &appinfo);
+		Assert(subroot != NULL);
+		Assert(subroot->parse->resultRelation == childRTindex);
 
 		/*
 		 * If there are securityQuals attached to the parent, move them to the
 		 * child rel (they've already been transformed properly for that).
 		 */
-		parent_rte = rt_fetch(appinfo->parent_relid, subroot->parse->rtable);
-		child_rte = rt_fetch(appinfo->child_relid, subroot->parse->rtable);
+		parent_rte = planner_rt_fetch(appinfo->parent_relid, subroot);
+		child_rte = planner_rt_fetch(appinfo->child_relid, subroot);
 		child_rte->securityQuals = parent_rte->securityQuals;
 		parent_rte->securityQuals = NIL;
 
 		/*
-		 * Mark whether we're planning a query to a partitioned table or an
-		 * inheritance parent.
+		 * Ignore a partitioned child.  Instead, the paths of its children will
+		 * be added to subpaths.
 		 */
-		subroot->inhTargetKind =
-			(rootRelation != 0) ? INHKIND_PARTITIONED : INHKIND_INHERITED;
-
-		/*
-		 * If this child is further partitioned, remember it as a parent.
-		 * Since a partitioned table does not have any data, we don't need to
-		 * create a plan for it, and we can stop processing it here.  We do,
-		 * however, need to remember its modified PlannerInfo for use when
-		 * processing its children, since we'll update their varnos based on
-		 * the delta from immediate parent to child, not from top to child.
-		 *
-		 * Note: a very non-obvious point is that we have not yet added
-		 * duplicate subquery RTEs to the subroot's rtable.  We mustn't,
-		 * because then its children would have two sets of duplicates,
-		 * confusing matters.
-		 */
-		if (child_rte->inh)
+		if (childrel->part_scheme)
 		{
-			Assert(child_rte->relkind == RELKIND_PARTITIONED_TABLE);
-			parent_relids = bms_add_member(parent_relids, appinfo->child_relid);
-			parent_roots[appinfo->child_relid] = subroot;
-
+			Assert(child_rte->inh);
 			continue;
 		}
 
@@ -1376,111 +1319,8 @@ inheritance_planner(PlannerInfo *root)
 		if (nominalRelation < 0)
 			nominalRelation = appinfo->child_relid;
 
-		/*
-		 * The rowMarks list might contain references to subquery RTEs, so
-		 * make a copy that we can apply ChangeVarNodes to.  (Fortunately, the
-		 * executor doesn't need to see the modified copies --- we can just
-		 * pass it the original rowMarks list.)
-		 */
-		subroot->rowMarks = copyObject(parent_root->rowMarks);
-
-		/*
-		 * The append_rel_list likewise might contain references to subquery
-		 * RTEs (if any subqueries were flattenable UNION ALLs).  So prepare
-		 * to apply ChangeVarNodes to that, too.  As explained above, we only
-		 * want to copy items that actually contain such references; the rest
-		 * can just get linked into the subroot's append_rel_list.
-		 *
-		 * If we know there are no such references, we can just use the outer
-		 * append_rel_list unmodified.
-		 */
-		if (modifiableARIindexes != NULL)
-		{
-			ListCell   *lc2;
-
-			subroot->append_rel_list = NIL;
-			foreach(lc2, parent_root->append_rel_list)
-			{
-				AppendRelInfo *appinfo2 = lfirst_node(AppendRelInfo, lc2);
-
-				if (bms_is_member(appinfo2->child_relid, modifiableARIindexes))
-					appinfo2 = copyObject(appinfo2);
-
-				subroot->append_rel_list = lappend(subroot->append_rel_list,
-												   appinfo2);
-			}
-		}
-
-		/*
-		 * Add placeholders to the child Query's rangetable list to fill the
-		 * RT indexes already reserved for subqueries in previous children.
-		 * These won't be referenced, so there's no need to make them very
-		 * valid-looking.
-		 */
-		while (list_length(subroot->parse->rtable) < list_length(final_rtable))
-			subroot->parse->rtable = lappend(subroot->parse->rtable,
-											 makeNode(RangeTblEntry));
-
-		/*
-		 * If this isn't the first child Query, generate duplicates of all
-		 * subquery RTEs, and adjust Var numbering to reference the
-		 * duplicates. To simplify the loop logic, we scan the original rtable
-		 * not the copy just made by adjust_appendrel_attrs; that should be OK
-		 * since subquery RTEs couldn't contain any references to the target
-		 * rel.
-		 */
-		if (final_rtable != NIL && subqueryRTindexes != NULL)
-		{
-			ListCell   *lr;
-
-			rti = 1;
-			foreach(lr, parent_parse->rtable)
-			{
-				RangeTblEntry *rte = lfirst_node(RangeTblEntry, lr);
-
-				if (bms_is_member(rti, subqueryRTindexes))
-				{
-					Index		newrti;
-
-					/*
-					 * The RTE can't contain any references to its own RT
-					 * index, except in its securityQuals, so we can save a
-					 * few cycles by applying ChangeVarNodes to the rest of
-					 * the rangetable before we append the RTE to it.
-					 */
-					newrti = list_length(subroot->parse->rtable) + 1;
-					ChangeVarNodes((Node *) subroot->parse, rti, newrti, 0);
-					ChangeVarNodes((Node *) subroot->rowMarks, rti, newrti, 0);
-					/* Skip processing unchanging parts of append_rel_list */
-					if (modifiableARIindexes != NULL)
-					{
-						ListCell   *lc2;
-
-						foreach(lc2, subroot->append_rel_list)
-						{
-							AppendRelInfo *appinfo2 = lfirst_node(AppendRelInfo, lc2);
-
-							if (bms_is_member(appinfo2->child_relid,
-											  modifiableARIindexes))
-								ChangeVarNodes((Node *) appinfo2, rti, newrti, 0);
-						}
-					}
-					rte = copyObject(rte);
-					ChangeVarNodes((Node *) rte->securityQuals, rti, newrti, 0);
-					subroot->parse->rtable = lappend(subroot->parse->rtable,
-													 rte);
-				}
-				rti++;
-			}
-		}
-
-		/* There shouldn't be any OJ info to translate, as yet */
-		Assert(subroot->join_info_list == NIL);
-		/* and we haven't created PlaceHolderInfos, either */
-		Assert(subroot->placeholder_list == NIL);
-
-		/* Generate Path(s) for accessing this result relation */
-		grouping_planner(subroot, true, 0.0 /* retrieve all tuples */ );
+		/* Apply the top-level targetlist to childrel's path. */
+		grouping_planner(subroot, true, childrel, 0.0);
 
 		/*
 		 * Select cheapest path in case there's more than one.  We always run
@@ -1492,45 +1332,10 @@ inheritance_planner(PlannerInfo *root)
 		subpath = sub_final_rel->cheapest_total_path;
 
 		/*
-		 * If this child rel was excluded by constraint exclusion, exclude it
-		 * from the result plan.
+		 * child rel cannot be empty, or inheritance_make_rel_from_joinlist
+		 * wouldn't have put it in the list to begin with.
 		 */
-		if (IS_DUMMY_PATH(subpath))
-			continue;
-
-		/*
-		 * If this is the first non-excluded child, its post-planning rtable
-		 * becomes the initial contents of final_rtable; otherwise, append
-		 * just its modified subquery RTEs to final_rtable.
-		 */
-		if (final_rtable == NIL)
-			final_rtable = subroot->parse->rtable;
-		else
-			final_rtable = list_concat(final_rtable,
-									   list_copy_tail(subroot->parse->rtable,
-													  list_length(final_rtable)));
-
-		/*
-		 * We need to collect all the RelOptInfos from all child plans into
-		 * the main PlannerInfo, since setrefs.c will need them.  We use the
-		 * last child's simple_rel_array (previous ones are too short), so we
-		 * have to propagate forward the RelOptInfos that were already built
-		 * in previous children.
-		 */
-		Assert(subroot->simple_rel_array_size >= save_rel_array_size);
-		for (rti = 1; rti < save_rel_array_size; rti++)
-		{
-			RelOptInfo *brel = save_rel_array[rti];
-
-			if (brel)
-				subroot->simple_rel_array[rti] = brel;
-		}
-		save_rel_array_size = subroot->simple_rel_array_size;
-		save_rel_array = subroot->simple_rel_array;
-		save_append_rel_array = subroot->append_rel_array;
-
-		/* Make sure any initplans from this rel get into the outer list */
-		root->init_plans = subroot->init_plans;
+		Assert(!IS_DUMMY_PATH(subpath));
 
 		/* Build list of sub-paths */
 		subpaths = lappend(subpaths, subpath);
@@ -1562,36 +1367,6 @@ inheritance_planner(PlannerInfo *root)
 	 */
 
 	/*
-	 * If we managed to exclude every child rel, return a dummy plan; it
-	 * doesn't even need a ModifyTable node.
-	 */
-	if (subpaths == NIL)
-	{
-		set_dummy_rel_pathlist(final_rel);
-		return;
-	}
-
-	/*
-	 * Put back the final adjusted rtable into the master copy of the Query.
-	 * (We mustn't do this if we found no non-excluded children.)
-	 */
-	parse->rtable = final_rtable;
-	root->simple_rel_array_size = save_rel_array_size;
-	root->simple_rel_array = save_rel_array;
-	root->append_rel_array = save_append_rel_array;
-
-	/* Must reconstruct master's simple_rte_array, too */
-	root->simple_rte_array = (RangeTblEntry **)
-		palloc0((list_length(final_rtable) + 1) * sizeof(RangeTblEntry *));
-	rti = 1;
-	foreach(lc, final_rtable)
-	{
-		RangeTblEntry *rte = lfirst_node(RangeTblEntry, lc);
-
-		root->simple_rte_array[rti++] = rte;
-	}
-
-	/*
 	 * If there was a FOR [KEY] UPDATE/SHARE clause, the LockRows node will
 	 * have dealt with fetching non-locked marked rows, else we need to have
 	 * ModifyTable do that.
@@ -1631,6 +1406,12 @@ inheritance_planner(PlannerInfo *root)
  * (inheritance_planner will create a single ModifyTable node covering all the
  * target tables.)
  *
+ * If non-NULL, planned_rel is a RelOptInfo containing paths for the query's
+ * top-level joinrel, which the caller produced by itself.  In that case, this
+ * function only needs to adjust the targetlist of its cheapest_total_path.
+ * The only caller that may pass such a RelOptInfo currently is
+ * inheritance_planner.
+ *
  * tuple_fraction is the fraction of tuples we expect will be retrieved.
  * tuple_fraction is interpreted as follows:
  *	  0: expect all tuples to be retrieved (normal case)
@@ -1649,6 +1430,7 @@ inheritance_planner(PlannerInfo *root)
  */
 static void
 grouping_planner(PlannerInfo *root, bool inheritance_update,
+				 RelOptInfo *planned_rel,
 				 double tuple_fraction)
 {
 	Query	   *parse = root->parse;
@@ -1661,7 +1443,7 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 	List	   *final_targets;
 	List	   *final_targets_contain_srfs;
 	bool		final_target_parallel_safe;
-	RelOptInfo *current_rel;
+	RelOptInfo *current_rel = planned_rel;
 	RelOptInfo *final_rel;
 	ListCell   *lc;
 
@@ -1701,6 +1483,7 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 		 * special work for recursive unions is the responsibility of
 		 * plan_set_operations.
 		 */
+		Assert(current_rel == NULL);
 		current_rel = plan_set_operations(root);
 
 		/*
@@ -1790,17 +1573,26 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 				parse->groupClause = preprocess_groupclause(root, NIL);
 		}
 
-		/* Preprocess targetlist */
-		tlist = preprocess_targetlist(root);
-
 		/*
-		 * We are now done hacking up the query's targetlist.  Most of the
-		 * remaining planning work will be done with the PathTarget
-		 * representation of tlists, but save aside the full representation so
-		 * that we can transfer its decoration (resnames etc) to the topmost
-		 * tlist of the finished Plan.
+		 * Preprocess targetlist, if needed.  If the caller has already done
+		 * query planning, root->processed_tlist already contains the desired
+		 * targetlist.
 		 */
-		root->processed_tlist = tlist;
+		if (planned_rel == NULL)
+		{
+			tlist = preprocess_targetlist(root);
+
+			/*
+			 * We are now done hacking up the query's targetlist.  Most of the
+			 * remaining planning work will be done with the PathTarget
+			 * representation of tlists, but save aside the full representation
+			 * so that we can transfer its decoration (resnames etc) to the
+			 * topmost tlist of the finished Plan.
+			 */
+			root->processed_tlist = tlist;
+		}
+		else
+			tlist = root->processed_tlist;
 
 		/*
 		 * Collect statistics about aggregates for estimating costs, and mark
@@ -1880,8 +1672,9 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 		 * We also generate (in standard_qp_callback) pathkey representations
 		 * of the query's sort clause, distinct clause, etc.
 		 */
-		current_rel = query_planner(root, tlist,
-									standard_qp_callback, &qp_extra);
+		if (current_rel == NULL)
+			current_rel = query_planner(root, tlist,
+										standard_qp_callback, &qp_extra);
 
 		/*
 		 * Convert the query's result tlist into PathTarget format.
diff --git a/src/backend/optimizer/prep/prepjointree.c b/src/backend/optimizer/prep/prepjointree.c
index 77dbf4eba3..87adfa02b1 100644
--- a/src/backend/optimizer/prep/prepjointree.c
+++ b/src/backend/optimizer/prep/prepjointree.c
@@ -917,7 +917,6 @@ pull_up_simple_subquery(PlannerInfo *root, Node *jtnode, RangeTblEntry *rte,
 	subroot->grouping_map = NULL;
 	subroot->minmax_aggs = NIL;
 	subroot->qual_security_level = 0;
-	subroot->inhTargetKind = INHKIND_NONE;
 	subroot->hasRecursion = false;
 	subroot->wt_param_id = -1;
 	subroot->non_recursive_path = NULL;
diff --git a/src/backend/optimizer/util/appendinfo.c b/src/backend/optimizer/util/appendinfo.c
index 37fbc3a117..0b9ca39a51 100644
--- a/src/backend/optimizer/util/appendinfo.c
+++ b/src/backend/optimizer/util/appendinfo.c
@@ -394,8 +394,39 @@ adjust_appendrel_attrs_mutator(Node *node,
 											  context->appinfos);
 		return (Node *) phv;
 	}
+
+	/*
+	 * This is needed, because inheritance_make_rel_from_joinlist needs to
+	 * translate root->join_info_list executing make_rel_from_joinlist for a
+	 * given child.
+	 */
+	if (IsA(node, SpecialJoinInfo))
+	{
+		SpecialJoinInfo *oldinfo = (SpecialJoinInfo *) node;
+		SpecialJoinInfo *newinfo = makeNode(SpecialJoinInfo);
+
+		memcpy(newinfo, oldinfo, sizeof(SpecialJoinInfo));
+		newinfo->min_lefthand = adjust_child_relids(oldinfo->min_lefthand,
+													context->nappinfos,
+													context->appinfos);
+		newinfo->min_righthand = adjust_child_relids(oldinfo->min_righthand,
+													 context->nappinfos,
+													 context->appinfos);
+		newinfo->syn_lefthand = adjust_child_relids(oldinfo->syn_lefthand,
+													context->nappinfos,
+													context->appinfos);
+		newinfo->syn_righthand = adjust_child_relids(oldinfo->syn_righthand,
+													 context->nappinfos,
+													 context->appinfos);
+		newinfo->semi_rhs_exprs =
+			(List *) expression_tree_mutator((Node *)
+											 oldinfo->semi_rhs_exprs,
+											 adjust_appendrel_attrs_mutator,
+											 (void *) context);
+		return (Node *) newinfo;
+	}
+
 	/* 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));
diff --git a/src/backend/optimizer/util/plancat.c b/src/backend/optimizer/util/plancat.c
index 48ffc5f254..6009de309e 100644
--- a/src/backend/optimizer/util/plancat.c
+++ b/src/backend/optimizer/util/plancat.c
@@ -1264,36 +1264,6 @@ get_relation_constraints(PlannerInfo *root,
 		}
 	}
 
-	/*
-	 * Append partition predicates, if any.
-	 *
-	 * For selects, partition pruning uses the parent table's partition bound
-	 * descriptor, instead of constraint exclusion which is driven by the
-	 * individual partition's partition constraint.
-	 */
-	if (enable_partition_pruning && root->parse->commandType != CMD_SELECT)
-	{
-		List	   *pcqual = RelationGetPartitionQual(relation);
-
-		if (pcqual)
-		{
-			/*
-			 * Run the partition quals through const-simplification similar to
-			 * check constraints.  We skip canonicalize_qual, though, because
-			 * partition quals should be in canonical form already; also,
-			 * since the qual is in implicit-AND format, we'd have to
-			 * explicitly convert it to explicit-AND format and back again.
-			 */
-			pcqual = (List *) eval_const_expressions(root, (Node *) pcqual);
-
-			/* Fix Vars to have the desired varno */
-			if (varno != 1)
-				ChangeVarNodes((Node *) pcqual, 1, varno, 0);
-
-			result = list_concat(result, pcqual);
-		}
-	}
-
 	heap_close(relation, NoLock);
 
 	return result;
@@ -1417,40 +1387,15 @@ relation_excluded_by_constraints(PlannerInfo *root,
 	/*
 	 * Skip further tests, depending on constraint_exclusion.
 	 */
-	switch (constraint_exclusion)
-	{
-		case CONSTRAINT_EXCLUSION_OFF:
-
-			/*
-			 * Don't prune if feature turned off -- except if the relation is
-			 * a partition.  While partprune.c-style partition pruning is not
-			 * yet in use for all cases (update/delete is not handled), it
-			 * would be a UI horror to use different user-visible controls
-			 * depending on such a volatile implementation detail.  Therefore,
-			 * for partitioned tables we use enable_partition_pruning to
-			 * control this behavior.
-			 */
-			if (root->inhTargetKind == INHKIND_PARTITIONED)
-				break;
-			return false;
-
-		case CONSTRAINT_EXCLUSION_PARTITION:
-
-			/*
-			 * When constraint_exclusion is set to 'partition' we only handle
-			 * OTHER_MEMBER_RELs, or BASERELs in cases where the result target
-			 * is an inheritance parent or a partitioned table.
-			 */
-			if ((rel->reloptkind != RELOPT_OTHER_MEMBER_REL) &&
-				!(rel->reloptkind == RELOPT_BASEREL &&
-				  root->inhTargetKind != INHKIND_NONE &&
-				  rel->relid == root->parse->resultRelation))
-				return false;
-			break;
-
-		case CONSTRAINT_EXCLUSION_ON:
-			break;				/* always try to exclude */
-	}
+	if (constraint_exclusion == CONSTRAINT_EXCLUSION_OFF)
+		return false;
+	/*
+	 * When constraint_exclusion is set to 'partition' we only handle
+	 * OTHER_MEMBER_RELs.
+	 */
+	else if (constraint_exclusion == CONSTRAINT_EXCLUSION_PARTITION &&
+			 rel->reloptkind != RELOPT_OTHER_MEMBER_REL)
+		return false;
 
 	/*
 	 * Check for self-contradictory restriction clauses.  We dare not make
diff --git a/src/include/nodes/relation.h b/src/include/nodes/relation.h
index 3430061361..beb2e323a8 100644
--- a/src/include/nodes/relation.h
+++ b/src/include/nodes/relation.h
@@ -319,9 +319,6 @@ typedef struct PlannerInfo
 	Index		qual_security_level;	/* minimum security_level for quals */
 	/* Note: qual_security_level is zero if there are no securityQuals */
 
-	InheritanceKind inhTargetKind;	/* indicates if the target relation is an
-									 * inheritance child or partition or a
-									 * partitioned table */
 	bool		hasJoinRTEs;	/* true if any RTEs are RTE_JOIN kind */
 	bool		hasLateralRTEs; /* true if any RTEs are marked LATERAL */
 	bool		hasDeletedRTEs; /* true if any RTE was deleted from jointree */
@@ -343,6 +340,40 @@ typedef struct PlannerInfo
 
 	/* Does this query modify any partition key columns? */
 	bool		partColsUpdated;
+
+	/*
+	 * The following fields are set during query planning portion of an
+	 * inherited UPDATE/DEELETE operation.
+	 */
+	bool		inherited_update;	/* UPDATE/DELETE on inheritance parent? */
+
+	/*
+	 * This stores the original version of the query's targetlist that's
+	 * not modified by the planner.
+	 */
+	List	   *unexpanded_tlist;
+
+	/*
+	 * Array containing simple_rel_array_size elements, indexed by rangetable
+	 * index (entry 0 is wasted like simple_rel_array).  Only elements
+	 * corresponding to individual inheritance child target relations are
+	 * non-NULL.  Content of each PlannerInfo is same as the parent
+	 * PlannerInfo, except for the parse tree which is a translated copy of
+	 * the parent's parse tree.
+	 */
+	struct PlannerInfo **inh_target_child_roots;
+
+	/* List of RT indexes of child RT indexes. */
+	List	   *inh_target_child_rels;
+
+	/*
+	 * RelOptInfos corresponding to each child target rel.  For leaf children,
+	 * it's the RelOptInfo representing the output of make_rel_from_joinlist()
+	 * called with the parent rel in the original join tree replaced by a
+	 * given leaf child.  For non-leaf children, it's the baserel RelOptInfo
+	 * itself, left as a placeholder.
+	 */
+	List	   *inh_target_child_joinrels;
 } PlannerInfo;
 
 
diff --git a/src/include/optimizer/paths.h b/src/include/optimizer/paths.h
index 666217c189..f524ab6beb 100644
--- a/src/include/optimizer/paths.h
+++ b/src/include/optimizer/paths.h
@@ -161,7 +161,8 @@ extern EquivalenceClass *match_eclasses_to_foreign_key_col(PlannerInfo *root,
 extern void add_child_rel_equivalences(PlannerInfo *root,
 						   AppendRelInfo *appinfo,
 						   RelOptInfo *parent_rel,
-						   RelOptInfo *child_rel);
+						   RelOptInfo *child_rel,
+						   bool replace);
 extern List *generate_implied_equalities_for_column(PlannerInfo *root,
 									   RelOptInfo *rel,
 									   ec_matches_callback_type callback,
diff --git a/src/test/regress/expected/partition_join.out b/src/test/regress/expected/partition_join.out
index c55de5d476..c9f02c1fb0 100644
--- a/src/test/regress/expected/partition_join.out
+++ b/src/test/regress/expected/partition_join.out
@@ -1780,7 +1780,7 @@ WHERE EXISTS (
                Filter: (c IS NULL)
          ->  Nested Loop
                ->  Seq Scan on int4_tbl
-               ->  Subquery Scan on ss_1
+               ->  Subquery Scan on ss
                      ->  Limit
                            ->  Seq Scan on int8_tbl int8_tbl_1
    ->  Nested Loop Semi Join
@@ -1788,7 +1788,7 @@ WHERE EXISTS (
                Filter: (c IS NULL)
          ->  Nested Loop
                ->  Seq Scan on int4_tbl
-               ->  Subquery Scan on ss_2
+               ->  Subquery Scan on ss
                      ->  Limit
                            ->  Seq Scan on int8_tbl int8_tbl_2
 (28 rows)
-- 
2.11.0

From 2dc0d62b9475841805caa4dbc38cb62fc85251a5 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Fri, 26 Oct 2018 16:45:59 +0900
Subject: [PATCH v13 3/6] Store inheritance root parent index in otherrel's
 RelOptInfo

Although it's set by build_simple_rel, it's not being used by any
code yet.
---
 src/backend/nodes/outfuncs.c         |  1 +
 src/backend/optimizer/util/relnode.c | 15 +++++++++++++--
 src/include/nodes/relation.h         |  9 +++++++++
 3 files changed, 23 insertions(+), 2 deletions(-)

diff --git a/src/backend/nodes/outfuncs.c b/src/backend/nodes/outfuncs.c
index 158da68925..67697b8884 100644
--- a/src/backend/nodes/outfuncs.c
+++ b/src/backend/nodes/outfuncs.c
@@ -2272,6 +2272,7 @@ _outRelOptInfo(StringInfo str, const RelOptInfo *node)
 	WRITE_BOOL_FIELD(consider_partitionwise_join);
 	WRITE_BITMAPSET_FIELD(top_parent_relids);
 	WRITE_NODE_FIELD(partitioned_child_rels);
+	WRITE_UINT_FIELD(inh_root_parent);
 }
 
 static void
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index fe83ec4519..45f9950935 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -195,6 +195,7 @@ build_simple_rel(PlannerInfo *root, int relid, RelOptInfo *parent)
 	rel->joininfo = NIL;
 	rel->has_eclass_joins = false;
 	rel->consider_partitionwise_join = false; /* might get changed later */
+	rel->top_parent_relids = NULL; /* might be changed later */
 	rel->part_scheme = NULL;
 	rel->nparts = 0;
 	rel->boundinfo = NULL;
@@ -203,6 +204,7 @@ build_simple_rel(PlannerInfo *root, int relid, RelOptInfo *parent)
 	rel->partexprs = NULL;
 	rel->nullable_partexprs = NULL;
 	rel->partitioned_child_rels = NIL;
+	rel->inh_root_parent = 0; /* might be changed later */
 
 	/*
 	 * Pass top parent's relids down the inheritance hierarchy. If the parent
@@ -216,9 +218,18 @@ build_simple_rel(PlannerInfo *root, int relid, RelOptInfo *parent)
 			rel->top_parent_relids = parent->top_parent_relids;
 		else
 			rel->top_parent_relids = bms_copy(parent->relids);
+
+		/*
+		 * For inheritance child relations, we also set inh_root_parent.
+		 * Note that 'parent' might itself be a child (a sub-partitioned
+		 * partition), in which case we simply use its value of
+		 * inh_root_parent.
+		 */
+		if (parent->rtekind == RTE_RELATION)
+			rel->inh_root_parent = parent->inh_root_parent > 0 ?
+										parent->inh_root_parent :
+										parent->relid;
 	}
-	else
-		rel->top_parent_relids = NULL;
 
 	/* Check type of rtable entry */
 	switch (rte->rtekind)
diff --git a/src/include/nodes/relation.h b/src/include/nodes/relation.h
index beb2e323a8..db439bd904 100644
--- a/src/include/nodes/relation.h
+++ b/src/include/nodes/relation.h
@@ -734,6 +734,15 @@ typedef struct RelOptInfo
 	List	  **partexprs;		/* Non-nullable partition key expressions. */
 	List	  **nullable_partexprs; /* Nullable partition key expressions. */
 	List	   *partitioned_child_rels; /* List of RT indexes. */
+
+	/*
+	 * For inheritance children, this is the RT index of inheritance table
+	 * mentioned in the query from which this relation originated.
+	 * top_parent_relids cannot be used for this, because if the inheritance
+	 * root table is itself under UNION ALL, top_parent_relids contains the
+	 * RT index of UNION ALL parent subquery.
+	 */
+	Index		inh_root_parent;
 } RelOptInfo;
 
 /*
-- 
2.11.0

From 8b1f8e5d6027bae1d560ba123d85002494681d70 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Wed, 17 Oct 2018 18:14:13 +0900
Subject: [PATCH v13 4/6] Lazy creation of RTEs for inheritance children

Currently, expand_inherited_tables called from subquery_planner opens
all inheritance child tables and adds them to the query's range
table and PlannerInfo in the form of AppendRelInfo's initially and
later RelOptInfo's.  For partitioning, that's pretty wasteful, because
it's possible to determine only the partitions that will need to be
scanned using partition pruning, which doesn't require opening the
partitions themselves.  However, the point at which the above
processing happens is too early to perform partition pruning.

This commit rearranges things within the planner so that inheritance
child relations can be added to the Query and PlannerInfo during
make_one_rel, just before set_base_rel_sizes is called.  Although the
late initialization approach only benefits the partitioning case, it
seems undesirable to do it only for partitioned tables, because it
means adding code to handle partitions specially at various places
within the planner.  So, *all* inheritance parent tables are expanded
in make_one_rel.  All unpruned partitions are added to Query in the
form of their RangeTblEntry's being added to the range table and to
PlannerInfo in the form of an AppendRelInfo and a RelOptInfo for each.

For partitioning, although we don't create a RangeTblEntry and
RelOptInfo for pruned partitions at make_one_rel time, partitionwise
join code relies on the fact that even though partitions may have
been pruned, they'd still own a RelOptInfo to handle the outer join
case where the pruned partition appears on the nullable side of join.
Partitionwise join code deals with that by allocating dummy
RelOptInfos for pruned partitions that are based mostly on their
parent's properties.

There are some regression test diffs:

 1. Caused by the fact that we no longer allocate a duplicate RT
    entry for a partitioned table in its role as child, as seen in
    the partition_aggregate.out test output.

 2. Those in postgres_fdw.out are caused by the fact that junk columns
    required for row marking are added to reltarget->exprs later than
    user columns, because the row marking junk columns arent added
    until after the inheritance is expanded which as of this commit
    is later than it used to be.
---
 contrib/postgres_fdw/expected/postgres_fdw.out    |  32 +-
 src/backend/optimizer/path/allpaths.c             | 357 +---------
 src/backend/optimizer/path/joinrels.c             |  61 ++
 src/backend/optimizer/plan/initsplan.c            |  58 --
 src/backend/optimizer/plan/planmain.c             |  12 +-
 src/backend/optimizer/plan/planner.c              |  77 ++-
 src/backend/optimizer/plan/setrefs.c              |   6 +
 src/backend/optimizer/prep/preptlist.c            |  15 +-
 src/backend/optimizer/prep/prepunion.c            |   3 +
 src/backend/optimizer/util/appendinfo.c           |  45 +-
 src/backend/optimizer/util/inherit.c              | 808 +++++++++++++++-------
 src/backend/optimizer/util/plancat.c              |  47 +-
 src/backend/optimizer/util/relnode.c              |  84 +--
 src/backend/partitioning/partprune.c              |  43 +-
 src/include/nodes/relation.h                      |   9 +
 src/include/optimizer/appendinfo.h                |   7 +-
 src/include/optimizer/pathnode.h                  |   1 +
 src/include/optimizer/plancat.h                   |   4 +-
 src/include/optimizer/prep.h                      |   3 +-
 src/include/partitioning/partprune.h              |   2 +-
 src/test/regress/expected/partition_aggregate.out |   4 +-
 21 files changed, 901 insertions(+), 777 deletions(-)

diff --git a/contrib/postgres_fdw/expected/postgres_fdw.out b/contrib/postgres_fdw/expected/postgres_fdw.out
index bb92d9d37a..33a33606ef 100644
--- a/contrib/postgres_fdw/expected/postgres_fdw.out
+++ b/contrib/postgres_fdw/expected/postgres_fdw.out
@@ -7072,15 +7072,15 @@ select * from bar where f1 in (select f1 from foo) for update;
                      Output: bar2.f1, bar2.f2, bar2.ctid, bar2.*, bar2.tableoid
                      Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct2 FOR UPDATE
          ->  Hash
-               Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+               Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                ->  HashAggregate
-                     Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                     Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                      Group Key: foo.f1
                      ->  Append
                            ->  Seq Scan on public.foo
-                                 Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                                 Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                            ->  Foreign Scan on public.foo2
-                                 Output: foo2.ctid, foo2.*, foo2.tableoid, foo2.f1
+                                 Output: foo2.f1, foo2.ctid, foo2.*, foo2.tableoid
                                  Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct1
 (23 rows)
 
@@ -7110,15 +7110,15 @@ select * from bar where f1 in (select f1 from foo) for share;
                      Output: bar2.f1, bar2.f2, bar2.ctid, bar2.*, bar2.tableoid
                      Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct2 FOR SHARE
          ->  Hash
-               Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+               Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                ->  HashAggregate
-                     Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                     Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                      Group Key: foo.f1
                      ->  Append
                            ->  Seq Scan on public.foo
-                                 Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                                 Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                            ->  Foreign Scan on public.foo2
-                                 Output: foo2.ctid, foo2.*, foo2.tableoid, foo2.f1
+                                 Output: foo2.f1, foo2.ctid, foo2.*, foo2.tableoid
                                  Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct1
 (23 rows)
 
@@ -7147,15 +7147,15 @@ update bar set f2 = f2 + 100 where f1 in (select f1 from foo);
          ->  Seq Scan on public.bar
                Output: bar.f1, bar.f2, bar.ctid
          ->  Hash
-               Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+               Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                ->  HashAggregate
-                     Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                     Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                      Group Key: foo.f1
                      ->  Append
                            ->  Seq Scan on public.foo
-                                 Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                                 Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                            ->  Foreign Scan on public.foo2
-                                 Output: foo2.ctid, foo2.*, foo2.tableoid, foo2.f1
+                                 Output: foo2.f1, foo2.ctid, foo2.*, foo2.tableoid
                                  Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct1
    ->  Hash Join
          Output: bar2.f1, (bar2.f2 + 100), bar2.f3, bar2.ctid, foo.ctid, foo.*, foo.tableoid
@@ -7165,15 +7165,15 @@ update bar set f2 = f2 + 100 where f1 in (select f1 from foo);
                Output: bar2.f1, bar2.f2, bar2.f3, bar2.ctid
                Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct2 FOR UPDATE
          ->  Hash
-               Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+               Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                ->  HashAggregate
-                     Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                     Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                      Group Key: foo.f1
                      ->  Append
                            ->  Seq Scan on public.foo
-                                 Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                                 Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                            ->  Foreign Scan on public.foo2
-                                 Output: foo2.ctid, foo2.*, foo2.tableoid, foo2.f1
+                                 Output: foo2.f1, foo2.ctid, foo2.*, foo2.tableoid
                                  Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct1
 (39 rows)
 
diff --git a/src/backend/optimizer/path/allpaths.c b/src/backend/optimizer/path/allpaths.c
index 35dba9c7ce..e3b93cb108 100644
--- a/src/backend/optimizer/path/allpaths.c
+++ b/src/backend/optimizer/path/allpaths.c
@@ -45,7 +45,6 @@
 #include "optimizer/var.h"
 #include "parser/parse_clause.h"
 #include "parser/parsetree.h"
-#include "partitioning/partprune.h"
 #include "rewrite/rewriteManip.h"
 #include "utils/lsyscache.h"
 
@@ -383,6 +382,14 @@ set_rel_size(PlannerInfo *root, RelOptInfo *rel,
 	else if (rte->inh)
 	{
 		/*
+		 * expand_inherited_tables may have proved that the relation is empty.
+		 * For example, if it's a partitioned table with 0 partitions or all
+		 * of its partitions are pruned.  In that case nothing to do here.
+		 */
+		if (IS_DUMMY_REL(rel))
+			return;
+
+		/*
 		 * If it's a target relation, set the sizes of children instead.
 		 * Otherwise, we'll append the outputs of children, so process it as
 		 * an "append relation".
@@ -951,38 +958,18 @@ set_inherit_target_rel_sizes(PlannerInfo *root, RelOptInfo *rel,
 	int			parentRTindex = rti;
 	bool		has_live_children;
 	ListCell   *l;
-	Relids		live_children = NULL;
-	bool		did_pruning = false;
 
 	/* Guard against stack overflow due to overly deep inheritance tree. */
 	check_stack_depth();
 
 	Assert(IS_SIMPLE_REL(rel));
 
-	/*
-	 * If the partitioned relation has any baserestrictinfo quals then we
-	 * attempt to use these quals to prune away partitions that cannot
-	 * possibly contain any tuples matching these quals.  In this case we'll
-	 * store the relids of all partitions which could possibly contain a
-	 * matching tuple, and skip anything else in the loop below.
-	 */
-	if (enable_partition_pruning &&
-		rte->relkind == RELKIND_PARTITIONED_TABLE &&
-		rel->baserestrictinfo != NIL)
-	{
-		live_children = prune_append_rel_partitions(rel);
-		did_pruning = true;
-	}
-
 	foreach(l, root->append_rel_list)
 	{
 		AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(l);
 		int			childRTindex;
 		RangeTblEntry *childRTE;
 		RelOptInfo *childrel;
-		List	   *childquals;
-		Index		cq_min_security;
-		bool		have_const_false_cq;
 		PlannerInfo *subroot;
 		ListCell   *lc;
 		List	   *translated_exprs,
@@ -997,139 +984,18 @@ set_inherit_target_rel_sizes(PlannerInfo *root, RelOptInfo *rel,
 		subroot = root->inh_target_child_roots[childRTindex];
 
 		/*
-		 * The child rel's RelOptInfo was already created during
-		 * add_base_rels_to_query.
+		 * The child rel's RelOptInfo was created during
+		 * expand_inherited_tables().
 		 */
 		childrel = find_base_rel(root, childRTindex);
 		Assert(childrel->reloptkind == RELOPT_OTHER_MEMBER_REL);
 
 		/*
-		 * We have to copy the parent's quals to the child, with appropriate
-		 * substitution of variables.  However, only the baserestrictinfo
-		 * quals are needed before we can check for constraint exclusion; so
-		 * do that first and then check to see if we can disregard this child.
-		 *
-		 * The child rel's targetlist might contain non-Var expressions, which
-		 * means that substitution into the quals could produce opportunities
-		 * for const-simplification, and perhaps even pseudoconstant quals.
-		 * Therefore, transform each RestrictInfo separately to see if it
-		 * reduces to a constant or pseudoconstant.  (We must process them
-		 * separately to keep track of the security level of each qual.)
+		 * Child relation may have been marked dummy if build_append_child_rel
+		 * found self-contradictory quals.
 		 */
-		childquals = NIL;
-		cq_min_security = UINT_MAX;
-		have_const_false_cq = false;
-		foreach(lc, rel->baserestrictinfo)
-		{
-			RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
-			Node	   *childqual;
-			ListCell   *lc2;
-
-			Assert(IsA(rinfo, RestrictInfo));
-			childqual = adjust_appendrel_attrs(root,
-											   (Node *) rinfo->clause,
-											   1, &appinfo);
-			childqual = eval_const_expressions(root, childqual);
-			/* check for flat-out constant */
-			if (childqual && IsA(childqual, Const))
-			{
-				if (((Const *) childqual)->constisnull ||
-					!DatumGetBool(((Const *) childqual)->constvalue))
-				{
-					/* Restriction reduces to constant FALSE or NULL */
-					have_const_false_cq = true;
-					break;
-				}
-				/* Restriction reduces to constant TRUE, so drop it */
-				continue;
-			}
-			/* might have gotten an AND clause, if so flatten it */
-			foreach(lc2, make_ands_implicit((Expr *) childqual))
-			{
-				Node	   *onecq = (Node *) lfirst(lc2);
-				bool		pseudoconstant;
-
-				/* check for pseudoconstant (no Vars or volatile functions) */
-				pseudoconstant =
-					!contain_vars_of_level(onecq, 0) &&
-					!contain_volatile_functions(onecq);
-				if (pseudoconstant)
-				{
-					/* tell createplan.c to check for gating quals */
-					root->hasPseudoConstantQuals = true;
-				}
-				/* reconstitute RestrictInfo with appropriate properties */
-				childquals = lappend(childquals,
-									 make_restrictinfo((Expr *) onecq,
-													   rinfo->is_pushed_down,
-													   rinfo->outerjoin_delayed,
-													   pseudoconstant,
-													   rinfo->security_level,
-													   NULL, NULL, NULL));
-				/* track minimum security level among child quals */
-				cq_min_security = Min(cq_min_security, rinfo->security_level);
-			}
-		}
-
-		/*
-		 * In addition to the quals inherited from the parent, we might have
-		 * securityQuals associated with this particular child node.
-		 * (Currently this can only happen in appendrels originating from
-		 * UNION ALL; inheritance child tables don't have their own
-		 * securityQuals, see expand_inherited_rtentry().)	Pull any such
-		 * securityQuals up into the baserestrictinfo for the child.  This is
-		 * similar to process_security_barrier_quals() for the parent rel,
-		 * except that we can't make any general deductions from such quals,
-		 * since they don't hold for the whole appendrel.
-		 */
-		if (childRTE->securityQuals)
-		{
-			Index		security_level = 0;
-
-			foreach(lc, childRTE->securityQuals)
-			{
-				List	   *qualset = (List *) lfirst(lc);
-				ListCell   *lc2;
-
-				foreach(lc2, qualset)
-				{
-					Expr	   *qual = (Expr *) lfirst(lc2);
-
-					/* not likely that we'd see constants here, so no check */
-					childquals = lappend(childquals,
-										 make_restrictinfo(qual,
-														   true, false, false,
-														   security_level,
-														   NULL, NULL, NULL));
-					cq_min_security = Min(cq_min_security, security_level);
-				}
-				security_level++;
-			}
-			Assert(security_level <= root->qual_security_level);
-		}
-
-		/*
-		 * OK, we've got all the baserestrictinfo quals for this child.
-		 */
-		childrel->baserestrictinfo = childquals;
-		childrel->baserestrict_min_security = cq_min_security;
-
-		if (have_const_false_cq)
-		{
-			/*
-			 * Some restriction clause reduced to constant FALSE or NULL after
-			 * substitution, so this child need not be scanned.
-			 */
-			set_dummy_rel_pathlist(childrel);
+		if (IS_DUMMY_REL(childrel))
 			continue;
-		}
-
-		if (did_pruning && !bms_is_member(appinfo->child_relid, live_children))
-		{
-			/* This partition was pruned; skip it. */
-			set_dummy_rel_pathlist(childrel);
-			continue;
-		}
 
 		if (relation_excluded_by_constraints(root, childrel, childRTE))
 		{
@@ -1297,8 +1163,6 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 	double	   *parent_attrsizes;
 	int			nattrs;
 	ListCell   *l;
-	Relids		live_children = NULL;
-	bool		did_pruning = false;
 
 	/* Guard against stack overflow due to overly deep inheritance tree. */
 	check_stack_depth();
@@ -1306,32 +1170,6 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 	Assert(IS_SIMPLE_REL(rel));
 
 	/*
-	 * Initialize partitioned_child_rels to contain this RT index.
-	 *
-	 * Note that during the set_append_rel_pathlist() phase, we will bubble up
-	 * the indexes of partitioned relations that appear down in the tree, so
-	 * that when we've created Paths for all the children, the root
-	 * partitioned table's list will contain all such indexes.
-	 */
-	if (rte->relkind == RELKIND_PARTITIONED_TABLE)
-		rel->partitioned_child_rels = list_make1_int(rti);
-
-	/*
-	 * If the partitioned relation has any baserestrictinfo quals then we
-	 * attempt to use these quals to prune away partitions that cannot
-	 * possibly contain any tuples matching these quals.  In this case we'll
-	 * store the relids of all partitions which could possibly contain a
-	 * matching tuple, and skip anything else in the loop below.
-	 */
-	if (enable_partition_pruning &&
-		rte->relkind == RELKIND_PARTITIONED_TABLE &&
-		rel->baserestrictinfo != NIL)
-	{
-		live_children = prune_append_rel_partitions(rel);
-		did_pruning = true;
-	}
-
-	/*
 	 * If this is a partitioned baserel, set the consider_partitionwise_join
 	 * flag; currently, we only consider partitionwise joins with the baserel
 	 * if its targetlist doesn't contain a whole-row Var.
@@ -1368,12 +1206,8 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 		int			childRTindex;
 		RangeTblEntry *childRTE;
 		RelOptInfo *childrel;
-		List	   *childquals;
-		Index		cq_min_security;
-		bool		have_const_false_cq;
 		ListCell   *parentvars;
 		ListCell   *childvars;
-		ListCell   *lc;
 
 		/* append_rel_list contains all append rels; ignore others */
 		if (appinfo->parent_relid != parentRTindex)
@@ -1381,18 +1215,34 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 
 		childRTindex = appinfo->child_relid;
 		childRTE = root->simple_rte_array[childRTindex];
+		Assert(childRTE != NULL);
 
 		/*
-		 * The child rel's RelOptInfo was already created during
-		 * add_base_rels_to_query.
+		 * The child rel's RelOptInfo was created during
+		 * expand_inherited_tables().
 		 */
 		childrel = find_base_rel(root, childRTindex);
 		Assert(childrel->reloptkind == RELOPT_OTHER_MEMBER_REL);
 
 		/*
-		 * Copy/Modify targetlist. Even if this child is deemed empty, we need
-		 * its targetlist in case it falls on nullable side in a child-join
-		 * because of partitionwise join.
+		 * Child relation may have been marked dummy if build_append_child_rel
+		 * found self-contradictory quals.
+		 */
+		if (IS_DUMMY_REL(childrel))
+			continue;
+
+		if (relation_excluded_by_constraints(root, childrel, childRTE))
+		{
+			/*
+			 * This child need not be scanned, so we can omit it from the
+			 * appendrel.
+			 */
+			set_dummy_rel_pathlist(childrel);
+			continue;
+		}
+
+		/*
+		 * Copy/Modify targetlist.
 		 *
 		 * NB: the resulting childrel->reltarget->exprs may contain arbitrary
 		 * expressions, which otherwise would not occur in a rel's targetlist.
@@ -1422,144 +1272,6 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 									   false);
 		childrel->has_eclass_joins = rel->has_eclass_joins;
 
-		/*
-		 * We have to copy the parent's quals to the child, with appropriate
-		 * substitution of variables.  However, only the baserestrictinfo
-		 * quals are needed before we can check for constraint exclusion; so
-		 * do that first and then check to see if we can disregard this child.
-		 *
-		 * The child rel's targetlist might contain non-Var expressions, which
-		 * means that substitution into the quals could produce opportunities
-		 * for const-simplification, and perhaps even pseudoconstant quals.
-		 * Therefore, transform each RestrictInfo separately to see if it
-		 * reduces to a constant or pseudoconstant.  (We must process them
-		 * separately to keep track of the security level of each qual.)
-		 */
-		childquals = NIL;
-		cq_min_security = UINT_MAX;
-		have_const_false_cq = false;
-		foreach(lc, rel->baserestrictinfo)
-		{
-			RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
-			Node	   *childqual;
-			ListCell   *lc2;
-
-			Assert(IsA(rinfo, RestrictInfo));
-			childqual = adjust_appendrel_attrs(root,
-											   (Node *) rinfo->clause,
-											   1, &appinfo);
-			childqual = eval_const_expressions(root, childqual);
-			/* check for flat-out constant */
-			if (childqual && IsA(childqual, Const))
-			{
-				if (((Const *) childqual)->constisnull ||
-					!DatumGetBool(((Const *) childqual)->constvalue))
-				{
-					/* Restriction reduces to constant FALSE or NULL */
-					have_const_false_cq = true;
-					break;
-				}
-				/* Restriction reduces to constant TRUE, so drop it */
-				continue;
-			}
-			/* might have gotten an AND clause, if so flatten it */
-			foreach(lc2, make_ands_implicit((Expr *) childqual))
-			{
-				Node	   *onecq = (Node *) lfirst(lc2);
-				bool		pseudoconstant;
-
-				/* check for pseudoconstant (no Vars or volatile functions) */
-				pseudoconstant =
-					!contain_vars_of_level(onecq, 0) &&
-					!contain_volatile_functions(onecq);
-				if (pseudoconstant)
-				{
-					/* tell createplan.c to check for gating quals */
-					root->hasPseudoConstantQuals = true;
-				}
-				/* reconstitute RestrictInfo with appropriate properties */
-				childquals = lappend(childquals,
-									 make_restrictinfo((Expr *) onecq,
-													   rinfo->is_pushed_down,
-													   rinfo->outerjoin_delayed,
-													   pseudoconstant,
-													   rinfo->security_level,
-													   NULL, NULL, NULL));
-				/* track minimum security level among child quals */
-				cq_min_security = Min(cq_min_security, rinfo->security_level);
-			}
-		}
-
-		/*
-		 * In addition to the quals inherited from the parent, we might have
-		 * securityQuals associated with this particular child node.
-		 * (Currently this can only happen in appendrels originating from
-		 * UNION ALL; inheritance child tables don't have their own
-		 * securityQuals, see expand_inherited_rtentry().)	Pull any such
-		 * securityQuals up into the baserestrictinfo for the child.  This is
-		 * similar to process_security_barrier_quals() for the parent rel,
-		 * except that we can't make any general deductions from such quals,
-		 * since they don't hold for the whole appendrel.
-		 */
-		if (childRTE->securityQuals)
-		{
-			Index		security_level = 0;
-
-			foreach(lc, childRTE->securityQuals)
-			{
-				List	   *qualset = (List *) lfirst(lc);
-				ListCell   *lc2;
-
-				foreach(lc2, qualset)
-				{
-					Expr	   *qual = (Expr *) lfirst(lc2);
-
-					/* not likely that we'd see constants here, so no check */
-					childquals = lappend(childquals,
-										 make_restrictinfo(qual,
-														   true, false, false,
-														   security_level,
-														   NULL, NULL, NULL));
-					cq_min_security = Min(cq_min_security, security_level);
-				}
-				security_level++;
-			}
-			Assert(security_level <= root->qual_security_level);
-		}
-
-		/*
-		 * OK, we've got all the baserestrictinfo quals for this child.
-		 */
-		childrel->baserestrictinfo = childquals;
-		childrel->baserestrict_min_security = cq_min_security;
-
-		if (have_const_false_cq)
-		{
-			/*
-			 * Some restriction clause reduced to constant FALSE or NULL after
-			 * substitution, so this child need not be scanned.
-			 */
-			set_dummy_rel_pathlist(childrel);
-			continue;
-		}
-
-		if (did_pruning && !bms_is_member(appinfo->child_relid, live_children))
-		{
-			/* This partition was pruned; skip it. */
-			set_dummy_rel_pathlist(childrel);
-			continue;
-		}
-
-		if (relation_excluded_by_constraints(root, childrel, childRTE))
-		{
-			/*
-			 * This child need not be scanned, so we can omit it from the
-			 * appendrel.
-			 */
-			set_dummy_rel_pathlist(childrel);
-			continue;
-		}
-
 		/* CE failed, so finish copying/modifying join quals. */
 		childrel->joininfo = (List *)
 			adjust_appendrel_attrs(root,
@@ -3035,6 +2747,7 @@ inheritance_make_rel_from_joinlist(PlannerInfo *root, List *joinlist)
 			continue;
 
 		childrel = find_base_rel(root, appinfo->child_relid);
+		Assert(childrel != NULL);
 
 		/* Ignore excluded/pruned children. */
 		if (IS_DUMMY_REL(childrel))
diff --git a/src/backend/optimizer/path/joinrels.c b/src/backend/optimizer/path/joinrels.c
index db18feccfe..411cdbd84f 100644
--- a/src/backend/optimizer/path/joinrels.c
+++ b/src/backend/optimizer/path/joinrels.c
@@ -20,6 +20,7 @@
 #include "optimizer/joininfo.h"
 #include "optimizer/pathnode.h"
 #include "optimizer/paths.h"
+#include "optimizer/tlist.h"
 #include "partitioning/partbounds.h"
 #include "utils/lsyscache.h"
 #include "utils/memutils.h"
@@ -49,6 +50,9 @@ static int match_expr_to_partition_keys(Expr *expr, RelOptInfo *rel,
 static SpecialJoinInfo *build_child_join_sjinfo(PlannerInfo *root,
 						SpecialJoinInfo *parent_sjinfo,
 						Relids left_relids, Relids right_relids);
+static RelOptInfo *build_dummy_partition_rel(PlannerInfo *root,
+									RelOptInfo *parent,
+									int partidx);
 
 
 /*
@@ -1379,6 +1383,11 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
 		AppendRelInfo **appinfos;
 		int			nappinfos;
 
+		if (IS_SIMPLE_REL(rel1) && child_rel1 == NULL)
+			child_rel1 = build_dummy_partition_rel(root, rel1, cnt_parts);
+		if (IS_SIMPLE_REL(rel1) && child_rel2 == NULL)
+			child_rel2 = build_dummy_partition_rel(root, rel2, cnt_parts);
+
 		/* We should never try to join two overlapping sets of rels. */
 		Assert(!bms_overlap(child_rel1->relids, child_rel2->relids));
 		child_joinrelids = bms_union(child_rel1->relids, child_rel2->relids);
@@ -1627,3 +1636,55 @@ build_child_join_sjinfo(PlannerInfo *root, SpecialJoinInfo *parent_sjinfo,
 
 	return sjinfo;
 }
+
+/*
+ * build_dummy_partition_rel
+ *		Build a RelOptInfo and AppendRelInfo for a pruned partition
+ *
+ * This does not result in opening the relation or a range table entry being
+ * created.  Also, the RelOptInfo thus created is not stored anywhere else
+ * beside the parent's part_rels array.
+ *
+ * The only reason this exists is because partition-wise join, in some cases,
+ * needs a RelOptInfo to represent an empty relation that's on the nullable
+ * side of an outer join, so that a Path representing the outer join can be
+ * created.
+ */
+static RelOptInfo *
+build_dummy_partition_rel(PlannerInfo *root, RelOptInfo *parent, int partidx)
+{
+	RangeTblEntry *parentrte = root->simple_rte_array[parent->relid];
+	RelOptInfo *rel;
+
+	Assert(parent->part_rels[partidx] == NULL);
+
+	/* Create minimally valid-looking RelOptInfo with parent's relid. */
+	rel = makeNode(RelOptInfo);
+	rel->reloptkind = RELOPT_OTHER_MEMBER_REL;
+	rel->relid = parent->relid;
+	rel->relids = bms_copy(parent->relids);
+	if (parent->top_parent_relids)
+		rel->top_parent_relids = parent->top_parent_relids;
+	else
+		rel->top_parent_relids = bms_copy(parent->relids);
+	rel->reltarget = copy_pathtarget(parent->reltarget);
+	parent->part_rels[partidx] = rel;
+	mark_dummy_rel(rel);
+
+	/*
+	 * Now we'll need a (no-op) AppendRelInfo for parent, because we're
+	 * setting the dummy partition's relid to be same as the parent's.
+	 */
+	if (root->append_rel_array[parent->relid] == NULL)
+	{
+		AppendRelInfo *appinfo = make_append_rel_info(parent, parentrte,
+													  parent->tupdesc,
+													  parentrte->relid,
+													  parent->reltype,
+													  parent->relid);
+
+		root->append_rel_array[parent->relid] = appinfo;
+	}
+
+	return rel;
+}
diff --git a/src/backend/optimizer/plan/initsplan.c b/src/backend/optimizer/plan/initsplan.c
index a66374094f..c628f3d9e7 100644
--- a/src/backend/optimizer/plan/initsplan.c
+++ b/src/backend/optimizer/plan/initsplan.c
@@ -616,64 +616,6 @@ create_lateral_join_info(PlannerInfo *root)
 				bms_add_member(brel2->lateral_referencers, rti);
 		}
 	}
-
-	/*
-	 * Lastly, propagate lateral_relids and lateral_referencers from appendrel
-	 * parent rels to their child rels.  We intentionally give each child rel
-	 * the same minimum parameterization, even though it's quite possible that
-	 * some don't reference all the lateral rels.  This is because any append
-	 * path for the parent will have to have the same parameterization for
-	 * every child anyway, and there's no value in forcing extra
-	 * reparameterize_path() calls.  Similarly, a lateral reference to the
-	 * parent prevents use of otherwise-movable join rels for each child.
-	 */
-	for (rti = 1; rti < root->simple_rel_array_size; rti++)
-	{
-		RelOptInfo *brel = root->simple_rel_array[rti];
-		RangeTblEntry *brte = root->simple_rte_array[rti];
-
-		/*
-		 * Skip empty slots. Also skip non-simple relations i.e. dead
-		 * relations.
-		 */
-		if (brel == NULL || !IS_SIMPLE_REL(brel))
-			continue;
-
-		/*
-		 * In the case of table inheritance, the parent RTE is directly linked
-		 * to every child table via an AppendRelInfo.  In the case of table
-		 * partitioning, the inheritance hierarchy is expanded one level at a
-		 * time rather than flattened.  Therefore, an other member rel that is
-		 * a partitioned table may have children of its own, and must
-		 * therefore be marked with the appropriate lateral info so that those
-		 * children eventually get marked also.
-		 */
-		Assert(brte);
-		if (brel->reloptkind == RELOPT_OTHER_MEMBER_REL &&
-			(brte->rtekind != RTE_RELATION ||
-			 brte->relkind != RELKIND_PARTITIONED_TABLE))
-			continue;
-
-		if (brte->inh)
-		{
-			foreach(lc, root->append_rel_list)
-			{
-				AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(lc);
-				RelOptInfo *childrel;
-
-				if (appinfo->parent_relid != rti)
-					continue;
-				childrel = root->simple_rel_array[appinfo->child_relid];
-				Assert(childrel->reloptkind == RELOPT_OTHER_MEMBER_REL);
-				Assert(childrel->direct_lateral_relids == NULL);
-				childrel->direct_lateral_relids = brel->direct_lateral_relids;
-				Assert(childrel->lateral_relids == NULL);
-				childrel->lateral_relids = brel->lateral_relids;
-				Assert(childrel->lateral_referencers == NULL);
-				childrel->lateral_referencers = brel->lateral_referencers;
-			}
-		}
-	}
 }
 
 
diff --git a/src/backend/optimizer/plan/planmain.c b/src/backend/optimizer/plan/planmain.c
index 96a09bb134..2021162fdb 100644
--- a/src/backend/optimizer/plan/planmain.c
+++ b/src/backend/optimizer/plan/planmain.c
@@ -258,6 +258,16 @@ query_planner(PlannerInfo *root, List *tlist,
 	}
 
 	/*
+	 * Expand RT entries that represent inherited or partitioned tables.
+	 * This will perform partition pruning on partitioned tables in the
+	 * original range table and also recursively on any child partitioned
+	 * tables that were added by the expansion of the original parent(s).
+	 * As new entries are added to the range table, various arrays in the
+	 * PlannerInfo will be expanded accordingly.
+	 */
+	expand_inherited_tables(root);
+
+	/*
 	 * Add child subroots needed to use during planning for individual child
 	 * targets
 	 */
@@ -370,7 +380,7 @@ adjust_inherited_target_child_root(PlannerInfo *root, AppendRelInfo *appinfo)
 	 * column, filling placeholder entries for dropped columns, etc., all of
 	 * which occurs with the child's TupleDesc.
 	 */
-	tlist = preprocess_targetlist(subroot);
+	tlist = preprocess_targetlist(subroot, true);
 	subroot->processed_tlist = tlist;
 
 	/* Add any newly added Vars to the child RelOptInfo. */
diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index a0bb61af41..6ea2fca611 100644
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -23,6 +23,7 @@
 #include "access/sysattr.h"
 #include "access/xact.h"
 #include "catalog/pg_constraint.h"
+#include "catalog/pg_inherits.h"
 #include "catalog/pg_proc.h"
 #include "catalog/pg_type.h"
 #include "executor/executor.h"
@@ -701,27 +702,18 @@ subquery_planner(PlannerGlobal *glob, Query *parse,
 		}
 		if (rte->lateral)
 			root->hasLateralRTEs = true;
+
+		/*
+		 * While at it, also update the inh status.  If the relation doesn't
+		 * or can't have any children, there is no point in letting inh be set
+		 * to true.  Note that we do this before processing rowmarks, so that
+		 * the correct information for setting isParent field of PlanRowMarks.
+		 */
+		if (rte->rtekind == RTE_RELATION)
+			rte->inh = rte->inh && has_subclass(rte->relid);
 	}
 
 	/*
-	 * Preprocess RowMark information.  We need to do this after subquery
-	 * pullup (so that all non-inherited RTEs are present) and before
-	 * inheritance expansion (so that the info is available for
-	 * expand_inherited_tables to examine and modify).
-	 */
-	preprocess_rowmarks(root);
-
-	/*
-	 * Expand any rangetable entries that are inheritance sets into "append
-	 * relations".  This can add entries to the rangetable, but they must be
-	 * plain base relations not joins, so it's OK (and marginally more
-	 * efficient) to do it after checking for join RTEs.  We must do it after
-	 * pulling up subqueries, else we'd fail to handle inherited tables in
-	 * subqueries.
-	 */
-	expand_inherited_tables(root);
-
-	/*
 	 * Now that we have figured out "actual" inheritance situation of the
 	 * relations, set whether the query is an inherited UPDATE/DELETE.
 	 */
@@ -729,6 +721,12 @@ subquery_planner(PlannerGlobal *glob, Query *parse,
 					  rt_fetch(parse->resultRelation, parse->rtable)->inh);
 
 	/*
+	 * Preprocess RowMark information.  We need to do this after subquery
+	 * pullup (so that all non-inherited RTEs are present).
+	 */
+	preprocess_rowmarks(root);
+
+	/*
 	 * Set hasHavingQual to remember if HAVING clause is present.  Needed
 	 * because preprocess_expression will reduce a constant-true condition to
 	 * an empty qual list ... but "HAVING TRUE" is not a semantic no-op.
@@ -1220,8 +1218,11 @@ inheritance_planner(PlannerInfo *root)
 	 */
 	root->unexpanded_tlist = list_copy(root->parse->targetList);
 
-	/* Do the scan/join planning. */
-	tlist = preprocess_targetlist(root);
+	/*
+	 * Do the scan/join planning.  We haven't expanded inheritance yet, so
+	 * pass false.
+	 */
+	tlist = preprocess_targetlist(root, false);
 	root->processed_tlist = tlist;
 	qp_extra.tlist = tlist;
 	qp_extra.activeWindows = qp_extra.groupClause = NIL;
@@ -1230,9 +1231,11 @@ inheritance_planner(PlannerInfo *root)
 	/*
 	 * If it turned out during query planning that all the children are dummy
 	 * (pruned or excluded by constraints), no need to do the steps below.
-	 * Let grouping_planner finish up the final path.
+	 * For regular inheritance case, it's possible that we only need to modify
+	 * the parent table.  Let grouping_planner finish up the final path.
 	 */
-	if (IS_DUMMY_REL(planned_rel))
+	parent_rte = planner_rt_fetch(top_parentRTindex, root);
+	if (!parent_rte->inh || IS_DUMMY_REL(planned_rel))
 	{
 		grouping_planner(root, false, planned_rel, 0.0);
 		return;
@@ -1248,7 +1251,6 @@ inheritance_planner(PlannerInfo *root)
 	 * not appear anywhere else in the plan, so the confusion explained below
 	 * for non-partitioning inheritance cases is not possible.
 	 */
-	parent_rte = planner_rt_fetch(top_parentRTindex, root);
 	if (parent_rte->relkind == RELKIND_PARTITIONED_TABLE)
 	{
 		nominalRelation = top_parentRTindex;
@@ -1580,14 +1582,19 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 		 */
 		if (planned_rel == NULL)
 		{
-			tlist = preprocess_targetlist(root);
+			/* We haven't expanded inheritance yet, so pass false. */
+			tlist = preprocess_targetlist(root, false);
 
 			/*
-			 * We are now done hacking up the query's targetlist.  Most of the
-			 * remaining planning work will be done with the PathTarget
-			 * representation of tlists, but save aside the full representation
-			 * so that we can transfer its decoration (resnames etc) to the
-			 * topmost tlist of the finished Plan.
+			 * We are now mostly done hacking up the query's targetlist.  More
+			 * columns might be added during query_planner after inheritance
+			 * expansion in make_one_rel, because some children may require
+			 * different column than the parent for row mark handling; see
+			 * add_rowmark_junk_columns().  Most of the remaining planning
+			 * work will be done with the PathTarget representation of tlists,
+			 * but save aside the full representation so that we can transfer
+			 * its decoration (resnames etc) to the topmost tlist of the
+			 * finished Plan.
 			 */
 			root->processed_tlist = tlist;
 		}
@@ -2363,7 +2370,7 @@ preprocess_rowmarks(PlannerInfo *root)
 		newrc->allMarkTypes = (1 << newrc->markType);
 		newrc->strength = rc->strength;
 		newrc->waitPolicy = rc->waitPolicy;
-		newrc->isParent = false;
+		newrc->isParent = rte->inh;
 
 		prowmarks = lappend(prowmarks, newrc);
 	}
@@ -2388,7 +2395,7 @@ preprocess_rowmarks(PlannerInfo *root)
 		newrc->allMarkTypes = (1 << newrc->markType);
 		newrc->strength = LCS_NONE;
 		newrc->waitPolicy = LockWaitBlock;	/* doesn't matter */
-		newrc->isParent = false;
+		newrc->isParent = rte->rtekind == RTE_RELATION ? rte->inh : false;
 
 		prowmarks = lappend(prowmarks, newrc);
 	}
@@ -6825,6 +6832,10 @@ apply_scanjoin_target_to_paths(PlannerInfo *root,
 			int			nappinfos;
 			List	   *child_scanjoin_targets = NIL;
 
+			/* Skip processing pruned partitions. */
+			if (child_rel == NULL)
+				continue;
+
 			/* Translate scan/join targets for this child. */
 			appinfos = find_appinfos_by_relids(root, child_rel->relids,
 											   &nappinfos);
@@ -6926,6 +6937,10 @@ create_partitionwise_grouping_paths(PlannerInfo *root,
 		RelOptInfo *child_grouped_rel;
 		RelOptInfo *child_partially_grouped_rel;
 
+		/* Skip processing pruned partitions. */
+		if (child_input_rel == NULL)
+			continue;
+
 		/* Input child rel must have a path */
 		Assert(child_input_rel->pathlist != NIL);
 
diff --git a/src/backend/optimizer/plan/setrefs.c b/src/backend/optimizer/plan/setrefs.c
index 5d363edab8..4dcdede6b6 100644
--- a/src/backend/optimizer/plan/setrefs.c
+++ b/src/backend/optimizer/plan/setrefs.c
@@ -325,6 +325,12 @@ add_rtes_to_flat_rtable(PlannerInfo *root, bool recursing)
 													  UPPERREL_FINAL, NULL)))
 					add_rtes_to_flat_rtable(rel->subroot, true);
 			}
+			/*
+			 * A NULL rel also means an unplanned subquery rte, so apply
+			 * flatten_unplanned_rtes.
+			 */
+			else
+				flatten_unplanned_rtes(glob, rte);
 		}
 		rti++;
 	}
diff --git a/src/backend/optimizer/prep/preptlist.c b/src/backend/optimizer/prep/preptlist.c
index f8bc2dd257..a55949c305 100644
--- a/src/backend/optimizer/prep/preptlist.c
+++ b/src/backend/optimizer/prep/preptlist.c
@@ -65,9 +65,13 @@ static List *expand_targetlist(List *tlist, int command_type,
  *
  * As a side effect, if there's an ON CONFLICT UPDATE clause, its targetlist
  * is also preprocessed (and updated in-place).
+ *
+ * inheritance_expanded specifies whether inheritance tables are expanded
+ * as of calling this function.  Caller must specify it because that affects
+ * which row marking related junk columns get added to the targetlist.
  */
 List *
-preprocess_targetlist(PlannerInfo *root)
+preprocess_targetlist(PlannerInfo *root, bool inheritance_expanded)
 {
 	Query	   *parse = root->parse;
 	int			result_relation = parse->resultRelation;
@@ -134,6 +138,15 @@ preprocess_targetlist(PlannerInfo *root)
 		if (rc->rti != rc->prti)
 			continue;
 
+		/*
+		 * For inheritance parent row marks, we defer adding junk columns
+		 * until we've added child row marks, because some children might
+		 * require different row mark types which will change the parent row
+		 * mark's allMarkTypes fields.
+		 */
+		if (rc->isParent && !inheritance_expanded)
+			continue;
+
 		if (rc->allMarkTypes & ~(1 << ROW_MARK_COPY))
 		{
 			/* Need to fetch TID */
diff --git a/src/backend/optimizer/prep/prepunion.c b/src/backend/optimizer/prep/prepunion.c
index 05388355fd..0fb01e2145 100644
--- a/src/backend/optimizer/prep/prepunion.c
+++ b/src/backend/optimizer/prep/prepunion.c
@@ -32,13 +32,16 @@
 #include "miscadmin.h"
 #include "nodes/makefuncs.h"
 #include "nodes/nodeFuncs.h"
+#include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
 #include "optimizer/paths.h"
 #include "optimizer/planmain.h"
 #include "optimizer/planner.h"
 #include "optimizer/prep.h"
+#include "optimizer/restrictinfo.h"
 #include "optimizer/tlist.h"
+#include "optimizer/var.h"
 #include "parser/parse_coerce.h"
 #include "parser/parsetree.h"
 #include "utils/lsyscache.h"
diff --git a/src/backend/optimizer/util/appendinfo.c b/src/backend/optimizer/util/appendinfo.c
index 0b9ca39a51..1500ea22b9 100644
--- a/src/backend/optimizer/util/appendinfo.c
+++ b/src/backend/optimizer/util/appendinfo.c
@@ -31,10 +31,10 @@ typedef struct
 	AppendRelInfo **appinfos;
 } adjust_appendrel_attrs_context;
 
-static void make_inh_translation_list(Relation oldrelation,
-						  Relation newrelation,
-						  Index newvarno,
-						  List **translated_vars);
+static void make_inh_translation_list(TupleDesc old_tupdesc,
+						  TupleDesc new_tupdesc,
+						  Oid from_rel, Oid to_rel,
+						  Index newvarno, List **translated_vars);
 static Node *adjust_appendrel_attrs_mutator(Node *node,
 							   adjust_appendrel_attrs_context *context);
 static List *adjust_inherited_tlist(List *tlist,
@@ -46,18 +46,20 @@ static List *adjust_inherited_tlist(List *tlist,
  *	  Build an AppendRelInfo for the parent-child pair
  */
 AppendRelInfo *
-make_append_rel_info(Relation parentrel, Relation childrel,
-					 Index parentRTindex, Index childRTindex)
+make_append_rel_info(RelOptInfo *parent, RangeTblEntry *parentrte,
+					 TupleDesc childdesc, Oid childoid, Oid childtype,
+					 Index childRTindex)
 {
 	AppendRelInfo *appinfo = makeNode(AppendRelInfo);
 
-	appinfo->parent_relid = parentRTindex;
+	appinfo->parent_relid = parent->relid;
 	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->translated_vars);
-	appinfo->parent_reloid = RelationGetRelid(parentrel);
+	appinfo->parent_reltype = parent->reltype;
+	appinfo->child_reltype = childtype;
+	make_inh_translation_list(parent->tupdesc, childdesc,
+							  parentrte->relid, childoid,
+							  childRTindex, &appinfo->translated_vars);
+	appinfo->parent_reloid = parentrte->relid;
 
 	return appinfo;
 }
@@ -70,14 +72,11 @@ make_append_rel_info(Relation parentrel, Relation childrel,
  * For paranoia's sake, we match type/collation as well as attribute name.
  */
 static void
-make_inh_translation_list(Relation oldrelation, Relation newrelation,
-						  Index newvarno,
-						  List **translated_vars)
+make_inh_translation_list(TupleDesc old_tupdesc, TupleDesc new_tupdesc,
+						  Oid from_rel, Oid to_rel,
+						  Index newvarno, List **translated_vars)
 {
 	List	   *vars = NIL;
-	TupleDesc	old_tupdesc = RelationGetDescr(oldrelation);
-	TupleDesc	new_tupdesc = RelationGetDescr(newrelation);
-	Oid			new_relid = RelationGetRelid(newrelation);
 	int			oldnatts = old_tupdesc->natts;
 	int			newnatts = new_tupdesc->natts;
 	int			old_attno;
@@ -107,7 +106,7 @@ make_inh_translation_list(Relation oldrelation, Relation newrelation,
 		 * When we are generating the "translation list" for the parent table
 		 * of an inheritance set, no need to search for matches.
 		 */
-		if (oldrelation == newrelation)
+		if (from_rel == to_rel)
 		{
 			vars = lappend(vars, makeVar(newvarno,
 										 (AttrNumber) (old_attno + 1),
@@ -133,10 +132,10 @@ make_inh_translation_list(Relation oldrelation, Relation newrelation,
 		{
 			HeapTuple	newtup;
 
-			newtup = SearchSysCacheAttName(new_relid, attname);
+			newtup = SearchSysCacheAttName(to_rel, attname);
 			if (!newtup)
 				elog(ERROR, "could not find inherited attribute \"%s\" of relation \"%s\"",
-					 attname, RelationGetRelationName(newrelation));
+					 attname, get_rel_name(to_rel));
 			new_attno = ((Form_pg_attribute) GETSTRUCT(newtup))->attnum - 1;
 			ReleaseSysCache(newtup);
 
@@ -146,10 +145,10 @@ make_inh_translation_list(Relation oldrelation, Relation newrelation,
 		/* Found it, check type and collation match */
 		if (atttypid != att->atttypid || atttypmod != att->atttypmod)
 			elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's type",
-				 attname, RelationGetRelationName(newrelation));
+				 attname, get_rel_name(to_rel));
 		if (attcollation != att->attcollation)
 			elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's collation",
-				 attname, RelationGetRelationName(newrelation));
+				 attname, get_rel_name(to_rel));
 
 		vars = lappend(vars, makeVar(newvarno,
 									 (AttrNumber) (new_attno + 1),
diff --git a/src/backend/optimizer/util/inherit.c b/src/backend/optimizer/util/inherit.c
index db474acbc5..bbf90c4c6c 100644
--- a/src/backend/optimizer/util/inherit.c
+++ b/src/backend/optimizer/util/inherit.c
@@ -18,30 +18,40 @@
 #include "access/sysattr.h"
 #include "catalog/partition.h"
 #include "catalog/pg_inherits.h"
+#include "catalog/pg_type.h"
 #include "miscadmin.h"
+#include "nodes/makefuncs.h"
 #include "optimizer/appendinfo.h"
+#include "optimizer/clauses.h"
 #include "optimizer/inherit.h"
+#include "optimizer/pathnode.h"
+#include "optimizer/paths.h"
+#include "optimizer/planmain.h"
 #include "optimizer/planner.h"
 #include "optimizer/prep.h"
+#include "optimizer/restrictinfo.h"
+#include "optimizer/var.h"
+#include "partitioning/partprune.h"
 #include "utils/rel.h"
 
-
+static void expand_append_rtentry(PlannerInfo *root, RelOptInfo *rel,
+					  RangeTblEntry *rte, Index rti);
 static void expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte,
-						 Index rti);
+						 Index rti, RelOptInfo *rel);
 static void expand_partitioned_rtentry(PlannerInfo *root,
 						   RangeTblEntry *parentrte,
-						   Index parentRTindex, Relation parentrel,
-						   PlanRowMark *top_parentrc, LOCKMODE lockmode,
-						   List **appinfos);
-static void expand_single_inheritance_child(PlannerInfo *root,
-								RangeTblEntry *parentrte,
-								Index parentRTindex, Relation parentrel,
-								PlanRowMark *top_parentrc, Relation childrel,
-								List **appinfos, RangeTblEntry **childrte_p,
-								Index *childRTindex_p);
+						   Index parentRTindex, RelOptInfo *parentrel);
+static RelOptInfo *add_inheritance_child_rel(PlannerInfo *root,
+						  RangeTblEntry *parentrte,
+						  Index parentRTindex, RelOptInfo *parentrel,
+						  PlanRowMark *top_parentrc, Relation childrel,
+						  RangeTblEntry **childrte_p, Index *childRTindex_p);
 static Bitmapset *translate_col_privs(const Bitmapset *parent_privs,
 					List *translated_vars);
-
+static RelOptInfo *build_append_child_rel(PlannerInfo *root,
+					   RelOptInfo *parent,
+					   Index childRTindex);
+static List *add_rowmark_junk_columns(PlannerInfo *root, PlanRowMark *rc);
 
 /*
  * expand_inherited_tables
@@ -53,33 +63,134 @@ static Bitmapset *translate_col_privs(const Bitmapset *parent_privs,
 void
 expand_inherited_tables(PlannerInfo *root)
 {
-	Index		nrtes;
+	int			orig_rtable_size;
 	Index		rti;
-	ListCell   *rl;
+
+	Assert(root->simple_rel_array_size > 0);
+	orig_rtable_size = root->simple_rel_array_size;
 
 	/*
-	 * expand_inherited_rtentry may add RTEs to parse->rtable. The function is
+	 * expand_append_rtentry may add RTEs to parse->rtable. The function is
 	 * expected to recursively handle any RTEs that it creates with inh=true.
 	 * So just scan as far as the original end of the rtable list.
 	 */
-	nrtes = list_length(root->parse->rtable);
-	rl = list_head(root->parse->rtable);
-	for (rti = 1; rti <= nrtes; rti++)
+	for (rti = 1; rti < orig_rtable_size; rti++)
 	{
-		RangeTblEntry *rte = (RangeTblEntry *) lfirst(rl);
+		RelOptInfo *brel = root->simple_rel_array[rti];
+		RangeTblEntry *rte = root->simple_rte_array[rti];
 
-		expand_inherited_rtentry(root, rte, rti);
-		rl = lnext(rl);
+		/* there may be empty slots corresponding to non-baserel RTEs */
+		if (brel == NULL)
+			continue;
+
+		if (rte->inh)
+			expand_append_rtentry(root, brel, rte, rti);
+	}
+}
+
+/*
+ * expand_append_rtentry
+ *		This initializes RelOptInfos for an appendrel's child relations, if
+ *		any
+ *
+ * 'rel' is the appendrel parent, whose range table entry ('rte') has been
+ * marked to require adding children.  An appendrel parent could either
+ * be a subquery (if we flattened UNION ALL query) or a table that's known
+ * to have inheritance children.  The latter consists of both regular
+ * inheritance parents and partitioned tables.
+ *
+ * For a subquery parent, there is not much to be done here because the
+ * children's RTEs are already present in the query, so we just initialize
+ * RelOptInfos for them.  Also, the AppendRelInfos for child subqueries
+ * have already been added.
+ *
+ * For tables, we need to add the children to the range table and initialize
+ * AppendRelInfos, RelOptInfos, and PlanRowMarks (if any) for them.  For
+ * a partitioned parent, we only add the children remaining after pruning.
+ * For regular inheritance parents, we find the children using
+ * find_all_inheritors and add all of them.
+ *
+ * If it turns out that there are no children, then we set rte->inh to false
+ * to let the caller know that only the parent table needs to be scanned.  The
+ * caller can accordingly switch to a non-Append path.  For a partitioned
+ * parent, that means an empty relation because parents themselves contain no
+ * data.
+ *
+ * For the regular inheritance case, the parent also gets another RTE with
+ * inh = false to represent it as an appendrel child.  The original RTE is
+ * considered to represent the whole inheritance set.
+ */
+static void
+expand_append_rtentry(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte,
+					  Index rti)
+{
+	Assert(rte->inh);
+	/* Inheritance parent (partitioned or not) or UNION ALL parent subquery. */
+	Assert(rte->rtekind == RTE_RELATION || rte->rtekind == RTE_SUBQUERY);
+
+	/*
+	 * UNION ALL children already got RTEs and AppendRelInfos, so just build
+	 * RelOptInfos and return.
+	 *
+	 * It might be a bit odd that this code is in this, because there is
+	 * nothing to expand really.
+	 */
+	if (rte->rtekind == RTE_SUBQUERY)
+	{
+		ListCell   *l;
+
+		/*
+		 * We don't need to use expand_planner_arrays in this case, because
+		 * no new child RTEs are created.  setup_simple_rel_arrays() and
+		 * setup_append_rel_array would've considered these child RTEs when
+		 * allocating space for various arrays.
+		 */
+		foreach(l, root->append_rel_list)
+		{
+			AppendRelInfo *appinfo = lfirst(l);
+			Index		childRTindex = appinfo->child_relid;
+
+			if (appinfo->parent_relid != rti)
+				continue;
+
+			Assert(childRTindex < root->simple_rel_array_size);
+			Assert(root->simple_rte_array[childRTindex] != NULL);
+
+			/*
+			 * We set the correct value of baserestricinfo and
+			 * baserestrict_min_security below.
+			 */
+			root->simple_rel_array[childRTindex] =
+				build_append_child_rel(root, rel, appinfo->child_relid);
+		}
+	}
+	else
+	{
+		Assert(rte->rtekind == RTE_RELATION);
+		Assert(has_subclass(rte->relid));
+
+		/*
+		 * The rewriter should already have obtained an appropriate lock on
+		 * each relation named in the query.  However, for each child relation
+		 * we add to the query, we must obtain an appropriate lock, because
+		 * this will be the first use of those relations in the
+		 * parse/rewrite/plan pipeline.  Child rels should use the same
+		 * lockmode as their parent.
+		 */
+		Assert(rte->rellockmode != NoLock);
+
+		if (rte->relkind == RELKIND_PARTITIONED_TABLE)
+			expand_partitioned_rtentry(root, rte, rti, rel);
+		else
+			expand_inherited_rtentry(root, rte, rti, rel);
 	}
 }
 
 /*
  * expand_inherited_rtentry
- *		Check whether a rangetable entry represents an inheritance set.
- *		If so, add entries for all the child tables to the query's
- *		rangetable, and build AppendRelInfo nodes for all the child tables
- *		and add them to root->append_rel_list.  If not, clear the entry's
- *		"inh" flag to prevent later code from looking for AppendRelInfos.
+ *		Add entries for all the child tables to the query's rangetable, and
+ *		build AppendRelInfo nodes for all the child tables and add them to
+ *		root->append_rel_list.
  *
  * Note that the original RTE is considered to represent the whole
  * inheritance set.  The first of the generated RTEs is an RTE for the same
@@ -90,55 +201,33 @@ expand_inherited_tables(PlannerInfo *root)
  * regular inheritance, a parent RTE must always have at least two associated
  * AppendRelInfos: one corresponding to the parent table as a simple member of
  * inheritance set and one or more corresponding to the actual children.
- * Since a partitioned table is not scanned, it might have only one associated
- * AppendRelInfo.
  */
 static void
-expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti)
+expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti,
+						 RelOptInfo *rel)
 {
 	Oid			parentOID;
 	PlanRowMark *oldrc;
-	Relation	oldrelation;
-	LOCKMODE	lockmode;
+	LOCKMODE	lockmode = rte->rellockmode;
 	List	   *inhOIDs;
 	ListCell   *l;
+	int			num_children;
+	int			num_children_added = 0;
 
-	/* Does RT entry allow inheritance? */
-	if (!rte->inh)
-		return;
-	/* Ignore any already-expanded UNION ALL nodes */
-	if (rte->rtekind != RTE_RELATION)
-	{
-		Assert(rte->rtekind == RTE_SUBQUERY);
-		return;
-	}
-	/* Fast path for common case of childless table */
+	Assert(rte->rtekind == RTE_RELATION);
+	Assert(lockmode != NoLock);
 	parentOID = rte->relid;
-	if (!has_subclass(parentOID))
-	{
-		/* Clear flag before returning */
-		rte->inh = false;
-		return;
-	}
-
-	/*
-	 * The rewriter should already have obtained an appropriate lock on each
-	 * relation named in the query.  However, for each child relation we add
-	 * to the query, we must obtain an appropriate lock, because this will be
-	 * the first use of those relations in the parse/rewrite/plan pipeline.
-	 * Child rels should use the same lockmode as their parent.
-	 */
-	lockmode = rte->rellockmode;
 
 	/* Scan for all members of inheritance set, acquire needed locks */
 	inhOIDs = find_all_inheritors(parentOID, lockmode, NULL);
 
 	/*
 	 * Check that there's at least one descendant, else treat as no-child
-	 * case.  This could happen despite above has_subclass() check, if table
-	 * once had a child but no longer does.
+	 * case.  This could happen despite has_subclass() check performed by
+	 * subquery_planner, if table once had a child but no longer does.
 	 */
-	if (list_length(inhOIDs) < 2)
+	num_children = list_length(inhOIDs);
+	if (num_children < 2)
 	{
 		/* Clear flag before returning */
 		rte->inh = false;
@@ -146,216 +235,219 @@ expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti)
 	}
 
 	/*
-	 * If parent relation is selected FOR UPDATE/SHARE, we need to mark its
-	 * PlanRowMark as isParent = true, and generate a new PlanRowMark for each
-	 * child.
+	 * If parent relation is selected FOR UPDATE/SHARE, preprocess_rowmarks
+	 * should've set isParent = true.  We'll generate a new PlanRowMark for
+	 * each child.
 	 */
 	oldrc = get_plan_rowmark(root->rowMarks, rti);
-	if (oldrc)
-		oldrc->isParent = true;
+	Assert(oldrc == NULL || oldrc->isParent);
 
 	/*
-	 * Must open the parent relation to examine its tupdesc.  We need not lock
-	 * it; we assume the rewriter already did.
+	 * Must expand PlannerInfo arrays by num_children before we can add
+	 * children.
 	 */
-	oldrelation = heap_open(parentOID, NoLock);
+	expand_planner_arrays(root, num_children);
 
-	/* Scan the inheritance set and expand it */
-	if (RelationGetPartitionDesc(oldrelation) != NULL)
+	foreach(l, inhOIDs)
 	{
-		Assert(rte->relkind == RELKIND_PARTITIONED_TABLE);
-
-		/*
-		 * If this table has partitions, recursively expand them in the order
-		 * in which they appear in the PartitionDesc.  While at it, also
-		 * extract the partition key columns of all the partitioned tables.
-		 */
-		expand_partitioned_rtentry(root, rte, rti, oldrelation, oldrc,
-								   lockmode, &root->append_rel_list);
-	}
-	else
-	{
-		List	   *appinfos = NIL;
+		Oid			childOID = lfirst_oid(l);
+		Relation	newrelation;
 		RangeTblEntry *childrte;
 		Index		childRTindex;
 
+		/* Already locked above. */
+		newrelation = heap_open(childOID, NoLock);
+
 		/*
-		 * This table has no partitions.  Expand any plain inheritance
-		 * children in the order the OIDs were returned by
-		 * find_all_inheritors.
+		 * It is possible that the parent table has children that are temp
+		 * tables of other backends.  We cannot safely access such tables
+		 * (because of buffering issues), and the best thing to do seems
+		 * to be to silently ignore them.
 		 */
-		foreach(l, inhOIDs)
+		if (childOID != parentOID && RELATION_IS_OTHER_TEMP(newrelation))
 		{
-			Oid			childOID = lfirst_oid(l);
-			Relation	newrelation;
-
-			/* Open rel if needed; we already have required locks */
-			if (childOID != parentOID)
-				newrelation = heap_open(childOID, NoLock);
-			else
-				newrelation = oldrelation;
-
-			/*
-			 * It is possible that the parent table has children that are temp
-			 * tables of other backends.  We cannot safely access such tables
-			 * (because of buffering issues), and the best thing to do seems
-			 * to be to silently ignore them.
-			 */
-			if (childOID != parentOID && RELATION_IS_OTHER_TEMP(newrelation))
-			{
-				heap_close(newrelation, lockmode);
-				continue;
-			}
-
-			expand_single_inheritance_child(root, rte, rti, oldrelation, oldrc,
-											newrelation,
-											&appinfos, &childrte,
-											&childRTindex);
-
-			/* Close child relations, but keep locks */
-			if (childOID != parentOID)
-				heap_close(newrelation, NoLock);
+			heap_close(newrelation, lockmode);
+			continue;
 		}
 
-		/*
-		 * If all the children were temp tables, pretend it's a
-		 * non-inheritance situation; we don't need Append node in that case.
-		 * The duplicate RTE we added for the parent table is harmless, so we
-		 * don't bother to get rid of it; ditto for the useless PlanRowMark
-		 * node.
-		 */
-		if (list_length(appinfos) < 2)
-			rte->inh = false;
-		else
-			root->append_rel_list = list_concat(root->append_rel_list,
-												appinfos);
+		(void) add_inheritance_child_rel(root, rte, rti, rel, oldrc,
+										 newrelation, &childrte,
+										 &childRTindex);
+		Assert(childrte != NULL);
+		/* All regular inheritance children are leaf children. */
+		Assert(!childrte->inh);
+		Assert(childRTindex > 0);
 
+		/* Close child relations, but keep locks */
+		heap_close(newrelation, NoLock);
+		num_children_added++;
 	}
 
-	heap_close(oldrelation, NoLock);
+	/*
+	 * If all children, including the parent (as child rel), were
+	 * excluded, mark the parent rel as empty.  If all the children were temp
+	 * tables, pretend it's a non-inheritance situation; we don't need Append
+	 * node in that case.  The duplicate RTE we added for the parent table is
+	 * harmless, so we don't bother to get rid of it; ditto for the useless
+	 * PlanRowMark node.
+	 */
+	if (num_children_added == 0)
+		mark_dummy_rel(rel);
+	else if (num_children_added == 1)
+		rte->inh = false;
+
+	/*
+	 * Add junk columns needed by the row mark if any and also add the
+	 * relevant expressions to the root parent's reltarget.
+	 */
+	if (oldrc)
+	{
+		List   *tlist = add_rowmark_junk_columns(root, oldrc);
+
+		build_base_rel_tlists(root, tlist);
+	}
 }
 
 /*
  * expand_partitioned_rtentry
- *		Recursively expand an RTE for a partitioned table.
+ *		Prunes unnecessary partitions of a partitioned table and adds
+ *		remaining ones to the Query and the PlannerInfo
+ *
+ * Partitions are added to the query in order in which they are found in
+ * the parent's PartitionDesc.
+ *
+ * Note: even though only the unpruned partitions will be added to the
+ * resulting plan, this still locks *all* partitions via find_all_inheritors
+ * when this function is called for the root partitioned table.
  */
 static void
 expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
-						   Index parentRTindex, Relation parentrel,
-						   PlanRowMark *top_parentrc, LOCKMODE lockmode,
-						   List **appinfos)
+						   Index parentRTindex, RelOptInfo *parentrel)
 {
+	LOCKMODE	lockmode = parentrte->rellockmode;
+	PlanRowMark *rootrc = NULL;
 	int			i;
-	RangeTblEntry *childrte;
-	Index		childRTindex;
-	PartitionDesc partdesc = RelationGetPartitionDesc(parentrel);
+	Bitmapset  *partindexes;
+	Index		rootParentRTindex = parentrel->inh_root_parent > 0 ?
+									parentrel->inh_root_parent :
+									parentRTindex;
 
-	check_stack_depth();
-
-	/* A partitioned table should always have a partition descriptor. */
-	Assert(partdesc);
-
-	Assert(parentrte->inh);
+	/* If root partitioned table, lock *all* partitions in the tree. */
+	if (parentRTindex == rootParentRTindex)
+		(void) find_all_inheritors(parentrte->relid, lockmode, NULL);
 
 	/*
-	 * Note down whether any partition key cols are being updated. Though it's
-	 * the root partitioned table's updatedCols we are interested in, we
-	 * instead use parentrte to get the updatedCols. This is convenient
-	 * because parentrte already has the root partrel's updatedCols translated
-	 * to match the attribute ordering of parentrel.
+	 * Initialize partitioned_child_rels to contain this RT index.
+	 *
+	 * Note that during the set_append_rel_pathlist() phase, values of the
+	 * indexes of partitioned relations that appear down in the tree will be
+	 * bubbled up into root parent's list so that when we've created Paths for
+	 * all the children, the root table's list will contain all such indexes.
 	 */
-	if (!root->partColsUpdated)
-		root->partColsUpdated =
-			has_partition_attrs(parentrel, parentrte->updatedCols, NULL);
+	parentrel->partitioned_child_rels = list_make1_int(parentRTindex);
 
-	/* First expand the partitioned table itself. */
-	expand_single_inheritance_child(root, parentrte, parentRTindex, parentrel,
-									top_parentrc, parentrel,
-									appinfos, &childrte, &childRTindex);
+	/* Perform pruning. */
+	partindexes = prune_append_rel_partitions(parentrel);
+
+	/* Must expand PlannerInfo arrays before we can add children. */
+	expand_planner_arrays(root, bms_num_members(partindexes));
 
 	/*
-	 * If the partitioned table has no partitions, treat this as the
-	 * non-inheritance case.
+	 * For partitioned tables, we also store the partition RelOptInfo
+	 * pointers in the parent's RelOptInfo.
 	 */
-	if (partdesc->nparts == 0)
-	{
-		parentrte->inh = false;
-		return;
-	}
+	parentrel->part_rels = (RelOptInfo **) palloc0(sizeof(RelOptInfo *) *
+												   parentrel->nparts);
 
-	for (i = 0; i < partdesc->nparts; i++)
+	rootrc = get_plan_rowmark(root->rowMarks, rootParentRTindex);
+	Assert(rootrc == NULL || rootrc->isParent);
+	i = -1;
+	while ((i = bms_next_member(partindexes, i)) >= 0)
 	{
-		Oid			childOID = partdesc->oids[i];
-		Relation	childrel;
+		Oid		childOID = parentrel->part_oids[i];
+		Relation	newrelation;
+		RelOptInfo *childrel;
+		RangeTblEntry *childrte;
+		Index		childRTindex;
 
-		/* Open rel; we already have required locks */
-		childrel = heap_open(childOID, NoLock);
+		/* Already locked above. */
+		newrelation = heap_open(childOID, NoLock);
+		Assert(!RELATION_IS_OTHER_TEMP(newrelation));
 
 		/*
-		 * Temporary partitions belonging to other sessions should have been
-		 * disallowed at definition, but for paranoia's sake, let's double
-		 * check.
+		 * A partitioned child table with 0 children is a dummy rel, so don't
+		 * bother creating planner objects for it.
 		 */
-		if (RELATION_IS_OTHER_TEMP(childrel))
-			elog(ERROR, "temporary relation from another session found as partition");
+		if (newrelation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE &&
+			RelationGetPartitionDesc(newrelation)->nparts == 0)
+		{
+			heap_close(newrelation, NoLock);
+			continue;
+		}
 
-		expand_single_inheritance_child(root, parentrte, parentRTindex,
-										parentrel, top_parentrc, childrel,
-										appinfos, &childrte, &childRTindex);
+		childrel = add_inheritance_child_rel(root, parentrte, parentRTindex,
+											 parentrel, rootrc, newrelation,
+											 &childrte, &childRTindex);
+		Assert(childrel != NULL);
+		parentrel->part_rels[i] = childrel;
 
-		/* If this child is itself partitioned, recurse */
-		if (childrel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
+		/* Close child relations, but keep locks */
+		heap_close(newrelation, NoLock);
+
+		/* If the child is partitioned itself, expand it too. */
+		if (childrel->part_scheme)
+		{
+			Assert(childrte->inh);
 			expand_partitioned_rtentry(root, childrte, childRTindex,
-									   childrel, top_parentrc, lockmode,
-									   appinfos);
+									   childrel);
+		}
+	}
 
-		/* Close child relation, but keep locks */
-		heap_close(childrel, NoLock);
+	/*
+	 * Add junk columns needed by the row mark if any and also add the
+	 * relevant expressions to the root parent's reltarget.
+	 */
+	if (rootrc)
+	{
+		List   *tlist = add_rowmark_junk_columns(root, rootrc);
+
+		build_base_rel_tlists(root, tlist);
 	}
 }
 
 /*
- * expand_single_inheritance_child
- *		Build a RangeTblEntry and an AppendRelInfo, if appropriate, plus
- *		maybe a PlanRowMark.
+ * add_inheritance_child_rel
+ *		Build a RangeTblEntry, an AppendRelInfo, a PlanRowMark, and finally
+ *		a RelOptInfo for an inheritance child relation.
  *
- * We now expand the partition hierarchy level by level, creating a
- * corresponding hierarchy of AppendRelInfos and RelOptInfos, where each
- * partitioned descendant acts as a parent of its immediate partitions.
- * (This is a difference from what older versions of PostgreSQL did and what
- * is still done in the case of table inheritance for unpartitioned tables,
- * where the hierarchy is flattened during RTE expansion.)
+ * The return value is the RelOptInfo that's added.
  *
  * PlanRowMarks still carry the top-parent's RTI, and the top-parent's
  * allMarkTypes field still accumulates values from all descendents.
  *
  * "parentrte" and "parentRTindex" are immediate parent's RTE and
  * RTI. "top_parentrc" is top parent's PlanRowMark.
- *
- * The child RangeTblEntry and its RTI are returned in "childrte_p" and
- * "childRTindex_p" resp.
  */
-static void
-expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte,
-								Index parentRTindex, Relation parentrel,
-								PlanRowMark *top_parentrc, Relation childrel,
-								List **appinfos, RangeTblEntry **childrte_p,
-								Index *childRTindex_p)
+static RelOptInfo *
+add_inheritance_child_rel(PlannerInfo *root, RangeTblEntry *parentrte,
+						  Index parentRTindex, RelOptInfo *parentrel,
+						  PlanRowMark *top_parentrc, Relation childrel,
+						  RangeTblEntry **childrte_p, Index *childRTindex_p)
 {
 	Query	   *parse = root->parse;
-	Oid			parentOID = RelationGetRelid(parentrel);
 	Oid			childOID = RelationGetRelid(childrel);
 	RangeTblEntry *childrte;
 	Index		childRTindex;
 	AppendRelInfo *appinfo;
+	RelOptInfo *childrelopt;
 
 	/*
 	 * Build an RTE for the child, and attach to query's rangetable list. We
 	 * copy most fields of the parent's RTE, but replace relation OID and
-	 * relkind, and set inh = false.  Also, set requiredPerms to zero since
-	 * all required permissions checks are done on the original RTE. Likewise,
-	 * set the child's securityQuals to empty, because we only want to apply
-	 * the parent's RLS conditions regardless of what RLS properties
+	 * relkind, and set inh appropriately.  Also, set requiredPerms to zero
+	 * since all required permissions checks are done on the original RTE.
+	 * Likewise, set the child's securityQuals to empty, because we only want
+	 * to apply the parent's RLS conditions regardless of what RLS properties
 	 * individual children may have.  (This is an intentional choice to make
 	 * inherited RLS work like regular permissions checks.) The parent
 	 * securityQuals will be propagated to children along with other base
@@ -365,49 +457,42 @@ expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte,
 	*childrte_p = childrte;
 	childrte->relid = childOID;
 	childrte->relkind = childrel->rd_rel->relkind;
-	/* A partitioned child will need to be expanded further. */
-	if (childOID != parentOID &&
-		childrte->relkind == RELKIND_PARTITIONED_TABLE)
-		childrte->inh = true;
-	else
-		childrte->inh = false;
+	/*
+	 * A partitioned child will need to be expanded as an append parent
+	 * itself, so set its inh to true.
+	 */
+	childrte->inh = (childrte->relkind == RELKIND_PARTITIONED_TABLE);
 	childrte->requiredPerms = 0;
 	childrte->securityQuals = NIL;
 	parse->rtable = lappend(parse->rtable, childrte);
 	childRTindex = list_length(parse->rtable);
 	*childRTindex_p = childRTindex;
 
-	/*
-	 * We need an AppendRelInfo if paths will be built for the child RTE. If
-	 * childrte->inh is true, then we'll always need to generate append paths
-	 * for it.  If childrte->inh is false, we must scan it if it's not a
-	 * partitioned table; but if it is a partitioned table, then it never has
-	 * any data of its own and need not be scanned.
-	 */
-	if (childrte->relkind != RELKIND_PARTITIONED_TABLE || childrte->inh)
-	{
-		appinfo = make_append_rel_info(parentrel, childrel,
-									   parentRTindex, childRTindex);
-		*appinfos = lappend(*appinfos, appinfo);
+	/* Create an AppendRelInfo and add it to planner's global list. */
+	appinfo = make_append_rel_info(parentrel, parentrte,
+								   RelationGetDescr(childrel),
+								   RelationGetRelid(childrel),
+								   RelationGetForm(childrel)->reltype,
+								   childRTindex);
+	root->append_rel_list = lappend(root->append_rel_list, appinfo);
 
-		/*
-		 * Translate the column permissions bitmaps to the child's attnums (we
-		 * have to build the translated_vars list before we can do this). But
-		 * if this is the parent table, leave copyObject's result alone.
-		 *
-		 * Note: we need to do this even though the executor won't run any
-		 * permissions checks on the child RTE.  The insertedCols/updatedCols
-		 * bitmaps may be examined for trigger-firing purposes.
-		 */
-		if (childOID != parentOID)
-		{
-			childrte->selectedCols = translate_col_privs(parentrte->selectedCols,
-														 appinfo->translated_vars);
-			childrte->insertedCols = translate_col_privs(parentrte->insertedCols,
-														 appinfo->translated_vars);
-			childrte->updatedCols = translate_col_privs(parentrte->updatedCols,
-														appinfo->translated_vars);
-		}
+	/*
+	 * Translate the column permissions bitmaps to the child's attnums (we
+	 * have to build the translated_vars list before we can do this). But
+	 * if this is the parent table, leave copyObject's result alone.
+	 *
+	 * Note: we need to do this even though the executor won't run any
+	 * permissions checks on the child RTE.  The insertedCols/updatedCols
+	 * bitmaps may be examined for trigger-firing purposes.
+	 */
+	if (childrte->relid != parentrte->relid)
+	{
+		childrte->selectedCols = translate_col_privs(parentrte->selectedCols,
+													 appinfo->translated_vars);
+		childrte->insertedCols = translate_col_privs(parentrte->insertedCols,
+													 appinfo->translated_vars);
+		childrte->updatedCols = translate_col_privs(parentrte->updatedCols,
+													appinfo->translated_vars);
 	}
 
 	/*
@@ -439,6 +524,253 @@ expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte,
 
 		root->rowMarks = lappend(root->rowMarks, childrc);
 	}
+
+	/*
+	 * Add the RelOptInfo.  Even though we may not really scan this relation
+	 * for reasons such as contradictory quals, we still need to create one,
+	 * because for every RTE in the query's range table, there must be an
+	 * accompanying RelOptInfo.
+	 */
+
+	/* First, store the RTE and appinfos into planner arrays. */
+	Assert(root->simple_rte_array[childRTindex] == NULL);
+	root->simple_rte_array[childRTindex] = childrte;
+	Assert(root->append_rel_array[childRTindex] == NULL);
+	root->append_rel_array[childRTindex] = appinfo;
+
+	childrelopt = build_append_child_rel(root, parentrel, childRTindex);
+	Assert(childrelopt != NULL);
+
+	return childrelopt;
+}
+
+/*
+ *	build_append_child_rel
+ *		Build a RelOptInfo for child relation of an append rel
+ *
+ * After creating the RelOptInfo for the given child RT index, it goes on to
+ * initialize some of its fields based on the parent RelOptInfo.
+ *
+ * If the quals in baserestrictinfo turn out to be self-contradictory,
+ * RelOptInfo is marked dummy before returning.
+ */
+static RelOptInfo *
+build_append_child_rel(PlannerInfo *root,
+					   RelOptInfo *parent,
+					   Index childRTindex)
+{
+	RelOptInfo *childrel;
+	RangeTblEntry *childRTE = root->simple_rte_array[childRTindex];
+	AppendRelInfo *appinfo = root->append_rel_array[childRTindex];
+	List	   *childquals;
+	ListCell   *lc;
+	bool		have_const_false_cq;
+	Index		cq_min_security;
+
+	/* Build the RelOptInfo. */
+	childrel = build_simple_rel(root, childRTindex, parent);
+
+	/*
+	 * Propagate lateral_relids and lateral_referencers from appendrel
+	 * parent rels to their child rels.  We intentionally give each child rel
+	 * the same minimum parameterization, even though it's quite possible that
+	 * some don't reference all the lateral rels.  This is because any append
+	 * path for the parent will have to have the same parameterization for
+	 * every child anyway, and there's no value in forcing extra
+	 * reparameterize_path() calls.  Similarly, a lateral reference to the
+	 * parent prevents use of otherwise-movable join rels for each child.
+	 */
+	childrel->direct_lateral_relids = parent->direct_lateral_relids;
+	childrel->lateral_relids = parent->lateral_relids;
+	childrel->lateral_referencers = parent->lateral_referencers;
+
+	/*
+	 * We have to copy the parent's quals to the child, with appropriate
+	 * substitution of variables.  However, only the baserestrictinfo
+	 * quals are needed before we can check for constraint exclusion; so
+	 * do that first and then check to see if we can disregard this child.
+	 *
+	 * The child rel's targetlist might contain non-Var expressions, which
+	 * means that substitution into the quals could produce opportunities
+	 * for const-simplification, and perhaps even pseudoconstant quals.
+	 * Therefore, transform each RestrictInfo separately to see if it
+	 * reduces to a constant or pseudoconstant.  (We must process them
+	 * separately to keep track of the security level of each qual.)
+	 */
+	childquals = false;
+	cq_min_security = UINT_MAX;
+	have_const_false_cq = false;
+	foreach(lc, parent->baserestrictinfo)
+	{
+		RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
+		Node	   *childqual = (Node *) rinfo->clause;
+		ListCell   *lc2;
+
+		Assert(IsA(rinfo, RestrictInfo));
+		childqual = adjust_appendrel_attrs(root, childqual,
+										   1, &appinfo);
+		childqual = eval_const_expressions(root, childqual);
+		/* check for flat-out constant */
+		if (childqual && IsA(childqual, Const))
+		{
+			if (((Const *) childqual)->constisnull ||
+				!DatumGetBool(((Const *) childqual)->constvalue))
+			{
+				/* Restriction reduces to constant FALSE or NULL */
+				have_const_false_cq = true;
+				break;
+			}
+			/* Restriction reduces to constant TRUE, so drop it */
+			continue;
+		}
+		/* might have gotten an AND clause, if so flatten it */
+		foreach(lc2, make_ands_implicit((Expr *) childqual))
+		{
+			Node	   *onecq = (Node *) lfirst(lc2);
+			bool		pseudoconstant;
+
+			/* check for pseudoconstant (no Vars or volatile functions) */
+			pseudoconstant =
+					!contain_vars_of_level(onecq, 0) &&
+					!contain_volatile_functions(onecq);
+			if (pseudoconstant)
+			{
+				/* tell createplan.c to check for gating quals */
+				root->hasPseudoConstantQuals = true;
+			}
+			/* reconstitute RestrictInfo with appropriate properties */
+			childquals = lappend(childquals,
+								 make_restrictinfo((Expr *) onecq,
+												   rinfo->is_pushed_down,
+												   rinfo->outerjoin_delayed,
+												   pseudoconstant,
+												   rinfo->security_level,
+												   NULL, NULL, NULL));
+			cq_min_security = Min(cq_min_security, rinfo->security_level);
+		}
+	}
+
+	/*
+	 * In addition to the quals inherited from the parent, we might
+	 * have securityQuals associated with this particular child node.
+	 * (Currently this can only happen in appendrels originating from
+	 * UNION ALL; inheritance child tables don't have their own
+	 * securityQuals.)	Pull any such securityQuals up into the
+	 * baserestrictinfo for the child.  This is similar to
+	 * process_security_barrier_quals() for the parent rel, except
+	 * that we can't make any general deductions from such quals,
+	 * since they don't hold for the whole appendrel.
+	 */
+	if (childRTE->securityQuals)
+	{
+		Index		security_level = 0;
+
+		foreach(lc, childRTE->securityQuals)
+		{
+			List	   *qualset = (List *) lfirst(lc);
+			ListCell   *lc2;
+
+			foreach(lc2, qualset)
+			{
+				Expr	   *qual = (Expr *) lfirst(lc2);
+
+				/*
+				 * not likely that we'd see constants here, so no
+				 * check
+				 */
+				childquals = lappend(childquals,
+									 make_restrictinfo(qual,
+													   true,
+													   false,
+													   false,
+													   security_level,
+													   NULL, NULL,
+													   NULL));
+				cq_min_security = Min(cq_min_security, security_level);
+			}
+			security_level++;
+		}
+		Assert(security_level <= root->qual_security_level);
+	}
+
+	/* Set child's version of baserestrictinfo. */
+	childrel->baserestrictinfo = childquals;
+	childrel->baserestrict_min_security = cq_min_security;
+
+	if (have_const_false_cq)
+	{
+		/*
+		 * Some restriction clause reduced to constant FALSE or NULL after
+		 * substitution, so this child need not be scanned.
+		 */
+		set_dummy_rel_pathlist(childrel);
+	}
+
+	return childrel;
+}
+
+/*
+ * add_rowmark_junk_columns
+ * 		Add necessary junk columns for rowmarked inheritance parent rel.
+ *
+ * These values are needed for locking of rels selected FOR UPDATE/SHARE, and
+ * to do EvalPlanQual rechecking.  See comments for PlanRowMark in
+ * plannodes.h.
+ */
+static List *
+add_rowmark_junk_columns(PlannerInfo *root, PlanRowMark *rc)
+{
+	List   *tlist = root->processed_tlist;
+	Var		   *var;
+	char		resname[32];
+	TargetEntry *tle;
+
+	if (rc->allMarkTypes & ~(1 << ROW_MARK_COPY))
+	{
+		/* Need to fetch TID */
+		var = makeVar(rc->rti,
+					  SelfItemPointerAttributeNumber,
+					  TIDOID,
+					  -1,
+					  InvalidOid,
+					  0);
+		snprintf(resname, sizeof(resname), "ctid%u", rc->rowmarkId);
+		tle = makeTargetEntry((Expr *) var,
+							  list_length(tlist) + 1,
+							  pstrdup(resname),
+							  true);
+		tlist = lappend(tlist, tle);
+	}
+	if (rc->allMarkTypes & (1 << ROW_MARK_COPY))
+	{
+		/* Need the whole row as a junk var */
+		var = makeWholeRowVar(root->simple_rte_array[rc->rti],
+							  rc->rti,
+							  0,
+							  false);
+		snprintf(resname, sizeof(resname), "wholerow%u", rc->rowmarkId);
+		tle = makeTargetEntry((Expr *) var,
+							  list_length(tlist) + 1,
+							  pstrdup(resname),
+							  true);
+		tlist = lappend(tlist, tle);
+	}
+
+	/* For inheritance cases, always fetch the tableoid too. */
+	var = makeVar(rc->rti,
+				  TableOidAttributeNumber,
+				  OIDOID,
+				  -1,
+				  InvalidOid,
+				  0);
+	snprintf(resname, sizeof(resname), "tableoid%u", rc->rowmarkId);
+	tle = makeTargetEntry((Expr *) var,
+						  list_length(tlist) + 1,
+						  pstrdup(resname),
+						  true);
+	tlist = lappend(tlist, tle);
+
+	return tlist;
 }
 
 /*
diff --git a/src/backend/optimizer/util/plancat.c b/src/backend/optimizer/util/plancat.c
index 6009de309e..293f9ac619 100644
--- a/src/backend/optimizer/util/plancat.c
+++ b/src/backend/optimizer/util/plancat.c
@@ -105,20 +105,20 @@ static void set_baserel_partition_key_exprs(Relation relation,
  * important for it.
  */
 void
-get_relation_info(PlannerInfo *root, Oid relationObjectId, bool inhparent,
-				  RelOptInfo *rel)
+get_relation_info(PlannerInfo *root, RangeTblEntry *rte, RelOptInfo *rel)
 {
 	Index		varno = rel->relid;
 	Relation	relation;
 	bool		hasindex;
 	List	   *indexinfos = NIL;
+	bool		inhparent = rte->inh;
 
 	/*
 	 * We need not lock the relation since it was already locked, either by
 	 * the rewriter or when expand_inherited_rtentry() added it to the query's
 	 * rangetable.
 	 */
-	relation = heap_open(relationObjectId, NoLock);
+	relation = heap_open(rte->relid, NoLock);
 
 	/* Temporary and unlogged relations are inaccessible during recovery. */
 	if (!RelationNeedsWAL(relation) && RecoveryInProgress())
@@ -444,11 +444,32 @@ get_relation_info(PlannerInfo *root, Oid relationObjectId, bool inhparent,
 	get_relation_foreign_keys(root, rel, relation, inhparent);
 
 	/*
-	 * Collect info about relation's partitioning scheme, if any. Only
-	 * inheritance parents may be partitioned.
+	 * Collect some additional information for inheritance parents.
 	 */
-	if (inhparent && relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
-		set_relation_partition_info(root, rel, relation);
+	if (inhparent)
+	{
+		/*
+		 * We'll need the TupleDesc when initializing the child relation.
+		 * A copy is being made because concurrent changes might drop
+		 * the relcache entry.  That's possible because ALTER TABLE
+		 * child_table NO INHERIT parent_table only requires an
+		 * AccessShareLock on parent_table.
+		 */
+		rel->tupdesc = CreateTupleDescCopy(RelationGetDescr(relation));
+		rel->reltype = RelationGetForm(relation)->reltype;
+
+		/*
+		 * If partitioned, also save the information of partitioning scheme,
+		 * and whether the query updates any of the partition key columns.
+		 */
+		if (relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
+		{
+			set_relation_partition_info(root, rel, relation);
+			root->partColsUpdated |= has_partition_attrs(relation,
+														 rte->updatedCols,
+														 NULL);
+		}
+	}
 
 	heap_close(relation, NoLock);
 
@@ -458,7 +479,7 @@ get_relation_info(PlannerInfo *root, Oid relationObjectId, bool inhparent,
 	 * removing an index, or adding a hypothetical index to the indexlist.
 	 */
 	if (get_relation_info_hook)
-		(*get_relation_info_hook) (root, relationObjectId, inhparent, rel);
+		(*get_relation_info_hook) (root, rte->relid, rte->inh, rel);
 }
 
 /*
@@ -1844,16 +1865,20 @@ set_relation_partition_info(PlannerInfo *root, RelOptInfo *rel,
 							Relation relation)
 {
 	PartitionDesc partdesc;
-	PartitionKey partkey;
 
 	Assert(relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE);
 
 	partdesc = RelationGetPartitionDesc(relation);
-	partkey = RelationGetPartitionKey(relation);
 	rel->part_scheme = find_partition_scheme(root, relation);
 	Assert(partdesc != NULL && rel->part_scheme != NULL);
-	rel->boundinfo = partition_bounds_copy(partdesc->boundinfo, partkey);
 	rel->nparts = partdesc->nparts;
+
+	/*
+	 * Since we must've taken a lock on the table, it's okay to simply copy
+	 * the pointers to relcache data here.
+	 */
+	rel->part_oids = partdesc->oids;
+	rel->boundinfo = partdesc->boundinfo;
 	set_baserel_partition_key_exprs(relation, rel);
 	rel->partition_qual = RelationGetPartitionQual(relation);
 }
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index 45f9950935..905fdc1419 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -131,6 +131,42 @@ setup_append_rel_array(PlannerInfo *root)
 	}
 }
 
+/* Expand the PlannerInfo arrays by add_size members and zero-init it. */
+void
+expand_planner_arrays(PlannerInfo *root, int add_size)
+{
+	int		new_size = root->simple_rel_array_size + add_size;
+
+	/* Expand various arrays and 0-initialize added bytes. */
+	root->simple_rte_array = (RangeTblEntry **)
+							repalloc(root->simple_rte_array,
+									 sizeof(RangeTblEntry *) * new_size);
+	MemSet(root->simple_rte_array + root->simple_rel_array_size,
+		   0, sizeof(RangeTblEntry *) * add_size);
+	root->simple_rel_array = (RelOptInfo **)
+								repalloc(root->simple_rel_array,
+										 sizeof(RelOptInfo *) * new_size);
+	MemSet(root->simple_rel_array + root->simple_rel_array_size,
+		   0, sizeof(RelOptInfo *) * add_size);
+
+	if (root->append_rel_array)
+	{
+		root->append_rel_array = (AppendRelInfo **)
+									repalloc(root->append_rel_array,
+									 sizeof(AppendRelInfo *) * new_size);
+		MemSet(root->append_rel_array + root->simple_rel_array_size,
+			   0, sizeof(AppendRelInfo *) * add_size);
+	}
+	else
+	{
+		root->append_rel_array = (AppendRelInfo **)
+									palloc0(sizeof(AppendRelInfo *) *
+											new_size);
+	}
+
+	root->simple_rel_array_size = new_size;
+}
+
 /*
  * build_simple_rel
  *	  Construct a new RelOptInfo for a base relation or 'other' relation.
@@ -236,7 +272,7 @@ build_simple_rel(PlannerInfo *root, int relid, RelOptInfo *parent)
 	{
 		case RTE_RELATION:
 			/* Table --- retrieve statistics from the system catalogs */
-			get_relation_info(root, rte->relid, rte->inh, rel);
+			get_relation_info(root, rte, rel);
 			break;
 		case RTE_SUBQUERY:
 		case RTE_FUNCTION:
@@ -277,52 +313,6 @@ build_simple_rel(PlannerInfo *root, int relid, RelOptInfo *parent)
 		root->qual_security_level = Max(root->qual_security_level,
 										list_length(rte->securityQuals));
 
-	/*
-	 * If this rel is an appendrel parent, recurse to build "other rel"
-	 * RelOptInfos for its children.  They are "other rels" because they are
-	 * not in the main join tree, but we will need RelOptInfos to plan access
-	 * to them.
-	 */
-	if (rte->inh)
-	{
-		ListCell   *l;
-		int			nparts = rel->nparts;
-		int			cnt_parts = 0;
-
-		if (nparts > 0)
-			rel->part_rels = (RelOptInfo **)
-				palloc(sizeof(RelOptInfo *) * nparts);
-
-		foreach(l, root->append_rel_list)
-		{
-			AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(l);
-			RelOptInfo *childrel;
-
-			/* append_rel_list contains all append rels; ignore others */
-			if (appinfo->parent_relid != relid)
-				continue;
-
-			childrel = build_simple_rel(root, appinfo->child_relid,
-										rel);
-
-			/* Nothing more to do for an unpartitioned table. */
-			if (!rel->part_scheme)
-				continue;
-
-			/*
-			 * The order of partition OIDs in append_rel_list is the same as
-			 * the order in the PartitionDesc, so the order of part_rels will
-			 * also match the PartitionDesc.  See expand_partitioned_rtentry.
-			 */
-			Assert(cnt_parts < nparts);
-			rel->part_rels[cnt_parts] = childrel;
-			cnt_parts++;
-		}
-
-		/* We should have seen all the child partitions. */
-		Assert(cnt_parts == nparts);
-	}
-
 	return rel;
 }
 
diff --git a/src/backend/partitioning/partprune.c b/src/backend/partitioning/partprune.c
index 901433c68c..9bb472fd98 100644
--- a/src/backend/partitioning/partprune.c
+++ b/src/backend/partitioning/partprune.c
@@ -46,6 +46,7 @@
 #include "nodes/nodeFuncs.h"
 #include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
+#include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
 #include "optimizer/planner.h"
 #include "optimizer/predtest.h"
@@ -437,17 +438,23 @@ make_partitionedrel_pruneinfo(PlannerInfo *root, RelOptInfo *parentrel,
 		 * is, not pruned already).
 		 */
 		subplan_map = (int *) palloc(nparts * sizeof(int));
+		memset(subplan_map, -1, nparts * sizeof(int));
 		subpart_map = (int *) palloc(nparts * sizeof(int));
+		memset(subpart_map, -1, nparts * sizeof(int));
 		present_parts = NULL;
 
 		for (i = 0; i < nparts; i++)
 		{
 			RelOptInfo *partrel = subpart->part_rels[i];
-			int			subplanidx = relid_subplan_map[partrel->relid] - 1;
-			int			subpartidx = relid_subpart_map[partrel->relid] - 1;
+			int			subplanidx;
+			int			subpartidx;
 
-			subplan_map[i] = subplanidx;
-			subpart_map[i] = subpartidx;
+			/* Skip processing pruned partitions. */
+			if (partrel == NULL)
+				continue;
+
+			subplan_map[i] = subplanidx = relid_subplan_map[partrel->relid] - 1;
+			subpart_map[i] = subpartidx = relid_subpart_map[partrel->relid] - 1;
 			if (subplanidx >= 0)
 			{
 				present_parts = bms_add_member(present_parts, i);
@@ -541,23 +548,20 @@ gen_partprune_steps(RelOptInfo *rel, List *clauses, bool *contradictory)
 
 /*
  * prune_append_rel_partitions
- *		Returns RT indexes of the minimum set of child partitions which must
- *		be scanned to satisfy rel's baserestrictinfo quals.
+ *		Returns indexes into rel->part_rels of the minimum set of child
+ *		partitions which must be scanned to satisfy rel's baserestrictinfo
+ *		quals.
  *
  * Callers must ensure that 'rel' is a partitioned table.
  */
-Relids
+Bitmapset *
 prune_append_rel_partitions(RelOptInfo *rel)
 {
-	Relids		result;
 	List	   *clauses = rel->baserestrictinfo;
 	List	   *pruning_steps;
 	bool		contradictory;
 	PartitionPruneContext context;
-	Bitmapset  *partindexes;
-	int			i;
 
-	Assert(clauses != NIL);
 	Assert(rel->part_scheme != NULL);
 
 	/* If there are no partitions, return the empty set */
@@ -565,6 +569,13 @@ prune_append_rel_partitions(RelOptInfo *rel)
 		return NULL;
 
 	/*
+	 * If pruning is disabled or if there are no clauses to prune with,
+	 * return all partitions.
+	 */
+	if (!enable_partition_pruning || clauses == NIL)
+		return bms_add_range(NULL, 0, rel->nparts - 1);
+
+	/*
 	 * Process clauses.  If the clauses are found to be contradictory, we can
 	 * return the empty set.
 	 */
@@ -591,15 +602,7 @@ prune_append_rel_partitions(RelOptInfo *rel)
 	context.evalexecparams = false;
 
 	/* Actual pruning happens here. */
-	partindexes = get_matching_partitions(&context, pruning_steps);
-
-	/* Add selected partitions' RT indexes to result. */
-	i = -1;
-	result = NULL;
-	while ((i = bms_next_member(partindexes, i)) >= 0)
-		result = bms_add_member(result, rel->part_rels[i]->relid);
-
-	return result;
+	return get_matching_partitions(&context, pruning_steps);
 }
 
 /*
diff --git a/src/include/nodes/relation.h b/src/include/nodes/relation.h
index db439bd904..01a664d246 100644
--- a/src/include/nodes/relation.h
+++ b/src/include/nodes/relation.h
@@ -15,6 +15,7 @@
 #define RELATION_H
 
 #include "access/sdir.h"
+#include "access/tupdesc.h"
 #include "fmgr.h"
 #include "lib/stringinfo.h"
 #include "nodes/params.h"
@@ -729,6 +730,7 @@ typedef struct RelOptInfo
 	int			nparts;			/* number of partitions */
 	struct PartitionBoundInfoData *boundinfo;	/* Partition bounds */
 	List	   *partition_qual; /* partition constraint */
+	Oid		   *part_oids;		/* partition OIDs */
 	struct RelOptInfo **part_rels;	/* Array of RelOptInfos of partitions,
 									 * stored in the same order of bounds */
 	List	  **partexprs;		/* Non-nullable partition key expressions. */
@@ -743,6 +745,13 @@ typedef struct RelOptInfo
 	 * RT index of UNION ALL parent subquery.
 	 */
 	Index		inh_root_parent;
+
+	/*
+	 * Set only if this is an inheritance parent relation.  This information
+	 * is needed when initializing the planning info for children.
+	 */
+	TupleDesc	tupdesc;		/* A "copy" of the table's tuple desriptor */
+	Oid			reltype;		/* Table's reltype */
 } RelOptInfo;
 
 /*
diff --git a/src/include/optimizer/appendinfo.h b/src/include/optimizer/appendinfo.h
index 156a0e077d..689d39517a 100644
--- a/src/include/optimizer/appendinfo.h
+++ b/src/include/optimizer/appendinfo.h
@@ -17,9 +17,10 @@
 #include "nodes/relation.h"
 #include "utils/relcache.h"
 
-extern AppendRelInfo *make_append_rel_info(Relation parentrel,
-					 Relation childrel,
-					 Index parentRTindex, Index childRTindex);
+extern AppendRelInfo *make_append_rel_info(RelOptInfo *parent,
+					 RangeTblEntry *parentrte,
+					 TupleDesc childdesc, Oid childoid, Oid childtype,
+					 Index childRTindex);
 extern Node *adjust_appendrel_attrs(PlannerInfo *root, Node *node,
 					   int nappinfos, AppendRelInfo **appinfos);
 extern Node *adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node,
diff --git a/src/include/optimizer/pathnode.h b/src/include/optimizer/pathnode.h
index bd905d3328..e7d0a20c54 100644
--- a/src/include/optimizer/pathnode.h
+++ b/src/include/optimizer/pathnode.h
@@ -261,6 +261,7 @@ extern Path *reparameterize_path_by_child(PlannerInfo *root, Path *path,
  */
 extern void setup_simple_rel_arrays(PlannerInfo *root);
 extern void setup_append_rel_array(PlannerInfo *root);
+extern void expand_planner_arrays(PlannerInfo *root, int add_size);
 extern RelOptInfo *build_simple_rel(PlannerInfo *root, int relid,
 				 RelOptInfo *parent);
 extern RelOptInfo *find_base_rel(PlannerInfo *root, int relid);
diff --git a/src/include/optimizer/plancat.h b/src/include/optimizer/plancat.h
index a1b23251a1..d8091cdfa4 100644
--- a/src/include/optimizer/plancat.h
+++ b/src/include/optimizer/plancat.h
@@ -25,8 +25,8 @@ typedef void (*get_relation_info_hook_type) (PlannerInfo *root,
 extern PGDLLIMPORT get_relation_info_hook_type get_relation_info_hook;
 
 
-extern void get_relation_info(PlannerInfo *root, Oid relationObjectId,
-				  bool inhparent, RelOptInfo *rel);
+extern void get_relation_info(PlannerInfo *root, RangeTblEntry *rte,
+				  RelOptInfo *rel);
 
 extern List *infer_arbiter_indexes(PlannerInfo *root);
 
diff --git a/src/include/optimizer/prep.h b/src/include/optimizer/prep.h
index 62d45dd142..a329e87fc2 100644
--- a/src/include/optimizer/prep.h
+++ b/src/include/optimizer/prep.h
@@ -38,7 +38,8 @@ extern Expr *canonicalize_qual(Expr *qual, bool is_check);
 /*
  * prototypes for preptlist.c
  */
-extern List *preprocess_targetlist(PlannerInfo *root);
+extern List *preprocess_targetlist(PlannerInfo *root,
+							bool inheritance_expanded);
 
 extern PlanRowMark *get_plan_rowmark(List *rowmarks, Index rtindex);
 
diff --git a/src/include/partitioning/partprune.h b/src/include/partitioning/partprune.h
index ce9bc8d9fd..5c5d27d040 100644
--- a/src/include/partitioning/partprune.h
+++ b/src/include/partitioning/partprune.h
@@ -76,7 +76,7 @@ extern PartitionPruneInfo *make_partition_pruneinfo(PlannerInfo *root,
 						 List *subpaths,
 						 List *partitioned_rels,
 						 List *prunequal);
-extern Relids prune_append_rel_partitions(RelOptInfo *rel);
+extern Bitmapset *prune_append_rel_partitions(RelOptInfo *rel);
 extern Bitmapset *get_matching_partitions(PartitionPruneContext *context,
 						List *pruning_steps);
 
diff --git a/src/test/regress/expected/partition_aggregate.out b/src/test/regress/expected/partition_aggregate.out
index 6bc106831e..1450cef057 100644
--- a/src/test/regress/expected/partition_aggregate.out
+++ b/src/test/regress/expected/partition_aggregate.out
@@ -144,7 +144,7 @@ SELECT c, sum(a) FROM pagg_tab WHERE 1 = 2 GROUP BY c;
            QUERY PLAN           
 --------------------------------
  HashAggregate
-   Group Key: pagg_tab.c
+   Group Key: c
    ->  Result
          One-Time Filter: false
 (4 rows)
@@ -159,7 +159,7 @@ SELECT c, sum(a) FROM pagg_tab WHERE c = 'x' GROUP BY c;
            QUERY PLAN           
 --------------------------------
  GroupAggregate
-   Group Key: pagg_tab.c
+   Group Key: c
    ->  Result
          One-Time Filter: false
 (4 rows)
-- 
2.11.0

From 717cdd515f4a135370460b2288fe2e0c29608b06 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Mon, 15 Oct 2018 10:59:24 +0900
Subject: [PATCH v13 5/6] Teach planner to only process unpruned partitions

This adds a bitmapset field live_parts to RelOptInfo and stores
the partition indexes of non-dummy partitions in it, meaning it
contains indexes of only those partitions that have a non-NULL
RelOptInfo present in its parent's RelOptInfo's part_rels array.

This speeds up processing partitioned table's partitions compared
to going through the whole part_rels array in a number of places.
---
 src/backend/optimizer/path/joinrels.c |  3 +++
 src/backend/optimizer/plan/planner.c  | 18 +++++++++---------
 src/backend/optimizer/util/inherit.c  |  1 +
 src/backend/optimizer/util/relnode.c  |  3 +++
 src/backend/partitioning/partprune.c  | 18 +++++-------------
 src/include/nodes/relation.h          |  4 ++++
 6 files changed, 25 insertions(+), 22 deletions(-)

diff --git a/src/backend/optimizer/path/joinrels.c b/src/backend/optimizer/path/joinrels.c
index 411cdbd84f..eb0e918d05 100644
--- a/src/backend/optimizer/path/joinrels.c
+++ b/src/backend/optimizer/path/joinrels.c
@@ -1426,6 +1426,9 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
 		populate_joinrel_with_paths(root, child_rel1, child_rel2,
 									child_joinrel, child_sjinfo,
 									child_restrictlist);
+		if (!IS_DUMMY_REL(child_joinrel))
+			joinrel->live_parts = bms_add_member(joinrel->live_parts,
+												 cnt_parts);
 	}
 }
 
diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index 6ea2fca611..6591d46c8f 100644
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -6824,7 +6824,9 @@ apply_scanjoin_target_to_paths(PlannerInfo *root,
 		List	   *live_children = NIL;
 
 		/* Adjust each partition. */
-		for (partition_idx = 0; partition_idx < rel->nparts; partition_idx++)
+		partition_idx = -1;
+		while ((partition_idx = bms_next_member(rel->live_parts,
+												partition_idx)) >= 0)
 		{
 			RelOptInfo *child_rel = rel->part_rels[partition_idx];
 			ListCell   *lc;
@@ -6832,9 +6834,7 @@ apply_scanjoin_target_to_paths(PlannerInfo *root,
 			int			nappinfos;
 			List	   *child_scanjoin_targets = NIL;
 
-			/* Skip processing pruned partitions. */
-			if (child_rel == NULL)
-				continue;
+			Assert(child_rel != NULL);
 
 			/* Translate scan/join targets for this child. */
 			appinfos = find_appinfos_by_relids(root, child_rel->relids,
@@ -6915,7 +6915,6 @@ create_partitionwise_grouping_paths(PlannerInfo *root,
 									PartitionwiseAggregateType patype,
 									GroupPathExtraData *extra)
 {
-	int			nparts = input_rel->nparts;
 	int			cnt_parts;
 	List	   *grouped_live_children = NIL;
 	List	   *partially_grouped_live_children = NIL;
@@ -6927,7 +6926,9 @@ create_partitionwise_grouping_paths(PlannerInfo *root,
 		   partially_grouped_rel != NULL);
 
 	/* Add paths for partitionwise aggregation/grouping. */
-	for (cnt_parts = 0; cnt_parts < nparts; cnt_parts++)
+	cnt_parts = -1;
+	while ((cnt_parts = bms_next_member(input_rel->live_parts,
+										cnt_parts)) >= 0)
 	{
 		RelOptInfo *child_input_rel = input_rel->part_rels[cnt_parts];
 		PathTarget *child_target = copy_pathtarget(target);
@@ -6937,9 +6938,8 @@ create_partitionwise_grouping_paths(PlannerInfo *root,
 		RelOptInfo *child_grouped_rel;
 		RelOptInfo *child_partially_grouped_rel;
 
-		/* Skip processing pruned partitions. */
-		if (child_input_rel == NULL)
-			continue;
+		/* A live partition must have a RelOptInfo. */
+		Assert(child_input_rel != NULL);
 
 		/* Input child rel must have a path */
 		Assert(child_input_rel->pathlist != NIL);
diff --git a/src/backend/optimizer/util/inherit.c b/src/backend/optimizer/util/inherit.c
index bbf90c4c6c..ac2217a742 100644
--- a/src/backend/optimizer/util/inherit.c
+++ b/src/backend/optimizer/util/inherit.c
@@ -348,6 +348,7 @@ expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
 
 	/* Perform pruning. */
 	partindexes = prune_append_rel_partitions(parentrel);
+	parentrel->live_parts = partindexes;
 
 	/* Must expand PlannerInfo arrays before we can add children. */
 	expand_planner_arrays(root, bms_num_members(partindexes));
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index 905fdc1419..fa52aaa6de 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -1749,6 +1749,9 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
 		joinrel->partexprs[cnt] = partexpr;
 		joinrel->nullable_partexprs[cnt] = nullable_partexpr;
 	}
+
+	/* Partitions will be added by try_partitionwise_join. */
+	joinrel->live_parts = NULL;
 }
 
 /*
diff --git a/src/backend/partitioning/partprune.c b/src/backend/partitioning/partprune.c
index 9bb472fd98..088b191bdd 100644
--- a/src/backend/partitioning/partprune.c
+++ b/src/backend/partitioning/partprune.c
@@ -441,29 +441,21 @@ make_partitionedrel_pruneinfo(PlannerInfo *root, RelOptInfo *parentrel,
 		memset(subplan_map, -1, nparts * sizeof(int));
 		subpart_map = (int *) palloc(nparts * sizeof(int));
 		memset(subpart_map, -1, nparts * sizeof(int));
-		present_parts = NULL;
+		present_parts = bms_copy(subpart->live_parts);
 
-		for (i = 0; i < nparts; i++)
+		i = -1;
+		while ((i = bms_next_member(present_parts, i)) >= 0)
 		{
 			RelOptInfo *partrel = subpart->part_rels[i];
 			int			subplanidx;
 			int			subpartidx;
 
-			/* Skip processing pruned partitions. */
-			if (partrel == NULL)
-				continue;
-
+			Assert(partrel != NULL);
 			subplan_map[i] = subplanidx = relid_subplan_map[partrel->relid] - 1;
 			subpart_map[i] = subpartidx = relid_subpart_map[partrel->relid] - 1;
+			/* Record finding this subplan */
 			if (subplanidx >= 0)
-			{
-				present_parts = bms_add_member(present_parts, i);
-
-				/* Record finding this subplan  */
 				subplansfound = bms_add_member(subplansfound, subplanidx);
-			}
-			else if (subpartidx >= 0)
-				present_parts = bms_add_member(present_parts, i);
 		}
 
 		pinfo = makeNode(PartitionedRelPruneInfo);
diff --git a/src/include/nodes/relation.h b/src/include/nodes/relation.h
index 01a664d246..d27611c2c7 100644
--- a/src/include/nodes/relation.h
+++ b/src/include/nodes/relation.h
@@ -733,6 +733,10 @@ typedef struct RelOptInfo
 	Oid		   *part_oids;		/* partition OIDs */
 	struct RelOptInfo **part_rels;	/* Array of RelOptInfos of partitions,
 									 * stored in the same order of bounds */
+	Bitmapset  *live_parts;		/* Indexes into part_rels of the non-NULL
+								 * RelOptInfos of unpruned partitions; exists
+								 * to avoid having to iterate over the entire
+								 * part_rels array to filter NULL entries. */
 	List	  **partexprs;		/* Non-nullable partition key expressions. */
 	List	  **nullable_partexprs; /* Nullable partition key expressions. */
 	List	   *partitioned_child_rels; /* List of RT indexes. */
-- 
2.11.0

From 3ad1e4668b168beae60a5999019457958ee52916 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Fri, 12 Oct 2018 19:12:53 +0900
Subject: [PATCH v13 6/6] Do not lock all partitions at the beginning

---
 src/backend/optimizer/util/inherit.c | 11 +----------
 1 file changed, 1 insertion(+), 10 deletions(-)

diff --git a/src/backend/optimizer/util/inherit.c b/src/backend/optimizer/util/inherit.c
index ac2217a742..9d64abdce7 100644
--- a/src/backend/optimizer/util/inherit.c
+++ b/src/backend/optimizer/util/inherit.c
@@ -315,10 +315,6 @@ expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti,
  *
  * Partitions are added to the query in order in which they are found in
  * the parent's PartitionDesc.
- *
- * Note: even though only the unpruned partitions will be added to the
- * resulting plan, this still locks *all* partitions via find_all_inheritors
- * when this function is called for the root partitioned table.
  */
 static void
 expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
@@ -332,10 +328,6 @@ expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
 									parentrel->inh_root_parent :
 									parentRTindex;
 
-	/* If root partitioned table, lock *all* partitions in the tree. */
-	if (parentRTindex == rootParentRTindex)
-		(void) find_all_inheritors(parentrte->relid, lockmode, NULL);
-
 	/*
 	 * Initialize partitioned_child_rels to contain this RT index.
 	 *
@@ -371,8 +363,7 @@ expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
 		RangeTblEntry *childrte;
 		Index		childRTindex;
 
-		/* Already locked above. */
-		newrelation = heap_open(childOID, NoLock);
+		newrelation = heap_open(childOID, lockmode);
 		Assert(!RELATION_IS_OTHER_TEMP(newrelation));
 
 		/*
-- 
2.11.0

From ea4433237227778676f3bc7bfc9fa3609f240f8d Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Fri, 11 Jan 2019 11:11:30 +0900
Subject: [PATCH v14 1/6] Some fixups for b60c397599 (v2)

---
 src/backend/optimizer/path/joinrels.c   |  45 ++++++++++++++
 src/backend/optimizer/util/appendinfo.c | 101 +-------------------------------
 src/backend/optimizer/util/inherit.c    |  55 +++++++++++++++++
 src/include/optimizer/appendinfo.h      |  10 +---
 4 files changed, 104 insertions(+), 107 deletions(-)

diff --git a/src/backend/optimizer/path/joinrels.c b/src/backend/optimizer/path/joinrels.c
index 38eeb23d81..db18feccfe 100644
--- a/src/backend/optimizer/path/joinrels.c
+++ b/src/backend/optimizer/path/joinrels.c
@@ -46,6 +46,9 @@ static void try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1,
 					   List *parent_restrictlist);
 static int match_expr_to_partition_keys(Expr *expr, RelOptInfo *rel,
 							 bool strict_op);
+static SpecialJoinInfo *build_child_join_sjinfo(PlannerInfo *root,
+						SpecialJoinInfo *parent_sjinfo,
+						Relids left_relids, Relids right_relids);
 
 
 /*
@@ -1582,3 +1585,45 @@ match_expr_to_partition_keys(Expr *expr, RelOptInfo *rel, bool strict_op)
 
 	return -1;
 }
+
+/*
+ * Construct the SpecialJoinInfo for a child-join by translating
+ * SpecialJoinInfo for the join between parents. left_relids and right_relids
+ * are the relids of left and right side of the join respectively.
+ */
+static SpecialJoinInfo *
+build_child_join_sjinfo(PlannerInfo *root, SpecialJoinInfo *parent_sjinfo,
+						Relids left_relids, Relids right_relids)
+{
+	SpecialJoinInfo *sjinfo = makeNode(SpecialJoinInfo);
+	AppendRelInfo **left_appinfos;
+	int			left_nappinfos;
+	AppendRelInfo **right_appinfos;
+	int			right_nappinfos;
+
+	memcpy(sjinfo, parent_sjinfo, sizeof(SpecialJoinInfo));
+	left_appinfos = find_appinfos_by_relids(root, left_relids,
+											&left_nappinfos);
+	right_appinfos = find_appinfos_by_relids(root, right_relids,
+											 &right_nappinfos);
+
+	sjinfo->min_lefthand = adjust_child_relids(sjinfo->min_lefthand,
+											   left_nappinfos, left_appinfos);
+	sjinfo->min_righthand = adjust_child_relids(sjinfo->min_righthand,
+												right_nappinfos,
+												right_appinfos);
+	sjinfo->syn_lefthand = adjust_child_relids(sjinfo->syn_lefthand,
+											   left_nappinfos, left_appinfos);
+	sjinfo->syn_righthand = adjust_child_relids(sjinfo->syn_righthand,
+												right_nappinfos,
+												right_appinfos);
+	sjinfo->semi_rhs_exprs = (List *) adjust_appendrel_attrs(root,
+															 (Node *) sjinfo->semi_rhs_exprs,
+															 right_nappinfos,
+															 right_appinfos);
+
+	pfree(left_appinfos);
+	pfree(right_appinfos);
+
+	return sjinfo;
+}
diff --git a/src/backend/optimizer/util/appendinfo.c b/src/backend/optimizer/util/appendinfo.c
index d48e3a09b3..37fbc3a117 100644
--- a/src/backend/optimizer/util/appendinfo.c
+++ b/src/backend/optimizer/util/appendinfo.c
@@ -15,13 +15,12 @@
 #include "postgres.h"
 
 #include "access/htup_details.h"
-#include "access/sysattr.h"
 #include "nodes/makefuncs.h"
 #include "nodes/nodeFuncs.h"
 #include "optimizer/appendinfo.h"
 #include "parser/parsetree.h"
-#include "utils/rel.h"
 #include "utils/lsyscache.h"
+#include "utils/rel.h"
 #include "utils/syscache.h"
 
 
@@ -38,8 +37,6 @@ static void make_inh_translation_list(Relation oldrelation,
 						  List **translated_vars);
 static Node *adjust_appendrel_attrs_mutator(Node *node,
 							   adjust_appendrel_attrs_context *context);
-static Relids adjust_child_relids(Relids relids, int nappinfos,
-					AppendRelInfo **appinfos);
 static List *adjust_inherited_tlist(List *tlist,
 					   AppendRelInfo *context);
 
@@ -167,58 +164,6 @@ make_inh_translation_list(Relation oldrelation, Relation newrelation,
 }
 
 /*
- * translate_col_privs
- *	  Translate a bitmapset representing per-column privileges from the
- *	  parent rel's attribute numbering to the child's.
- *
- * The only surprise here is that we don't translate a parent whole-row
- * reference into a child whole-row reference.  That would mean requiring
- * permissions on all child columns, which is overly strict, since the
- * query is really only going to reference the inherited columns.  Instead
- * we set the per-column bits for all inherited columns.
- */
-Bitmapset *
-translate_col_privs(const Bitmapset *parent_privs,
-					List *translated_vars)
-{
-	Bitmapset  *child_privs = NULL;
-	bool		whole_row;
-	int			attno;
-	ListCell   *lc;
-
-	/* System attributes have the same numbers in all tables */
-	for (attno = FirstLowInvalidHeapAttributeNumber + 1; attno < 0; attno++)
-	{
-		if (bms_is_member(attno - FirstLowInvalidHeapAttributeNumber,
-						  parent_privs))
-			child_privs = bms_add_member(child_privs,
-										 attno - FirstLowInvalidHeapAttributeNumber);
-	}
-
-	/* Check if parent has whole-row reference */
-	whole_row = bms_is_member(InvalidAttrNumber - FirstLowInvalidHeapAttributeNumber,
-							  parent_privs);
-
-	/* And now translate the regular user attributes, using the vars list */
-	attno = InvalidAttrNumber;
-	foreach(lc, translated_vars)
-	{
-		Var		   *var = lfirst_node(Var, lc);
-
-		attno++;
-		if (var == NULL)		/* ignore dropped columns */
-			continue;
-		if (whole_row ||
-			bms_is_member(attno - FirstLowInvalidHeapAttributeNumber,
-						  parent_privs))
-			child_privs = bms_add_member(child_privs,
-										 var->varattno - FirstLowInvalidHeapAttributeNumber);
-	}
-
-	return child_privs;
-}
-
-/*
  * adjust_appendrel_attrs
  *	  Copy the specified query or expression and translate Vars referring to a
  *	  parent rel to refer to the corresponding child rel instead.  We also
@@ -531,7 +476,7 @@ adjust_appendrel_attrs_mutator(Node *node,
  * Substitute child relids for parent relids in a Relid set.  The array of
  * appinfos specifies the substitutions to be performed.
  */
-static Relids
+Relids
 adjust_child_relids(Relids relids, int nappinfos, AppendRelInfo **appinfos)
 {
 	Bitmapset  *result = NULL;
@@ -754,48 +699,6 @@ adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node,
 }
 
 /*
- * Construct the SpecialJoinInfo for a child-join by translating
- * SpecialJoinInfo for the join between parents. left_relids and right_relids
- * are the relids of left and right side of the join respectively.
- */
-SpecialJoinInfo *
-build_child_join_sjinfo(PlannerInfo *root, SpecialJoinInfo *parent_sjinfo,
-						Relids left_relids, Relids right_relids)
-{
-	SpecialJoinInfo *sjinfo = makeNode(SpecialJoinInfo);
-	AppendRelInfo **left_appinfos;
-	int			left_nappinfos;
-	AppendRelInfo **right_appinfos;
-	int			right_nappinfos;
-
-	memcpy(sjinfo, parent_sjinfo, sizeof(SpecialJoinInfo));
-	left_appinfos = find_appinfos_by_relids(root, left_relids,
-											&left_nappinfos);
-	right_appinfos = find_appinfos_by_relids(root, right_relids,
-											 &right_nappinfos);
-
-	sjinfo->min_lefthand = adjust_child_relids(sjinfo->min_lefthand,
-											   left_nappinfos, left_appinfos);
-	sjinfo->min_righthand = adjust_child_relids(sjinfo->min_righthand,
-												right_nappinfos,
-												right_appinfos);
-	sjinfo->syn_lefthand = adjust_child_relids(sjinfo->syn_lefthand,
-											   left_nappinfos, left_appinfos);
-	sjinfo->syn_righthand = adjust_child_relids(sjinfo->syn_righthand,
-												right_nappinfos,
-												right_appinfos);
-	sjinfo->semi_rhs_exprs = (List *) adjust_appendrel_attrs(root,
-															 (Node *) sjinfo->semi_rhs_exprs,
-															 right_nappinfos,
-															 right_appinfos);
-
-	pfree(left_appinfos);
-	pfree(right_appinfos);
-
-	return sjinfo;
-}
-
-/*
  * find_appinfos_by_relids
  * 		Find AppendRelInfo structures for all relations specified by relids.
  *
diff --git a/src/backend/optimizer/util/inherit.c b/src/backend/optimizer/util/inherit.c
index 350e6afe27..db474acbc5 100644
--- a/src/backend/optimizer/util/inherit.c
+++ b/src/backend/optimizer/util/inherit.c
@@ -15,6 +15,7 @@
 #include "postgres.h"
 
 #include "access/heapam.h"
+#include "access/sysattr.h"
 #include "catalog/partition.h"
 #include "catalog/pg_inherits.h"
 #include "miscadmin.h"
@@ -38,6 +39,8 @@ static void expand_single_inheritance_child(PlannerInfo *root,
 								PlanRowMark *top_parentrc, Relation childrel,
 								List **appinfos, RangeTblEntry **childrte_p,
 								Index *childRTindex_p);
+static Bitmapset *translate_col_privs(const Bitmapset *parent_privs,
+					List *translated_vars);
 
 
 /*
@@ -437,3 +440,55 @@ expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte,
 		root->rowMarks = lappend(root->rowMarks, childrc);
 	}
 }
+
+/*
+ * translate_col_privs
+ *	  Translate a bitmapset representing per-column privileges from the
+ *	  parent rel's attribute numbering to the child's.
+ *
+ * The only surprise here is that we don't translate a parent whole-row
+ * reference into a child whole-row reference.  That would mean requiring
+ * permissions on all child columns, which is overly strict, since the
+ * query is really only going to reference the inherited columns.  Instead
+ * we set the per-column bits for all inherited columns.
+ */
+static Bitmapset *
+translate_col_privs(const Bitmapset *parent_privs,
+					List *translated_vars)
+{
+	Bitmapset  *child_privs = NULL;
+	bool		whole_row;
+	int			attno;
+	ListCell   *lc;
+
+	/* System attributes have the same numbers in all tables */
+	for (attno = FirstLowInvalidHeapAttributeNumber + 1; attno < 0; attno++)
+	{
+		if (bms_is_member(attno - FirstLowInvalidHeapAttributeNumber,
+						  parent_privs))
+			child_privs = bms_add_member(child_privs,
+										 attno - FirstLowInvalidHeapAttributeNumber);
+	}
+
+	/* Check if parent has whole-row reference */
+	whole_row = bms_is_member(InvalidAttrNumber - FirstLowInvalidHeapAttributeNumber,
+							  parent_privs);
+
+	/* And now translate the regular user attributes, using the vars list */
+	attno = InvalidAttrNumber;
+	foreach(lc, translated_vars)
+	{
+		Var		   *var = lfirst_node(Var, lc);
+
+		attno++;
+		if (var == NULL)		/* ignore dropped columns */
+			continue;
+		if (whole_row ||
+			bms_is_member(attno - FirstLowInvalidHeapAttributeNumber,
+						  parent_privs))
+			child_privs = bms_add_member(child_privs,
+										 var->varattno - FirstLowInvalidHeapAttributeNumber);
+	}
+
+	return child_privs;
+}
diff --git a/src/include/optimizer/appendinfo.h b/src/include/optimizer/appendinfo.h
index 16705da780..156a0e077d 100644
--- a/src/include/optimizer/appendinfo.h
+++ b/src/include/optimizer/appendinfo.h
@@ -20,21 +20,15 @@
 extern AppendRelInfo *make_append_rel_info(Relation parentrel,
 					 Relation childrel,
 					 Index parentRTindex, Index childRTindex);
-extern Bitmapset *translate_col_privs(const Bitmapset *parent_privs,
-					List *translated_vars);
 extern Node *adjust_appendrel_attrs(PlannerInfo *root, Node *node,
 					   int nappinfos, AppendRelInfo **appinfos);
-
 extern Node *adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node,
 								  Relids child_relids,
 								  Relids top_parent_relids);
-
 extern AppendRelInfo **find_appinfos_by_relids(PlannerInfo *root,
 						Relids relids, int *nappinfos);
-
-extern SpecialJoinInfo *build_child_join_sjinfo(PlannerInfo *root,
-						SpecialJoinInfo *parent_sjinfo,
-						Relids left_relids, Relids right_relids);
+extern Relids adjust_child_relids(Relids relids, int nappinfos,
+					AppendRelInfo **appinfos);
 extern Relids adjust_child_relids_multilevel(PlannerInfo *root, Relids relids,
 							   Relids child_relids, Relids top_parent_relids);
 
-- 
2.11.0

From 07939e55d4574645308354963b6e86e2eedd033f Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Wed, 17 Oct 2018 11:18:12 +0900
Subject: [PATCH v14 2/6] Overhaul inheritance update/delete planning

With the current method, inheritance_planner, which handles the
planning for update/delete commands targeting inheritance trees,
repeatedly calls query_planner for each child table.

That's inefficient for two reasons:

 1. partprune.c cannot be used to perform partition pruning, because
    it can only be invoked from query_planner.  With the current
    approach, query_planner only sees the individual partitions in
    the query tree it receives, not the parent partitioned table.
    This leaves each partition to be pruned using constraint
    exclusion.  (constraint exclusion cannon prune hash partitions
    which means UPDATE/DELETE don't support hash partition pruning.)

 2. Repeated invocation of query_planner results in allocating large
    amounts of memory, especially if there are many child tables.
    Also, it involves repeatedly performing the same processing,
    such as jointree processing.

This commit addresses both of the issues by modifying query_planner
to handle the inheritance target case directly.  Instead of having
the caller create separate PlannerInfo's for individual child
target relations and pass them to query_planner (actually, via
grouping_planner), this teaches query_planner itself to create
the child PlannerInfo's by the original parent PlannerInfo.
It creates them *after* it has generated enough state in the latter,
such as RelOptInfos for various relations, EquivalenceClasses
after processing the join tree, and *before* generating the scan and
join paths.  Scan paths are generated normally, except that Paths of
target children are not "appended".  Join paths are generated
separately for each child target relation, that is, by replacing the
parent relation references in the original join tree with the child
relation references.  Joinrels (RelOptInfos thereof) corresponding
to various child target relation are saved in the parent PlannerInfo
for further processing.

inheritance_planner now calls query_planner just once at the beginning
with the original unmodified query, which takes care of generating
top-level join rels for the child queries as described above.  For each
child join rel, it then calls grouping_planner using previously created
child PlannerInfo to finish up the paths such that they produce
query's top-level target list expanded according to a given child
relation's descriptor.  grouping_planner()'s interface is modified so
that we can pass it what's called a 'planned_rel', a RelOptInfo that
already contains the necessary paths needed to produce its output.

This removes some existing code in inheritance_planner that dealt
with any subquery RTEs in the query.  The rationale of that code
was that the subquery RTEs may change during each iteration of
planning (that is, for different children), so different iterations
better use different copies of those RTEs.  That was handled by
making fresh copies of those RTEs for each iteration of planning
which were appended to the range table, accompanied by modifying all
expressions and auxiliary structures that referenced the original
subquery RTEs to instead reference the copies (that is, change the
varnos).  This copying meant we would end up adding S * N new entries
to the original range table by the time we got to the last unpruned
child, where S is the number of subquery RTEs in the original query
and N the number of unpruned children.  Since with the new code
we perform planning just once, I think we don't need this special
handling.  Actually, there is a regression test output change due
to no longer having copies of subquery RTEs (see the diff of
partition_join.out file.)

Also we no longer need the hack in relation_excluded_by_constraints()
involving setting PlannerInfo.inhTargetKind to enable constraint
exclusion for target child relation, which is no longer needed.
Constraint exclusion now runs during query_planner step described
above.

Regression test output change in partition_join.out is due to the fact
that we no longer create duplicates of subquery RTEs in child range
tables.
---
 doc/src/sgml/ddl.sgml                        |  17 +-
 src/backend/nodes/outfuncs.c                 |   2 +-
 src/backend/optimizer/path/allpaths.c        | 614 +++++++++++++++++++++++++--
 src/backend/optimizer/path/equivclass.c      |  57 ++-
 src/backend/optimizer/plan/createplan.c      |  10 -
 src/backend/optimizer/plan/planmain.c        |  48 ++-
 src/backend/optimizer/plan/planner.c         | 444 ++++++-------------
 src/backend/optimizer/prep/prepjointree.c    |   1 -
 src/backend/optimizer/util/appendinfo.c      |  33 +-
 src/backend/optimizer/util/inherit.c         | 109 +++++
 src/backend/optimizer/util/plancat.c         |  73 +---
 src/include/nodes/relation.h                 |  37 +-
 src/include/optimizer/inherit.h              |   1 +
 src/include/optimizer/paths.h                |   3 +-
 src/test/regress/expected/partition_join.out |   4 +-
 15 files changed, 988 insertions(+), 465 deletions(-)

diff --git a/doc/src/sgml/ddl.sgml b/doc/src/sgml/ddl.sgml
index 85e4358988..1bb5ca6b08 100644
--- a/doc/src/sgml/ddl.sgml
+++ b/doc/src/sgml/ddl.sgml
@@ -4439,24 +4439,11 @@ EXPLAIN SELECT count(*) FROM measurement WHERE logdate &gt;= DATE '2008-01-01';
 
    <note>
     <para>
-     Currently, pruning of partitions during the planning of an
-     <command>UPDATE</command> or <command>DELETE</command> command is
-     implemented using the constraint exclusion method (however, it is
-     controlled by the <literal>enable_partition_pruning</literal> rather than
-     <literal>constraint_exclusion</literal>) &mdash; see the following section
-     for details and caveats that apply.
-    </para>
-
-    <para>
      Execution-time partition pruning currently only occurs for the
      <literal>Append</literal> and <literal>MergeAppend</literal> node types.
      It is not yet implemented for the <literal>ModifyTable</literal> node
-     type.
-    </para>
-
-    <para>
-     Both of these behaviors are likely to be changed in a future release
-     of <productname>PostgreSQL</productname>.
+     type, but that is likely to be changed in a future release of
+     <productname>PostgreSQL</productname>.
     </para>
    </note>
   </sect2>
diff --git a/src/backend/nodes/outfuncs.c b/src/backend/nodes/outfuncs.c
index 0fde876c77..158da68925 100644
--- a/src/backend/nodes/outfuncs.c
+++ b/src/backend/nodes/outfuncs.c
@@ -2210,7 +2210,6 @@ _outPlannerInfo(StringInfo str, const PlannerInfo *node)
 	WRITE_FLOAT_FIELD(tuple_fraction, "%.4f");
 	WRITE_FLOAT_FIELD(limit_tuples, "%.0f");
 	WRITE_UINT_FIELD(qual_security_level);
-	WRITE_ENUM_FIELD(inhTargetKind, InheritanceKind);
 	WRITE_BOOL_FIELD(hasJoinRTEs);
 	WRITE_BOOL_FIELD(hasLateralRTEs);
 	WRITE_BOOL_FIELD(hasDeletedRTEs);
@@ -2221,6 +2220,7 @@ _outPlannerInfo(StringInfo str, const PlannerInfo *node)
 	WRITE_BITMAPSET_FIELD(curOuterRels);
 	WRITE_NODE_FIELD(curOuterParams);
 	WRITE_BOOL_FIELD(partColsUpdated);
+	WRITE_BOOL_FIELD(inherited_update);
 }
 
 static void
diff --git a/src/backend/optimizer/path/allpaths.c b/src/backend/optimizer/path/allpaths.c
index bc389b52e4..3324d485e4 100644
--- a/src/backend/optimizer/path/allpaths.c
+++ b/src/backend/optimizer/path/allpaths.c
@@ -38,6 +38,7 @@
 #include "optimizer/pathnode.h"
 #include "optimizer/paths.h"
 #include "optimizer/plancat.h"
+#include "optimizer/planmain.h"
 #include "optimizer/planner.h"
 #include "optimizer/restrictinfo.h"
 #include "optimizer/tlist.h"
@@ -92,8 +93,12 @@ static void set_foreign_size(PlannerInfo *root, RelOptInfo *rel,
 				 RangeTblEntry *rte);
 static void set_foreign_pathlist(PlannerInfo *root, RelOptInfo *rel,
 					 RangeTblEntry *rte);
+static void set_inherit_target_rel_sizes(PlannerInfo *root, RelOptInfo *rel,
+							 Index rti, RangeTblEntry *rte);
 static void set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 					Index rti, RangeTblEntry *rte);
+static void set_inherit_target_rel_pathlists(PlannerInfo *root,
+							 RelOptInfo *rel, Index rti, RangeTblEntry *rte);
 static void set_append_rel_pathlist(PlannerInfo *root, RelOptInfo *rel,
 						Index rti, RangeTblEntry *rte);
 static void generate_mergeappend_paths(PlannerInfo *root, RelOptInfo *rel,
@@ -120,6 +125,8 @@ static void set_namedtuplestore_pathlist(PlannerInfo *root, RelOptInfo *rel,
 static void set_worktable_pathlist(PlannerInfo *root, RelOptInfo *rel,
 					   RangeTblEntry *rte);
 static RelOptInfo *make_rel_from_joinlist(PlannerInfo *root, List *joinlist);
+static void inheritance_make_rel_from_joinlist(PlannerInfo *root,
+						List *joinlist);
 static bool subquery_is_pushdown_safe(Query *subquery, Query *topquery,
 						  pushdown_safety_info *safetyInfo);
 static bool recurse_pushdown_safe(Node *setOp, Query *topquery,
@@ -150,27 +157,6 @@ make_one_rel(PlannerInfo *root, List *joinlist)
 	Index		rti;
 	double		total_pages;
 
-	/*
-	 * Construct the all_baserels Relids set.
-	 */
-	root->all_baserels = NULL;
-	for (rti = 1; rti < root->simple_rel_array_size; rti++)
-	{
-		RelOptInfo *brel = root->simple_rel_array[rti];
-
-		/* there may be empty slots corresponding to non-baserel RTEs */
-		if (brel == NULL)
-			continue;
-
-		Assert(brel->relid == rti); /* sanity check on array */
-
-		/* ignore RTEs that are "other rels" */
-		if (brel->reloptkind != RELOPT_BASEREL)
-			continue;
-
-		root->all_baserels = bms_add_member(root->all_baserels, brel->relid);
-	}
-
 	/* Mark base rels as to whether we care about fast-start plans */
 	set_base_rel_consider_startup(root);
 
@@ -218,13 +204,34 @@ make_one_rel(PlannerInfo *root, List *joinlist)
 
 	/*
 	 * Generate access paths for the entire join tree.
+	 *
+	 * For UPDATE/DELETE on an inheritance parent, join paths should be
+	 * generated for each child result rel separately.
 	 */
-	rel = make_rel_from_joinlist(root, joinlist);
+	if (root->parse->resultRelation &&
+		root->simple_rte_array[root->parse->resultRelation]->inh)
+	{
+		inheritance_make_rel_from_joinlist(root, joinlist);
 
-	/*
-	 * The result should join all and only the query's base rels.
-	 */
-	Assert(bms_equal(rel->relids, root->all_baserels));
+		/*
+		 * Return the RelOptInfo of original target relation, although this
+		 * doesn't really contain the final path.  inheritance_planner
+		 * from where we got here will generate the final path, but it will
+		 * do so by iterative over child subroots, not through this
+		 * RelOptInfo.
+		 */
+		rel = find_base_rel(root, root->parse->resultRelation);
+	}
+	else
+	{
+		rel = make_rel_from_joinlist(root, joinlist);
+
+		/*
+		 * The result should join all and only the query's base rels.
+		 */
+		Assert(bms_equal(rel->relids, root->all_baserels));
+
+	}
 
 	return rel;
 }
@@ -308,9 +315,10 @@ set_base_rel_sizes(PlannerInfo *root)
 		 * If parallelism is allowable for this query in general, see whether
 		 * it's allowable for this rel in particular.  We have to do this
 		 * before set_rel_size(), because (a) if this rel is an inheritance
-		 * parent, set_append_rel_size() will use and perhaps change the rel's
-		 * consider_parallel flag, and (b) for some RTE types, set_rel_size()
-		 * goes ahead and makes paths immediately.
+		 * parent, set_append_rel_size() or set_inherit_target_rel_sizes()
+		 * will use and perhaps change the rel's consider_parallel flag, and
+		 * (b) for some RTE types, set_rel_size() goes ahead and makes paths
+		 * immediately.
 		 */
 		if (root->glob->parallelModeOK)
 			set_rel_consider_parallel(root, rel, rte);
@@ -374,8 +382,15 @@ set_rel_size(PlannerInfo *root, RelOptInfo *rel,
 	}
 	else if (rte->inh)
 	{
-		/* It's an "append relation", process accordingly */
-		set_append_rel_size(root, rel, rti, rte);
+		/*
+		 * If it's a target relation, set the sizes of children instead.
+		 * Otherwise, we'll append the outputs of children, so process it as
+		 * an "append relation".
+		 */
+		if (rti == root->parse->resultRelation)
+			set_inherit_target_rel_sizes(root, rel, rti, rte);
+		else
+			set_append_rel_size(root, rel, rti, rte);
 	}
 	else
 	{
@@ -459,14 +474,26 @@ static void
 set_rel_pathlist(PlannerInfo *root, RelOptInfo *rel,
 				 Index rti, RangeTblEntry *rte)
 {
+	bool	inherited_update = false;
+
 	if (IS_DUMMY_REL(rel))
 	{
 		/* We already proved the relation empty, so nothing more to do */
 	}
 	else if (rte->inh)
 	{
-		/* It's an "append relation", process accordingly */
-		set_append_rel_pathlist(root, rel, rti, rte);
+		/*
+		 * If it's a target relation, set the pathlists of children instead.
+		 * Otherwise, we'll append the outputs of children, so process it as
+		 * an "append relation".
+		 */
+		if (root->inherited_update && root->parse->resultRelation == rti)
+		{
+			inherited_update = true;
+			set_inherit_target_rel_pathlists(root, rel, rti, rte);
+		}
+		else
+			set_append_rel_pathlist(root, rel, rti, rte);
 	}
 	else
 	{
@@ -541,8 +568,12 @@ set_rel_pathlist(PlannerInfo *root, RelOptInfo *rel,
 	if (set_rel_pathlist_hook)
 		(*set_rel_pathlist_hook) (root, rel, rti, rte);
 
-	/* Now find the cheapest of the paths for this rel */
-	set_cheapest(rel);
+	/*
+	 * Now find the cheapest of the paths for this rel, unless it's an
+	 * inheritance parent and this is an update/delete operation.
+	 */
+	if (!inherited_update)
+		set_cheapest(rel);
 
 #ifdef OPTIMIZER_DEBUG
 	debug_print_rel(root, rel);
@@ -904,6 +935,382 @@ set_foreign_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
 }
 
 /*
+ * set_inherit_target_rel_sizes
+ *	  Set size estimates for the child target relations
+ *
+ * The passed-in rel represents the target relation of the query that is
+ * known to have inheritance children.  This is very much like
+ * set_append_rel_size, except it doesn't set the size estimates for the
+ * passed-in rel itself, because we don't need to "append" the children
+ * in this case.
+ */
+static void
+set_inherit_target_rel_sizes(PlannerInfo *root, RelOptInfo *rel,
+							 Index rti, RangeTblEntry *rte)
+{
+	int			parentRTindex = rti;
+	bool		has_live_children;
+	ListCell   *l;
+	Relids		live_children = NULL;
+	bool		did_pruning = false;
+
+	/* Guard against stack overflow due to overly deep inheritance tree. */
+	check_stack_depth();
+
+	Assert(IS_SIMPLE_REL(rel));
+
+	/*
+	 * If the partitioned relation has any baserestrictinfo quals then we
+	 * attempt to use these quals to prune away partitions that cannot
+	 * possibly contain any tuples matching these quals.  In this case we'll
+	 * store the relids of all partitions which could possibly contain a
+	 * matching tuple, and skip anything else in the loop below.
+	 */
+	if (enable_partition_pruning &&
+		rte->relkind == RELKIND_PARTITIONED_TABLE &&
+		rel->baserestrictinfo != NIL)
+	{
+		live_children = prune_append_rel_partitions(rel);
+		did_pruning = true;
+	}
+
+	foreach(l, root->append_rel_list)
+	{
+		AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(l);
+		int			childRTindex;
+		RangeTblEntry *childRTE;
+		RelOptInfo *childrel;
+		List	   *childquals;
+		Index		cq_min_security;
+		bool		have_const_false_cq;
+		PlannerInfo *subroot;
+		ListCell   *lc;
+		List	   *translated_exprs,
+				   *child_target_exprs;
+
+		/* append_rel_list contains all append rels; ignore others */
+		if (appinfo->parent_relid != parentRTindex)
+			continue;
+
+		childRTindex = appinfo->child_relid;
+		childRTE = root->simple_rte_array[childRTindex];
+
+		/*
+		 * The child rel's RelOptInfo was already created during
+		 * add_base_rels_to_query.
+		 */
+		childrel = find_base_rel(root, childRTindex);
+		Assert(childrel->reloptkind == RELOPT_OTHER_MEMBER_REL);
+
+		/*
+		 * We have to copy the parent's quals to the child, with appropriate
+		 * substitution of variables.  However, only the baserestrictinfo
+		 * quals are needed before we can check for constraint exclusion; so
+		 * do that first and then check to see if we can disregard this child.
+		 *
+		 * The child rel's targetlist might contain non-Var expressions, which
+		 * means that substitution into the quals could produce opportunities
+		 * for const-simplification, and perhaps even pseudoconstant quals.
+		 * Therefore, transform each RestrictInfo separately to see if it
+		 * reduces to a constant or pseudoconstant.  (We must process them
+		 * separately to keep track of the security level of each qual.)
+		 */
+		childquals = NIL;
+		cq_min_security = UINT_MAX;
+		have_const_false_cq = false;
+		foreach(lc, rel->baserestrictinfo)
+		{
+			RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
+			Node	   *childqual;
+			ListCell   *lc2;
+
+			Assert(IsA(rinfo, RestrictInfo));
+			childqual = adjust_appendrel_attrs(root,
+											   (Node *) rinfo->clause,
+											   1, &appinfo);
+			childqual = eval_const_expressions(root, childqual);
+			/* check for flat-out constant */
+			if (childqual && IsA(childqual, Const))
+			{
+				if (((Const *) childqual)->constisnull ||
+					!DatumGetBool(((Const *) childqual)->constvalue))
+				{
+					/* Restriction reduces to constant FALSE or NULL */
+					have_const_false_cq = true;
+					break;
+				}
+				/* Restriction reduces to constant TRUE, so drop it */
+				continue;
+			}
+			/* might have gotten an AND clause, if so flatten it */
+			foreach(lc2, make_ands_implicit((Expr *) childqual))
+			{
+				Node	   *onecq = (Node *) lfirst(lc2);
+				bool		pseudoconstant;
+
+				/* check for pseudoconstant (no Vars or volatile functions) */
+				pseudoconstant =
+					!contain_vars_of_level(onecq, 0) &&
+					!contain_volatile_functions(onecq);
+				if (pseudoconstant)
+				{
+					/* tell createplan.c to check for gating quals */
+					root->hasPseudoConstantQuals = true;
+				}
+				/* reconstitute RestrictInfo with appropriate properties */
+				childquals = lappend(childquals,
+									 make_restrictinfo((Expr *) onecq,
+													   rinfo->is_pushed_down,
+													   rinfo->outerjoin_delayed,
+													   pseudoconstant,
+													   rinfo->security_level,
+													   NULL, NULL, NULL));
+				/* track minimum security level among child quals */
+				cq_min_security = Min(cq_min_security, rinfo->security_level);
+			}
+		}
+
+		/*
+		 * In addition to the quals inherited from the parent, we might have
+		 * securityQuals associated with this particular child node.
+		 * (Currently this can only happen in appendrels originating from
+		 * UNION ALL; inheritance child tables don't have their own
+		 * securityQuals, see expand_inherited_rtentry().)	Pull any such
+		 * securityQuals up into the baserestrictinfo for the child.  This is
+		 * similar to process_security_barrier_quals() for the parent rel,
+		 * except that we can't make any general deductions from such quals,
+		 * since they don't hold for the whole appendrel.
+		 */
+		if (childRTE->securityQuals)
+		{
+			Index		security_level = 0;
+
+			foreach(lc, childRTE->securityQuals)
+			{
+				List	   *qualset = (List *) lfirst(lc);
+				ListCell   *lc2;
+
+				foreach(lc2, qualset)
+				{
+					Expr	   *qual = (Expr *) lfirst(lc2);
+
+					/* not likely that we'd see constants here, so no check */
+					childquals = lappend(childquals,
+										 make_restrictinfo(qual,
+														   true, false, false,
+														   security_level,
+														   NULL, NULL, NULL));
+					cq_min_security = Min(cq_min_security, security_level);
+				}
+				security_level++;
+			}
+			Assert(security_level <= root->qual_security_level);
+		}
+
+		/*
+		 * OK, we've got all the baserestrictinfo quals for this child.
+		 */
+		childrel->baserestrictinfo = childquals;
+		childrel->baserestrict_min_security = cq_min_security;
+
+		if (have_const_false_cq)
+		{
+			/*
+			 * Some restriction clause reduced to constant FALSE or NULL after
+			 * substitution, so this child need not be scanned.
+			 */
+			set_dummy_rel_pathlist(childrel);
+			continue;
+		}
+
+		if (did_pruning && !bms_is_member(appinfo->child_relid, live_children))
+		{
+			/* This partition was pruned; skip it. */
+			set_dummy_rel_pathlist(childrel);
+			continue;
+		}
+
+		if (relation_excluded_by_constraints(root, childrel, childRTE))
+		{
+			/* This child is excluded; skip it. */
+			set_dummy_rel_pathlist(childrel);
+			continue;
+		}
+
+		/*
+		 * Add missing Vars to child's reltarget.
+		 *
+		 * add_inherit_target_child_root() would've added only those that are
+		 * needed to be present in the top-level tlist (or ones that
+		 * preprocess_targetlist thinks are needed to be in the tlist.)  We
+		 * may need other attributes such as those contained in WHERE clauses,
+		 * which are already computed for the parent during
+		 * deconstruct_jointree processing of the original query (child's
+		 * query never goes through deconstruct_jointree.)
+		 */
+		translated_exprs = (List *)
+			adjust_appendrel_attrs(root,
+								   (Node *) rel->reltarget->exprs,
+								   1, &appinfo);
+		child_target_exprs = childrel->reltarget->exprs;
+		foreach(lc, translated_exprs)
+		{
+			Expr *expr = lfirst(lc);
+
+			if (!list_member(child_target_exprs, expr))
+				child_target_exprs = lappend(child_target_exprs, expr);
+		}
+
+		subroot = root->inh_target_child_roots[childRTindex];
+
+		/*
+		 * Also, We have to find any ECs containing parent's expressions and
+		 * *replace* them with their copies containing child expressions.
+		 */
+		if (rel->has_eclass_joins || has_useful_pathkeys(root, rel))
+		{
+			/*
+			 * First make copies for ECs for the child's root, because some
+			 * might be modified to replace parent EC expressions by child
+			 * expressions in add_child_rel_equivalences.
+			 */
+			subroot->eq_classes = NIL;
+			foreach(lc, root->eq_classes)
+			{
+				EquivalenceClass *ec = lfirst(lc);
+				EquivalenceClass *new_ec = makeNode(EquivalenceClass);
+
+				/*
+				 * First memcpy which creates shallow copies of all
+				 * the members and then make copies of members that could
+				 * change.
+				 *
+				 * XXX comment in _copyPathKey says it's OK to recycle EC
+				 * pointers, but as long as we do the whole planning for a
+				 * given child using a given root, copying ECs like this
+				 * shouldn't be a problem.  Maybe, the following code could
+				 * be in _copyEquivalenceClass()?
+				 */
+				memcpy(new_ec, ec, sizeof(EquivalenceClass));
+				new_ec->ec_opfamilies = list_copy(ec->ec_opfamilies);
+				new_ec->ec_members = list_copy(ec->ec_members);
+				new_ec->ec_sources = list_copy(ec->ec_sources);
+				new_ec->ec_derives = list_copy(ec->ec_derives);
+				new_ec->ec_relids = bms_copy(ec->ec_relids);
+
+				subroot->eq_classes = lappend(subroot->eq_classes, new_ec);
+			}
+
+			add_child_rel_equivalences(subroot, appinfo, rel, childrel, true);
+		}
+		childrel->has_eclass_joins = rel->has_eclass_joins;
+
+		/* Translate join quals. */
+		childrel->joininfo = (List *)
+			adjust_appendrel_attrs(subroot,
+								   (Node *) rel->joininfo,
+								   1, &appinfo);
+
+		/*
+		 * If parallelism is allowable for this query in general, see whether
+		 * it's allowable for this childrel in particular.  For consistency,
+		 * do this before calling set_rel_size() for the child.
+		 */
+		if (root->glob->parallelModeOK)
+			set_rel_consider_parallel(subroot, childrel, childRTE);
+
+		/*
+		 * Compute the child's size using possibly modified subroot.
+		 */
+		set_rel_size(subroot, childrel, childRTindex, childRTE);
+
+		/* If the child itself is partitioned it may turn into a dummy rel. */
+		if (IS_DUMMY_REL(childrel))
+			continue;
+
+		/* We have at least one live child. */
+		has_live_children = true;
+
+		Assert(childrel->rows > 0);
+	}
+
+	if (has_live_children)
+	{
+		/*
+		 * Set a non-zero value here to cope with the caller's requirement
+		 * that non-dummy relations are actually not empty.  We don't try to
+		 * be accurate here, because we're not going to create a path that
+		 * combines the children outputs.
+		 */
+		rel->rows = 1;
+	}
+	else
+	{
+		/*
+		 * All children were excluded by constraints, so mark the relation
+		 * ass dummy.  We must do this in this phase so that the rel's
+		 * dummy-ness is visible when we generate paths for other rels.
+		 */
+		set_dummy_rel_pathlist(rel);
+	}
+}
+
+/*
+ * set_inherit_target_rel_pathlists
+ *	  Build access paths for the child target relations
+ *
+ * Similar to set_append_rel_pathlist, except that we build paths of the
+ * children, but don't build an Append path.
+ */
+static void
+set_inherit_target_rel_pathlists(PlannerInfo *root, RelOptInfo *rel,
+								 Index rti, RangeTblEntry *rte)
+{
+	int			parentRTindex = rti;
+	ListCell   *l;
+
+	/* Nothing to do if all the children were excluded. */
+	if (IS_DUMMY_REL(rel))
+		return;
+
+	/* Generate access paths for each of the children of passed-in rel */
+	foreach(l, root->append_rel_list)
+	{
+		AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(l);
+		int			childRTindex;
+		RangeTblEntry *childRTE;
+		RelOptInfo *childrel;
+		PlannerInfo *subroot;
+
+		/* append_rel_list contains all append rels; ignore others */
+		if (appinfo->parent_relid != parentRTindex)
+			continue;
+
+		/* Re-locate the child RTE and RelOptInfo */
+		childRTindex = appinfo->child_relid;
+		childRTE = root->simple_rte_array[childRTindex];
+		childrel = root->simple_rel_array[childRTindex];
+		subroot = root->inh_target_child_roots[childRTindex];
+		/* Transfer the value from main root to subroot. */
+		subroot->total_table_pages = root->total_table_pages;
+
+		/*
+		 * If set_append_rel_size() decided the parent appendrel was
+		 * parallel-unsafe at some point after visiting this child rel, we
+		 * need to propagate the unsafety marking down to the child, so that
+		 * we don't generate useless partial paths for it.
+		 */
+		if (!rel->consider_parallel)
+			childrel->consider_parallel = false;
+
+		/*
+		 * Compute the child's access paths.
+		 */
+		set_rel_pathlist(subroot, childrel, childRTindex, childRTE);
+	}
+}
+
+/*
  * set_append_rel_size
  *	  Set size estimates for a simple "append relation"
  *
@@ -1046,7 +1453,8 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 		 * EquivalenceClass data structures.
 		 */
 		if (rel->has_eclass_joins || has_useful_pathkeys(root, rel))
-			add_child_rel_equivalences(root, appinfo, rel, childrel);
+			add_child_rel_equivalences(root, appinfo, rel, childrel,
+									   false);
 		childrel->has_eclass_joins = rel->has_eclass_joins;
 
 		/*
@@ -2625,6 +3033,140 @@ generate_gather_paths(PlannerInfo *root, RelOptInfo *rel, bool override_rows)
 }
 
 /*
+ * inheritance_make_rel_from_joinlist
+ *		Perform join planning for all non-dummy leaf inheritance children
+ *		in their role as an UPDATE/DELETE query's target relation
+ *
+ * If a child relation is a partitioned table, its children are processed in
+ * turn by recursively calling this function.
+ */
+static void
+inheritance_make_rel_from_joinlist(PlannerInfo *root, List *joinlist)
+{
+	Index		resultRelation = root->parse->resultRelation;
+	ListCell   *lc;
+#ifdef USE_ASSERT_CHECKING
+	Relids	all_baserels;
+#endif
+
+	/* For UPDATE/DELETE queries, the top parent can only ever be a table. */
+	Assert(root->parse->commandType == CMD_UPDATE ||
+		   root->parse->commandType == CMD_DELETE);
+	Assert(planner_rt_fetch(resultRelation, root)->rtekind == RTE_RELATION);
+
+	/* Nothing to do. */
+	if (IS_DUMMY_REL(find_base_rel(root, resultRelation)))
+		return;
+
+	foreach(lc, root->append_rel_list)
+	{
+		AppendRelInfo *appinfo = lfirst(lc);
+		PlannerInfo *subroot;
+		RelOptInfo *childrel;
+		RelOptInfo *childjoinrel;
+		List	   *translated_joinlist;
+
+		if (appinfo->parent_relid != resultRelation)
+			continue;
+
+		childrel = find_base_rel(root, appinfo->child_relid);
+
+		/* Ignore excluded/pruned children. */
+		if (IS_DUMMY_REL(childrel))
+			continue;
+
+		/* Add this child. */
+		root->inh_target_child_rels = lappend_int(root->inh_target_child_rels,
+												  appinfo->child_relid);
+
+		/* Perform join planning with child subroot. */
+		subroot = root->inh_target_child_roots[appinfo->child_relid];
+		Assert(subroot->parse->resultRelation > 0);
+
+		/*
+		 * Modify joinlist such that relations joined to the top parent rel
+		 * appear to be joined to the child rel instead.  Do the same for
+		 * any SpecialJoinInfo structs.
+		 */
+		translated_joinlist = (List *)
+						adjust_appendrel_attrs(subroot,
+											   (Node *) joinlist,
+											   1, &appinfo);
+		subroot->join_info_list = (List *)
+						adjust_appendrel_attrs(subroot,
+											   (Node *) root->join_info_list,
+											   1, &appinfo);
+
+		/*
+		 * Sub-partitioned tables have to be processed recursively using the
+		 * translated subroot as the parent, because AppendRelInfos link
+		 * sub-partitions to their immediate parents, not the root partitioned
+		 * table.
+		 */
+		if (childrel->part_scheme != NULL)
+		{
+			inheritance_make_rel_from_joinlist(subroot, translated_joinlist);
+
+			/*
+			 * Add this child relation as a placeholder in the parent root's
+			 * inh_target_child_joinrels so that inheritance_planner see same
+			 * number of entries as inh_target_child_rels.
+			 */
+			root->inh_target_child_joinrels =
+					lappend(root->inh_target_child_joinrels, childrel);
+
+			/* Also propagate this child's own children into parent's list. */
+			if (subroot->inh_target_child_rels != NIL)
+			{
+				root->inh_target_child_rels =
+					list_concat(root->inh_target_child_rels,
+								subroot->inh_target_child_rels);
+				root->inh_target_child_joinrels =
+					list_concat(root->inh_target_child_joinrels,
+								subroot->inh_target_child_joinrels);
+			}
+			continue;
+		}
+
+		/*
+		 * Since we added the child rel directly into the join tree, we must
+		 * modify it to be a "base" rel instead of an "other" rel, which the
+		 * join planning code expects the relations being joined to be.
+		 */
+		childrel->reloptkind = RELOPT_BASEREL;
+
+		Assert(subroot->join_rel_list == NIL);
+		Assert(subroot->join_rel_hash == NULL);
+
+		/* Perform join planning and save the resulting RelOptInfo. */
+		childjoinrel = make_rel_from_joinlist(subroot, translated_joinlist);
+
+		/*
+		 * Remember this child target rel.  inheritance_planner will perform
+		 * the remaining steps of planning for each child relation separately.
+		 * Specifically, it will call grouping_planner on every
+		 * RelOptInfo contained in the inh_target_child_rels list, each of
+		 * which represents the source of tuples to be modified for a given
+		 * target child rel.
+		 */
+		root->inh_target_child_joinrels =
+					lappend(root->inh_target_child_joinrels, childjoinrel);
+#ifdef USE_ASSERT_CHECKING
+		/*
+		 * The following implements essentially the same Assert as in
+		 * make_one_rel, our caller.
+		 */
+		all_baserels = bms_copy(root->all_baserels);
+		all_baserels = bms_del_member(all_baserels,
+									  root->parse->resultRelation);
+		all_baserels = bms_add_member(all_baserels,
+									  subroot->parse->resultRelation);
+		Assert(bms_equal(childjoinrel->relids, all_baserels));
+#endif
+	}
+}
+
+/*
  * make_rel_from_joinlist
  *	  Build access paths using a "joinlist" to guide the join path search.
  *
diff --git a/src/backend/optimizer/path/equivclass.c b/src/backend/optimizer/path/equivclass.c
index 6e134ae1d2..10136ef940 100644
--- a/src/backend/optimizer/path/equivclass.c
+++ b/src/backend/optimizer/path/equivclass.c
@@ -2104,12 +2104,16 @@ match_eclasses_to_foreign_key_col(PlannerInfo *root,
  *
  * parent_rel and child_rel could be derived from appinfo, but since the
  * caller has already computed them, we might as well just pass them in.
+ *
+ * If 'replace' is true then the child EC members *replace* the corresponding
+ * parent members.
  */
 void
 add_child_rel_equivalences(PlannerInfo *root,
 						   AppendRelInfo *appinfo,
 						   RelOptInfo *parent_rel,
-						   RelOptInfo *child_rel)
+						   RelOptInfo *child_rel,
+						   bool replace)
 {
 	ListCell   *lc1;
 
@@ -2117,14 +2121,23 @@ add_child_rel_equivalences(PlannerInfo *root,
 	{
 		EquivalenceClass *cur_ec = (EquivalenceClass *) lfirst(lc1);
 		ListCell   *lc2;
+		ListCell   *prev;
+		ListCell   *next;
 
 		/*
 		 * If this EC contains a volatile expression, then generating child
 		 * EMs would be downright dangerous, so skip it.  We rely on a
-		 * volatile EC having only one EM.
+		 * volatile EC having only one EM.  If the caller asked to *replace*
+		 * the original parent expression with the child one, then it's
+		 * okay to proceed, because we wouldn't be adding another expression
+		 * as being equivalent in that case.
 		 */
 		if (cur_ec->ec_has_volatile)
-			continue;
+		{
+			Assert(list_length(cur_ec->ec_members) == 1);
+			if (!replace)
+				continue;
+		}
 
 		/*
 		 * No point in searching if parent rel not mentioned in eclass; but we
@@ -2134,12 +2147,18 @@ add_child_rel_equivalences(PlannerInfo *root,
 			!bms_is_subset(parent_rel->relids, cur_ec->ec_relids))
 			continue;
 
-		foreach(lc2, cur_ec->ec_members)
+		prev = NULL;
+		for (lc2 = list_head(cur_ec->ec_members); lc2 != NULL; lc2 = next)
 		{
 			EquivalenceMember *cur_em = (EquivalenceMember *) lfirst(lc2);
 
+			next = lnext(lc2);
+
 			if (cur_em->em_is_const)
+			{
+				prev = lc2;
 				continue;		/* ignore consts here */
+			}
 
 			/* Does it reference parent_rel? */
 			if (bms_overlap(cur_em->em_relids, parent_rel->relids))
@@ -2177,10 +2196,38 @@ add_child_rel_equivalences(PlannerInfo *root,
 														  child_rel->relids);
 				}
 
+				/*
+				 * Caller may have asked us to replace the parent expression
+				 * with the child expression, so delete the parent expression
+				 * first.
+				 */
+				if (replace)
+					cur_ec->ec_members = list_delete_cell(cur_ec->ec_members,
+														  lc2, prev);
+
+				/*
+				 * If we're replacing, then the new member isn't really a
+				 * a child, so em_is_child should be set to false.
+				 */
 				(void) add_eq_member(cur_ec, child_expr,
 									 new_relids, new_nullable_relids,
-									 true, cur_em->em_datatype);
+									 !replace, cur_em->em_datatype);
 			}
+			else
+				prev = lc2;
+		}
+
+		if (replace)
+		{
+			/*
+			 * Now fix up EC's relids set.  It's OK to modify EC like this,
+			 * because caller must have made a copy of the original EC.
+			 * For example, see adjust_inherited_target_child_root.
+			 */
+			cur_ec->ec_relids = bms_difference(cur_ec->ec_relids,
+											   parent_rel->relids);
+			cur_ec->ec_relids = bms_add_members(cur_ec->ec_relids,
+												child_rel->relids);
 		}
 	}
 }
diff --git a/src/backend/optimizer/plan/createplan.c b/src/backend/optimizer/plan/createplan.c
index 97d0c28132..1e1c7efef9 100644
--- a/src/backend/optimizer/plan/createplan.c
+++ b/src/backend/optimizer/plan/createplan.c
@@ -2019,12 +2019,7 @@ create_groupingsets_plan(PlannerInfo *root, GroupingSetsPath *best_path)
 	/*
 	 * During setrefs.c, we'll need the grouping_map to fix up the cols lists
 	 * in GroupingFunc nodes.  Save it for setrefs.c to use.
-	 *
-	 * This doesn't work if we're in an inheritance subtree (see notes in
-	 * create_modifytable_plan).  Fortunately we can't be because there would
-	 * never be grouping in an UPDATE/DELETE; but let's Assert that.
 	 */
-	Assert(root->inhTargetKind == INHKIND_NONE);
 	Assert(root->grouping_map == NULL);
 	root->grouping_map = grouping_map;
 
@@ -2181,12 +2176,7 @@ create_minmaxagg_plan(PlannerInfo *root, MinMaxAggPath *best_path)
 	 * with InitPlan output params.  (We can't just do that locally in the
 	 * MinMaxAgg node, because path nodes above here may have Agg references
 	 * as well.)  Save the mmaggregates list to tell setrefs.c to do that.
-	 *
-	 * This doesn't work if we're in an inheritance subtree (see notes in
-	 * create_modifytable_plan).  Fortunately we can't be because there would
-	 * never be aggregates in an UPDATE/DELETE; but let's Assert that.
 	 */
-	Assert(root->inhTargetKind == INHKIND_NONE);
 	Assert(root->minmax_aggs == NIL);
 	root->minmax_aggs = best_path->mmaggregates;
 
diff --git a/src/backend/optimizer/plan/planmain.c b/src/backend/optimizer/plan/planmain.c
index fc97a1bb50..78557aeecb 100644
--- a/src/backend/optimizer/plan/planmain.c
+++ b/src/backend/optimizer/plan/planmain.c
@@ -28,7 +28,7 @@
 #include "optimizer/paths.h"
 #include "optimizer/placeholder.h"
 #include "optimizer/planmain.h"
-
+#include "optimizer/prep.h"
 
 /*
  * query_planner
@@ -59,6 +59,7 @@ query_planner(PlannerInfo *root, List *tlist,
 	Query	   *parse = root->parse;
 	List	   *joinlist;
 	RelOptInfo *final_rel;
+	Index		rti;
 
 	/*
 	 * If the query has an empty join tree, then it's something easy like
@@ -232,13 +233,52 @@ query_planner(PlannerInfo *root, List *tlist,
 	extract_restriction_or_clauses(root);
 
 	/*
+	 * Construct the all_baserels Relids set.
+	 */
+	root->all_baserels = NULL;
+	for (rti = 1; rti < root->simple_rel_array_size; rti++)
+	{
+		RelOptInfo *brel = root->simple_rel_array[rti];
+
+		/* there may be empty slots corresponding to non-baserel RTEs */
+		if (brel == NULL)
+			continue;
+
+		Assert(brel->relid == rti); /* sanity check on array */
+
+		/* ignore RTEs that are "other rels" */
+		if (brel->reloptkind != RELOPT_BASEREL)
+			continue;
+
+		root->all_baserels = bms_add_member(root->all_baserels, brel->relid);
+	}
+
+	/*
+	 * Add child subroots needed to use during planning for individual child
+	 * targets
+	 */
+	if (root->inherited_update)
+	{
+		root->inh_target_child_roots = (PlannerInfo **)
+										palloc0(root->simple_rel_array_size *
+												sizeof(PlannerInfo *));
+		add_inherited_target_child_roots(root);
+	}
+
+	/*
 	 * Ready to do the primary planning.
 	 */
 	final_rel = make_one_rel(root, joinlist);
 
-	/* Check that we got at least one usable path */
-	if (!final_rel || !final_rel->cheapest_total_path ||
-		final_rel->cheapest_total_path->param_info != NULL)
+	/*
+	 * Check that we got at least one usable path.  In the case of an
+	 * inherited update/delete operation, no path has been created for
+	 * the query's actual target relation yet.
+	 */
+	if (!root->inherited_update &&
+		(!final_rel ||
+		 !final_rel->cheapest_total_path ||
+		 final_rel->cheapest_total_path->param_info != NULL))
 		elog(ERROR, "failed to construct the join relation");
 
 	return final_rel;
diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index 5ba612922f..703babfdf0 100644
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -39,6 +39,7 @@
 #ifdef OPTIMIZER_DEBUG
 #include "nodes/print.h"
 #endif
+#include "nodes/relation.h"
 #include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
 #include "optimizer/cost.h"
@@ -131,7 +132,7 @@ static Node *preprocess_expression(PlannerInfo *root, Node *expr, int kind);
 static void preprocess_qual_conditions(PlannerInfo *root, Node *jtnode);
 static void inheritance_planner(PlannerInfo *root);
 static void grouping_planner(PlannerInfo *root, bool inheritance_update,
-				 double tuple_fraction);
+				 RelOptInfo *planned_rel, double tuple_fraction);
 static grouping_sets_data *preprocess_grouping_sets(PlannerInfo *root);
 static List *remap_to_groupclause_idx(List *groupClause, List *gsets,
 						 int *tleref_to_colnum_map);
@@ -635,7 +636,6 @@ subquery_planner(PlannerGlobal *glob, Query *parse,
 	root->grouping_map = NULL;
 	root->minmax_aggs = NIL;
 	root->qual_security_level = 0;
-	root->inhTargetKind = INHKIND_NONE;
 	root->hasRecursion = hasRecursion;
 	if (hasRecursion)
 		root->wt_param_id = assign_special_exec_param(root);
@@ -725,6 +725,13 @@ subquery_planner(PlannerGlobal *glob, Query *parse,
 	expand_inherited_tables(root);
 
 	/*
+	 * Now that we have figured out "actual" inheritance situation of the
+	 * relations, set whether the query is an inherited UPDATE/DELETE.
+	 */
+	root->inherited_update = (parse->resultRelation &&
+					  rt_fetch(parse->resultRelation, parse->rtable)->inh);
+
+	/*
 	 * Set hasHavingQual to remember if HAVING clause is present.  Needed
 	 * because preprocess_expression will reduce a constant-true condition to
 	 * an empty qual list ... but "HAVING TRUE" is not a semantic no-op.
@@ -975,7 +982,7 @@ subquery_planner(PlannerGlobal *glob, Query *parse,
 		rt_fetch(parse->resultRelation, parse->rtable)->inh)
 		inheritance_planner(root);
 	else
-		grouping_planner(root, false, tuple_fraction);
+		grouping_planner(root, false, NULL, tuple_fraction);
 
 	/*
 	 * Capture the set of outer-level param IDs we have access to, for use in
@@ -1151,13 +1158,41 @@ preprocess_phv_expression(PlannerInfo *root, Expr *expr)
  *	  inheritance set.
  *
  * We have to handle this case differently from cases where a source relation
- * is an inheritance set. Source inheritance is expanded at the bottom of the
- * plan tree (see allpaths.c), but target inheritance has to be expanded at
- * the top.  The reason is that for UPDATE, each target relation needs a
- * different targetlist matching its own column set.  Fortunately,
+ * is an inheritance set, where outputs of all the children are combined and
+ * combined output consumed using the source relation's (parent's) column set.
+ * For UPDATE, each target relation, where the query's output will go, needs
+ * a different targetlist matching its own column set.  So, we will need to
+ * translate the query such that it produces the desired output required by
+ * each of the child target relations and plan each separately.  Fortunately,
  * the UPDATE/DELETE target can never be the nullable side of an outer join,
  * so it's OK to generate the plan this way.
  *
+ * Planning steps that need to be performed separately for each child and
+ * any preliminary processing needed for that are handled by the following
+ * sub-routines of query_planner:
+ *
+ *	add_inherit_target_roots - this creates copies of PlannerInfo for each
+ *	child after query_planner has finished processing the join tree and
+ *	creating EquivalenceClasses, so that working state of planning need
+ *	not be created afresh for each child, especially the various arrays
+ *
+ *	set_inherit_target_rel_sizes - this sets size estimates for child
+ *	relations, replace the parent EC members by corresponding child ones
+ *	in their respective subroots
+ *
+ *	set_inherit_target_rel_pathlists - this creates Paths for scanning
+ *	individual child relations
+ *
+ *	inherit_make_rel_from_joinlist - this translates the jointree, replacing
+ *	the target relation in the original jointree (the root parent) by
+ *	individual child target relations and performs join planning on the
+ *	resulting join tree, saving the RelOptInfos of resulting join relations
+ *	into the top-level PlannerInfo
+ *
+ * Finally, here we apply grouping_planner to each child join relation
+ * produced by set_inherit_target_rel_pathlists to so that its path produces
+ * the desired targetlist.
+ *
  * Returns nothing; the useful output is in the Paths we attach to
  * the (UPPERREL_FINAL, NULL) upperrel stored in *root.
  *
@@ -1169,14 +1204,8 @@ inheritance_planner(PlannerInfo *root)
 {
 	Query	   *parse = root->parse;
 	int			top_parentRTindex = parse->resultRelation;
-	Bitmapset  *subqueryRTindexes;
-	Bitmapset  *modifiableARIindexes;
 	int			nominalRelation = -1;
 	Index		rootRelation = 0;
-	List	   *final_rtable = NIL;
-	int			save_rel_array_size = 0;
-	RelOptInfo **save_rel_array = NULL;
-	AppendRelInfo **save_append_rel_array = NULL;
 	List	   *subpaths = NIL;
 	List	   *subroots = NIL;
 	List	   *resultRelations = NIL;
@@ -1184,70 +1213,47 @@ inheritance_planner(PlannerInfo *root)
 	List	   *returningLists = NIL;
 	List	   *rowMarks;
 	RelOptInfo *final_rel;
-	ListCell   *lc;
-	Index		rti;
+	ListCell   *lc1,
+			   *lc2;
 	RangeTblEntry *parent_rte;
-	PlannerInfo *parent_root;
-	Query	   *parent_parse;
-	Bitmapset  *parent_relids = bms_make_singleton(top_parentRTindex);
-	PlannerInfo **parent_roots = NULL;
+	List	   *tlist;
+	standard_qp_extra qp_extra;
+	RelOptInfo *planned_rel;
 
+	/* Inheritance is never used for insert. */
 	Assert(parse->commandType != CMD_INSERT);
 
 	/*
-	 * We generate a modified instance of the original Query for each target
-	 * relation, plan that, and put all the plans into a list that will be
-	 * controlled by a single ModifyTable node.  All the instances share the
-	 * same rangetable, but each instance must have its own set of subquery
-	 * RTEs within the finished rangetable because (1) they are likely to get
-	 * scribbled on during planning, and (2) it's not inconceivable that
-	 * subqueries could get planned differently in different cases.  We need
-	 * not create duplicate copies of other RTE kinds, in particular not the
-	 * target relations, because they don't have either of those issues.  Not
-	 * having to duplicate the target relations is important because doing so
-	 * (1) would result in a rangetable of length O(N^2) for N targets, with
-	 * at least O(N^3) work expended here; and (2) would greatly complicate
-	 * management of the rowMarks list.
+	 * Let query_planner generate the access paths for the query for each
+	 * target child relation.
 	 *
-	 * To begin with, generate a bitmapset of the relids of the subquery RTEs.
+	 * First, save the unexpanded version of the query's targetlist.
+	 * create_inherit_target_child_root will use it as base when expanding
+	 * it for a given child relation as the query's target relation instead
+	 * of the parent.
 	 */
-	subqueryRTindexes = NULL;
-	rti = 1;
-	foreach(lc, parse->rtable)
-	{
-		RangeTblEntry *rte = lfirst_node(RangeTblEntry, lc);
-
-		if (rte->rtekind == RTE_SUBQUERY)
-			subqueryRTindexes = bms_add_member(subqueryRTindexes, rti);
-		rti++;
-	}
+	root->unexpanded_tlist = list_copy(root->parse->targetList);
+	tlist = preprocess_targetlist(root);
+	root->processed_tlist = tlist;
+	qp_extra.tlist = tlist;
+	qp_extra.activeWindows = NIL;
+	qp_extra.groupClause = NIL;
+	planned_rel = query_planner(root, tlist, standard_qp_callback, &qp_extra);
 
 	/*
-	 * Next, we want to identify which AppendRelInfo items contain references
-	 * to any of the aforesaid subquery RTEs.  These items will need to be
-	 * copied and modified to adjust their subquery references; whereas the
-	 * other ones need not be touched.  It's worth being tense over this
-	 * because we can usually avoid processing most of the AppendRelInfo
-	 * items, thereby saving O(N^2) space and time when the target is a large
-	 * inheritance tree.  We can identify AppendRelInfo items by their
-	 * child_relid, since that should be unique within the list.
+	 * If it turned out during query planning that all the children are dummy
+	 * (pruned or excluded by constraints), no need to do the steps below.
+	 * Let grouping_planner finish up the final path.
 	 */
-	modifiableARIindexes = NULL;
-	if (subqueryRTindexes != NULL)
+	if (IS_DUMMY_REL(planned_rel))
 	{
-		foreach(lc, root->append_rel_list)
-		{
-			AppendRelInfo *appinfo = lfirst_node(AppendRelInfo, lc);
-
-			if (bms_is_member(appinfo->parent_relid, subqueryRTindexes) ||
-				bms_is_member(appinfo->child_relid, subqueryRTindexes) ||
-				bms_overlap(pull_varnos((Node *) appinfo->translated_vars),
-							subqueryRTindexes))
-				modifiableARIindexes = bms_add_member(modifiableARIindexes,
-													  appinfo->child_relid);
-		}
+		grouping_planner(root, false, planned_rel, 0.0);
+		return;
 	}
 
+	Assert(planned_rel->relid == top_parentRTindex);
+	Assert(planned_rel->reloptkind == RELOPT_BASEREL);
+
 	/*
 	 * If the parent RTE is a partitioned table, we should use that as the
 	 * nominal target relation, because the RTEs added for partitioned tables
@@ -1255,7 +1261,7 @@ inheritance_planner(PlannerInfo *root)
 	 * not appear anywhere else in the plan, so the confusion explained below
 	 * for non-partitioning inheritance cases is not possible.
 	 */
-	parent_rte = rt_fetch(top_parentRTindex, root->parse->rtable);
+	parent_rte = planner_rt_fetch(top_parentRTindex, root);
 	if (parent_rte->relkind == RELKIND_PARTITIONED_TABLE)
 	{
 		nominalRelation = top_parentRTindex;
@@ -1263,95 +1269,39 @@ inheritance_planner(PlannerInfo *root)
 	}
 
 	/*
-	 * The PlannerInfo for each child is obtained by translating the relevant
-	 * members of the PlannerInfo for its immediate parent, which we find
-	 * using the parent_relid in its AppendRelInfo.  We save the PlannerInfo
-	 * for each parent in an array indexed by relid for fast retrieval. Since
-	 * the maximum number of parents is limited by the number of RTEs in the
-	 * query, we use that number to allocate the array. An extra entry is
-	 * needed since relids start from 1.
+	 * Get on with finalizing the path for each child target relation by
+	 * calling grouping_planner on its joinrel.
 	 */
-	parent_roots = (PlannerInfo **) palloc0((list_length(parse->rtable) + 1) *
-											sizeof(PlannerInfo *));
-	parent_roots[top_parentRTindex] = root;
-
-	/*
-	 * And now we can get on with generating a plan for each child table.
-	 */
-	foreach(lc, root->append_rel_list)
+	forboth(lc1, root->inh_target_child_rels,
+			lc2, root->inh_target_child_joinrels)
 	{
-		AppendRelInfo *appinfo = lfirst_node(AppendRelInfo, lc);
-		PlannerInfo *subroot;
+		Index		childRTindex = lfirst_int(lc1);
+		RelOptInfo *childjoinrel = lfirst(lc2);
+		PlannerInfo *subroot = root->inh_target_child_roots[childRTindex];
+		AppendRelInfo *appinfo = root->append_rel_array[childRTindex];
 		RangeTblEntry *child_rte;
 		RelOptInfo *sub_final_rel;
 		Path	   *subpath;
 
-		/* append_rel_list contains all append rels; ignore others */
-		if (!bms_is_member(appinfo->parent_relid, parent_relids))
-			continue;
-
-		/*
-		 * expand_inherited_rtentry() always processes a parent before any of
-		 * that parent's children, so the parent_root for this relation should
-		 * already be available.
-		 */
-		parent_root = parent_roots[appinfo->parent_relid];
-		Assert(parent_root != NULL);
-		parent_parse = parent_root->parse;
-
-		/*
-		 * We need a working copy of the PlannerInfo so that we can control
-		 * propagation of information back to the main copy.
-		 */
-		subroot = makeNode(PlannerInfo);
-		memcpy(subroot, parent_root, sizeof(PlannerInfo));
-
-		/*
-		 * Generate modified query with this rel as target.  We first apply
-		 * adjust_appendrel_attrs, which copies the Query and changes
-		 * references to the parent RTE to refer to the current child RTE,
-		 * then fool around with subquery RTEs.
-		 */
-		subroot->parse = (Query *)
-			adjust_appendrel_attrs(parent_root,
-								   (Node *) parent_parse,
-								   1, &appinfo);
+		Assert(subroot != NULL);
+		Assert(subroot->parse->resultRelation == childRTindex);
 
 		/*
 		 * If there are securityQuals attached to the parent, move them to the
 		 * child rel (they've already been transformed properly for that).
 		 */
-		parent_rte = rt_fetch(appinfo->parent_relid, subroot->parse->rtable);
-		child_rte = rt_fetch(appinfo->child_relid, subroot->parse->rtable);
+		parent_rte = planner_rt_fetch(appinfo->parent_relid, subroot);
+		child_rte = planner_rt_fetch(appinfo->child_relid, subroot);
 		child_rte->securityQuals = parent_rte->securityQuals;
 		parent_rte->securityQuals = NIL;
 
 		/*
-		 * Mark whether we're planning a query to a partitioned table or an
-		 * inheritance parent.
+		 * Ignore a partitioned child.  Instead, the paths of its children will
+		 * be added to subpaths.
 		 */
-		subroot->inhTargetKind =
-			(rootRelation != 0) ? INHKIND_PARTITIONED : INHKIND_INHERITED;
-
-		/*
-		 * If this child is further partitioned, remember it as a parent.
-		 * Since a partitioned table does not have any data, we don't need to
-		 * create a plan for it, and we can stop processing it here.  We do,
-		 * however, need to remember its modified PlannerInfo for use when
-		 * processing its children, since we'll update their varnos based on
-		 * the delta from immediate parent to child, not from top to child.
-		 *
-		 * Note: a very non-obvious point is that we have not yet added
-		 * duplicate subquery RTEs to the subroot's rtable.  We mustn't,
-		 * because then its children would have two sets of duplicates,
-		 * confusing matters.
-		 */
-		if (child_rte->inh)
+		if (childjoinrel->part_scheme)
 		{
-			Assert(child_rte->relkind == RELKIND_PARTITIONED_TABLE);
-			parent_relids = bms_add_member(parent_relids, appinfo->child_relid);
-			parent_roots[appinfo->child_relid] = subroot;
-
+			Assert(child_rte->inh);
 			continue;
 		}
 
@@ -1379,111 +1329,8 @@ inheritance_planner(PlannerInfo *root)
 		if (nominalRelation < 0)
 			nominalRelation = appinfo->child_relid;
 
-		/*
-		 * The rowMarks list might contain references to subquery RTEs, so
-		 * make a copy that we can apply ChangeVarNodes to.  (Fortunately, the
-		 * executor doesn't need to see the modified copies --- we can just
-		 * pass it the original rowMarks list.)
-		 */
-		subroot->rowMarks = copyObject(parent_root->rowMarks);
-
-		/*
-		 * The append_rel_list likewise might contain references to subquery
-		 * RTEs (if any subqueries were flattenable UNION ALLs).  So prepare
-		 * to apply ChangeVarNodes to that, too.  As explained above, we only
-		 * want to copy items that actually contain such references; the rest
-		 * can just get linked into the subroot's append_rel_list.
-		 *
-		 * If we know there are no such references, we can just use the outer
-		 * append_rel_list unmodified.
-		 */
-		if (modifiableARIindexes != NULL)
-		{
-			ListCell   *lc2;
-
-			subroot->append_rel_list = NIL;
-			foreach(lc2, parent_root->append_rel_list)
-			{
-				AppendRelInfo *appinfo2 = lfirst_node(AppendRelInfo, lc2);
-
-				if (bms_is_member(appinfo2->child_relid, modifiableARIindexes))
-					appinfo2 = copyObject(appinfo2);
-
-				subroot->append_rel_list = lappend(subroot->append_rel_list,
-												   appinfo2);
-			}
-		}
-
-		/*
-		 * Add placeholders to the child Query's rangetable list to fill the
-		 * RT indexes already reserved for subqueries in previous children.
-		 * These won't be referenced, so there's no need to make them very
-		 * valid-looking.
-		 */
-		while (list_length(subroot->parse->rtable) < list_length(final_rtable))
-			subroot->parse->rtable = lappend(subroot->parse->rtable,
-											 makeNode(RangeTblEntry));
-
-		/*
-		 * If this isn't the first child Query, generate duplicates of all
-		 * subquery RTEs, and adjust Var numbering to reference the
-		 * duplicates. To simplify the loop logic, we scan the original rtable
-		 * not the copy just made by adjust_appendrel_attrs; that should be OK
-		 * since subquery RTEs couldn't contain any references to the target
-		 * rel.
-		 */
-		if (final_rtable != NIL && subqueryRTindexes != NULL)
-		{
-			ListCell   *lr;
-
-			rti = 1;
-			foreach(lr, parent_parse->rtable)
-			{
-				RangeTblEntry *rte = lfirst_node(RangeTblEntry, lr);
-
-				if (bms_is_member(rti, subqueryRTindexes))
-				{
-					Index		newrti;
-
-					/*
-					 * The RTE can't contain any references to its own RT
-					 * index, except in its securityQuals, so we can save a
-					 * few cycles by applying ChangeVarNodes to the rest of
-					 * the rangetable before we append the RTE to it.
-					 */
-					newrti = list_length(subroot->parse->rtable) + 1;
-					ChangeVarNodes((Node *) subroot->parse, rti, newrti, 0);
-					ChangeVarNodes((Node *) subroot->rowMarks, rti, newrti, 0);
-					/* Skip processing unchanging parts of append_rel_list */
-					if (modifiableARIindexes != NULL)
-					{
-						ListCell   *lc2;
-
-						foreach(lc2, subroot->append_rel_list)
-						{
-							AppendRelInfo *appinfo2 = lfirst_node(AppendRelInfo, lc2);
-
-							if (bms_is_member(appinfo2->child_relid,
-											  modifiableARIindexes))
-								ChangeVarNodes((Node *) appinfo2, rti, newrti, 0);
-						}
-					}
-					rte = copyObject(rte);
-					ChangeVarNodes((Node *) rte->securityQuals, rti, newrti, 0);
-					subroot->parse->rtable = lappend(subroot->parse->rtable,
-													 rte);
-				}
-				rti++;
-			}
-		}
-
-		/* There shouldn't be any OJ info to translate, as yet */
-		Assert(subroot->join_info_list == NIL);
-		/* and we haven't created PlaceHolderInfos, either */
-		Assert(subroot->placeholder_list == NIL);
-
-		/* Generate Path(s) for accessing this result relation */
-		grouping_planner(subroot, true, 0.0 /* retrieve all tuples */ );
+		/* Apply the top-level targetlist to childjoinrel's path. */
+		grouping_planner(subroot, true, childjoinrel, 0.0);
 
 		/*
 		 * Select cheapest path in case there's more than one.  We always run
@@ -1495,45 +1342,10 @@ inheritance_planner(PlannerInfo *root)
 		subpath = sub_final_rel->cheapest_total_path;
 
 		/*
-		 * If this child rel was excluded by constraint exclusion, exclude it
-		 * from the result plan.
+		 * child rel cannot be empty, or inheritance_make_rel_from_joinlist
+		 * wouldn't have put it in the list to begin with.
 		 */
-		if (IS_DUMMY_PATH(subpath))
-			continue;
-
-		/*
-		 * If this is the first non-excluded child, its post-planning rtable
-		 * becomes the initial contents of final_rtable; otherwise, append
-		 * just its modified subquery RTEs to final_rtable.
-		 */
-		if (final_rtable == NIL)
-			final_rtable = subroot->parse->rtable;
-		else
-			final_rtable = list_concat(final_rtable,
-									   list_copy_tail(subroot->parse->rtable,
-													  list_length(final_rtable)));
-
-		/*
-		 * We need to collect all the RelOptInfos from all child plans into
-		 * the main PlannerInfo, since setrefs.c will need them.  We use the
-		 * last child's simple_rel_array (previous ones are too short), so we
-		 * have to propagate forward the RelOptInfos that were already built
-		 * in previous children.
-		 */
-		Assert(subroot->simple_rel_array_size >= save_rel_array_size);
-		for (rti = 1; rti < save_rel_array_size; rti++)
-		{
-			RelOptInfo *brel = save_rel_array[rti];
-
-			if (brel)
-				subroot->simple_rel_array[rti] = brel;
-		}
-		save_rel_array_size = subroot->simple_rel_array_size;
-		save_rel_array = subroot->simple_rel_array;
-		save_append_rel_array = subroot->append_rel_array;
-
-		/* Make sure any initplans from this rel get into the outer list */
-		root->init_plans = subroot->init_plans;
+		Assert(!IS_DUMMY_PATH(subpath));
 
 		/* Build list of sub-paths */
 		subpaths = lappend(subpaths, subpath);
@@ -1565,36 +1377,6 @@ inheritance_planner(PlannerInfo *root)
 	 */
 
 	/*
-	 * If we managed to exclude every child rel, return a dummy plan; it
-	 * doesn't even need a ModifyTable node.
-	 */
-	if (subpaths == NIL)
-	{
-		set_dummy_rel_pathlist(final_rel);
-		return;
-	}
-
-	/*
-	 * Put back the final adjusted rtable into the master copy of the Query.
-	 * (We mustn't do this if we found no non-excluded children.)
-	 */
-	parse->rtable = final_rtable;
-	root->simple_rel_array_size = save_rel_array_size;
-	root->simple_rel_array = save_rel_array;
-	root->append_rel_array = save_append_rel_array;
-
-	/* Must reconstruct master's simple_rte_array, too */
-	root->simple_rte_array = (RangeTblEntry **)
-		palloc0((list_length(final_rtable) + 1) * sizeof(RangeTblEntry *));
-	rti = 1;
-	foreach(lc, final_rtable)
-	{
-		RangeTblEntry *rte = lfirst_node(RangeTblEntry, lc);
-
-		root->simple_rte_array[rti++] = rte;
-	}
-
-	/*
 	 * If there was a FOR [KEY] UPDATE/SHARE clause, the LockRows node will
 	 * have dealt with fetching non-locked marked rows, else we need to have
 	 * ModifyTable do that.
@@ -1634,6 +1416,12 @@ inheritance_planner(PlannerInfo *root)
  * (inheritance_planner will create a single ModifyTable node covering all the
  * target tables.)
  *
+ * If non-NULL, planned_rel is a RelOptInfo containing paths for the query's
+ * top-level joinrel, which the caller produced by itself.  In that case, this
+ * function only needs to adjust the targetlist of its cheapest_total_path.
+ * The only caller that may pass such a RelOptInfo currently is
+ * inheritance_planner.
+ *
  * tuple_fraction is the fraction of tuples we expect will be retrieved.
  * tuple_fraction is interpreted as follows:
  *	  0: expect all tuples to be retrieved (normal case)
@@ -1652,6 +1440,7 @@ inheritance_planner(PlannerInfo *root)
  */
 static void
 grouping_planner(PlannerInfo *root, bool inheritance_update,
+				 RelOptInfo *planned_rel,
 				 double tuple_fraction)
 {
 	Query	   *parse = root->parse;
@@ -1664,7 +1453,7 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 	List	   *final_targets;
 	List	   *final_targets_contain_srfs;
 	bool		final_target_parallel_safe;
-	RelOptInfo *current_rel;
+	RelOptInfo *current_rel = planned_rel;
 	RelOptInfo *final_rel;
 	ListCell   *lc;
 
@@ -1704,6 +1493,7 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 		 * special work for recursive unions is the responsibility of
 		 * plan_set_operations.
 		 */
+		Assert(current_rel == NULL);
 		current_rel = plan_set_operations(root);
 
 		/*
@@ -1793,17 +1583,26 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 				parse->groupClause = preprocess_groupclause(root, NIL);
 		}
 
-		/* Preprocess targetlist */
-		tlist = preprocess_targetlist(root);
-
 		/*
-		 * We are now done hacking up the query's targetlist.  Most of the
-		 * remaining planning work will be done with the PathTarget
-		 * representation of tlists, but save aside the full representation so
-		 * that we can transfer its decoration (resnames etc) to the topmost
-		 * tlist of the finished Plan.
+		 * Preprocess targetlist, if needed.  If the caller has already done
+		 * query planning, root->processed_tlist already contains the desired
+		 * targetlist.
 		 */
-		root->processed_tlist = tlist;
+		if (planned_rel == NULL)
+		{
+			tlist = preprocess_targetlist(root);
+
+			/*
+			 * We are now done hacking up the query's targetlist.  Most of the
+			 * remaining planning work will be done with the PathTarget
+			 * representation of tlists, but save aside the full representation
+			 * so that we can transfer its decoration (resnames etc) to the
+			 * topmost tlist of the finished Plan.
+			 */
+			root->processed_tlist = tlist;
+		}
+		else
+			tlist = root->processed_tlist;
 
 		/*
 		 * Collect statistics about aggregates for estimating costs, and mark
@@ -1883,8 +1682,9 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 		 * We also generate (in standard_qp_callback) pathkey representations
 		 * of the query's sort clause, distinct clause, etc.
 		 */
-		current_rel = query_planner(root, tlist,
-									standard_qp_callback, &qp_extra);
+		if (current_rel == NULL)
+			current_rel = query_planner(root, tlist,
+										standard_qp_callback, &qp_extra);
 
 		/*
 		 * Convert the query's result tlist into PathTarget format.
diff --git a/src/backend/optimizer/prep/prepjointree.c b/src/backend/optimizer/prep/prepjointree.c
index 77dbf4eba3..87adfa02b1 100644
--- a/src/backend/optimizer/prep/prepjointree.c
+++ b/src/backend/optimizer/prep/prepjointree.c
@@ -917,7 +917,6 @@ pull_up_simple_subquery(PlannerInfo *root, Node *jtnode, RangeTblEntry *rte,
 	subroot->grouping_map = NULL;
 	subroot->minmax_aggs = NIL;
 	subroot->qual_security_level = 0;
-	subroot->inhTargetKind = INHKIND_NONE;
 	subroot->hasRecursion = false;
 	subroot->wt_param_id = -1;
 	subroot->non_recursive_path = NULL;
diff --git a/src/backend/optimizer/util/appendinfo.c b/src/backend/optimizer/util/appendinfo.c
index 37fbc3a117..0b9ca39a51 100644
--- a/src/backend/optimizer/util/appendinfo.c
+++ b/src/backend/optimizer/util/appendinfo.c
@@ -394,8 +394,39 @@ adjust_appendrel_attrs_mutator(Node *node,
 											  context->appinfos);
 		return (Node *) phv;
 	}
+
+	/*
+	 * This is needed, because inheritance_make_rel_from_joinlist needs to
+	 * translate root->join_info_list executing make_rel_from_joinlist for a
+	 * given child.
+	 */
+	if (IsA(node, SpecialJoinInfo))
+	{
+		SpecialJoinInfo *oldinfo = (SpecialJoinInfo *) node;
+		SpecialJoinInfo *newinfo = makeNode(SpecialJoinInfo);
+
+		memcpy(newinfo, oldinfo, sizeof(SpecialJoinInfo));
+		newinfo->min_lefthand = adjust_child_relids(oldinfo->min_lefthand,
+													context->nappinfos,
+													context->appinfos);
+		newinfo->min_righthand = adjust_child_relids(oldinfo->min_righthand,
+													 context->nappinfos,
+													 context->appinfos);
+		newinfo->syn_lefthand = adjust_child_relids(oldinfo->syn_lefthand,
+													context->nappinfos,
+													context->appinfos);
+		newinfo->syn_righthand = adjust_child_relids(oldinfo->syn_righthand,
+													 context->nappinfos,
+													 context->appinfos);
+		newinfo->semi_rhs_exprs =
+			(List *) expression_tree_mutator((Node *)
+											 oldinfo->semi_rhs_exprs,
+											 adjust_appendrel_attrs_mutator,
+											 (void *) context);
+		return (Node *) newinfo;
+	}
+
 	/* 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));
diff --git a/src/backend/optimizer/util/inherit.c b/src/backend/optimizer/util/inherit.c
index db474acbc5..0d2b42f72e 100644
--- a/src/backend/optimizer/util/inherit.c
+++ b/src/backend/optimizer/util/inherit.c
@@ -21,11 +21,14 @@
 #include "miscadmin.h"
 #include "optimizer/appendinfo.h"
 #include "optimizer/inherit.h"
+#include "optimizer/planmain.h"
 #include "optimizer/planner.h"
 #include "optimizer/prep.h"
 #include "utils/rel.h"
 
 
+static PlannerInfo *create_inherited_target_child_root(PlannerInfo *root,
+									AppendRelInfo *appinfo);
 static void expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte,
 						 Index rti);
 static void expand_partitioned_rtentry(PlannerInfo *root,
@@ -492,3 +495,109 @@ translate_col_privs(const Bitmapset *parent_privs,
 
 	return child_privs;
 }
+
+/*
+ * add_inherited_target_child_roots
+ *		For each child of of the query's result relation, this translates the
+ *		original query to match the child and creates a PlannerInfo containing
+ *		the translated query
+ *
+ * Child PlannerInfo reuses most of the parent PlannerInfo's fields unchanged,
+ * except unexpanded_tlist, processed_tlist, and all_baserels, all of which
+ * are based on the child relation.
+ */
+void
+add_inherited_target_child_roots(PlannerInfo *root)
+{
+	Index		resultRelation = root->parse->resultRelation;
+	ListCell   *lc;
+
+	Assert(root->inh_target_child_roots != NULL);
+
+	foreach(lc, root->append_rel_list)
+	{
+		AppendRelInfo *appinfo = lfirst(lc);
+		RangeTblEntry *childRTE;
+		PlannerInfo   *subroot;
+
+		if (appinfo->parent_relid != resultRelation)
+			continue;
+
+		/*
+		 * Create a PlannerInfo for processing this child target relation
+		 * with.
+		 */
+		subroot = create_inherited_target_child_root(root, appinfo);
+		root->inh_target_child_roots[appinfo->child_relid] = subroot;
+
+		/*
+		 * If the child is a partitioned table, recurse to do this for its
+		 * partitions.
+		 */
+		childRTE = root->simple_rte_array[appinfo->child_relid];
+		if (childRTE->inh)
+			add_inherited_target_child_roots(subroot);
+	}
+}
+
+/*
+ * create_inherited_target_child_root
+ *		Workhorse of add_inherited_target_child_roots
+ */
+static PlannerInfo *
+create_inherited_target_child_root(PlannerInfo *root, AppendRelInfo *appinfo)
+{
+	PlannerInfo *subroot;
+	List	   *tlist;
+
+	Assert(root->parse->commandType == CMD_UPDATE ||
+		   root->parse->commandType == CMD_DELETE);
+
+	/*
+	 * Translate the original query to replace Vars of the parent table
+	 * by the corresponding Vars of the child table and to make child the main
+	 * target relation of the query.
+	 */
+	subroot = makeNode(PlannerInfo);
+	memcpy(subroot, root, sizeof(PlannerInfo));
+
+	/*
+	 * Restore the original, unexpanded targetlist, that is, the one before
+	 * preprocess_targetlist was run on the original query.  We'll run
+	 * preprocess_targetlist after translating the query and the targetlist,
+	 * so that it is expanded according to child's tuple descriptor.
+	 */
+	root->parse->targetList = root->unexpanded_tlist;
+	subroot->parse = (Query *) adjust_appendrel_attrs(root,
+													  (Node *) root->parse,
+													  1, &appinfo);
+
+	/* Save the just translated targetlist as unexpanded_tlist in the child's
+	 * subroot, so that this child's own children can use it.  Must use copy
+	 * because subroot->parse->targetList will be modified soon.
+	 */
+	subroot->unexpanded_tlist = list_copy(subroot->parse->targetList);
+
+	/*
+	 * Apply planner's expansion of targetlist, such as adding various junk
+	 * column, filling placeholder entries for dropped columns, etc., all of
+	 * which occurs with the child's TupleDesc.
+	 */
+	tlist = preprocess_targetlist(subroot);
+	subroot->processed_tlist = tlist;
+
+	/* Add any newly added Vars to the child RelOptInfo. */
+	build_base_rel_tlists(subroot, tlist);
+
+	/*
+	 * Adjust all_baserels to replace the original target relation with the
+	 * child target relation.  Copy it before modifying though.
+	 */
+	subroot->all_baserels = bms_copy(root->all_baserels);
+	subroot->all_baserels = bms_del_member(subroot->all_baserels,
+										   root->parse->resultRelation);
+	subroot->all_baserels = bms_add_member(subroot->all_baserels,
+										   subroot->parse->resultRelation);
+
+	return subroot;
+}
diff --git a/src/backend/optimizer/util/plancat.c b/src/backend/optimizer/util/plancat.c
index 48ffc5f254..6009de309e 100644
--- a/src/backend/optimizer/util/plancat.c
+++ b/src/backend/optimizer/util/plancat.c
@@ -1264,36 +1264,6 @@ get_relation_constraints(PlannerInfo *root,
 		}
 	}
 
-	/*
-	 * Append partition predicates, if any.
-	 *
-	 * For selects, partition pruning uses the parent table's partition bound
-	 * descriptor, instead of constraint exclusion which is driven by the
-	 * individual partition's partition constraint.
-	 */
-	if (enable_partition_pruning && root->parse->commandType != CMD_SELECT)
-	{
-		List	   *pcqual = RelationGetPartitionQual(relation);
-
-		if (pcqual)
-		{
-			/*
-			 * Run the partition quals through const-simplification similar to
-			 * check constraints.  We skip canonicalize_qual, though, because
-			 * partition quals should be in canonical form already; also,
-			 * since the qual is in implicit-AND format, we'd have to
-			 * explicitly convert it to explicit-AND format and back again.
-			 */
-			pcqual = (List *) eval_const_expressions(root, (Node *) pcqual);
-
-			/* Fix Vars to have the desired varno */
-			if (varno != 1)
-				ChangeVarNodes((Node *) pcqual, 1, varno, 0);
-
-			result = list_concat(result, pcqual);
-		}
-	}
-
 	heap_close(relation, NoLock);
 
 	return result;
@@ -1417,40 +1387,15 @@ relation_excluded_by_constraints(PlannerInfo *root,
 	/*
 	 * Skip further tests, depending on constraint_exclusion.
 	 */
-	switch (constraint_exclusion)
-	{
-		case CONSTRAINT_EXCLUSION_OFF:
-
-			/*
-			 * Don't prune if feature turned off -- except if the relation is
-			 * a partition.  While partprune.c-style partition pruning is not
-			 * yet in use for all cases (update/delete is not handled), it
-			 * would be a UI horror to use different user-visible controls
-			 * depending on such a volatile implementation detail.  Therefore,
-			 * for partitioned tables we use enable_partition_pruning to
-			 * control this behavior.
-			 */
-			if (root->inhTargetKind == INHKIND_PARTITIONED)
-				break;
-			return false;
-
-		case CONSTRAINT_EXCLUSION_PARTITION:
-
-			/*
-			 * When constraint_exclusion is set to 'partition' we only handle
-			 * OTHER_MEMBER_RELs, or BASERELs in cases where the result target
-			 * is an inheritance parent or a partitioned table.
-			 */
-			if ((rel->reloptkind != RELOPT_OTHER_MEMBER_REL) &&
-				!(rel->reloptkind == RELOPT_BASEREL &&
-				  root->inhTargetKind != INHKIND_NONE &&
-				  rel->relid == root->parse->resultRelation))
-				return false;
-			break;
-
-		case CONSTRAINT_EXCLUSION_ON:
-			break;				/* always try to exclude */
-	}
+	if (constraint_exclusion == CONSTRAINT_EXCLUSION_OFF)
+		return false;
+	/*
+	 * When constraint_exclusion is set to 'partition' we only handle
+	 * OTHER_MEMBER_RELs.
+	 */
+	else if (constraint_exclusion == CONSTRAINT_EXCLUSION_PARTITION &&
+			 rel->reloptkind != RELOPT_OTHER_MEMBER_REL)
+		return false;
 
 	/*
 	 * Check for self-contradictory restriction clauses.  We dare not make
diff --git a/src/include/nodes/relation.h b/src/include/nodes/relation.h
index 3430061361..beb2e323a8 100644
--- a/src/include/nodes/relation.h
+++ b/src/include/nodes/relation.h
@@ -319,9 +319,6 @@ typedef struct PlannerInfo
 	Index		qual_security_level;	/* minimum security_level for quals */
 	/* Note: qual_security_level is zero if there are no securityQuals */
 
-	InheritanceKind inhTargetKind;	/* indicates if the target relation is an
-									 * inheritance child or partition or a
-									 * partitioned table */
 	bool		hasJoinRTEs;	/* true if any RTEs are RTE_JOIN kind */
 	bool		hasLateralRTEs; /* true if any RTEs are marked LATERAL */
 	bool		hasDeletedRTEs; /* true if any RTE was deleted from jointree */
@@ -343,6 +340,40 @@ typedef struct PlannerInfo
 
 	/* Does this query modify any partition key columns? */
 	bool		partColsUpdated;
+
+	/*
+	 * The following fields are set during query planning portion of an
+	 * inherited UPDATE/DEELETE operation.
+	 */
+	bool		inherited_update;	/* UPDATE/DELETE on inheritance parent? */
+
+	/*
+	 * This stores the original version of the query's targetlist that's
+	 * not modified by the planner.
+	 */
+	List	   *unexpanded_tlist;
+
+	/*
+	 * Array containing simple_rel_array_size elements, indexed by rangetable
+	 * index (entry 0 is wasted like simple_rel_array).  Only elements
+	 * corresponding to individual inheritance child target relations are
+	 * non-NULL.  Content of each PlannerInfo is same as the parent
+	 * PlannerInfo, except for the parse tree which is a translated copy of
+	 * the parent's parse tree.
+	 */
+	struct PlannerInfo **inh_target_child_roots;
+
+	/* List of RT indexes of child RT indexes. */
+	List	   *inh_target_child_rels;
+
+	/*
+	 * RelOptInfos corresponding to each child target rel.  For leaf children,
+	 * it's the RelOptInfo representing the output of make_rel_from_joinlist()
+	 * called with the parent rel in the original join tree replaced by a
+	 * given leaf child.  For non-leaf children, it's the baserel RelOptInfo
+	 * itself, left as a placeholder.
+	 */
+	List	   *inh_target_child_joinrels;
 } PlannerInfo;
 
 
diff --git a/src/include/optimizer/inherit.h b/src/include/optimizer/inherit.h
index b2687abd4e..1dbc2ca5bf 100644
--- a/src/include/optimizer/inherit.h
+++ b/src/include/optimizer/inherit.h
@@ -18,5 +18,6 @@
 
 
 extern void expand_inherited_tables(PlannerInfo *root);
+extern void add_inherited_target_child_roots(PlannerInfo *root);
 
 #endif							/* INHERIT_H */
diff --git a/src/include/optimizer/paths.h b/src/include/optimizer/paths.h
index 666217c189..f524ab6beb 100644
--- a/src/include/optimizer/paths.h
+++ b/src/include/optimizer/paths.h
@@ -161,7 +161,8 @@ extern EquivalenceClass *match_eclasses_to_foreign_key_col(PlannerInfo *root,
 extern void add_child_rel_equivalences(PlannerInfo *root,
 						   AppendRelInfo *appinfo,
 						   RelOptInfo *parent_rel,
-						   RelOptInfo *child_rel);
+						   RelOptInfo *child_rel,
+						   bool replace);
 extern List *generate_implied_equalities_for_column(PlannerInfo *root,
 									   RelOptInfo *rel,
 									   ec_matches_callback_type callback,
diff --git a/src/test/regress/expected/partition_join.out b/src/test/regress/expected/partition_join.out
index c55de5d476..c9f02c1fb0 100644
--- a/src/test/regress/expected/partition_join.out
+++ b/src/test/regress/expected/partition_join.out
@@ -1780,7 +1780,7 @@ WHERE EXISTS (
                Filter: (c IS NULL)
          ->  Nested Loop
                ->  Seq Scan on int4_tbl
-               ->  Subquery Scan on ss_1
+               ->  Subquery Scan on ss
                      ->  Limit
                            ->  Seq Scan on int8_tbl int8_tbl_1
    ->  Nested Loop Semi Join
@@ -1788,7 +1788,7 @@ WHERE EXISTS (
                Filter: (c IS NULL)
          ->  Nested Loop
                ->  Seq Scan on int4_tbl
-               ->  Subquery Scan on ss_2
+               ->  Subquery Scan on ss
                      ->  Limit
                            ->  Seq Scan on int8_tbl int8_tbl_2
 (28 rows)
-- 
2.11.0

From abdaaca3ce8ec87809440e0650cbdaf25b4bbc99 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Fri, 26 Oct 2018 16:45:59 +0900
Subject: [PATCH v14 3/6] Store inheritance root parent index in otherrel's
 RelOptInfo

Although it's set by build_simple_rel, it's not being used by any
code yet.
---
 src/backend/nodes/outfuncs.c         |  1 +
 src/backend/optimizer/util/relnode.c | 15 +++++++++++++--
 src/include/nodes/relation.h         |  9 +++++++++
 3 files changed, 23 insertions(+), 2 deletions(-)

diff --git a/src/backend/nodes/outfuncs.c b/src/backend/nodes/outfuncs.c
index 158da68925..67697b8884 100644
--- a/src/backend/nodes/outfuncs.c
+++ b/src/backend/nodes/outfuncs.c
@@ -2272,6 +2272,7 @@ _outRelOptInfo(StringInfo str, const RelOptInfo *node)
 	WRITE_BOOL_FIELD(consider_partitionwise_join);
 	WRITE_BITMAPSET_FIELD(top_parent_relids);
 	WRITE_NODE_FIELD(partitioned_child_rels);
+	WRITE_UINT_FIELD(inh_root_parent);
 }
 
 static void
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index fe83ec4519..45f9950935 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -195,6 +195,7 @@ build_simple_rel(PlannerInfo *root, int relid, RelOptInfo *parent)
 	rel->joininfo = NIL;
 	rel->has_eclass_joins = false;
 	rel->consider_partitionwise_join = false; /* might get changed later */
+	rel->top_parent_relids = NULL; /* might be changed later */
 	rel->part_scheme = NULL;
 	rel->nparts = 0;
 	rel->boundinfo = NULL;
@@ -203,6 +204,7 @@ build_simple_rel(PlannerInfo *root, int relid, RelOptInfo *parent)
 	rel->partexprs = NULL;
 	rel->nullable_partexprs = NULL;
 	rel->partitioned_child_rels = NIL;
+	rel->inh_root_parent = 0; /* might be changed later */
 
 	/*
 	 * Pass top parent's relids down the inheritance hierarchy. If the parent
@@ -216,9 +218,18 @@ build_simple_rel(PlannerInfo *root, int relid, RelOptInfo *parent)
 			rel->top_parent_relids = parent->top_parent_relids;
 		else
 			rel->top_parent_relids = bms_copy(parent->relids);
+
+		/*
+		 * For inheritance child relations, we also set inh_root_parent.
+		 * Note that 'parent' might itself be a child (a sub-partitioned
+		 * partition), in which case we simply use its value of
+		 * inh_root_parent.
+		 */
+		if (parent->rtekind == RTE_RELATION)
+			rel->inh_root_parent = parent->inh_root_parent > 0 ?
+										parent->inh_root_parent :
+										parent->relid;
 	}
-	else
-		rel->top_parent_relids = NULL;
 
 	/* Check type of rtable entry */
 	switch (rte->rtekind)
diff --git a/src/include/nodes/relation.h b/src/include/nodes/relation.h
index beb2e323a8..db439bd904 100644
--- a/src/include/nodes/relation.h
+++ b/src/include/nodes/relation.h
@@ -734,6 +734,15 @@ typedef struct RelOptInfo
 	List	  **partexprs;		/* Non-nullable partition key expressions. */
 	List	  **nullable_partexprs; /* Nullable partition key expressions. */
 	List	   *partitioned_child_rels; /* List of RT indexes. */
+
+	/*
+	 * For inheritance children, this is the RT index of inheritance table
+	 * mentioned in the query from which this relation originated.
+	 * top_parent_relids cannot be used for this, because if the inheritance
+	 * root table is itself under UNION ALL, top_parent_relids contains the
+	 * RT index of UNION ALL parent subquery.
+	 */
+	Index		inh_root_parent;
 } RelOptInfo;
 
 /*
-- 
2.11.0

From 0525aff10c5752dc4ee661bc538562cb313e8979 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Wed, 17 Oct 2018 18:14:13 +0900
Subject: [PATCH v14 4/6] Lazy creation of RTEs for inheritance children

Currently, expand_inherited_tables called from subquery_planner opens
all inheritance child tables and adds them to the query's range
table and PlannerInfo in the form of AppendRelInfo's initially and
later RelOptInfo's.  For partitioning, that's pretty wasteful, because
it's possible to determine only the partitions that will need to be
scanned using partition pruning, which doesn't require opening the
partitions themselves.  However, the point at which the above
processing happens is too early to perform partition pruning.

This commit rearranges things within the planner so that inheritance
child relations can be added to the Query and PlannerInfo during
make_one_rel, just before set_base_rel_sizes is called.  Although the
late initialization approach only benefits the partitioning case, it
seems undesirable to do it only for partitioned tables, because it
means adding code to handle partitions specially at various places
within the planner.  So, *all* inheritance parent tables are expanded
in make_one_rel.  All unpruned partitions are added to Query in the
form of their RangeTblEntry's being added to the range table and to
PlannerInfo in the form of an AppendRelInfo and a RelOptInfo for each.

For partitioning, although we don't create a RangeTblEntry and
RelOptInfo for pruned partitions at make_one_rel time, partitionwise
join code relies on the fact that even though partitions may have
been pruned, they'd still own a RelOptInfo to handle the outer join
case where the pruned partition appears on the nullable side of join.
Partitionwise join code deals with that by allocating dummy
RelOptInfos for pruned partitions that are based mostly on their
parent's properties.

There are some regression test diffs:

 1. Caused by the fact that we no longer allocate a duplicate RT
    entry for a partitioned table in its role as child, as seen in
    the partition_aggregate.out test output.

 2. Those in postgres_fdw.out are caused by the fact that junk columns
    required for row marking are added to reltarget->exprs later than
    user columns, because the row marking junk columns arent added
    until after the inheritance is expanded which as of this commit
    is later than it used to be.
---
 contrib/postgres_fdw/expected/postgres_fdw.out    |  32 +-
 src/backend/optimizer/path/allpaths.c             | 372 ++--------
 src/backend/optimizer/path/joinrels.c             |  61 ++
 src/backend/optimizer/plan/initsplan.c            |  58 --
 src/backend/optimizer/plan/planmain.c             |  10 +
 src/backend/optimizer/plan/planner.c              |  74 +-
 src/backend/optimizer/plan/setrefs.c              |   6 +
 src/backend/optimizer/prep/preptlist.c            |  15 +-
 src/backend/optimizer/prep/prepunion.c            |   3 +
 src/backend/optimizer/util/appendinfo.c           |  45 +-
 src/backend/optimizer/util/inherit.c              | 817 +++++++++++++++-------
 src/backend/optimizer/util/plancat.c              |  47 +-
 src/backend/optimizer/util/relnode.c              |  84 +--
 src/backend/partitioning/partprune.c              |  43 +-
 src/include/nodes/relation.h                      |   9 +
 src/include/optimizer/appendinfo.h                |   7 +-
 src/include/optimizer/pathnode.h                  |   1 +
 src/include/optimizer/plancat.h                   |   4 +-
 src/include/optimizer/prep.h                      |   3 +-
 src/include/partitioning/partprune.h              |   2 +-
 src/test/regress/expected/partition_aggregate.out |   4 +-
 21 files changed, 913 insertions(+), 784 deletions(-)

diff --git a/contrib/postgres_fdw/expected/postgres_fdw.out b/contrib/postgres_fdw/expected/postgres_fdw.out
index bb92d9d37a..33a33606ef 100644
--- a/contrib/postgres_fdw/expected/postgres_fdw.out
+++ b/contrib/postgres_fdw/expected/postgres_fdw.out
@@ -7072,15 +7072,15 @@ select * from bar where f1 in (select f1 from foo) for update;
                      Output: bar2.f1, bar2.f2, bar2.ctid, bar2.*, bar2.tableoid
                      Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct2 FOR UPDATE
          ->  Hash
-               Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+               Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                ->  HashAggregate
-                     Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                     Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                      Group Key: foo.f1
                      ->  Append
                            ->  Seq Scan on public.foo
-                                 Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                                 Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                            ->  Foreign Scan on public.foo2
-                                 Output: foo2.ctid, foo2.*, foo2.tableoid, foo2.f1
+                                 Output: foo2.f1, foo2.ctid, foo2.*, foo2.tableoid
                                  Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct1
 (23 rows)
 
@@ -7110,15 +7110,15 @@ select * from bar where f1 in (select f1 from foo) for share;
                      Output: bar2.f1, bar2.f2, bar2.ctid, bar2.*, bar2.tableoid
                      Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct2 FOR SHARE
          ->  Hash
-               Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+               Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                ->  HashAggregate
-                     Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                     Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                      Group Key: foo.f1
                      ->  Append
                            ->  Seq Scan on public.foo
-                                 Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                                 Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                            ->  Foreign Scan on public.foo2
-                                 Output: foo2.ctid, foo2.*, foo2.tableoid, foo2.f1
+                                 Output: foo2.f1, foo2.ctid, foo2.*, foo2.tableoid
                                  Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct1
 (23 rows)
 
@@ -7147,15 +7147,15 @@ update bar set f2 = f2 + 100 where f1 in (select f1 from foo);
          ->  Seq Scan on public.bar
                Output: bar.f1, bar.f2, bar.ctid
          ->  Hash
-               Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+               Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                ->  HashAggregate
-                     Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                     Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                      Group Key: foo.f1
                      ->  Append
                            ->  Seq Scan on public.foo
-                                 Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                                 Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                            ->  Foreign Scan on public.foo2
-                                 Output: foo2.ctid, foo2.*, foo2.tableoid, foo2.f1
+                                 Output: foo2.f1, foo2.ctid, foo2.*, foo2.tableoid
                                  Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct1
    ->  Hash Join
          Output: bar2.f1, (bar2.f2 + 100), bar2.f3, bar2.ctid, foo.ctid, foo.*, foo.tableoid
@@ -7165,15 +7165,15 @@ update bar set f2 = f2 + 100 where f1 in (select f1 from foo);
                Output: bar2.f1, bar2.f2, bar2.f3, bar2.ctid
                Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct2 FOR UPDATE
          ->  Hash
-               Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+               Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                ->  HashAggregate
-                     Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                     Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                      Group Key: foo.f1
                      ->  Append
                            ->  Seq Scan on public.foo
-                                 Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                                 Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                            ->  Foreign Scan on public.foo2
-                                 Output: foo2.ctid, foo2.*, foo2.tableoid, foo2.f1
+                                 Output: foo2.f1, foo2.ctid, foo2.*, foo2.tableoid
                                  Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct1
 (39 rows)
 
diff --git a/src/backend/optimizer/path/allpaths.c b/src/backend/optimizer/path/allpaths.c
index 3324d485e4..042d6b2b0d 100644
--- a/src/backend/optimizer/path/allpaths.c
+++ b/src/backend/optimizer/path/allpaths.c
@@ -45,7 +45,6 @@
 #include "optimizer/var.h"
 #include "parser/parse_clause.h"
 #include "parser/parsetree.h"
-#include "partitioning/partprune.h"
 #include "rewrite/rewriteManip.h"
 #include "utils/lsyscache.h"
 
@@ -383,6 +382,14 @@ set_rel_size(PlannerInfo *root, RelOptInfo *rel,
 	else if (rte->inh)
 	{
 		/*
+		 * expand_inherited_tables may have proved that the relation is empty.
+		 * For example, if it's a partitioned table with 0 partitions or all
+		 * of its partitions are pruned.  In that case nothing to do here.
+		 */
+		if (IS_DUMMY_REL(rel))
+			return;
+
+		/*
 		 * If it's a target relation, set the sizes of children instead.
 		 * Otherwise, we'll append the outputs of children, so process it as
 		 * an "append relation".
@@ -951,38 +958,18 @@ set_inherit_target_rel_sizes(PlannerInfo *root, RelOptInfo *rel,
 	int			parentRTindex = rti;
 	bool		has_live_children;
 	ListCell   *l;
-	Relids		live_children = NULL;
-	bool		did_pruning = false;
 
 	/* Guard against stack overflow due to overly deep inheritance tree. */
 	check_stack_depth();
 
 	Assert(IS_SIMPLE_REL(rel));
 
-	/*
-	 * If the partitioned relation has any baserestrictinfo quals then we
-	 * attempt to use these quals to prune away partitions that cannot
-	 * possibly contain any tuples matching these quals.  In this case we'll
-	 * store the relids of all partitions which could possibly contain a
-	 * matching tuple, and skip anything else in the loop below.
-	 */
-	if (enable_partition_pruning &&
-		rte->relkind == RELKIND_PARTITIONED_TABLE &&
-		rel->baserestrictinfo != NIL)
-	{
-		live_children = prune_append_rel_partitions(rel);
-		did_pruning = true;
-	}
-
 	foreach(l, root->append_rel_list)
 	{
 		AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(l);
 		int			childRTindex;
 		RangeTblEntry *childRTE;
 		RelOptInfo *childrel;
-		List	   *childquals;
-		Index		cq_min_security;
-		bool		have_const_false_cq;
 		PlannerInfo *subroot;
 		ListCell   *lc;
 		List	   *translated_exprs,
@@ -994,141 +981,22 @@ set_inherit_target_rel_sizes(PlannerInfo *root, RelOptInfo *rel,
 
 		childRTindex = appinfo->child_relid;
 		childRTE = root->simple_rte_array[childRTindex];
+		Assert(childRTE != NULL);
 
 		/*
-		 * The child rel's RelOptInfo was already created during
-		 * add_base_rels_to_query.
+		 * The child rel's RelOptInfo was created during
+		 * expand_inherited_tables().
 		 */
 		childrel = find_base_rel(root, childRTindex);
+		Assert(childrel != NULL);
 		Assert(childrel->reloptkind == RELOPT_OTHER_MEMBER_REL);
 
 		/*
-		 * We have to copy the parent's quals to the child, with appropriate
-		 * substitution of variables.  However, only the baserestrictinfo
-		 * quals are needed before we can check for constraint exclusion; so
-		 * do that first and then check to see if we can disregard this child.
-		 *
-		 * The child rel's targetlist might contain non-Var expressions, which
-		 * means that substitution into the quals could produce opportunities
-		 * for const-simplification, and perhaps even pseudoconstant quals.
-		 * Therefore, transform each RestrictInfo separately to see if it
-		 * reduces to a constant or pseudoconstant.  (We must process them
-		 * separately to keep track of the security level of each qual.)
+		 * Child relation may have been marked dummy if build_append_child_rel
+		 * found self-contradictory quals.
 		 */
-		childquals = NIL;
-		cq_min_security = UINT_MAX;
-		have_const_false_cq = false;
-		foreach(lc, rel->baserestrictinfo)
-		{
-			RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
-			Node	   *childqual;
-			ListCell   *lc2;
-
-			Assert(IsA(rinfo, RestrictInfo));
-			childqual = adjust_appendrel_attrs(root,
-											   (Node *) rinfo->clause,
-											   1, &appinfo);
-			childqual = eval_const_expressions(root, childqual);
-			/* check for flat-out constant */
-			if (childqual && IsA(childqual, Const))
-			{
-				if (((Const *) childqual)->constisnull ||
-					!DatumGetBool(((Const *) childqual)->constvalue))
-				{
-					/* Restriction reduces to constant FALSE or NULL */
-					have_const_false_cq = true;
-					break;
-				}
-				/* Restriction reduces to constant TRUE, so drop it */
-				continue;
-			}
-			/* might have gotten an AND clause, if so flatten it */
-			foreach(lc2, make_ands_implicit((Expr *) childqual))
-			{
-				Node	   *onecq = (Node *) lfirst(lc2);
-				bool		pseudoconstant;
-
-				/* check for pseudoconstant (no Vars or volatile functions) */
-				pseudoconstant =
-					!contain_vars_of_level(onecq, 0) &&
-					!contain_volatile_functions(onecq);
-				if (pseudoconstant)
-				{
-					/* tell createplan.c to check for gating quals */
-					root->hasPseudoConstantQuals = true;
-				}
-				/* reconstitute RestrictInfo with appropriate properties */
-				childquals = lappend(childquals,
-									 make_restrictinfo((Expr *) onecq,
-													   rinfo->is_pushed_down,
-													   rinfo->outerjoin_delayed,
-													   pseudoconstant,
-													   rinfo->security_level,
-													   NULL, NULL, NULL));
-				/* track minimum security level among child quals */
-				cq_min_security = Min(cq_min_security, rinfo->security_level);
-			}
-		}
-
-		/*
-		 * In addition to the quals inherited from the parent, we might have
-		 * securityQuals associated with this particular child node.
-		 * (Currently this can only happen in appendrels originating from
-		 * UNION ALL; inheritance child tables don't have their own
-		 * securityQuals, see expand_inherited_rtentry().)	Pull any such
-		 * securityQuals up into the baserestrictinfo for the child.  This is
-		 * similar to process_security_barrier_quals() for the parent rel,
-		 * except that we can't make any general deductions from such quals,
-		 * since they don't hold for the whole appendrel.
-		 */
-		if (childRTE->securityQuals)
-		{
-			Index		security_level = 0;
-
-			foreach(lc, childRTE->securityQuals)
-			{
-				List	   *qualset = (List *) lfirst(lc);
-				ListCell   *lc2;
-
-				foreach(lc2, qualset)
-				{
-					Expr	   *qual = (Expr *) lfirst(lc2);
-
-					/* not likely that we'd see constants here, so no check */
-					childquals = lappend(childquals,
-										 make_restrictinfo(qual,
-														   true, false, false,
-														   security_level,
-														   NULL, NULL, NULL));
-					cq_min_security = Min(cq_min_security, security_level);
-				}
-				security_level++;
-			}
-			Assert(security_level <= root->qual_security_level);
-		}
-
-		/*
-		 * OK, we've got all the baserestrictinfo quals for this child.
-		 */
-		childrel->baserestrictinfo = childquals;
-		childrel->baserestrict_min_security = cq_min_security;
-
-		if (have_const_false_cq)
-		{
-			/*
-			 * Some restriction clause reduced to constant FALSE or NULL after
-			 * substitution, so this child need not be scanned.
-			 */
-			set_dummy_rel_pathlist(childrel);
+		if (IS_DUMMY_REL(childrel))
 			continue;
-		}
-
-		if (did_pruning && !bms_is_member(appinfo->child_relid, live_children))
-		{
-			/* This partition was pruned; skip it. */
-			set_dummy_rel_pathlist(childrel);
-			continue;
-		}
 
 		if (relation_excluded_by_constraints(root, childrel, childRTE))
 		{
@@ -1181,15 +1049,9 @@ set_inherit_target_rel_sizes(PlannerInfo *root, RelOptInfo *rel,
 				EquivalenceClass *new_ec = makeNode(EquivalenceClass);
 
 				/*
-				 * First memcpy which creates shallow copies of all
-				 * the members and then make copies of members that could
-				 * change.
-				 *
-				 * XXX comment in _copyPathKey says it's OK to recycle EC
-				 * pointers, but as long as we do the whole planning for a
-				 * given child using a given root, copying ECs like this
-				 * shouldn't be a problem.  Maybe, the following code could
-				 * be in _copyEquivalenceClass()?
+				 * First memcpy the original EC, which creates shallow copies
+				 * of all the members and then make copies of members that
+				 * might change during add_child_rel_equivalences().
 				 */
 				memcpy(new_ec, ec, sizeof(EquivalenceClass));
 				new_ec->ec_opfamilies = list_copy(ec->ec_opfamilies);
@@ -1332,8 +1194,6 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 	double	   *parent_attrsizes;
 	int			nattrs;
 	ListCell   *l;
-	Relids		live_children = NULL;
-	bool		did_pruning = false;
 
 	/* Guard against stack overflow due to overly deep inheritance tree. */
 	check_stack_depth();
@@ -1341,32 +1201,6 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 	Assert(IS_SIMPLE_REL(rel));
 
 	/*
-	 * Initialize partitioned_child_rels to contain this RT index.
-	 *
-	 * Note that during the set_append_rel_pathlist() phase, we will bubble up
-	 * the indexes of partitioned relations that appear down in the tree, so
-	 * that when we've created Paths for all the children, the root
-	 * partitioned table's list will contain all such indexes.
-	 */
-	if (rte->relkind == RELKIND_PARTITIONED_TABLE)
-		rel->partitioned_child_rels = list_make1_int(rti);
-
-	/*
-	 * If the partitioned relation has any baserestrictinfo quals then we
-	 * attempt to use these quals to prune away partitions that cannot
-	 * possibly contain any tuples matching these quals.  In this case we'll
-	 * store the relids of all partitions which could possibly contain a
-	 * matching tuple, and skip anything else in the loop below.
-	 */
-	if (enable_partition_pruning &&
-		rte->relkind == RELKIND_PARTITIONED_TABLE &&
-		rel->baserestrictinfo != NIL)
-	{
-		live_children = prune_append_rel_partitions(rel);
-		did_pruning = true;
-	}
-
-	/*
 	 * If this is a partitioned baserel, set the consider_partitionwise_join
 	 * flag; currently, we only consider partitionwise joins with the baserel
 	 * if its targetlist doesn't contain a whole-row Var.
@@ -1403,12 +1237,8 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 		int			childRTindex;
 		RangeTblEntry *childRTE;
 		RelOptInfo *childrel;
-		List	   *childquals;
-		Index		cq_min_security;
-		bool		have_const_false_cq;
 		ListCell   *parentvars;
 		ListCell   *childvars;
-		ListCell   *lc;
 
 		/* append_rel_list contains all append rels; ignore others */
 		if (appinfo->parent_relid != parentRTindex)
@@ -1416,18 +1246,35 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 
 		childRTindex = appinfo->child_relid;
 		childRTE = root->simple_rte_array[childRTindex];
+		Assert(childRTE != NULL);
 
 		/*
-		 * The child rel's RelOptInfo was already created during
-		 * add_base_rels_to_query.
+		 * The child rel's RelOptInfo was created during
+		 * expand_inherited_tables().
 		 */
 		childrel = find_base_rel(root, childRTindex);
+		Assert(childrel != NULL);
 		Assert(childrel->reloptkind == RELOPT_OTHER_MEMBER_REL);
 
 		/*
-		 * Copy/Modify targetlist. Even if this child is deemed empty, we need
-		 * its targetlist in case it falls on nullable side in a child-join
-		 * because of partitionwise join.
+		 * Child relation may have been marked dummy if build_append_child_rel
+		 * found self-contradictory quals.
+		 */
+		if (IS_DUMMY_REL(childrel))
+			continue;
+
+		if (relation_excluded_by_constraints(root, childrel, childRTE))
+		{
+			/*
+			 * This child need not be scanned, so we can omit it from the
+			 * appendrel.
+			 */
+			set_dummy_rel_pathlist(childrel);
+			continue;
+		}
+
+		/*
+		 * Copy/Modify targetlist.
 		 *
 		 * NB: the resulting childrel->reltarget->exprs may contain arbitrary
 		 * expressions, which otherwise would not occur in a rel's targetlist.
@@ -1457,144 +1304,6 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 									   false);
 		childrel->has_eclass_joins = rel->has_eclass_joins;
 
-		/*
-		 * We have to copy the parent's quals to the child, with appropriate
-		 * substitution of variables.  However, only the baserestrictinfo
-		 * quals are needed before we can check for constraint exclusion; so
-		 * do that first and then check to see if we can disregard this child.
-		 *
-		 * The child rel's targetlist might contain non-Var expressions, which
-		 * means that substitution into the quals could produce opportunities
-		 * for const-simplification, and perhaps even pseudoconstant quals.
-		 * Therefore, transform each RestrictInfo separately to see if it
-		 * reduces to a constant or pseudoconstant.  (We must process them
-		 * separately to keep track of the security level of each qual.)
-		 */
-		childquals = NIL;
-		cq_min_security = UINT_MAX;
-		have_const_false_cq = false;
-		foreach(lc, rel->baserestrictinfo)
-		{
-			RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
-			Node	   *childqual;
-			ListCell   *lc2;
-
-			Assert(IsA(rinfo, RestrictInfo));
-			childqual = adjust_appendrel_attrs(root,
-											   (Node *) rinfo->clause,
-											   1, &appinfo);
-			childqual = eval_const_expressions(root, childqual);
-			/* check for flat-out constant */
-			if (childqual && IsA(childqual, Const))
-			{
-				if (((Const *) childqual)->constisnull ||
-					!DatumGetBool(((Const *) childqual)->constvalue))
-				{
-					/* Restriction reduces to constant FALSE or NULL */
-					have_const_false_cq = true;
-					break;
-				}
-				/* Restriction reduces to constant TRUE, so drop it */
-				continue;
-			}
-			/* might have gotten an AND clause, if so flatten it */
-			foreach(lc2, make_ands_implicit((Expr *) childqual))
-			{
-				Node	   *onecq = (Node *) lfirst(lc2);
-				bool		pseudoconstant;
-
-				/* check for pseudoconstant (no Vars or volatile functions) */
-				pseudoconstant =
-					!contain_vars_of_level(onecq, 0) &&
-					!contain_volatile_functions(onecq);
-				if (pseudoconstant)
-				{
-					/* tell createplan.c to check for gating quals */
-					root->hasPseudoConstantQuals = true;
-				}
-				/* reconstitute RestrictInfo with appropriate properties */
-				childquals = lappend(childquals,
-									 make_restrictinfo((Expr *) onecq,
-													   rinfo->is_pushed_down,
-													   rinfo->outerjoin_delayed,
-													   pseudoconstant,
-													   rinfo->security_level,
-													   NULL, NULL, NULL));
-				/* track minimum security level among child quals */
-				cq_min_security = Min(cq_min_security, rinfo->security_level);
-			}
-		}
-
-		/*
-		 * In addition to the quals inherited from the parent, we might have
-		 * securityQuals associated with this particular child node.
-		 * (Currently this can only happen in appendrels originating from
-		 * UNION ALL; inheritance child tables don't have their own
-		 * securityQuals, see expand_inherited_rtentry().)	Pull any such
-		 * securityQuals up into the baserestrictinfo for the child.  This is
-		 * similar to process_security_barrier_quals() for the parent rel,
-		 * except that we can't make any general deductions from such quals,
-		 * since they don't hold for the whole appendrel.
-		 */
-		if (childRTE->securityQuals)
-		{
-			Index		security_level = 0;
-
-			foreach(lc, childRTE->securityQuals)
-			{
-				List	   *qualset = (List *) lfirst(lc);
-				ListCell   *lc2;
-
-				foreach(lc2, qualset)
-				{
-					Expr	   *qual = (Expr *) lfirst(lc2);
-
-					/* not likely that we'd see constants here, so no check */
-					childquals = lappend(childquals,
-										 make_restrictinfo(qual,
-														   true, false, false,
-														   security_level,
-														   NULL, NULL, NULL));
-					cq_min_security = Min(cq_min_security, security_level);
-				}
-				security_level++;
-			}
-			Assert(security_level <= root->qual_security_level);
-		}
-
-		/*
-		 * OK, we've got all the baserestrictinfo quals for this child.
-		 */
-		childrel->baserestrictinfo = childquals;
-		childrel->baserestrict_min_security = cq_min_security;
-
-		if (have_const_false_cq)
-		{
-			/*
-			 * Some restriction clause reduced to constant FALSE or NULL after
-			 * substitution, so this child need not be scanned.
-			 */
-			set_dummy_rel_pathlist(childrel);
-			continue;
-		}
-
-		if (did_pruning && !bms_is_member(appinfo->child_relid, live_children))
-		{
-			/* This partition was pruned; skip it. */
-			set_dummy_rel_pathlist(childrel);
-			continue;
-		}
-
-		if (relation_excluded_by_constraints(root, childrel, childRTE))
-		{
-			/*
-			 * This child need not be scanned, so we can omit it from the
-			 * appendrel.
-			 */
-			set_dummy_rel_pathlist(childrel);
-			continue;
-		}
-
 		/* CE failed, so finish copying/modifying join quals. */
 		childrel->joininfo = (List *)
 			adjust_appendrel_attrs(root,
@@ -3070,6 +2779,7 @@ inheritance_make_rel_from_joinlist(PlannerInfo *root, List *joinlist)
 			continue;
 
 		childrel = find_base_rel(root, appinfo->child_relid);
+		Assert(childrel != NULL);
 
 		/* Ignore excluded/pruned children. */
 		if (IS_DUMMY_REL(childrel))
diff --git a/src/backend/optimizer/path/joinrels.c b/src/backend/optimizer/path/joinrels.c
index db18feccfe..411cdbd84f 100644
--- a/src/backend/optimizer/path/joinrels.c
+++ b/src/backend/optimizer/path/joinrels.c
@@ -20,6 +20,7 @@
 #include "optimizer/joininfo.h"
 #include "optimizer/pathnode.h"
 #include "optimizer/paths.h"
+#include "optimizer/tlist.h"
 #include "partitioning/partbounds.h"
 #include "utils/lsyscache.h"
 #include "utils/memutils.h"
@@ -49,6 +50,9 @@ static int match_expr_to_partition_keys(Expr *expr, RelOptInfo *rel,
 static SpecialJoinInfo *build_child_join_sjinfo(PlannerInfo *root,
 						SpecialJoinInfo *parent_sjinfo,
 						Relids left_relids, Relids right_relids);
+static RelOptInfo *build_dummy_partition_rel(PlannerInfo *root,
+									RelOptInfo *parent,
+									int partidx);
 
 
 /*
@@ -1379,6 +1383,11 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
 		AppendRelInfo **appinfos;
 		int			nappinfos;
 
+		if (IS_SIMPLE_REL(rel1) && child_rel1 == NULL)
+			child_rel1 = build_dummy_partition_rel(root, rel1, cnt_parts);
+		if (IS_SIMPLE_REL(rel1) && child_rel2 == NULL)
+			child_rel2 = build_dummy_partition_rel(root, rel2, cnt_parts);
+
 		/* We should never try to join two overlapping sets of rels. */
 		Assert(!bms_overlap(child_rel1->relids, child_rel2->relids));
 		child_joinrelids = bms_union(child_rel1->relids, child_rel2->relids);
@@ -1627,3 +1636,55 @@ build_child_join_sjinfo(PlannerInfo *root, SpecialJoinInfo *parent_sjinfo,
 
 	return sjinfo;
 }
+
+/*
+ * build_dummy_partition_rel
+ *		Build a RelOptInfo and AppendRelInfo for a pruned partition
+ *
+ * This does not result in opening the relation or a range table entry being
+ * created.  Also, the RelOptInfo thus created is not stored anywhere else
+ * beside the parent's part_rels array.
+ *
+ * The only reason this exists is because partition-wise join, in some cases,
+ * needs a RelOptInfo to represent an empty relation that's on the nullable
+ * side of an outer join, so that a Path representing the outer join can be
+ * created.
+ */
+static RelOptInfo *
+build_dummy_partition_rel(PlannerInfo *root, RelOptInfo *parent, int partidx)
+{
+	RangeTblEntry *parentrte = root->simple_rte_array[parent->relid];
+	RelOptInfo *rel;
+
+	Assert(parent->part_rels[partidx] == NULL);
+
+	/* Create minimally valid-looking RelOptInfo with parent's relid. */
+	rel = makeNode(RelOptInfo);
+	rel->reloptkind = RELOPT_OTHER_MEMBER_REL;
+	rel->relid = parent->relid;
+	rel->relids = bms_copy(parent->relids);
+	if (parent->top_parent_relids)
+		rel->top_parent_relids = parent->top_parent_relids;
+	else
+		rel->top_parent_relids = bms_copy(parent->relids);
+	rel->reltarget = copy_pathtarget(parent->reltarget);
+	parent->part_rels[partidx] = rel;
+	mark_dummy_rel(rel);
+
+	/*
+	 * Now we'll need a (no-op) AppendRelInfo for parent, because we're
+	 * setting the dummy partition's relid to be same as the parent's.
+	 */
+	if (root->append_rel_array[parent->relid] == NULL)
+	{
+		AppendRelInfo *appinfo = make_append_rel_info(parent, parentrte,
+													  parent->tupdesc,
+													  parentrte->relid,
+													  parent->reltype,
+													  parent->relid);
+
+		root->append_rel_array[parent->relid] = appinfo;
+	}
+
+	return rel;
+}
diff --git a/src/backend/optimizer/plan/initsplan.c b/src/backend/optimizer/plan/initsplan.c
index a66374094f..c628f3d9e7 100644
--- a/src/backend/optimizer/plan/initsplan.c
+++ b/src/backend/optimizer/plan/initsplan.c
@@ -616,64 +616,6 @@ create_lateral_join_info(PlannerInfo *root)
 				bms_add_member(brel2->lateral_referencers, rti);
 		}
 	}
-
-	/*
-	 * Lastly, propagate lateral_relids and lateral_referencers from appendrel
-	 * parent rels to their child rels.  We intentionally give each child rel
-	 * the same minimum parameterization, even though it's quite possible that
-	 * some don't reference all the lateral rels.  This is because any append
-	 * path for the parent will have to have the same parameterization for
-	 * every child anyway, and there's no value in forcing extra
-	 * reparameterize_path() calls.  Similarly, a lateral reference to the
-	 * parent prevents use of otherwise-movable join rels for each child.
-	 */
-	for (rti = 1; rti < root->simple_rel_array_size; rti++)
-	{
-		RelOptInfo *brel = root->simple_rel_array[rti];
-		RangeTblEntry *brte = root->simple_rte_array[rti];
-
-		/*
-		 * Skip empty slots. Also skip non-simple relations i.e. dead
-		 * relations.
-		 */
-		if (brel == NULL || !IS_SIMPLE_REL(brel))
-			continue;
-
-		/*
-		 * In the case of table inheritance, the parent RTE is directly linked
-		 * to every child table via an AppendRelInfo.  In the case of table
-		 * partitioning, the inheritance hierarchy is expanded one level at a
-		 * time rather than flattened.  Therefore, an other member rel that is
-		 * a partitioned table may have children of its own, and must
-		 * therefore be marked with the appropriate lateral info so that those
-		 * children eventually get marked also.
-		 */
-		Assert(brte);
-		if (brel->reloptkind == RELOPT_OTHER_MEMBER_REL &&
-			(brte->rtekind != RTE_RELATION ||
-			 brte->relkind != RELKIND_PARTITIONED_TABLE))
-			continue;
-
-		if (brte->inh)
-		{
-			foreach(lc, root->append_rel_list)
-			{
-				AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(lc);
-				RelOptInfo *childrel;
-
-				if (appinfo->parent_relid != rti)
-					continue;
-				childrel = root->simple_rel_array[appinfo->child_relid];
-				Assert(childrel->reloptkind == RELOPT_OTHER_MEMBER_REL);
-				Assert(childrel->direct_lateral_relids == NULL);
-				childrel->direct_lateral_relids = brel->direct_lateral_relids;
-				Assert(childrel->lateral_relids == NULL);
-				childrel->lateral_relids = brel->lateral_relids;
-				Assert(childrel->lateral_referencers == NULL);
-				childrel->lateral_referencers = brel->lateral_referencers;
-			}
-		}
-	}
 }
 
 
diff --git a/src/backend/optimizer/plan/planmain.c b/src/backend/optimizer/plan/planmain.c
index 78557aeecb..62e11157da 100644
--- a/src/backend/optimizer/plan/planmain.c
+++ b/src/backend/optimizer/plan/planmain.c
@@ -254,6 +254,16 @@ query_planner(PlannerInfo *root, List *tlist,
 	}
 
 	/*
+	 * Expand RT entries that represent inherited or partitioned tables.
+	 * This will perform partition pruning on partitioned tables in the
+	 * original range table and also recursively on any child partitioned
+	 * tables that were added by the expansion of the original parent(s).
+	 * As new entries are added to the range table, various arrays in the
+	 * PlannerInfo will be expanded accordingly.
+	 */
+	expand_inherited_tables(root);
+
+	/*
 	 * Add child subroots needed to use during planning for individual child
 	 * targets
 	 */
diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index 703babfdf0..f80f35eed3 100644
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -25,6 +25,7 @@
 #include "access/sysattr.h"
 #include "access/xact.h"
 #include "catalog/pg_constraint.h"
+#include "catalog/pg_inherits.h"
 #include "catalog/pg_proc.h"
 #include "catalog/pg_type.h"
 #include "executor/executor.h"
@@ -704,27 +705,18 @@ subquery_planner(PlannerGlobal *glob, Query *parse,
 		}
 		if (rte->lateral)
 			root->hasLateralRTEs = true;
+
+		/*
+		 * While at it, also update the inh status.  If the relation doesn't
+		 * or can't have any children, there is no point in letting inh be set
+		 * to true.  Note that we do this before processing rowmarks, so that
+		 * the correct information for setting isParent field of PlanRowMarks.
+		 */
+		if (rte->rtekind == RTE_RELATION)
+			rte->inh = rte->inh && has_subclass(rte->relid);
 	}
 
 	/*
-	 * Preprocess RowMark information.  We need to do this after subquery
-	 * pullup (so that all non-inherited RTEs are present) and before
-	 * inheritance expansion (so that the info is available for
-	 * expand_inherited_tables to examine and modify).
-	 */
-	preprocess_rowmarks(root);
-
-	/*
-	 * Expand any rangetable entries that are inheritance sets into "append
-	 * relations".  This can add entries to the rangetable, but they must be
-	 * plain base relations not joins, so it's OK (and marginally more
-	 * efficient) to do it after checking for join RTEs.  We must do it after
-	 * pulling up subqueries, else we'd fail to handle inherited tables in
-	 * subqueries.
-	 */
-	expand_inherited_tables(root);
-
-	/*
 	 * Now that we have figured out "actual" inheritance situation of the
 	 * relations, set whether the query is an inherited UPDATE/DELETE.
 	 */
@@ -732,6 +724,12 @@ subquery_planner(PlannerGlobal *glob, Query *parse,
 					  rt_fetch(parse->resultRelation, parse->rtable)->inh);
 
 	/*
+	 * Preprocess RowMark information.  We need to do this after subquery
+	 * pullup (so that all non-inherited RTEs are present).
+	 */
+	preprocess_rowmarks(root);
+
+	/*
 	 * Set hasHavingQual to remember if HAVING clause is present.  Needed
 	 * because preprocess_expression will reduce a constant-true condition to
 	 * an empty qual list ... but "HAVING TRUE" is not a semantic no-op.
@@ -1233,7 +1231,9 @@ inheritance_planner(PlannerInfo *root)
 	 * of the parent.
 	 */
 	root->unexpanded_tlist = list_copy(root->parse->targetList);
-	tlist = preprocess_targetlist(root);
+	
+	/* We haven't expanded inheritance yet, so pass false. */
+	tlist = preprocess_targetlist(root, false);
 	root->processed_tlist = tlist;
 	qp_extra.tlist = tlist;
 	qp_extra.activeWindows = NIL;
@@ -1243,9 +1243,11 @@ inheritance_planner(PlannerInfo *root)
 	/*
 	 * If it turned out during query planning that all the children are dummy
 	 * (pruned or excluded by constraints), no need to do the steps below.
-	 * Let grouping_planner finish up the final path.
+	 * For regular inheritance case, it's possible that we only need to modify
+	 * the parent table.  Let grouping_planner finish up the final path.
 	 */
-	if (IS_DUMMY_REL(planned_rel))
+	parent_rte = planner_rt_fetch(top_parentRTindex, root);
+	if (!parent_rte->inh || IS_DUMMY_REL(planned_rel))
 	{
 		grouping_planner(root, false, planned_rel, 0.0);
 		return;
@@ -1261,7 +1263,6 @@ inheritance_planner(PlannerInfo *root)
 	 * not appear anywhere else in the plan, so the confusion explained below
 	 * for non-partitioning inheritance cases is not possible.
 	 */
-	parent_rte = planner_rt_fetch(top_parentRTindex, root);
 	if (parent_rte->relkind == RELKIND_PARTITIONED_TABLE)
 	{
 		nominalRelation = top_parentRTindex;
@@ -1590,14 +1591,19 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 		 */
 		if (planned_rel == NULL)
 		{
-			tlist = preprocess_targetlist(root);
+			/* We haven't expanded inheritance yet, so pass false. */
+			tlist = preprocess_targetlist(root, false);
 
 			/*
-			 * We are now done hacking up the query's targetlist.  Most of the
-			 * remaining planning work will be done with the PathTarget
-			 * representation of tlists, but save aside the full representation
-			 * so that we can transfer its decoration (resnames etc) to the
-			 * topmost tlist of the finished Plan.
+			 * We are now mostly done hacking up the query's targetlist.  More
+			 * columns might be added during query_planner after inheritance
+			 * expansion in make_one_rel, because some children may require
+			 * different column than the parent for row mark handling; see
+			 * add_rowmark_junk_columns().  Most of the remaining planning
+			 * work will be done with the PathTarget representation of tlists,
+			 * but save aside the full representation so that we can transfer
+			 * its decoration (resnames etc) to the topmost tlist of the
+			 * finished Plan.
 			 */
 			root->processed_tlist = tlist;
 		}
@@ -2373,7 +2379,7 @@ preprocess_rowmarks(PlannerInfo *root)
 		newrc->allMarkTypes = (1 << newrc->markType);
 		newrc->strength = rc->strength;
 		newrc->waitPolicy = rc->waitPolicy;
-		newrc->isParent = false;
+		newrc->isParent = rte->inh;
 
 		prowmarks = lappend(prowmarks, newrc);
 	}
@@ -2398,7 +2404,7 @@ preprocess_rowmarks(PlannerInfo *root)
 		newrc->allMarkTypes = (1 << newrc->markType);
 		newrc->strength = LCS_NONE;
 		newrc->waitPolicy = LockWaitBlock;	/* doesn't matter */
-		newrc->isParent = false;
+		newrc->isParent = rte->rtekind == RTE_RELATION ? rte->inh : false;
 
 		prowmarks = lappend(prowmarks, newrc);
 	}
@@ -6835,6 +6841,10 @@ apply_scanjoin_target_to_paths(PlannerInfo *root,
 			int			nappinfos;
 			List	   *child_scanjoin_targets = NIL;
 
+			/* Skip processing pruned partitions. */
+			if (child_rel == NULL)
+				continue;
+
 			/* Translate scan/join targets for this child. */
 			appinfos = find_appinfos_by_relids(root, child_rel->relids,
 											   &nappinfos);
@@ -6936,6 +6946,10 @@ create_partitionwise_grouping_paths(PlannerInfo *root,
 		RelOptInfo *child_grouped_rel;
 		RelOptInfo *child_partially_grouped_rel;
 
+		/* Skip processing pruned partitions. */
+		if (child_input_rel == NULL)
+			continue;
+
 		/* Input child rel must have a path */
 		Assert(child_input_rel->pathlist != NIL);
 
diff --git a/src/backend/optimizer/plan/setrefs.c b/src/backend/optimizer/plan/setrefs.c
index 5d363edab8..4dcdede6b6 100644
--- a/src/backend/optimizer/plan/setrefs.c
+++ b/src/backend/optimizer/plan/setrefs.c
@@ -325,6 +325,12 @@ add_rtes_to_flat_rtable(PlannerInfo *root, bool recursing)
 													  UPPERREL_FINAL, NULL)))
 					add_rtes_to_flat_rtable(rel->subroot, true);
 			}
+			/*
+			 * A NULL rel also means an unplanned subquery rte, so apply
+			 * flatten_unplanned_rtes.
+			 */
+			else
+				flatten_unplanned_rtes(glob, rte);
 		}
 		rti++;
 	}
diff --git a/src/backend/optimizer/prep/preptlist.c b/src/backend/optimizer/prep/preptlist.c
index f8bc2dd257..a55949c305 100644
--- a/src/backend/optimizer/prep/preptlist.c
+++ b/src/backend/optimizer/prep/preptlist.c
@@ -65,9 +65,13 @@ static List *expand_targetlist(List *tlist, int command_type,
  *
  * As a side effect, if there's an ON CONFLICT UPDATE clause, its targetlist
  * is also preprocessed (and updated in-place).
+ *
+ * inheritance_expanded specifies whether inheritance tables are expanded
+ * as of calling this function.  Caller must specify it because that affects
+ * which row marking related junk columns get added to the targetlist.
  */
 List *
-preprocess_targetlist(PlannerInfo *root)
+preprocess_targetlist(PlannerInfo *root, bool inheritance_expanded)
 {
 	Query	   *parse = root->parse;
 	int			result_relation = parse->resultRelation;
@@ -134,6 +138,15 @@ preprocess_targetlist(PlannerInfo *root)
 		if (rc->rti != rc->prti)
 			continue;
 
+		/*
+		 * For inheritance parent row marks, we defer adding junk columns
+		 * until we've added child row marks, because some children might
+		 * require different row mark types which will change the parent row
+		 * mark's allMarkTypes fields.
+		 */
+		if (rc->isParent && !inheritance_expanded)
+			continue;
+
 		if (rc->allMarkTypes & ~(1 << ROW_MARK_COPY))
 		{
 			/* Need to fetch TID */
diff --git a/src/backend/optimizer/prep/prepunion.c b/src/backend/optimizer/prep/prepunion.c
index 55eeb5127c..d4d36248a1 100644
--- a/src/backend/optimizer/prep/prepunion.c
+++ b/src/backend/optimizer/prep/prepunion.c
@@ -31,13 +31,16 @@
 #include "miscadmin.h"
 #include "nodes/makefuncs.h"
 #include "nodes/nodeFuncs.h"
+#include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
 #include "optimizer/paths.h"
 #include "optimizer/planmain.h"
 #include "optimizer/planner.h"
 #include "optimizer/prep.h"
+#include "optimizer/restrictinfo.h"
 #include "optimizer/tlist.h"
+#include "optimizer/var.h"
 #include "parser/parse_coerce.h"
 #include "parser/parsetree.h"
 #include "utils/lsyscache.h"
diff --git a/src/backend/optimizer/util/appendinfo.c b/src/backend/optimizer/util/appendinfo.c
index 0b9ca39a51..1500ea22b9 100644
--- a/src/backend/optimizer/util/appendinfo.c
+++ b/src/backend/optimizer/util/appendinfo.c
@@ -31,10 +31,10 @@ typedef struct
 	AppendRelInfo **appinfos;
 } adjust_appendrel_attrs_context;
 
-static void make_inh_translation_list(Relation oldrelation,
-						  Relation newrelation,
-						  Index newvarno,
-						  List **translated_vars);
+static void make_inh_translation_list(TupleDesc old_tupdesc,
+						  TupleDesc new_tupdesc,
+						  Oid from_rel, Oid to_rel,
+						  Index newvarno, List **translated_vars);
 static Node *adjust_appendrel_attrs_mutator(Node *node,
 							   adjust_appendrel_attrs_context *context);
 static List *adjust_inherited_tlist(List *tlist,
@@ -46,18 +46,20 @@ static List *adjust_inherited_tlist(List *tlist,
  *	  Build an AppendRelInfo for the parent-child pair
  */
 AppendRelInfo *
-make_append_rel_info(Relation parentrel, Relation childrel,
-					 Index parentRTindex, Index childRTindex)
+make_append_rel_info(RelOptInfo *parent, RangeTblEntry *parentrte,
+					 TupleDesc childdesc, Oid childoid, Oid childtype,
+					 Index childRTindex)
 {
 	AppendRelInfo *appinfo = makeNode(AppendRelInfo);
 
-	appinfo->parent_relid = parentRTindex;
+	appinfo->parent_relid = parent->relid;
 	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->translated_vars);
-	appinfo->parent_reloid = RelationGetRelid(parentrel);
+	appinfo->parent_reltype = parent->reltype;
+	appinfo->child_reltype = childtype;
+	make_inh_translation_list(parent->tupdesc, childdesc,
+							  parentrte->relid, childoid,
+							  childRTindex, &appinfo->translated_vars);
+	appinfo->parent_reloid = parentrte->relid;
 
 	return appinfo;
 }
@@ -70,14 +72,11 @@ make_append_rel_info(Relation parentrel, Relation childrel,
  * For paranoia's sake, we match type/collation as well as attribute name.
  */
 static void
-make_inh_translation_list(Relation oldrelation, Relation newrelation,
-						  Index newvarno,
-						  List **translated_vars)
+make_inh_translation_list(TupleDesc old_tupdesc, TupleDesc new_tupdesc,
+						  Oid from_rel, Oid to_rel,
+						  Index newvarno, List **translated_vars)
 {
 	List	   *vars = NIL;
-	TupleDesc	old_tupdesc = RelationGetDescr(oldrelation);
-	TupleDesc	new_tupdesc = RelationGetDescr(newrelation);
-	Oid			new_relid = RelationGetRelid(newrelation);
 	int			oldnatts = old_tupdesc->natts;
 	int			newnatts = new_tupdesc->natts;
 	int			old_attno;
@@ -107,7 +106,7 @@ make_inh_translation_list(Relation oldrelation, Relation newrelation,
 		 * When we are generating the "translation list" for the parent table
 		 * of an inheritance set, no need to search for matches.
 		 */
-		if (oldrelation == newrelation)
+		if (from_rel == to_rel)
 		{
 			vars = lappend(vars, makeVar(newvarno,
 										 (AttrNumber) (old_attno + 1),
@@ -133,10 +132,10 @@ make_inh_translation_list(Relation oldrelation, Relation newrelation,
 		{
 			HeapTuple	newtup;
 
-			newtup = SearchSysCacheAttName(new_relid, attname);
+			newtup = SearchSysCacheAttName(to_rel, attname);
 			if (!newtup)
 				elog(ERROR, "could not find inherited attribute \"%s\" of relation \"%s\"",
-					 attname, RelationGetRelationName(newrelation));
+					 attname, get_rel_name(to_rel));
 			new_attno = ((Form_pg_attribute) GETSTRUCT(newtup))->attnum - 1;
 			ReleaseSysCache(newtup);
 
@@ -146,10 +145,10 @@ make_inh_translation_list(Relation oldrelation, Relation newrelation,
 		/* Found it, check type and collation match */
 		if (atttypid != att->atttypid || atttypmod != att->atttypmod)
 			elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's type",
-				 attname, RelationGetRelationName(newrelation));
+				 attname, get_rel_name(to_rel));
 		if (attcollation != att->attcollation)
 			elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's collation",
-				 attname, RelationGetRelationName(newrelation));
+				 attname, get_rel_name(to_rel));
 
 		vars = lappend(vars, makeVar(newvarno,
 									 (AttrNumber) (new_attno + 1),
diff --git a/src/backend/optimizer/util/inherit.c b/src/backend/optimizer/util/inherit.c
index 0d2b42f72e..0e927254c7 100644
--- a/src/backend/optimizer/util/inherit.c
+++ b/src/backend/optimizer/util/inherit.c
@@ -18,33 +18,43 @@
 #include "access/sysattr.h"
 #include "catalog/partition.h"
 #include "catalog/pg_inherits.h"
+#include "catalog/pg_type.h"
 #include "miscadmin.h"
+#include "nodes/makefuncs.h"
 #include "optimizer/appendinfo.h"
+#include "optimizer/clauses.h"
 #include "optimizer/inherit.h"
+#include "optimizer/pathnode.h"
+#include "optimizer/paths.h"
 #include "optimizer/planmain.h"
 #include "optimizer/planner.h"
 #include "optimizer/prep.h"
+#include "optimizer/restrictinfo.h"
+#include "optimizer/var.h"
+#include "partitioning/partprune.h"
 #include "utils/rel.h"
 
 
 static PlannerInfo *create_inherited_target_child_root(PlannerInfo *root,
 									AppendRelInfo *appinfo);
-static void expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte,
-						 Index rti);
+static void expand_inherited_rtentry(PlannerInfo *root, RelOptInfo *rel,
+					  RangeTblEntry *rte, Index rti);
+static void expand_nonpartitioned_inherited_rtentry(PlannerInfo *root,
+						 RangeTblEntry *rte, Index rti, RelOptInfo *rel);
 static void expand_partitioned_rtentry(PlannerInfo *root,
 						   RangeTblEntry *parentrte,
-						   Index parentRTindex, Relation parentrel,
-						   PlanRowMark *top_parentrc, LOCKMODE lockmode,
-						   List **appinfos);
-static void expand_single_inheritance_child(PlannerInfo *root,
-								RangeTblEntry *parentrte,
-								Index parentRTindex, Relation parentrel,
-								PlanRowMark *top_parentrc, Relation childrel,
-								List **appinfos, RangeTblEntry **childrte_p,
-								Index *childRTindex_p);
+						   Index parentRTindex, RelOptInfo *parentrel);
+static RelOptInfo *add_inheritance_child_rel(PlannerInfo *root,
+						  RangeTblEntry *parentrte,
+						  Index parentRTindex, RelOptInfo *parentrel,
+						  PlanRowMark *top_parentrc, Relation childrel,
+						  RangeTblEntry **childrte_p, Index *childRTindex_p);
 static Bitmapset *translate_col_privs(const Bitmapset *parent_privs,
 					List *translated_vars);
-
+static RelOptInfo *build_inheritance_child_rel(PlannerInfo *root,
+					   RelOptInfo *parent,
+					   Index childRTindex);
+static List *add_rowmark_junk_columns(PlannerInfo *root, PlanRowMark *rc);
 
 /*
  * expand_inherited_tables
@@ -52,37 +62,145 @@ static Bitmapset *translate_col_privs(const Bitmapset *parent_privs,
  *		into an "append relation".  At the conclusion of this process,
  *		the "inh" flag is set in all and only those RTEs that are append
  *		relation parents.
+ *
+ * Note that although we're calling the combined output of inheritance set
+ * relations an "append relation" here, the caller may not always want to
+ * combine the relations.  For example, if the parent of the inheritance
+ * set is the query's target relation, each child relation is processed
+ * on its own as the query's target relation.
  */
 void
 expand_inherited_tables(PlannerInfo *root)
 {
-	Index		nrtes;
+	int			orig_rtable_size;
 	Index		rti;
-	ListCell   *rl;
+
+	Assert(root->simple_rel_array_size > 0);
+	orig_rtable_size = root->simple_rel_array_size;
 
 	/*
 	 * expand_inherited_rtentry may add RTEs to parse->rtable. The function is
 	 * expected to recursively handle any RTEs that it creates with inh=true.
 	 * So just scan as far as the original end of the rtable list.
 	 */
-	nrtes = list_length(root->parse->rtable);
-	rl = list_head(root->parse->rtable);
-	for (rti = 1; rti <= nrtes; rti++)
+	for (rti = 1; rti < orig_rtable_size; rti++)
 	{
-		RangeTblEntry *rte = (RangeTblEntry *) lfirst(rl);
+		RelOptInfo *brel = root->simple_rel_array[rti];
+		RangeTblEntry *rte = root->simple_rte_array[rti];
 
-		expand_inherited_rtentry(root, rte, rti);
-		rl = lnext(rl);
+		/* there may be empty slots corresponding to non-baserel RTEs */
+		if (brel == NULL)
+			continue;
+
+		if (rte->inh)
+			expand_inherited_rtentry(root, brel, rte, rti);
 	}
 }
 
 /*
  * expand_inherited_rtentry
- *		Check whether a rangetable entry represents an inheritance set.
- *		If so, add entries for all the child tables to the query's
- *		rangetable, and build AppendRelInfo nodes for all the child tables
- *		and add them to root->append_rel_list.  If not, clear the entry's
- *		"inh" flag to prevent later code from looking for AppendRelInfos.
+ *		This initializes RelOptInfos for inheritance child relations if the
+ *		passed-in relation has any
+ *
+ * 'rel' is the parent relation, whose range table entry ('rte') has been
+ * marked to require adding children.  Parent could either be a subquery (if
+ * we flattened UNION ALL query) or a table that's known to have (or once had)
+ * inheritance children.  The latter consists of both regular inheritance
+ * parents and partitioned tables.
+ *
+ * For a subquery parent, there is not much to be done here because the
+ * children's RTEs are already present in the query, so we just initialize
+ * RelOptInfos for them.  Also, the AppendRelInfos for child subqueries
+ * have already been added.
+ *
+ * For tables, we need to add the children to the range table and initialize
+ * AppendRelInfos, RelOptInfos, and PlanRowMarks (if any) for them.  For
+ * a partitioned parent, we only add the children remaining after pruning.
+ * For regular inheritance parents, we find the children using
+ * find_all_inheritors and add all of them.
+ *
+ * If it turns out that there are no children, then we set rte->inh to false
+ * to let the caller know that only the parent table needs to be scanned.  The
+ * caller can accordingly switch to a non-Append path.  For a partitioned
+ * parent, that means an empty relation because parents themselves contain no
+ * data.
+ *
+ * For the regular inheritance case, the parent also gets another RTE with
+ * inh = false to represent it as a child to be scanned as part of the
+ * inheritance set.  The original RTE is considered to represent the whole
+ * inheritance set.
+ */
+static void
+expand_inherited_rtentry(PlannerInfo *root, RelOptInfo *rel,
+						 RangeTblEntry *rte, Index rti)
+{
+	Assert(rte->inh);
+	/* Inheritance parent (partitioned or not) or UNION ALL parent subquery. */
+	Assert(rte->rtekind == RTE_RELATION || rte->rtekind == RTE_SUBQUERY);
+
+	/*
+	 * UNION ALL children already got RTEs and AppendRelInfos, so just build
+	 * RelOptInfos and return.
+	 *
+	 * It might be a bit odd that this code is in this, because there is
+	 * nothing to expand really.
+	 */
+	if (rte->rtekind == RTE_SUBQUERY)
+	{
+		ListCell   *l;
+
+		/*
+		 * We don't need to use expand_planner_arrays in this case, because
+		 * no new child RTEs are created.  setup_simple_rel_arrays() and
+		 * setup_append_rel_array would've considered these child RTEs when
+		 * allocating space for various arrays.
+		 */
+		foreach(l, root->append_rel_list)
+		{
+			AppendRelInfo *appinfo = lfirst(l);
+			Index		childRTindex = appinfo->child_relid;
+
+			if (appinfo->parent_relid != rti)
+				continue;
+
+			Assert(childRTindex < root->simple_rel_array_size);
+			Assert(root->simple_rte_array[childRTindex] != NULL);
+
+			/*
+			 * We set the correct value of baserestricinfo and
+			 * baserestrict_min_security below.
+			 */
+			root->simple_rel_array[childRTindex] =
+				build_inheritance_child_rel(root, rel, appinfo->child_relid);
+		}
+	}
+	else
+	{
+		Assert(rte->rtekind == RTE_RELATION);
+		Assert(has_subclass(rte->relid));
+
+		/*
+		 * The rewriter should already have obtained an appropriate lock on
+		 * each relation named in the query.  However, for each child relation
+		 * we add to the query, we must obtain an appropriate lock, because
+		 * this will be the first use of those relations in the
+		 * parse/rewrite/plan pipeline.  Child rels should use the same
+		 * lockmode as their parent.
+		 */
+		Assert(rte->rellockmode != NoLock);
+
+		if (rte->relkind == RELKIND_PARTITIONED_TABLE)
+			expand_partitioned_rtentry(root, rte, rti, rel);
+		else
+			expand_nonpartitioned_inherited_rtentry(root, rte, rti, rel);
+	}
+}
+
+/*
+ * expand_nonpartitioned_inherited_rtentry
+ *		Add entries for all the child tables to the query's rangetable, and
+ *		build AppendRelInfo nodes for all the child tables and add them to
+ *		root->append_rel_list.
  *
  * Note that the original RTE is considered to represent the whole
  * inheritance set.  The first of the generated RTEs is an RTE for the same
@@ -93,55 +211,35 @@ expand_inherited_tables(PlannerInfo *root)
  * regular inheritance, a parent RTE must always have at least two associated
  * AppendRelInfos: one corresponding to the parent table as a simple member of
  * inheritance set and one or more corresponding to the actual children.
- * Since a partitioned table is not scanned, it might have only one associated
- * AppendRelInfo.
  */
 static void
-expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti)
+expand_nonpartitioned_inherited_rtentry(PlannerInfo *root,
+										RangeTblEntry *rte,
+										Index rti,
+										RelOptInfo *rel)
 {
 	Oid			parentOID;
 	PlanRowMark *oldrc;
-	Relation	oldrelation;
-	LOCKMODE	lockmode;
+	LOCKMODE	lockmode = rte->rellockmode;
 	List	   *inhOIDs;
 	ListCell   *l;
+	int			num_children;
+	int			num_children_added = 0;
 
-	/* Does RT entry allow inheritance? */
-	if (!rte->inh)
-		return;
-	/* Ignore any already-expanded UNION ALL nodes */
-	if (rte->rtekind != RTE_RELATION)
-	{
-		Assert(rte->rtekind == RTE_SUBQUERY);
-		return;
-	}
-	/* Fast path for common case of childless table */
+	Assert(rte->rtekind == RTE_RELATION);
+	Assert(lockmode != NoLock);
 	parentOID = rte->relid;
-	if (!has_subclass(parentOID))
-	{
-		/* Clear flag before returning */
-		rte->inh = false;
-		return;
-	}
-
-	/*
-	 * The rewriter should already have obtained an appropriate lock on each
-	 * relation named in the query.  However, for each child relation we add
-	 * to the query, we must obtain an appropriate lock, because this will be
-	 * the first use of those relations in the parse/rewrite/plan pipeline.
-	 * Child rels should use the same lockmode as their parent.
-	 */
-	lockmode = rte->rellockmode;
 
 	/* Scan for all members of inheritance set, acquire needed locks */
 	inhOIDs = find_all_inheritors(parentOID, lockmode, NULL);
 
 	/*
 	 * Check that there's at least one descendant, else treat as no-child
-	 * case.  This could happen despite above has_subclass() check, if table
-	 * once had a child but no longer does.
+	 * case.  This could happen despite has_subclass() check performed by
+	 * subquery_planner, if table once had a child but no longer does.
 	 */
-	if (list_length(inhOIDs) < 2)
+	num_children = list_length(inhOIDs);
+	if (num_children < 2)
 	{
 		/* Clear flag before returning */
 		rte->inh = false;
@@ -149,216 +247,219 @@ expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti)
 	}
 
 	/*
-	 * If parent relation is selected FOR UPDATE/SHARE, we need to mark its
-	 * PlanRowMark as isParent = true, and generate a new PlanRowMark for each
-	 * child.
+	 * If parent relation is selected FOR UPDATE/SHARE, preprocess_rowmarks
+	 * should've set isParent = true.  We'll generate a new PlanRowMark for
+	 * each child.
 	 */
 	oldrc = get_plan_rowmark(root->rowMarks, rti);
-	if (oldrc)
-		oldrc->isParent = true;
+	Assert(oldrc == NULL || oldrc->isParent);
 
 	/*
-	 * Must open the parent relation to examine its tupdesc.  We need not lock
-	 * it; we assume the rewriter already did.
+	 * Must expand PlannerInfo arrays by num_children before we can add
+	 * children.
 	 */
-	oldrelation = heap_open(parentOID, NoLock);
+	expand_planner_arrays(root, num_children);
 
-	/* Scan the inheritance set and expand it */
-	if (RelationGetPartitionDesc(oldrelation) != NULL)
+	foreach(l, inhOIDs)
 	{
-		Assert(rte->relkind == RELKIND_PARTITIONED_TABLE);
-
-		/*
-		 * If this table has partitions, recursively expand them in the order
-		 * in which they appear in the PartitionDesc.  While at it, also
-		 * extract the partition key columns of all the partitioned tables.
-		 */
-		expand_partitioned_rtentry(root, rte, rti, oldrelation, oldrc,
-								   lockmode, &root->append_rel_list);
-	}
-	else
-	{
-		List	   *appinfos = NIL;
+		Oid			childOID = lfirst_oid(l);
+		Relation	newrelation;
 		RangeTblEntry *childrte;
 		Index		childRTindex;
 
+		/* Already locked above. */
+		newrelation = heap_open(childOID, NoLock);
+
 		/*
-		 * This table has no partitions.  Expand any plain inheritance
-		 * children in the order the OIDs were returned by
-		 * find_all_inheritors.
+		 * It is possible that the parent table has children that are temp
+		 * tables of other backends.  We cannot safely access such tables
+		 * (because of buffering issues), and the best thing to do seems
+		 * to be to silently ignore them.
 		 */
-		foreach(l, inhOIDs)
+		if (childOID != parentOID && RELATION_IS_OTHER_TEMP(newrelation))
 		{
-			Oid			childOID = lfirst_oid(l);
-			Relation	newrelation;
-
-			/* Open rel if needed; we already have required locks */
-			if (childOID != parentOID)
-				newrelation = heap_open(childOID, NoLock);
-			else
-				newrelation = oldrelation;
-
-			/*
-			 * It is possible that the parent table has children that are temp
-			 * tables of other backends.  We cannot safely access such tables
-			 * (because of buffering issues), and the best thing to do seems
-			 * to be to silently ignore them.
-			 */
-			if (childOID != parentOID && RELATION_IS_OTHER_TEMP(newrelation))
-			{
-				heap_close(newrelation, lockmode);
-				continue;
-			}
-
-			expand_single_inheritance_child(root, rte, rti, oldrelation, oldrc,
-											newrelation,
-											&appinfos, &childrte,
-											&childRTindex);
-
-			/* Close child relations, but keep locks */
-			if (childOID != parentOID)
-				heap_close(newrelation, NoLock);
+			heap_close(newrelation, lockmode);
+			continue;
 		}
 
-		/*
-		 * If all the children were temp tables, pretend it's a
-		 * non-inheritance situation; we don't need Append node in that case.
-		 * The duplicate RTE we added for the parent table is harmless, so we
-		 * don't bother to get rid of it; ditto for the useless PlanRowMark
-		 * node.
-		 */
-		if (list_length(appinfos) < 2)
-			rte->inh = false;
-		else
-			root->append_rel_list = list_concat(root->append_rel_list,
-												appinfos);
+		(void) add_inheritance_child_rel(root, rte, rti, rel, oldrc,
+										 newrelation, &childrte,
+										 &childRTindex);
+		Assert(childrte != NULL);
+		/* All regular inheritance children are leaf children. */
+		Assert(!childrte->inh);
+		Assert(childRTindex > 0);
 
+		/* Close child relations, but keep locks */
+		heap_close(newrelation, NoLock);
+		num_children_added++;
 	}
 
-	heap_close(oldrelation, NoLock);
+	/*
+	 * If all children, including the parent (as child rel), were
+	 * excluded, mark the parent rel as empty.  If all the children were temp
+	 * tables, pretend it's a non-inheritance situation; we don't need Append
+	 * node in that case.  The duplicate RTE we added for the parent table is
+	 * harmless, so we don't bother to get rid of it; ditto for the useless
+	 * PlanRowMark node.
+	 */
+	if (num_children_added == 0)
+		mark_dummy_rel(rel);
+	else if (num_children_added == 1)
+		rte->inh = false;
+
+	/*
+	 * Add junk columns needed by the row mark if any and also add the
+	 * relevant expressions to the root parent's reltarget.
+	 */
+	if (oldrc)
+	{
+		List   *tlist = add_rowmark_junk_columns(root, oldrc);
+
+		build_base_rel_tlists(root, tlist);
+	}
 }
 
 /*
  * expand_partitioned_rtentry
- *		Recursively expand an RTE for a partitioned table.
+ *		Prunes unnecessary partitions of a partitioned table and adds
+ *		remaining ones to the Query and the PlannerInfo
+ *
+ * Partitions are added to the query in order in which they are found in
+ * the parent's PartitionDesc.
+ *
+ * Note: even though only the unpruned partitions will be added to the
+ * resulting plan, this still locks *all* partitions via find_all_inheritors
+ * when this function is called for the root partitioned table.
  */
 static void
 expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
-						   Index parentRTindex, Relation parentrel,
-						   PlanRowMark *top_parentrc, LOCKMODE lockmode,
-						   List **appinfos)
+						   Index parentRTindex, RelOptInfo *parentrel)
 {
+	LOCKMODE	lockmode = parentrte->rellockmode;
+	PlanRowMark *rootrc = NULL;
 	int			i;
-	RangeTblEntry *childrte;
-	Index		childRTindex;
-	PartitionDesc partdesc = RelationGetPartitionDesc(parentrel);
+	Bitmapset  *partindexes;
+	Index		rootParentRTindex = parentrel->inh_root_parent > 0 ?
+									parentrel->inh_root_parent :
+									parentRTindex;
 
-	check_stack_depth();
-
-	/* A partitioned table should always have a partition descriptor. */
-	Assert(partdesc);
-
-	Assert(parentrte->inh);
+	/* If root partitioned table, lock *all* partitions in the tree. */
+	if (parentRTindex == rootParentRTindex)
+		(void) find_all_inheritors(parentrte->relid, lockmode, NULL);
 
 	/*
-	 * Note down whether any partition key cols are being updated. Though it's
-	 * the root partitioned table's updatedCols we are interested in, we
-	 * instead use parentrte to get the updatedCols. This is convenient
-	 * because parentrte already has the root partrel's updatedCols translated
-	 * to match the attribute ordering of parentrel.
+	 * Initialize partitioned_child_rels to contain this RT index.
+	 *
+	 * Note that during the set_append_rel_pathlist() phase, values of the
+	 * indexes of partitioned relations that appear down in the tree will be
+	 * bubbled up into root parent's list so that when we've created Paths for
+	 * all the children, the root table's list will contain all such indexes.
 	 */
-	if (!root->partColsUpdated)
-		root->partColsUpdated =
-			has_partition_attrs(parentrel, parentrte->updatedCols, NULL);
+	parentrel->partitioned_child_rels = list_make1_int(parentRTindex);
 
-	/* First expand the partitioned table itself. */
-	expand_single_inheritance_child(root, parentrte, parentRTindex, parentrel,
-									top_parentrc, parentrel,
-									appinfos, &childrte, &childRTindex);
+	/* Perform pruning. */
+	partindexes = prune_append_rel_partitions(parentrel);
+
+	/* Must expand PlannerInfo arrays before we can add children. */
+	expand_planner_arrays(root, bms_num_members(partindexes));
 
 	/*
-	 * If the partitioned table has no partitions, treat this as the
-	 * non-inheritance case.
+	 * For partitioned tables, we also store the partition RelOptInfo
+	 * pointers in the parent's RelOptInfo.
 	 */
-	if (partdesc->nparts == 0)
-	{
-		parentrte->inh = false;
-		return;
-	}
+	parentrel->part_rels = (RelOptInfo **) palloc0(sizeof(RelOptInfo *) *
+												   parentrel->nparts);
 
-	for (i = 0; i < partdesc->nparts; i++)
+	rootrc = get_plan_rowmark(root->rowMarks, rootParentRTindex);
+	Assert(rootrc == NULL || rootrc->isParent);
+	i = -1;
+	while ((i = bms_next_member(partindexes, i)) >= 0)
 	{
-		Oid			childOID = partdesc->oids[i];
-		Relation	childrel;
+		Oid		childOID = parentrel->part_oids[i];
+		Relation	newrelation;
+		RelOptInfo *childrel;
+		RangeTblEntry *childrte;
+		Index		childRTindex;
 
-		/* Open rel; we already have required locks */
-		childrel = heap_open(childOID, NoLock);
+		/* Already locked above. */
+		newrelation = heap_open(childOID, NoLock);
+		Assert(!RELATION_IS_OTHER_TEMP(newrelation));
 
 		/*
-		 * Temporary partitions belonging to other sessions should have been
-		 * disallowed at definition, but for paranoia's sake, let's double
-		 * check.
+		 * A partitioned child table with 0 children is a dummy rel, so don't
+		 * bother creating planner objects for it.
 		 */
-		if (RELATION_IS_OTHER_TEMP(childrel))
-			elog(ERROR, "temporary relation from another session found as partition");
+		if (newrelation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE &&
+			RelationGetPartitionDesc(newrelation)->nparts == 0)
+		{
+			heap_close(newrelation, NoLock);
+			continue;
+		}
 
-		expand_single_inheritance_child(root, parentrte, parentRTindex,
-										parentrel, top_parentrc, childrel,
-										appinfos, &childrte, &childRTindex);
+		childrel = add_inheritance_child_rel(root, parentrte, parentRTindex,
+											 parentrel, rootrc, newrelation,
+											 &childrte, &childRTindex);
+		Assert(childrel != NULL);
+		parentrel->part_rels[i] = childrel;
 
-		/* If this child is itself partitioned, recurse */
-		if (childrel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
+		/* Close child relations, but keep locks */
+		heap_close(newrelation, NoLock);
+
+		/* If the child is partitioned itself, expand it too. */
+		if (childrel->part_scheme)
+		{
+			Assert(childrte->inh);
 			expand_partitioned_rtentry(root, childrte, childRTindex,
-									   childrel, top_parentrc, lockmode,
-									   appinfos);
+									   childrel);
+		}
+	}
 
-		/* Close child relation, but keep locks */
-		heap_close(childrel, NoLock);
+	/*
+	 * Add junk columns needed by the row mark if any and also add the
+	 * relevant expressions to the root parent's reltarget.
+	 */
+	if (rootrc)
+	{
+		List   *tlist = add_rowmark_junk_columns(root, rootrc);
+
+		build_base_rel_tlists(root, tlist);
 	}
 }
 
 /*
- * expand_single_inheritance_child
- *		Build a RangeTblEntry and an AppendRelInfo, if appropriate, plus
- *		maybe a PlanRowMark.
+ * add_inheritance_child_rel
+ *		Build a RangeTblEntry, an AppendRelInfo, a PlanRowMark, and finally
+ *		a RelOptInfo for an inheritance child relation.
  *
- * We now expand the partition hierarchy level by level, creating a
- * corresponding hierarchy of AppendRelInfos and RelOptInfos, where each
- * partitioned descendant acts as a parent of its immediate partitions.
- * (This is a difference from what older versions of PostgreSQL did and what
- * is still done in the case of table inheritance for unpartitioned tables,
- * where the hierarchy is flattened during RTE expansion.)
+ * The return value is the RelOptInfo that's added.
  *
  * PlanRowMarks still carry the top-parent's RTI, and the top-parent's
  * allMarkTypes field still accumulates values from all descendents.
  *
  * "parentrte" and "parentRTindex" are immediate parent's RTE and
  * RTI. "top_parentrc" is top parent's PlanRowMark.
- *
- * The child RangeTblEntry and its RTI are returned in "childrte_p" and
- * "childRTindex_p" resp.
  */
-static void
-expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte,
-								Index parentRTindex, Relation parentrel,
-								PlanRowMark *top_parentrc, Relation childrel,
-								List **appinfos, RangeTblEntry **childrte_p,
-								Index *childRTindex_p)
+static RelOptInfo *
+add_inheritance_child_rel(PlannerInfo *root, RangeTblEntry *parentrte,
+						  Index parentRTindex, RelOptInfo *parentrel,
+						  PlanRowMark *top_parentrc, Relation childrel,
+						  RangeTblEntry **childrte_p, Index *childRTindex_p)
 {
 	Query	   *parse = root->parse;
-	Oid			parentOID = RelationGetRelid(parentrel);
 	Oid			childOID = RelationGetRelid(childrel);
 	RangeTblEntry *childrte;
 	Index		childRTindex;
 	AppendRelInfo *appinfo;
+	RelOptInfo *childrelopt;
 
 	/*
 	 * Build an RTE for the child, and attach to query's rangetable list. We
 	 * copy most fields of the parent's RTE, but replace relation OID and
-	 * relkind, and set inh = false.  Also, set requiredPerms to zero since
-	 * all required permissions checks are done on the original RTE. Likewise,
-	 * set the child's securityQuals to empty, because we only want to apply
-	 * the parent's RLS conditions regardless of what RLS properties
+	 * relkind, and set inh appropriately.  Also, set requiredPerms to zero
+	 * since all required permissions checks are done on the original RTE.
+	 * Likewise, set the child's securityQuals to empty, because we only want
+	 * to apply the parent's RLS conditions regardless of what RLS properties
 	 * individual children may have.  (This is an intentional choice to make
 	 * inherited RLS work like regular permissions checks.) The parent
 	 * securityQuals will be propagated to children along with other base
@@ -368,49 +469,42 @@ expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte,
 	*childrte_p = childrte;
 	childrte->relid = childOID;
 	childrte->relkind = childrel->rd_rel->relkind;
-	/* A partitioned child will need to be expanded further. */
-	if (childOID != parentOID &&
-		childrte->relkind == RELKIND_PARTITIONED_TABLE)
-		childrte->inh = true;
-	else
-		childrte->inh = false;
+	/*
+	 * A partitioned child will need to be expanded as an append parent
+	 * itself, so set its inh to true.
+	 */
+	childrte->inh = (childrte->relkind == RELKIND_PARTITIONED_TABLE);
 	childrte->requiredPerms = 0;
 	childrte->securityQuals = NIL;
 	parse->rtable = lappend(parse->rtable, childrte);
 	childRTindex = list_length(parse->rtable);
 	*childRTindex_p = childRTindex;
 
-	/*
-	 * We need an AppendRelInfo if paths will be built for the child RTE. If
-	 * childrte->inh is true, then we'll always need to generate append paths
-	 * for it.  If childrte->inh is false, we must scan it if it's not a
-	 * partitioned table; but if it is a partitioned table, then it never has
-	 * any data of its own and need not be scanned.
-	 */
-	if (childrte->relkind != RELKIND_PARTITIONED_TABLE || childrte->inh)
-	{
-		appinfo = make_append_rel_info(parentrel, childrel,
-									   parentRTindex, childRTindex);
-		*appinfos = lappend(*appinfos, appinfo);
+	/* Create an AppendRelInfo and add it to planner's global list. */
+	appinfo = make_append_rel_info(parentrel, parentrte,
+								   RelationGetDescr(childrel),
+								   RelationGetRelid(childrel),
+								   RelationGetForm(childrel)->reltype,
+								   childRTindex);
+	root->append_rel_list = lappend(root->append_rel_list, appinfo);
 
-		/*
-		 * Translate the column permissions bitmaps to the child's attnums (we
-		 * have to build the translated_vars list before we can do this). But
-		 * if this is the parent table, leave copyObject's result alone.
-		 *
-		 * Note: we need to do this even though the executor won't run any
-		 * permissions checks on the child RTE.  The insertedCols/updatedCols
-		 * bitmaps may be examined for trigger-firing purposes.
-		 */
-		if (childOID != parentOID)
-		{
-			childrte->selectedCols = translate_col_privs(parentrte->selectedCols,
-														 appinfo->translated_vars);
-			childrte->insertedCols = translate_col_privs(parentrte->insertedCols,
-														 appinfo->translated_vars);
-			childrte->updatedCols = translate_col_privs(parentrte->updatedCols,
-														appinfo->translated_vars);
-		}
+	/*
+	 * Translate the column permissions bitmaps to the child's attnums (we
+	 * have to build the translated_vars list before we can do this). But
+	 * if this is the parent table, leave copyObject's result alone.
+	 *
+	 * Note: we need to do this even though the executor won't run any
+	 * permissions checks on the child RTE.  The insertedCols/updatedCols
+	 * bitmaps may be examined for trigger-firing purposes.
+	 */
+	if (childrte->relid != parentrte->relid)
+	{
+		childrte->selectedCols = translate_col_privs(parentrte->selectedCols,
+													 appinfo->translated_vars);
+		childrte->insertedCols = translate_col_privs(parentrte->insertedCols,
+													 appinfo->translated_vars);
+		childrte->updatedCols = translate_col_privs(parentrte->updatedCols,
+													appinfo->translated_vars);
 	}
 
 	/*
@@ -442,6 +536,253 @@ expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte,
 
 		root->rowMarks = lappend(root->rowMarks, childrc);
 	}
+
+	/*
+	 * Add the RelOptInfo.  Even though we may not really scan this relation
+	 * for reasons such as contradictory quals, we still need to create one,
+	 * because for every RTE in the query's range table, there must be an
+	 * accompanying RelOptInfo.
+	 */
+
+	/* First, store the RTE and appinfos into planner arrays. */
+	Assert(root->simple_rte_array[childRTindex] == NULL);
+	root->simple_rte_array[childRTindex] = childrte;
+	Assert(root->append_rel_array[childRTindex] == NULL);
+	root->append_rel_array[childRTindex] = appinfo;
+
+	childrelopt = build_inheritance_child_rel(root, parentrel, childRTindex);
+	Assert(childrelopt != NULL);
+
+	return childrelopt;
+}
+
+/*
+ *	build_inheritance_child_rel
+ *		Build a RelOptInfo for child relation of an inheritance set
+ *
+ * After creating the RelOptInfo for the given child RT index, it goes on to
+ * initialize some of its fields based on the parent RelOptInfo.
+ *
+ * If the quals in baserestrictinfo turn out to be self-contradictory,
+ * RelOptInfo is marked dummy before returning.
+ */
+static RelOptInfo *
+build_inheritance_child_rel(PlannerInfo *root,
+					   RelOptInfo *parent,
+					   Index childRTindex)
+{
+	RelOptInfo *childrel;
+	RangeTblEntry *childRTE = root->simple_rte_array[childRTindex];
+	AppendRelInfo *appinfo = root->append_rel_array[childRTindex];
+	List	   *childquals;
+	ListCell   *lc;
+	bool		have_const_false_cq;
+	Index		cq_min_security;
+
+	/* Build the RelOptInfo. */
+	childrel = build_simple_rel(root, childRTindex, parent);
+
+	/*
+	 * Propagate lateral_relids and lateral_referencers from appendrel
+	 * parent rels to their child rels.  We intentionally give each child rel
+	 * the same minimum parameterization, even though it's quite possible that
+	 * some don't reference all the lateral rels.  This is because any append
+	 * path for the parent will have to have the same parameterization for
+	 * every child anyway, and there's no value in forcing extra
+	 * reparameterize_path() calls.  Similarly, a lateral reference to the
+	 * parent prevents use of otherwise-movable join rels for each child.
+	 */
+	childrel->direct_lateral_relids = parent->direct_lateral_relids;
+	childrel->lateral_relids = parent->lateral_relids;
+	childrel->lateral_referencers = parent->lateral_referencers;
+
+	/*
+	 * We have to copy the parent's quals to the child, with appropriate
+	 * substitution of variables.  However, only the baserestrictinfo
+	 * quals are needed before we can check for constraint exclusion; so
+	 * do that first and then check to see if we can disregard this child.
+	 *
+	 * The child rel's targetlist might contain non-Var expressions, which
+	 * means that substitution into the quals could produce opportunities
+	 * for const-simplification, and perhaps even pseudoconstant quals.
+	 * Therefore, transform each RestrictInfo separately to see if it
+	 * reduces to a constant or pseudoconstant.  (We must process them
+	 * separately to keep track of the security level of each qual.)
+	 */
+	childquals = false;
+	cq_min_security = UINT_MAX;
+	have_const_false_cq = false;
+	foreach(lc, parent->baserestrictinfo)
+	{
+		RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
+		Node	   *childqual = (Node *) rinfo->clause;
+		ListCell   *lc2;
+
+		Assert(IsA(rinfo, RestrictInfo));
+		childqual = adjust_appendrel_attrs(root, childqual,
+										   1, &appinfo);
+		childqual = eval_const_expressions(root, childqual);
+		/* check for flat-out constant */
+		if (childqual && IsA(childqual, Const))
+		{
+			if (((Const *) childqual)->constisnull ||
+				!DatumGetBool(((Const *) childqual)->constvalue))
+			{
+				/* Restriction reduces to constant FALSE or NULL */
+				have_const_false_cq = true;
+				break;
+			}
+			/* Restriction reduces to constant TRUE, so drop it */
+			continue;
+		}
+		/* might have gotten an AND clause, if so flatten it */
+		foreach(lc2, make_ands_implicit((Expr *) childqual))
+		{
+			Node	   *onecq = (Node *) lfirst(lc2);
+			bool		pseudoconstant;
+
+			/* check for pseudoconstant (no Vars or volatile functions) */
+			pseudoconstant =
+					!contain_vars_of_level(onecq, 0) &&
+					!contain_volatile_functions(onecq);
+			if (pseudoconstant)
+			{
+				/* tell createplan.c to check for gating quals */
+				root->hasPseudoConstantQuals = true;
+			}
+			/* reconstitute RestrictInfo with appropriate properties */
+			childquals = lappend(childquals,
+								 make_restrictinfo((Expr *) onecq,
+												   rinfo->is_pushed_down,
+												   rinfo->outerjoin_delayed,
+												   pseudoconstant,
+												   rinfo->security_level,
+												   NULL, NULL, NULL));
+			cq_min_security = Min(cq_min_security, rinfo->security_level);
+		}
+	}
+
+	/*
+	 * In addition to the quals inherited from the parent, we might
+	 * have securityQuals associated with this particular child node.
+	 * (Currently this can only happen in appendrels originating from
+	 * UNION ALL; inheritance child tables don't have their own
+	 * securityQuals.)	Pull any such securityQuals up into the
+	 * baserestrictinfo for the child.  This is similar to
+	 * process_security_barrier_quals() for the parent rel, except
+	 * that we can't make any general deductions from such quals,
+	 * since they don't hold for the whole appendrel.
+	 */
+	if (childRTE->securityQuals)
+	{
+		Index		security_level = 0;
+
+		foreach(lc, childRTE->securityQuals)
+		{
+			List	   *qualset = (List *) lfirst(lc);
+			ListCell   *lc2;
+
+			foreach(lc2, qualset)
+			{
+				Expr	   *qual = (Expr *) lfirst(lc2);
+
+				/*
+				 * not likely that we'd see constants here, so no
+				 * check
+				 */
+				childquals = lappend(childquals,
+									 make_restrictinfo(qual,
+													   true,
+													   false,
+													   false,
+													   security_level,
+													   NULL, NULL,
+													   NULL));
+				cq_min_security = Min(cq_min_security, security_level);
+			}
+			security_level++;
+		}
+		Assert(security_level <= root->qual_security_level);
+	}
+
+	/* Set child's version of baserestrictinfo. */
+	childrel->baserestrictinfo = childquals;
+	childrel->baserestrict_min_security = cq_min_security;
+
+	if (have_const_false_cq)
+	{
+		/*
+		 * Some restriction clause reduced to constant FALSE or NULL after
+		 * substitution, so this child need not be scanned.
+		 */
+		set_dummy_rel_pathlist(childrel);
+	}
+
+	return childrel;
+}
+
+/*
+ * add_rowmark_junk_columns
+ * 		Add necessary junk columns for rowmarked inheritance parent rel.
+ *
+ * These values are needed for locking of rels selected FOR UPDATE/SHARE, and
+ * to do EvalPlanQual rechecking.  See comments for PlanRowMark in
+ * plannodes.h.
+ */
+static List *
+add_rowmark_junk_columns(PlannerInfo *root, PlanRowMark *rc)
+{
+	List   *tlist = root->processed_tlist;
+	Var		   *var;
+	char		resname[32];
+	TargetEntry *tle;
+
+	if (rc->allMarkTypes & ~(1 << ROW_MARK_COPY))
+	{
+		/* Need to fetch TID */
+		var = makeVar(rc->rti,
+					  SelfItemPointerAttributeNumber,
+					  TIDOID,
+					  -1,
+					  InvalidOid,
+					  0);
+		snprintf(resname, sizeof(resname), "ctid%u", rc->rowmarkId);
+		tle = makeTargetEntry((Expr *) var,
+							  list_length(tlist) + 1,
+							  pstrdup(resname),
+							  true);
+		tlist = lappend(tlist, tle);
+	}
+	if (rc->allMarkTypes & (1 << ROW_MARK_COPY))
+	{
+		/* Need the whole row as a junk var */
+		var = makeWholeRowVar(root->simple_rte_array[rc->rti],
+							  rc->rti,
+							  0,
+							  false);
+		snprintf(resname, sizeof(resname), "wholerow%u", rc->rowmarkId);
+		tle = makeTargetEntry((Expr *) var,
+							  list_length(tlist) + 1,
+							  pstrdup(resname),
+							  true);
+		tlist = lappend(tlist, tle);
+	}
+
+	/* For inheritance cases, always fetch the tableoid too. */
+	var = makeVar(rc->rti,
+				  TableOidAttributeNumber,
+				  OIDOID,
+				  -1,
+				  InvalidOid,
+				  0);
+	snprintf(resname, sizeof(resname), "tableoid%u", rc->rowmarkId);
+	tle = makeTargetEntry((Expr *) var,
+						  list_length(tlist) + 1,
+						  pstrdup(resname),
+						  true);
+	tlist = lappend(tlist, tle);
+
+	return tlist;
 }
 
 /*
@@ -583,7 +924,7 @@ create_inherited_target_child_root(PlannerInfo *root, AppendRelInfo *appinfo)
 	 * column, filling placeholder entries for dropped columns, etc., all of
 	 * which occurs with the child's TupleDesc.
 	 */
-	tlist = preprocess_targetlist(subroot);
+	tlist = preprocess_targetlist(subroot, true);
 	subroot->processed_tlist = tlist;
 
 	/* Add any newly added Vars to the child RelOptInfo. */
diff --git a/src/backend/optimizer/util/plancat.c b/src/backend/optimizer/util/plancat.c
index 6009de309e..293f9ac619 100644
--- a/src/backend/optimizer/util/plancat.c
+++ b/src/backend/optimizer/util/plancat.c
@@ -105,20 +105,20 @@ static void set_baserel_partition_key_exprs(Relation relation,
  * important for it.
  */
 void
-get_relation_info(PlannerInfo *root, Oid relationObjectId, bool inhparent,
-				  RelOptInfo *rel)
+get_relation_info(PlannerInfo *root, RangeTblEntry *rte, RelOptInfo *rel)
 {
 	Index		varno = rel->relid;
 	Relation	relation;
 	bool		hasindex;
 	List	   *indexinfos = NIL;
+	bool		inhparent = rte->inh;
 
 	/*
 	 * We need not lock the relation since it was already locked, either by
 	 * the rewriter or when expand_inherited_rtentry() added it to the query's
 	 * rangetable.
 	 */
-	relation = heap_open(relationObjectId, NoLock);
+	relation = heap_open(rte->relid, NoLock);
 
 	/* Temporary and unlogged relations are inaccessible during recovery. */
 	if (!RelationNeedsWAL(relation) && RecoveryInProgress())
@@ -444,11 +444,32 @@ get_relation_info(PlannerInfo *root, Oid relationObjectId, bool inhparent,
 	get_relation_foreign_keys(root, rel, relation, inhparent);
 
 	/*
-	 * Collect info about relation's partitioning scheme, if any. Only
-	 * inheritance parents may be partitioned.
+	 * Collect some additional information for inheritance parents.
 	 */
-	if (inhparent && relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
-		set_relation_partition_info(root, rel, relation);
+	if (inhparent)
+	{
+		/*
+		 * We'll need the TupleDesc when initializing the child relation.
+		 * A copy is being made because concurrent changes might drop
+		 * the relcache entry.  That's possible because ALTER TABLE
+		 * child_table NO INHERIT parent_table only requires an
+		 * AccessShareLock on parent_table.
+		 */
+		rel->tupdesc = CreateTupleDescCopy(RelationGetDescr(relation));
+		rel->reltype = RelationGetForm(relation)->reltype;
+
+		/*
+		 * If partitioned, also save the information of partitioning scheme,
+		 * and whether the query updates any of the partition key columns.
+		 */
+		if (relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
+		{
+			set_relation_partition_info(root, rel, relation);
+			root->partColsUpdated |= has_partition_attrs(relation,
+														 rte->updatedCols,
+														 NULL);
+		}
+	}
 
 	heap_close(relation, NoLock);
 
@@ -458,7 +479,7 @@ get_relation_info(PlannerInfo *root, Oid relationObjectId, bool inhparent,
 	 * removing an index, or adding a hypothetical index to the indexlist.
 	 */
 	if (get_relation_info_hook)
-		(*get_relation_info_hook) (root, relationObjectId, inhparent, rel);
+		(*get_relation_info_hook) (root, rte->relid, rte->inh, rel);
 }
 
 /*
@@ -1844,16 +1865,20 @@ set_relation_partition_info(PlannerInfo *root, RelOptInfo *rel,
 							Relation relation)
 {
 	PartitionDesc partdesc;
-	PartitionKey partkey;
 
 	Assert(relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE);
 
 	partdesc = RelationGetPartitionDesc(relation);
-	partkey = RelationGetPartitionKey(relation);
 	rel->part_scheme = find_partition_scheme(root, relation);
 	Assert(partdesc != NULL && rel->part_scheme != NULL);
-	rel->boundinfo = partition_bounds_copy(partdesc->boundinfo, partkey);
 	rel->nparts = partdesc->nparts;
+
+	/*
+	 * Since we must've taken a lock on the table, it's okay to simply copy
+	 * the pointers to relcache data here.
+	 */
+	rel->part_oids = partdesc->oids;
+	rel->boundinfo = partdesc->boundinfo;
 	set_baserel_partition_key_exprs(relation, rel);
 	rel->partition_qual = RelationGetPartitionQual(relation);
 }
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index 45f9950935..905fdc1419 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -131,6 +131,42 @@ setup_append_rel_array(PlannerInfo *root)
 	}
 }
 
+/* Expand the PlannerInfo arrays by add_size members and zero-init it. */
+void
+expand_planner_arrays(PlannerInfo *root, int add_size)
+{
+	int		new_size = root->simple_rel_array_size + add_size;
+
+	/* Expand various arrays and 0-initialize added bytes. */
+	root->simple_rte_array = (RangeTblEntry **)
+							repalloc(root->simple_rte_array,
+									 sizeof(RangeTblEntry *) * new_size);
+	MemSet(root->simple_rte_array + root->simple_rel_array_size,
+		   0, sizeof(RangeTblEntry *) * add_size);
+	root->simple_rel_array = (RelOptInfo **)
+								repalloc(root->simple_rel_array,
+										 sizeof(RelOptInfo *) * new_size);
+	MemSet(root->simple_rel_array + root->simple_rel_array_size,
+		   0, sizeof(RelOptInfo *) * add_size);
+
+	if (root->append_rel_array)
+	{
+		root->append_rel_array = (AppendRelInfo **)
+									repalloc(root->append_rel_array,
+									 sizeof(AppendRelInfo *) * new_size);
+		MemSet(root->append_rel_array + root->simple_rel_array_size,
+			   0, sizeof(AppendRelInfo *) * add_size);
+	}
+	else
+	{
+		root->append_rel_array = (AppendRelInfo **)
+									palloc0(sizeof(AppendRelInfo *) *
+											new_size);
+	}
+
+	root->simple_rel_array_size = new_size;
+}
+
 /*
  * build_simple_rel
  *	  Construct a new RelOptInfo for a base relation or 'other' relation.
@@ -236,7 +272,7 @@ build_simple_rel(PlannerInfo *root, int relid, RelOptInfo *parent)
 	{
 		case RTE_RELATION:
 			/* Table --- retrieve statistics from the system catalogs */
-			get_relation_info(root, rte->relid, rte->inh, rel);
+			get_relation_info(root, rte, rel);
 			break;
 		case RTE_SUBQUERY:
 		case RTE_FUNCTION:
@@ -277,52 +313,6 @@ build_simple_rel(PlannerInfo *root, int relid, RelOptInfo *parent)
 		root->qual_security_level = Max(root->qual_security_level,
 										list_length(rte->securityQuals));
 
-	/*
-	 * If this rel is an appendrel parent, recurse to build "other rel"
-	 * RelOptInfos for its children.  They are "other rels" because they are
-	 * not in the main join tree, but we will need RelOptInfos to plan access
-	 * to them.
-	 */
-	if (rte->inh)
-	{
-		ListCell   *l;
-		int			nparts = rel->nparts;
-		int			cnt_parts = 0;
-
-		if (nparts > 0)
-			rel->part_rels = (RelOptInfo **)
-				palloc(sizeof(RelOptInfo *) * nparts);
-
-		foreach(l, root->append_rel_list)
-		{
-			AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(l);
-			RelOptInfo *childrel;
-
-			/* append_rel_list contains all append rels; ignore others */
-			if (appinfo->parent_relid != relid)
-				continue;
-
-			childrel = build_simple_rel(root, appinfo->child_relid,
-										rel);
-
-			/* Nothing more to do for an unpartitioned table. */
-			if (!rel->part_scheme)
-				continue;
-
-			/*
-			 * The order of partition OIDs in append_rel_list is the same as
-			 * the order in the PartitionDesc, so the order of part_rels will
-			 * also match the PartitionDesc.  See expand_partitioned_rtentry.
-			 */
-			Assert(cnt_parts < nparts);
-			rel->part_rels[cnt_parts] = childrel;
-			cnt_parts++;
-		}
-
-		/* We should have seen all the child partitions. */
-		Assert(cnt_parts == nparts);
-	}
-
 	return rel;
 }
 
diff --git a/src/backend/partitioning/partprune.c b/src/backend/partitioning/partprune.c
index 901433c68c..9bb472fd98 100644
--- a/src/backend/partitioning/partprune.c
+++ b/src/backend/partitioning/partprune.c
@@ -46,6 +46,7 @@
 #include "nodes/nodeFuncs.h"
 #include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
+#include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
 #include "optimizer/planner.h"
 #include "optimizer/predtest.h"
@@ -437,17 +438,23 @@ make_partitionedrel_pruneinfo(PlannerInfo *root, RelOptInfo *parentrel,
 		 * is, not pruned already).
 		 */
 		subplan_map = (int *) palloc(nparts * sizeof(int));
+		memset(subplan_map, -1, nparts * sizeof(int));
 		subpart_map = (int *) palloc(nparts * sizeof(int));
+		memset(subpart_map, -1, nparts * sizeof(int));
 		present_parts = NULL;
 
 		for (i = 0; i < nparts; i++)
 		{
 			RelOptInfo *partrel = subpart->part_rels[i];
-			int			subplanidx = relid_subplan_map[partrel->relid] - 1;
-			int			subpartidx = relid_subpart_map[partrel->relid] - 1;
+			int			subplanidx;
+			int			subpartidx;
 
-			subplan_map[i] = subplanidx;
-			subpart_map[i] = subpartidx;
+			/* Skip processing pruned partitions. */
+			if (partrel == NULL)
+				continue;
+
+			subplan_map[i] = subplanidx = relid_subplan_map[partrel->relid] - 1;
+			subpart_map[i] = subpartidx = relid_subpart_map[partrel->relid] - 1;
 			if (subplanidx >= 0)
 			{
 				present_parts = bms_add_member(present_parts, i);
@@ -541,23 +548,20 @@ gen_partprune_steps(RelOptInfo *rel, List *clauses, bool *contradictory)
 
 /*
  * prune_append_rel_partitions
- *		Returns RT indexes of the minimum set of child partitions which must
- *		be scanned to satisfy rel's baserestrictinfo quals.
+ *		Returns indexes into rel->part_rels of the minimum set of child
+ *		partitions which must be scanned to satisfy rel's baserestrictinfo
+ *		quals.
  *
  * Callers must ensure that 'rel' is a partitioned table.
  */
-Relids
+Bitmapset *
 prune_append_rel_partitions(RelOptInfo *rel)
 {
-	Relids		result;
 	List	   *clauses = rel->baserestrictinfo;
 	List	   *pruning_steps;
 	bool		contradictory;
 	PartitionPruneContext context;
-	Bitmapset  *partindexes;
-	int			i;
 
-	Assert(clauses != NIL);
 	Assert(rel->part_scheme != NULL);
 
 	/* If there are no partitions, return the empty set */
@@ -565,6 +569,13 @@ prune_append_rel_partitions(RelOptInfo *rel)
 		return NULL;
 
 	/*
+	 * If pruning is disabled or if there are no clauses to prune with,
+	 * return all partitions.
+	 */
+	if (!enable_partition_pruning || clauses == NIL)
+		return bms_add_range(NULL, 0, rel->nparts - 1);
+
+	/*
 	 * Process clauses.  If the clauses are found to be contradictory, we can
 	 * return the empty set.
 	 */
@@ -591,15 +602,7 @@ prune_append_rel_partitions(RelOptInfo *rel)
 	context.evalexecparams = false;
 
 	/* Actual pruning happens here. */
-	partindexes = get_matching_partitions(&context, pruning_steps);
-
-	/* Add selected partitions' RT indexes to result. */
-	i = -1;
-	result = NULL;
-	while ((i = bms_next_member(partindexes, i)) >= 0)
-		result = bms_add_member(result, rel->part_rels[i]->relid);
-
-	return result;
+	return get_matching_partitions(&context, pruning_steps);
 }
 
 /*
diff --git a/src/include/nodes/relation.h b/src/include/nodes/relation.h
index db439bd904..01a664d246 100644
--- a/src/include/nodes/relation.h
+++ b/src/include/nodes/relation.h
@@ -15,6 +15,7 @@
 #define RELATION_H
 
 #include "access/sdir.h"
+#include "access/tupdesc.h"
 #include "fmgr.h"
 #include "lib/stringinfo.h"
 #include "nodes/params.h"
@@ -729,6 +730,7 @@ typedef struct RelOptInfo
 	int			nparts;			/* number of partitions */
 	struct PartitionBoundInfoData *boundinfo;	/* Partition bounds */
 	List	   *partition_qual; /* partition constraint */
+	Oid		   *part_oids;		/* partition OIDs */
 	struct RelOptInfo **part_rels;	/* Array of RelOptInfos of partitions,
 									 * stored in the same order of bounds */
 	List	  **partexprs;		/* Non-nullable partition key expressions. */
@@ -743,6 +745,13 @@ typedef struct RelOptInfo
 	 * RT index of UNION ALL parent subquery.
 	 */
 	Index		inh_root_parent;
+
+	/*
+	 * Set only if this is an inheritance parent relation.  This information
+	 * is needed when initializing the planning info for children.
+	 */
+	TupleDesc	tupdesc;		/* A "copy" of the table's tuple desriptor */
+	Oid			reltype;		/* Table's reltype */
 } RelOptInfo;
 
 /*
diff --git a/src/include/optimizer/appendinfo.h b/src/include/optimizer/appendinfo.h
index 156a0e077d..689d39517a 100644
--- a/src/include/optimizer/appendinfo.h
+++ b/src/include/optimizer/appendinfo.h
@@ -17,9 +17,10 @@
 #include "nodes/relation.h"
 #include "utils/relcache.h"
 
-extern AppendRelInfo *make_append_rel_info(Relation parentrel,
-					 Relation childrel,
-					 Index parentRTindex, Index childRTindex);
+extern AppendRelInfo *make_append_rel_info(RelOptInfo *parent,
+					 RangeTblEntry *parentrte,
+					 TupleDesc childdesc, Oid childoid, Oid childtype,
+					 Index childRTindex);
 extern Node *adjust_appendrel_attrs(PlannerInfo *root, Node *node,
 					   int nappinfos, AppendRelInfo **appinfos);
 extern Node *adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node,
diff --git a/src/include/optimizer/pathnode.h b/src/include/optimizer/pathnode.h
index bd905d3328..e7d0a20c54 100644
--- a/src/include/optimizer/pathnode.h
+++ b/src/include/optimizer/pathnode.h
@@ -261,6 +261,7 @@ extern Path *reparameterize_path_by_child(PlannerInfo *root, Path *path,
  */
 extern void setup_simple_rel_arrays(PlannerInfo *root);
 extern void setup_append_rel_array(PlannerInfo *root);
+extern void expand_planner_arrays(PlannerInfo *root, int add_size);
 extern RelOptInfo *build_simple_rel(PlannerInfo *root, int relid,
 				 RelOptInfo *parent);
 extern RelOptInfo *find_base_rel(PlannerInfo *root, int relid);
diff --git a/src/include/optimizer/plancat.h b/src/include/optimizer/plancat.h
index a1b23251a1..d8091cdfa4 100644
--- a/src/include/optimizer/plancat.h
+++ b/src/include/optimizer/plancat.h
@@ -25,8 +25,8 @@ typedef void (*get_relation_info_hook_type) (PlannerInfo *root,
 extern PGDLLIMPORT get_relation_info_hook_type get_relation_info_hook;
 
 
-extern void get_relation_info(PlannerInfo *root, Oid relationObjectId,
-				  bool inhparent, RelOptInfo *rel);
+extern void get_relation_info(PlannerInfo *root, RangeTblEntry *rte,
+				  RelOptInfo *rel);
 
 extern List *infer_arbiter_indexes(PlannerInfo *root);
 
diff --git a/src/include/optimizer/prep.h b/src/include/optimizer/prep.h
index 62d45dd142..a329e87fc2 100644
--- a/src/include/optimizer/prep.h
+++ b/src/include/optimizer/prep.h
@@ -38,7 +38,8 @@ extern Expr *canonicalize_qual(Expr *qual, bool is_check);
 /*
  * prototypes for preptlist.c
  */
-extern List *preprocess_targetlist(PlannerInfo *root);
+extern List *preprocess_targetlist(PlannerInfo *root,
+							bool inheritance_expanded);
 
 extern PlanRowMark *get_plan_rowmark(List *rowmarks, Index rtindex);
 
diff --git a/src/include/partitioning/partprune.h b/src/include/partitioning/partprune.h
index ce9bc8d9fd..5c5d27d040 100644
--- a/src/include/partitioning/partprune.h
+++ b/src/include/partitioning/partprune.h
@@ -76,7 +76,7 @@ extern PartitionPruneInfo *make_partition_pruneinfo(PlannerInfo *root,
 						 List *subpaths,
 						 List *partitioned_rels,
 						 List *prunequal);
-extern Relids prune_append_rel_partitions(RelOptInfo *rel);
+extern Bitmapset *prune_append_rel_partitions(RelOptInfo *rel);
 extern Bitmapset *get_matching_partitions(PartitionPruneContext *context,
 						List *pruning_steps);
 
diff --git a/src/test/regress/expected/partition_aggregate.out b/src/test/regress/expected/partition_aggregate.out
index 6bc106831e..1450cef057 100644
--- a/src/test/regress/expected/partition_aggregate.out
+++ b/src/test/regress/expected/partition_aggregate.out
@@ -144,7 +144,7 @@ SELECT c, sum(a) FROM pagg_tab WHERE 1 = 2 GROUP BY c;
            QUERY PLAN           
 --------------------------------
  HashAggregate
-   Group Key: pagg_tab.c
+   Group Key: c
    ->  Result
          One-Time Filter: false
 (4 rows)
@@ -159,7 +159,7 @@ SELECT c, sum(a) FROM pagg_tab WHERE c = 'x' GROUP BY c;
            QUERY PLAN           
 --------------------------------
  GroupAggregate
-   Group Key: pagg_tab.c
+   Group Key: c
    ->  Result
          One-Time Filter: false
 (4 rows)
-- 
2.11.0

From e40ac4001b12b5a04a905ae7b34d1e7c049c137d Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Mon, 15 Oct 2018 10:59:24 +0900
Subject: [PATCH v14 5/6] Teach planner to only process unpruned partitions

This adds a bitmapset field live_parts to RelOptInfo and stores
the partition indexes of non-dummy partitions in it, meaning it
contains indexes of only those partitions that have a non-NULL
RelOptInfo present in its parent's RelOptInfo's part_rels array.

This speeds up processing partitioned table's partitions compared
to going through the whole part_rels array in a number of places.
---
 src/backend/optimizer/path/joinrels.c |  3 +++
 src/backend/optimizer/plan/planner.c  | 18 +++++++++---------
 src/backend/optimizer/util/inherit.c  |  1 +
 src/backend/optimizer/util/relnode.c  |  3 +++
 src/backend/partitioning/partprune.c  | 18 +++++-------------
 src/include/nodes/relation.h          |  4 ++++
 6 files changed, 25 insertions(+), 22 deletions(-)

diff --git a/src/backend/optimizer/path/joinrels.c b/src/backend/optimizer/path/joinrels.c
index 411cdbd84f..eb0e918d05 100644
--- a/src/backend/optimizer/path/joinrels.c
+++ b/src/backend/optimizer/path/joinrels.c
@@ -1426,6 +1426,9 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
 		populate_joinrel_with_paths(root, child_rel1, child_rel2,
 									child_joinrel, child_sjinfo,
 									child_restrictlist);
+		if (!IS_DUMMY_REL(child_joinrel))
+			joinrel->live_parts = bms_add_member(joinrel->live_parts,
+												 cnt_parts);
 	}
 }
 
diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index f80f35eed3..faf5f343fb 100644
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -6833,7 +6833,9 @@ apply_scanjoin_target_to_paths(PlannerInfo *root,
 		List	   *live_children = NIL;
 
 		/* Adjust each partition. */
-		for (partition_idx = 0; partition_idx < rel->nparts; partition_idx++)
+		partition_idx = -1;
+		while ((partition_idx = bms_next_member(rel->live_parts,
+												partition_idx)) >= 0)
 		{
 			RelOptInfo *child_rel = rel->part_rels[partition_idx];
 			ListCell   *lc;
@@ -6841,9 +6843,7 @@ apply_scanjoin_target_to_paths(PlannerInfo *root,
 			int			nappinfos;
 			List	   *child_scanjoin_targets = NIL;
 
-			/* Skip processing pruned partitions. */
-			if (child_rel == NULL)
-				continue;
+			Assert(child_rel != NULL);
 
 			/* Translate scan/join targets for this child. */
 			appinfos = find_appinfos_by_relids(root, child_rel->relids,
@@ -6924,7 +6924,6 @@ create_partitionwise_grouping_paths(PlannerInfo *root,
 									PartitionwiseAggregateType patype,
 									GroupPathExtraData *extra)
 {
-	int			nparts = input_rel->nparts;
 	int			cnt_parts;
 	List	   *grouped_live_children = NIL;
 	List	   *partially_grouped_live_children = NIL;
@@ -6936,7 +6935,9 @@ create_partitionwise_grouping_paths(PlannerInfo *root,
 		   partially_grouped_rel != NULL);
 
 	/* Add paths for partitionwise aggregation/grouping. */
-	for (cnt_parts = 0; cnt_parts < nparts; cnt_parts++)
+	cnt_parts = -1;
+	while ((cnt_parts = bms_next_member(input_rel->live_parts,
+										cnt_parts)) >= 0)
 	{
 		RelOptInfo *child_input_rel = input_rel->part_rels[cnt_parts];
 		PathTarget *child_target = copy_pathtarget(target);
@@ -6946,9 +6947,8 @@ create_partitionwise_grouping_paths(PlannerInfo *root,
 		RelOptInfo *child_grouped_rel;
 		RelOptInfo *child_partially_grouped_rel;
 
-		/* Skip processing pruned partitions. */
-		if (child_input_rel == NULL)
-			continue;
+		/* A live partition must have a RelOptInfo. */
+		Assert(child_input_rel != NULL);
 
 		/* Input child rel must have a path */
 		Assert(child_input_rel->pathlist != NIL);
diff --git a/src/backend/optimizer/util/inherit.c b/src/backend/optimizer/util/inherit.c
index 0e927254c7..776d02c81a 100644
--- a/src/backend/optimizer/util/inherit.c
+++ b/src/backend/optimizer/util/inherit.c
@@ -360,6 +360,7 @@ expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
 
 	/* Perform pruning. */
 	partindexes = prune_append_rel_partitions(parentrel);
+	parentrel->live_parts = partindexes;
 
 	/* Must expand PlannerInfo arrays before we can add children. */
 	expand_planner_arrays(root, bms_num_members(partindexes));
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index 905fdc1419..fa52aaa6de 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -1749,6 +1749,9 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
 		joinrel->partexprs[cnt] = partexpr;
 		joinrel->nullable_partexprs[cnt] = nullable_partexpr;
 	}
+
+	/* Partitions will be added by try_partitionwise_join. */
+	joinrel->live_parts = NULL;
 }
 
 /*
diff --git a/src/backend/partitioning/partprune.c b/src/backend/partitioning/partprune.c
index 9bb472fd98..088b191bdd 100644
--- a/src/backend/partitioning/partprune.c
+++ b/src/backend/partitioning/partprune.c
@@ -441,29 +441,21 @@ make_partitionedrel_pruneinfo(PlannerInfo *root, RelOptInfo *parentrel,
 		memset(subplan_map, -1, nparts * sizeof(int));
 		subpart_map = (int *) palloc(nparts * sizeof(int));
 		memset(subpart_map, -1, nparts * sizeof(int));
-		present_parts = NULL;
+		present_parts = bms_copy(subpart->live_parts);
 
-		for (i = 0; i < nparts; i++)
+		i = -1;
+		while ((i = bms_next_member(present_parts, i)) >= 0)
 		{
 			RelOptInfo *partrel = subpart->part_rels[i];
 			int			subplanidx;
 			int			subpartidx;
 
-			/* Skip processing pruned partitions. */
-			if (partrel == NULL)
-				continue;
-
+			Assert(partrel != NULL);
 			subplan_map[i] = subplanidx = relid_subplan_map[partrel->relid] - 1;
 			subpart_map[i] = subpartidx = relid_subpart_map[partrel->relid] - 1;
+			/* Record finding this subplan */
 			if (subplanidx >= 0)
-			{
-				present_parts = bms_add_member(present_parts, i);
-
-				/* Record finding this subplan  */
 				subplansfound = bms_add_member(subplansfound, subplanidx);
-			}
-			else if (subpartidx >= 0)
-				present_parts = bms_add_member(present_parts, i);
 		}
 
 		pinfo = makeNode(PartitionedRelPruneInfo);
diff --git a/src/include/nodes/relation.h b/src/include/nodes/relation.h
index 01a664d246..d27611c2c7 100644
--- a/src/include/nodes/relation.h
+++ b/src/include/nodes/relation.h
@@ -733,6 +733,10 @@ typedef struct RelOptInfo
 	Oid		   *part_oids;		/* partition OIDs */
 	struct RelOptInfo **part_rels;	/* Array of RelOptInfos of partitions,
 									 * stored in the same order of bounds */
+	Bitmapset  *live_parts;		/* Indexes into part_rels of the non-NULL
+								 * RelOptInfos of unpruned partitions; exists
+								 * to avoid having to iterate over the entire
+								 * part_rels array to filter NULL entries. */
 	List	  **partexprs;		/* Non-nullable partition key expressions. */
 	List	  **nullable_partexprs; /* Nullable partition key expressions. */
 	List	   *partitioned_child_rels; /* List of RT indexes. */
-- 
2.11.0

From 9fff3f615968d365fc96ffcd2debbbf590bd6386 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Fri, 12 Oct 2018 19:12:53 +0900
Subject: [PATCH v14 6/6] Do not lock all partitions at the beginning

---
 src/backend/optimizer/util/inherit.c | 11 +----------
 1 file changed, 1 insertion(+), 10 deletions(-)

diff --git a/src/backend/optimizer/util/inherit.c b/src/backend/optimizer/util/inherit.c
index 776d02c81a..d88b9a7cb7 100644
--- a/src/backend/optimizer/util/inherit.c
+++ b/src/backend/optimizer/util/inherit.c
@@ -327,10 +327,6 @@ expand_nonpartitioned_inherited_rtentry(PlannerInfo *root,
  *
  * Partitions are added to the query in order in which they are found in
  * the parent's PartitionDesc.
- *
- * Note: even though only the unpruned partitions will be added to the
- * resulting plan, this still locks *all* partitions via find_all_inheritors
- * when this function is called for the root partitioned table.
  */
 static void
 expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
@@ -344,10 +340,6 @@ expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
 									parentrel->inh_root_parent :
 									parentRTindex;
 
-	/* If root partitioned table, lock *all* partitions in the tree. */
-	if (parentRTindex == rootParentRTindex)
-		(void) find_all_inheritors(parentrte->relid, lockmode, NULL);
-
 	/*
 	 * Initialize partitioned_child_rels to contain this RT index.
 	 *
@@ -383,8 +375,7 @@ expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
 		RangeTblEntry *childrte;
 		Index		childRTindex;
 
-		/* Already locked above. */
-		newrelation = heap_open(childOID, NoLock);
+		newrelation = heap_open(childOID, lockmode);
 		Assert(!RELATION_IS_OTHER_TEMP(newrelation));
 
 		/*
-- 
2.11.0

From 198dc6d3e932ff8aaa4d787368ee9fd7101459a1 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Wed, 17 Oct 2018 11:18:12 +0900
Subject: [PATCH v15 1/4] Overhaul inheritance update/delete planning

With the current method, inheritance_planner, which handles the
planning for update/delete commands targeting inheritance trees,
repeatedly calls query_planner for each child table.

That's inefficient for two reasons:

 1. partprune.c cannot be used to perform partition pruning, because
    it can only be invoked from query_planner.  With the current
    approach, query_planner only sees the individual partitions in
    the query tree it receives, not the parent partitioned table.
    This leaves each partition to be pruned using constraint
    exclusion.  (constraint exclusion cannon prune hash partitions
    which means UPDATE/DELETE don't support hash partition pruning.)

 2. Repeated invocation of query_planner results in allocating large
    amounts of memory, especially if there are many child tables.
    Also, it involves repeatedly performing the same processing,
    such as jointree processing.

This commit addresses both of the issues by modifying query_planner
to handle the inheritance target case directly.  Instead of having
the caller create separate PlannerInfo's for individual child
target relations and pass them to query_planner (actually, via
grouping_planner), this teaches query_planner itself to create
the child PlannerInfo's by the original parent PlannerInfo.
It creates them *after* it has generated enough state in the latter,
such as RelOptInfos for various relations, EquivalenceClasses
after processing the join tree, and *before* generating the scan and
join paths.  Scan paths are generated normally, except that Paths of
target children are not "appended".  Join paths are generated
separately for each child target relation, that is, by replacing the
parent relation references in the original join tree with the child
relation references.  Joinrels (RelOptInfos thereof) corresponding
to various child target relation are saved in the parent PlannerInfo
for further processing.

inheritance_planner now calls query_planner just once at the beginning
with the original unmodified query, which takes care of generating
top-level join rels for the child queries as described above.  For each
child join rel, it then calls grouping_planner using previously created
child PlannerInfo to finish up the paths such that they produce
query's top-level target list expanded according to a given child
relation's descriptor.  grouping_planner()'s interface is modified so
that we can pass it what's called a 'planned_rel', a RelOptInfo that
already contains the necessary paths needed to produce its output.

This removes some existing code in inheritance_planner that dealt
with any subquery RTEs in the query.  The rationale of that code
was that the subquery RTEs may change during each iteration of
planning (that is, for different children), so different iterations
better use different copies of those RTEs.  That was handled by
making fresh copies of those RTEs for each iteration of planning
which were appended to the range table, accompanied by modifying all
expressions and auxiliary structures that referenced the original
subquery RTEs to instead reference the copies (that is, change the
varnos).  This copying meant we would end up adding S * N new entries
to the original range table by the time we got to the last unpruned
child, where S is the number of subquery RTEs in the original query
and N the number of unpruned children.  Since with the new code
we perform planning just once, I think we don't need this special
handling.  Actually, there is a regression test output change due
to no longer having copies of subquery RTEs (see the diff of
partition_join.out file.)

Also we no longer need the hack in relation_excluded_by_constraints()
involving setting PlannerInfo.inhTargetKind to enable constraint
exclusion for target child relation, which is no longer needed.
Constraint exclusion now runs during query_planner step described
above.

Regression test output change in partition_join.out is due to the fact
that we no longer create duplicates of subquery RTEs in child range
tables.
---
 doc/src/sgml/ddl.sgml                        |  17 +-
 src/backend/nodes/outfuncs.c                 |   2 +-
 src/backend/optimizer/path/allpaths.c        | 614 +++++++++++++++++++++++++--
 src/backend/optimizer/path/equivclass.c      |  57 ++-
 src/backend/optimizer/plan/createplan.c      |  10 -
 src/backend/optimizer/plan/planmain.c        |  48 ++-
 src/backend/optimizer/plan/planner.c         | 444 ++++++-------------
 src/backend/optimizer/prep/prepjointree.c    |   1 -
 src/backend/optimizer/util/appendinfo.c      |  33 +-
 src/backend/optimizer/util/inherit.c         | 109 +++++
 src/backend/optimizer/util/plancat.c         |  73 +---
 src/include/nodes/relation.h                 |  37 +-
 src/include/optimizer/inherit.h              |   1 +
 src/include/optimizer/paths.h                |   3 +-
 src/test/regress/expected/partition_join.out |   4 +-
 15 files changed, 988 insertions(+), 465 deletions(-)

diff --git a/doc/src/sgml/ddl.sgml b/doc/src/sgml/ddl.sgml
index 85e4358988..1bb5ca6b08 100644
--- a/doc/src/sgml/ddl.sgml
+++ b/doc/src/sgml/ddl.sgml
@@ -4439,24 +4439,11 @@ EXPLAIN SELECT count(*) FROM measurement WHERE logdate &gt;= DATE '2008-01-01';
 
    <note>
     <para>
-     Currently, pruning of partitions during the planning of an
-     <command>UPDATE</command> or <command>DELETE</command> command is
-     implemented using the constraint exclusion method (however, it is
-     controlled by the <literal>enable_partition_pruning</literal> rather than
-     <literal>constraint_exclusion</literal>) &mdash; see the following section
-     for details and caveats that apply.
-    </para>
-
-    <para>
      Execution-time partition pruning currently only occurs for the
      <literal>Append</literal> and <literal>MergeAppend</literal> node types.
      It is not yet implemented for the <literal>ModifyTable</literal> node
-     type.
-    </para>
-
-    <para>
-     Both of these behaviors are likely to be changed in a future release
-     of <productname>PostgreSQL</productname>.
+     type, but that is likely to be changed in a future release of
+     <productname>PostgreSQL</productname>.
     </para>
    </note>
   </sect2>
diff --git a/src/backend/nodes/outfuncs.c b/src/backend/nodes/outfuncs.c
index 0fde876c77..158da68925 100644
--- a/src/backend/nodes/outfuncs.c
+++ b/src/backend/nodes/outfuncs.c
@@ -2210,7 +2210,6 @@ _outPlannerInfo(StringInfo str, const PlannerInfo *node)
 	WRITE_FLOAT_FIELD(tuple_fraction, "%.4f");
 	WRITE_FLOAT_FIELD(limit_tuples, "%.0f");
 	WRITE_UINT_FIELD(qual_security_level);
-	WRITE_ENUM_FIELD(inhTargetKind, InheritanceKind);
 	WRITE_BOOL_FIELD(hasJoinRTEs);
 	WRITE_BOOL_FIELD(hasLateralRTEs);
 	WRITE_BOOL_FIELD(hasDeletedRTEs);
@@ -2221,6 +2220,7 @@ _outPlannerInfo(StringInfo str, const PlannerInfo *node)
 	WRITE_BITMAPSET_FIELD(curOuterRels);
 	WRITE_NODE_FIELD(curOuterParams);
 	WRITE_BOOL_FIELD(partColsUpdated);
+	WRITE_BOOL_FIELD(inherited_update);
 }
 
 static void
diff --git a/src/backend/optimizer/path/allpaths.c b/src/backend/optimizer/path/allpaths.c
index bc389b52e4..3324d485e4 100644
--- a/src/backend/optimizer/path/allpaths.c
+++ b/src/backend/optimizer/path/allpaths.c
@@ -38,6 +38,7 @@
 #include "optimizer/pathnode.h"
 #include "optimizer/paths.h"
 #include "optimizer/plancat.h"
+#include "optimizer/planmain.h"
 #include "optimizer/planner.h"
 #include "optimizer/restrictinfo.h"
 #include "optimizer/tlist.h"
@@ -92,8 +93,12 @@ static void set_foreign_size(PlannerInfo *root, RelOptInfo *rel,
 				 RangeTblEntry *rte);
 static void set_foreign_pathlist(PlannerInfo *root, RelOptInfo *rel,
 					 RangeTblEntry *rte);
+static void set_inherit_target_rel_sizes(PlannerInfo *root, RelOptInfo *rel,
+							 Index rti, RangeTblEntry *rte);
 static void set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 					Index rti, RangeTblEntry *rte);
+static void set_inherit_target_rel_pathlists(PlannerInfo *root,
+							 RelOptInfo *rel, Index rti, RangeTblEntry *rte);
 static void set_append_rel_pathlist(PlannerInfo *root, RelOptInfo *rel,
 						Index rti, RangeTblEntry *rte);
 static void generate_mergeappend_paths(PlannerInfo *root, RelOptInfo *rel,
@@ -120,6 +125,8 @@ static void set_namedtuplestore_pathlist(PlannerInfo *root, RelOptInfo *rel,
 static void set_worktable_pathlist(PlannerInfo *root, RelOptInfo *rel,
 					   RangeTblEntry *rte);
 static RelOptInfo *make_rel_from_joinlist(PlannerInfo *root, List *joinlist);
+static void inheritance_make_rel_from_joinlist(PlannerInfo *root,
+						List *joinlist);
 static bool subquery_is_pushdown_safe(Query *subquery, Query *topquery,
 						  pushdown_safety_info *safetyInfo);
 static bool recurse_pushdown_safe(Node *setOp, Query *topquery,
@@ -150,27 +157,6 @@ make_one_rel(PlannerInfo *root, List *joinlist)
 	Index		rti;
 	double		total_pages;
 
-	/*
-	 * Construct the all_baserels Relids set.
-	 */
-	root->all_baserels = NULL;
-	for (rti = 1; rti < root->simple_rel_array_size; rti++)
-	{
-		RelOptInfo *brel = root->simple_rel_array[rti];
-
-		/* there may be empty slots corresponding to non-baserel RTEs */
-		if (brel == NULL)
-			continue;
-
-		Assert(brel->relid == rti); /* sanity check on array */
-
-		/* ignore RTEs that are "other rels" */
-		if (brel->reloptkind != RELOPT_BASEREL)
-			continue;
-
-		root->all_baserels = bms_add_member(root->all_baserels, brel->relid);
-	}
-
 	/* Mark base rels as to whether we care about fast-start plans */
 	set_base_rel_consider_startup(root);
 
@@ -218,13 +204,34 @@ make_one_rel(PlannerInfo *root, List *joinlist)
 
 	/*
 	 * Generate access paths for the entire join tree.
+	 *
+	 * For UPDATE/DELETE on an inheritance parent, join paths should be
+	 * generated for each child result rel separately.
 	 */
-	rel = make_rel_from_joinlist(root, joinlist);
+	if (root->parse->resultRelation &&
+		root->simple_rte_array[root->parse->resultRelation]->inh)
+	{
+		inheritance_make_rel_from_joinlist(root, joinlist);
 
-	/*
-	 * The result should join all and only the query's base rels.
-	 */
-	Assert(bms_equal(rel->relids, root->all_baserels));
+		/*
+		 * Return the RelOptInfo of original target relation, although this
+		 * doesn't really contain the final path.  inheritance_planner
+		 * from where we got here will generate the final path, but it will
+		 * do so by iterative over child subroots, not through this
+		 * RelOptInfo.
+		 */
+		rel = find_base_rel(root, root->parse->resultRelation);
+	}
+	else
+	{
+		rel = make_rel_from_joinlist(root, joinlist);
+
+		/*
+		 * The result should join all and only the query's base rels.
+		 */
+		Assert(bms_equal(rel->relids, root->all_baserels));
+
+	}
 
 	return rel;
 }
@@ -308,9 +315,10 @@ set_base_rel_sizes(PlannerInfo *root)
 		 * If parallelism is allowable for this query in general, see whether
 		 * it's allowable for this rel in particular.  We have to do this
 		 * before set_rel_size(), because (a) if this rel is an inheritance
-		 * parent, set_append_rel_size() will use and perhaps change the rel's
-		 * consider_parallel flag, and (b) for some RTE types, set_rel_size()
-		 * goes ahead and makes paths immediately.
+		 * parent, set_append_rel_size() or set_inherit_target_rel_sizes()
+		 * will use and perhaps change the rel's consider_parallel flag, and
+		 * (b) for some RTE types, set_rel_size() goes ahead and makes paths
+		 * immediately.
 		 */
 		if (root->glob->parallelModeOK)
 			set_rel_consider_parallel(root, rel, rte);
@@ -374,8 +382,15 @@ set_rel_size(PlannerInfo *root, RelOptInfo *rel,
 	}
 	else if (rte->inh)
 	{
-		/* It's an "append relation", process accordingly */
-		set_append_rel_size(root, rel, rti, rte);
+		/*
+		 * If it's a target relation, set the sizes of children instead.
+		 * Otherwise, we'll append the outputs of children, so process it as
+		 * an "append relation".
+		 */
+		if (rti == root->parse->resultRelation)
+			set_inherit_target_rel_sizes(root, rel, rti, rte);
+		else
+			set_append_rel_size(root, rel, rti, rte);
 	}
 	else
 	{
@@ -459,14 +474,26 @@ static void
 set_rel_pathlist(PlannerInfo *root, RelOptInfo *rel,
 				 Index rti, RangeTblEntry *rte)
 {
+	bool	inherited_update = false;
+
 	if (IS_DUMMY_REL(rel))
 	{
 		/* We already proved the relation empty, so nothing more to do */
 	}
 	else if (rte->inh)
 	{
-		/* It's an "append relation", process accordingly */
-		set_append_rel_pathlist(root, rel, rti, rte);
+		/*
+		 * If it's a target relation, set the pathlists of children instead.
+		 * Otherwise, we'll append the outputs of children, so process it as
+		 * an "append relation".
+		 */
+		if (root->inherited_update && root->parse->resultRelation == rti)
+		{
+			inherited_update = true;
+			set_inherit_target_rel_pathlists(root, rel, rti, rte);
+		}
+		else
+			set_append_rel_pathlist(root, rel, rti, rte);
 	}
 	else
 	{
@@ -541,8 +568,12 @@ set_rel_pathlist(PlannerInfo *root, RelOptInfo *rel,
 	if (set_rel_pathlist_hook)
 		(*set_rel_pathlist_hook) (root, rel, rti, rte);
 
-	/* Now find the cheapest of the paths for this rel */
-	set_cheapest(rel);
+	/*
+	 * Now find the cheapest of the paths for this rel, unless it's an
+	 * inheritance parent and this is an update/delete operation.
+	 */
+	if (!inherited_update)
+		set_cheapest(rel);
 
 #ifdef OPTIMIZER_DEBUG
 	debug_print_rel(root, rel);
@@ -904,6 +935,382 @@ set_foreign_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
 }
 
 /*
+ * set_inherit_target_rel_sizes
+ *	  Set size estimates for the child target relations
+ *
+ * The passed-in rel represents the target relation of the query that is
+ * known to have inheritance children.  This is very much like
+ * set_append_rel_size, except it doesn't set the size estimates for the
+ * passed-in rel itself, because we don't need to "append" the children
+ * in this case.
+ */
+static void
+set_inherit_target_rel_sizes(PlannerInfo *root, RelOptInfo *rel,
+							 Index rti, RangeTblEntry *rte)
+{
+	int			parentRTindex = rti;
+	bool		has_live_children;
+	ListCell   *l;
+	Relids		live_children = NULL;
+	bool		did_pruning = false;
+
+	/* Guard against stack overflow due to overly deep inheritance tree. */
+	check_stack_depth();
+
+	Assert(IS_SIMPLE_REL(rel));
+
+	/*
+	 * If the partitioned relation has any baserestrictinfo quals then we
+	 * attempt to use these quals to prune away partitions that cannot
+	 * possibly contain any tuples matching these quals.  In this case we'll
+	 * store the relids of all partitions which could possibly contain a
+	 * matching tuple, and skip anything else in the loop below.
+	 */
+	if (enable_partition_pruning &&
+		rte->relkind == RELKIND_PARTITIONED_TABLE &&
+		rel->baserestrictinfo != NIL)
+	{
+		live_children = prune_append_rel_partitions(rel);
+		did_pruning = true;
+	}
+
+	foreach(l, root->append_rel_list)
+	{
+		AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(l);
+		int			childRTindex;
+		RangeTblEntry *childRTE;
+		RelOptInfo *childrel;
+		List	   *childquals;
+		Index		cq_min_security;
+		bool		have_const_false_cq;
+		PlannerInfo *subroot;
+		ListCell   *lc;
+		List	   *translated_exprs,
+				   *child_target_exprs;
+
+		/* append_rel_list contains all append rels; ignore others */
+		if (appinfo->parent_relid != parentRTindex)
+			continue;
+
+		childRTindex = appinfo->child_relid;
+		childRTE = root->simple_rte_array[childRTindex];
+
+		/*
+		 * The child rel's RelOptInfo was already created during
+		 * add_base_rels_to_query.
+		 */
+		childrel = find_base_rel(root, childRTindex);
+		Assert(childrel->reloptkind == RELOPT_OTHER_MEMBER_REL);
+
+		/*
+		 * We have to copy the parent's quals to the child, with appropriate
+		 * substitution of variables.  However, only the baserestrictinfo
+		 * quals are needed before we can check for constraint exclusion; so
+		 * do that first and then check to see if we can disregard this child.
+		 *
+		 * The child rel's targetlist might contain non-Var expressions, which
+		 * means that substitution into the quals could produce opportunities
+		 * for const-simplification, and perhaps even pseudoconstant quals.
+		 * Therefore, transform each RestrictInfo separately to see if it
+		 * reduces to a constant or pseudoconstant.  (We must process them
+		 * separately to keep track of the security level of each qual.)
+		 */
+		childquals = NIL;
+		cq_min_security = UINT_MAX;
+		have_const_false_cq = false;
+		foreach(lc, rel->baserestrictinfo)
+		{
+			RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
+			Node	   *childqual;
+			ListCell   *lc2;
+
+			Assert(IsA(rinfo, RestrictInfo));
+			childqual = adjust_appendrel_attrs(root,
+											   (Node *) rinfo->clause,
+											   1, &appinfo);
+			childqual = eval_const_expressions(root, childqual);
+			/* check for flat-out constant */
+			if (childqual && IsA(childqual, Const))
+			{
+				if (((Const *) childqual)->constisnull ||
+					!DatumGetBool(((Const *) childqual)->constvalue))
+				{
+					/* Restriction reduces to constant FALSE or NULL */
+					have_const_false_cq = true;
+					break;
+				}
+				/* Restriction reduces to constant TRUE, so drop it */
+				continue;
+			}
+			/* might have gotten an AND clause, if so flatten it */
+			foreach(lc2, make_ands_implicit((Expr *) childqual))
+			{
+				Node	   *onecq = (Node *) lfirst(lc2);
+				bool		pseudoconstant;
+
+				/* check for pseudoconstant (no Vars or volatile functions) */
+				pseudoconstant =
+					!contain_vars_of_level(onecq, 0) &&
+					!contain_volatile_functions(onecq);
+				if (pseudoconstant)
+				{
+					/* tell createplan.c to check for gating quals */
+					root->hasPseudoConstantQuals = true;
+				}
+				/* reconstitute RestrictInfo with appropriate properties */
+				childquals = lappend(childquals,
+									 make_restrictinfo((Expr *) onecq,
+													   rinfo->is_pushed_down,
+													   rinfo->outerjoin_delayed,
+													   pseudoconstant,
+													   rinfo->security_level,
+													   NULL, NULL, NULL));
+				/* track minimum security level among child quals */
+				cq_min_security = Min(cq_min_security, rinfo->security_level);
+			}
+		}
+
+		/*
+		 * In addition to the quals inherited from the parent, we might have
+		 * securityQuals associated with this particular child node.
+		 * (Currently this can only happen in appendrels originating from
+		 * UNION ALL; inheritance child tables don't have their own
+		 * securityQuals, see expand_inherited_rtentry().)	Pull any such
+		 * securityQuals up into the baserestrictinfo for the child.  This is
+		 * similar to process_security_barrier_quals() for the parent rel,
+		 * except that we can't make any general deductions from such quals,
+		 * since they don't hold for the whole appendrel.
+		 */
+		if (childRTE->securityQuals)
+		{
+			Index		security_level = 0;
+
+			foreach(lc, childRTE->securityQuals)
+			{
+				List	   *qualset = (List *) lfirst(lc);
+				ListCell   *lc2;
+
+				foreach(lc2, qualset)
+				{
+					Expr	   *qual = (Expr *) lfirst(lc2);
+
+					/* not likely that we'd see constants here, so no check */
+					childquals = lappend(childquals,
+										 make_restrictinfo(qual,
+														   true, false, false,
+														   security_level,
+														   NULL, NULL, NULL));
+					cq_min_security = Min(cq_min_security, security_level);
+				}
+				security_level++;
+			}
+			Assert(security_level <= root->qual_security_level);
+		}
+
+		/*
+		 * OK, we've got all the baserestrictinfo quals for this child.
+		 */
+		childrel->baserestrictinfo = childquals;
+		childrel->baserestrict_min_security = cq_min_security;
+
+		if (have_const_false_cq)
+		{
+			/*
+			 * Some restriction clause reduced to constant FALSE or NULL after
+			 * substitution, so this child need not be scanned.
+			 */
+			set_dummy_rel_pathlist(childrel);
+			continue;
+		}
+
+		if (did_pruning && !bms_is_member(appinfo->child_relid, live_children))
+		{
+			/* This partition was pruned; skip it. */
+			set_dummy_rel_pathlist(childrel);
+			continue;
+		}
+
+		if (relation_excluded_by_constraints(root, childrel, childRTE))
+		{
+			/* This child is excluded; skip it. */
+			set_dummy_rel_pathlist(childrel);
+			continue;
+		}
+
+		/*
+		 * Add missing Vars to child's reltarget.
+		 *
+		 * add_inherit_target_child_root() would've added only those that are
+		 * needed to be present in the top-level tlist (or ones that
+		 * preprocess_targetlist thinks are needed to be in the tlist.)  We
+		 * may need other attributes such as those contained in WHERE clauses,
+		 * which are already computed for the parent during
+		 * deconstruct_jointree processing of the original query (child's
+		 * query never goes through deconstruct_jointree.)
+		 */
+		translated_exprs = (List *)
+			adjust_appendrel_attrs(root,
+								   (Node *) rel->reltarget->exprs,
+								   1, &appinfo);
+		child_target_exprs = childrel->reltarget->exprs;
+		foreach(lc, translated_exprs)
+		{
+			Expr *expr = lfirst(lc);
+
+			if (!list_member(child_target_exprs, expr))
+				child_target_exprs = lappend(child_target_exprs, expr);
+		}
+
+		subroot = root->inh_target_child_roots[childRTindex];
+
+		/*
+		 * Also, We have to find any ECs containing parent's expressions and
+		 * *replace* them with their copies containing child expressions.
+		 */
+		if (rel->has_eclass_joins || has_useful_pathkeys(root, rel))
+		{
+			/*
+			 * First make copies for ECs for the child's root, because some
+			 * might be modified to replace parent EC expressions by child
+			 * expressions in add_child_rel_equivalences.
+			 */
+			subroot->eq_classes = NIL;
+			foreach(lc, root->eq_classes)
+			{
+				EquivalenceClass *ec = lfirst(lc);
+				EquivalenceClass *new_ec = makeNode(EquivalenceClass);
+
+				/*
+				 * First memcpy which creates shallow copies of all
+				 * the members and then make copies of members that could
+				 * change.
+				 *
+				 * XXX comment in _copyPathKey says it's OK to recycle EC
+				 * pointers, but as long as we do the whole planning for a
+				 * given child using a given root, copying ECs like this
+				 * shouldn't be a problem.  Maybe, the following code could
+				 * be in _copyEquivalenceClass()?
+				 */
+				memcpy(new_ec, ec, sizeof(EquivalenceClass));
+				new_ec->ec_opfamilies = list_copy(ec->ec_opfamilies);
+				new_ec->ec_members = list_copy(ec->ec_members);
+				new_ec->ec_sources = list_copy(ec->ec_sources);
+				new_ec->ec_derives = list_copy(ec->ec_derives);
+				new_ec->ec_relids = bms_copy(ec->ec_relids);
+
+				subroot->eq_classes = lappend(subroot->eq_classes, new_ec);
+			}
+
+			add_child_rel_equivalences(subroot, appinfo, rel, childrel, true);
+		}
+		childrel->has_eclass_joins = rel->has_eclass_joins;
+
+		/* Translate join quals. */
+		childrel->joininfo = (List *)
+			adjust_appendrel_attrs(subroot,
+								   (Node *) rel->joininfo,
+								   1, &appinfo);
+
+		/*
+		 * If parallelism is allowable for this query in general, see whether
+		 * it's allowable for this childrel in particular.  For consistency,
+		 * do this before calling set_rel_size() for the child.
+		 */
+		if (root->glob->parallelModeOK)
+			set_rel_consider_parallel(subroot, childrel, childRTE);
+
+		/*
+		 * Compute the child's size using possibly modified subroot.
+		 */
+		set_rel_size(subroot, childrel, childRTindex, childRTE);
+
+		/* If the child itself is partitioned it may turn into a dummy rel. */
+		if (IS_DUMMY_REL(childrel))
+			continue;
+
+		/* We have at least one live child. */
+		has_live_children = true;
+
+		Assert(childrel->rows > 0);
+	}
+
+	if (has_live_children)
+	{
+		/*
+		 * Set a non-zero value here to cope with the caller's requirement
+		 * that non-dummy relations are actually not empty.  We don't try to
+		 * be accurate here, because we're not going to create a path that
+		 * combines the children outputs.
+		 */
+		rel->rows = 1;
+	}
+	else
+	{
+		/*
+		 * All children were excluded by constraints, so mark the relation
+		 * ass dummy.  We must do this in this phase so that the rel's
+		 * dummy-ness is visible when we generate paths for other rels.
+		 */
+		set_dummy_rel_pathlist(rel);
+	}
+}
+
+/*
+ * set_inherit_target_rel_pathlists
+ *	  Build access paths for the child target relations
+ *
+ * Similar to set_append_rel_pathlist, except that we build paths of the
+ * children, but don't build an Append path.
+ */
+static void
+set_inherit_target_rel_pathlists(PlannerInfo *root, RelOptInfo *rel,
+								 Index rti, RangeTblEntry *rte)
+{
+	int			parentRTindex = rti;
+	ListCell   *l;
+
+	/* Nothing to do if all the children were excluded. */
+	if (IS_DUMMY_REL(rel))
+		return;
+
+	/* Generate access paths for each of the children of passed-in rel */
+	foreach(l, root->append_rel_list)
+	{
+		AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(l);
+		int			childRTindex;
+		RangeTblEntry *childRTE;
+		RelOptInfo *childrel;
+		PlannerInfo *subroot;
+
+		/* append_rel_list contains all append rels; ignore others */
+		if (appinfo->parent_relid != parentRTindex)
+			continue;
+
+		/* Re-locate the child RTE and RelOptInfo */
+		childRTindex = appinfo->child_relid;
+		childRTE = root->simple_rte_array[childRTindex];
+		childrel = root->simple_rel_array[childRTindex];
+		subroot = root->inh_target_child_roots[childRTindex];
+		/* Transfer the value from main root to subroot. */
+		subroot->total_table_pages = root->total_table_pages;
+
+		/*
+		 * If set_append_rel_size() decided the parent appendrel was
+		 * parallel-unsafe at some point after visiting this child rel, we
+		 * need to propagate the unsafety marking down to the child, so that
+		 * we don't generate useless partial paths for it.
+		 */
+		if (!rel->consider_parallel)
+			childrel->consider_parallel = false;
+
+		/*
+		 * Compute the child's access paths.
+		 */
+		set_rel_pathlist(subroot, childrel, childRTindex, childRTE);
+	}
+}
+
+/*
  * set_append_rel_size
  *	  Set size estimates for a simple "append relation"
  *
@@ -1046,7 +1453,8 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 		 * EquivalenceClass data structures.
 		 */
 		if (rel->has_eclass_joins || has_useful_pathkeys(root, rel))
-			add_child_rel_equivalences(root, appinfo, rel, childrel);
+			add_child_rel_equivalences(root, appinfo, rel, childrel,
+									   false);
 		childrel->has_eclass_joins = rel->has_eclass_joins;
 
 		/*
@@ -2625,6 +3033,140 @@ generate_gather_paths(PlannerInfo *root, RelOptInfo *rel, bool override_rows)
 }
 
 /*
+ * inheritance_make_rel_from_joinlist
+ *		Perform join planning for all non-dummy leaf inheritance children
+ *		in their role as an UPDATE/DELETE query's target relation
+ *
+ * If a child relation is a partitioned table, its children are processed in
+ * turn by recursively calling this function.
+ */
+static void
+inheritance_make_rel_from_joinlist(PlannerInfo *root, List *joinlist)
+{
+	Index		resultRelation = root->parse->resultRelation;
+	ListCell   *lc;
+#ifdef USE_ASSERT_CHECKING
+	Relids	all_baserels;
+#endif
+
+	/* For UPDATE/DELETE queries, the top parent can only ever be a table. */
+	Assert(root->parse->commandType == CMD_UPDATE ||
+		   root->parse->commandType == CMD_DELETE);
+	Assert(planner_rt_fetch(resultRelation, root)->rtekind == RTE_RELATION);
+
+	/* Nothing to do. */
+	if (IS_DUMMY_REL(find_base_rel(root, resultRelation)))
+		return;
+
+	foreach(lc, root->append_rel_list)
+	{
+		AppendRelInfo *appinfo = lfirst(lc);
+		PlannerInfo *subroot;
+		RelOptInfo *childrel;
+		RelOptInfo *childjoinrel;
+		List	   *translated_joinlist;
+
+		if (appinfo->parent_relid != resultRelation)
+			continue;
+
+		childrel = find_base_rel(root, appinfo->child_relid);
+
+		/* Ignore excluded/pruned children. */
+		if (IS_DUMMY_REL(childrel))
+			continue;
+
+		/* Add this child. */
+		root->inh_target_child_rels = lappend_int(root->inh_target_child_rels,
+												  appinfo->child_relid);
+
+		/* Perform join planning with child subroot. */
+		subroot = root->inh_target_child_roots[appinfo->child_relid];
+		Assert(subroot->parse->resultRelation > 0);
+
+		/*
+		 * Modify joinlist such that relations joined to the top parent rel
+		 * appear to be joined to the child rel instead.  Do the same for
+		 * any SpecialJoinInfo structs.
+		 */
+		translated_joinlist = (List *)
+						adjust_appendrel_attrs(subroot,
+											   (Node *) joinlist,
+											   1, &appinfo);
+		subroot->join_info_list = (List *)
+						adjust_appendrel_attrs(subroot,
+											   (Node *) root->join_info_list,
+											   1, &appinfo);
+
+		/*
+		 * Sub-partitioned tables have to be processed recursively using the
+		 * translated subroot as the parent, because AppendRelInfos link
+		 * sub-partitions to their immediate parents, not the root partitioned
+		 * table.
+		 */
+		if (childrel->part_scheme != NULL)
+		{
+			inheritance_make_rel_from_joinlist(subroot, translated_joinlist);
+
+			/*
+			 * Add this child relation as a placeholder in the parent root's
+			 * inh_target_child_joinrels so that inheritance_planner see same
+			 * number of entries as inh_target_child_rels.
+			 */
+			root->inh_target_child_joinrels =
+					lappend(root->inh_target_child_joinrels, childrel);
+
+			/* Also propagate this child's own children into parent's list. */
+			if (subroot->inh_target_child_rels != NIL)
+			{
+				root->inh_target_child_rels =
+					list_concat(root->inh_target_child_rels,
+								subroot->inh_target_child_rels);
+				root->inh_target_child_joinrels =
+					list_concat(root->inh_target_child_joinrels,
+								subroot->inh_target_child_joinrels);
+			}
+			continue;
+		}
+
+		/*
+		 * Since we added the child rel directly into the join tree, we must
+		 * modify it to be a "base" rel instead of an "other" rel, which the
+		 * join planning code expects the relations being joined to be.
+		 */
+		childrel->reloptkind = RELOPT_BASEREL;
+
+		Assert(subroot->join_rel_list == NIL);
+		Assert(subroot->join_rel_hash == NULL);
+
+		/* Perform join planning and save the resulting RelOptInfo. */
+		childjoinrel = make_rel_from_joinlist(subroot, translated_joinlist);
+
+		/*
+		 * Remember this child target rel.  inheritance_planner will perform
+		 * the remaining steps of planning for each child relation separately.
+		 * Specifically, it will call grouping_planner on every
+		 * RelOptInfo contained in the inh_target_child_rels list, each of
+		 * which represents the source of tuples to be modified for a given
+		 * target child rel.
+		 */
+		root->inh_target_child_joinrels =
+					lappend(root->inh_target_child_joinrels, childjoinrel);
+#ifdef USE_ASSERT_CHECKING
+		/*
+		 * The following implements essentially the same Assert as in
+		 * make_one_rel, our caller.
+		 */
+		all_baserels = bms_copy(root->all_baserels);
+		all_baserels = bms_del_member(all_baserels,
+									  root->parse->resultRelation);
+		all_baserels = bms_add_member(all_baserels,
+									  subroot->parse->resultRelation);
+		Assert(bms_equal(childjoinrel->relids, all_baserels));
+#endif
+	}
+}
+
+/*
  * make_rel_from_joinlist
  *	  Build access paths using a "joinlist" to guide the join path search.
  *
diff --git a/src/backend/optimizer/path/equivclass.c b/src/backend/optimizer/path/equivclass.c
index 6e134ae1d2..10136ef940 100644
--- a/src/backend/optimizer/path/equivclass.c
+++ b/src/backend/optimizer/path/equivclass.c
@@ -2104,12 +2104,16 @@ match_eclasses_to_foreign_key_col(PlannerInfo *root,
  *
  * parent_rel and child_rel could be derived from appinfo, but since the
  * caller has already computed them, we might as well just pass them in.
+ *
+ * If 'replace' is true then the child EC members *replace* the corresponding
+ * parent members.
  */
 void
 add_child_rel_equivalences(PlannerInfo *root,
 						   AppendRelInfo *appinfo,
 						   RelOptInfo *parent_rel,
-						   RelOptInfo *child_rel)
+						   RelOptInfo *child_rel,
+						   bool replace)
 {
 	ListCell   *lc1;
 
@@ -2117,14 +2121,23 @@ add_child_rel_equivalences(PlannerInfo *root,
 	{
 		EquivalenceClass *cur_ec = (EquivalenceClass *) lfirst(lc1);
 		ListCell   *lc2;
+		ListCell   *prev;
+		ListCell   *next;
 
 		/*
 		 * If this EC contains a volatile expression, then generating child
 		 * EMs would be downright dangerous, so skip it.  We rely on a
-		 * volatile EC having only one EM.
+		 * volatile EC having only one EM.  If the caller asked to *replace*
+		 * the original parent expression with the child one, then it's
+		 * okay to proceed, because we wouldn't be adding another expression
+		 * as being equivalent in that case.
 		 */
 		if (cur_ec->ec_has_volatile)
-			continue;
+		{
+			Assert(list_length(cur_ec->ec_members) == 1);
+			if (!replace)
+				continue;
+		}
 
 		/*
 		 * No point in searching if parent rel not mentioned in eclass; but we
@@ -2134,12 +2147,18 @@ add_child_rel_equivalences(PlannerInfo *root,
 			!bms_is_subset(parent_rel->relids, cur_ec->ec_relids))
 			continue;
 
-		foreach(lc2, cur_ec->ec_members)
+		prev = NULL;
+		for (lc2 = list_head(cur_ec->ec_members); lc2 != NULL; lc2 = next)
 		{
 			EquivalenceMember *cur_em = (EquivalenceMember *) lfirst(lc2);
 
+			next = lnext(lc2);
+
 			if (cur_em->em_is_const)
+			{
+				prev = lc2;
 				continue;		/* ignore consts here */
+			}
 
 			/* Does it reference parent_rel? */
 			if (bms_overlap(cur_em->em_relids, parent_rel->relids))
@@ -2177,10 +2196,38 @@ add_child_rel_equivalences(PlannerInfo *root,
 														  child_rel->relids);
 				}
 
+				/*
+				 * Caller may have asked us to replace the parent expression
+				 * with the child expression, so delete the parent expression
+				 * first.
+				 */
+				if (replace)
+					cur_ec->ec_members = list_delete_cell(cur_ec->ec_members,
+														  lc2, prev);
+
+				/*
+				 * If we're replacing, then the new member isn't really a
+				 * a child, so em_is_child should be set to false.
+				 */
 				(void) add_eq_member(cur_ec, child_expr,
 									 new_relids, new_nullable_relids,
-									 true, cur_em->em_datatype);
+									 !replace, cur_em->em_datatype);
 			}
+			else
+				prev = lc2;
+		}
+
+		if (replace)
+		{
+			/*
+			 * Now fix up EC's relids set.  It's OK to modify EC like this,
+			 * because caller must have made a copy of the original EC.
+			 * For example, see adjust_inherited_target_child_root.
+			 */
+			cur_ec->ec_relids = bms_difference(cur_ec->ec_relids,
+											   parent_rel->relids);
+			cur_ec->ec_relids = bms_add_members(cur_ec->ec_relids,
+												child_rel->relids);
 		}
 	}
 }
diff --git a/src/backend/optimizer/plan/createplan.c b/src/backend/optimizer/plan/createplan.c
index 97d0c28132..1e1c7efef9 100644
--- a/src/backend/optimizer/plan/createplan.c
+++ b/src/backend/optimizer/plan/createplan.c
@@ -2019,12 +2019,7 @@ create_groupingsets_plan(PlannerInfo *root, GroupingSetsPath *best_path)
 	/*
 	 * During setrefs.c, we'll need the grouping_map to fix up the cols lists
 	 * in GroupingFunc nodes.  Save it for setrefs.c to use.
-	 *
-	 * This doesn't work if we're in an inheritance subtree (see notes in
-	 * create_modifytable_plan).  Fortunately we can't be because there would
-	 * never be grouping in an UPDATE/DELETE; but let's Assert that.
 	 */
-	Assert(root->inhTargetKind == INHKIND_NONE);
 	Assert(root->grouping_map == NULL);
 	root->grouping_map = grouping_map;
 
@@ -2181,12 +2176,7 @@ create_minmaxagg_plan(PlannerInfo *root, MinMaxAggPath *best_path)
 	 * with InitPlan output params.  (We can't just do that locally in the
 	 * MinMaxAgg node, because path nodes above here may have Agg references
 	 * as well.)  Save the mmaggregates list to tell setrefs.c to do that.
-	 *
-	 * This doesn't work if we're in an inheritance subtree (see notes in
-	 * create_modifytable_plan).  Fortunately we can't be because there would
-	 * never be aggregates in an UPDATE/DELETE; but let's Assert that.
 	 */
-	Assert(root->inhTargetKind == INHKIND_NONE);
 	Assert(root->minmax_aggs == NIL);
 	root->minmax_aggs = best_path->mmaggregates;
 
diff --git a/src/backend/optimizer/plan/planmain.c b/src/backend/optimizer/plan/planmain.c
index fc97a1bb50..78557aeecb 100644
--- a/src/backend/optimizer/plan/planmain.c
+++ b/src/backend/optimizer/plan/planmain.c
@@ -28,7 +28,7 @@
 #include "optimizer/paths.h"
 #include "optimizer/placeholder.h"
 #include "optimizer/planmain.h"
-
+#include "optimizer/prep.h"
 
 /*
  * query_planner
@@ -59,6 +59,7 @@ query_planner(PlannerInfo *root, List *tlist,
 	Query	   *parse = root->parse;
 	List	   *joinlist;
 	RelOptInfo *final_rel;
+	Index		rti;
 
 	/*
 	 * If the query has an empty join tree, then it's something easy like
@@ -232,13 +233,52 @@ query_planner(PlannerInfo *root, List *tlist,
 	extract_restriction_or_clauses(root);
 
 	/*
+	 * Construct the all_baserels Relids set.
+	 */
+	root->all_baserels = NULL;
+	for (rti = 1; rti < root->simple_rel_array_size; rti++)
+	{
+		RelOptInfo *brel = root->simple_rel_array[rti];
+
+		/* there may be empty slots corresponding to non-baserel RTEs */
+		if (brel == NULL)
+			continue;
+
+		Assert(brel->relid == rti); /* sanity check on array */
+
+		/* ignore RTEs that are "other rels" */
+		if (brel->reloptkind != RELOPT_BASEREL)
+			continue;
+
+		root->all_baserels = bms_add_member(root->all_baserels, brel->relid);
+	}
+
+	/*
+	 * Add child subroots needed to use during planning for individual child
+	 * targets
+	 */
+	if (root->inherited_update)
+	{
+		root->inh_target_child_roots = (PlannerInfo **)
+										palloc0(root->simple_rel_array_size *
+												sizeof(PlannerInfo *));
+		add_inherited_target_child_roots(root);
+	}
+
+	/*
 	 * Ready to do the primary planning.
 	 */
 	final_rel = make_one_rel(root, joinlist);
 
-	/* Check that we got at least one usable path */
-	if (!final_rel || !final_rel->cheapest_total_path ||
-		final_rel->cheapest_total_path->param_info != NULL)
+	/*
+	 * Check that we got at least one usable path.  In the case of an
+	 * inherited update/delete operation, no path has been created for
+	 * the query's actual target relation yet.
+	 */
+	if (!root->inherited_update &&
+		(!final_rel ||
+		 !final_rel->cheapest_total_path ||
+		 final_rel->cheapest_total_path->param_info != NULL))
 		elog(ERROR, "failed to construct the join relation");
 
 	return final_rel;
diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index 5ba612922f..703babfdf0 100644
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -39,6 +39,7 @@
 #ifdef OPTIMIZER_DEBUG
 #include "nodes/print.h"
 #endif
+#include "nodes/relation.h"
 #include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
 #include "optimizer/cost.h"
@@ -131,7 +132,7 @@ static Node *preprocess_expression(PlannerInfo *root, Node *expr, int kind);
 static void preprocess_qual_conditions(PlannerInfo *root, Node *jtnode);
 static void inheritance_planner(PlannerInfo *root);
 static void grouping_planner(PlannerInfo *root, bool inheritance_update,
-				 double tuple_fraction);
+				 RelOptInfo *planned_rel, double tuple_fraction);
 static grouping_sets_data *preprocess_grouping_sets(PlannerInfo *root);
 static List *remap_to_groupclause_idx(List *groupClause, List *gsets,
 						 int *tleref_to_colnum_map);
@@ -635,7 +636,6 @@ subquery_planner(PlannerGlobal *glob, Query *parse,
 	root->grouping_map = NULL;
 	root->minmax_aggs = NIL;
 	root->qual_security_level = 0;
-	root->inhTargetKind = INHKIND_NONE;
 	root->hasRecursion = hasRecursion;
 	if (hasRecursion)
 		root->wt_param_id = assign_special_exec_param(root);
@@ -725,6 +725,13 @@ subquery_planner(PlannerGlobal *glob, Query *parse,
 	expand_inherited_tables(root);
 
 	/*
+	 * Now that we have figured out "actual" inheritance situation of the
+	 * relations, set whether the query is an inherited UPDATE/DELETE.
+	 */
+	root->inherited_update = (parse->resultRelation &&
+					  rt_fetch(parse->resultRelation, parse->rtable)->inh);
+
+	/*
 	 * Set hasHavingQual to remember if HAVING clause is present.  Needed
 	 * because preprocess_expression will reduce a constant-true condition to
 	 * an empty qual list ... but "HAVING TRUE" is not a semantic no-op.
@@ -975,7 +982,7 @@ subquery_planner(PlannerGlobal *glob, Query *parse,
 		rt_fetch(parse->resultRelation, parse->rtable)->inh)
 		inheritance_planner(root);
 	else
-		grouping_planner(root, false, tuple_fraction);
+		grouping_planner(root, false, NULL, tuple_fraction);
 
 	/*
 	 * Capture the set of outer-level param IDs we have access to, for use in
@@ -1151,13 +1158,41 @@ preprocess_phv_expression(PlannerInfo *root, Expr *expr)
  *	  inheritance set.
  *
  * We have to handle this case differently from cases where a source relation
- * is an inheritance set. Source inheritance is expanded at the bottom of the
- * plan tree (see allpaths.c), but target inheritance has to be expanded at
- * the top.  The reason is that for UPDATE, each target relation needs a
- * different targetlist matching its own column set.  Fortunately,
+ * is an inheritance set, where outputs of all the children are combined and
+ * combined output consumed using the source relation's (parent's) column set.
+ * For UPDATE, each target relation, where the query's output will go, needs
+ * a different targetlist matching its own column set.  So, we will need to
+ * translate the query such that it produces the desired output required by
+ * each of the child target relations and plan each separately.  Fortunately,
  * the UPDATE/DELETE target can never be the nullable side of an outer join,
  * so it's OK to generate the plan this way.
  *
+ * Planning steps that need to be performed separately for each child and
+ * any preliminary processing needed for that are handled by the following
+ * sub-routines of query_planner:
+ *
+ *	add_inherit_target_roots - this creates copies of PlannerInfo for each
+ *	child after query_planner has finished processing the join tree and
+ *	creating EquivalenceClasses, so that working state of planning need
+ *	not be created afresh for each child, especially the various arrays
+ *
+ *	set_inherit_target_rel_sizes - this sets size estimates for child
+ *	relations, replace the parent EC members by corresponding child ones
+ *	in their respective subroots
+ *
+ *	set_inherit_target_rel_pathlists - this creates Paths for scanning
+ *	individual child relations
+ *
+ *	inherit_make_rel_from_joinlist - this translates the jointree, replacing
+ *	the target relation in the original jointree (the root parent) by
+ *	individual child target relations and performs join planning on the
+ *	resulting join tree, saving the RelOptInfos of resulting join relations
+ *	into the top-level PlannerInfo
+ *
+ * Finally, here we apply grouping_planner to each child join relation
+ * produced by set_inherit_target_rel_pathlists to so that its path produces
+ * the desired targetlist.
+ *
  * Returns nothing; the useful output is in the Paths we attach to
  * the (UPPERREL_FINAL, NULL) upperrel stored in *root.
  *
@@ -1169,14 +1204,8 @@ inheritance_planner(PlannerInfo *root)
 {
 	Query	   *parse = root->parse;
 	int			top_parentRTindex = parse->resultRelation;
-	Bitmapset  *subqueryRTindexes;
-	Bitmapset  *modifiableARIindexes;
 	int			nominalRelation = -1;
 	Index		rootRelation = 0;
-	List	   *final_rtable = NIL;
-	int			save_rel_array_size = 0;
-	RelOptInfo **save_rel_array = NULL;
-	AppendRelInfo **save_append_rel_array = NULL;
 	List	   *subpaths = NIL;
 	List	   *subroots = NIL;
 	List	   *resultRelations = NIL;
@@ -1184,70 +1213,47 @@ inheritance_planner(PlannerInfo *root)
 	List	   *returningLists = NIL;
 	List	   *rowMarks;
 	RelOptInfo *final_rel;
-	ListCell   *lc;
-	Index		rti;
+	ListCell   *lc1,
+			   *lc2;
 	RangeTblEntry *parent_rte;
-	PlannerInfo *parent_root;
-	Query	   *parent_parse;
-	Bitmapset  *parent_relids = bms_make_singleton(top_parentRTindex);
-	PlannerInfo **parent_roots = NULL;
+	List	   *tlist;
+	standard_qp_extra qp_extra;
+	RelOptInfo *planned_rel;
 
+	/* Inheritance is never used for insert. */
 	Assert(parse->commandType != CMD_INSERT);
 
 	/*
-	 * We generate a modified instance of the original Query for each target
-	 * relation, plan that, and put all the plans into a list that will be
-	 * controlled by a single ModifyTable node.  All the instances share the
-	 * same rangetable, but each instance must have its own set of subquery
-	 * RTEs within the finished rangetable because (1) they are likely to get
-	 * scribbled on during planning, and (2) it's not inconceivable that
-	 * subqueries could get planned differently in different cases.  We need
-	 * not create duplicate copies of other RTE kinds, in particular not the
-	 * target relations, because they don't have either of those issues.  Not
-	 * having to duplicate the target relations is important because doing so
-	 * (1) would result in a rangetable of length O(N^2) for N targets, with
-	 * at least O(N^3) work expended here; and (2) would greatly complicate
-	 * management of the rowMarks list.
+	 * Let query_planner generate the access paths for the query for each
+	 * target child relation.
 	 *
-	 * To begin with, generate a bitmapset of the relids of the subquery RTEs.
+	 * First, save the unexpanded version of the query's targetlist.
+	 * create_inherit_target_child_root will use it as base when expanding
+	 * it for a given child relation as the query's target relation instead
+	 * of the parent.
 	 */
-	subqueryRTindexes = NULL;
-	rti = 1;
-	foreach(lc, parse->rtable)
-	{
-		RangeTblEntry *rte = lfirst_node(RangeTblEntry, lc);
-
-		if (rte->rtekind == RTE_SUBQUERY)
-			subqueryRTindexes = bms_add_member(subqueryRTindexes, rti);
-		rti++;
-	}
+	root->unexpanded_tlist = list_copy(root->parse->targetList);
+	tlist = preprocess_targetlist(root);
+	root->processed_tlist = tlist;
+	qp_extra.tlist = tlist;
+	qp_extra.activeWindows = NIL;
+	qp_extra.groupClause = NIL;
+	planned_rel = query_planner(root, tlist, standard_qp_callback, &qp_extra);
 
 	/*
-	 * Next, we want to identify which AppendRelInfo items contain references
-	 * to any of the aforesaid subquery RTEs.  These items will need to be
-	 * copied and modified to adjust their subquery references; whereas the
-	 * other ones need not be touched.  It's worth being tense over this
-	 * because we can usually avoid processing most of the AppendRelInfo
-	 * items, thereby saving O(N^2) space and time when the target is a large
-	 * inheritance tree.  We can identify AppendRelInfo items by their
-	 * child_relid, since that should be unique within the list.
+	 * If it turned out during query planning that all the children are dummy
+	 * (pruned or excluded by constraints), no need to do the steps below.
+	 * Let grouping_planner finish up the final path.
 	 */
-	modifiableARIindexes = NULL;
-	if (subqueryRTindexes != NULL)
+	if (IS_DUMMY_REL(planned_rel))
 	{
-		foreach(lc, root->append_rel_list)
-		{
-			AppendRelInfo *appinfo = lfirst_node(AppendRelInfo, lc);
-
-			if (bms_is_member(appinfo->parent_relid, subqueryRTindexes) ||
-				bms_is_member(appinfo->child_relid, subqueryRTindexes) ||
-				bms_overlap(pull_varnos((Node *) appinfo->translated_vars),
-							subqueryRTindexes))
-				modifiableARIindexes = bms_add_member(modifiableARIindexes,
-													  appinfo->child_relid);
-		}
+		grouping_planner(root, false, planned_rel, 0.0);
+		return;
 	}
 
+	Assert(planned_rel->relid == top_parentRTindex);
+	Assert(planned_rel->reloptkind == RELOPT_BASEREL);
+
 	/*
 	 * If the parent RTE is a partitioned table, we should use that as the
 	 * nominal target relation, because the RTEs added for partitioned tables
@@ -1255,7 +1261,7 @@ inheritance_planner(PlannerInfo *root)
 	 * not appear anywhere else in the plan, so the confusion explained below
 	 * for non-partitioning inheritance cases is not possible.
 	 */
-	parent_rte = rt_fetch(top_parentRTindex, root->parse->rtable);
+	parent_rte = planner_rt_fetch(top_parentRTindex, root);
 	if (parent_rte->relkind == RELKIND_PARTITIONED_TABLE)
 	{
 		nominalRelation = top_parentRTindex;
@@ -1263,95 +1269,39 @@ inheritance_planner(PlannerInfo *root)
 	}
 
 	/*
-	 * The PlannerInfo for each child is obtained by translating the relevant
-	 * members of the PlannerInfo for its immediate parent, which we find
-	 * using the parent_relid in its AppendRelInfo.  We save the PlannerInfo
-	 * for each parent in an array indexed by relid for fast retrieval. Since
-	 * the maximum number of parents is limited by the number of RTEs in the
-	 * query, we use that number to allocate the array. An extra entry is
-	 * needed since relids start from 1.
+	 * Get on with finalizing the path for each child target relation by
+	 * calling grouping_planner on its joinrel.
 	 */
-	parent_roots = (PlannerInfo **) palloc0((list_length(parse->rtable) + 1) *
-											sizeof(PlannerInfo *));
-	parent_roots[top_parentRTindex] = root;
-
-	/*
-	 * And now we can get on with generating a plan for each child table.
-	 */
-	foreach(lc, root->append_rel_list)
+	forboth(lc1, root->inh_target_child_rels,
+			lc2, root->inh_target_child_joinrels)
 	{
-		AppendRelInfo *appinfo = lfirst_node(AppendRelInfo, lc);
-		PlannerInfo *subroot;
+		Index		childRTindex = lfirst_int(lc1);
+		RelOptInfo *childjoinrel = lfirst(lc2);
+		PlannerInfo *subroot = root->inh_target_child_roots[childRTindex];
+		AppendRelInfo *appinfo = root->append_rel_array[childRTindex];
 		RangeTblEntry *child_rte;
 		RelOptInfo *sub_final_rel;
 		Path	   *subpath;
 
-		/* append_rel_list contains all append rels; ignore others */
-		if (!bms_is_member(appinfo->parent_relid, parent_relids))
-			continue;
-
-		/*
-		 * expand_inherited_rtentry() always processes a parent before any of
-		 * that parent's children, so the parent_root for this relation should
-		 * already be available.
-		 */
-		parent_root = parent_roots[appinfo->parent_relid];
-		Assert(parent_root != NULL);
-		parent_parse = parent_root->parse;
-
-		/*
-		 * We need a working copy of the PlannerInfo so that we can control
-		 * propagation of information back to the main copy.
-		 */
-		subroot = makeNode(PlannerInfo);
-		memcpy(subroot, parent_root, sizeof(PlannerInfo));
-
-		/*
-		 * Generate modified query with this rel as target.  We first apply
-		 * adjust_appendrel_attrs, which copies the Query and changes
-		 * references to the parent RTE to refer to the current child RTE,
-		 * then fool around with subquery RTEs.
-		 */
-		subroot->parse = (Query *)
-			adjust_appendrel_attrs(parent_root,
-								   (Node *) parent_parse,
-								   1, &appinfo);
+		Assert(subroot != NULL);
+		Assert(subroot->parse->resultRelation == childRTindex);
 
 		/*
 		 * If there are securityQuals attached to the parent, move them to the
 		 * child rel (they've already been transformed properly for that).
 		 */
-		parent_rte = rt_fetch(appinfo->parent_relid, subroot->parse->rtable);
-		child_rte = rt_fetch(appinfo->child_relid, subroot->parse->rtable);
+		parent_rte = planner_rt_fetch(appinfo->parent_relid, subroot);
+		child_rte = planner_rt_fetch(appinfo->child_relid, subroot);
 		child_rte->securityQuals = parent_rte->securityQuals;
 		parent_rte->securityQuals = NIL;
 
 		/*
-		 * Mark whether we're planning a query to a partitioned table or an
-		 * inheritance parent.
+		 * Ignore a partitioned child.  Instead, the paths of its children will
+		 * be added to subpaths.
 		 */
-		subroot->inhTargetKind =
-			(rootRelation != 0) ? INHKIND_PARTITIONED : INHKIND_INHERITED;
-
-		/*
-		 * If this child is further partitioned, remember it as a parent.
-		 * Since a partitioned table does not have any data, we don't need to
-		 * create a plan for it, and we can stop processing it here.  We do,
-		 * however, need to remember its modified PlannerInfo for use when
-		 * processing its children, since we'll update their varnos based on
-		 * the delta from immediate parent to child, not from top to child.
-		 *
-		 * Note: a very non-obvious point is that we have not yet added
-		 * duplicate subquery RTEs to the subroot's rtable.  We mustn't,
-		 * because then its children would have two sets of duplicates,
-		 * confusing matters.
-		 */
-		if (child_rte->inh)
+		if (childjoinrel->part_scheme)
 		{
-			Assert(child_rte->relkind == RELKIND_PARTITIONED_TABLE);
-			parent_relids = bms_add_member(parent_relids, appinfo->child_relid);
-			parent_roots[appinfo->child_relid] = subroot;
-
+			Assert(child_rte->inh);
 			continue;
 		}
 
@@ -1379,111 +1329,8 @@ inheritance_planner(PlannerInfo *root)
 		if (nominalRelation < 0)
 			nominalRelation = appinfo->child_relid;
 
-		/*
-		 * The rowMarks list might contain references to subquery RTEs, so
-		 * make a copy that we can apply ChangeVarNodes to.  (Fortunately, the
-		 * executor doesn't need to see the modified copies --- we can just
-		 * pass it the original rowMarks list.)
-		 */
-		subroot->rowMarks = copyObject(parent_root->rowMarks);
-
-		/*
-		 * The append_rel_list likewise might contain references to subquery
-		 * RTEs (if any subqueries were flattenable UNION ALLs).  So prepare
-		 * to apply ChangeVarNodes to that, too.  As explained above, we only
-		 * want to copy items that actually contain such references; the rest
-		 * can just get linked into the subroot's append_rel_list.
-		 *
-		 * If we know there are no such references, we can just use the outer
-		 * append_rel_list unmodified.
-		 */
-		if (modifiableARIindexes != NULL)
-		{
-			ListCell   *lc2;
-
-			subroot->append_rel_list = NIL;
-			foreach(lc2, parent_root->append_rel_list)
-			{
-				AppendRelInfo *appinfo2 = lfirst_node(AppendRelInfo, lc2);
-
-				if (bms_is_member(appinfo2->child_relid, modifiableARIindexes))
-					appinfo2 = copyObject(appinfo2);
-
-				subroot->append_rel_list = lappend(subroot->append_rel_list,
-												   appinfo2);
-			}
-		}
-
-		/*
-		 * Add placeholders to the child Query's rangetable list to fill the
-		 * RT indexes already reserved for subqueries in previous children.
-		 * These won't be referenced, so there's no need to make them very
-		 * valid-looking.
-		 */
-		while (list_length(subroot->parse->rtable) < list_length(final_rtable))
-			subroot->parse->rtable = lappend(subroot->parse->rtable,
-											 makeNode(RangeTblEntry));
-
-		/*
-		 * If this isn't the first child Query, generate duplicates of all
-		 * subquery RTEs, and adjust Var numbering to reference the
-		 * duplicates. To simplify the loop logic, we scan the original rtable
-		 * not the copy just made by adjust_appendrel_attrs; that should be OK
-		 * since subquery RTEs couldn't contain any references to the target
-		 * rel.
-		 */
-		if (final_rtable != NIL && subqueryRTindexes != NULL)
-		{
-			ListCell   *lr;
-
-			rti = 1;
-			foreach(lr, parent_parse->rtable)
-			{
-				RangeTblEntry *rte = lfirst_node(RangeTblEntry, lr);
-
-				if (bms_is_member(rti, subqueryRTindexes))
-				{
-					Index		newrti;
-
-					/*
-					 * The RTE can't contain any references to its own RT
-					 * index, except in its securityQuals, so we can save a
-					 * few cycles by applying ChangeVarNodes to the rest of
-					 * the rangetable before we append the RTE to it.
-					 */
-					newrti = list_length(subroot->parse->rtable) + 1;
-					ChangeVarNodes((Node *) subroot->parse, rti, newrti, 0);
-					ChangeVarNodes((Node *) subroot->rowMarks, rti, newrti, 0);
-					/* Skip processing unchanging parts of append_rel_list */
-					if (modifiableARIindexes != NULL)
-					{
-						ListCell   *lc2;
-
-						foreach(lc2, subroot->append_rel_list)
-						{
-							AppendRelInfo *appinfo2 = lfirst_node(AppendRelInfo, lc2);
-
-							if (bms_is_member(appinfo2->child_relid,
-											  modifiableARIindexes))
-								ChangeVarNodes((Node *) appinfo2, rti, newrti, 0);
-						}
-					}
-					rte = copyObject(rte);
-					ChangeVarNodes((Node *) rte->securityQuals, rti, newrti, 0);
-					subroot->parse->rtable = lappend(subroot->parse->rtable,
-													 rte);
-				}
-				rti++;
-			}
-		}
-
-		/* There shouldn't be any OJ info to translate, as yet */
-		Assert(subroot->join_info_list == NIL);
-		/* and we haven't created PlaceHolderInfos, either */
-		Assert(subroot->placeholder_list == NIL);
-
-		/* Generate Path(s) for accessing this result relation */
-		grouping_planner(subroot, true, 0.0 /* retrieve all tuples */ );
+		/* Apply the top-level targetlist to childjoinrel's path. */
+		grouping_planner(subroot, true, childjoinrel, 0.0);
 
 		/*
 		 * Select cheapest path in case there's more than one.  We always run
@@ -1495,45 +1342,10 @@ inheritance_planner(PlannerInfo *root)
 		subpath = sub_final_rel->cheapest_total_path;
 
 		/*
-		 * If this child rel was excluded by constraint exclusion, exclude it
-		 * from the result plan.
+		 * child rel cannot be empty, or inheritance_make_rel_from_joinlist
+		 * wouldn't have put it in the list to begin with.
 		 */
-		if (IS_DUMMY_PATH(subpath))
-			continue;
-
-		/*
-		 * If this is the first non-excluded child, its post-planning rtable
-		 * becomes the initial contents of final_rtable; otherwise, append
-		 * just its modified subquery RTEs to final_rtable.
-		 */
-		if (final_rtable == NIL)
-			final_rtable = subroot->parse->rtable;
-		else
-			final_rtable = list_concat(final_rtable,
-									   list_copy_tail(subroot->parse->rtable,
-													  list_length(final_rtable)));
-
-		/*
-		 * We need to collect all the RelOptInfos from all child plans into
-		 * the main PlannerInfo, since setrefs.c will need them.  We use the
-		 * last child's simple_rel_array (previous ones are too short), so we
-		 * have to propagate forward the RelOptInfos that were already built
-		 * in previous children.
-		 */
-		Assert(subroot->simple_rel_array_size >= save_rel_array_size);
-		for (rti = 1; rti < save_rel_array_size; rti++)
-		{
-			RelOptInfo *brel = save_rel_array[rti];
-
-			if (brel)
-				subroot->simple_rel_array[rti] = brel;
-		}
-		save_rel_array_size = subroot->simple_rel_array_size;
-		save_rel_array = subroot->simple_rel_array;
-		save_append_rel_array = subroot->append_rel_array;
-
-		/* Make sure any initplans from this rel get into the outer list */
-		root->init_plans = subroot->init_plans;
+		Assert(!IS_DUMMY_PATH(subpath));
 
 		/* Build list of sub-paths */
 		subpaths = lappend(subpaths, subpath);
@@ -1565,36 +1377,6 @@ inheritance_planner(PlannerInfo *root)
 	 */
 
 	/*
-	 * If we managed to exclude every child rel, return a dummy plan; it
-	 * doesn't even need a ModifyTable node.
-	 */
-	if (subpaths == NIL)
-	{
-		set_dummy_rel_pathlist(final_rel);
-		return;
-	}
-
-	/*
-	 * Put back the final adjusted rtable into the master copy of the Query.
-	 * (We mustn't do this if we found no non-excluded children.)
-	 */
-	parse->rtable = final_rtable;
-	root->simple_rel_array_size = save_rel_array_size;
-	root->simple_rel_array = save_rel_array;
-	root->append_rel_array = save_append_rel_array;
-
-	/* Must reconstruct master's simple_rte_array, too */
-	root->simple_rte_array = (RangeTblEntry **)
-		palloc0((list_length(final_rtable) + 1) * sizeof(RangeTblEntry *));
-	rti = 1;
-	foreach(lc, final_rtable)
-	{
-		RangeTblEntry *rte = lfirst_node(RangeTblEntry, lc);
-
-		root->simple_rte_array[rti++] = rte;
-	}
-
-	/*
 	 * If there was a FOR [KEY] UPDATE/SHARE clause, the LockRows node will
 	 * have dealt with fetching non-locked marked rows, else we need to have
 	 * ModifyTable do that.
@@ -1634,6 +1416,12 @@ inheritance_planner(PlannerInfo *root)
  * (inheritance_planner will create a single ModifyTable node covering all the
  * target tables.)
  *
+ * If non-NULL, planned_rel is a RelOptInfo containing paths for the query's
+ * top-level joinrel, which the caller produced by itself.  In that case, this
+ * function only needs to adjust the targetlist of its cheapest_total_path.
+ * The only caller that may pass such a RelOptInfo currently is
+ * inheritance_planner.
+ *
  * tuple_fraction is the fraction of tuples we expect will be retrieved.
  * tuple_fraction is interpreted as follows:
  *	  0: expect all tuples to be retrieved (normal case)
@@ -1652,6 +1440,7 @@ inheritance_planner(PlannerInfo *root)
  */
 static void
 grouping_planner(PlannerInfo *root, bool inheritance_update,
+				 RelOptInfo *planned_rel,
 				 double tuple_fraction)
 {
 	Query	   *parse = root->parse;
@@ -1664,7 +1453,7 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 	List	   *final_targets;
 	List	   *final_targets_contain_srfs;
 	bool		final_target_parallel_safe;
-	RelOptInfo *current_rel;
+	RelOptInfo *current_rel = planned_rel;
 	RelOptInfo *final_rel;
 	ListCell   *lc;
 
@@ -1704,6 +1493,7 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 		 * special work for recursive unions is the responsibility of
 		 * plan_set_operations.
 		 */
+		Assert(current_rel == NULL);
 		current_rel = plan_set_operations(root);
 
 		/*
@@ -1793,17 +1583,26 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 				parse->groupClause = preprocess_groupclause(root, NIL);
 		}
 
-		/* Preprocess targetlist */
-		tlist = preprocess_targetlist(root);
-
 		/*
-		 * We are now done hacking up the query's targetlist.  Most of the
-		 * remaining planning work will be done with the PathTarget
-		 * representation of tlists, but save aside the full representation so
-		 * that we can transfer its decoration (resnames etc) to the topmost
-		 * tlist of the finished Plan.
+		 * Preprocess targetlist, if needed.  If the caller has already done
+		 * query planning, root->processed_tlist already contains the desired
+		 * targetlist.
 		 */
-		root->processed_tlist = tlist;
+		if (planned_rel == NULL)
+		{
+			tlist = preprocess_targetlist(root);
+
+			/*
+			 * We are now done hacking up the query's targetlist.  Most of the
+			 * remaining planning work will be done with the PathTarget
+			 * representation of tlists, but save aside the full representation
+			 * so that we can transfer its decoration (resnames etc) to the
+			 * topmost tlist of the finished Plan.
+			 */
+			root->processed_tlist = tlist;
+		}
+		else
+			tlist = root->processed_tlist;
 
 		/*
 		 * Collect statistics about aggregates for estimating costs, and mark
@@ -1883,8 +1682,9 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 		 * We also generate (in standard_qp_callback) pathkey representations
 		 * of the query's sort clause, distinct clause, etc.
 		 */
-		current_rel = query_planner(root, tlist,
-									standard_qp_callback, &qp_extra);
+		if (current_rel == NULL)
+			current_rel = query_planner(root, tlist,
+										standard_qp_callback, &qp_extra);
 
 		/*
 		 * Convert the query's result tlist into PathTarget format.
diff --git a/src/backend/optimizer/prep/prepjointree.c b/src/backend/optimizer/prep/prepjointree.c
index 77dbf4eba3..87adfa02b1 100644
--- a/src/backend/optimizer/prep/prepjointree.c
+++ b/src/backend/optimizer/prep/prepjointree.c
@@ -917,7 +917,6 @@ pull_up_simple_subquery(PlannerInfo *root, Node *jtnode, RangeTblEntry *rte,
 	subroot->grouping_map = NULL;
 	subroot->minmax_aggs = NIL;
 	subroot->qual_security_level = 0;
-	subroot->inhTargetKind = INHKIND_NONE;
 	subroot->hasRecursion = false;
 	subroot->wt_param_id = -1;
 	subroot->non_recursive_path = NULL;
diff --git a/src/backend/optimizer/util/appendinfo.c b/src/backend/optimizer/util/appendinfo.c
index ca6622ece9..34a3ebbbe4 100644
--- a/src/backend/optimizer/util/appendinfo.c
+++ b/src/backend/optimizer/util/appendinfo.c
@@ -394,8 +394,39 @@ adjust_appendrel_attrs_mutator(Node *node,
 											  context->appinfos);
 		return (Node *) phv;
 	}
+
+	/*
+	 * This is needed, because inheritance_make_rel_from_joinlist needs to
+	 * translate root->join_info_list executing make_rel_from_joinlist for a
+	 * given child.
+	 */
+	if (IsA(node, SpecialJoinInfo))
+	{
+		SpecialJoinInfo *oldinfo = (SpecialJoinInfo *) node;
+		SpecialJoinInfo *newinfo = makeNode(SpecialJoinInfo);
+
+		memcpy(newinfo, oldinfo, sizeof(SpecialJoinInfo));
+		newinfo->min_lefthand = adjust_child_relids(oldinfo->min_lefthand,
+													context->nappinfos,
+													context->appinfos);
+		newinfo->min_righthand = adjust_child_relids(oldinfo->min_righthand,
+													 context->nappinfos,
+													 context->appinfos);
+		newinfo->syn_lefthand = adjust_child_relids(oldinfo->syn_lefthand,
+													context->nappinfos,
+													context->appinfos);
+		newinfo->syn_righthand = adjust_child_relids(oldinfo->syn_righthand,
+													 context->nappinfos,
+													 context->appinfos);
+		newinfo->semi_rhs_exprs =
+			(List *) expression_tree_mutator((Node *)
+											 oldinfo->semi_rhs_exprs,
+											 adjust_appendrel_attrs_mutator,
+											 (void *) context);
+		return (Node *) newinfo;
+	}
+
 	/* 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));
diff --git a/src/backend/optimizer/util/inherit.c b/src/backend/optimizer/util/inherit.c
index db474acbc5..0d2b42f72e 100644
--- a/src/backend/optimizer/util/inherit.c
+++ b/src/backend/optimizer/util/inherit.c
@@ -21,11 +21,14 @@
 #include "miscadmin.h"
 #include "optimizer/appendinfo.h"
 #include "optimizer/inherit.h"
+#include "optimizer/planmain.h"
 #include "optimizer/planner.h"
 #include "optimizer/prep.h"
 #include "utils/rel.h"
 
 
+static PlannerInfo *create_inherited_target_child_root(PlannerInfo *root,
+									AppendRelInfo *appinfo);
 static void expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte,
 						 Index rti);
 static void expand_partitioned_rtentry(PlannerInfo *root,
@@ -492,3 +495,109 @@ translate_col_privs(const Bitmapset *parent_privs,
 
 	return child_privs;
 }
+
+/*
+ * add_inherited_target_child_roots
+ *		For each child of of the query's result relation, this translates the
+ *		original query to match the child and creates a PlannerInfo containing
+ *		the translated query
+ *
+ * Child PlannerInfo reuses most of the parent PlannerInfo's fields unchanged,
+ * except unexpanded_tlist, processed_tlist, and all_baserels, all of which
+ * are based on the child relation.
+ */
+void
+add_inherited_target_child_roots(PlannerInfo *root)
+{
+	Index		resultRelation = root->parse->resultRelation;
+	ListCell   *lc;
+
+	Assert(root->inh_target_child_roots != NULL);
+
+	foreach(lc, root->append_rel_list)
+	{
+		AppendRelInfo *appinfo = lfirst(lc);
+		RangeTblEntry *childRTE;
+		PlannerInfo   *subroot;
+
+		if (appinfo->parent_relid != resultRelation)
+			continue;
+
+		/*
+		 * Create a PlannerInfo for processing this child target relation
+		 * with.
+		 */
+		subroot = create_inherited_target_child_root(root, appinfo);
+		root->inh_target_child_roots[appinfo->child_relid] = subroot;
+
+		/*
+		 * If the child is a partitioned table, recurse to do this for its
+		 * partitions.
+		 */
+		childRTE = root->simple_rte_array[appinfo->child_relid];
+		if (childRTE->inh)
+			add_inherited_target_child_roots(subroot);
+	}
+}
+
+/*
+ * create_inherited_target_child_root
+ *		Workhorse of add_inherited_target_child_roots
+ */
+static PlannerInfo *
+create_inherited_target_child_root(PlannerInfo *root, AppendRelInfo *appinfo)
+{
+	PlannerInfo *subroot;
+	List	   *tlist;
+
+	Assert(root->parse->commandType == CMD_UPDATE ||
+		   root->parse->commandType == CMD_DELETE);
+
+	/*
+	 * Translate the original query to replace Vars of the parent table
+	 * by the corresponding Vars of the child table and to make child the main
+	 * target relation of the query.
+	 */
+	subroot = makeNode(PlannerInfo);
+	memcpy(subroot, root, sizeof(PlannerInfo));
+
+	/*
+	 * Restore the original, unexpanded targetlist, that is, the one before
+	 * preprocess_targetlist was run on the original query.  We'll run
+	 * preprocess_targetlist after translating the query and the targetlist,
+	 * so that it is expanded according to child's tuple descriptor.
+	 */
+	root->parse->targetList = root->unexpanded_tlist;
+	subroot->parse = (Query *) adjust_appendrel_attrs(root,
+													  (Node *) root->parse,
+													  1, &appinfo);
+
+	/* Save the just translated targetlist as unexpanded_tlist in the child's
+	 * subroot, so that this child's own children can use it.  Must use copy
+	 * because subroot->parse->targetList will be modified soon.
+	 */
+	subroot->unexpanded_tlist = list_copy(subroot->parse->targetList);
+
+	/*
+	 * Apply planner's expansion of targetlist, such as adding various junk
+	 * column, filling placeholder entries for dropped columns, etc., all of
+	 * which occurs with the child's TupleDesc.
+	 */
+	tlist = preprocess_targetlist(subroot);
+	subroot->processed_tlist = tlist;
+
+	/* Add any newly added Vars to the child RelOptInfo. */
+	build_base_rel_tlists(subroot, tlist);
+
+	/*
+	 * Adjust all_baserels to replace the original target relation with the
+	 * child target relation.  Copy it before modifying though.
+	 */
+	subroot->all_baserels = bms_copy(root->all_baserels);
+	subroot->all_baserels = bms_del_member(subroot->all_baserels,
+										   root->parse->resultRelation);
+	subroot->all_baserels = bms_add_member(subroot->all_baserels,
+										   subroot->parse->resultRelation);
+
+	return subroot;
+}
diff --git a/src/backend/optimizer/util/plancat.c b/src/backend/optimizer/util/plancat.c
index 48ffc5f254..6009de309e 100644
--- a/src/backend/optimizer/util/plancat.c
+++ b/src/backend/optimizer/util/plancat.c
@@ -1264,36 +1264,6 @@ get_relation_constraints(PlannerInfo *root,
 		}
 	}
 
-	/*
-	 * Append partition predicates, if any.
-	 *
-	 * For selects, partition pruning uses the parent table's partition bound
-	 * descriptor, instead of constraint exclusion which is driven by the
-	 * individual partition's partition constraint.
-	 */
-	if (enable_partition_pruning && root->parse->commandType != CMD_SELECT)
-	{
-		List	   *pcqual = RelationGetPartitionQual(relation);
-
-		if (pcqual)
-		{
-			/*
-			 * Run the partition quals through const-simplification similar to
-			 * check constraints.  We skip canonicalize_qual, though, because
-			 * partition quals should be in canonical form already; also,
-			 * since the qual is in implicit-AND format, we'd have to
-			 * explicitly convert it to explicit-AND format and back again.
-			 */
-			pcqual = (List *) eval_const_expressions(root, (Node *) pcqual);
-
-			/* Fix Vars to have the desired varno */
-			if (varno != 1)
-				ChangeVarNodes((Node *) pcqual, 1, varno, 0);
-
-			result = list_concat(result, pcqual);
-		}
-	}
-
 	heap_close(relation, NoLock);
 
 	return result;
@@ -1417,40 +1387,15 @@ relation_excluded_by_constraints(PlannerInfo *root,
 	/*
 	 * Skip further tests, depending on constraint_exclusion.
 	 */
-	switch (constraint_exclusion)
-	{
-		case CONSTRAINT_EXCLUSION_OFF:
-
-			/*
-			 * Don't prune if feature turned off -- except if the relation is
-			 * a partition.  While partprune.c-style partition pruning is not
-			 * yet in use for all cases (update/delete is not handled), it
-			 * would be a UI horror to use different user-visible controls
-			 * depending on such a volatile implementation detail.  Therefore,
-			 * for partitioned tables we use enable_partition_pruning to
-			 * control this behavior.
-			 */
-			if (root->inhTargetKind == INHKIND_PARTITIONED)
-				break;
-			return false;
-
-		case CONSTRAINT_EXCLUSION_PARTITION:
-
-			/*
-			 * When constraint_exclusion is set to 'partition' we only handle
-			 * OTHER_MEMBER_RELs, or BASERELs in cases where the result target
-			 * is an inheritance parent or a partitioned table.
-			 */
-			if ((rel->reloptkind != RELOPT_OTHER_MEMBER_REL) &&
-				!(rel->reloptkind == RELOPT_BASEREL &&
-				  root->inhTargetKind != INHKIND_NONE &&
-				  rel->relid == root->parse->resultRelation))
-				return false;
-			break;
-
-		case CONSTRAINT_EXCLUSION_ON:
-			break;				/* always try to exclude */
-	}
+	if (constraint_exclusion == CONSTRAINT_EXCLUSION_OFF)
+		return false;
+	/*
+	 * When constraint_exclusion is set to 'partition' we only handle
+	 * OTHER_MEMBER_RELs.
+	 */
+	else if (constraint_exclusion == CONSTRAINT_EXCLUSION_PARTITION &&
+			 rel->reloptkind != RELOPT_OTHER_MEMBER_REL)
+		return false;
 
 	/*
 	 * Check for self-contradictory restriction clauses.  We dare not make
diff --git a/src/include/nodes/relation.h b/src/include/nodes/relation.h
index 3430061361..beb2e323a8 100644
--- a/src/include/nodes/relation.h
+++ b/src/include/nodes/relation.h
@@ -319,9 +319,6 @@ typedef struct PlannerInfo
 	Index		qual_security_level;	/* minimum security_level for quals */
 	/* Note: qual_security_level is zero if there are no securityQuals */
 
-	InheritanceKind inhTargetKind;	/* indicates if the target relation is an
-									 * inheritance child or partition or a
-									 * partitioned table */
 	bool		hasJoinRTEs;	/* true if any RTEs are RTE_JOIN kind */
 	bool		hasLateralRTEs; /* true if any RTEs are marked LATERAL */
 	bool		hasDeletedRTEs; /* true if any RTE was deleted from jointree */
@@ -343,6 +340,40 @@ typedef struct PlannerInfo
 
 	/* Does this query modify any partition key columns? */
 	bool		partColsUpdated;
+
+	/*
+	 * The following fields are set during query planning portion of an
+	 * inherited UPDATE/DEELETE operation.
+	 */
+	bool		inherited_update;	/* UPDATE/DELETE on inheritance parent? */
+
+	/*
+	 * This stores the original version of the query's targetlist that's
+	 * not modified by the planner.
+	 */
+	List	   *unexpanded_tlist;
+
+	/*
+	 * Array containing simple_rel_array_size elements, indexed by rangetable
+	 * index (entry 0 is wasted like simple_rel_array).  Only elements
+	 * corresponding to individual inheritance child target relations are
+	 * non-NULL.  Content of each PlannerInfo is same as the parent
+	 * PlannerInfo, except for the parse tree which is a translated copy of
+	 * the parent's parse tree.
+	 */
+	struct PlannerInfo **inh_target_child_roots;
+
+	/* List of RT indexes of child RT indexes. */
+	List	   *inh_target_child_rels;
+
+	/*
+	 * RelOptInfos corresponding to each child target rel.  For leaf children,
+	 * it's the RelOptInfo representing the output of make_rel_from_joinlist()
+	 * called with the parent rel in the original join tree replaced by a
+	 * given leaf child.  For non-leaf children, it's the baserel RelOptInfo
+	 * itself, left as a placeholder.
+	 */
+	List	   *inh_target_child_joinrels;
 } PlannerInfo;
 
 
diff --git a/src/include/optimizer/inherit.h b/src/include/optimizer/inherit.h
index b2687abd4e..1dbc2ca5bf 100644
--- a/src/include/optimizer/inherit.h
+++ b/src/include/optimizer/inherit.h
@@ -18,5 +18,6 @@
 
 
 extern void expand_inherited_tables(PlannerInfo *root);
+extern void add_inherited_target_child_roots(PlannerInfo *root);
 
 #endif							/* INHERIT_H */
diff --git a/src/include/optimizer/paths.h b/src/include/optimizer/paths.h
index 666217c189..f524ab6beb 100644
--- a/src/include/optimizer/paths.h
+++ b/src/include/optimizer/paths.h
@@ -161,7 +161,8 @@ extern EquivalenceClass *match_eclasses_to_foreign_key_col(PlannerInfo *root,
 extern void add_child_rel_equivalences(PlannerInfo *root,
 						   AppendRelInfo *appinfo,
 						   RelOptInfo *parent_rel,
-						   RelOptInfo *child_rel);
+						   RelOptInfo *child_rel,
+						   bool replace);
 extern List *generate_implied_equalities_for_column(PlannerInfo *root,
 									   RelOptInfo *rel,
 									   ec_matches_callback_type callback,
diff --git a/src/test/regress/expected/partition_join.out b/src/test/regress/expected/partition_join.out
index c55de5d476..c9f02c1fb0 100644
--- a/src/test/regress/expected/partition_join.out
+++ b/src/test/regress/expected/partition_join.out
@@ -1780,7 +1780,7 @@ WHERE EXISTS (
                Filter: (c IS NULL)
          ->  Nested Loop
                ->  Seq Scan on int4_tbl
-               ->  Subquery Scan on ss_1
+               ->  Subquery Scan on ss
                      ->  Limit
                            ->  Seq Scan on int8_tbl int8_tbl_1
    ->  Nested Loop Semi Join
@@ -1788,7 +1788,7 @@ WHERE EXISTS (
                Filter: (c IS NULL)
          ->  Nested Loop
                ->  Seq Scan on int4_tbl
-               ->  Subquery Scan on ss_2
+               ->  Subquery Scan on ss
                      ->  Limit
                            ->  Seq Scan on int8_tbl int8_tbl_2
 (28 rows)
-- 
2.11.0

From 6cea5750413fade8ef432c8f9196035dba2d0f99 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Fri, 26 Oct 2018 16:45:59 +0900
Subject: [PATCH v15 2/4] Lazy creation of RTEs for inheritance children

Currently, expand_inherited_tables called from subquery_planner opens
all inheritance child tables and adds them to the query's range
table and PlannerInfo in the form of AppendRelInfo's initially and
later RelOptInfo's.  For partitioning, that's pretty wasteful, because
it's possible to determine only the partitions that will need to be
scanned using partition pruning, which doesn't require opening the
partitions themselves.  However, the point at which
expand_inherited_tables is called currently is too early to perform
partition pruning.

This commit rearranges things within the planner so that
expand_inherited_tables can be called from query_planner after the
latter has finished setting up the information needed to perform
partition pruning.  However that means the PlannerInfo arrays that
store RangeTblEntry's, RelOptInfo's, and AppendRelInfo's need to
be expanded if inheritance expansion leads to adding more relations
to planning.  There are also consequences around targetlist
expansion.  For example, preprocess_targetlist cannot add the junk
columns entries needed for row mark handling until all of the
inheritance children have been determined, because different children
may need different types of junk columns to be added.  So, the
approach of late inheritance expansion required some interface tweaks
for preprocess_targetlist().

For partitioning, although we don't create a RangeTblEntry and
RelOptInfo for pruned partitions at make_one_rel time, partitionwise
join code relies on the fact that even though partitions may have
been pruned, they'd still own a RelOptInfo to handle the outer join
case where the pruned partition appears on the nullable side of join.
Partitionwise join code deals with that by allocating dummy
RelOptInfos for pruned partitions that are based mostly on their
parent's properties.

There are some regression test diffs:

 1. Caused by the fact that we no longer allocate a duplicate RT
    entry for a partitioned table in its role as child, as seen in
    the partition_aggregate.out test output.

 2. Those in postgres_fdw.out are caused by the fact that junk columns
    required for row marking are added to reltarget->exprs later than
    user columns, because the row marking junk columns aren't added
    until the inheritance is expanded which as of this commit is
    later than it used to be as noted above.
---
 contrib/postgres_fdw/expected/postgres_fdw.out    |  32 +-
 src/backend/nodes/outfuncs.c                      |   1 +
 src/backend/optimizer/path/allpaths.c             | 372 ++--------
 src/backend/optimizer/path/joinrels.c             |  61 ++
 src/backend/optimizer/plan/initsplan.c            |  58 --
 src/backend/optimizer/plan/planmain.c             |  10 +
 src/backend/optimizer/plan/planner.c              |  74 +-
 src/backend/optimizer/plan/setrefs.c              |   6 +
 src/backend/optimizer/prep/preptlist.c            |  15 +-
 src/backend/optimizer/prep/prepunion.c            |   3 +
 src/backend/optimizer/util/appendinfo.c           |  45 +-
 src/backend/optimizer/util/inherit.c              | 819 +++++++++++++++-------
 src/backend/optimizer/util/plancat.c              |  47 +-
 src/backend/optimizer/util/relnode.c              | 107 +--
 src/backend/partitioning/partprune.c              |  43 +-
 src/include/nodes/relation.h                      |  18 +
 src/include/optimizer/appendinfo.h                |   7 +-
 src/include/optimizer/pathnode.h                  |   1 +
 src/include/optimizer/plancat.h                   |   4 +-
 src/include/optimizer/prep.h                      |   3 +-
 src/include/partitioning/partprune.h              |   2 +-
 src/test/regress/expected/partition_aggregate.out |   4 +-
 22 files changed, 946 insertions(+), 786 deletions(-)

diff --git a/contrib/postgres_fdw/expected/postgres_fdw.out b/contrib/postgres_fdw/expected/postgres_fdw.out
index bb92d9d37a..33a33606ef 100644
--- a/contrib/postgres_fdw/expected/postgres_fdw.out
+++ b/contrib/postgres_fdw/expected/postgres_fdw.out
@@ -7072,15 +7072,15 @@ select * from bar where f1 in (select f1 from foo) for update;
                      Output: bar2.f1, bar2.f2, bar2.ctid, bar2.*, bar2.tableoid
                      Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct2 FOR UPDATE
          ->  Hash
-               Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+               Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                ->  HashAggregate
-                     Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                     Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                      Group Key: foo.f1
                      ->  Append
                            ->  Seq Scan on public.foo
-                                 Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                                 Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                            ->  Foreign Scan on public.foo2
-                                 Output: foo2.ctid, foo2.*, foo2.tableoid, foo2.f1
+                                 Output: foo2.f1, foo2.ctid, foo2.*, foo2.tableoid
                                  Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct1
 (23 rows)
 
@@ -7110,15 +7110,15 @@ select * from bar where f1 in (select f1 from foo) for share;
                      Output: bar2.f1, bar2.f2, bar2.ctid, bar2.*, bar2.tableoid
                      Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct2 FOR SHARE
          ->  Hash
-               Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+               Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                ->  HashAggregate
-                     Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                     Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                      Group Key: foo.f1
                      ->  Append
                            ->  Seq Scan on public.foo
-                                 Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                                 Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                            ->  Foreign Scan on public.foo2
-                                 Output: foo2.ctid, foo2.*, foo2.tableoid, foo2.f1
+                                 Output: foo2.f1, foo2.ctid, foo2.*, foo2.tableoid
                                  Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct1
 (23 rows)
 
@@ -7147,15 +7147,15 @@ update bar set f2 = f2 + 100 where f1 in (select f1 from foo);
          ->  Seq Scan on public.bar
                Output: bar.f1, bar.f2, bar.ctid
          ->  Hash
-               Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+               Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                ->  HashAggregate
-                     Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                     Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                      Group Key: foo.f1
                      ->  Append
                            ->  Seq Scan on public.foo
-                                 Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                                 Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                            ->  Foreign Scan on public.foo2
-                                 Output: foo2.ctid, foo2.*, foo2.tableoid, foo2.f1
+                                 Output: foo2.f1, foo2.ctid, foo2.*, foo2.tableoid
                                  Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct1
    ->  Hash Join
          Output: bar2.f1, (bar2.f2 + 100), bar2.f3, bar2.ctid, foo.ctid, foo.*, foo.tableoid
@@ -7165,15 +7165,15 @@ update bar set f2 = f2 + 100 where f1 in (select f1 from foo);
                Output: bar2.f1, bar2.f2, bar2.f3, bar2.ctid
                Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct2 FOR UPDATE
          ->  Hash
-               Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+               Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                ->  HashAggregate
-                     Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                     Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                      Group Key: foo.f1
                      ->  Append
                            ->  Seq Scan on public.foo
-                                 Output: foo.ctid, foo.*, foo.tableoid, foo.f1
+                                 Output: foo.f1, foo.ctid, foo.*, foo.tableoid
                            ->  Foreign Scan on public.foo2
-                                 Output: foo2.ctid, foo2.*, foo2.tableoid, foo2.f1
+                                 Output: foo2.f1, foo2.ctid, foo2.*, foo2.tableoid
                                  Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct1
 (39 rows)
 
diff --git a/src/backend/nodes/outfuncs.c b/src/backend/nodes/outfuncs.c
index 158da68925..67697b8884 100644
--- a/src/backend/nodes/outfuncs.c
+++ b/src/backend/nodes/outfuncs.c
@@ -2272,6 +2272,7 @@ _outRelOptInfo(StringInfo str, const RelOptInfo *node)
 	WRITE_BOOL_FIELD(consider_partitionwise_join);
 	WRITE_BITMAPSET_FIELD(top_parent_relids);
 	WRITE_NODE_FIELD(partitioned_child_rels);
+	WRITE_UINT_FIELD(inh_root_parent);
 }
 
 static void
diff --git a/src/backend/optimizer/path/allpaths.c b/src/backend/optimizer/path/allpaths.c
index 3324d485e4..042d6b2b0d 100644
--- a/src/backend/optimizer/path/allpaths.c
+++ b/src/backend/optimizer/path/allpaths.c
@@ -45,7 +45,6 @@
 #include "optimizer/var.h"
 #include "parser/parse_clause.h"
 #include "parser/parsetree.h"
-#include "partitioning/partprune.h"
 #include "rewrite/rewriteManip.h"
 #include "utils/lsyscache.h"
 
@@ -383,6 +382,14 @@ set_rel_size(PlannerInfo *root, RelOptInfo *rel,
 	else if (rte->inh)
 	{
 		/*
+		 * expand_inherited_tables may have proved that the relation is empty.
+		 * For example, if it's a partitioned table with 0 partitions or all
+		 * of its partitions are pruned.  In that case nothing to do here.
+		 */
+		if (IS_DUMMY_REL(rel))
+			return;
+
+		/*
 		 * If it's a target relation, set the sizes of children instead.
 		 * Otherwise, we'll append the outputs of children, so process it as
 		 * an "append relation".
@@ -951,38 +958,18 @@ set_inherit_target_rel_sizes(PlannerInfo *root, RelOptInfo *rel,
 	int			parentRTindex = rti;
 	bool		has_live_children;
 	ListCell   *l;
-	Relids		live_children = NULL;
-	bool		did_pruning = false;
 
 	/* Guard against stack overflow due to overly deep inheritance tree. */
 	check_stack_depth();
 
 	Assert(IS_SIMPLE_REL(rel));
 
-	/*
-	 * If the partitioned relation has any baserestrictinfo quals then we
-	 * attempt to use these quals to prune away partitions that cannot
-	 * possibly contain any tuples matching these quals.  In this case we'll
-	 * store the relids of all partitions which could possibly contain a
-	 * matching tuple, and skip anything else in the loop below.
-	 */
-	if (enable_partition_pruning &&
-		rte->relkind == RELKIND_PARTITIONED_TABLE &&
-		rel->baserestrictinfo != NIL)
-	{
-		live_children = prune_append_rel_partitions(rel);
-		did_pruning = true;
-	}
-
 	foreach(l, root->append_rel_list)
 	{
 		AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(l);
 		int			childRTindex;
 		RangeTblEntry *childRTE;
 		RelOptInfo *childrel;
-		List	   *childquals;
-		Index		cq_min_security;
-		bool		have_const_false_cq;
 		PlannerInfo *subroot;
 		ListCell   *lc;
 		List	   *translated_exprs,
@@ -994,141 +981,22 @@ set_inherit_target_rel_sizes(PlannerInfo *root, RelOptInfo *rel,
 
 		childRTindex = appinfo->child_relid;
 		childRTE = root->simple_rte_array[childRTindex];
+		Assert(childRTE != NULL);
 
 		/*
-		 * The child rel's RelOptInfo was already created during
-		 * add_base_rels_to_query.
+		 * The child rel's RelOptInfo was created during
+		 * expand_inherited_tables().
 		 */
 		childrel = find_base_rel(root, childRTindex);
+		Assert(childrel != NULL);
 		Assert(childrel->reloptkind == RELOPT_OTHER_MEMBER_REL);
 
 		/*
-		 * We have to copy the parent's quals to the child, with appropriate
-		 * substitution of variables.  However, only the baserestrictinfo
-		 * quals are needed before we can check for constraint exclusion; so
-		 * do that first and then check to see if we can disregard this child.
-		 *
-		 * The child rel's targetlist might contain non-Var expressions, which
-		 * means that substitution into the quals could produce opportunities
-		 * for const-simplification, and perhaps even pseudoconstant quals.
-		 * Therefore, transform each RestrictInfo separately to see if it
-		 * reduces to a constant or pseudoconstant.  (We must process them
-		 * separately to keep track of the security level of each qual.)
+		 * Child relation may have been marked dummy if build_append_child_rel
+		 * found self-contradictory quals.
 		 */
-		childquals = NIL;
-		cq_min_security = UINT_MAX;
-		have_const_false_cq = false;
-		foreach(lc, rel->baserestrictinfo)
-		{
-			RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
-			Node	   *childqual;
-			ListCell   *lc2;
-
-			Assert(IsA(rinfo, RestrictInfo));
-			childqual = adjust_appendrel_attrs(root,
-											   (Node *) rinfo->clause,
-											   1, &appinfo);
-			childqual = eval_const_expressions(root, childqual);
-			/* check for flat-out constant */
-			if (childqual && IsA(childqual, Const))
-			{
-				if (((Const *) childqual)->constisnull ||
-					!DatumGetBool(((Const *) childqual)->constvalue))
-				{
-					/* Restriction reduces to constant FALSE or NULL */
-					have_const_false_cq = true;
-					break;
-				}
-				/* Restriction reduces to constant TRUE, so drop it */
-				continue;
-			}
-			/* might have gotten an AND clause, if so flatten it */
-			foreach(lc2, make_ands_implicit((Expr *) childqual))
-			{
-				Node	   *onecq = (Node *) lfirst(lc2);
-				bool		pseudoconstant;
-
-				/* check for pseudoconstant (no Vars or volatile functions) */
-				pseudoconstant =
-					!contain_vars_of_level(onecq, 0) &&
-					!contain_volatile_functions(onecq);
-				if (pseudoconstant)
-				{
-					/* tell createplan.c to check for gating quals */
-					root->hasPseudoConstantQuals = true;
-				}
-				/* reconstitute RestrictInfo with appropriate properties */
-				childquals = lappend(childquals,
-									 make_restrictinfo((Expr *) onecq,
-													   rinfo->is_pushed_down,
-													   rinfo->outerjoin_delayed,
-													   pseudoconstant,
-													   rinfo->security_level,
-													   NULL, NULL, NULL));
-				/* track minimum security level among child quals */
-				cq_min_security = Min(cq_min_security, rinfo->security_level);
-			}
-		}
-
-		/*
-		 * In addition to the quals inherited from the parent, we might have
-		 * securityQuals associated with this particular child node.
-		 * (Currently this can only happen in appendrels originating from
-		 * UNION ALL; inheritance child tables don't have their own
-		 * securityQuals, see expand_inherited_rtentry().)	Pull any such
-		 * securityQuals up into the baserestrictinfo for the child.  This is
-		 * similar to process_security_barrier_quals() for the parent rel,
-		 * except that we can't make any general deductions from such quals,
-		 * since they don't hold for the whole appendrel.
-		 */
-		if (childRTE->securityQuals)
-		{
-			Index		security_level = 0;
-
-			foreach(lc, childRTE->securityQuals)
-			{
-				List	   *qualset = (List *) lfirst(lc);
-				ListCell   *lc2;
-
-				foreach(lc2, qualset)
-				{
-					Expr	   *qual = (Expr *) lfirst(lc2);
-
-					/* not likely that we'd see constants here, so no check */
-					childquals = lappend(childquals,
-										 make_restrictinfo(qual,
-														   true, false, false,
-														   security_level,
-														   NULL, NULL, NULL));
-					cq_min_security = Min(cq_min_security, security_level);
-				}
-				security_level++;
-			}
-			Assert(security_level <= root->qual_security_level);
-		}
-
-		/*
-		 * OK, we've got all the baserestrictinfo quals for this child.
-		 */
-		childrel->baserestrictinfo = childquals;
-		childrel->baserestrict_min_security = cq_min_security;
-
-		if (have_const_false_cq)
-		{
-			/*
-			 * Some restriction clause reduced to constant FALSE or NULL after
-			 * substitution, so this child need not be scanned.
-			 */
-			set_dummy_rel_pathlist(childrel);
+		if (IS_DUMMY_REL(childrel))
 			continue;
-		}
-
-		if (did_pruning && !bms_is_member(appinfo->child_relid, live_children))
-		{
-			/* This partition was pruned; skip it. */
-			set_dummy_rel_pathlist(childrel);
-			continue;
-		}
 
 		if (relation_excluded_by_constraints(root, childrel, childRTE))
 		{
@@ -1181,15 +1049,9 @@ set_inherit_target_rel_sizes(PlannerInfo *root, RelOptInfo *rel,
 				EquivalenceClass *new_ec = makeNode(EquivalenceClass);
 
 				/*
-				 * First memcpy which creates shallow copies of all
-				 * the members and then make copies of members that could
-				 * change.
-				 *
-				 * XXX comment in _copyPathKey says it's OK to recycle EC
-				 * pointers, but as long as we do the whole planning for a
-				 * given child using a given root, copying ECs like this
-				 * shouldn't be a problem.  Maybe, the following code could
-				 * be in _copyEquivalenceClass()?
+				 * First memcpy the original EC, which creates shallow copies
+				 * of all the members and then make copies of members that
+				 * might change during add_child_rel_equivalences().
 				 */
 				memcpy(new_ec, ec, sizeof(EquivalenceClass));
 				new_ec->ec_opfamilies = list_copy(ec->ec_opfamilies);
@@ -1332,8 +1194,6 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 	double	   *parent_attrsizes;
 	int			nattrs;
 	ListCell   *l;
-	Relids		live_children = NULL;
-	bool		did_pruning = false;
 
 	/* Guard against stack overflow due to overly deep inheritance tree. */
 	check_stack_depth();
@@ -1341,32 +1201,6 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 	Assert(IS_SIMPLE_REL(rel));
 
 	/*
-	 * Initialize partitioned_child_rels to contain this RT index.
-	 *
-	 * Note that during the set_append_rel_pathlist() phase, we will bubble up
-	 * the indexes of partitioned relations that appear down in the tree, so
-	 * that when we've created Paths for all the children, the root
-	 * partitioned table's list will contain all such indexes.
-	 */
-	if (rte->relkind == RELKIND_PARTITIONED_TABLE)
-		rel->partitioned_child_rels = list_make1_int(rti);
-
-	/*
-	 * If the partitioned relation has any baserestrictinfo quals then we
-	 * attempt to use these quals to prune away partitions that cannot
-	 * possibly contain any tuples matching these quals.  In this case we'll
-	 * store the relids of all partitions which could possibly contain a
-	 * matching tuple, and skip anything else in the loop below.
-	 */
-	if (enable_partition_pruning &&
-		rte->relkind == RELKIND_PARTITIONED_TABLE &&
-		rel->baserestrictinfo != NIL)
-	{
-		live_children = prune_append_rel_partitions(rel);
-		did_pruning = true;
-	}
-
-	/*
 	 * If this is a partitioned baserel, set the consider_partitionwise_join
 	 * flag; currently, we only consider partitionwise joins with the baserel
 	 * if its targetlist doesn't contain a whole-row Var.
@@ -1403,12 +1237,8 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 		int			childRTindex;
 		RangeTblEntry *childRTE;
 		RelOptInfo *childrel;
-		List	   *childquals;
-		Index		cq_min_security;
-		bool		have_const_false_cq;
 		ListCell   *parentvars;
 		ListCell   *childvars;
-		ListCell   *lc;
 
 		/* append_rel_list contains all append rels; ignore others */
 		if (appinfo->parent_relid != parentRTindex)
@@ -1416,18 +1246,35 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 
 		childRTindex = appinfo->child_relid;
 		childRTE = root->simple_rte_array[childRTindex];
+		Assert(childRTE != NULL);
 
 		/*
-		 * The child rel's RelOptInfo was already created during
-		 * add_base_rels_to_query.
+		 * The child rel's RelOptInfo was created during
+		 * expand_inherited_tables().
 		 */
 		childrel = find_base_rel(root, childRTindex);
+		Assert(childrel != NULL);
 		Assert(childrel->reloptkind == RELOPT_OTHER_MEMBER_REL);
 
 		/*
-		 * Copy/Modify targetlist. Even if this child is deemed empty, we need
-		 * its targetlist in case it falls on nullable side in a child-join
-		 * because of partitionwise join.
+		 * Child relation may have been marked dummy if build_append_child_rel
+		 * found self-contradictory quals.
+		 */
+		if (IS_DUMMY_REL(childrel))
+			continue;
+
+		if (relation_excluded_by_constraints(root, childrel, childRTE))
+		{
+			/*
+			 * This child need not be scanned, so we can omit it from the
+			 * appendrel.
+			 */
+			set_dummy_rel_pathlist(childrel);
+			continue;
+		}
+
+		/*
+		 * Copy/Modify targetlist.
 		 *
 		 * NB: the resulting childrel->reltarget->exprs may contain arbitrary
 		 * expressions, which otherwise would not occur in a rel's targetlist.
@@ -1457,144 +1304,6 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 									   false);
 		childrel->has_eclass_joins = rel->has_eclass_joins;
 
-		/*
-		 * We have to copy the parent's quals to the child, with appropriate
-		 * substitution of variables.  However, only the baserestrictinfo
-		 * quals are needed before we can check for constraint exclusion; so
-		 * do that first and then check to see if we can disregard this child.
-		 *
-		 * The child rel's targetlist might contain non-Var expressions, which
-		 * means that substitution into the quals could produce opportunities
-		 * for const-simplification, and perhaps even pseudoconstant quals.
-		 * Therefore, transform each RestrictInfo separately to see if it
-		 * reduces to a constant or pseudoconstant.  (We must process them
-		 * separately to keep track of the security level of each qual.)
-		 */
-		childquals = NIL;
-		cq_min_security = UINT_MAX;
-		have_const_false_cq = false;
-		foreach(lc, rel->baserestrictinfo)
-		{
-			RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
-			Node	   *childqual;
-			ListCell   *lc2;
-
-			Assert(IsA(rinfo, RestrictInfo));
-			childqual = adjust_appendrel_attrs(root,
-											   (Node *) rinfo->clause,
-											   1, &appinfo);
-			childqual = eval_const_expressions(root, childqual);
-			/* check for flat-out constant */
-			if (childqual && IsA(childqual, Const))
-			{
-				if (((Const *) childqual)->constisnull ||
-					!DatumGetBool(((Const *) childqual)->constvalue))
-				{
-					/* Restriction reduces to constant FALSE or NULL */
-					have_const_false_cq = true;
-					break;
-				}
-				/* Restriction reduces to constant TRUE, so drop it */
-				continue;
-			}
-			/* might have gotten an AND clause, if so flatten it */
-			foreach(lc2, make_ands_implicit((Expr *) childqual))
-			{
-				Node	   *onecq = (Node *) lfirst(lc2);
-				bool		pseudoconstant;
-
-				/* check for pseudoconstant (no Vars or volatile functions) */
-				pseudoconstant =
-					!contain_vars_of_level(onecq, 0) &&
-					!contain_volatile_functions(onecq);
-				if (pseudoconstant)
-				{
-					/* tell createplan.c to check for gating quals */
-					root->hasPseudoConstantQuals = true;
-				}
-				/* reconstitute RestrictInfo with appropriate properties */
-				childquals = lappend(childquals,
-									 make_restrictinfo((Expr *) onecq,
-													   rinfo->is_pushed_down,
-													   rinfo->outerjoin_delayed,
-													   pseudoconstant,
-													   rinfo->security_level,
-													   NULL, NULL, NULL));
-				/* track minimum security level among child quals */
-				cq_min_security = Min(cq_min_security, rinfo->security_level);
-			}
-		}
-
-		/*
-		 * In addition to the quals inherited from the parent, we might have
-		 * securityQuals associated with this particular child node.
-		 * (Currently this can only happen in appendrels originating from
-		 * UNION ALL; inheritance child tables don't have their own
-		 * securityQuals, see expand_inherited_rtentry().)	Pull any such
-		 * securityQuals up into the baserestrictinfo for the child.  This is
-		 * similar to process_security_barrier_quals() for the parent rel,
-		 * except that we can't make any general deductions from such quals,
-		 * since they don't hold for the whole appendrel.
-		 */
-		if (childRTE->securityQuals)
-		{
-			Index		security_level = 0;
-
-			foreach(lc, childRTE->securityQuals)
-			{
-				List	   *qualset = (List *) lfirst(lc);
-				ListCell   *lc2;
-
-				foreach(lc2, qualset)
-				{
-					Expr	   *qual = (Expr *) lfirst(lc2);
-
-					/* not likely that we'd see constants here, so no check */
-					childquals = lappend(childquals,
-										 make_restrictinfo(qual,
-														   true, false, false,
-														   security_level,
-														   NULL, NULL, NULL));
-					cq_min_security = Min(cq_min_security, security_level);
-				}
-				security_level++;
-			}
-			Assert(security_level <= root->qual_security_level);
-		}
-
-		/*
-		 * OK, we've got all the baserestrictinfo quals for this child.
-		 */
-		childrel->baserestrictinfo = childquals;
-		childrel->baserestrict_min_security = cq_min_security;
-
-		if (have_const_false_cq)
-		{
-			/*
-			 * Some restriction clause reduced to constant FALSE or NULL after
-			 * substitution, so this child need not be scanned.
-			 */
-			set_dummy_rel_pathlist(childrel);
-			continue;
-		}
-
-		if (did_pruning && !bms_is_member(appinfo->child_relid, live_children))
-		{
-			/* This partition was pruned; skip it. */
-			set_dummy_rel_pathlist(childrel);
-			continue;
-		}
-
-		if (relation_excluded_by_constraints(root, childrel, childRTE))
-		{
-			/*
-			 * This child need not be scanned, so we can omit it from the
-			 * appendrel.
-			 */
-			set_dummy_rel_pathlist(childrel);
-			continue;
-		}
-
 		/* CE failed, so finish copying/modifying join quals. */
 		childrel->joininfo = (List *)
 			adjust_appendrel_attrs(root,
@@ -3070,6 +2779,7 @@ inheritance_make_rel_from_joinlist(PlannerInfo *root, List *joinlist)
 			continue;
 
 		childrel = find_base_rel(root, appinfo->child_relid);
+		Assert(childrel != NULL);
 
 		/* Ignore excluded/pruned children. */
 		if (IS_DUMMY_REL(childrel))
diff --git a/src/backend/optimizer/path/joinrels.c b/src/backend/optimizer/path/joinrels.c
index 00611a5e40..75edac96f4 100644
--- a/src/backend/optimizer/path/joinrels.c
+++ b/src/backend/optimizer/path/joinrels.c
@@ -20,6 +20,7 @@
 #include "optimizer/joininfo.h"
 #include "optimizer/pathnode.h"
 #include "optimizer/paths.h"
+#include "optimizer/tlist.h"
 #include "partitioning/partbounds.h"
 #include "utils/lsyscache.h"
 #include "utils/memutils.h"
@@ -49,6 +50,9 @@ static SpecialJoinInfo *build_child_join_sjinfo(PlannerInfo *root,
 						Relids left_relids, Relids right_relids);
 static int match_expr_to_partition_keys(Expr *expr, RelOptInfo *rel,
 							 bool strict_op);
+static RelOptInfo *build_dummy_partition_rel(PlannerInfo *root,
+									RelOptInfo *parent,
+									int partidx);
 
 
 /*
@@ -1379,6 +1383,11 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
 		AppendRelInfo **appinfos;
 		int			nappinfos;
 
+		if (IS_SIMPLE_REL(rel1) && child_rel1 == NULL)
+			child_rel1 = build_dummy_partition_rel(root, rel1, cnt_parts);
+		if (IS_SIMPLE_REL(rel1) && child_rel2 == NULL)
+			child_rel2 = build_dummy_partition_rel(root, rel2, cnt_parts);
+
 		/* We should never try to join two overlapping sets of rels. */
 		Assert(!bms_overlap(child_rel1->relids, child_rel2->relids));
 		child_joinrelids = bms_union(child_rel1->relids, child_rel2->relids);
@@ -1627,3 +1636,55 @@ match_expr_to_partition_keys(Expr *expr, RelOptInfo *rel, bool strict_op)
 
 	return -1;
 }
+
+/*
+ * build_dummy_partition_rel
+ *		Build a RelOptInfo and AppendRelInfo for a pruned partition
+ *
+ * This does not result in opening the relation or a range table entry being
+ * created.  Also, the RelOptInfo thus created is not stored anywhere else
+ * beside the parent's part_rels array.
+ *
+ * The only reason this exists is because partition-wise join, in some cases,
+ * needs a RelOptInfo to represent an empty relation that's on the nullable
+ * side of an outer join, so that a Path representing the outer join can be
+ * created.
+ */
+static RelOptInfo *
+build_dummy_partition_rel(PlannerInfo *root, RelOptInfo *parent, int partidx)
+{
+	RangeTblEntry *parentrte = root->simple_rte_array[parent->relid];
+	RelOptInfo *rel;
+
+	Assert(parent->part_rels[partidx] == NULL);
+
+	/* Create minimally valid-looking RelOptInfo with parent's relid. */
+	rel = makeNode(RelOptInfo);
+	rel->reloptkind = RELOPT_OTHER_MEMBER_REL;
+	rel->relid = parent->relid;
+	rel->relids = bms_copy(parent->relids);
+	if (parent->top_parent_relids)
+		rel->top_parent_relids = parent->top_parent_relids;
+	else
+		rel->top_parent_relids = bms_copy(parent->relids);
+	rel->reltarget = copy_pathtarget(parent->reltarget);
+	parent->part_rels[partidx] = rel;
+	mark_dummy_rel(rel);
+
+	/*
+	 * Now we'll need a (no-op) AppendRelInfo for parent, because we're
+	 * setting the dummy partition's relid to be same as the parent's.
+	 */
+	if (root->append_rel_array[parent->relid] == NULL)
+	{
+		AppendRelInfo *appinfo = make_append_rel_info(parent, parentrte,
+													  parent->tupdesc,
+													  parentrte->relid,
+													  parent->reltype,
+													  parent->relid);
+
+		root->append_rel_array[parent->relid] = appinfo;
+	}
+
+	return rel;
+}
diff --git a/src/backend/optimizer/plan/initsplan.c b/src/backend/optimizer/plan/initsplan.c
index a66374094f..c628f3d9e7 100644
--- a/src/backend/optimizer/plan/initsplan.c
+++ b/src/backend/optimizer/plan/initsplan.c
@@ -616,64 +616,6 @@ create_lateral_join_info(PlannerInfo *root)
 				bms_add_member(brel2->lateral_referencers, rti);
 		}
 	}
-
-	/*
-	 * Lastly, propagate lateral_relids and lateral_referencers from appendrel
-	 * parent rels to their child rels.  We intentionally give each child rel
-	 * the same minimum parameterization, even though it's quite possible that
-	 * some don't reference all the lateral rels.  This is because any append
-	 * path for the parent will have to have the same parameterization for
-	 * every child anyway, and there's no value in forcing extra
-	 * reparameterize_path() calls.  Similarly, a lateral reference to the
-	 * parent prevents use of otherwise-movable join rels for each child.
-	 */
-	for (rti = 1; rti < root->simple_rel_array_size; rti++)
-	{
-		RelOptInfo *brel = root->simple_rel_array[rti];
-		RangeTblEntry *brte = root->simple_rte_array[rti];
-
-		/*
-		 * Skip empty slots. Also skip non-simple relations i.e. dead
-		 * relations.
-		 */
-		if (brel == NULL || !IS_SIMPLE_REL(brel))
-			continue;
-
-		/*
-		 * In the case of table inheritance, the parent RTE is directly linked
-		 * to every child table via an AppendRelInfo.  In the case of table
-		 * partitioning, the inheritance hierarchy is expanded one level at a
-		 * time rather than flattened.  Therefore, an other member rel that is
-		 * a partitioned table may have children of its own, and must
-		 * therefore be marked with the appropriate lateral info so that those
-		 * children eventually get marked also.
-		 */
-		Assert(brte);
-		if (brel->reloptkind == RELOPT_OTHER_MEMBER_REL &&
-			(brte->rtekind != RTE_RELATION ||
-			 brte->relkind != RELKIND_PARTITIONED_TABLE))
-			continue;
-
-		if (brte->inh)
-		{
-			foreach(lc, root->append_rel_list)
-			{
-				AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(lc);
-				RelOptInfo *childrel;
-
-				if (appinfo->parent_relid != rti)
-					continue;
-				childrel = root->simple_rel_array[appinfo->child_relid];
-				Assert(childrel->reloptkind == RELOPT_OTHER_MEMBER_REL);
-				Assert(childrel->direct_lateral_relids == NULL);
-				childrel->direct_lateral_relids = brel->direct_lateral_relids;
-				Assert(childrel->lateral_relids == NULL);
-				childrel->lateral_relids = brel->lateral_relids;
-				Assert(childrel->lateral_referencers == NULL);
-				childrel->lateral_referencers = brel->lateral_referencers;
-			}
-		}
-	}
 }
 
 
diff --git a/src/backend/optimizer/plan/planmain.c b/src/backend/optimizer/plan/planmain.c
index 78557aeecb..62e11157da 100644
--- a/src/backend/optimizer/plan/planmain.c
+++ b/src/backend/optimizer/plan/planmain.c
@@ -254,6 +254,16 @@ query_planner(PlannerInfo *root, List *tlist,
 	}
 
 	/*
+	 * Expand RT entries that represent inherited or partitioned tables.
+	 * This will perform partition pruning on partitioned tables in the
+	 * original range table and also recursively on any child partitioned
+	 * tables that were added by the expansion of the original parent(s).
+	 * As new entries are added to the range table, various arrays in the
+	 * PlannerInfo will be expanded accordingly.
+	 */
+	expand_inherited_tables(root);
+
+	/*
 	 * Add child subroots needed to use during planning for individual child
 	 * targets
 	 */
diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index 703babfdf0..f80f35eed3 100644
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -25,6 +25,7 @@
 #include "access/sysattr.h"
 #include "access/xact.h"
 #include "catalog/pg_constraint.h"
+#include "catalog/pg_inherits.h"
 #include "catalog/pg_proc.h"
 #include "catalog/pg_type.h"
 #include "executor/executor.h"
@@ -704,27 +705,18 @@ subquery_planner(PlannerGlobal *glob, Query *parse,
 		}
 		if (rte->lateral)
 			root->hasLateralRTEs = true;
+
+		/*
+		 * While at it, also update the inh status.  If the relation doesn't
+		 * or can't have any children, there is no point in letting inh be set
+		 * to true.  Note that we do this before processing rowmarks, so that
+		 * the correct information for setting isParent field of PlanRowMarks.
+		 */
+		if (rte->rtekind == RTE_RELATION)
+			rte->inh = rte->inh && has_subclass(rte->relid);
 	}
 
 	/*
-	 * Preprocess RowMark information.  We need to do this after subquery
-	 * pullup (so that all non-inherited RTEs are present) and before
-	 * inheritance expansion (so that the info is available for
-	 * expand_inherited_tables to examine and modify).
-	 */
-	preprocess_rowmarks(root);
-
-	/*
-	 * Expand any rangetable entries that are inheritance sets into "append
-	 * relations".  This can add entries to the rangetable, but they must be
-	 * plain base relations not joins, so it's OK (and marginally more
-	 * efficient) to do it after checking for join RTEs.  We must do it after
-	 * pulling up subqueries, else we'd fail to handle inherited tables in
-	 * subqueries.
-	 */
-	expand_inherited_tables(root);
-
-	/*
 	 * Now that we have figured out "actual" inheritance situation of the
 	 * relations, set whether the query is an inherited UPDATE/DELETE.
 	 */
@@ -732,6 +724,12 @@ subquery_planner(PlannerGlobal *glob, Query *parse,
 					  rt_fetch(parse->resultRelation, parse->rtable)->inh);
 
 	/*
+	 * Preprocess RowMark information.  We need to do this after subquery
+	 * pullup (so that all non-inherited RTEs are present).
+	 */
+	preprocess_rowmarks(root);
+
+	/*
 	 * Set hasHavingQual to remember if HAVING clause is present.  Needed
 	 * because preprocess_expression will reduce a constant-true condition to
 	 * an empty qual list ... but "HAVING TRUE" is not a semantic no-op.
@@ -1233,7 +1231,9 @@ inheritance_planner(PlannerInfo *root)
 	 * of the parent.
 	 */
 	root->unexpanded_tlist = list_copy(root->parse->targetList);
-	tlist = preprocess_targetlist(root);
+	
+	/* We haven't expanded inheritance yet, so pass false. */
+	tlist = preprocess_targetlist(root, false);
 	root->processed_tlist = tlist;
 	qp_extra.tlist = tlist;
 	qp_extra.activeWindows = NIL;
@@ -1243,9 +1243,11 @@ inheritance_planner(PlannerInfo *root)
 	/*
 	 * If it turned out during query planning that all the children are dummy
 	 * (pruned or excluded by constraints), no need to do the steps below.
-	 * Let grouping_planner finish up the final path.
+	 * For regular inheritance case, it's possible that we only need to modify
+	 * the parent table.  Let grouping_planner finish up the final path.
 	 */
-	if (IS_DUMMY_REL(planned_rel))
+	parent_rte = planner_rt_fetch(top_parentRTindex, root);
+	if (!parent_rte->inh || IS_DUMMY_REL(planned_rel))
 	{
 		grouping_planner(root, false, planned_rel, 0.0);
 		return;
@@ -1261,7 +1263,6 @@ inheritance_planner(PlannerInfo *root)
 	 * not appear anywhere else in the plan, so the confusion explained below
 	 * for non-partitioning inheritance cases is not possible.
 	 */
-	parent_rte = planner_rt_fetch(top_parentRTindex, root);
 	if (parent_rte->relkind == RELKIND_PARTITIONED_TABLE)
 	{
 		nominalRelation = top_parentRTindex;
@@ -1590,14 +1591,19 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
 		 */
 		if (planned_rel == NULL)
 		{
-			tlist = preprocess_targetlist(root);
+			/* We haven't expanded inheritance yet, so pass false. */
+			tlist = preprocess_targetlist(root, false);
 
 			/*
-			 * We are now done hacking up the query's targetlist.  Most of the
-			 * remaining planning work will be done with the PathTarget
-			 * representation of tlists, but save aside the full representation
-			 * so that we can transfer its decoration (resnames etc) to the
-			 * topmost tlist of the finished Plan.
+			 * We are now mostly done hacking up the query's targetlist.  More
+			 * columns might be added during query_planner after inheritance
+			 * expansion in make_one_rel, because some children may require
+			 * different column than the parent for row mark handling; see
+			 * add_rowmark_junk_columns().  Most of the remaining planning
+			 * work will be done with the PathTarget representation of tlists,
+			 * but save aside the full representation so that we can transfer
+			 * its decoration (resnames etc) to the topmost tlist of the
+			 * finished Plan.
 			 */
 			root->processed_tlist = tlist;
 		}
@@ -2373,7 +2379,7 @@ preprocess_rowmarks(PlannerInfo *root)
 		newrc->allMarkTypes = (1 << newrc->markType);
 		newrc->strength = rc->strength;
 		newrc->waitPolicy = rc->waitPolicy;
-		newrc->isParent = false;
+		newrc->isParent = rte->inh;
 
 		prowmarks = lappend(prowmarks, newrc);
 	}
@@ -2398,7 +2404,7 @@ preprocess_rowmarks(PlannerInfo *root)
 		newrc->allMarkTypes = (1 << newrc->markType);
 		newrc->strength = LCS_NONE;
 		newrc->waitPolicy = LockWaitBlock;	/* doesn't matter */
-		newrc->isParent = false;
+		newrc->isParent = rte->rtekind == RTE_RELATION ? rte->inh : false;
 
 		prowmarks = lappend(prowmarks, newrc);
 	}
@@ -6835,6 +6841,10 @@ apply_scanjoin_target_to_paths(PlannerInfo *root,
 			int			nappinfos;
 			List	   *child_scanjoin_targets = NIL;
 
+			/* Skip processing pruned partitions. */
+			if (child_rel == NULL)
+				continue;
+
 			/* Translate scan/join targets for this child. */
 			appinfos = find_appinfos_by_relids(root, child_rel->relids,
 											   &nappinfos);
@@ -6936,6 +6946,10 @@ create_partitionwise_grouping_paths(PlannerInfo *root,
 		RelOptInfo *child_grouped_rel;
 		RelOptInfo *child_partially_grouped_rel;
 
+		/* Skip processing pruned partitions. */
+		if (child_input_rel == NULL)
+			continue;
+
 		/* Input child rel must have a path */
 		Assert(child_input_rel->pathlist != NIL);
 
diff --git a/src/backend/optimizer/plan/setrefs.c b/src/backend/optimizer/plan/setrefs.c
index 5d363edab8..4dcdede6b6 100644
--- a/src/backend/optimizer/plan/setrefs.c
+++ b/src/backend/optimizer/plan/setrefs.c
@@ -325,6 +325,12 @@ add_rtes_to_flat_rtable(PlannerInfo *root, bool recursing)
 													  UPPERREL_FINAL, NULL)))
 					add_rtes_to_flat_rtable(rel->subroot, true);
 			}
+			/*
+			 * A NULL rel also means an unplanned subquery rte, so apply
+			 * flatten_unplanned_rtes.
+			 */
+			else
+				flatten_unplanned_rtes(glob, rte);
 		}
 		rti++;
 	}
diff --git a/src/backend/optimizer/prep/preptlist.c b/src/backend/optimizer/prep/preptlist.c
index f8bc2dd257..a55949c305 100644
--- a/src/backend/optimizer/prep/preptlist.c
+++ b/src/backend/optimizer/prep/preptlist.c
@@ -65,9 +65,13 @@ static List *expand_targetlist(List *tlist, int command_type,
  *
  * As a side effect, if there's an ON CONFLICT UPDATE clause, its targetlist
  * is also preprocessed (and updated in-place).
+ *
+ * inheritance_expanded specifies whether inheritance tables are expanded
+ * as of calling this function.  Caller must specify it because that affects
+ * which row marking related junk columns get added to the targetlist.
  */
 List *
-preprocess_targetlist(PlannerInfo *root)
+preprocess_targetlist(PlannerInfo *root, bool inheritance_expanded)
 {
 	Query	   *parse = root->parse;
 	int			result_relation = parse->resultRelation;
@@ -134,6 +138,15 @@ preprocess_targetlist(PlannerInfo *root)
 		if (rc->rti != rc->prti)
 			continue;
 
+		/*
+		 * For inheritance parent row marks, we defer adding junk columns
+		 * until we've added child row marks, because some children might
+		 * require different row mark types which will change the parent row
+		 * mark's allMarkTypes fields.
+		 */
+		if (rc->isParent && !inheritance_expanded)
+			continue;
+
 		if (rc->allMarkTypes & ~(1 << ROW_MARK_COPY))
 		{
 			/* Need to fetch TID */
diff --git a/src/backend/optimizer/prep/prepunion.c b/src/backend/optimizer/prep/prepunion.c
index 55eeb5127c..d4d36248a1 100644
--- a/src/backend/optimizer/prep/prepunion.c
+++ b/src/backend/optimizer/prep/prepunion.c
@@ -31,13 +31,16 @@
 #include "miscadmin.h"
 #include "nodes/makefuncs.h"
 #include "nodes/nodeFuncs.h"
+#include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
 #include "optimizer/paths.h"
 #include "optimizer/planmain.h"
 #include "optimizer/planner.h"
 #include "optimizer/prep.h"
+#include "optimizer/restrictinfo.h"
 #include "optimizer/tlist.h"
+#include "optimizer/var.h"
 #include "parser/parse_coerce.h"
 #include "parser/parsetree.h"
 #include "utils/lsyscache.h"
diff --git a/src/backend/optimizer/util/appendinfo.c b/src/backend/optimizer/util/appendinfo.c
index 34a3ebbbe4..d2c3c7b590 100644
--- a/src/backend/optimizer/util/appendinfo.c
+++ b/src/backend/optimizer/util/appendinfo.c
@@ -31,10 +31,10 @@ typedef struct
 	AppendRelInfo **appinfos;
 } adjust_appendrel_attrs_context;
 
-static void make_inh_translation_list(Relation oldrelation,
-						  Relation newrelation,
-						  Index newvarno,
-						  List **translated_vars);
+static void make_inh_translation_list(TupleDesc old_tupdesc,
+						  TupleDesc new_tupdesc,
+						  Oid from_rel, Oid to_rel,
+						  Index newvarno, List **translated_vars);
 static Node *adjust_appendrel_attrs_mutator(Node *node,
 							   adjust_appendrel_attrs_context *context);
 static List *adjust_inherited_tlist(List *tlist,
@@ -46,18 +46,20 @@ static List *adjust_inherited_tlist(List *tlist,
  *	  Build an AppendRelInfo for the parent-child pair
  */
 AppendRelInfo *
-make_append_rel_info(Relation parentrel, Relation childrel,
-					 Index parentRTindex, Index childRTindex)
+make_append_rel_info(RelOptInfo *parent, RangeTblEntry *parentrte,
+					 TupleDesc childdesc, Oid childoid, Oid childtype,
+					 Index childRTindex)
 {
 	AppendRelInfo *appinfo = makeNode(AppendRelInfo);
 
-	appinfo->parent_relid = parentRTindex;
+	appinfo->parent_relid = parent->relid;
 	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->translated_vars);
-	appinfo->parent_reloid = RelationGetRelid(parentrel);
+	appinfo->parent_reltype = parent->reltype;
+	appinfo->child_reltype = childtype;
+	make_inh_translation_list(parent->tupdesc, childdesc,
+							  parentrte->relid, childoid,
+							  childRTindex, &appinfo->translated_vars);
+	appinfo->parent_reloid = parentrte->relid;
 
 	return appinfo;
 }
@@ -70,14 +72,11 @@ make_append_rel_info(Relation parentrel, Relation childrel,
  * For paranoia's sake, we match type/collation as well as attribute name.
  */
 static void
-make_inh_translation_list(Relation oldrelation, Relation newrelation,
-						  Index newvarno,
-						  List **translated_vars)
+make_inh_translation_list(TupleDesc old_tupdesc, TupleDesc new_tupdesc,
+						  Oid from_rel, Oid to_rel,
+						  Index newvarno, List **translated_vars)
 {
 	List	   *vars = NIL;
-	TupleDesc	old_tupdesc = RelationGetDescr(oldrelation);
-	TupleDesc	new_tupdesc = RelationGetDescr(newrelation);
-	Oid			new_relid = RelationGetRelid(newrelation);
 	int			oldnatts = old_tupdesc->natts;
 	int			newnatts = new_tupdesc->natts;
 	int			old_attno;
@@ -107,7 +106,7 @@ make_inh_translation_list(Relation oldrelation, Relation newrelation,
 		 * When we are generating the "translation list" for the parent table
 		 * of an inheritance set, no need to search for matches.
 		 */
-		if (oldrelation == newrelation)
+		if (from_rel == to_rel)
 		{
 			vars = lappend(vars, makeVar(newvarno,
 										 (AttrNumber) (old_attno + 1),
@@ -133,10 +132,10 @@ make_inh_translation_list(Relation oldrelation, Relation newrelation,
 		{
 			HeapTuple	newtup;
 
-			newtup = SearchSysCacheAttName(new_relid, attname);
+			newtup = SearchSysCacheAttName(to_rel, attname);
 			if (!newtup)
 				elog(ERROR, "could not find inherited attribute \"%s\" of relation \"%s\"",
-					 attname, RelationGetRelationName(newrelation));
+					 attname, get_rel_name(to_rel));
 			new_attno = ((Form_pg_attribute) GETSTRUCT(newtup))->attnum - 1;
 			ReleaseSysCache(newtup);
 
@@ -146,10 +145,10 @@ make_inh_translation_list(Relation oldrelation, Relation newrelation,
 		/* Found it, check type and collation match */
 		if (atttypid != att->atttypid || atttypmod != att->atttypmod)
 			elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's type",
-				 attname, RelationGetRelationName(newrelation));
+				 attname, get_rel_name(to_rel));
 		if (attcollation != att->attcollation)
 			elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's collation",
-				 attname, RelationGetRelationName(newrelation));
+				 attname, get_rel_name(to_rel));
 
 		vars = lappend(vars, makeVar(newvarno,
 									 (AttrNumber) (new_attno + 1),
diff --git a/src/backend/optimizer/util/inherit.c b/src/backend/optimizer/util/inherit.c
index 0d2b42f72e..f1bd954373 100644
--- a/src/backend/optimizer/util/inherit.c
+++ b/src/backend/optimizer/util/inherit.c
@@ -18,33 +18,43 @@
 #include "access/sysattr.h"
 #include "catalog/partition.h"
 #include "catalog/pg_inherits.h"
+#include "catalog/pg_type.h"
 #include "miscadmin.h"
+#include "nodes/makefuncs.h"
 #include "optimizer/appendinfo.h"
+#include "optimizer/clauses.h"
 #include "optimizer/inherit.h"
+#include "optimizer/pathnode.h"
+#include "optimizer/paths.h"
 #include "optimizer/planmain.h"
 #include "optimizer/planner.h"
 #include "optimizer/prep.h"
+#include "optimizer/restrictinfo.h"
+#include "optimizer/var.h"
+#include "partitioning/partprune.h"
 #include "utils/rel.h"
 
 
 static PlannerInfo *create_inherited_target_child_root(PlannerInfo *root,
 									AppendRelInfo *appinfo);
-static void expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte,
-						 Index rti);
+static void expand_inherited_rtentry(PlannerInfo *root, RelOptInfo *rel,
+					  RangeTblEntry *rte, Index rti);
+static void expand_nonpartitioned_inherited_rtentry(PlannerInfo *root,
+						 RangeTblEntry *rte, Index rti, RelOptInfo *rel);
 static void expand_partitioned_rtentry(PlannerInfo *root,
 						   RangeTblEntry *parentrte,
-						   Index parentRTindex, Relation parentrel,
-						   PlanRowMark *top_parentrc, LOCKMODE lockmode,
-						   List **appinfos);
-static void expand_single_inheritance_child(PlannerInfo *root,
-								RangeTblEntry *parentrte,
-								Index parentRTindex, Relation parentrel,
-								PlanRowMark *top_parentrc, Relation childrel,
-								List **appinfos, RangeTblEntry **childrte_p,
-								Index *childRTindex_p);
+						   Index parentRTindex, RelOptInfo *parentrel);
+static RelOptInfo *add_inheritance_child_rel(PlannerInfo *root,
+						  RangeTblEntry *parentrte,
+						  Index parentRTindex, RelOptInfo *parentrel,
+						  PlanRowMark *top_parentrc, Relation childrel,
+						  RangeTblEntry **childrte_p, Index *childRTindex_p);
 static Bitmapset *translate_col_privs(const Bitmapset *parent_privs,
 					List *translated_vars);
-
+static RelOptInfo *build_inheritance_child_rel(PlannerInfo *root,
+					   RelOptInfo *parent,
+					   Index childRTindex);
+static List *add_rowmark_junk_columns(PlannerInfo *root, PlanRowMark *rc);
 
 /*
  * expand_inherited_tables
@@ -52,37 +62,145 @@ static Bitmapset *translate_col_privs(const Bitmapset *parent_privs,
  *		into an "append relation".  At the conclusion of this process,
  *		the "inh" flag is set in all and only those RTEs that are append
  *		relation parents.
+ *
+ * Note that although we're calling the combined output of inheritance set
+ * relations an "append relation" here, the caller may not always want to
+ * combine the relations.  For example, if the parent of the inheritance
+ * set is the query's target relation, each child relation is processed
+ * on its own as the query's target relation.
  */
 void
 expand_inherited_tables(PlannerInfo *root)
 {
-	Index		nrtes;
+	int			orig_rtable_size;
 	Index		rti;
-	ListCell   *rl;
+
+	Assert(root->simple_rel_array_size > 0);
+	orig_rtable_size = root->simple_rel_array_size;
 
 	/*
 	 * expand_inherited_rtentry may add RTEs to parse->rtable. The function is
 	 * expected to recursively handle any RTEs that it creates with inh=true.
 	 * So just scan as far as the original end of the rtable list.
 	 */
-	nrtes = list_length(root->parse->rtable);
-	rl = list_head(root->parse->rtable);
-	for (rti = 1; rti <= nrtes; rti++)
+	for (rti = 1; rti < orig_rtable_size; rti++)
 	{
-		RangeTblEntry *rte = (RangeTblEntry *) lfirst(rl);
+		RelOptInfo *brel = root->simple_rel_array[rti];
+		RangeTblEntry *rte = root->simple_rte_array[rti];
 
-		expand_inherited_rtentry(root, rte, rti);
-		rl = lnext(rl);
+		/* there may be empty slots corresponding to non-baserel RTEs */
+		if (brel == NULL)
+			continue;
+
+		if (rte->inh)
+			expand_inherited_rtentry(root, brel, rte, rti);
 	}
 }
 
 /*
  * expand_inherited_rtentry
- *		Check whether a rangetable entry represents an inheritance set.
- *		If so, add entries for all the child tables to the query's
- *		rangetable, and build AppendRelInfo nodes for all the child tables
- *		and add them to root->append_rel_list.  If not, clear the entry's
- *		"inh" flag to prevent later code from looking for AppendRelInfos.
+ *		This initializes RelOptInfos for inheritance child relations if the
+ *		passed-in relation has any
+ *
+ * 'rel' is the parent relation, whose range table entry ('rte') has been
+ * marked to require adding children.  Parent could either be a subquery (if
+ * we flattened UNION ALL query) or a table that's known to have (or once had)
+ * inheritance children.  The latter consists of both regular inheritance
+ * parents and partitioned tables.
+ *
+ * For a subquery parent, there is not much to be done here because the
+ * children's RTEs are already present in the query, so we just initialize
+ * RelOptInfos for them.  Also, the AppendRelInfos for child subqueries
+ * have already been added.
+ *
+ * For tables, we need to add the children to the range table and initialize
+ * AppendRelInfos, RelOptInfos, and PlanRowMarks (if any) for them.  For
+ * a partitioned parent, we only add the children remaining after pruning.
+ * For regular inheritance parents, we find the children using
+ * find_all_inheritors and add all of them.
+ *
+ * If it turns out that there are no children, then we set rte->inh to false
+ * to let the caller know that only the parent table needs to be scanned.  The
+ * caller can accordingly switch to a non-Append path.  For a partitioned
+ * parent, that means an empty relation because parents themselves contain no
+ * data.
+ *
+ * For the regular inheritance case, the parent also gets another RTE with
+ * inh = false to represent it as a child to be scanned as part of the
+ * inheritance set.  The original RTE is considered to represent the whole
+ * inheritance set.
+ */
+static void
+expand_inherited_rtentry(PlannerInfo *root, RelOptInfo *rel,
+						 RangeTblEntry *rte, Index rti)
+{
+	Assert(rte->inh);
+	/* Inheritance parent (partitioned or not) or UNION ALL parent subquery. */
+	Assert(rte->rtekind == RTE_RELATION || rte->rtekind == RTE_SUBQUERY);
+
+	/*
+	 * UNION ALL children already got RTEs and AppendRelInfos, so just build
+	 * RelOptInfos and return.
+	 *
+	 * It might be a bit odd that this code is in this, because there is
+	 * nothing to expand really.
+	 */
+	if (rte->rtekind == RTE_SUBQUERY)
+	{
+		ListCell   *l;
+
+		/*
+		 * We don't need to use expand_planner_arrays in this case, because
+		 * no new child RTEs are created.  setup_simple_rel_arrays() and
+		 * setup_append_rel_array would've considered these child RTEs when
+		 * allocating space for various arrays.
+		 */
+		foreach(l, root->append_rel_list)
+		{
+			AppendRelInfo *appinfo = lfirst(l);
+			Index		childRTindex = appinfo->child_relid;
+
+			if (appinfo->parent_relid != rti)
+				continue;
+
+			Assert(childRTindex < root->simple_rel_array_size);
+			Assert(root->simple_rte_array[childRTindex] != NULL);
+
+			/*
+			 * We set the correct value of baserestricinfo and
+			 * baserestrict_min_security below.
+			 */
+			root->simple_rel_array[childRTindex] =
+				build_inheritance_child_rel(root, rel, appinfo->child_relid);
+		}
+	}
+	else
+	{
+		Assert(rte->rtekind == RTE_RELATION);
+		Assert(has_subclass(rte->relid));
+
+		/*
+		 * The rewriter should already have obtained an appropriate lock on
+		 * each relation named in the query.  However, for each child relation
+		 * we add to the query, we must obtain an appropriate lock, because
+		 * this will be the first use of those relations in the
+		 * parse/rewrite/plan pipeline.  Child rels should use the same
+		 * lockmode as their parent.
+		 */
+		Assert(rte->rellockmode != NoLock);
+
+		if (rte->relkind == RELKIND_PARTITIONED_TABLE)
+			expand_partitioned_rtentry(root, rte, rti, rel);
+		else
+			expand_nonpartitioned_inherited_rtentry(root, rte, rti, rel);
+	}
+}
+
+/*
+ * expand_nonpartitioned_inherited_rtentry
+ *		Add entries for all the child tables to the query's rangetable, and
+ *		build AppendRelInfo nodes for all the child tables and add them to
+ *		root->append_rel_list.
  *
  * Note that the original RTE is considered to represent the whole
  * inheritance set.  The first of the generated RTEs is an RTE for the same
@@ -93,55 +211,35 @@ expand_inherited_tables(PlannerInfo *root)
  * regular inheritance, a parent RTE must always have at least two associated
  * AppendRelInfos: one corresponding to the parent table as a simple member of
  * inheritance set and one or more corresponding to the actual children.
- * Since a partitioned table is not scanned, it might have only one associated
- * AppendRelInfo.
  */
 static void
-expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti)
+expand_nonpartitioned_inherited_rtentry(PlannerInfo *root,
+										RangeTblEntry *rte,
+										Index rti,
+										RelOptInfo *rel)
 {
 	Oid			parentOID;
 	PlanRowMark *oldrc;
-	Relation	oldrelation;
-	LOCKMODE	lockmode;
+	LOCKMODE	lockmode = rte->rellockmode;
 	List	   *inhOIDs;
 	ListCell   *l;
+	int			num_children;
+	int			num_children_added = 0;
 
-	/* Does RT entry allow inheritance? */
-	if (!rte->inh)
-		return;
-	/* Ignore any already-expanded UNION ALL nodes */
-	if (rte->rtekind != RTE_RELATION)
-	{
-		Assert(rte->rtekind == RTE_SUBQUERY);
-		return;
-	}
-	/* Fast path for common case of childless table */
+	Assert(rte->rtekind == RTE_RELATION);
+	Assert(lockmode != NoLock);
 	parentOID = rte->relid;
-	if (!has_subclass(parentOID))
-	{
-		/* Clear flag before returning */
-		rte->inh = false;
-		return;
-	}
-
-	/*
-	 * The rewriter should already have obtained an appropriate lock on each
-	 * relation named in the query.  However, for each child relation we add
-	 * to the query, we must obtain an appropriate lock, because this will be
-	 * the first use of those relations in the parse/rewrite/plan pipeline.
-	 * Child rels should use the same lockmode as their parent.
-	 */
-	lockmode = rte->rellockmode;
 
 	/* Scan for all members of inheritance set, acquire needed locks */
 	inhOIDs = find_all_inheritors(parentOID, lockmode, NULL);
 
 	/*
 	 * Check that there's at least one descendant, else treat as no-child
-	 * case.  This could happen despite above has_subclass() check, if table
-	 * once had a child but no longer does.
+	 * case.  This could happen despite has_subclass() check performed by
+	 * subquery_planner, if table once had a child but no longer does.
 	 */
-	if (list_length(inhOIDs) < 2)
+	num_children = list_length(inhOIDs);
+	if (num_children < 2)
 	{
 		/* Clear flag before returning */
 		rte->inh = false;
@@ -149,216 +247,221 @@ expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti)
 	}
 
 	/*
-	 * If parent relation is selected FOR UPDATE/SHARE, we need to mark its
-	 * PlanRowMark as isParent = true, and generate a new PlanRowMark for each
-	 * child.
+	 * If parent relation is selected FOR UPDATE/SHARE, preprocess_rowmarks
+	 * should've set isParent = true.  We'll generate a new PlanRowMark for
+	 * each child.
 	 */
 	oldrc = get_plan_rowmark(root->rowMarks, rti);
-	if (oldrc)
-		oldrc->isParent = true;
+	Assert(oldrc == NULL || oldrc->isParent);
 
 	/*
-	 * Must open the parent relation to examine its tupdesc.  We need not lock
-	 * it; we assume the rewriter already did.
+	 * Must expand PlannerInfo arrays by num_children before we can add
+	 * children.
 	 */
-	oldrelation = heap_open(parentOID, NoLock);
+	Assert(num_children > 0);
+	expand_planner_arrays(root, num_children);
 
-	/* Scan the inheritance set and expand it */
-	if (RelationGetPartitionDesc(oldrelation) != NULL)
+	foreach(l, inhOIDs)
 	{
-		Assert(rte->relkind == RELKIND_PARTITIONED_TABLE);
-
-		/*
-		 * If this table has partitions, recursively expand them in the order
-		 * in which they appear in the PartitionDesc.  While at it, also
-		 * extract the partition key columns of all the partitioned tables.
-		 */
-		expand_partitioned_rtentry(root, rte, rti, oldrelation, oldrc,
-								   lockmode, &root->append_rel_list);
-	}
-	else
-	{
-		List	   *appinfos = NIL;
+		Oid			childOID = lfirst_oid(l);
+		Relation	newrelation;
 		RangeTblEntry *childrte;
 		Index		childRTindex;
 
+		/* Already locked above. */
+		newrelation = heap_open(childOID, NoLock);
+
 		/*
-		 * This table has no partitions.  Expand any plain inheritance
-		 * children in the order the OIDs were returned by
-		 * find_all_inheritors.
+		 * It is possible that the parent table has children that are temp
+		 * tables of other backends.  We cannot safely access such tables
+		 * (because of buffering issues), and the best thing to do seems
+		 * to be to silently ignore them.
 		 */
-		foreach(l, inhOIDs)
+		if (childOID != parentOID && RELATION_IS_OTHER_TEMP(newrelation))
 		{
-			Oid			childOID = lfirst_oid(l);
-			Relation	newrelation;
-
-			/* Open rel if needed; we already have required locks */
-			if (childOID != parentOID)
-				newrelation = heap_open(childOID, NoLock);
-			else
-				newrelation = oldrelation;
-
-			/*
-			 * It is possible that the parent table has children that are temp
-			 * tables of other backends.  We cannot safely access such tables
-			 * (because of buffering issues), and the best thing to do seems
-			 * to be to silently ignore them.
-			 */
-			if (childOID != parentOID && RELATION_IS_OTHER_TEMP(newrelation))
-			{
-				heap_close(newrelation, lockmode);
-				continue;
-			}
-
-			expand_single_inheritance_child(root, rte, rti, oldrelation, oldrc,
-											newrelation,
-											&appinfos, &childrte,
-											&childRTindex);
-
-			/* Close child relations, but keep locks */
-			if (childOID != parentOID)
-				heap_close(newrelation, NoLock);
+			heap_close(newrelation, lockmode);
+			continue;
 		}
 
-		/*
-		 * If all the children were temp tables, pretend it's a
-		 * non-inheritance situation; we don't need Append node in that case.
-		 * The duplicate RTE we added for the parent table is harmless, so we
-		 * don't bother to get rid of it; ditto for the useless PlanRowMark
-		 * node.
-		 */
-		if (list_length(appinfos) < 2)
-			rte->inh = false;
-		else
-			root->append_rel_list = list_concat(root->append_rel_list,
-												appinfos);
+		(void) add_inheritance_child_rel(root, rte, rti, rel, oldrc,
+										 newrelation, &childrte,
+										 &childRTindex);
+		Assert(childrte != NULL);
+		/* All regular inheritance children are leaf children. */
+		Assert(!childrte->inh);
+		Assert(childRTindex > 0);
 
+		/* Close child relations, but keep locks */
+		heap_close(newrelation, NoLock);
+		num_children_added++;
 	}
 
-	heap_close(oldrelation, NoLock);
+	/*
+	 * If all children, including the parent (as child rel), were
+	 * excluded, mark the parent rel as empty.  If all the children were temp
+	 * tables, pretend it's a non-inheritance situation; we don't need Append
+	 * node in that case.  The duplicate RTE we added for the parent table is
+	 * harmless, so we don't bother to get rid of it; ditto for the useless
+	 * PlanRowMark node.
+	 */
+	if (num_children_added == 0)
+		mark_dummy_rel(rel);
+	else if (num_children_added == 1)
+		rte->inh = false;
+
+	/*
+	 * Add junk columns needed by the row mark if any and also add the
+	 * relevant expressions to the root parent's reltarget.
+	 */
+	if (oldrc)
+	{
+		List   *tlist = add_rowmark_junk_columns(root, oldrc);
+
+		build_base_rel_tlists(root, tlist);
+	}
 }
 
 /*
  * expand_partitioned_rtentry
- *		Recursively expand an RTE for a partitioned table.
+ *		Prunes unnecessary partitions of a partitioned table and adds
+ *		remaining ones to the Query and the PlannerInfo
+ *
+ * Partitions are added to the query in order in which they are found in
+ * the parent's PartitionDesc.
+ *
+ * Note: even though only the unpruned partitions will be added to the
+ * resulting plan, this still locks *all* partitions via find_all_inheritors
+ * when this function is called for the root partitioned table.
  */
 static void
 expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
-						   Index parentRTindex, Relation parentrel,
-						   PlanRowMark *top_parentrc, LOCKMODE lockmode,
-						   List **appinfos)
+						   Index parentRTindex, RelOptInfo *parentrel)
 {
+	LOCKMODE	lockmode = parentrte->rellockmode;
+	PlanRowMark *rootrc = NULL;
 	int			i;
-	RangeTblEntry *childrte;
-	Index		childRTindex;
-	PartitionDesc partdesc = RelationGetPartitionDesc(parentrel);
+	Bitmapset  *partindexes;
+	Index		rootParentRTindex = parentrel->inh_root_parent > 0 ?
+									parentrel->inh_root_parent :
+									parentRTindex;
 
-	check_stack_depth();
-
-	/* A partitioned table should always have a partition descriptor. */
-	Assert(partdesc);
-
-	Assert(parentrte->inh);
+	/* If root partitioned table, lock *all* partitions in the tree. */
+	if (parentRTindex == rootParentRTindex)
+		(void) find_all_inheritors(parentrte->relid, lockmode, NULL);
 
 	/*
-	 * Note down whether any partition key cols are being updated. Though it's
-	 * the root partitioned table's updatedCols we are interested in, we
-	 * instead use parentrte to get the updatedCols. This is convenient
-	 * because parentrte already has the root partrel's updatedCols translated
-	 * to match the attribute ordering of parentrel.
+	 * Initialize partitioned_child_rels to contain this RT index.
+	 *
+	 * Note that during the set_append_rel_pathlist() phase, values of the
+	 * indexes of partitioned relations that appear down in the tree will be
+	 * bubbled up into root parent's list so that when we've created Paths for
+	 * all the children, the root table's list will contain all such indexes.
 	 */
-	if (!root->partColsUpdated)
-		root->partColsUpdated =
-			has_partition_attrs(parentrel, parentrte->updatedCols, NULL);
+	parentrel->partitioned_child_rels = list_make1_int(parentRTindex);
 
-	/* First expand the partitioned table itself. */
-	expand_single_inheritance_child(root, parentrte, parentRTindex, parentrel,
-									top_parentrc, parentrel,
-									appinfos, &childrte, &childRTindex);
+	/* Perform pruning. */
+	partindexes = prune_append_rel_partitions(parentrel);
+
+	/* Must expand PlannerInfo arrays before we can add children. */
+	if (bms_num_members(partindexes) > 0)
+		expand_planner_arrays(root, bms_num_members(partindexes));
 
 	/*
-	 * If the partitioned table has no partitions, treat this as the
-	 * non-inheritance case.
+	 * For partitioned tables, we also store the partition RelOptInfo
+	 * pointers in the parent's RelOptInfo.
 	 */
-	if (partdesc->nparts == 0)
-	{
-		parentrte->inh = false;
-		return;
-	}
+	parentrel->part_rels = (RelOptInfo **) palloc0(sizeof(RelOptInfo *) *
+												   parentrel->nparts);
 
-	for (i = 0; i < partdesc->nparts; i++)
+	rootrc = get_plan_rowmark(root->rowMarks, rootParentRTindex);
+	Assert(rootrc == NULL || rootrc->isParent);
+	i = -1;
+	while ((i = bms_next_member(partindexes, i)) >= 0)
 	{
-		Oid			childOID = partdesc->oids[i];
-		Relation	childrel;
+		Oid		childOID = parentrel->part_oids[i];
+		Relation	newrelation;
+		RelOptInfo *childrel;
+		RangeTblEntry *childrte;
+		Index		childRTindex;
 
-		/* Open rel; we already have required locks */
-		childrel = heap_open(childOID, NoLock);
+		/* Already locked above. */
+		newrelation = heap_open(childOID, NoLock);
+		Assert(!RELATION_IS_OTHER_TEMP(newrelation));
 
 		/*
-		 * Temporary partitions belonging to other sessions should have been
-		 * disallowed at definition, but for paranoia's sake, let's double
-		 * check.
+		 * A partitioned child table with 0 children is a dummy rel, so don't
+		 * bother creating planner objects for it.
 		 */
-		if (RELATION_IS_OTHER_TEMP(childrel))
-			elog(ERROR, "temporary relation from another session found as partition");
+		if (newrelation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE &&
+			RelationGetPartitionDesc(newrelation)->nparts == 0)
+		{
+			heap_close(newrelation, NoLock);
+			continue;
+		}
 
-		expand_single_inheritance_child(root, parentrte, parentRTindex,
-										parentrel, top_parentrc, childrel,
-										appinfos, &childrte, &childRTindex);
+		childrel = add_inheritance_child_rel(root, parentrte, parentRTindex,
+											 parentrel, rootrc, newrelation,
+											 &childrte, &childRTindex);
+		Assert(childrel != NULL);
+		parentrel->part_rels[i] = childrel;
 
-		/* If this child is itself partitioned, recurse */
-		if (childrel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
+		/* Close child relations, but keep locks */
+		heap_close(newrelation, NoLock);
+
+		/* If the child is partitioned itself, expand it too. */
+		if (childrel->part_scheme)
+		{
+			Assert(childrte->inh);
 			expand_partitioned_rtentry(root, childrte, childRTindex,
-									   childrel, top_parentrc, lockmode,
-									   appinfos);
+									   childrel);
+		}
+	}
 
-		/* Close child relation, but keep locks */
-		heap_close(childrel, NoLock);
+	/*
+	 * Add junk columns needed by the row mark if any and also add the
+	 * relevant expressions to the root parent's reltarget.
+	 */
+	if (rootrc)
+	{
+		List   *tlist = add_rowmark_junk_columns(root, rootrc);
+
+		build_base_rel_tlists(root, tlist);
 	}
 }
 
 /*
- * expand_single_inheritance_child
- *		Build a RangeTblEntry and an AppendRelInfo, if appropriate, plus
- *		maybe a PlanRowMark.
+ * add_inheritance_child_rel
+ *		Build a RangeTblEntry, an AppendRelInfo, a PlanRowMark, and finally
+ *		a RelOptInfo for an inheritance child relation.
  *
- * We now expand the partition hierarchy level by level, creating a
- * corresponding hierarchy of AppendRelInfos and RelOptInfos, where each
- * partitioned descendant acts as a parent of its immediate partitions.
- * (This is a difference from what older versions of PostgreSQL did and what
- * is still done in the case of table inheritance for unpartitioned tables,
- * where the hierarchy is flattened during RTE expansion.)
+ * The return value is the RelOptInfo that's added.
  *
  * PlanRowMarks still carry the top-parent's RTI, and the top-parent's
  * allMarkTypes field still accumulates values from all descendents.
  *
  * "parentrte" and "parentRTindex" are immediate parent's RTE and
  * RTI. "top_parentrc" is top parent's PlanRowMark.
- *
- * The child RangeTblEntry and its RTI are returned in "childrte_p" and
- * "childRTindex_p" resp.
  */
-static void
-expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte,
-								Index parentRTindex, Relation parentrel,
-								PlanRowMark *top_parentrc, Relation childrel,
-								List **appinfos, RangeTblEntry **childrte_p,
-								Index *childRTindex_p)
+static RelOptInfo *
+add_inheritance_child_rel(PlannerInfo *root, RangeTblEntry *parentrte,
+						  Index parentRTindex, RelOptInfo *parentrel,
+						  PlanRowMark *top_parentrc, Relation childrel,
+						  RangeTblEntry **childrte_p, Index *childRTindex_p)
 {
 	Query	   *parse = root->parse;
-	Oid			parentOID = RelationGetRelid(parentrel);
 	Oid			childOID = RelationGetRelid(childrel);
 	RangeTblEntry *childrte;
 	Index		childRTindex;
 	AppendRelInfo *appinfo;
+	RelOptInfo *childrelopt;
 
 	/*
 	 * Build an RTE for the child, and attach to query's rangetable list. We
 	 * copy most fields of the parent's RTE, but replace relation OID and
-	 * relkind, and set inh = false.  Also, set requiredPerms to zero since
-	 * all required permissions checks are done on the original RTE. Likewise,
-	 * set the child's securityQuals to empty, because we only want to apply
-	 * the parent's RLS conditions regardless of what RLS properties
+	 * relkind, and set inh appropriately.  Also, set requiredPerms to zero
+	 * since all required permissions checks are done on the original RTE.
+	 * Likewise, set the child's securityQuals to empty, because we only want
+	 * to apply the parent's RLS conditions regardless of what RLS properties
 	 * individual children may have.  (This is an intentional choice to make
 	 * inherited RLS work like regular permissions checks.) The parent
 	 * securityQuals will be propagated to children along with other base
@@ -368,49 +471,42 @@ expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte,
 	*childrte_p = childrte;
 	childrte->relid = childOID;
 	childrte->relkind = childrel->rd_rel->relkind;
-	/* A partitioned child will need to be expanded further. */
-	if (childOID != parentOID &&
-		childrte->relkind == RELKIND_PARTITIONED_TABLE)
-		childrte->inh = true;
-	else
-		childrte->inh = false;
+	/*
+	 * A partitioned child will need to be expanded as an append parent
+	 * itself, so set its inh to true.
+	 */
+	childrte->inh = (childrte->relkind == RELKIND_PARTITIONED_TABLE);
 	childrte->requiredPerms = 0;
 	childrte->securityQuals = NIL;
 	parse->rtable = lappend(parse->rtable, childrte);
 	childRTindex = list_length(parse->rtable);
 	*childRTindex_p = childRTindex;
 
-	/*
-	 * We need an AppendRelInfo if paths will be built for the child RTE. If
-	 * childrte->inh is true, then we'll always need to generate append paths
-	 * for it.  If childrte->inh is false, we must scan it if it's not a
-	 * partitioned table; but if it is a partitioned table, then it never has
-	 * any data of its own and need not be scanned.
-	 */
-	if (childrte->relkind != RELKIND_PARTITIONED_TABLE || childrte->inh)
-	{
-		appinfo = make_append_rel_info(parentrel, childrel,
-									   parentRTindex, childRTindex);
-		*appinfos = lappend(*appinfos, appinfo);
+	/* Create an AppendRelInfo and add it to planner's global list. */
+	appinfo = make_append_rel_info(parentrel, parentrte,
+								   RelationGetDescr(childrel),
+								   RelationGetRelid(childrel),
+								   RelationGetForm(childrel)->reltype,
+								   childRTindex);
+	root->append_rel_list = lappend(root->append_rel_list, appinfo);
 
-		/*
-		 * Translate the column permissions bitmaps to the child's attnums (we
-		 * have to build the translated_vars list before we can do this). But
-		 * if this is the parent table, leave copyObject's result alone.
-		 *
-		 * Note: we need to do this even though the executor won't run any
-		 * permissions checks on the child RTE.  The insertedCols/updatedCols
-		 * bitmaps may be examined for trigger-firing purposes.
-		 */
-		if (childOID != parentOID)
-		{
-			childrte->selectedCols = translate_col_privs(parentrte->selectedCols,
-														 appinfo->translated_vars);
-			childrte->insertedCols = translate_col_privs(parentrte->insertedCols,
-														 appinfo->translated_vars);
-			childrte->updatedCols = translate_col_privs(parentrte->updatedCols,
-														appinfo->translated_vars);
-		}
+	/*
+	 * Translate the column permissions bitmaps to the child's attnums (we
+	 * have to build the translated_vars list before we can do this). But
+	 * if this is the parent table, leave copyObject's result alone.
+	 *
+	 * Note: we need to do this even though the executor won't run any
+	 * permissions checks on the child RTE.  The insertedCols/updatedCols
+	 * bitmaps may be examined for trigger-firing purposes.
+	 */
+	if (childrte->relid != parentrte->relid)
+	{
+		childrte->selectedCols = translate_col_privs(parentrte->selectedCols,
+													 appinfo->translated_vars);
+		childrte->insertedCols = translate_col_privs(parentrte->insertedCols,
+													 appinfo->translated_vars);
+		childrte->updatedCols = translate_col_privs(parentrte->updatedCols,
+													appinfo->translated_vars);
 	}
 
 	/*
@@ -442,6 +538,253 @@ expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte,
 
 		root->rowMarks = lappend(root->rowMarks, childrc);
 	}
+
+	/*
+	 * Add the RelOptInfo.  Even though we may not really scan this relation
+	 * for reasons such as contradictory quals, we still need to create one,
+	 * because for every RTE in the query's range table, there must be an
+	 * accompanying RelOptInfo.
+	 */
+
+	/* First, store the RTE and appinfos into planner arrays. */
+	Assert(root->simple_rte_array[childRTindex] == NULL);
+	root->simple_rte_array[childRTindex] = childrte;
+	Assert(root->append_rel_array[childRTindex] == NULL);
+	root->append_rel_array[childRTindex] = appinfo;
+
+	childrelopt = build_inheritance_child_rel(root, parentrel, childRTindex);
+	Assert(childrelopt != NULL);
+
+	return childrelopt;
+}
+
+/*
+ *	build_inheritance_child_rel
+ *		Build a RelOptInfo for child relation of an inheritance set
+ *
+ * After creating the RelOptInfo for the given child RT index, it goes on to
+ * initialize some of its fields based on the parent RelOptInfo.
+ *
+ * If the quals in baserestrictinfo turn out to be self-contradictory,
+ * RelOptInfo is marked dummy before returning.
+ */
+static RelOptInfo *
+build_inheritance_child_rel(PlannerInfo *root,
+					   RelOptInfo *parent,
+					   Index childRTindex)
+{
+	RelOptInfo *childrel;
+	RangeTblEntry *childRTE = root->simple_rte_array[childRTindex];
+	AppendRelInfo *appinfo = root->append_rel_array[childRTindex];
+	List	   *childquals;
+	ListCell   *lc;
+	bool		have_const_false_cq;
+	Index		cq_min_security;
+
+	/* Build the RelOptInfo. */
+	childrel = build_simple_rel(root, childRTindex, parent);
+
+	/*
+	 * Propagate lateral_relids and lateral_referencers from appendrel
+	 * parent rels to their child rels.  We intentionally give each child rel
+	 * the same minimum parameterization, even though it's quite possible that
+	 * some don't reference all the lateral rels.  This is because any append
+	 * path for the parent will have to have the same parameterization for
+	 * every child anyway, and there's no value in forcing extra
+	 * reparameterize_path() calls.  Similarly, a lateral reference to the
+	 * parent prevents use of otherwise-movable join rels for each child.
+	 */
+	childrel->direct_lateral_relids = parent->direct_lateral_relids;
+	childrel->lateral_relids = parent->lateral_relids;
+	childrel->lateral_referencers = parent->lateral_referencers;
+
+	/*
+	 * We have to copy the parent's quals to the child, with appropriate
+	 * substitution of variables.  However, only the baserestrictinfo
+	 * quals are needed before we can check for constraint exclusion; so
+	 * do that first and then check to see if we can disregard this child.
+	 *
+	 * The child rel's targetlist might contain non-Var expressions, which
+	 * means that substitution into the quals could produce opportunities
+	 * for const-simplification, and perhaps even pseudoconstant quals.
+	 * Therefore, transform each RestrictInfo separately to see if it
+	 * reduces to a constant or pseudoconstant.  (We must process them
+	 * separately to keep track of the security level of each qual.)
+	 */
+	childquals = false;
+	cq_min_security = UINT_MAX;
+	have_const_false_cq = false;
+	foreach(lc, parent->baserestrictinfo)
+	{
+		RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
+		Node	   *childqual = (Node *) rinfo->clause;
+		ListCell   *lc2;
+
+		Assert(IsA(rinfo, RestrictInfo));
+		childqual = adjust_appendrel_attrs(root, childqual,
+										   1, &appinfo);
+		childqual = eval_const_expressions(root, childqual);
+		/* check for flat-out constant */
+		if (childqual && IsA(childqual, Const))
+		{
+			if (((Const *) childqual)->constisnull ||
+				!DatumGetBool(((Const *) childqual)->constvalue))
+			{
+				/* Restriction reduces to constant FALSE or NULL */
+				have_const_false_cq = true;
+				break;
+			}
+			/* Restriction reduces to constant TRUE, so drop it */
+			continue;
+		}
+		/* might have gotten an AND clause, if so flatten it */
+		foreach(lc2, make_ands_implicit((Expr *) childqual))
+		{
+			Node	   *onecq = (Node *) lfirst(lc2);
+			bool		pseudoconstant;
+
+			/* check for pseudoconstant (no Vars or volatile functions) */
+			pseudoconstant =
+					!contain_vars_of_level(onecq, 0) &&
+					!contain_volatile_functions(onecq);
+			if (pseudoconstant)
+			{
+				/* tell createplan.c to check for gating quals */
+				root->hasPseudoConstantQuals = true;
+			}
+			/* reconstitute RestrictInfo with appropriate properties */
+			childquals = lappend(childquals,
+								 make_restrictinfo((Expr *) onecq,
+												   rinfo->is_pushed_down,
+												   rinfo->outerjoin_delayed,
+												   pseudoconstant,
+												   rinfo->security_level,
+												   NULL, NULL, NULL));
+			cq_min_security = Min(cq_min_security, rinfo->security_level);
+		}
+	}
+
+	/*
+	 * In addition to the quals inherited from the parent, we might
+	 * have securityQuals associated with this particular child node.
+	 * (Currently this can only happen in appendrels originating from
+	 * UNION ALL; inheritance child tables don't have their own
+	 * securityQuals.)	Pull any such securityQuals up into the
+	 * baserestrictinfo for the child.  This is similar to
+	 * process_security_barrier_quals() for the parent rel, except
+	 * that we can't make any general deductions from such quals,
+	 * since they don't hold for the whole appendrel.
+	 */
+	if (childRTE->securityQuals)
+	{
+		Index		security_level = 0;
+
+		foreach(lc, childRTE->securityQuals)
+		{
+			List	   *qualset = (List *) lfirst(lc);
+			ListCell   *lc2;
+
+			foreach(lc2, qualset)
+			{
+				Expr	   *qual = (Expr *) lfirst(lc2);
+
+				/*
+				 * not likely that we'd see constants here, so no
+				 * check
+				 */
+				childquals = lappend(childquals,
+									 make_restrictinfo(qual,
+													   true,
+													   false,
+													   false,
+													   security_level,
+													   NULL, NULL,
+													   NULL));
+				cq_min_security = Min(cq_min_security, security_level);
+			}
+			security_level++;
+		}
+		Assert(security_level <= root->qual_security_level);
+	}
+
+	/* Set child's version of baserestrictinfo. */
+	childrel->baserestrictinfo = childquals;
+	childrel->baserestrict_min_security = cq_min_security;
+
+	if (have_const_false_cq)
+	{
+		/*
+		 * Some restriction clause reduced to constant FALSE or NULL after
+		 * substitution, so this child need not be scanned.
+		 */
+		set_dummy_rel_pathlist(childrel);
+	}
+
+	return childrel;
+}
+
+/*
+ * add_rowmark_junk_columns
+ * 		Add necessary junk columns for rowmarked inheritance parent rel.
+ *
+ * These values are needed for locking of rels selected FOR UPDATE/SHARE, and
+ * to do EvalPlanQual rechecking.  See comments for PlanRowMark in
+ * plannodes.h.
+ */
+static List *
+add_rowmark_junk_columns(PlannerInfo *root, PlanRowMark *rc)
+{
+	List   *tlist = root->processed_tlist;
+	Var		   *var;
+	char		resname[32];
+	TargetEntry *tle;
+
+	if (rc->allMarkTypes & ~(1 << ROW_MARK_COPY))
+	{
+		/* Need to fetch TID */
+		var = makeVar(rc->rti,
+					  SelfItemPointerAttributeNumber,
+					  TIDOID,
+					  -1,
+					  InvalidOid,
+					  0);
+		snprintf(resname, sizeof(resname), "ctid%u", rc->rowmarkId);
+		tle = makeTargetEntry((Expr *) var,
+							  list_length(tlist) + 1,
+							  pstrdup(resname),
+							  true);
+		tlist = lappend(tlist, tle);
+	}
+	if (rc->allMarkTypes & (1 << ROW_MARK_COPY))
+	{
+		/* Need the whole row as a junk var */
+		var = makeWholeRowVar(root->simple_rte_array[rc->rti],
+							  rc->rti,
+							  0,
+							  false);
+		snprintf(resname, sizeof(resname), "wholerow%u", rc->rowmarkId);
+		tle = makeTargetEntry((Expr *) var,
+							  list_length(tlist) + 1,
+							  pstrdup(resname),
+							  true);
+		tlist = lappend(tlist, tle);
+	}
+
+	/* For inheritance cases, always fetch the tableoid too. */
+	var = makeVar(rc->rti,
+				  TableOidAttributeNumber,
+				  OIDOID,
+				  -1,
+				  InvalidOid,
+				  0);
+	snprintf(resname, sizeof(resname), "tableoid%u", rc->rowmarkId);
+	tle = makeTargetEntry((Expr *) var,
+						  list_length(tlist) + 1,
+						  pstrdup(resname),
+						  true);
+	tlist = lappend(tlist, tle);
+
+	return tlist;
 }
 
 /*
@@ -583,7 +926,7 @@ create_inherited_target_child_root(PlannerInfo *root, AppendRelInfo *appinfo)
 	 * column, filling placeholder entries for dropped columns, etc., all of
 	 * which occurs with the child's TupleDesc.
 	 */
-	tlist = preprocess_targetlist(subroot);
+	tlist = preprocess_targetlist(subroot, true);
 	subroot->processed_tlist = tlist;
 
 	/* Add any newly added Vars to the child RelOptInfo. */
diff --git a/src/backend/optimizer/util/plancat.c b/src/backend/optimizer/util/plancat.c
index 6009de309e..293f9ac619 100644
--- a/src/backend/optimizer/util/plancat.c
+++ b/src/backend/optimizer/util/plancat.c
@@ -105,20 +105,20 @@ static void set_baserel_partition_key_exprs(Relation relation,
  * important for it.
  */
 void
-get_relation_info(PlannerInfo *root, Oid relationObjectId, bool inhparent,
-				  RelOptInfo *rel)
+get_relation_info(PlannerInfo *root, RangeTblEntry *rte, RelOptInfo *rel)
 {
 	Index		varno = rel->relid;
 	Relation	relation;
 	bool		hasindex;
 	List	   *indexinfos = NIL;
+	bool		inhparent = rte->inh;
 
 	/*
 	 * We need not lock the relation since it was already locked, either by
 	 * the rewriter or when expand_inherited_rtentry() added it to the query's
 	 * rangetable.
 	 */
-	relation = heap_open(relationObjectId, NoLock);
+	relation = heap_open(rte->relid, NoLock);
 
 	/* Temporary and unlogged relations are inaccessible during recovery. */
 	if (!RelationNeedsWAL(relation) && RecoveryInProgress())
@@ -444,11 +444,32 @@ get_relation_info(PlannerInfo *root, Oid relationObjectId, bool inhparent,
 	get_relation_foreign_keys(root, rel, relation, inhparent);
 
 	/*
-	 * Collect info about relation's partitioning scheme, if any. Only
-	 * inheritance parents may be partitioned.
+	 * Collect some additional information for inheritance parents.
 	 */
-	if (inhparent && relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
-		set_relation_partition_info(root, rel, relation);
+	if (inhparent)
+	{
+		/*
+		 * We'll need the TupleDesc when initializing the child relation.
+		 * A copy is being made because concurrent changes might drop
+		 * the relcache entry.  That's possible because ALTER TABLE
+		 * child_table NO INHERIT parent_table only requires an
+		 * AccessShareLock on parent_table.
+		 */
+		rel->tupdesc = CreateTupleDescCopy(RelationGetDescr(relation));
+		rel->reltype = RelationGetForm(relation)->reltype;
+
+		/*
+		 * If partitioned, also save the information of partitioning scheme,
+		 * and whether the query updates any of the partition key columns.
+		 */
+		if (relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
+		{
+			set_relation_partition_info(root, rel, relation);
+			root->partColsUpdated |= has_partition_attrs(relation,
+														 rte->updatedCols,
+														 NULL);
+		}
+	}
 
 	heap_close(relation, NoLock);
 
@@ -458,7 +479,7 @@ get_relation_info(PlannerInfo *root, Oid relationObjectId, bool inhparent,
 	 * removing an index, or adding a hypothetical index to the indexlist.
 	 */
 	if (get_relation_info_hook)
-		(*get_relation_info_hook) (root, relationObjectId, inhparent, rel);
+		(*get_relation_info_hook) (root, rte->relid, rte->inh, rel);
 }
 
 /*
@@ -1844,16 +1865,20 @@ set_relation_partition_info(PlannerInfo *root, RelOptInfo *rel,
 							Relation relation)
 {
 	PartitionDesc partdesc;
-	PartitionKey partkey;
 
 	Assert(relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE);
 
 	partdesc = RelationGetPartitionDesc(relation);
-	partkey = RelationGetPartitionKey(relation);
 	rel->part_scheme = find_partition_scheme(root, relation);
 	Assert(partdesc != NULL && rel->part_scheme != NULL);
-	rel->boundinfo = partition_bounds_copy(partdesc->boundinfo, partkey);
 	rel->nparts = partdesc->nparts;
+
+	/*
+	 * Since we must've taken a lock on the table, it's okay to simply copy
+	 * the pointers to relcache data here.
+	 */
+	rel->part_oids = partdesc->oids;
+	rel->boundinfo = partdesc->boundinfo;
 	set_baserel_partition_key_exprs(relation, rel);
 	rel->partition_qual = RelationGetPartitionQual(relation);
 }
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index fe83ec4519..d12d047002 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -132,6 +132,50 @@ setup_append_rel_array(PlannerInfo *root)
 }
 
 /*
+ * expand_planner_arrays
+ *		Expand the PlannerInfo arrays by add_size members and initialize the
+ *		the	newly added bytes with zero
+ */
+void
+expand_planner_arrays(PlannerInfo *root, int add_size)
+{
+	int		new_size;
+
+	Assert(add_size > 0);
+
+	new_size = root->simple_rel_array_size + add_size;
+
+	/* Expand various arrays and 0-initialize added bytes. */
+	root->simple_rte_array = (RangeTblEntry **)
+							repalloc(root->simple_rte_array,
+									 sizeof(RangeTblEntry *) * new_size);
+	MemSet(root->simple_rte_array + root->simple_rel_array_size,
+		   0, sizeof(RangeTblEntry *) * add_size);
+	root->simple_rel_array = (RelOptInfo **)
+								repalloc(root->simple_rel_array,
+										 sizeof(RelOptInfo *) * new_size);
+	MemSet(root->simple_rel_array + root->simple_rel_array_size,
+		   0, sizeof(RelOptInfo *) * add_size);
+
+	if (root->append_rel_array)
+	{
+		root->append_rel_array = (AppendRelInfo **)
+									repalloc(root->append_rel_array,
+									 sizeof(AppendRelInfo *) * new_size);
+		MemSet(root->append_rel_array + root->simple_rel_array_size,
+			   0, sizeof(AppendRelInfo *) * add_size);
+	}
+	else
+	{
+		root->append_rel_array = (AppendRelInfo **)
+									palloc0(sizeof(AppendRelInfo *) *
+											new_size);
+	}
+
+	root->simple_rel_array_size = new_size;
+}
+
+/*
  * build_simple_rel
  *	  Construct a new RelOptInfo for a base relation or 'other' relation.
  */
@@ -195,6 +239,7 @@ build_simple_rel(PlannerInfo *root, int relid, RelOptInfo *parent)
 	rel->joininfo = NIL;
 	rel->has_eclass_joins = false;
 	rel->consider_partitionwise_join = false; /* might get changed later */
+	rel->top_parent_relids = NULL; /* might be changed later */
 	rel->part_scheme = NULL;
 	rel->nparts = 0;
 	rel->boundinfo = NULL;
@@ -203,6 +248,7 @@ build_simple_rel(PlannerInfo *root, int relid, RelOptInfo *parent)
 	rel->partexprs = NULL;
 	rel->nullable_partexprs = NULL;
 	rel->partitioned_child_rels = NIL;
+	rel->inh_root_parent = 0; /* might be changed later */
 
 	/*
 	 * Pass top parent's relids down the inheritance hierarchy. If the parent
@@ -216,16 +262,25 @@ build_simple_rel(PlannerInfo *root, int relid, RelOptInfo *parent)
 			rel->top_parent_relids = parent->top_parent_relids;
 		else
 			rel->top_parent_relids = bms_copy(parent->relids);
+
+		/*
+		 * For inheritance child relations, we also set inh_root_parent.
+		 * Note that 'parent' might itself be a child (a sub-partitioned
+		 * partition), in which case we simply use its value of
+		 * inh_root_parent.
+		 */
+		if (parent->rtekind == RTE_RELATION)
+			rel->inh_root_parent = parent->inh_root_parent > 0 ?
+										parent->inh_root_parent :
+										parent->relid;
 	}
-	else
-		rel->top_parent_relids = NULL;
 
 	/* Check type of rtable entry */
 	switch (rte->rtekind)
 	{
 		case RTE_RELATION:
 			/* Table --- retrieve statistics from the system catalogs */
-			get_relation_info(root, rte->relid, rte->inh, rel);
+			get_relation_info(root, rte, rel);
 			break;
 		case RTE_SUBQUERY:
 		case RTE_FUNCTION:
@@ -266,52 +321,6 @@ build_simple_rel(PlannerInfo *root, int relid, RelOptInfo *parent)
 		root->qual_security_level = Max(root->qual_security_level,
 										list_length(rte->securityQuals));
 
-	/*
-	 * If this rel is an appendrel parent, recurse to build "other rel"
-	 * RelOptInfos for its children.  They are "other rels" because they are
-	 * not in the main join tree, but we will need RelOptInfos to plan access
-	 * to them.
-	 */
-	if (rte->inh)
-	{
-		ListCell   *l;
-		int			nparts = rel->nparts;
-		int			cnt_parts = 0;
-
-		if (nparts > 0)
-			rel->part_rels = (RelOptInfo **)
-				palloc(sizeof(RelOptInfo *) * nparts);
-
-		foreach(l, root->append_rel_list)
-		{
-			AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(l);
-			RelOptInfo *childrel;
-
-			/* append_rel_list contains all append rels; ignore others */
-			if (appinfo->parent_relid != relid)
-				continue;
-
-			childrel = build_simple_rel(root, appinfo->child_relid,
-										rel);
-
-			/* Nothing more to do for an unpartitioned table. */
-			if (!rel->part_scheme)
-				continue;
-
-			/*
-			 * The order of partition OIDs in append_rel_list is the same as
-			 * the order in the PartitionDesc, so the order of part_rels will
-			 * also match the PartitionDesc.  See expand_partitioned_rtentry.
-			 */
-			Assert(cnt_parts < nparts);
-			rel->part_rels[cnt_parts] = childrel;
-			cnt_parts++;
-		}
-
-		/* We should have seen all the child partitions. */
-		Assert(cnt_parts == nparts);
-	}
-
 	return rel;
 }
 
diff --git a/src/backend/partitioning/partprune.c b/src/backend/partitioning/partprune.c
index 901433c68c..9bb472fd98 100644
--- a/src/backend/partitioning/partprune.c
+++ b/src/backend/partitioning/partprune.c
@@ -46,6 +46,7 @@
 #include "nodes/nodeFuncs.h"
 #include "optimizer/appendinfo.h"
 #include "optimizer/clauses.h"
+#include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
 #include "optimizer/planner.h"
 #include "optimizer/predtest.h"
@@ -437,17 +438,23 @@ make_partitionedrel_pruneinfo(PlannerInfo *root, RelOptInfo *parentrel,
 		 * is, not pruned already).
 		 */
 		subplan_map = (int *) palloc(nparts * sizeof(int));
+		memset(subplan_map, -1, nparts * sizeof(int));
 		subpart_map = (int *) palloc(nparts * sizeof(int));
+		memset(subpart_map, -1, nparts * sizeof(int));
 		present_parts = NULL;
 
 		for (i = 0; i < nparts; i++)
 		{
 			RelOptInfo *partrel = subpart->part_rels[i];
-			int			subplanidx = relid_subplan_map[partrel->relid] - 1;
-			int			subpartidx = relid_subpart_map[partrel->relid] - 1;
+			int			subplanidx;
+			int			subpartidx;
 
-			subplan_map[i] = subplanidx;
-			subpart_map[i] = subpartidx;
+			/* Skip processing pruned partitions. */
+			if (partrel == NULL)
+				continue;
+
+			subplan_map[i] = subplanidx = relid_subplan_map[partrel->relid] - 1;
+			subpart_map[i] = subpartidx = relid_subpart_map[partrel->relid] - 1;
 			if (subplanidx >= 0)
 			{
 				present_parts = bms_add_member(present_parts, i);
@@ -541,23 +548,20 @@ gen_partprune_steps(RelOptInfo *rel, List *clauses, bool *contradictory)
 
 /*
  * prune_append_rel_partitions
- *		Returns RT indexes of the minimum set of child partitions which must
- *		be scanned to satisfy rel's baserestrictinfo quals.
+ *		Returns indexes into rel->part_rels of the minimum set of child
+ *		partitions which must be scanned to satisfy rel's baserestrictinfo
+ *		quals.
  *
  * Callers must ensure that 'rel' is a partitioned table.
  */
-Relids
+Bitmapset *
 prune_append_rel_partitions(RelOptInfo *rel)
 {
-	Relids		result;
 	List	   *clauses = rel->baserestrictinfo;
 	List	   *pruning_steps;
 	bool		contradictory;
 	PartitionPruneContext context;
-	Bitmapset  *partindexes;
-	int			i;
 
-	Assert(clauses != NIL);
 	Assert(rel->part_scheme != NULL);
 
 	/* If there are no partitions, return the empty set */
@@ -565,6 +569,13 @@ prune_append_rel_partitions(RelOptInfo *rel)
 		return NULL;
 
 	/*
+	 * If pruning is disabled or if there are no clauses to prune with,
+	 * return all partitions.
+	 */
+	if (!enable_partition_pruning || clauses == NIL)
+		return bms_add_range(NULL, 0, rel->nparts - 1);
+
+	/*
 	 * Process clauses.  If the clauses are found to be contradictory, we can
 	 * return the empty set.
 	 */
@@ -591,15 +602,7 @@ prune_append_rel_partitions(RelOptInfo *rel)
 	context.evalexecparams = false;
 
 	/* Actual pruning happens here. */
-	partindexes = get_matching_partitions(&context, pruning_steps);
-
-	/* Add selected partitions' RT indexes to result. */
-	i = -1;
-	result = NULL;
-	while ((i = bms_next_member(partindexes, i)) >= 0)
-		result = bms_add_member(result, rel->part_rels[i]->relid);
-
-	return result;
+	return get_matching_partitions(&context, pruning_steps);
 }
 
 /*
diff --git a/src/include/nodes/relation.h b/src/include/nodes/relation.h
index beb2e323a8..01a664d246 100644
--- a/src/include/nodes/relation.h
+++ b/src/include/nodes/relation.h
@@ -15,6 +15,7 @@
 #define RELATION_H
 
 #include "access/sdir.h"
+#include "access/tupdesc.h"
 #include "fmgr.h"
 #include "lib/stringinfo.h"
 #include "nodes/params.h"
@@ -729,11 +730,28 @@ typedef struct RelOptInfo
 	int			nparts;			/* number of partitions */
 	struct PartitionBoundInfoData *boundinfo;	/* Partition bounds */
 	List	   *partition_qual; /* partition constraint */
+	Oid		   *part_oids;		/* partition OIDs */
 	struct RelOptInfo **part_rels;	/* Array of RelOptInfos of partitions,
 									 * stored in the same order of bounds */
 	List	  **partexprs;		/* Non-nullable partition key expressions. */
 	List	  **nullable_partexprs; /* Nullable partition key expressions. */
 	List	   *partitioned_child_rels; /* List of RT indexes. */
+
+	/*
+	 * For inheritance children, this is the RT index of inheritance table
+	 * mentioned in the query from which this relation originated.
+	 * top_parent_relids cannot be used for this, because if the inheritance
+	 * root table is itself under UNION ALL, top_parent_relids contains the
+	 * RT index of UNION ALL parent subquery.
+	 */
+	Index		inh_root_parent;
+
+	/*
+	 * Set only if this is an inheritance parent relation.  This information
+	 * is needed when initializing the planning info for children.
+	 */
+	TupleDesc	tupdesc;		/* A "copy" of the table's tuple desriptor */
+	Oid			reltype;		/* Table's reltype */
 } RelOptInfo;
 
 /*
diff --git a/src/include/optimizer/appendinfo.h b/src/include/optimizer/appendinfo.h
index 604e36d73c..8f7b06a608 100644
--- a/src/include/optimizer/appendinfo.h
+++ b/src/include/optimizer/appendinfo.h
@@ -17,9 +17,10 @@
 #include "nodes/relation.h"
 #include "utils/relcache.h"
 
-extern AppendRelInfo *make_append_rel_info(Relation parentrel,
-					 Relation childrel,
-					 Index parentRTindex, Index childRTindex);
+extern AppendRelInfo *make_append_rel_info(RelOptInfo *parent,
+					 RangeTblEntry *parentrte,
+					 TupleDesc childdesc, Oid childoid, Oid childtype,
+					 Index childRTindex);
 extern Node *adjust_appendrel_attrs(PlannerInfo *root, Node *node,
 					   int nappinfos, AppendRelInfo **appinfos);
 extern Node *adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node,
diff --git a/src/include/optimizer/pathnode.h b/src/include/optimizer/pathnode.h
index bd905d3328..e7d0a20c54 100644
--- a/src/include/optimizer/pathnode.h
+++ b/src/include/optimizer/pathnode.h
@@ -261,6 +261,7 @@ extern Path *reparameterize_path_by_child(PlannerInfo *root, Path *path,
  */
 extern void setup_simple_rel_arrays(PlannerInfo *root);
 extern void setup_append_rel_array(PlannerInfo *root);
+extern void expand_planner_arrays(PlannerInfo *root, int add_size);
 extern RelOptInfo *build_simple_rel(PlannerInfo *root, int relid,
 				 RelOptInfo *parent);
 extern RelOptInfo *find_base_rel(PlannerInfo *root, int relid);
diff --git a/src/include/optimizer/plancat.h b/src/include/optimizer/plancat.h
index a1b23251a1..d8091cdfa4 100644
--- a/src/include/optimizer/plancat.h
+++ b/src/include/optimizer/plancat.h
@@ -25,8 +25,8 @@ typedef void (*get_relation_info_hook_type) (PlannerInfo *root,
 extern PGDLLIMPORT get_relation_info_hook_type get_relation_info_hook;
 
 
-extern void get_relation_info(PlannerInfo *root, Oid relationObjectId,
-				  bool inhparent, RelOptInfo *rel);
+extern void get_relation_info(PlannerInfo *root, RangeTblEntry *rte,
+				  RelOptInfo *rel);
 
 extern List *infer_arbiter_indexes(PlannerInfo *root);
 
diff --git a/src/include/optimizer/prep.h b/src/include/optimizer/prep.h
index 62d45dd142..a329e87fc2 100644
--- a/src/include/optimizer/prep.h
+++ b/src/include/optimizer/prep.h
@@ -38,7 +38,8 @@ extern Expr *canonicalize_qual(Expr *qual, bool is_check);
 /*
  * prototypes for preptlist.c
  */
-extern List *preprocess_targetlist(PlannerInfo *root);
+extern List *preprocess_targetlist(PlannerInfo *root,
+							bool inheritance_expanded);
 
 extern PlanRowMark *get_plan_rowmark(List *rowmarks, Index rtindex);
 
diff --git a/src/include/partitioning/partprune.h b/src/include/partitioning/partprune.h
index ce9bc8d9fd..5c5d27d040 100644
--- a/src/include/partitioning/partprune.h
+++ b/src/include/partitioning/partprune.h
@@ -76,7 +76,7 @@ extern PartitionPruneInfo *make_partition_pruneinfo(PlannerInfo *root,
 						 List *subpaths,
 						 List *partitioned_rels,
 						 List *prunequal);
-extern Relids prune_append_rel_partitions(RelOptInfo *rel);
+extern Bitmapset *prune_append_rel_partitions(RelOptInfo *rel);
 extern Bitmapset *get_matching_partitions(PartitionPruneContext *context,
 						List *pruning_steps);
 
diff --git a/src/test/regress/expected/partition_aggregate.out b/src/test/regress/expected/partition_aggregate.out
index 6bc106831e..1450cef057 100644
--- a/src/test/regress/expected/partition_aggregate.out
+++ b/src/test/regress/expected/partition_aggregate.out
@@ -144,7 +144,7 @@ SELECT c, sum(a) FROM pagg_tab WHERE 1 = 2 GROUP BY c;
            QUERY PLAN           
 --------------------------------
  HashAggregate
-   Group Key: pagg_tab.c
+   Group Key: c
    ->  Result
          One-Time Filter: false
 (4 rows)
@@ -159,7 +159,7 @@ SELECT c, sum(a) FROM pagg_tab WHERE c = 'x' GROUP BY c;
            QUERY PLAN           
 --------------------------------
  GroupAggregate
-   Group Key: pagg_tab.c
+   Group Key: c
    ->  Result
          One-Time Filter: false
 (4 rows)
-- 
2.11.0

From ca5a541d56177bc2cf2abd526cf3042b7169bf23 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Mon, 15 Oct 2018 10:59:24 +0900
Subject: [PATCH v15 3/4] Teach planner to only process unpruned partitions

This adds a bitmapset field live_parts to RelOptInfo and stores
the partition indexes of non-dummy partitions in it, meaning it
contains indexes of only those partitions that have a non-NULL
RelOptInfo present in its parent's RelOptInfo's part_rels array.

This speeds up processing partitioned table's partitions compared
to going through the whole part_rels array in a number of places.
---
 src/backend/optimizer/path/joinrels.c |  3 +++
 src/backend/optimizer/plan/planner.c  | 18 +++++++++---------
 src/backend/optimizer/util/inherit.c  |  1 +
 src/backend/optimizer/util/relnode.c  |  3 +++
 src/backend/partitioning/partprune.c  | 18 +++++-------------
 src/include/nodes/relation.h          |  4 ++++
 6 files changed, 25 insertions(+), 22 deletions(-)

diff --git a/src/backend/optimizer/path/joinrels.c b/src/backend/optimizer/path/joinrels.c
index 75edac96f4..97b79035f0 100644
--- a/src/backend/optimizer/path/joinrels.c
+++ b/src/backend/optimizer/path/joinrels.c
@@ -1426,6 +1426,9 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
 		populate_joinrel_with_paths(root, child_rel1, child_rel2,
 									child_joinrel, child_sjinfo,
 									child_restrictlist);
+		if (!IS_DUMMY_REL(child_joinrel))
+			joinrel->live_parts = bms_add_member(joinrel->live_parts,
+												 cnt_parts);
 	}
 }
 
diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index f80f35eed3..faf5f343fb 100644
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -6833,7 +6833,9 @@ apply_scanjoin_target_to_paths(PlannerInfo *root,
 		List	   *live_children = NIL;
 
 		/* Adjust each partition. */
-		for (partition_idx = 0; partition_idx < rel->nparts; partition_idx++)
+		partition_idx = -1;
+		while ((partition_idx = bms_next_member(rel->live_parts,
+												partition_idx)) >= 0)
 		{
 			RelOptInfo *child_rel = rel->part_rels[partition_idx];
 			ListCell   *lc;
@@ -6841,9 +6843,7 @@ apply_scanjoin_target_to_paths(PlannerInfo *root,
 			int			nappinfos;
 			List	   *child_scanjoin_targets = NIL;
 
-			/* Skip processing pruned partitions. */
-			if (child_rel == NULL)
-				continue;
+			Assert(child_rel != NULL);
 
 			/* Translate scan/join targets for this child. */
 			appinfos = find_appinfos_by_relids(root, child_rel->relids,
@@ -6924,7 +6924,6 @@ create_partitionwise_grouping_paths(PlannerInfo *root,
 									PartitionwiseAggregateType patype,
 									GroupPathExtraData *extra)
 {
-	int			nparts = input_rel->nparts;
 	int			cnt_parts;
 	List	   *grouped_live_children = NIL;
 	List	   *partially_grouped_live_children = NIL;
@@ -6936,7 +6935,9 @@ create_partitionwise_grouping_paths(PlannerInfo *root,
 		   partially_grouped_rel != NULL);
 
 	/* Add paths for partitionwise aggregation/grouping. */
-	for (cnt_parts = 0; cnt_parts < nparts; cnt_parts++)
+	cnt_parts = -1;
+	while ((cnt_parts = bms_next_member(input_rel->live_parts,
+										cnt_parts)) >= 0)
 	{
 		RelOptInfo *child_input_rel = input_rel->part_rels[cnt_parts];
 		PathTarget *child_target = copy_pathtarget(target);
@@ -6946,9 +6947,8 @@ create_partitionwise_grouping_paths(PlannerInfo *root,
 		RelOptInfo *child_grouped_rel;
 		RelOptInfo *child_partially_grouped_rel;
 
-		/* Skip processing pruned partitions. */
-		if (child_input_rel == NULL)
-			continue;
+		/* A live partition must have a RelOptInfo. */
+		Assert(child_input_rel != NULL);
 
 		/* Input child rel must have a path */
 		Assert(child_input_rel->pathlist != NIL);
diff --git a/src/backend/optimizer/util/inherit.c b/src/backend/optimizer/util/inherit.c
index f1bd954373..d6f120fcc1 100644
--- a/src/backend/optimizer/util/inherit.c
+++ b/src/backend/optimizer/util/inherit.c
@@ -361,6 +361,7 @@ expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
 
 	/* Perform pruning. */
 	partindexes = prune_append_rel_partitions(parentrel);
+	parentrel->live_parts = partindexes;
 
 	/* Must expand PlannerInfo arrays before we can add children. */
 	if (bms_num_members(partindexes) > 0)
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index d12d047002..059ab8f35e 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -1757,6 +1757,9 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
 		joinrel->partexprs[cnt] = partexpr;
 		joinrel->nullable_partexprs[cnt] = nullable_partexpr;
 	}
+
+	/* Partitions will be added by try_partitionwise_join. */
+	joinrel->live_parts = NULL;
 }
 
 /*
diff --git a/src/backend/partitioning/partprune.c b/src/backend/partitioning/partprune.c
index 9bb472fd98..088b191bdd 100644
--- a/src/backend/partitioning/partprune.c
+++ b/src/backend/partitioning/partprune.c
@@ -441,29 +441,21 @@ make_partitionedrel_pruneinfo(PlannerInfo *root, RelOptInfo *parentrel,
 		memset(subplan_map, -1, nparts * sizeof(int));
 		subpart_map = (int *) palloc(nparts * sizeof(int));
 		memset(subpart_map, -1, nparts * sizeof(int));
-		present_parts = NULL;
+		present_parts = bms_copy(subpart->live_parts);
 
-		for (i = 0; i < nparts; i++)
+		i = -1;
+		while ((i = bms_next_member(present_parts, i)) >= 0)
 		{
 			RelOptInfo *partrel = subpart->part_rels[i];
 			int			subplanidx;
 			int			subpartidx;
 
-			/* Skip processing pruned partitions. */
-			if (partrel == NULL)
-				continue;
-
+			Assert(partrel != NULL);
 			subplan_map[i] = subplanidx = relid_subplan_map[partrel->relid] - 1;
 			subpart_map[i] = subpartidx = relid_subpart_map[partrel->relid] - 1;
+			/* Record finding this subplan */
 			if (subplanidx >= 0)
-			{
-				present_parts = bms_add_member(present_parts, i);
-
-				/* Record finding this subplan  */
 				subplansfound = bms_add_member(subplansfound, subplanidx);
-			}
-			else if (subpartidx >= 0)
-				present_parts = bms_add_member(present_parts, i);
 		}
 
 		pinfo = makeNode(PartitionedRelPruneInfo);
diff --git a/src/include/nodes/relation.h b/src/include/nodes/relation.h
index 01a664d246..d27611c2c7 100644
--- a/src/include/nodes/relation.h
+++ b/src/include/nodes/relation.h
@@ -733,6 +733,10 @@ typedef struct RelOptInfo
 	Oid		   *part_oids;		/* partition OIDs */
 	struct RelOptInfo **part_rels;	/* Array of RelOptInfos of partitions,
 									 * stored in the same order of bounds */
+	Bitmapset  *live_parts;		/* Indexes into part_rels of the non-NULL
+								 * RelOptInfos of unpruned partitions; exists
+								 * to avoid having to iterate over the entire
+								 * part_rels array to filter NULL entries. */
 	List	  **partexprs;		/* Non-nullable partition key expressions. */
 	List	  **nullable_partexprs; /* Nullable partition key expressions. */
 	List	   *partitioned_child_rels; /* List of RT indexes. */
-- 
2.11.0

From e0c030502e531b9c5cd7949498251670c3673146 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Fri, 12 Oct 2018 19:12:53 +0900
Subject: [PATCH v15 4/4] Do not lock all partitions at the beginning

---
 src/backend/optimizer/util/inherit.c | 11 +----------
 1 file changed, 1 insertion(+), 10 deletions(-)

diff --git a/src/backend/optimizer/util/inherit.c b/src/backend/optimizer/util/inherit.c
index d6f120fcc1..426d64faea 100644
--- a/src/backend/optimizer/util/inherit.c
+++ b/src/backend/optimizer/util/inherit.c
@@ -328,10 +328,6 @@ expand_nonpartitioned_inherited_rtentry(PlannerInfo *root,
  *
  * Partitions are added to the query in order in which they are found in
  * the parent's PartitionDesc.
- *
- * Note: even though only the unpruned partitions will be added to the
- * resulting plan, this still locks *all* partitions via find_all_inheritors
- * when this function is called for the root partitioned table.
  */
 static void
 expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
@@ -345,10 +341,6 @@ expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
 									parentrel->inh_root_parent :
 									parentRTindex;
 
-	/* If root partitioned table, lock *all* partitions in the tree. */
-	if (parentRTindex == rootParentRTindex)
-		(void) find_all_inheritors(parentrte->relid, lockmode, NULL);
-
 	/*
 	 * Initialize partitioned_child_rels to contain this RT index.
 	 *
@@ -385,8 +377,7 @@ expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
 		RangeTblEntry *childrte;
 		Index		childRTindex;
 
-		/* Already locked above. */
-		newrelation = heap_open(childOID, NoLock);
+		newrelation = heap_open(childOID, lockmode);
 		Assert(!RELATION_IS_OTHER_TEMP(newrelation));
 
 		/*
-- 
2.11.0