Inheritance planner CPU and memory usage change since 9.3.2

diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index 8afde2b..84c75f1 100644
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -43,6 +43,7 @@
 #include "parser/parsetree.h"
 #include "parser/parse_agg.h"
 #include "rewrite/rewriteManip.h"
+#include "utils/memutils.h"
 #include "utils/rel.h"
 #include "utils/selfuncs.h"
 
@@ -845,9 +846,17 @@ inheritance_planner(PlannerInfo *root)
 	List	   *returningLists = NIL;
 	List	   *rowMarks;
 	ListCell   *lc;
+	MemoryContext	myctx;
+	MemoryContext	oldctx;
 
 	Assert(parse->commandType != CMD_INSERT);
 
+	myctx = AllocSetContextCreate(CurrentMemoryContext,
+								  "inheritance_planner",
+								  ALLOCSET_DEFAULT_MINSIZE,
+								  ALLOCSET_DEFAULT_INITSIZE,
+								  ALLOCSET_DEFAULT_MAXSIZE);
+
 	/*
 	 * 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
@@ -908,18 +917,16 @@ inheritance_planner(PlannerInfo *root)
 
 		/*
 		 * 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.)
+		 * make a copy that we can apply ChangeVarNodes to.  If any security
+		 * barrier quals are present, the rowMarks list may be further modified
+		 * by grouping_planner. (Fortunately, the executor doesn't need to see
+		 * the modified copies --- we can just pass it the original rowMarks
+		 * list.  For the same reason, we can arrange to throw away the copy
+		 * we make here relatively quickly.)
 		 */
+		oldctx = MemoryContextSwitchTo(myctx);
 		subroot.rowMarks = (List *) copyObject(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.
-		 */
-		subroot.append_rel_list = (List *) copyObject(root->append_rel_list);
+		MemoryContextSwitchTo(oldctx);
 
 		/*
 		 * Add placeholders to the child Query's rangetable list to fill the
@@ -942,6 +949,7 @@ inheritance_planner(PlannerInfo *root)
 		if (final_rtable != NIL)
 		{
 			ListCell   *lr;
+			bool		did_copy = false;
 
 			rti = 1;
 			foreach(lr, parse->rtable)
@@ -960,6 +968,21 @@ inheritance_planner(PlannerInfo *root)
 					Index		newrti;
 
 					/*
+					 * The append_rel_list likewise might contain references
+					 * to subquery RTEs (if any subqueries were flattenable
+					 * UNION ALLs).  So we need to mutate that too, and must
+					 * therefore copy it.
+					 */
+					if (!did_copy)
+					{
+						oldctx = MemoryContextSwitchTo(myctx);
+						subroot.append_rel_list =
+							(List *) copyObject(root->append_rel_list);
+						MemoryContextSwitchTo(oldctx);
+						did_copy = true;
+					}
+
+					/*
 					 * The RTE can't contain any references to its own RT
 					 * index, except in the security barrier quals, so we can
 					 * save a few cycles by applying ChangeVarNodes before we
@@ -989,6 +1012,9 @@ inheritance_planner(PlannerInfo *root)
 		/* Generate plan */
 		subplan = grouping_planner(&subroot, 0.0 /* retrieve all tuples */ );
 
+		/* Reclaim some memory */
+		MemoryContextReset(myctx);
+
 		/*
 		 * Planning may have modified the query result relation (if there were
 		 * security barrier quals on the result RTE).
@@ -1097,6 +1123,8 @@ inheritance_planner(PlannerInfo *root)
 		Assert(!parse->onConflict);
 	}
 
+	MemoryContextDelete(myctx);
+
 	/* Mark result as unordered (probably unnecessary) */
 	root->query_pathkeys = NIL;
 

diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index 8afde2b..6737818 100644
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -43,6 +43,7 @@
 #include "parser/parsetree.h"
 #include "parser/parse_agg.h"
 #include "rewrite/rewriteManip.h"
+#include "utils/memutils.h"
 #include "utils/rel.h"
 #include "utils/selfuncs.h"
 
@@ -845,9 +846,19 @@ inheritance_planner(PlannerInfo *root)
 	List	   *returningLists = NIL;
 	List	   *rowMarks;
 	ListCell   *lc;
+	MemoryContext	myctx;
+	MemoryContext	oldctx;
+	bool		did_extract = false;
+	Relids		append_rel_list_relids = NULL;
 
 	Assert(parse->commandType != CMD_INSERT);
 
+	myctx = AllocSetContextCreate(CurrentMemoryContext,
+								  "inheritance_planner",
+								  ALLOCSET_DEFAULT_MINSIZE,
+								  ALLOCSET_DEFAULT_INITSIZE,
+								  ALLOCSET_DEFAULT_MAXSIZE);
+
 	/*
 	 * 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
@@ -908,18 +919,16 @@ inheritance_planner(PlannerInfo *root)
 
 		/*
 		 * 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.)
+		 * make a copy that we can apply ChangeVarNodes to.  If any security
+		 * barrier quals are present, the rowMarks list may be further modified
+		 * by grouping_planner. (Fortunately, the executor doesn't need to see
+		 * the modified copies --- we can just pass it the original rowMarks
+		 * list.  For the same reason, we can arrange to throw away the copy
+		 * we make here relatively quickly.)
 		 */
+		oldctx = MemoryContextSwitchTo(myctx);
 		subroot.rowMarks = (List *) copyObject(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.
-		 */
-		subroot.append_rel_list = (List *) copyObject(root->append_rel_list);
+		MemoryContextSwitchTo(oldctx);
 
 		/*
 		 * Add placeholders to the child Query's rangetable list to fill the
@@ -942,6 +951,7 @@ inheritance_planner(PlannerInfo *root)
 		if (final_rtable != NIL)
 		{
 			ListCell   *lr;
+			bool		did_copy = false;
 
 			rti = 1;
 			foreach(lr, parse->rtable)
@@ -968,7 +978,39 @@ inheritance_planner(PlannerInfo *root)
 					newrti = list_length(subroot.parse->rtable) + 1;
 					ChangeVarNodes((Node *) subroot.parse, rti, newrti, 0);
 					ChangeVarNodes((Node *) subroot.rowMarks, rti, newrti, 0);
-					ChangeVarNodes((Node *) subroot.append_rel_list, rti, newrti, 0);
+
+					/*
+					 * The append_rel_list likewise might contain references
+					 * to subquery RTEs (if any subqueries were flattenable
+					 * UNION ALLs).  We can't modify the original copy owned
+					 * by the parent root, so we have to copy the list if
+					 * anything needs to be changed.  But that may be expensive
+					 * if there are many RTEs, so if we have not yet made a
+					 * copy, do so only if ChangeVarNodes will not be a no-op.
+					 * Even walking the whole node tree is expensive, so skip
+					 * that unless a reference to this RTI is indeed present.
+					 */
+					if (!did_extract)
+					{
+						append_rel_list_relids =
+							ExtractRTIndexes((Node *) subroot.append_rel_list,
+											 0);
+						did_extract = true;
+					}
+					if (bms_is_member(rti, append_rel_list_relids))
+					{
+						if (!did_copy)
+						{
+							oldctx = MemoryContextSwitchTo(myctx);
+							subroot.append_rel_list =
+								(List *) copyObject(root->append_rel_list);
+							MemoryContextSwitchTo(oldctx);
+							did_copy = true;
+						}
+						ChangeVarNodes((Node *) subroot.append_rel_list, rti,
+									   newrti, 0);
+					}
+
 					rte = copyObject(rte);
 					ChangeVarNodes((Node *) rte->securityQuals, rti, newrti, 0);
 					subroot.parse->rtable = lappend(subroot.parse->rtable,
@@ -976,6 +1018,8 @@ inheritance_planner(PlannerInfo *root)
 				}
 				rti++;
 			}
+
+			bms_free(append_rel_list_relids);
 		}
 
 		/* There shouldn't be any OJ or LATERAL info to translate, as yet */
@@ -989,6 +1033,9 @@ inheritance_planner(PlannerInfo *root)
 		/* Generate plan */
 		subplan = grouping_planner(&subroot, 0.0 /* retrieve all tuples */ );
 
+		/* Reclaim some memory */
+		MemoryContextReset(myctx);
+
 		/*
 		 * Planning may have modified the query result relation (if there were
 		 * security barrier quals on the result RTE).
@@ -1097,6 +1144,8 @@ inheritance_planner(PlannerInfo *root)
 		Assert(!parse->onConflict);
 	}
 
+	MemoryContextDelete(myctx);
+
 	/* Mark result as unordered (probably unnecessary) */
 	root->query_pathkeys = NIL;
 
diff --git a/src/backend/rewrite/rewriteManip.c b/src/backend/rewrite/rewriteManip.c
index 1da90ff..3075b9a 100644
--- a/src/backend/rewrite/rewriteManip.c
+++ b/src/backend/rewrite/rewriteManip.c
@@ -674,6 +674,152 @@ adjust_relid_set(Relids relids, int oldrelid, int newrelid)
 }
 
 /*
+ * ExtractRTIndexes - find all RT indexes referenced in a node tree
+ *
+ * This is similar to pull_varnos, but it needs to use exactly the same
+ * criteria as ChangeVarNodes, and pull_varnos does not.
+ */
+
+typedef struct
+{
+	int			sublevels_up;
+	Relids		varnos;
+} ExtractRTIndexes_context;
+
+static bool
+ExtractRTIndexes_walker(Node *node, ExtractRTIndexes_context *context)
+{
+	if (node == NULL)
+		return false;
+	if (IsA(node, Var))
+	{
+		Var		   *var = (Var *) node;
+
+		if (var->varlevelsup == context->sublevels_up)
+			context->varnos = bms_add_member(context->varnos, var->varno);
+		return false;
+	}
+	if (IsA(node, CurrentOfExpr))
+	{
+		CurrentOfExpr *cexpr = (CurrentOfExpr *) node;
+
+		if (context->sublevels_up == 0)
+			context->varnos = bms_add_member(context->varnos, cexpr->cvarno);
+		return false;
+	}
+	if (IsA(node, RangeTblRef))
+	{
+		RangeTblRef *rtr = (RangeTblRef *) node;
+
+		if (context->sublevels_up == 0)
+			context->varnos = bms_add_member(context->varnos, rtr->rtindex);
+		/* the subquery itself is visited separately */
+		return false;
+	}
+	if (IsA(node, JoinExpr))
+	{
+		JoinExpr   *j = (JoinExpr *) node;
+
+		if (context->sublevels_up == 0)
+			context->varnos = bms_add_member(context->varnos, j->rtindex);
+		/* fall through to examine children */
+	}
+	if (IsA(node, PlaceHolderVar))
+	{
+		PlaceHolderVar *phv = (PlaceHolderVar *) node;
+
+		if (phv->phlevelsup == context->sublevels_up)
+			context->varnos = bms_add_members(context->varnos, phv->phrels);
+		/* fall through to examine children */
+	}
+	if (IsA(node, PlanRowMark))
+	{
+		PlanRowMark *rowmark = (PlanRowMark *) node;
+
+		if (context->sublevels_up == 0)
+		{
+			context->varnos = bms_add_member(context->varnos, rowmark->rti);
+			context->varnos = bms_add_member(context->varnos, rowmark->prti);
+		}
+		return false;
+	}
+	if (IsA(node, AppendRelInfo))
+	{
+		AppendRelInfo *appinfo = (AppendRelInfo *) node;
+
+		if (context->sublevels_up == 0)
+		{
+			context->varnos = bms_add_member(context->varnos,
+											 appinfo->parent_relid);
+			context->varnos = bms_add_member(context->varnos,
+											 appinfo->child_relid);
+		}
+		/* fall through to examine children */
+	}
+	/* Shouldn't need to handle other planner auxiliary nodes here */
+	Assert(!IsA(node, SpecialJoinInfo));
+	Assert(!IsA(node, LateralJoinInfo));
+	Assert(!IsA(node, PlaceHolderInfo));
+	Assert(!IsA(node, MinMaxAggInfo));
+
+	if (IsA(node, Query))
+	{
+		/* Recurse into subselects */
+		bool		result;
+
+		context->sublevels_up++;
+		result = query_tree_walker((Query *) node, ExtractRTIndexes_walker,
+								   (void *) context, 0);
+		context->sublevels_up--;
+		return result;
+	}
+	return expression_tree_walker(node, ExtractRTIndexes_walker,
+								  (void *) context);
+}
+
+Relids
+ExtractRTIndexes(Node *node, int sublevels_up)
+{
+	ExtractRTIndexes_context context;
+
+	context.sublevels_up = sublevels_up;
+	context.varnos = NULL;
+
+	/*
+	 * Must be prepared to start with a Query or a bare expression tree; if
+	 * it's a Query, go straight to query_tree_walker to make sure that
+	 * sublevels_up doesn't get incremented prematurely.
+	 */
+	if (node && IsA(node, Query))
+	{
+		Query	   *qry = (Query *) node;
+
+		if (sublevels_up == 0)
+		{
+			ListCell   *l;
+
+			context.varnos = bms_add_member(context.varnos,
+											qry->resultRelation);
+			if (qry->onConflict)
+				context.varnos = bms_add_member(context.varnos,
+											 qry->onConflict->exclRelIndex);
+
+			foreach(l, qry->rowMarks)
+			{
+				RowMarkClause *rc = (RowMarkClause *) lfirst(l);
+
+				context.varnos = bms_add_member(context.varnos, rc->rti);
+			}
+		}
+		query_tree_walker(qry, ExtractRTIndexes_walker, (void *) &context, 0);
+	}
+	else
+		ExtractRTIndexes_walker(node, &context);
+
+	return context.varnos;
+}
+
+/*
  * IncrementVarSublevelsUp - adjust Var nodes when pushing them down in tree
  *
  * Find all Var nodes in the given tree having varlevelsup >= min_sublevels_up,
diff --git a/src/include/rewrite/rewriteManip.h b/src/include/rewrite/rewriteManip.h
index bb56fa0..1fc1587 100644
--- a/src/include/rewrite/rewriteManip.h
+++ b/src/include/rewrite/rewriteManip.h
@@ -15,6 +15,7 @@
 #define REWRITEMANIP_H
 
 #include "nodes/parsenodes.h"
+#include "nodes/relation.h"
 
 
 typedef struct replace_rte_variables_context replace_rte_variables_context;
@@ -42,6 +43,7 @@ typedef enum ReplaceVarsNoMatchOption
 extern void OffsetVarNodes(Node *node, int offset, int sublevels_up);
 extern void ChangeVarNodes(Node *node, int old_varno, int new_varno,
 			   int sublevels_up);
+extern Relids ExtractRTIndexes(Node *node, int sublevels_up);
 extern void IncrementVarSublevelsUp(Node *node, int delta_sublevels_up,
 						int min_sublevels_up);
 extern void IncrementVarSublevelsUp_rtable(List *rtable,

diff --git a/src/backend/nodes/nodeFuncs.c b/src/backend/nodes/nodeFuncs.c
index a2bcca5..931d464 100644
--- a/src/backend/nodes/nodeFuncs.c
+++ b/src/backend/nodes/nodeFuncs.c
@@ -2870,9 +2870,9 @@ range_table_mutator(List *rtable,
 			case RTE_RELATION:
 				if (rte->tablesample)
 				{
-					MUTATE(rte->tablesample->args, rte->tablesample->args,
+					MUTATE(newrte->tablesample->args, rte->tablesample->args,
 						   List *);
-					MUTATE(rte->tablesample->repeatable,
+					MUTATE(newrte->tablesample->repeatable,
 						   rte->tablesample->repeatable, Node *);
 				}
 				break;

diff --git a/src/backend/nodes/nodeFuncs.c b/src/backend/nodes/nodeFuncs.c
index a2bcca5..1c89abb 100644
--- a/src/backend/nodes/nodeFuncs.c
+++ b/src/backend/nodes/nodeFuncs.c
@@ -2870,9 +2870,10 @@ range_table_mutator(List *rtable,
 			case RTE_RELATION:
 				if (rte->tablesample)
 				{
-					MUTATE(rte->tablesample->args, rte->tablesample->args,
+					FLATCOPY(newrte->tablesample, rte->tablesample, TableSampleClause);
+					MUTATE(newrte->tablesample->args, rte->tablesample->args,
 						   List *);
-					MUTATE(rte->tablesample->repeatable,
+					MUTATE(newrte->tablesample->repeatable,
 						   rte->tablesample->repeatable, Node *);
 				}
 				break;
diff --git a/src/test/regress/sql/tablesample.sql b/src/test/regress/sql/tablesample.sql
index 7b3eb9b..2be5d85 100644
--- a/src/test/regress/sql/tablesample.sql
+++ b/src/test/regress/sql/tablesample.sql
@@ -1,4 +1,5 @@
 CREATE TABLE test_tablesample (id int, name text) WITH (fillfactor=10); -- force smaller pages so we don't have to load too much data to get multiple pages
+CREATE TABLE test_tablesample_inh() INHERITS (test_tablesample);
 
 INSERT INTO test_tablesample SELECT i, repeat(i::text, 200) FROM generate_series(0, 9) s(i) ORDER BY i;
 

diff --git a/src/backend/nodes/nodeFuncs.c b/src/backend/nodes/nodeFuncs.c
index a2bcca5..1c89abb 100644
--- a/src/backend/nodes/nodeFuncs.c
+++ b/src/backend/nodes/nodeFuncs.c
@@ -2870,9 +2870,10 @@ range_table_mutator(List *rtable,
 			case RTE_RELATION:
 				if (rte->tablesample)
 				{
-					MUTATE(rte->tablesample->args, rte->tablesample->args,
+					FLATCOPY(newrte->tablesample, rte->tablesample, TableSampleClause);
+					MUTATE(newrte->tablesample->args, rte->tablesample->args,
 						   List *);
-					MUTATE(rte->tablesample->repeatable,
+					MUTATE(newrte->tablesample->repeatable,
 						   rte->tablesample->repeatable, Node *);
 				}
 				break;

diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index 8afde2b7d5069707e346901f819bed888a2333ee..d7fee96ba01272efdf7231d5985ab688912bcf58 100644
*** a/src/backend/optimizer/plan/planner.c
--- b/src/backend/optimizer/plan/planner.c
*************** inheritance_planner(PlannerInfo *root)
*** 834,840 ****
  {
  	Query	   *parse = root->parse;
  	int			parentRTindex = parse->resultRelation;
! 	Bitmapset  *resultRTindexes = NULL;
  	int			nominalRelation = -1;
  	List	   *final_rtable = NIL;
  	int			save_rel_array_size = 0;
--- 834,842 ----
  {
  	Query	   *parse = root->parse;
  	int			parentRTindex = parse->resultRelation;
! 	Bitmapset  *resultRTindexes;
! 	Bitmapset  *subqueryRTindexes;
! 	Bitmapset  *modifiableARIindexes;
  	int			nominalRelation = -1;
  	List	   *final_rtable = NIL;
  	int			save_rel_array_size = 0;
*************** inheritance_planner(PlannerInfo *root)
*** 845,850 ****
--- 847,853 ----
  	List	   *returningLists = NIL;
  	List	   *rowMarks;
  	ListCell   *lc;
+ 	Index		rti;
  
  	Assert(parse->commandType != CMD_INSERT);
  
*************** inheritance_planner(PlannerInfo *root)
*** 867,874 ****
  	 * subqueries during planning, and so we must create copies of them too,
  	 * except where they are target relations, which will each only be used in
  	 * a single plan.
  	 */
! 	resultRTindexes = bms_add_member(resultRTindexes, parentRTindex);
  	foreach(lc, root->append_rel_list)
  	{
  		AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(lc);
--- 870,879 ----
  	 * subqueries during planning, and so we must create copies of them too,
  	 * except where they are target relations, which will each only be used in
  	 * a single plan.
+ 	 *
+ 	 * To begin with, we'll need a bitmapset of the target relation relids.
  	 */
! 	resultRTindexes = bms_make_singleton(parentRTindex);
  	foreach(lc, root->append_rel_list)
  	{
  		AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(lc);
*************** inheritance_planner(PlannerInfo *root)
*** 878,889 ****
  											 appinfo->child_relid);
  	}
  
  	foreach(lc, root->append_rel_list)
  	{
  		AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(lc);
  		PlannerInfo subroot;
  		Plan	   *subplan;
! 		Index		rti;
  
  		/* append_rel_list contains all append rels; ignore others */
  		if (appinfo->parent_relid != parentRTindex)
--- 883,937 ----
  											 appinfo->child_relid);
  	}
  
+ 	/*
+ 	 * Now, generate a bitmapset of the relids of the subquery RTEs, including
+ 	 * security-barrier RTEs that will become subqueries, as just explained.
+ 	 */
+ 	subqueryRTindexes = NULL;
+ 	rti = 1;
+ 	foreach(lc, parse->rtable)
+ 	{
+ 		RangeTblEntry *rte = (RangeTblEntry *) lfirst(lc);
+ 
+ 		if (rte->rtekind == RTE_SUBQUERY ||
+ 			(rte->securityQuals != NIL &&
+ 			 !bms_is_member(rti, resultRTindexes)))
+ 			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;
+ 	foreach(lc, root->append_rel_list)
+ 	{
+ 		AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(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);
+ 	}
+ 
+ 	/*
+ 	 * And now we can get on with generating a plan for each child table.
+ 	 */
  	foreach(lc, root->append_rel_list)
  	{
  		AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(lc);
  		PlannerInfo subroot;
  		Plan	   *subplan;
! 		ListCell   *lc2;
  
  		/* append_rel_list contains all append rels; ignore others */
  		if (appinfo->parent_relid != parentRTindex)
*************** inheritance_planner(PlannerInfo *root)
*** 917,925 ****
  		/*
  		 * 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.
  		 */
! 		subroot.append_rel_list = (List *) copyObject(root->append_rel_list);
  
  		/*
  		 * Add placeholders to the child Query's rangetable list to fill the
--- 965,985 ----
  		/*
  		 * 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.
  		 */
! 		subroot.append_rel_list = NIL;
! 		foreach(lc2, root->append_rel_list)
! 		{
! 			AppendRelInfo *appinfo2 = (AppendRelInfo *) lfirst(lc2);
! 
! 			if (bms_is_member(appinfo2->child_relid, modifiableARIindexes))
! 				appinfo2 = (AppendRelInfo *) copyObject(appinfo2);
! 
! 			subroot.append_rel_list = lappend(subroot.append_rel_list,
! 											  appinfo2);
! 		}
  
  		/*
  		 * Add placeholders to the child Query's rangetable list to fill the
*************** inheritance_planner(PlannerInfo *root)
*** 933,945 ****
  
  		/*
  		 * 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)
  		{
  			ListCell   *lr;
  
--- 993,1005 ----
  
  		/*
  		 * If this isn't the first child Query, generate duplicates of all
! 		 * subquery (or subquery-to-be) 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 && !bms_is_empty(subqueryRTindexes))
  		{
  			ListCell   *lr;
  
*************** inheritance_planner(PlannerInfo *root)
*** 948,961 ****
  			{
  				RangeTblEntry *rte = (RangeTblEntry *) lfirst(lr);
  
! 				/*
! 				 * Copy subquery RTEs and RTEs with security barrier quals
! 				 * that will be turned into subqueries, except those that are
! 				 * target relations.
! 				 */
! 				if (rte->rtekind == RTE_SUBQUERY ||
! 					(rte->securityQuals != NIL &&
! 					 !bms_is_member(rti, resultRTindexes)))
  				{
  					Index		newrti;
  
--- 1008,1014 ----
  			{
  				RangeTblEntry *rte = (RangeTblEntry *) lfirst(lr);
  
! 				if (bms_is_member(rti, subqueryRTindexes))
  				{
  					Index		newrti;
  

diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
new file mode 100644
index 8afde2b..c8a3c65
*** a/src/backend/optimizer/plan/planner.c
--- b/src/backend/optimizer/plan/planner.c
*************** inheritance_planner(PlannerInfo *root)
*** 834,840 ****
  {
  	Query	   *parse = root->parse;
  	int			parentRTindex = parse->resultRelation;
! 	Bitmapset  *resultRTindexes = NULL;
  	int			nominalRelation = -1;
  	List	   *final_rtable = NIL;
  	int			save_rel_array_size = 0;
--- 834,842 ----
  {
  	Query	   *parse = root->parse;
  	int			parentRTindex = parse->resultRelation;
! 	Bitmapset  *resultRTindexes;
! 	Bitmapset  *subqueryRTindexes;
! 	Bitmapset  *modifiableARIindexes;
  	int			nominalRelation = -1;
  	List	   *final_rtable = NIL;
  	int			save_rel_array_size = 0;
*************** inheritance_planner(PlannerInfo *root)
*** 845,850 ****
--- 847,853 ----
  	List	   *returningLists = NIL;
  	List	   *rowMarks;
  	ListCell   *lc;
+ 	Index		rti;
  
  	Assert(parse->commandType != CMD_INSERT);
  
*************** inheritance_planner(PlannerInfo *root)
*** 867,874 ****
  	 * subqueries during planning, and so we must create copies of them too,
  	 * except where they are target relations, which will each only be used in
  	 * a single plan.
  	 */
! 	resultRTindexes = bms_add_member(resultRTindexes, parentRTindex);
  	foreach(lc, root->append_rel_list)
  	{
  		AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(lc);
--- 870,879 ----
  	 * subqueries during planning, and so we must create copies of them too,
  	 * except where they are target relations, which will each only be used in
  	 * a single plan.
+ 	 *
+ 	 * To begin with, we'll need a bitmapset of the target relation relids.
  	 */
! 	resultRTindexes = bms_make_singleton(parentRTindex);
  	foreach(lc, root->append_rel_list)
  	{
  		AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(lc);
*************** inheritance_planner(PlannerInfo *root)
*** 878,889 ****
  											 appinfo->child_relid);
  	}
  
  	foreach(lc, root->append_rel_list)
  	{
  		AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(lc);
  		PlannerInfo subroot;
  		Plan	   *subplan;
! 		Index		rti;
  
  		/* append_rel_list contains all append rels; ignore others */
  		if (appinfo->parent_relid != parentRTindex)
--- 883,937 ----
  											 appinfo->child_relid);
  	}
  
+ 	/*
+ 	 * Now, generate a bitmapset of the relids of the subquery RTEs, including
+ 	 * security-barrier RTEs that will become subqueries, as just explained.
+ 	 */
+ 	subqueryRTindexes = NULL;
+ 	rti = 1;
+ 	foreach(lc, parse->rtable)
+ 	{
+ 		RangeTblEntry *rte = (RangeTblEntry *) lfirst(lc);
+ 
+ 		if (rte->rtekind == RTE_SUBQUERY ||
+ 			(rte->securityQuals != NIL &&
+ 			 !bms_is_member(rti, resultRTindexes)))
+ 			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;
+ 	foreach(lc, root->append_rel_list)
+ 	{
+ 		AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(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);
+ 	}
+ 
+ 	/*
+ 	 * And now we can get on with generating a plan for each child table.
+ 	 */
  	foreach(lc, root->append_rel_list)
  	{
  		AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(lc);
  		PlannerInfo subroot;
  		Plan	   *subplan;
! 		ListCell   *lc2;
  
  		/* append_rel_list contains all append rels; ignore others */
  		if (appinfo->parent_relid != parentRTindex)
*************** inheritance_planner(PlannerInfo *root)
*** 917,925 ****
  		/*
  		 * 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.
  		 */
! 		subroot.append_rel_list = (List *) copyObject(root->append_rel_list);
  
  		/*
  		 * Add placeholders to the child Query's rangetable list to fill the
--- 965,985 ----
  		/*
  		 * 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.
  		 */
! 		subroot.append_rel_list = NIL;
! 		foreach(lc2, root->append_rel_list)
! 		{
! 			AppendRelInfo *appinfo2 = (AppendRelInfo *) lfirst(lc2);
! 
! 			if (bms_is_member(appinfo2->child_relid, modifiableARIindexes))
! 				appinfo2 = (AppendRelInfo *) copyObject(appinfo2);
! 
! 			subroot.append_rel_list = lappend(subroot.append_rel_list,
! 											  appinfo2);
! 		}
  
  		/*
  		 * Add placeholders to the child Query's rangetable list to fill the
*************** inheritance_planner(PlannerInfo *root)
*** 933,945 ****
  
  		/*
  		 * 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)
  		{
  			ListCell   *lr;
  
--- 993,1005 ----
  
  		/*
  		 * If this isn't the first child Query, generate duplicates of all
! 		 * subquery (or subquery-to-be) 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 && !bms_is_empty(subqueryRTindexes))
  		{
  			ListCell   *lr;
  
*************** inheritance_planner(PlannerInfo *root)
*** 948,961 ****
  			{
  				RangeTblEntry *rte = (RangeTblEntry *) lfirst(lr);
  
! 				/*
! 				 * Copy subquery RTEs and RTEs with security barrier quals
! 				 * that will be turned into subqueries, except those that are
! 				 * target relations.
! 				 */
! 				if (rte->rtekind == RTE_SUBQUERY ||
! 					(rte->securityQuals != NIL &&
! 					 !bms_is_member(rti, resultRTindexes)))
  				{
  					Index		newrti;
  
--- 1008,1014 ----
  			{
  				RangeTblEntry *rte = (RangeTblEntry *) lfirst(lr);
  
! 				if (bms_is_member(rti, subqueryRTindexes))
  				{
  					Index		newrti;
  
*************** inheritance_planner(PlannerInfo *root)
*** 968,974 ****
  					newrti = list_length(subroot.parse->rtable) + 1;
  					ChangeVarNodes((Node *) subroot.parse, rti, newrti, 0);
  					ChangeVarNodes((Node *) subroot.rowMarks, rti, newrti, 0);
! 					ChangeVarNodes((Node *) subroot.append_rel_list, rti, newrti, 0);
  					rte = copyObject(rte);
  					ChangeVarNodes((Node *) rte->securityQuals, rti, newrti, 0);
  					subroot.parse->rtable = lappend(subroot.parse->rtable,
--- 1021,1033 ----
  					newrti = list_length(subroot.parse->rtable) + 1;
  					ChangeVarNodes((Node *) subroot.parse, rti, newrti, 0);
  					ChangeVarNodes((Node *) subroot.rowMarks, rti, newrti, 0);
! 					foreach(lc2, subroot.append_rel_list)
! 					{
! 						AppendRelInfo *appinfo2 = (AppendRelInfo *) lfirst(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,