expanding inheritance in partition bound order

From f511186bfc3be54ce77b27541695c4c609a877a6 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Mon, 24 Jul 2017 18:59:57 +0900
Subject: [PATCH 1/5] Decouple RelationGetPartitionDispatchInfo() from executor

Currently it and the structure it generates viz. PartitionDispatch
objects are too coupled with the executor's tuple-routing code.  In
particular, it's pretty undesirable that it makes it the responsibility
of the caller to release some resources, such as relcache references
and tuple table slots.  That makes it harder to use in places other
than where it's currently being used.

After this refactoring, ExecSetupPartitionTupleRouting() now needs to
do some of the work that was previously done in
RelationGetPartitionDispatchInfo() and get_all_partition_oids() no
longer needs to do some things that it used to.
---
 src/backend/catalog/partition.c        | 324 +++++++++++++++++----------------
 src/backend/commands/copy.c            |  35 ++--
 src/backend/executor/execMain.c        | 158 ++++++++++++++--
 src/backend/executor/nodeModifyTable.c |  29 ++-
 src/include/catalog/partition.h        |  53 ++----
 src/include/executor/executor.h        |   4 +-
 src/include/nodes/execnodes.h          |  53 +++++-
 7 files changed, 409 insertions(+), 247 deletions(-)

diff --git a/src/backend/catalog/partition.c b/src/backend/catalog/partition.c
index dcc7f8af27..3d72d08c35 100644
--- a/src/backend/catalog/partition.c
+++ b/src/backend/catalog/partition.c
@@ -105,6 +105,24 @@ typedef struct PartitionRangeBound
 	bool		lower;			/* this is the lower (vs upper) bound */
 } PartitionRangeBound;
 
+/*-----------------------
+ * PartitionDispatchData - information of partitions of one partitioned table
+ *						   in a partition tree
+ *
+ *	partkey		Partition key of the table
+ *	partdesc	Partition descriptor of the table
+ *	indexes		Array with partdesc->nparts members (for details on what the
+ *				individual value represents, see the comments in
+ *				RelationGetPartitionDispatchInfo())
+ *-----------------------
+ */
+typedef struct PartitionDispatchData
+{
+	PartitionKey	partkey;	/* Points into the table's relcache entry */
+	PartitionDesc	partdesc;	/* Ditto */
+	int			   *indexes;
+} PartitionDispatchData;
+
 static int32 qsort_partition_list_value_cmp(const void *a, const void *b,
 							   void *arg);
 static int32 qsort_partition_rbound_cmp(const void *a, const void *b,
@@ -976,178 +994,167 @@ get_partition_qual_relid(Oid relid)
 }
 
 /*
- * Append OIDs of rel's partitions to the list 'partoids' and for each OID,
- * append pointer rel to the list 'parents'.
- */
-#define APPEND_REL_PARTITION_OIDS(rel, partoids, parents) \
-	do\
-	{\
-		int		i;\
-		for (i = 0; i < (rel)->rd_partdesc->nparts; i++)\
-		{\
-			(partoids) = lappend_oid((partoids), (rel)->rd_partdesc->oids[i]);\
-			(parents) = lappend((parents), (rel));\
-		}\
-	} while(0)
-
-/*
  * RelationGetPartitionDispatchInfo
- *		Returns information necessary to route tuples down a partition tree
+ *		Returns necessary information for each partition in the partition
+ *		tree rooted at rel
  *
- * All the partitions will be locked with lockmode, unless it is NoLock.
- * A list of the OIDs of all the leaf partitions of rel is returned in
- * *leaf_part_oids.
+ * Information returned includes the following: *ptinfos contains a list of
+ * PartitionedTableInfo objects, one for each partitioned table (with at least
+ * one member, that is, one for the root partitioned table), *leaf_part_oids
+ * contains a list of the OIDs of of all the leaf partitions.
+ *
+ * Note that we lock only those partitions that are partitioned tables, because
+ * we need to look at its relcache entry to get its PartitionKey and its
+ * PartitionDesc. It's the caller's responsibility to lock the leaf partitions
+ * that will actually be accessed during a given query.
  */
-PartitionDispatch *
+void
 RelationGetPartitionDispatchInfo(Relation rel, int lockmode,
-								 int *num_parted, List **leaf_part_oids)
+								 List **ptinfos, List **leaf_part_oids)
 {
-	PartitionDispatchData **pd;
-	List	   *all_parts = NIL,
-			   *all_parents = NIL,
-			   *parted_rels,
-			   *parted_rel_parents;
+	List	   *all_parts,
+			   *all_parents;
 	ListCell   *lc1,
 			   *lc2;
 	int			i,
-				k,
 				offset;
 
 	/*
-	 * Lock partitions and make a list of the partitioned ones to prepare
-	 * their PartitionDispatch objects below.
+	 * We rely on the relcache to traverse the partition tree, building
+	 * both the leaf partition OIDs list and the PartitionedTableInfo list.
+	 * Starting with the root partitioned table for which we already have the
+	 * relcache entry, we look at its partition descriptor to get the
+	 * partition OIDs.  For partitions that are themselves partitioned tables,
+	 * we get their relcache entries after locking them with lockmode and
+	 * queue their partitions to be looked at later.  Leaf partitions are
+	 * added to the result list without locking.  For each partitioned table,
+	 * we build a PartitionedTableInfo object and add it to the other result
+	 * list.
 	 *
-	 * Cannot use find_all_inheritors() here, because then the order of OIDs
-	 * in parted_rels list would be unknown, which does not help, because we
-	 * assign indexes within individual PartitionDispatch in an order that is
-	 * predetermined (determined by the order of OIDs in individual partition
-	 * descriptors).
+	 * Since RelationBuildPartitionDescriptor() puts partitions in a canonical
+	 * order determined by comparing partition bounds, we can rely that
+	 * concurrent backends see the partitions in the same order, ensuring that
+	 * there are no deadlocks when locking the partitions.
 	 */
-	*num_parted = 1;
-	parted_rels = list_make1(rel);
-	/* Root partitioned table has no parent, so NULL for parent */
-	parted_rel_parents = list_make1(NULL);
-	APPEND_REL_PARTITION_OIDS(rel, all_parts, all_parents);
+	i = offset = 0;
+	*ptinfos = *leaf_part_oids = NIL;
+
+	/* Start with the root table. */
+	all_parts = list_make1_oid(RelationGetRelid(rel));
+	all_parents = list_make1_oid(InvalidOid);
 	forboth(lc1, all_parts, lc2, all_parents)
 	{
-		Relation	partrel = heap_open(lfirst_oid(lc1), lockmode);
-		Relation	parent = lfirst(lc2);
-		PartitionDesc partdesc = RelationGetPartitionDesc(partrel);
+		Oid		partrelid = lfirst_oid(lc1);
+		Oid		parentrelid = lfirst_oid(lc2);
 
-		/*
-		 * If this partition is a partitioned table, add its children to the
-		 * end of the list, so that they are processed as well.
-		 */
-		if (partdesc)
+		if (get_rel_relkind(partrelid) == RELKIND_PARTITIONED_TABLE)
 		{
-			(*num_parted)++;
-			parted_rels = lappend(parted_rels, partrel);
-			parted_rel_parents = lappend(parted_rel_parents, parent);
-			APPEND_REL_PARTITION_OIDS(partrel, all_parts, all_parents);
-		}
-		else
-			heap_close(partrel, NoLock);
+			int		j,
+					k;
+			Relation		partrel;
+			PartitionKey	partkey;
+			PartitionDesc	partdesc;
+			PartitionedTableInfo   *ptinfo;
+			PartitionDispatch		pd;
+
+			if (partrelid != RelationGetRelid(rel))
+				partrel = heap_open(partrelid, lockmode);
+			else
+				partrel = rel;
 
-		/*
-		 * We keep the partitioned ones open until we're done using the
-		 * information being collected here (for example, see
-		 * ExecEndModifyTable).
-		 */
-	}
+			partkey = RelationGetPartitionKey(partrel);
+			partdesc = RelationGetPartitionDesc(partrel);
+
+			ptinfo = (PartitionedTableInfo *)
+									palloc0(sizeof(PartitionedTableInfo));
+			ptinfo->relid = partrelid;
+			ptinfo->parentid = parentrelid;
+
+			ptinfo->pd = pd = (PartitionDispatchData *)
+									palloc0(sizeof(PartitionDispatchData));
+			pd->partkey = partkey;
 
-	/*
-	 * We want to create two arrays - one for leaf partitions and another for
-	 * partitioned tables (including the root table and internal partitions).
-	 * While we only create the latter here, leaf partition array of suitable
-	 * objects (such as, ResultRelInfo) is created by the caller using the
-	 * list of OIDs we return.  Indexes into these arrays get assigned in a
-	 * breadth-first manner, whereby partitions of any given level are placed
-	 * consecutively in the respective arrays.
-	 */
-	pd = (PartitionDispatchData **) palloc(*num_parted *
-										   sizeof(PartitionDispatchData *));
-	*leaf_part_oids = NIL;
-	i = k = offset = 0;
-	forboth(lc1, parted_rels, lc2, parted_rel_parents)
-	{
-		Relation	partrel = lfirst(lc1);
-		Relation	parent = lfirst(lc2);
-		PartitionKey partkey = RelationGetPartitionKey(partrel);
-		TupleDesc	tupdesc = RelationGetDescr(partrel);
-		PartitionDesc partdesc = RelationGetPartitionDesc(partrel);
-		int			j,
-					m;
-
-		pd[i] = (PartitionDispatch) palloc(sizeof(PartitionDispatchData));
-		pd[i]->reldesc = partrel;
-		pd[i]->key = partkey;
-		pd[i]->keystate = NIL;
-		pd[i]->partdesc = partdesc;
-		if (parent != NULL)
-		{
 			/*
-			 * For every partitioned table other than root, we must store a
-			 * tuple table slot initialized with its tuple descriptor and a
-			 * tuple conversion map to convert a tuple from its parent's
-			 * rowtype to its own. That is to make sure that we are looking at
-			 * the correct row using the correct tuple descriptor when
-			 * computing its partition key for tuple routing.
+			 * XXX- do we need a pinning mechanism for partition descriptors
+			 * so that there references can be managed independently of
+			 * the parent relcache entry? Like PinPartitionDesc(partdesc)?
 			 */
-			pd[i]->tupslot = MakeSingleTupleTableSlot(tupdesc);
-			pd[i]->tupmap = convert_tuples_by_name(RelationGetDescr(parent),
-												   tupdesc,
-												   gettext_noop("could not convert row type"));
-		}
-		else
-		{
-			/* Not required for the root partitioned table */
-			pd[i]->tupslot = NULL;
-			pd[i]->tupmap = NULL;
-		}
-		pd[i]->indexes = (int *) palloc(partdesc->nparts * sizeof(int));
+			pd->partdesc = partdesc;
 
-		/*
-		 * Indexes corresponding to the internal partitions are multiplied by
-		 * -1 to distinguish them from those of leaf partitions.  Encountering
-		 * an index >= 0 means we found a leaf partition, which is immediately
-		 * returned as the partition we are looking for.  A negative index
-		 * means we found a partitioned table, whose PartitionDispatch object
-		 * is located at the above index multiplied back by -1.  Using the
-		 * PartitionDispatch object, search is continued further down the
-		 * partition tree.
-		 */
-		m = 0;
-		for (j = 0; j < partdesc->nparts; j++)
-		{
-			Oid			partrelid = partdesc->oids[j];
+			/*
+			 * The values contained in the following array correspond to
+			 * indexes of this table's partitions in the global sequence of
+			 * all the partitions contained in the partition tree rooted at
+			 * rel, traversed in a breadh-first manner.  The values should be
+			 * such that we will be able to distinguish the leaf partitions
+			 * from the non-leaf partitions, because they are returned to
+			 * to the caller in separate structures from where they will be
+			 * accessed.  The way that's done is described below:
+			 *
+			 * Leaf partition OIDs are put into the global leaf_part_oids list,
+			 * and for each one, the value stored is its ordinal position in
+			 * the list minus 1.
+			 *
+			 * PartitionedTableInfo objects corresponding to partitions that
+			 * are partitioned tables are put into the global ptinfos[] list,
+			 * and for each one, the value stored is its ordinal position in
+			 * the list multiplied by -1.
+			 *
+			 * So while looking at the values in the indexes array, if one
+			 * gets zero or a positive value, then it's a leaf partition,
+			 * Otherwise, it's a partitioned table.
+			 */
+			pd->indexes = (int *) palloc(partdesc->nparts * sizeof(int));
 
-			if (get_rel_relkind(partrelid) != RELKIND_PARTITIONED_TABLE)
-			{
-				*leaf_part_oids = lappend_oid(*leaf_part_oids, partrelid);
-				pd[i]->indexes[j] = k++;
-			}
-			else
+			k = 0;
+			for (j = 0; j < partdesc->nparts; j++)
 			{
+				Oid			partrelid = partdesc->oids[j];
+
 				/*
-				 * offset denotes the number of partitioned tables of upper
-				 * levels including those of the current level.  Any partition
-				 * of this table must belong to the next level and hence will
-				 * be placed after the last partitioned table of this level.
+				 * Queue this partition so that it will be processed later
+				 * by the outer loop.
 				 */
-				pd[i]->indexes[j] = -(1 + offset + m);
-				m++;
+				all_parts = lappend_oid(all_parts, partrelid);
+				all_parents = lappend_oid(all_parents,
+										  RelationGetRelid(partrel));
+
+				if (get_rel_relkind(partrelid) != RELKIND_PARTITIONED_TABLE)
+				{
+					*leaf_part_oids = lappend_oid(*leaf_part_oids, partrelid);
+					pd->indexes[j] = i++;
+				}
+				else
+				{
+					/*
+					 * offset denotes the number of partitioned tables that
+					 * we have already processed.  k counts the number of
+					 * partitions of this table that were found to be
+					 * partitioned tables.
+					 */
+					pd->indexes[j] = -(1 + offset + k);
+					k++;
+				}
 			}
-		}
-		i++;
 
-		/*
-		 * This counts the number of partitioned tables at upper levels
-		 * including those of the current level.
-		 */
-		offset += m;
+			offset += k;
+
+			/*
+			 * Release the relation descriptor.  Lock that we have on the
+			 * table will keep the PartitionDesc that is pointing into
+			 * RelationData intact, a pointer to which hope to keep
+			 * through this transaction's commit.
+			 * (XXX - how true is that?)
+			 */
+			if (partrel != rel)
+				heap_close(partrel, NoLock);
+
+			*ptinfos = lappend(*ptinfos, ptinfo);
+		}
 	}
 
-	return pd;
+	Assert(i == list_length(*leaf_part_oids));
+	Assert((offset + 1) == list_length(*ptinfos));
 }
 
 /* Module-local functions */
@@ -1864,7 +1871,7 @@ generate_partition_qual(Relation rel)
  * ----------------
  */
 void
-FormPartitionKeyDatum(PartitionDispatch pd,
+FormPartitionKeyDatum(PartitionKeyInfo *keyinfo,
 					  TupleTableSlot *slot,
 					  EState *estate,
 					  Datum *values,
@@ -1873,20 +1880,21 @@ FormPartitionKeyDatum(PartitionDispatch pd,
 	ListCell   *partexpr_item;
 	int			i;
 
-	if (pd->key->partexprs != NIL && pd->keystate == NIL)
+	if (keyinfo->key->partexprs != NIL && keyinfo->keystate == NIL)
 	{
 		/* Check caller has set up context correctly */
 		Assert(estate != NULL &&
 			   GetPerTupleExprContext(estate)->ecxt_scantuple == slot);
 
 		/* First time through, set up expression evaluation state */
-		pd->keystate = ExecPrepareExprList(pd->key->partexprs, estate);
+		keyinfo->keystate = ExecPrepareExprList(keyinfo->key->partexprs,
+												estate);
 	}
 
-	partexpr_item = list_head(pd->keystate);
-	for (i = 0; i < pd->key->partnatts; i++)
+	partexpr_item = list_head(keyinfo->keystate);
+	for (i = 0; i < keyinfo->key->partnatts; i++)
 	{
-		AttrNumber	keycol = pd->key->partattrs[i];
+		AttrNumber	keycol = keyinfo->key->partattrs[i];
 		Datum		datum;
 		bool		isNull;
 
@@ -1923,13 +1931,13 @@ FormPartitionKeyDatum(PartitionDispatch pd,
  * the latter case.
  */
 int
-get_partition_for_tuple(PartitionDispatch *pd,
+get_partition_for_tuple(PartitionTupleRoutingInfo **ptrinfos,
 						TupleTableSlot *slot,
 						EState *estate,
-						PartitionDispatchData **failed_at,
+						PartitionTupleRoutingInfo **failed_at,
 						TupleTableSlot **failed_slot)
 {
-	PartitionDispatch parent;
+	PartitionTupleRoutingInfo *parent;
 	Datum		values[PARTITION_MAX_KEYS];
 	bool		isnull[PARTITION_MAX_KEYS];
 	int			cur_offset,
@@ -1940,11 +1948,11 @@ get_partition_for_tuple(PartitionDispatch *pd,
 	TupleTableSlot *ecxt_scantuple_old = ecxt->ecxt_scantuple;
 
 	/* start with the root partitioned table */
-	parent = pd[0];
+	parent = ptrinfos[0];
 	while (true)
 	{
-		PartitionKey key = parent->key;
-		PartitionDesc partdesc = parent->partdesc;
+		PartitionKey  key = parent->pd->partkey;
+		PartitionDesc partdesc = parent->pd->partdesc;
 		TupleTableSlot *myslot = parent->tupslot;
 		TupleConversionMap *map = parent->tupmap;
 
@@ -1976,7 +1984,7 @@ get_partition_for_tuple(PartitionDispatch *pd,
 		 * So update ecxt_scantuple accordingly.
 		 */
 		ecxt->ecxt_scantuple = slot;
-		FormPartitionKeyDatum(parent, slot, estate, values, isnull);
+		FormPartitionKeyDatum(parent->keyinfo, slot, estate, values, isnull);
 
 		if (key->strategy == PARTITION_STRATEGY_RANGE)
 		{
@@ -2047,13 +2055,13 @@ get_partition_for_tuple(PartitionDispatch *pd,
 			*failed_slot = slot;
 			break;
 		}
-		else if (parent->indexes[cur_index] >= 0)
+		else if (parent->pd->indexes[cur_index] >= 0)
 		{
-			result = parent->indexes[cur_index];
+			result = parent->pd->indexes[cur_index];
 			break;
 		}
 		else
-			parent = pd[-parent->indexes[cur_index]];
+			parent = ptrinfos[-parent->pd->indexes[cur_index]];
 	}
 
 error_exit:
diff --git a/src/backend/commands/copy.c b/src/backend/commands/copy.c
index 53e296559a..b3de3de454 100644
--- a/src/backend/commands/copy.c
+++ b/src/backend/commands/copy.c
@@ -165,8 +165,8 @@ typedef struct CopyStateData
 	bool		volatile_defexprs;	/* is any of defexprs volatile? */
 	List	   *range_table;
 
-	PartitionDispatch *partition_dispatch_info;
-	int			num_dispatch;	/* Number of entries in the above array */
+	PartitionTupleRoutingInfo **ptrinfos;
+	int			num_parted;		/* Number of entries in the above array */
 	int			num_partitions; /* Number of members in the following arrays */
 	ResultRelInfo *partitions;	/* Per partition result relation */
 	TupleConversionMap **partition_tupconv_maps;
@@ -1425,7 +1425,7 @@ BeginCopy(ParseState *pstate,
 		/* Initialize state for CopyFrom tuple routing. */
 		if (is_from && rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
 		{
-			PartitionDispatch *partition_dispatch_info;
+			PartitionTupleRoutingInfo **ptrinfos;
 			ResultRelInfo *partitions;
 			TupleConversionMap **partition_tupconv_maps;
 			TupleTableSlot *partition_tuple_slot;
@@ -1434,13 +1434,13 @@ BeginCopy(ParseState *pstate,
 
 			ExecSetupPartitionTupleRouting(rel,
 										   1,
-										   &partition_dispatch_info,
+										   &ptrinfos,
 										   &partitions,
 										   &partition_tupconv_maps,
 										   &partition_tuple_slot,
 										   &num_parted, &num_partitions);
-			cstate->partition_dispatch_info = partition_dispatch_info;
-			cstate->num_dispatch = num_parted;
+			cstate->ptrinfos = ptrinfos;
+			cstate->num_parted = num_parted;
 			cstate->partitions = partitions;
 			cstate->num_partitions = num_partitions;
 			cstate->partition_tupconv_maps = partition_tupconv_maps;
@@ -2495,7 +2495,7 @@ CopyFrom(CopyState cstate)
 	if ((resultRelInfo->ri_TrigDesc != NULL &&
 		 (resultRelInfo->ri_TrigDesc->trig_insert_before_row ||
 		  resultRelInfo->ri_TrigDesc->trig_insert_instead_row)) ||
-		cstate->partition_dispatch_info != NULL ||
+		cstate->ptrinfos != NULL ||
 		cstate->volatile_defexprs)
 	{
 		useHeapMultiInsert = false;
@@ -2573,7 +2573,7 @@ CopyFrom(CopyState cstate)
 		ExecStoreTuple(tuple, slot, InvalidBuffer, false);
 
 		/* Determine the partition to heap_insert the tuple into */
-		if (cstate->partition_dispatch_info)
+		if (cstate->ptrinfos)
 		{
 			int			leaf_part_index;
 			TupleConversionMap *map;
@@ -2587,7 +2587,7 @@ CopyFrom(CopyState cstate)
 			 * partition, respectively.
 			 */
 			leaf_part_index = ExecFindPartition(resultRelInfo,
-												cstate->partition_dispatch_info,
+												cstate->ptrinfos,
 												slot,
 												estate);
 			Assert(leaf_part_index >= 0 &&
@@ -2818,23 +2818,20 @@ CopyFrom(CopyState cstate)
 
 	ExecCloseIndices(resultRelInfo);
 
-	/* Close all the partitioned tables, leaf partitions, and their indices */
-	if (cstate->partition_dispatch_info)
+	/* Close all the leaf partitions and their indices */
+	if (cstate->ptrinfos)
 	{
 		int			i;
 
 		/*
-		 * Remember cstate->partition_dispatch_info[0] corresponds to the root
-		 * partitioned table, which we must not try to close, because it is
-		 * the main target table of COPY that will be closed eventually by
-		 * DoCopy().  Also, tupslot is NULL for the root partitioned table.
+		 * cstate->ptrinfo[0] corresponds to the root partitioned table, for
+		 * which we didn't create tupslot.
 		 */
-		for (i = 1; i < cstate->num_dispatch; i++)
+		for (i = 1; i < cstate->num_parted; i++)
 		{
-			PartitionDispatch pd = cstate->partition_dispatch_info[i];
+			PartitionTupleRoutingInfo *ptrinfo = cstate->ptrinfos[i];
 
-			heap_close(pd->reldesc, NoLock);
-			ExecDropSingleTupleTableSlot(pd->tupslot);
+			ExecDropSingleTupleTableSlot(ptrinfo->tupslot);
 		}
 		for (i = 0; i < cstate->num_partitions; i++)
 		{
diff --git a/src/backend/executor/execMain.c b/src/backend/executor/execMain.c
index c11aa4fe21..0379e489d9 100644
--- a/src/backend/executor/execMain.c
+++ b/src/backend/executor/execMain.c
@@ -3214,8 +3214,8 @@ EvalPlanQualEnd(EPQState *epqstate)
  * tuple routing for partitioned tables
  *
  * Output arguments:
- * 'pd' receives an array of PartitionDispatch objects with one entry for
- *		every partitioned table in the partition tree
+ * 'ptrinfos' receives an array of PartitionTupleRoutingInfo objects with one
+ *		entry for each partitioned table in the partition tree
  * 'partitions' receives an array of ResultRelInfo objects with one entry for
  *		every leaf partition in the partition tree
  * 'tup_conv_maps' receives an array of TupleConversionMap objects with one
@@ -3237,7 +3237,7 @@ EvalPlanQualEnd(EPQState *epqstate)
 void
 ExecSetupPartitionTupleRouting(Relation rel,
 							   Index resultRTindex,
-							   PartitionDispatch **pd,
+							   PartitionTupleRoutingInfo ***ptrinfos,
 							   ResultRelInfo **partitions,
 							   TupleConversionMap ***tup_conv_maps,
 							   TupleTableSlot **partition_tuple_slot,
@@ -3245,13 +3245,135 @@ ExecSetupPartitionTupleRouting(Relation rel,
 {
 	TupleDesc	tupDesc = RelationGetDescr(rel);
 	List	   *leaf_parts;
+	List	   *ptinfos = NIL;
 	ListCell   *cell;
 	int			i;
 	ResultRelInfo *leaf_part_rri;
+	Relation	parent;
 
-	/* Get the tuple-routing information and lock partitions */
-	*pd = RelationGetPartitionDispatchInfo(rel, RowExclusiveLock, num_parted,
-										   &leaf_parts);
+	/*
+	 * Get information about the partition tree.  All the partitioned
+	 * tables in the tree are locked, but not the leaf partitions.  We
+	 * lock them while building their ResultRelInfos below.
+	 */
+	RelationGetPartitionDispatchInfo(rel, RowExclusiveLock,
+									 &ptinfos, &leaf_parts);
+
+	/*
+	 * The ptinfos list contains PartitionedTableInfo objects for all the
+	 * partitioned tables in the partition tree.  Using the information
+	 * therein, we construct an array of PartitionTupleRoutingInfo objects
+	 * to be used during tuple-routing.
+	 */
+	*num_parted = list_length(ptinfos);
+	*ptrinfos = (PartitionTupleRoutingInfo **) palloc0(*num_parted *
+										sizeof(PartitionTupleRoutingInfo *));
+	/*
+	 * Free the ptinfos List structure itself as we go through (open-coded
+	 * list_free).
+	 */
+	i = 0;
+	cell = list_head(ptinfos);
+	parent = NULL;
+	while (cell)
+	{
+		ListCell   *tmp = cell;
+		PartitionedTableInfo *ptinfo = lfirst(tmp),
+							 *next_ptinfo;
+		Relation		partrel;
+		PartitionTupleRoutingInfo *ptrinfo;
+
+		if (lnext(tmp))
+			next_ptinfo = lfirst(lnext(tmp));
+
+		/* As mentioned above, the partitioned tables have been locked. */
+		if (ptinfo->relid != RelationGetRelid(rel))
+			partrel = heap_open(ptinfo->relid, NoLock);
+		else
+			partrel = rel;
+
+		ptrinfo = (PartitionTupleRoutingInfo *)
+							palloc0(sizeof(PartitionTupleRoutingInfo));
+		ptrinfo->relid = ptinfo->relid;
+
+		/* Stash a reference to this PartitionDispatch. */
+		ptrinfo->pd = ptinfo->pd;
+
+		/* State for extracting partition key from tuples will go here. */
+		ptrinfo->keyinfo = (PartitionKeyInfo *)
+								palloc0(sizeof(PartitionKeyInfo));
+		ptrinfo->keyinfo->key = RelationGetPartitionKey(partrel);
+		ptrinfo->keyinfo->keystate = NIL;
+
+		/*
+		 * For every partitioned table other than root, we must store a tuple
+		 * table slot initialized with its tuple descriptor and a tuple
+		 * conversion map to convert a tuple from its parent's rowtype to its
+		 * own.  That is to make sure that we are looking at the correct row
+		 * using the correct tuple descriptor when computing its partition key
+		 * for tuple routing.
+		 */
+		if (ptinfo->parentid != InvalidOid)
+		{
+			TupleDesc	tupdesc = RelationGetDescr(partrel);
+
+			/* Open the parent relation descriptor if not already done. */
+			if (ptinfo->parentid == RelationGetRelid(rel))
+			{
+				parent = rel;
+			}
+			else if (parent == NULL)
+			{
+				/* Locked by RelationGetPartitionDispatchInfo(). */
+				parent = heap_open(ptinfo->parentid, NoLock);
+			}
+
+			ptrinfo->tupslot = MakeSingleTupleTableSlot(tupdesc);
+			ptrinfo->tupmap = convert_tuples_by_name(RelationGetDescr(parent),
+													 tupdesc,
+								  gettext_noop("could not convert row type"));
+
+			/*
+			 * Close the parent descriptor, if the next partitioned table in
+			 * the list is not a sibling, because it will have a different
+			 * parent if so.
+			 */
+			if (parent && parent != rel &&
+				next_ptinfo->parentid != ptinfo->parentid)
+			{
+				heap_close(parent, NoLock);
+				parent = NULL;
+			}
+
+			/*
+			 * Release the relation descriptor.  Lock that we have on the
+			 * table will keep the PartitionDesc that is pointing into
+			 * RelationData intact, a pointer to which hope to keep
+			 * through this transaction's commit.
+			 * (XXX - how true is that?)
+			 */
+			if (partrel != rel)
+				heap_close(partrel, NoLock);
+		}
+		else
+		{
+			/* Not required for the root partitioned table */
+			ptrinfo->tupslot = NULL;
+			ptrinfo->tupmap = NULL;
+		}
+
+		(*ptrinfos)[i++] = ptrinfo;
+
+		/* Free the ListCell. */
+		cell = lnext(cell);
+		pfree(tmp);
+	}
+
+	/* Free the List itself. */
+	if (ptinfos)
+		pfree(ptinfos);
+
+	/* For leaf partitions, we build ResultRelInfos and TupleConversionMaps. */
 	*num_partitions = list_length(leaf_parts);
 	*partitions = (ResultRelInfo *) palloc(*num_partitions *
 										   sizeof(ResultRelInfo));
@@ -3274,11 +3396,11 @@ ExecSetupPartitionTupleRouting(Relation rel,
 		TupleDesc	part_tupdesc;
 
 		/*
-		 * We locked all the partitions above including the leaf partitions.
-		 * Note that each of the relations in *partitions are eventually
-		 * closed by the caller.
+		 * RelationGetPartitionDispatchInfo didn't lock the leaf partitions,
+		 * so lock here.  Note that each of the relations in *partitions are
+		 * eventually closed (when the plan is shut down, for instance).
 		 */
-		partrel = heap_open(lfirst_oid(cell), NoLock);
+		partrel = heap_open(lfirst_oid(cell), RowExclusiveLock);
 		part_tupdesc = RelationGetDescr(partrel);
 
 		/*
@@ -3291,7 +3413,7 @@ ExecSetupPartitionTupleRouting(Relation rel,
 		 * partition from the parent's type to the partition's.
 		 */
 		(*tup_conv_maps)[i] = convert_tuples_by_name(tupDesc, part_tupdesc,
-													 gettext_noop("could not convert row type"));
+								 gettext_noop("could not convert row type"));
 
 		InitResultRelInfo(leaf_part_rri,
 						  partrel,
@@ -3325,11 +3447,13 @@ ExecSetupPartitionTupleRouting(Relation rel,
  * by get_partition_for_tuple() unchanged.
  */
 int
-ExecFindPartition(ResultRelInfo *resultRelInfo, PartitionDispatch *pd,
-				  TupleTableSlot *slot, EState *estate)
+ExecFindPartition(ResultRelInfo *resultRelInfo,
+				  PartitionTupleRoutingInfo **ptrinfos,
+				  TupleTableSlot *slot,
+				  EState *estate)
 {
 	int			result;
-	PartitionDispatchData *failed_at;
+	PartitionTupleRoutingInfo *failed_at;
 	TupleTableSlot *failed_slot;
 
 	/*
@@ -3339,7 +3463,7 @@ ExecFindPartition(ResultRelInfo *resultRelInfo, PartitionDispatch *pd,
 	if (resultRelInfo->ri_PartitionCheck)
 		ExecPartitionCheck(resultRelInfo, slot, estate);
 
-	result = get_partition_for_tuple(pd, slot, estate,
+	result = get_partition_for_tuple(ptrinfos, slot, estate,
 									 &failed_at, &failed_slot);
 	if (result < 0)
 	{
@@ -3349,9 +3473,9 @@ ExecFindPartition(ResultRelInfo *resultRelInfo, PartitionDispatch *pd,
 		char	   *val_desc;
 		ExprContext *ecxt = GetPerTupleExprContext(estate);
 
-		failed_rel = failed_at->reldesc;
+		failed_rel = heap_open(failed_at->relid, NoLock);
 		ecxt->ecxt_scantuple = failed_slot;
-		FormPartitionKeyDatum(failed_at, failed_slot, estate,
+		FormPartitionKeyDatum(failed_at->keyinfo, failed_slot, estate,
 							  key_values, key_isnull);
 		val_desc = ExecBuildSlotPartitionKeyDescription(failed_rel,
 														key_values,
diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c
index 30add8e3c7..00cbee4fb6 100644
--- a/src/backend/executor/nodeModifyTable.c
+++ b/src/backend/executor/nodeModifyTable.c
@@ -277,7 +277,7 @@ ExecInsert(ModifyTableState *mtstate,
 	resultRelInfo = estate->es_result_relation_info;
 
 	/* Determine the partition to heap_insert the tuple into */
-	if (mtstate->mt_partition_dispatch_info)
+	if (mtstate->mt_ptrinfos)
 	{
 		int			leaf_part_index;
 		TupleConversionMap *map;
@@ -291,7 +291,7 @@ ExecInsert(ModifyTableState *mtstate,
 		 * respectively.
 		 */
 		leaf_part_index = ExecFindPartition(resultRelInfo,
-											mtstate->mt_partition_dispatch_info,
+											mtstate->mt_ptrinfos,
 											slot,
 											estate);
 		Assert(leaf_part_index >= 0 &&
@@ -1486,7 +1486,7 @@ ExecSetupTransitionCaptureState(ModifyTableState *mtstate, EState *estate)
 		int		numResultRelInfos;
 
 		/* Find the set of partitions so that we can find their TupleDescs. */
-		if (mtstate->mt_partition_dispatch_info != NULL)
+		if (mtstate->mt_ptrinfos != NULL)
 		{
 			/*
 			 * For INSERT via partitioned table, so we need TupleDescs based
@@ -1910,7 +1910,7 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 	if (operation == CMD_INSERT &&
 		rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
 	{
-		PartitionDispatch *partition_dispatch_info;
+		PartitionTupleRoutingInfo **ptrinfos;
 		ResultRelInfo *partitions;
 		TupleConversionMap **partition_tupconv_maps;
 		TupleTableSlot *partition_tuple_slot;
@@ -1919,13 +1919,13 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 
 		ExecSetupPartitionTupleRouting(rel,
 									   node->nominalRelation,
-									   &partition_dispatch_info,
+									   &ptrinfos,
 									   &partitions,
 									   &partition_tupconv_maps,
 									   &partition_tuple_slot,
 									   &num_parted, &num_partitions);
-		mtstate->mt_partition_dispatch_info = partition_dispatch_info;
-		mtstate->mt_num_dispatch = num_parted;
+		mtstate->mt_ptrinfos = ptrinfos;
+		mtstate->mt_num_parted = num_parted;
 		mtstate->mt_partitions = partitions;
 		mtstate->mt_num_partitions = num_partitions;
 		mtstate->mt_partition_tupconv_maps = partition_tupconv_maps;
@@ -2335,19 +2335,16 @@ ExecEndModifyTable(ModifyTableState *node)
 	}
 
 	/*
-	 * Close all the partitioned tables, leaf partitions, and their indices
+	 * Close all the leaf partitions and their indices.
 	 *
-	 * Remember node->mt_partition_dispatch_info[0] corresponds to the root
-	 * partitioned table, which we must not try to close, because it is the
-	 * main target table of the query that will be closed by ExecEndPlan().
-	 * Also, tupslot is NULL for the root partitioned table.
+	 * node->mt_partition_dispatch_info[0] corresponds to the root partitioned
+	 * table, for which we didn't create tupslot.
 	 */
-	for (i = 1; i < node->mt_num_dispatch; i++)
+	for (i = 1; i < node->mt_num_parted; i++)
 	{
-		PartitionDispatch pd = node->mt_partition_dispatch_info[i];
+		PartitionTupleRoutingInfo *ptrinfo = node->mt_ptrinfos[i];
 
-		heap_close(pd->reldesc, NoLock);
-		ExecDropSingleTupleTableSlot(pd->tupslot);
+		ExecDropSingleTupleTableSlot(ptrinfo->tupslot);
 	}
 	for (i = 0; i < node->mt_num_partitions; i++)
 	{
diff --git a/src/include/catalog/partition.h b/src/include/catalog/partition.h
index 434ded37d7..6a0c81b3bd 100644
--- a/src/include/catalog/partition.h
+++ b/src/include/catalog/partition.h
@@ -39,36 +39,23 @@ typedef struct PartitionDescData
 
 typedef struct PartitionDescData *PartitionDesc;
 
-/*-----------------------
- * PartitionDispatch - information about one partitioned table in a partition
- * hierarchy required to route a tuple to one of its partitions
- *
- *	reldesc		Relation descriptor of the table
- *	key			Partition key information of the table
- *	keystate	Execution state required for expressions in the partition key
- *	partdesc	Partition descriptor of the table
- *	tupslot		A standalone TupleTableSlot initialized with this table's tuple
- *				descriptor
- *	tupmap		TupleConversionMap to convert from the parent's rowtype to
- *				this table's rowtype (when extracting the partition key of a
- *				tuple just before routing it through this table)
- *	indexes		Array with partdesc->nparts members (for details on what
- *				individual members represent, see how they are set in
- *				RelationGetPartitionDispatchInfo())
- *-----------------------
+typedef struct PartitionDispatchData *PartitionDispatch;
+
+/*
+ * Information about one partitioned table in a given partition tree
  */
-typedef struct PartitionDispatchData
+typedef struct PartitionedTableInfo
 {
-	Relation	reldesc;
-	PartitionKey key;
-	List	   *keystate;		/* list of ExprState */
-	PartitionDesc partdesc;
-	TupleTableSlot *tupslot;
-	TupleConversionMap *tupmap;
-	int		   *indexes;
-} PartitionDispatchData;
+	Oid				relid;
+	Oid				parentid;
 
-typedef struct PartitionDispatchData *PartitionDispatch;
+	/*
+	 * This contains information about bounds of the partitions of this
+	 * table and about where individual partitions are placed in the global
+	 * partition tree.
+	 */
+	PartitionDispatch pd;
+} PartitionedTableInfo;
 
 extern void RelationBuildPartitionDesc(Relation relation);
 extern bool partition_bounds_equal(PartitionKey key,
@@ -85,18 +72,18 @@ extern List *map_partition_varattnos(List *expr, int target_varno,
 extern List *RelationGetPartitionQual(Relation rel);
 extern Expr *get_partition_qual_relid(Oid relid);
 
+extern void RelationGetPartitionDispatchInfo(Relation rel, int lockmode,
+								 List **ptinfos, List **leaf_part_oids);
+
 /* For tuple routing */
-extern PartitionDispatch *RelationGetPartitionDispatchInfo(Relation rel,
-								 int lockmode, int *num_parted,
-								 List **leaf_part_oids);
-extern void FormPartitionKeyDatum(PartitionDispatch pd,
+extern void FormPartitionKeyDatum(PartitionKeyInfo *keyinfo,
 					  TupleTableSlot *slot,
 					  EState *estate,
 					  Datum *values,
 					  bool *isnull);
-extern int get_partition_for_tuple(PartitionDispatch *pd,
+extern int get_partition_for_tuple(PartitionTupleRoutingInfo **pd,
 						TupleTableSlot *slot,
 						EState *estate,
-						PartitionDispatchData **failed_at,
+						PartitionTupleRoutingInfo **failed_at,
 						TupleTableSlot **failed_slot);
 #endif							/* PARTITION_H */
diff --git a/src/include/executor/executor.h b/src/include/executor/executor.h
index 60326f9d03..6e1d3a6d2f 100644
--- a/src/include/executor/executor.h
+++ b/src/include/executor/executor.h
@@ -208,13 +208,13 @@ extern void EvalPlanQualSetTuple(EPQState *epqstate, Index rti,
 extern HeapTuple EvalPlanQualGetTuple(EPQState *epqstate, Index rti);
 extern void ExecSetupPartitionTupleRouting(Relation rel,
 							   Index resultRTindex,
-							   PartitionDispatch **pd,
+							   PartitionTupleRoutingInfo ***ptrinfos,
 							   ResultRelInfo **partitions,
 							   TupleConversionMap ***tup_conv_maps,
 							   TupleTableSlot **partition_tuple_slot,
 							   int *num_parted, int *num_partitions);
 extern int ExecFindPartition(ResultRelInfo *resultRelInfo,
-				  PartitionDispatch *pd,
+				  PartitionTupleRoutingInfo **ptrinfos,
 				  TupleTableSlot *slot,
 				  EState *estate);
 
diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h
index 35c28a6143..1514d62f52 100644
--- a/src/include/nodes/execnodes.h
+++ b/src/include/nodes/execnodes.h
@@ -414,6 +414,55 @@ typedef struct ResultRelInfo
 	Relation	ri_PartitionRoot;
 } ResultRelInfo;
 
+/* Forward declarations, to avoid including other headers */
+typedef struct PartitionKeyData *PartitionKey;
+typedef struct PartitionDispatchData *PartitionDispatch;
+
+/*
+ * PartitionKeyInfoData - execution state for the partition key of a
+ *						  partitioned table
+ *
+ * keystate is the execution state required for expressions contained in the
+ * partition key.  It is NIL until initialized by FormPartitionKeyDatum() if
+ * and when it is called; for example, during tuple routing through a given
+ * partitioned table.
+ */
+typedef struct PartitionKeyInfo
+{
+	PartitionKey	key;		/* Points into the table's relcache entry */
+	List		   *keystate;
+} PartitionKeyInfo;
+
+/*
+ * PartitionTupleRoutingInfo - information required for tuple-routing
+ *							   through one partitioned table in a partition
+ *							   tree
+ */
+typedef struct PartitionTupleRoutingInfo
+{
+	/* OID of the table */
+	Oid				relid;
+
+	/* Information about the table's partitions */
+	PartitionDispatch	pd;
+
+	/* See comment above the definition of PartitionKeyInfo */
+	PartitionKeyInfo   *keyinfo;
+
+	/*
+	 * A standalone TupleTableSlot initialized with this table's tuple
+	 * descriptor
+	 */
+	TupleTableSlot *tupslot;
+
+	/*
+	 * TupleConversionMap to convert from the parent's rowtype to this table's
+	 * rowtype (when extracting the partition key of a tuple just before
+	 * routing it through this table)
+	 */
+	TupleConversionMap *tupmap;
+} PartitionTupleRoutingInfo;
+
 /* ----------------
  *	  EState information
  *
@@ -970,9 +1019,9 @@ typedef struct ModifyTableState
 	TupleTableSlot *mt_existing;	/* slot to store existing target tuple in */
 	List	   *mt_excludedtlist;	/* the excluded pseudo relation's tlist  */
 	TupleTableSlot *mt_conflproj;	/* CONFLICT ... SET ... projection target */
-	struct PartitionDispatchData **mt_partition_dispatch_info;
 	/* Tuple-routing support info */
-	int			mt_num_dispatch;	/* Number of entries in the above array */
+	struct PartitionTupleRoutingInfo **mt_ptrinfos;
+	int			mt_num_parted;		/* Number of entries in the above array */
 	int			mt_num_partitions;	/* Number of members in the following
 									 * arrays */
 	ResultRelInfo *mt_partitions;	/* Per partition result relation */
-- 
2.11.0

From b7ec1ddc2e26e75e0ab092c36461c09e9ca0a9d8 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Tue, 8 Aug 2017 18:42:30 +0900
Subject: [PATCH 2/5] Teach pg_inherits.c a bit about partitioning

Both find_inheritance_children and find_all_inheritors now list
partitioned child tables before non-partitioned ones and return
the number of partitioned tables in an optional output argument
---
 contrib/sepgsql/dml.c                  |   2 +-
 src/backend/catalog/partition.c        |   2 +-
 src/backend/catalog/pg_inherits.c      | 157 ++++++++++++++++++++++++++-------
 src/backend/commands/analyze.c         |   3 +-
 src/backend/commands/lockcmds.c        |   2 +-
 src/backend/commands/publicationcmds.c |   2 +-
 src/backend/commands/tablecmds.c       |  39 ++++----
 src/backend/commands/vacuum.c          |   3 +-
 src/backend/optimizer/prep/prepunion.c |   2 +-
 src/include/catalog/pg_inherits_fn.h   |   5 +-
 10 files changed, 162 insertions(+), 55 deletions(-)

diff --git a/contrib/sepgsql/dml.c b/contrib/sepgsql/dml.c
index b643720e36..6fc279805c 100644
--- a/contrib/sepgsql/dml.c
+++ b/contrib/sepgsql/dml.c
@@ -333,7 +333,7 @@ sepgsql_dml_privileges(List *rangeTabls, bool abort_on_violation)
 		if (!rte->inh)
 			tableIds = list_make1_oid(rte->relid);
 		else
-			tableIds = find_all_inheritors(rte->relid, NoLock, NULL);
+			tableIds = find_all_inheritors(rte->relid, NoLock, NULL, NULL);
 
 		foreach(li, tableIds)
 		{
diff --git a/src/backend/catalog/partition.c b/src/backend/catalog/partition.c
index 3d72d08c35..465e4fc097 100644
--- a/src/backend/catalog/partition.c
+++ b/src/backend/catalog/partition.c
@@ -196,7 +196,7 @@ RelationBuildPartitionDesc(Relation rel)
 		return;
 
 	/* Get partition oids from pg_inherits */
-	inhoids = find_inheritance_children(RelationGetRelid(rel), NoLock);
+	inhoids = find_inheritance_children(RelationGetRelid(rel), NoLock, NULL);
 
 	/* Collect bound spec nodes in a list */
 	i = 0;
diff --git a/src/backend/catalog/pg_inherits.c b/src/backend/catalog/pg_inherits.c
index 245a374fc9..99b1e70de6 100644
--- a/src/backend/catalog/pg_inherits.c
+++ b/src/backend/catalog/pg_inherits.c
@@ -30,9 +30,12 @@
 #include "utils/builtins.h"
 #include "utils/fmgroids.h"
 #include "utils/memutils.h"
+#include "utils/lsyscache.h"
 #include "utils/syscache.h"
 #include "utils/tqual.h"
 
+static int32 inhchildinfo_cmp(const void *p1, const void *p2);
+
 /*
  * Entry of a hash table used in find_all_inheritors. See below.
  */
@@ -42,6 +45,30 @@ typedef struct SeenRelsEntry
 	ListCell   *numparents_cell;	/* corresponding list cell */
 } SeenRelsEntry;
 
+/* Information about one inheritance child table. */
+typedef struct InhChildInfo
+{
+	Oid			relid;
+	bool		is_partitioned;
+} InhChildInfo;
+
+#define OID_CMP(o1, o2) \
+		((o1) < (o2) ? -1 : ((o1) > (o2) ? 1 : 0));
+
+static int32
+inhchildinfo_cmp(const void *p1, const void *p2)
+{
+	InhChildInfo c1 = *((const InhChildInfo *) p1);
+	InhChildInfo c2 = *((const InhChildInfo *) p2);
+
+	if (c1.is_partitioned && !c2.is_partitioned)
+		return -1;
+	if (!c1.is_partitioned && c2.is_partitioned)
+		return 1;
+
+	return OID_CMP(c1.relid, c2.relid);
+}
+
 /*
  * find_inheritance_children
  *
@@ -54,7 +81,8 @@ typedef struct SeenRelsEntry
  * against possible DROPs of child relations.
  */
 List *
-find_inheritance_children(Oid parentrelId, LOCKMODE lockmode)
+find_inheritance_children(Oid parentrelId, LOCKMODE lockmode,
+						  int *num_partitioned_children)
 {
 	List	   *list = NIL;
 	Relation	relation;
@@ -62,9 +90,10 @@ find_inheritance_children(Oid parentrelId, LOCKMODE lockmode)
 	ScanKeyData key[1];
 	HeapTuple	inheritsTuple;
 	Oid			inhrelid;
-	Oid		   *oidarr;
-	int			maxoids,
-				numoids,
+	InhChildInfo *inhchildren;
+	int			maxchildren,
+				numchildren,
+				my_num_partitioned_children,
 				i;
 
 	/*
@@ -77,9 +106,10 @@ find_inheritance_children(Oid parentrelId, LOCKMODE lockmode)
 	/*
 	 * Scan pg_inherits and build a working array of subclass OIDs.
 	 */
-	maxoids = 32;
-	oidarr = (Oid *) palloc(maxoids * sizeof(Oid));
-	numoids = 0;
+	maxchildren = 32;
+	inhchildren = (InhChildInfo *) palloc(maxchildren * sizeof(InhChildInfo));
+	numchildren = 0;
+	my_num_partitioned_children = 0;
 
 	relation = heap_open(InheritsRelationId, AccessShareLock);
 
@@ -94,33 +124,47 @@ find_inheritance_children(Oid parentrelId, LOCKMODE lockmode)
 	while ((inheritsTuple = systable_getnext(scan)) != NULL)
 	{
 		inhrelid = ((Form_pg_inherits) GETSTRUCT(inheritsTuple))->inhrelid;
-		if (numoids >= maxoids)
+		if (numchildren >= maxchildren)
+		{
+			maxchildren *= 2;
+			inhchildren = (InhChildInfo *) repalloc(inhchildren,
+										maxchildren * sizeof(InhChildInfo));
+		}
+		inhchildren[numchildren].relid = inhrelid;
+
+		if (get_rel_relkind(inhrelid) == RELKIND_PARTITIONED_TABLE)
 		{
-			maxoids *= 2;
-			oidarr = (Oid *) repalloc(oidarr, maxoids * sizeof(Oid));
+			inhchildren[numchildren].is_partitioned = true;
+			my_num_partitioned_children++;
 		}
-		oidarr[numoids++] = inhrelid;
+		else
+			inhchildren[numchildren].is_partitioned = false;
+		numchildren++;
 	}
 
 	systable_endscan(scan);
 
 	heap_close(relation, AccessShareLock);
 
+	if (num_partitioned_children)
+		*num_partitioned_children = my_num_partitioned_children;
+
 	/*
 	 * If we found more than one child, sort them by OID.  This ensures
 	 * reasonably consistent behavior regardless of the vagaries of an
 	 * indexscan.  This is important since we need to be sure all backends
 	 * lock children in the same order to avoid needless deadlocks.
 	 */
-	if (numoids > 1)
-		qsort(oidarr, numoids, sizeof(Oid), oid_cmp);
+	if (numchildren > 1)
+		qsort(inhchildren, numchildren, sizeof(InhChildInfo),
+			  inhchildinfo_cmp);
 
 	/*
 	 * Acquire locks and build the result list.
 	 */
-	for (i = 0; i < numoids; i++)
+	for (i = 0; i < numchildren; i++)
 	{
-		inhrelid = oidarr[i];
+		inhrelid = inhchildren[i].relid;
 
 		if (lockmode != NoLock)
 		{
@@ -144,7 +188,7 @@ find_inheritance_children(Oid parentrelId, LOCKMODE lockmode)
 		list = lappend_oid(list, inhrelid);
 	}
 
-	pfree(oidarr);
+	pfree(inhchildren);
 
 	return list;
 }
@@ -159,18 +203,28 @@ find_inheritance_children(Oid parentrelId, LOCKMODE lockmode)
  *		given rel.
  *
  * The specified lock type is acquired on all child relations (but not on the
- * given rel; caller should already have locked it).  If lockmode is NoLock
- * then no locks are acquired, but caller must beware of race conditions
- * against possible DROPs of child relations.
+ * given rel; caller should already have locked it), unless
+ * lock_only_partitioned_children is specified, in which case, only the
+ * child relations that are partitioned tables are locked.  If lockmode is
+ * NoLock then no locks are acquired, but caller must beware of race
+ * conditions against possible DROPs of child relations.
+ *
+ * Returned list of OIDs is such that all the partitioned tables in the tree
+ * appear at the head of the list.  If num_partitioned_children is non-NULL,
+ * *num_partitioned_children returns the number of partitioned child table
+ * OIDs at the head of the list.
  */
 List *
-find_all_inheritors(Oid parentrelId, LOCKMODE lockmode, List **numparents)
+find_all_inheritors(Oid parentrelId, LOCKMODE lockmode,
+					List **numparents, int *num_partitioned_children)
 {
 	/* hash table for O(1) rel_oid -> rel_numparents cell lookup */
 	HTAB	   *seen_rels;
 	HASHCTL		ctl;
 	List	   *rels_list,
-			   *rel_numparents;
+			   *rel_numparents,
+			   *partitioned_rels_list,
+			   *other_rels_list;
 	ListCell   *l;
 
 	memset(&ctl, 0, sizeof(ctl));
@@ -185,31 +239,71 @@ find_all_inheritors(Oid parentrelId, LOCKMODE lockmode, List **numparents)
 
 	/*
 	 * We build a list starting with the given rel and adding all direct and
-	 * indirect children.  We can use a single list as both the record of
-	 * already-found rels and the agenda of rels yet to be scanned for more
-	 * children.  This is a bit tricky but works because the foreach() macro
-	 * doesn't fetch the next list element until the bottom of the loop.
+	 * indirect children.  We can use a single list (rels_list) as both the
+	 * record of already-found rels and the agenda of rels yet to be scanned
+	 * for more children.  This is a bit tricky but works because the foreach()
+	 * macro doesn't fetch the next list element until the bottom of the loop.
+	 *
+	 * partitioned_child_rels will contain the OIDs of the partitioned child
+	 * tables and other_rels_list will contain the OIDs of the non-partitioned
+	 * child tables.  Result list will be generated by concatening the two
+	 * lists together with partitioned_child_rels appearing first.
 	 */
 	rels_list = list_make1_oid(parentrelId);
+	partitioned_rels_list = list_make1_oid(parentrelId);
+	other_rels_list = NIL;
 	rel_numparents = list_make1_int(0);
 
+	if (num_partitioned_children)
+		*num_partitioned_children = 0;
+
 	foreach(l, rels_list)
 	{
 		Oid			currentrel = lfirst_oid(l);
 		List	   *currentchildren;
-		ListCell   *lc;
+		ListCell   *lc,
+				   *first_nonpartitioned_child;
+		int			cur_num_partitioned_children = 0,
+					i;
 
 		/* Get the direct children of this rel */
-		currentchildren = find_inheritance_children(currentrel, lockmode);
+		currentchildren = find_inheritance_children(currentrel, lockmode,
+											&cur_num_partitioned_children);
+
+		if (num_partitioned_children)
+			*num_partitioned_children += cur_num_partitioned_children;
+
+		/*
+		 * Append partitioned children to rels_list and partitioned_rels_list.
+		 * We know for sure that partitioned children don't need the
+		 * the de-duplication logic in the following loop, because partitioned
+		 * tables are not allowed to partiticipate in multiple inheritance.
+		 */
+		i = 0;
+		foreach(lc, currentchildren)
+		{
+			if (i < cur_num_partitioned_children)
+			{
+				Oid		child_oid = lfirst_oid(lc);
+
+				rels_list = lappend_oid(rels_list, child_oid);
+				partitioned_rels_list = lappend_oid(partitioned_rels_list,
+													child_oid);
+			}
+			else
+				break;
+			i++;
+		}
+		first_nonpartitioned_child = lc;
 
 		/*
 		 * Add to the queue only those children not already seen. This avoids
 		 * making duplicate entries in case of multiple inheritance paths from
 		 * the same parent.  (It'll also keep us from getting into an infinite
 		 * loop, though theoretically there can't be any cycles in the
-		 * inheritance graph anyway.)
+		 * inheritance graph anyway.)  Also, add them to the other_rels_list.
 		 */
-		foreach(lc, currentchildren)
+		for_each_cell(lc, first_nonpartitioned_child)
 		{
 			Oid			child_oid = lfirst_oid(lc);
 			bool		found;
@@ -225,6 +319,7 @@ find_all_inheritors(Oid parentrelId, LOCKMODE lockmode, List **numparents)
 			{
 				/* if it's not there, add it. expect 1 parent, initially. */
 				rels_list = lappend_oid(rels_list, child_oid);
+				other_rels_list = lappend_oid(other_rels_list, child_oid);
 				rel_numparents = lappend_int(rel_numparents, 1);
 				hash_entry->numparents_cell = rel_numparents->tail;
 			}
@@ -237,8 +332,10 @@ find_all_inheritors(Oid parentrelId, LOCKMODE lockmode, List **numparents)
 		list_free(rel_numparents);
 
 	hash_destroy(seen_rels);
+	list_free(rels_list);
 
-	return rels_list;
+	/* List partitioned child tables before non-partitioned ones. */
+	return list_concat(partitioned_rels_list, other_rels_list);
 }
 
 
diff --git a/src/backend/commands/analyze.c b/src/backend/commands/analyze.c
index 2b638271b3..ae8ce71e1c 100644
--- a/src/backend/commands/analyze.c
+++ b/src/backend/commands/analyze.c
@@ -1282,7 +1282,8 @@ acquire_inherited_sample_rows(Relation onerel, int elevel,
 	 * the children.
 	 */
 	tableOIDs =
-		find_all_inheritors(RelationGetRelid(onerel), AccessShareLock, NULL);
+		find_all_inheritors(RelationGetRelid(onerel), AccessShareLock, NULL,
+							NULL);
 
 	/*
 	 * Check that there's at least one descendant, else fail.  This could
diff --git a/src/backend/commands/lockcmds.c b/src/backend/commands/lockcmds.c
index 9fe9e022b0..529f244f7e 100644
--- a/src/backend/commands/lockcmds.c
+++ b/src/backend/commands/lockcmds.c
@@ -112,7 +112,7 @@ LockTableRecurse(Oid reloid, LOCKMODE lockmode, bool nowait)
 	List	   *children;
 	ListCell   *lc;
 
-	children = find_inheritance_children(reloid, NoLock);
+	children = find_inheritance_children(reloid, NoLock, NULL);
 
 	foreach(lc, children)
 	{
diff --git a/src/backend/commands/publicationcmds.c b/src/backend/commands/publicationcmds.c
index 610cb499d2..64179ea3ef 100644
--- a/src/backend/commands/publicationcmds.c
+++ b/src/backend/commands/publicationcmds.c
@@ -516,7 +516,7 @@ OpenTableList(List *tables)
 			List	   *children;
 
 			children = find_all_inheritors(myrelid, ShareUpdateExclusiveLock,
-										   NULL);
+										   NULL, NULL);
 
 			foreach(child, children)
 			{
diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c
index 1b8d4b3d17..14bac087d9 100644
--- a/src/backend/commands/tablecmds.c
+++ b/src/backend/commands/tablecmds.c
@@ -1231,7 +1231,8 @@ ExecuteTruncate(TruncateStmt *stmt)
 			ListCell   *child;
 			List	   *children;
 
-			children = find_all_inheritors(myrelid, AccessExclusiveLock, NULL);
+			children = find_all_inheritors(myrelid, AccessExclusiveLock, NULL,
+										   NULL);
 
 			foreach(child, children)
 			{
@@ -2556,7 +2557,7 @@ renameatt_internal(Oid myrelid,
 		 * outside the inheritance hierarchy being processed.
 		 */
 		child_oids = find_all_inheritors(myrelid, AccessExclusiveLock,
-										 &child_numparents);
+										 &child_numparents, NULL);
 
 		/*
 		 * find_all_inheritors does the recursive search of the inheritance
@@ -2583,7 +2584,7 @@ renameatt_internal(Oid myrelid,
 		 * expected_parents will only be 0 if we are not already recursing.
 		 */
 		if (expected_parents == 0 &&
-			find_inheritance_children(myrelid, NoLock) != NIL)
+			find_inheritance_children(myrelid, NoLock, NULL) != NIL)
 			ereport(ERROR,
 					(errcode(ERRCODE_INVALID_TABLE_DEFINITION),
 					 errmsg("inherited column \"%s\" must be renamed in child tables too",
@@ -2766,7 +2767,7 @@ rename_constraint_internal(Oid myrelid,
 					   *li;
 
 			child_oids = find_all_inheritors(myrelid, AccessExclusiveLock,
-											 &child_numparents);
+											 &child_numparents, NULL);
 
 			forboth(lo, child_oids, li, child_numparents)
 			{
@@ -2782,7 +2783,7 @@ rename_constraint_internal(Oid myrelid,
 		else
 		{
 			if (expected_parents == 0 &&
-				find_inheritance_children(myrelid, NoLock) != NIL)
+				find_inheritance_children(myrelid, NoLock, NULL) != NIL)
 				ereport(ERROR,
 						(errcode(ERRCODE_INVALID_TABLE_DEFINITION),
 						 errmsg("inherited constraint \"%s\" must be renamed in child tables too",
@@ -4790,7 +4791,7 @@ ATSimpleRecursion(List **wqueue, Relation rel,
 		ListCell   *child;
 		List	   *children;
 
-		children = find_all_inheritors(relid, lockmode, NULL);
+		children = find_all_inheritors(relid, lockmode, NULL, NULL);
 
 		/*
 		 * find_all_inheritors does the recursive search of the inheritance
@@ -5186,7 +5187,7 @@ ATExecAddColumn(List **wqueue, AlteredTableInfo *tab, Relation rel,
 	 */
 	if (colDef->identity &&
 		recurse &&
-		find_inheritance_children(myrelid, NoLock) != NIL)
+		find_inheritance_children(myrelid, NoLock, NULL) != NIL)
 		ereport(ERROR,
 				(errcode(ERRCODE_INVALID_TABLE_DEFINITION),
 				 errmsg("cannot recursively add identity column to table that has child tables")));
@@ -5392,7 +5393,8 @@ ATExecAddColumn(List **wqueue, AlteredTableInfo *tab, Relation rel,
 	 * routines, we have to do this one level of recursion at a time; we can't
 	 * use find_all_inheritors to do it in one pass.
 	 */
-	children = find_inheritance_children(RelationGetRelid(rel), lockmode);
+	children = find_inheritance_children(RelationGetRelid(rel), lockmode,
+										 NULL);
 
 	/*
 	 * If we are told not to recurse, there had better not be any child
@@ -6511,7 +6513,8 @@ ATExecDropColumn(List **wqueue, Relation rel, const char *colName,
 	 * routines, we have to do this one level of recursion at a time; we can't
 	 * use find_all_inheritors to do it in one pass.
 	 */
-	children = find_inheritance_children(RelationGetRelid(rel), lockmode);
+	children = find_inheritance_children(RelationGetRelid(rel), lockmode,
+										 NULL);
 
 	if (children)
 	{
@@ -6945,7 +6948,8 @@ ATAddCheckConstraint(List **wqueue, AlteredTableInfo *tab, Relation rel,
 	 * routines, we have to do this one level of recursion at a time; we can't
 	 * use find_all_inheritors to do it in one pass.
 	 */
-	children = find_inheritance_children(RelationGetRelid(rel), lockmode);
+	children = find_inheritance_children(RelationGetRelid(rel), lockmode,
+										 NULL);
 
 	/*
 	 * Check if ONLY was specified with ALTER TABLE.  If so, allow the
@@ -7664,7 +7668,7 @@ ATExecValidateConstraint(Relation rel, char *constrName, bool recurse,
 			 */
 			if (!recursing && !con->connoinherit)
 				children = find_all_inheritors(RelationGetRelid(rel),
-											   lockmode, NULL);
+											   lockmode, NULL, NULL);
 
 			/*
 			 * For CHECK constraints, we must ensure that we only mark the
@@ -8547,7 +8551,8 @@ ATExecDropConstraint(Relation rel, const char *constrName,
 	 * use find_all_inheritors to do it in one pass.
 	 */
 	if (!is_no_inherit_constraint)
-		children = find_inheritance_children(RelationGetRelid(rel), lockmode);
+		children = find_inheritance_children(RelationGetRelid(rel), lockmode,
+											 NULL);
 	else
 		children = NIL;
 
@@ -8836,7 +8841,7 @@ ATPrepAlterColumnType(List **wqueue,
 		ListCell   *child;
 		List	   *children;
 
-		children = find_all_inheritors(relid, lockmode, NULL);
+		children = find_all_inheritors(relid, lockmode, NULL, NULL);
 
 		/*
 		 * find_all_inheritors does the recursive search of the inheritance
@@ -8887,7 +8892,8 @@ ATPrepAlterColumnType(List **wqueue,
 		}
 	}
 	else if (!recursing &&
-			 find_inheritance_children(RelationGetRelid(rel), NoLock) != NIL)
+			 find_inheritance_children(RelationGetRelid(rel),
+									   NoLock, NULL) != NIL)
 		ereport(ERROR,
 				(errcode(ERRCODE_INVALID_TABLE_DEFINITION),
 				 errmsg("type of inherited column \"%s\" must be changed in child tables too",
@@ -10997,7 +11003,7 @@ ATExecAddInherit(Relation child_rel, RangeVar *parent, LOCKMODE lockmode)
 	 * We use weakest lock we can on child's children, namely AccessShareLock.
 	 */
 	children = find_all_inheritors(RelationGetRelid(child_rel),
-								   AccessShareLock, NULL);
+								   AccessShareLock, NULL, NULL);
 
 	if (list_member_oid(children, RelationGetRelid(parent_rel)))
 		ereport(ERROR,
@@ -13503,7 +13509,8 @@ ATExecAttachPartition(List **wqueue, Relation rel, PartitionCmd *cmd)
 	 * weaker lock now and the stronger one only when needed.
 	 */
 	attachrel_children = find_all_inheritors(RelationGetRelid(attachrel),
-											 AccessExclusiveLock, NULL);
+											 AccessExclusiveLock, NULL,
+											 NULL);
 	if (list_member_oid(attachrel_children, RelationGetRelid(rel)))
 		ereport(ERROR,
 				(errcode(ERRCODE_DUPLICATE_TABLE),
diff --git a/src/backend/commands/vacuum.c b/src/backend/commands/vacuum.c
index faa181207a..e2e5ffce42 100644
--- a/src/backend/commands/vacuum.c
+++ b/src/backend/commands/vacuum.c
@@ -430,7 +430,8 @@ get_rel_oids(Oid relid, const RangeVar *vacrel)
 		oldcontext = MemoryContextSwitchTo(vac_context);
 		if (include_parts)
 			oid_list = list_concat(oid_list,
-								   find_all_inheritors(relid, NoLock, NULL));
+								   find_all_inheritors(relid, NoLock, NULL,
+													   NULL));
 		else
 			oid_list = lappend_oid(oid_list, relid);
 		MemoryContextSwitchTo(oldcontext);
diff --git a/src/backend/optimizer/prep/prepunion.c b/src/backend/optimizer/prep/prepunion.c
index cf46b74782..09e45c2982 100644
--- a/src/backend/optimizer/prep/prepunion.c
+++ b/src/backend/optimizer/prep/prepunion.c
@@ -1418,7 +1418,7 @@ 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);
+	inhOIDs = find_all_inheritors(parentOID, lockmode, NULL, NULL);
 
 	/*
 	 * Check that there's at least one descendant, else treat as no-child
diff --git a/src/include/catalog/pg_inherits_fn.h b/src/include/catalog/pg_inherits_fn.h
index 7743388899..8f371acae7 100644
--- a/src/include/catalog/pg_inherits_fn.h
+++ b/src/include/catalog/pg_inherits_fn.h
@@ -17,9 +17,10 @@
 #include "nodes/pg_list.h"
 #include "storage/lock.h"
 
-extern List *find_inheritance_children(Oid parentrelId, LOCKMODE lockmode);
+extern List *find_inheritance_children(Oid parentrelId, LOCKMODE lockmode,
+						  int *num_partitioned_children);
 extern List *find_all_inheritors(Oid parentrelId, LOCKMODE lockmode,
-					List **parents);
+					List **parents, int *num_partitioned_children);
 extern bool has_subclass(Oid relationId);
 extern bool has_superclass(Oid relationId);
 extern bool typeInheritsFrom(Oid subclassTypeId, Oid superclassTypeId);
-- 
2.11.0

From 6ae18ec3456b2a3fedd239059687873ae91ddbee Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Wed, 9 Aug 2017 15:34:45 +0900
Subject: [PATCH 3/5] Relieve RelationGetPartitionDispatchInfo() of doing any
 locking

Anyone who wants to call RelationGetPartitionDispatchInfo() must first
acquire locks using find_all_inheritors.
---
 src/backend/catalog/partition.c | 42 ++++++++++++++++++++---------------------
 src/backend/executor/execMain.c | 20 +++++++++++---------
 src/include/catalog/partition.h |  4 ++--
 3 files changed, 33 insertions(+), 33 deletions(-)

diff --git a/src/backend/catalog/partition.c b/src/backend/catalog/partition.c
index 465e4fc097..4c16bf143b 100644
--- a/src/backend/catalog/partition.c
+++ b/src/backend/catalog/partition.c
@@ -1003,14 +1003,12 @@ get_partition_qual_relid(Oid relid)
  * one member, that is, one for the root partitioned table), *leaf_part_oids
  * contains a list of the OIDs of of all the leaf partitions.
  *
- * Note that we lock only those partitions that are partitioned tables, because
- * we need to look at its relcache entry to get its PartitionKey and its
- * PartitionDesc. It's the caller's responsibility to lock the leaf partitions
- * that will actually be accessed during a given query.
+ * It is assumed that the caller has locked at least all the partitioned tables
+ * in the tree, because we need to look at their relcache entries.
  */
 void
-RelationGetPartitionDispatchInfo(Relation rel, int lockmode,
-								 List **ptinfos, List **leaf_part_oids)
+RelationGetPartitionDispatchInfo(Relation rel, List **ptinfos,
+								 List **leaf_part_oids)
 {
 	List	   *all_parts,
 			   *all_parents;
@@ -1025,16 +1023,10 @@ RelationGetPartitionDispatchInfo(Relation rel, int lockmode,
 	 * Starting with the root partitioned table for which we already have the
 	 * relcache entry, we look at its partition descriptor to get the
 	 * partition OIDs.  For partitions that are themselves partitioned tables,
-	 * we get their relcache entries after locking them with lockmode and
-	 * queue their partitions to be looked at later.  Leaf partitions are
-	 * added to the result list without locking.  For each partitioned table,
-	 * we build a PartitionedTableInfo object and add it to the other result
-	 * list.
-	 *
-	 * Since RelationBuildPartitionDescriptor() puts partitions in a canonical
-	 * order determined by comparing partition bounds, we can rely that
-	 * concurrent backends see the partitions in the same order, ensuring that
-	 * there are no deadlocks when locking the partitions.
+	 * we get their relcache entries and queue their partitions to be looked at
+	 * later.  For each leaf partition, we simply add its OID to the result
+	 * list and for each partitioned table, we build a PartitionedTableInfo
+	 * object and add it to the other result list.
 	 */
 	i = offset = 0;
 	*ptinfos = *leaf_part_oids = NIL;
@@ -1057,8 +1049,14 @@ RelationGetPartitionDispatchInfo(Relation rel, int lockmode,
 			PartitionedTableInfo   *ptinfo;
 			PartitionDispatch		pd;
 
+			/*
+			 * All the relations in the partition tree must be locked
+			 * by the caller.
+			 *
+			 * XXX - Add RelationLockHeldByMe(partrelid) check here!
+			 */
 			if (partrelid != RelationGetRelid(rel))
-				partrel = heap_open(partrelid, lockmode);
+				partrel = heap_open(partrelid, NoLock);
 			else
 				partrel = rel;
 
@@ -1077,7 +1075,8 @@ RelationGetPartitionDispatchInfo(Relation rel, int lockmode,
 			/*
 			 * XXX- do we need a pinning mechanism for partition descriptors
 			 * so that there references can be managed independently of
-			 * the parent relcache entry? Like PinPartitionDesc(partdesc)?
+			 * the fate of parent relcache entry?
+			 * Like PinPartitionDesc(partdesc)?
 			 */
 			pd->partdesc = partdesc;
 
@@ -1141,10 +1140,9 @@ RelationGetPartitionDispatchInfo(Relation rel, int lockmode,
 
 			/*
 			 * Release the relation descriptor.  Lock that we have on the
-			 * table will keep the PartitionDesc that is pointing into
-			 * RelationData intact, a pointer to which hope to keep
-			 * through this transaction's commit.
-			 * (XXX - how true is that?)
+			 * table will keep PartitionDesc (that is pointing into
+			 * RelationData) intact, a reference to which want to keep through
+			 * this transaction's commit. (XXX - how true is that?)
 			 */
 			if (partrel != rel)
 				heap_close(partrel, NoLock);
diff --git a/src/backend/executor/execMain.c b/src/backend/executor/execMain.c
index 0379e489d9..3dd620fc8a 100644
--- a/src/backend/executor/execMain.c
+++ b/src/backend/executor/execMain.c
@@ -43,6 +43,7 @@
 #include "access/xact.h"
 #include "catalog/namespace.h"
 #include "catalog/partition.h"
+#include "catalog/pg_inherits_fn.h"
 #include "catalog/pg_publication.h"
 #include "commands/matview.h"
 #include "commands/trigger.h"
@@ -3250,14 +3251,16 @@ ExecSetupPartitionTupleRouting(Relation rel,
 	int			i;
 	ResultRelInfo *leaf_part_rri;
 	Relation	parent;
+	List	   *all_parts;
 
 	/*
-	 * Get information about the partition tree.  All the partitioned
-	 * tables in the tree are locked, but not the leaf partitions.  We
-	 * lock them while building their ResultRelInfos below.
+	 * Get information about the partition tree.  First lock all the
+	 * partitions using find_all_inheritors().
 	 */
-	RelationGetPartitionDispatchInfo(rel, RowExclusiveLock,
-									 &ptinfos, &leaf_parts);
+	all_parts = find_all_inheritors(RelationGetRelid(rel), RowExclusiveLock,
+									NULL, NULL);
+	list_free(all_parts);
+	RelationGetPartitionDispatchInfo(rel, &ptinfos, &leaf_parts);
 
 	/*
 	 * The ptinfos list contains PartitionedTableInfo objects for all the
@@ -3396,11 +3399,10 @@ ExecSetupPartitionTupleRouting(Relation rel,
 		TupleDesc	part_tupdesc;
 
 		/*
-		 * RelationGetPartitionDispatchInfo didn't lock the leaf partitions,
-		 * so lock here.  Note that each of the relations in *partitions are
-		 * eventually closed (when the plan is shut down, for instance).
+		 * Note that each of the relations in *partitions are eventually
+		 * closed (when the plan is shut down, for instance).
 		 */
-		partrel = heap_open(lfirst_oid(cell), RowExclusiveLock);
+		partrel = heap_open(lfirst_oid(cell), NoLock);	/* already locked */
 		part_tupdesc = RelationGetDescr(partrel);
 
 		/*
diff --git a/src/include/catalog/partition.h b/src/include/catalog/partition.h
index 6a0c81b3bd..9e63020c82 100644
--- a/src/include/catalog/partition.h
+++ b/src/include/catalog/partition.h
@@ -72,8 +72,8 @@ extern List *map_partition_varattnos(List *expr, int target_varno,
 extern List *RelationGetPartitionQual(Relation rel);
 extern Expr *get_partition_qual_relid(Oid relid);
 
-extern void RelationGetPartitionDispatchInfo(Relation rel, int lockmode,
-								 List **ptinfos, List **leaf_part_oids);
+extern void RelationGetPartitionDispatchInfo(Relation rel, List **ptinfos,
+								 List **leaf_part_oids);
 
 /* For tuple routing */
 extern void FormPartitionKeyDatum(PartitionKeyInfo *keyinfo,
-- 
2.11.0

From f09d3f00861b47fcb36e20f43be0b718e3350ab5 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Wed, 9 Aug 2017 15:52:36 +0900
Subject: [PATCH 4/5] Teach expand_inherited_rtentry to use partition bound
 order

After locking the child tables using find_all_inheritors, we discard
the list of child table OIDs that it generates and rebuild the same
using the information returned by RelationGetPartitionDispatchInfo.
---
 src/backend/optimizer/prep/prepunion.c | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/src/backend/optimizer/prep/prepunion.c b/src/backend/optimizer/prep/prepunion.c
index 09e45c2982..71a0daa1b0 100644
--- a/src/backend/optimizer/prep/prepunion.c
+++ b/src/backend/optimizer/prep/prepunion.c
@@ -33,6 +33,7 @@
 #include "access/heapam.h"
 #include "access/htup_details.h"
 #include "access/sysattr.h"
+#include "catalog/partition.h"
 #include "catalog/pg_inherits_fn.h"
 #include "catalog/pg_type.h"
 #include "miscadmin.h"
@@ -1446,6 +1447,37 @@ expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti)
 	 */
 	oldrelation = heap_open(parentOID, NoLock);
 
+	/*
+	 * For partitioned tables, we arrange the child table OIDs such that they
+	 * appear in the partition bound order.
+	 */
+	if (rte->relkind == RELKIND_PARTITIONED_TABLE)
+	{
+		List	*ptinfos,
+				*leaf_part_oids;
+
+		/* Discard the original list. */
+		list_free(inhOIDs);
+		inhOIDs = NIL;
+
+		/* Request partitioning information. */
+		RelationGetPartitionDispatchInfo(oldrelation, &ptinfos,
+										 &leaf_part_oids);
+		/*
+		 * First collect the partitioned child table OIDs, which includes the
+		 * root parent at the head.
+		 */
+		foreach(l, ptinfos)
+		{
+			PartitionedTableInfo *ptinfo = lfirst(l);
+
+			inhOIDs = lappend_oid(inhOIDs, ptinfo->relid);
+		}
+
+		/* Concatenate the leaf partition OIDs. */
+		inhOIDs = list_concat(inhOIDs, leaf_part_oids);
+	}
+
 	/* Scan the inheritance set and expand it */
 	appinfos = NIL;
 	need_append = false;
-- 
2.11.0

From 704b0877170757deae269b6bababbb2487693a4b Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Wed, 9 Aug 2017 16:53:47 +0900
Subject: [PATCH 5/5] Store in pg_inherits if a child is a partitioned table

---
 doc/src/sgml/catalogs.sgml        | 10 ++++++++++
 src/backend/catalog/pg_inherits.c | 14 +++++++-------
 src/backend/commands/tablecmds.c  | 17 +++++++++++------
 src/include/catalog/pg_inherits.h |  4 +++-
 4 files changed, 31 insertions(+), 14 deletions(-)

diff --git a/doc/src/sgml/catalogs.sgml b/doc/src/sgml/catalogs.sgml
index 97e5ecf686..eae9b77ccb 100644
--- a/doc/src/sgml/catalogs.sgml
+++ b/doc/src/sgml/catalogs.sgml
@@ -3896,6 +3896,16 @@ SCRAM-SHA-256$<replaceable>&lt;iteration count&gt;</>:<replaceable>&lt;salt&gt;<
        inherited columns are to be arranged.  The count starts at 1.
       </entry>
      </row>
+
+     <row>
+      <entry><structfield>inhchildparted</structfield></entry>
+      <entry><type>bool</type></entry>
+      <entry></entry>
+      <entry>
+       This is <literal>true</> if the child table is a partitioned table,
+       <literal>false</> otherwise
+      </entry>
+     </row>
     </tbody>
    </tgroup>
   </table>
diff --git a/src/backend/catalog/pg_inherits.c b/src/backend/catalog/pg_inherits.c
index 99b1e70de6..0285bc3c33 100644
--- a/src/backend/catalog/pg_inherits.c
+++ b/src/backend/catalog/pg_inherits.c
@@ -30,7 +30,6 @@
 #include "utils/builtins.h"
 #include "utils/fmgroids.h"
 #include "utils/memutils.h"
-#include "utils/lsyscache.h"
 #include "utils/syscache.h"
 #include "utils/tqual.h"
 
@@ -123,7 +122,12 @@ find_inheritance_children(Oid parentrelId, LOCKMODE lockmode,
 
 	while ((inheritsTuple = systable_getnext(scan)) != NULL)
 	{
+		bool	is_partitioned;
+
 		inhrelid = ((Form_pg_inherits) GETSTRUCT(inheritsTuple))->inhrelid;
+		is_partitioned = ((Form_pg_inherits)
+								GETSTRUCT(inheritsTuple))->inhchildparted;
+
 		if (numchildren >= maxchildren)
 		{
 			maxchildren *= 2;
@@ -131,14 +135,10 @@ find_inheritance_children(Oid parentrelId, LOCKMODE lockmode,
 										maxchildren * sizeof(InhChildInfo));
 		}
 		inhchildren[numchildren].relid = inhrelid;
+		inhchildren[numchildren].is_partitioned = is_partitioned;
 
-		if (get_rel_relkind(inhrelid) == RELKIND_PARTITIONED_TABLE)
-		{
-			inhchildren[numchildren].is_partitioned = true;
+		if (is_partitioned)
 			my_num_partitioned_children++;
-		}
-		else
-			inhchildren[numchildren].is_partitioned = false;
 		numchildren++;
 	}
 
diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c
index 14bac087d9..ab3cbbcdba 100644
--- a/src/backend/commands/tablecmds.c
+++ b/src/backend/commands/tablecmds.c
@@ -299,10 +299,10 @@ static bool MergeCheckConstraint(List *constraints, char *name, Node *expr);
 static void MergeAttributesIntoExisting(Relation child_rel, Relation parent_rel);
 static void MergeConstraintsIntoExisting(Relation child_rel, Relation parent_rel);
 static void StoreCatalogInheritance(Oid relationId, List *supers,
-						bool child_is_partition);
+						bool child_is_partition, bool child_is_partitioned);
 static void StoreCatalogInheritance1(Oid relationId, Oid parentOid,
 						 int16 seqNumber, Relation inhRelation,
-						 bool child_is_partition);
+						 bool child_is_partition, bool child_is_partitioned);
 static int	findAttrByName(const char *attributeName, List *schema);
 static void AlterIndexNamespaces(Relation classRel, Relation rel,
 					 Oid oldNspOid, Oid newNspOid, ObjectAddresses *objsMoved);
@@ -746,7 +746,8 @@ DefineRelation(CreateStmt *stmt, char relkind, Oid ownerId,
 										  typaddress);
 
 	/* Store inheritance information for new rel. */
-	StoreCatalogInheritance(relationId, inheritOids, stmt->partbound != NULL);
+	StoreCatalogInheritance(relationId, inheritOids, stmt->partbound != NULL,
+							relkind == RELKIND_PARTITIONED_TABLE);
 
 	/*
 	 * We must bump the command counter to make the newly-created relation
@@ -2298,7 +2299,7 @@ MergeCheckConstraint(List *constraints, char *name, Node *expr)
  */
 static void
 StoreCatalogInheritance(Oid relationId, List *supers,
-						bool child_is_partition)
+						bool child_is_partition, bool child_is_partitioned)
 {
 	Relation	relation;
 	int16		seqNumber;
@@ -2329,7 +2330,7 @@ StoreCatalogInheritance(Oid relationId, List *supers,
 		Oid			parentOid = lfirst_oid(entry);
 
 		StoreCatalogInheritance1(relationId, parentOid, seqNumber, relation,
-								 child_is_partition);
+								 child_is_partition, child_is_partitioned);
 		seqNumber++;
 	}
 
@@ -2343,7 +2344,7 @@ StoreCatalogInheritance(Oid relationId, List *supers,
 static void
 StoreCatalogInheritance1(Oid relationId, Oid parentOid,
 						 int16 seqNumber, Relation inhRelation,
-						 bool child_is_partition)
+						 bool child_is_partition, bool child_is_partitioned)
 {
 	TupleDesc	desc = RelationGetDescr(inhRelation);
 	Datum		values[Natts_pg_inherits];
@@ -2358,6 +2359,8 @@ StoreCatalogInheritance1(Oid relationId, Oid parentOid,
 	values[Anum_pg_inherits_inhrelid - 1] = ObjectIdGetDatum(relationId);
 	values[Anum_pg_inherits_inhparent - 1] = ObjectIdGetDatum(parentOid);
 	values[Anum_pg_inherits_inhseqno - 1] = Int16GetDatum(seqNumber);
+	values[Anum_pg_inherits_inhchildparted - 1] =
+									BoolGetDatum(child_is_partitioned);
 
 	memset(nulls, 0, sizeof(nulls));
 
@@ -11112,6 +11115,8 @@ CreateInheritance(Relation child_rel, Relation parent_rel)
 							 inhseqno + 1,
 							 catalogRelation,
 							 parent_rel->rd_rel->relkind ==
+							 RELKIND_PARTITIONED_TABLE,
+							 child_rel->rd_rel->relkind ==
 							 RELKIND_PARTITIONED_TABLE);
 
 	/* Now we're done with pg_inherits */
diff --git a/src/include/catalog/pg_inherits.h b/src/include/catalog/pg_inherits.h
index 26bfab5db6..2c4ef246a4 100644
--- a/src/include/catalog/pg_inherits.h
+++ b/src/include/catalog/pg_inherits.h
@@ -33,6 +33,7 @@ CATALOG(pg_inherits,2611) BKI_WITHOUT_OIDS
 	Oid			inhrelid;
 	Oid			inhparent;
 	int32		inhseqno;
+	bool		inhchildparted;
 } FormData_pg_inherits;
 
 /* ----------------
@@ -46,10 +47,11 @@ typedef FormData_pg_inherits *Form_pg_inherits;
  *		compiler constants for pg_inherits
  * ----------------
  */
-#define Natts_pg_inherits				3
+#define Natts_pg_inherits				4
 #define Anum_pg_inherits_inhrelid		1
 #define Anum_pg_inherits_inhparent		2
 #define Anum_pg_inherits_inhseqno		3
+#define Anum_pg_inherits_inhchildparted	4
 
 /* ----------------
  *		pg_inherits has no initial contents
-- 
2.11.0

From 23a3e291001394ffa2b79b34b32c582cb4898e87 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Wed, 16 Aug 2017 11:36:14 +0900
Subject: [PATCH 1/4] Relieve RelationGetPartitionDispatchInfo() of doing any
 locking

Anyone who wants to call RelationGetPartitionDispatchInfo() must first
acquire locks using find_all_inheritors.

Doing it this way gets rid of the possibility of a deadlock when partitions
are concurrently locked, because RelationGetPartitionDispatchInfo would lock
the partitions in one order and find_all_inheritors would in another.

Reported-by: Amit Khandekar, Robert Haas
Reports: https://postgr.es/m/CAJ3gD9fdjk2O8aPMXidCeYeB-mFB%3DwY9ZLfe8cQOfG4bTqVGyQ%40mail.gmail.com
         https://postgr.es/m/CA%2BTgmobwbh12OJerqAGyPEjb_%2B2y7T0nqRKTcjed6L4NTET6Fg%40mail.gmail.com
---
 src/backend/catalog/partition.c | 55 ++++++++++++++++++++++-------------------
 src/backend/executor/execMain.c | 18 +++++++++-----
 src/include/catalog/partition.h |  3 +--
 3 files changed, 42 insertions(+), 34 deletions(-)

diff --git a/src/backend/catalog/partition.c b/src/backend/catalog/partition.c
index c1a307c8d3..96a64ce6b2 100644
--- a/src/backend/catalog/partition.c
+++ b/src/backend/catalog/partition.c
@@ -999,12 +999,16 @@ get_partition_qual_relid(Oid relid)
  * RelationGetPartitionDispatchInfo
  *		Returns information necessary to route tuples down a partition tree
  *
- * All the partitions will be locked with lockmode, unless it is NoLock.
- * A list of the OIDs of all the leaf partitions of rel is returned in
- * *leaf_part_oids.
+ * The number of elements in the returned array (that is, the number of
+ * PartitionDispatch objects for the partitioned tables in the partition tree)
+ * is returned in *num_parted and a list of the OIDs of all the leaf
+ * partitions of rel is returned in *leaf_part_oids.
+ *
+ * All the relations in the partition tree (including 'rel') must have been
+ * locked (using at least the AccessShareLock) by the caller.
  */
 PartitionDispatch *
-RelationGetPartitionDispatchInfo(Relation rel, int lockmode,
+RelationGetPartitionDispatchInfo(Relation rel,
 								 int *num_parted, List **leaf_part_oids)
 {
 	PartitionDispatchData **pd;
@@ -1019,14 +1023,18 @@ RelationGetPartitionDispatchInfo(Relation rel, int lockmode,
 				offset;
 
 	/*
-	 * Lock partitions and make a list of the partitioned ones to prepare
-	 * their PartitionDispatch objects below.
+	 * We rely on the relcache to traverse the partition tree to build both
+	 * the leaf partition OIDs list and the array of PartitionDispatch objects
+	 * for the partitioned tables in the tree.  That means every partitioned
+	 * table in the tree must be locked, which is fine since we require the
+	 * caller to lock all the partitions anyway.
 	 *
-	 * Cannot use find_all_inheritors() here, because then the order of OIDs
-	 * in parted_rels list would be unknown, which does not help, because we
-	 * assign indexes within individual PartitionDispatch in an order that is
-	 * predetermined (determined by the order of OIDs in individual partition
-	 * descriptors).
+	 * For every partitioned table in the tree, starting with the root
+	 * partitioned table, add its relcache entry to parted_rels, while also
+	 * queuing its partitions (in the order in which they appear in the
+	 * partition descriptor) to be looked at later in the same loop.  This is
+	 * a bit tricky but works because the foreach() macro doesn't fetch the
+	 * next list element until the bottom of the loop.
 	 */
 	*num_parted = 1;
 	parted_rels = list_make1(rel);
@@ -1035,29 +1043,24 @@ RelationGetPartitionDispatchInfo(Relation rel, int lockmode,
 	APPEND_REL_PARTITION_OIDS(rel, all_parts, all_parents);
 	forboth(lc1, all_parts, lc2, all_parents)
 	{
-		Relation	partrel = heap_open(lfirst_oid(lc1), lockmode);
+		Oid			partrelid = lfirst_oid(lc1);
 		Relation	parent = lfirst(lc2);
-		PartitionDesc partdesc = RelationGetPartitionDesc(partrel);
 
-		/*
-		 * If this partition is a partitioned table, add its children to the
-		 * end of the list, so that they are processed as well.
-		 */
-		if (partdesc)
+		if (get_rel_relkind(partrelid) == RELKIND_PARTITIONED_TABLE)
 		{
+			/*
+			 * Already locked by the caller.  Note that it is the
+			 * responsibility of the caller to close the below relcache entry,
+			 * once done using the information being collected here (for
+			 * example, in ExecEndModifyTable).
+			 */
+			Relation	partrel = heap_open(partrelid, NoLock);
+
 			(*num_parted)++;
 			parted_rels = lappend(parted_rels, partrel);
 			parted_rel_parents = lappend(parted_rel_parents, parent);
 			APPEND_REL_PARTITION_OIDS(partrel, all_parts, all_parents);
 		}
-		else
-			heap_close(partrel, NoLock);
-
-		/*
-		 * We keep the partitioned ones open until we're done using the
-		 * information being collected here (for example, see
-		 * ExecEndModifyTable).
-		 */
 	}
 
 	/*
diff --git a/src/backend/executor/execMain.c b/src/backend/executor/execMain.c
index 6671a25ffb..eeadd8bec5 100644
--- a/src/backend/executor/execMain.c
+++ b/src/backend/executor/execMain.c
@@ -43,6 +43,7 @@
 #include "access/xact.h"
 #include "catalog/namespace.h"
 #include "catalog/partition.h"
+#include "catalog/pg_inherits_fn.h"
 #include "catalog/pg_publication.h"
 #include "commands/matview.h"
 #include "commands/trigger.h"
@@ -3248,10 +3249,16 @@ ExecSetupPartitionTupleRouting(Relation rel,
 	ListCell   *cell;
 	int			i;
 	ResultRelInfo *leaf_part_rri;
+	List	   *all_parts;
 
-	/* Get the tuple-routing information and lock partitions */
-	*pd = RelationGetPartitionDispatchInfo(rel, RowExclusiveLock, num_parted,
-										   &leaf_parts);
+	/*
+	 * Get the information about the partition tree after locking all the
+	 * partitions.
+	 */
+	all_parts = find_all_inheritors(RelationGetRelid(rel), RowExclusiveLock,
+									NULL);
+	list_free(all_parts);
+	*pd = RelationGetPartitionDispatchInfo(rel, num_parted, &leaf_parts);
 	*num_partitions = list_length(leaf_parts);
 	*partitions = (ResultRelInfo *) palloc(*num_partitions *
 										   sizeof(ResultRelInfo));
@@ -3274,9 +3281,8 @@ ExecSetupPartitionTupleRouting(Relation rel,
 		TupleDesc	part_tupdesc;
 
 		/*
-		 * We locked all the partitions above including the leaf partitions.
-		 * Note that each of the relations in *partitions are eventually
-		 * closed by the caller.
+		 * All the partitions were locked above.  Note that the relcache
+		 * entries will be closed by ExecEndModifyTable().
 		 */
 		partrel = heap_open(lfirst_oid(cell), NoLock);
 		part_tupdesc = RelationGetDescr(partrel);
diff --git a/src/include/catalog/partition.h b/src/include/catalog/partition.h
index bef7a0f5fb..2283c675e9 100644
--- a/src/include/catalog/partition.h
+++ b/src/include/catalog/partition.h
@@ -88,8 +88,7 @@ extern Expr *get_partition_qual_relid(Oid relid);
 
 /* For tuple routing */
 extern PartitionDispatch *RelationGetPartitionDispatchInfo(Relation rel,
-								 int lockmode, int *num_parted,
-								 List **leaf_part_oids);
+								 int *num_parted, List **leaf_part_oids);
 extern void FormPartitionKeyDatum(PartitionDispatch pd,
 					  TupleTableSlot *slot,
 					  EState *estate,
-- 
2.11.0

From e0ffad29a97f8ab2c2ee9bff1a4c1c6168c08532 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Tue, 8 Aug 2017 18:42:30 +0900
Subject: [PATCH 2/4] Teach pg_inherits.c a bit about partitioning

Both find_inheritance_children and find_all_inheritors now list
partitioned child tables before non-partitioned ones and return
the number of partitioned tables in an optional output argument

We also now store in pg_inherits, when adding a new child, if the
child is a partitioned table.

Per design idea from Robert Haas
---
 contrib/sepgsql/dml.c                  |   2 +-
 doc/src/sgml/catalogs.sgml             |  10 +++
 src/backend/catalog/partition.c        |   2 +-
 src/backend/catalog/pg_inherits.c      | 157 ++++++++++++++++++++++++++-------
 src/backend/commands/analyze.c         |   3 +-
 src/backend/commands/lockcmds.c        |   2 +-
 src/backend/commands/publicationcmds.c |   2 +-
 src/backend/commands/tablecmds.c       |  56 +++++++-----
 src/backend/commands/vacuum.c          |   3 +-
 src/backend/executor/execMain.c        |   2 +-
 src/backend/optimizer/prep/prepunion.c |   2 +-
 src/include/catalog/pg_inherits.h      |   4 +-
 src/include/catalog/pg_inherits_fn.h   |   5 +-
 13 files changed, 187 insertions(+), 63 deletions(-)

diff --git a/contrib/sepgsql/dml.c b/contrib/sepgsql/dml.c
index b643720e36..6fc279805c 100644
--- a/contrib/sepgsql/dml.c
+++ b/contrib/sepgsql/dml.c
@@ -333,7 +333,7 @@ sepgsql_dml_privileges(List *rangeTabls, bool abort_on_violation)
 		if (!rte->inh)
 			tableIds = list_make1_oid(rte->relid);
 		else
-			tableIds = find_all_inheritors(rte->relid, NoLock, NULL);
+			tableIds = find_all_inheritors(rte->relid, NoLock, NULL, NULL);
 
 		foreach(li, tableIds)
 		{
diff --git a/doc/src/sgml/catalogs.sgml b/doc/src/sgml/catalogs.sgml
index ef7054cf26..c1d5a75020 100644
--- a/doc/src/sgml/catalogs.sgml
+++ b/doc/src/sgml/catalogs.sgml
@@ -3894,6 +3894,16 @@ SCRAM-SHA-256$<replaceable>&lt;iteration count&gt;</>:<replaceable>&lt;salt&gt;<
        inherited columns are to be arranged.  The count starts at 1.
       </entry>
      </row>
+
+     <row>
+      <entry><structfield>inhchildparted</structfield></entry>
+      <entry><type>bool</type></entry>
+      <entry></entry>
+      <entry>
+       This is <literal>true</> if the child table is a partitioned table,
+       <literal>false</> otherwise
+      </entry>
+     </row>
     </tbody>
    </tgroup>
   </table>
diff --git a/src/backend/catalog/partition.c b/src/backend/catalog/partition.c
index 96a64ce6b2..efc025ec42 100644
--- a/src/backend/catalog/partition.c
+++ b/src/backend/catalog/partition.c
@@ -178,7 +178,7 @@ RelationBuildPartitionDesc(Relation rel)
 		return;
 
 	/* Get partition oids from pg_inherits */
-	inhoids = find_inheritance_children(RelationGetRelid(rel), NoLock);
+	inhoids = find_inheritance_children(RelationGetRelid(rel), NoLock, NULL);
 
 	/* Collect bound spec nodes in a list */
 	i = 0;
diff --git a/src/backend/catalog/pg_inherits.c b/src/backend/catalog/pg_inherits.c
index 245a374fc9..0285bc3c33 100644
--- a/src/backend/catalog/pg_inherits.c
+++ b/src/backend/catalog/pg_inherits.c
@@ -33,6 +33,8 @@
 #include "utils/syscache.h"
 #include "utils/tqual.h"
 
+static int32 inhchildinfo_cmp(const void *p1, const void *p2);
+
 /*
  * Entry of a hash table used in find_all_inheritors. See below.
  */
@@ -42,6 +44,30 @@ typedef struct SeenRelsEntry
 	ListCell   *numparents_cell;	/* corresponding list cell */
 } SeenRelsEntry;
 
+/* Information about one inheritance child table. */
+typedef struct InhChildInfo
+{
+	Oid			relid;
+	bool		is_partitioned;
+} InhChildInfo;
+
+#define OID_CMP(o1, o2) \
+		((o1) < (o2) ? -1 : ((o1) > (o2) ? 1 : 0));
+
+static int32
+inhchildinfo_cmp(const void *p1, const void *p2)
+{
+	InhChildInfo c1 = *((const InhChildInfo *) p1);
+	InhChildInfo c2 = *((const InhChildInfo *) p2);
+
+	if (c1.is_partitioned && !c2.is_partitioned)
+		return -1;
+	if (!c1.is_partitioned && c2.is_partitioned)
+		return 1;
+
+	return OID_CMP(c1.relid, c2.relid);
+}
+
 /*
  * find_inheritance_children
  *
@@ -54,7 +80,8 @@ typedef struct SeenRelsEntry
  * against possible DROPs of child relations.
  */
 List *
-find_inheritance_children(Oid parentrelId, LOCKMODE lockmode)
+find_inheritance_children(Oid parentrelId, LOCKMODE lockmode,
+						  int *num_partitioned_children)
 {
 	List	   *list = NIL;
 	Relation	relation;
@@ -62,9 +89,10 @@ find_inheritance_children(Oid parentrelId, LOCKMODE lockmode)
 	ScanKeyData key[1];
 	HeapTuple	inheritsTuple;
 	Oid			inhrelid;
-	Oid		   *oidarr;
-	int			maxoids,
-				numoids,
+	InhChildInfo *inhchildren;
+	int			maxchildren,
+				numchildren,
+				my_num_partitioned_children,
 				i;
 
 	/*
@@ -77,9 +105,10 @@ find_inheritance_children(Oid parentrelId, LOCKMODE lockmode)
 	/*
 	 * Scan pg_inherits and build a working array of subclass OIDs.
 	 */
-	maxoids = 32;
-	oidarr = (Oid *) palloc(maxoids * sizeof(Oid));
-	numoids = 0;
+	maxchildren = 32;
+	inhchildren = (InhChildInfo *) palloc(maxchildren * sizeof(InhChildInfo));
+	numchildren = 0;
+	my_num_partitioned_children = 0;
 
 	relation = heap_open(InheritsRelationId, AccessShareLock);
 
@@ -93,34 +122,49 @@ find_inheritance_children(Oid parentrelId, LOCKMODE lockmode)
 
 	while ((inheritsTuple = systable_getnext(scan)) != NULL)
 	{
+		bool	is_partitioned;
+
 		inhrelid = ((Form_pg_inherits) GETSTRUCT(inheritsTuple))->inhrelid;
-		if (numoids >= maxoids)
+		is_partitioned = ((Form_pg_inherits)
+								GETSTRUCT(inheritsTuple))->inhchildparted;
+
+		if (numchildren >= maxchildren)
 		{
-			maxoids *= 2;
-			oidarr = (Oid *) repalloc(oidarr, maxoids * sizeof(Oid));
+			maxchildren *= 2;
+			inhchildren = (InhChildInfo *) repalloc(inhchildren,
+										maxchildren * sizeof(InhChildInfo));
 		}
-		oidarr[numoids++] = inhrelid;
+		inhchildren[numchildren].relid = inhrelid;
+		inhchildren[numchildren].is_partitioned = is_partitioned;
+
+		if (is_partitioned)
+			my_num_partitioned_children++;
+		numchildren++;
 	}
 
 	systable_endscan(scan);
 
 	heap_close(relation, AccessShareLock);
 
+	if (num_partitioned_children)
+		*num_partitioned_children = my_num_partitioned_children;
+
 	/*
 	 * If we found more than one child, sort them by OID.  This ensures
 	 * reasonably consistent behavior regardless of the vagaries of an
 	 * indexscan.  This is important since we need to be sure all backends
 	 * lock children in the same order to avoid needless deadlocks.
 	 */
-	if (numoids > 1)
-		qsort(oidarr, numoids, sizeof(Oid), oid_cmp);
+	if (numchildren > 1)
+		qsort(inhchildren, numchildren, sizeof(InhChildInfo),
+			  inhchildinfo_cmp);
 
 	/*
 	 * Acquire locks and build the result list.
 	 */
-	for (i = 0; i < numoids; i++)
+	for (i = 0; i < numchildren; i++)
 	{
-		inhrelid = oidarr[i];
+		inhrelid = inhchildren[i].relid;
 
 		if (lockmode != NoLock)
 		{
@@ -144,7 +188,7 @@ find_inheritance_children(Oid parentrelId, LOCKMODE lockmode)
 		list = lappend_oid(list, inhrelid);
 	}
 
-	pfree(oidarr);
+	pfree(inhchildren);
 
 	return list;
 }
@@ -159,18 +203,28 @@ find_inheritance_children(Oid parentrelId, LOCKMODE lockmode)
  *		given rel.
  *
  * The specified lock type is acquired on all child relations (but not on the
- * given rel; caller should already have locked it).  If lockmode is NoLock
- * then no locks are acquired, but caller must beware of race conditions
- * against possible DROPs of child relations.
+ * given rel; caller should already have locked it), unless
+ * lock_only_partitioned_children is specified, in which case, only the
+ * child relations that are partitioned tables are locked.  If lockmode is
+ * NoLock then no locks are acquired, but caller must beware of race
+ * conditions against possible DROPs of child relations.
+ *
+ * Returned list of OIDs is such that all the partitioned tables in the tree
+ * appear at the head of the list.  If num_partitioned_children is non-NULL,
+ * *num_partitioned_children returns the number of partitioned child table
+ * OIDs at the head of the list.
  */
 List *
-find_all_inheritors(Oid parentrelId, LOCKMODE lockmode, List **numparents)
+find_all_inheritors(Oid parentrelId, LOCKMODE lockmode,
+					List **numparents, int *num_partitioned_children)
 {
 	/* hash table for O(1) rel_oid -> rel_numparents cell lookup */
 	HTAB	   *seen_rels;
 	HASHCTL		ctl;
 	List	   *rels_list,
-			   *rel_numparents;
+			   *rel_numparents,
+			   *partitioned_rels_list,
+			   *other_rels_list;
 	ListCell   *l;
 
 	memset(&ctl, 0, sizeof(ctl));
@@ -185,31 +239,71 @@ find_all_inheritors(Oid parentrelId, LOCKMODE lockmode, List **numparents)
 
 	/*
 	 * We build a list starting with the given rel and adding all direct and
-	 * indirect children.  We can use a single list as both the record of
-	 * already-found rels and the agenda of rels yet to be scanned for more
-	 * children.  This is a bit tricky but works because the foreach() macro
-	 * doesn't fetch the next list element until the bottom of the loop.
+	 * indirect children.  We can use a single list (rels_list) as both the
+	 * record of already-found rels and the agenda of rels yet to be scanned
+	 * for more children.  This is a bit tricky but works because the foreach()
+	 * macro doesn't fetch the next list element until the bottom of the loop.
+	 *
+	 * partitioned_child_rels will contain the OIDs of the partitioned child
+	 * tables and other_rels_list will contain the OIDs of the non-partitioned
+	 * child tables.  Result list will be generated by concatening the two
+	 * lists together with partitioned_child_rels appearing first.
 	 */
 	rels_list = list_make1_oid(parentrelId);
+	partitioned_rels_list = list_make1_oid(parentrelId);
+	other_rels_list = NIL;
 	rel_numparents = list_make1_int(0);
 
+	if (num_partitioned_children)
+		*num_partitioned_children = 0;
+
 	foreach(l, rels_list)
 	{
 		Oid			currentrel = lfirst_oid(l);
 		List	   *currentchildren;
-		ListCell   *lc;
+		ListCell   *lc,
+				   *first_nonpartitioned_child;
+		int			cur_num_partitioned_children = 0,
+					i;
 
 		/* Get the direct children of this rel */
-		currentchildren = find_inheritance_children(currentrel, lockmode);
+		currentchildren = find_inheritance_children(currentrel, lockmode,
+											&cur_num_partitioned_children);
+
+		if (num_partitioned_children)
+			*num_partitioned_children += cur_num_partitioned_children;
+
+		/*
+		 * Append partitioned children to rels_list and partitioned_rels_list.
+		 * We know for sure that partitioned children don't need the
+		 * the de-duplication logic in the following loop, because partitioned
+		 * tables are not allowed to partiticipate in multiple inheritance.
+		 */
+		i = 0;
+		foreach(lc, currentchildren)
+		{
+			if (i < cur_num_partitioned_children)
+			{
+				Oid		child_oid = lfirst_oid(lc);
+
+				rels_list = lappend_oid(rels_list, child_oid);
+				partitioned_rels_list = lappend_oid(partitioned_rels_list,
+													child_oid);
+			}
+			else
+				break;
+			i++;
+		}
+		first_nonpartitioned_child = lc;
 
 		/*
 		 * Add to the queue only those children not already seen. This avoids
 		 * making duplicate entries in case of multiple inheritance paths from
 		 * the same parent.  (It'll also keep us from getting into an infinite
 		 * loop, though theoretically there can't be any cycles in the
-		 * inheritance graph anyway.)
+		 * inheritance graph anyway.)  Also, add them to the other_rels_list.
 		 */
-		foreach(lc, currentchildren)
+		for_each_cell(lc, first_nonpartitioned_child)
 		{
 			Oid			child_oid = lfirst_oid(lc);
 			bool		found;
@@ -225,6 +319,7 @@ find_all_inheritors(Oid parentrelId, LOCKMODE lockmode, List **numparents)
 			{
 				/* if it's not there, add it. expect 1 parent, initially. */
 				rels_list = lappend_oid(rels_list, child_oid);
+				other_rels_list = lappend_oid(other_rels_list, child_oid);
 				rel_numparents = lappend_int(rel_numparents, 1);
 				hash_entry->numparents_cell = rel_numparents->tail;
 			}
@@ -237,8 +332,10 @@ find_all_inheritors(Oid parentrelId, LOCKMODE lockmode, List **numparents)
 		list_free(rel_numparents);
 
 	hash_destroy(seen_rels);
+	list_free(rels_list);
 
-	return rels_list;
+	/* List partitioned child tables before non-partitioned ones. */
+	return list_concat(partitioned_rels_list, other_rels_list);
 }
 
 
diff --git a/src/backend/commands/analyze.c b/src/backend/commands/analyze.c
index 2b638271b3..ae8ce71e1c 100644
--- a/src/backend/commands/analyze.c
+++ b/src/backend/commands/analyze.c
@@ -1282,7 +1282,8 @@ acquire_inherited_sample_rows(Relation onerel, int elevel,
 	 * the children.
 	 */
 	tableOIDs =
-		find_all_inheritors(RelationGetRelid(onerel), AccessShareLock, NULL);
+		find_all_inheritors(RelationGetRelid(onerel), AccessShareLock, NULL,
+							NULL);
 
 	/*
 	 * Check that there's at least one descendant, else fail.  This could
diff --git a/src/backend/commands/lockcmds.c b/src/backend/commands/lockcmds.c
index 9fe9e022b0..529f244f7e 100644
--- a/src/backend/commands/lockcmds.c
+++ b/src/backend/commands/lockcmds.c
@@ -112,7 +112,7 @@ LockTableRecurse(Oid reloid, LOCKMODE lockmode, bool nowait)
 	List	   *children;
 	ListCell   *lc;
 
-	children = find_inheritance_children(reloid, NoLock);
+	children = find_inheritance_children(reloid, NoLock, NULL);
 
 	foreach(lc, children)
 	{
diff --git a/src/backend/commands/publicationcmds.c b/src/backend/commands/publicationcmds.c
index 610cb499d2..64179ea3ef 100644
--- a/src/backend/commands/publicationcmds.c
+++ b/src/backend/commands/publicationcmds.c
@@ -516,7 +516,7 @@ OpenTableList(List *tables)
 			List	   *children;
 
 			children = find_all_inheritors(myrelid, ShareUpdateExclusiveLock,
-										   NULL);
+										   NULL, NULL);
 
 			foreach(child, children)
 			{
diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c
index 513a9ec485..a35d7810f2 100644
--- a/src/backend/commands/tablecmds.c
+++ b/src/backend/commands/tablecmds.c
@@ -299,10 +299,10 @@ static bool MergeCheckConstraint(List *constraints, char *name, Node *expr);
 static void MergeAttributesIntoExisting(Relation child_rel, Relation parent_rel);
 static void MergeConstraintsIntoExisting(Relation child_rel, Relation parent_rel);
 static void StoreCatalogInheritance(Oid relationId, List *supers,
-						bool child_is_partition);
+						bool child_is_partition, bool child_is_partitioned);
 static void StoreCatalogInheritance1(Oid relationId, Oid parentOid,
 						 int16 seqNumber, Relation inhRelation,
-						 bool child_is_partition);
+						 bool child_is_partition, bool child_is_partitioned);
 static int	findAttrByName(const char *attributeName, List *schema);
 static void AlterIndexNamespaces(Relation classRel, Relation rel,
 					 Oid oldNspOid, Oid newNspOid, ObjectAddresses *objsMoved);
@@ -746,7 +746,8 @@ DefineRelation(CreateStmt *stmt, char relkind, Oid ownerId,
 										  typaddress);
 
 	/* Store inheritance information for new rel. */
-	StoreCatalogInheritance(relationId, inheritOids, stmt->partbound != NULL);
+	StoreCatalogInheritance(relationId, inheritOids, stmt->partbound != NULL,
+							relkind == RELKIND_PARTITIONED_TABLE);
 
 	/*
 	 * We must bump the command counter to make the newly-created relation
@@ -1231,7 +1232,8 @@ ExecuteTruncate(TruncateStmt *stmt)
 			ListCell   *child;
 			List	   *children;
 
-			children = find_all_inheritors(myrelid, AccessExclusiveLock, NULL);
+			children = find_all_inheritors(myrelid, AccessExclusiveLock, NULL,
+										   NULL);
 
 			foreach(child, children)
 			{
@@ -2297,7 +2299,7 @@ MergeCheckConstraint(List *constraints, char *name, Node *expr)
  */
 static void
 StoreCatalogInheritance(Oid relationId, List *supers,
-						bool child_is_partition)
+						bool child_is_partition, bool child_is_partitioned)
 {
 	Relation	relation;
 	int16		seqNumber;
@@ -2328,7 +2330,7 @@ StoreCatalogInheritance(Oid relationId, List *supers,
 		Oid			parentOid = lfirst_oid(entry);
 
 		StoreCatalogInheritance1(relationId, parentOid, seqNumber, relation,
-								 child_is_partition);
+								 child_is_partition, child_is_partitioned);
 		seqNumber++;
 	}
 
@@ -2342,7 +2344,7 @@ StoreCatalogInheritance(Oid relationId, List *supers,
 static void
 StoreCatalogInheritance1(Oid relationId, Oid parentOid,
 						 int16 seqNumber, Relation inhRelation,
-						 bool child_is_partition)
+						 bool child_is_partition, bool child_is_partitioned)
 {
 	TupleDesc	desc = RelationGetDescr(inhRelation);
 	Datum		values[Natts_pg_inherits];
@@ -2357,6 +2359,8 @@ StoreCatalogInheritance1(Oid relationId, Oid parentOid,
 	values[Anum_pg_inherits_inhrelid - 1] = ObjectIdGetDatum(relationId);
 	values[Anum_pg_inherits_inhparent - 1] = ObjectIdGetDatum(parentOid);
 	values[Anum_pg_inherits_inhseqno - 1] = Int16GetDatum(seqNumber);
+	values[Anum_pg_inherits_inhchildparted - 1] =
+									BoolGetDatum(child_is_partitioned);
 
 	memset(nulls, 0, sizeof(nulls));
 
@@ -2556,7 +2560,7 @@ renameatt_internal(Oid myrelid,
 		 * outside the inheritance hierarchy being processed.
 		 */
 		child_oids = find_all_inheritors(myrelid, AccessExclusiveLock,
-										 &child_numparents);
+										 &child_numparents, NULL);
 
 		/*
 		 * find_all_inheritors does the recursive search of the inheritance
@@ -2583,7 +2587,7 @@ renameatt_internal(Oid myrelid,
 		 * expected_parents will only be 0 if we are not already recursing.
 		 */
 		if (expected_parents == 0 &&
-			find_inheritance_children(myrelid, NoLock) != NIL)
+			find_inheritance_children(myrelid, NoLock, NULL) != NIL)
 			ereport(ERROR,
 					(errcode(ERRCODE_INVALID_TABLE_DEFINITION),
 					 errmsg("inherited column \"%s\" must be renamed in child tables too",
@@ -2766,7 +2770,7 @@ rename_constraint_internal(Oid myrelid,
 					   *li;
 
 			child_oids = find_all_inheritors(myrelid, AccessExclusiveLock,
-											 &child_numparents);
+											 &child_numparents, NULL);
 
 			forboth(lo, child_oids, li, child_numparents)
 			{
@@ -2782,7 +2786,7 @@ rename_constraint_internal(Oid myrelid,
 		else
 		{
 			if (expected_parents == 0 &&
-				find_inheritance_children(myrelid, NoLock) != NIL)
+				find_inheritance_children(myrelid, NoLock, NULL) != NIL)
 				ereport(ERROR,
 						(errcode(ERRCODE_INVALID_TABLE_DEFINITION),
 						 errmsg("inherited constraint \"%s\" must be renamed in child tables too",
@@ -4790,7 +4794,7 @@ ATSimpleRecursion(List **wqueue, Relation rel,
 		ListCell   *child;
 		List	   *children;
 
-		children = find_all_inheritors(relid, lockmode, NULL);
+		children = find_all_inheritors(relid, lockmode, NULL, NULL);
 
 		/*
 		 * find_all_inheritors does the recursive search of the inheritance
@@ -5199,7 +5203,7 @@ ATExecAddColumn(List **wqueue, AlteredTableInfo *tab, Relation rel,
 	 */
 	if (colDef->identity &&
 		recurse &&
-		find_inheritance_children(myrelid, NoLock) != NIL)
+		find_inheritance_children(myrelid, NoLock, NULL) != NIL)
 		ereport(ERROR,
 				(errcode(ERRCODE_INVALID_TABLE_DEFINITION),
 				 errmsg("cannot recursively add identity column to table that has child tables")));
@@ -5405,7 +5409,8 @@ ATExecAddColumn(List **wqueue, AlteredTableInfo *tab, Relation rel,
 	 * routines, we have to do this one level of recursion at a time; we can't
 	 * use find_all_inheritors to do it in one pass.
 	 */
-	children = find_inheritance_children(RelationGetRelid(rel), lockmode);
+	children = find_inheritance_children(RelationGetRelid(rel), lockmode,
+										 NULL);
 
 	/*
 	 * If we are told not to recurse, there had better not be any child
@@ -6524,7 +6529,8 @@ ATExecDropColumn(List **wqueue, Relation rel, const char *colName,
 	 * routines, we have to do this one level of recursion at a time; we can't
 	 * use find_all_inheritors to do it in one pass.
 	 */
-	children = find_inheritance_children(RelationGetRelid(rel), lockmode);
+	children = find_inheritance_children(RelationGetRelid(rel), lockmode,
+										 NULL);
 
 	if (children)
 	{
@@ -6958,7 +6964,8 @@ ATAddCheckConstraint(List **wqueue, AlteredTableInfo *tab, Relation rel,
 	 * routines, we have to do this one level of recursion at a time; we can't
 	 * use find_all_inheritors to do it in one pass.
 	 */
-	children = find_inheritance_children(RelationGetRelid(rel), lockmode);
+	children = find_inheritance_children(RelationGetRelid(rel), lockmode,
+										 NULL);
 
 	/*
 	 * Check if ONLY was specified with ALTER TABLE.  If so, allow the
@@ -7677,7 +7684,7 @@ ATExecValidateConstraint(Relation rel, char *constrName, bool recurse,
 			 */
 			if (!recursing && !con->connoinherit)
 				children = find_all_inheritors(RelationGetRelid(rel),
-											   lockmode, NULL);
+											   lockmode, NULL, NULL);
 
 			/*
 			 * For CHECK constraints, we must ensure that we only mark the
@@ -8560,7 +8567,8 @@ ATExecDropConstraint(Relation rel, const char *constrName,
 	 * use find_all_inheritors to do it in one pass.
 	 */
 	if (!is_no_inherit_constraint)
-		children = find_inheritance_children(RelationGetRelid(rel), lockmode);
+		children = find_inheritance_children(RelationGetRelid(rel), lockmode,
+											 NULL);
 	else
 		children = NIL;
 
@@ -8849,7 +8857,7 @@ ATPrepAlterColumnType(List **wqueue,
 		ListCell   *child;
 		List	   *children;
 
-		children = find_all_inheritors(relid, lockmode, NULL);
+		children = find_all_inheritors(relid, lockmode, NULL, NULL);
 
 		/*
 		 * find_all_inheritors does the recursive search of the inheritance
@@ -8900,7 +8908,8 @@ ATPrepAlterColumnType(List **wqueue,
 		}
 	}
 	else if (!recursing &&
-			 find_inheritance_children(RelationGetRelid(rel), NoLock) != NIL)
+			 find_inheritance_children(RelationGetRelid(rel),
+									   NoLock, NULL) != NIL)
 		ereport(ERROR,
 				(errcode(ERRCODE_INVALID_TABLE_DEFINITION),
 				 errmsg("type of inherited column \"%s\" must be changed in child tables too",
@@ -11010,7 +11019,7 @@ ATExecAddInherit(Relation child_rel, RangeVar *parent, LOCKMODE lockmode)
 	 * We use weakest lock we can on child's children, namely AccessShareLock.
 	 */
 	children = find_all_inheritors(RelationGetRelid(child_rel),
-								   AccessShareLock, NULL);
+								   AccessShareLock, NULL, NULL);
 
 	if (list_member_oid(children, RelationGetRelid(parent_rel)))
 		ereport(ERROR,
@@ -11119,6 +11128,8 @@ CreateInheritance(Relation child_rel, Relation parent_rel)
 							 inhseqno + 1,
 							 catalogRelation,
 							 parent_rel->rd_rel->relkind ==
+							 RELKIND_PARTITIONED_TABLE,
+							 child_rel->rd_rel->relkind ==
 							 RELKIND_PARTITIONED_TABLE);
 
 	/* Now we're done with pg_inherits */
@@ -13516,7 +13527,8 @@ ATExecAttachPartition(List **wqueue, Relation rel, PartitionCmd *cmd)
 	 * weaker lock now and the stronger one only when needed.
 	 */
 	attachrel_children = find_all_inheritors(RelationGetRelid(attachrel),
-											 AccessExclusiveLock, NULL);
+											 AccessExclusiveLock, NULL,
+											 NULL);
 	if (list_member_oid(attachrel_children, RelationGetRelid(rel)))
 		ereport(ERROR,
 				(errcode(ERRCODE_DUPLICATE_TABLE),
diff --git a/src/backend/commands/vacuum.c b/src/backend/commands/vacuum.c
index faa181207a..e2e5ffce42 100644
--- a/src/backend/commands/vacuum.c
+++ b/src/backend/commands/vacuum.c
@@ -430,7 +430,8 @@ get_rel_oids(Oid relid, const RangeVar *vacrel)
 		oldcontext = MemoryContextSwitchTo(vac_context);
 		if (include_parts)
 			oid_list = list_concat(oid_list,
-								   find_all_inheritors(relid, NoLock, NULL));
+								   find_all_inheritors(relid, NoLock, NULL,
+													   NULL));
 		else
 			oid_list = lappend_oid(oid_list, relid);
 		MemoryContextSwitchTo(oldcontext);
diff --git a/src/backend/executor/execMain.c b/src/backend/executor/execMain.c
index eeadd8bec5..3db8b6f971 100644
--- a/src/backend/executor/execMain.c
+++ b/src/backend/executor/execMain.c
@@ -3256,7 +3256,7 @@ ExecSetupPartitionTupleRouting(Relation rel,
 	 * partitions.
 	 */
 	all_parts = find_all_inheritors(RelationGetRelid(rel), RowExclusiveLock,
-									NULL);
+									NULL, NULL);
 	list_free(all_parts);
 	*pd = RelationGetPartitionDispatchInfo(rel, num_parted, &leaf_parts);
 	*num_partitions = list_length(leaf_parts);
diff --git a/src/backend/optimizer/prep/prepunion.c b/src/backend/optimizer/prep/prepunion.c
index 6d8f8938b2..a59081103a 100644
--- a/src/backend/optimizer/prep/prepunion.c
+++ b/src/backend/optimizer/prep/prepunion.c
@@ -1424,7 +1424,7 @@ 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);
+	inhOIDs = find_all_inheritors(parentOID, lockmode, NULL, NULL);
 
 	/*
 	 * Check that there's at least one descendant, else treat as no-child
diff --git a/src/include/catalog/pg_inherits.h b/src/include/catalog/pg_inherits.h
index 26bfab5db6..2c4ef246a4 100644
--- a/src/include/catalog/pg_inherits.h
+++ b/src/include/catalog/pg_inherits.h
@@ -33,6 +33,7 @@ CATALOG(pg_inherits,2611) BKI_WITHOUT_OIDS
 	Oid			inhrelid;
 	Oid			inhparent;
 	int32		inhseqno;
+	bool		inhchildparted;
 } FormData_pg_inherits;
 
 /* ----------------
@@ -46,10 +47,11 @@ typedef FormData_pg_inherits *Form_pg_inherits;
  *		compiler constants for pg_inherits
  * ----------------
  */
-#define Natts_pg_inherits				3
+#define Natts_pg_inherits				4
 #define Anum_pg_inherits_inhrelid		1
 #define Anum_pg_inherits_inhparent		2
 #define Anum_pg_inherits_inhseqno		3
+#define Anum_pg_inherits_inhchildparted	4
 
 /* ----------------
  *		pg_inherits has no initial contents
diff --git a/src/include/catalog/pg_inherits_fn.h b/src/include/catalog/pg_inherits_fn.h
index 7743388899..8f371acae7 100644
--- a/src/include/catalog/pg_inherits_fn.h
+++ b/src/include/catalog/pg_inherits_fn.h
@@ -17,9 +17,10 @@
 #include "nodes/pg_list.h"
 #include "storage/lock.h"
 
-extern List *find_inheritance_children(Oid parentrelId, LOCKMODE lockmode);
+extern List *find_inheritance_children(Oid parentrelId, LOCKMODE lockmode,
+						  int *num_partitioned_children);
 extern List *find_all_inheritors(Oid parentrelId, LOCKMODE lockmode,
-					List **parents);
+					List **parents, int *num_partitioned_children);
 extern bool has_subclass(Oid relationId);
 extern bool has_superclass(Oid relationId);
 extern bool typeInheritsFrom(Oid subclassTypeId, Oid superclassTypeId);
-- 
2.11.0

From 928eabebed8806f2ead413744ac196bb9caef646 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Wed, 9 Aug 2017 15:52:36 +0900
Subject: [PATCH 3/4] Teach expand_inherited_rtentry to use partition bound
 order

After locking the child tables using find_all_inheritors, we discard
the list of child table OIDs that it generates and rebuild the same
using the information returned by RelationGetPartitionDispatchInfo.
---
 src/backend/optimizer/prep/prepunion.c | 51 ++++++++++++++++++++++++++++++++++
 1 file changed, 51 insertions(+)

diff --git a/src/backend/optimizer/prep/prepunion.c b/src/backend/optimizer/prep/prepunion.c
index a59081103a..734a7e55df 100644
--- a/src/backend/optimizer/prep/prepunion.c
+++ b/src/backend/optimizer/prep/prepunion.c
@@ -33,6 +33,7 @@
 #include "access/heapam.h"
 #include "access/htup_details.h"
 #include "access/sysattr.h"
+#include "catalog/partition.h"
 #include "catalog/pg_inherits_fn.h"
 #include "catalog/pg_type.h"
 #include "miscadmin.h"
@@ -1452,6 +1453,56 @@ expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti)
 	 */
 	oldrelation = heap_open(parentOID, NoLock);
 
+	/*
+	 * For partitioned tables, we arrange the child table OIDs such that they
+	 * appear in the partition bound order.
+	 */
+	if (rte->relkind == RELKIND_PARTITIONED_TABLE)
+	{
+		List   *leaf_part_oids;
+		int		num_parted,
+				i;
+		PartitionDispatch *pds;
+
+		/* Discard the original list. */
+		list_free(inhOIDs);
+		inhOIDs = NIL;
+
+		/* Request partitioning information. */
+		pds = RelationGetPartitionDispatchInfo(oldrelation, &num_parted,
+											   &leaf_part_oids);
+
+		/*
+		 * First collect the partitioned child table OIDs, which includes the
+		 * root parent at the head.
+		 */
+		for (i = 0; i < num_parted; i++)
+		{
+			PartitionDispatch pd = pds[i];
+
+			inhOIDs = lappend_oid(inhOIDs, RelationGetRelid(pd->reldesc));
+		}
+
+		/* Concatenate the leaf partition OIDs. */
+		inhOIDs = list_concat(inhOIDs, leaf_part_oids);
+
+		/*
+		 * Release the resources that RelationGetPartitionDispatchInfo
+		 * acquired for us but we don't really need in this case.  Note that
+		 * we don't touch the root partitioned table itself by starting the
+		 * loop with 1, not 0.
+		 */
+		for (i = 1; i < num_parted; i++)
+		{
+			PartitionDispatch pd = pds[i];
+
+			heap_close(pd->reldesc, NoLock);
+			ExecDropSingleTupleTableSlot(pd->tupslot);
+			if (pd->tupmap)
+				pfree(pd->tupmap);
+		}
+	}
+
 	/* Scan the inheritance set and expand it */
 	appinfos = NIL;
 	has_child = false;
-- 
2.11.0

From b2e3f1508534ddc49f192437b44810a6f0a0f1b4 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Mon, 24 Jul 2017 18:59:57 +0900
Subject: [PATCH 4/4] Decouple RelationGetPartitionDispatchInfo() from executor

Currently it and the structure it generates viz. PartitionDispatch
objects are too coupled with the executor's tuple-routing code.  In
particular, it's pretty undesirable that it makes it the responsibility
of the caller to release some resources, such as relcache references
and tuple table slots.  That makes it harder to use in places other
than where it's currently being used.

After this refactoring, ExecSetupPartitionTupleRouting() now needs to
do some of the work that was previously done in
RelationGetPartitionDispatchInfo() and expand_inherited_rtentry() no
longer needs to do some things that it used to.
---
 src/backend/catalog/partition.c        | 309 +++++++++++++++++----------------
 src/backend/commands/copy.c            |  35 ++--
 src/backend/executor/execMain.c        | 146 ++++++++++++++--
 src/backend/executor/nodeModifyTable.c |  29 ++--
 src/backend/optimizer/prep/prepunion.c |  32 +---
 src/include/catalog/partition.h        |  52 +++---
 src/include/executor/executor.h        |   4 +-
 src/include/nodes/execnodes.h          |  53 +++++-
 8 files changed, 399 insertions(+), 261 deletions(-)

diff --git a/src/backend/catalog/partition.c b/src/backend/catalog/partition.c
index efc025ec42..36f5c80b4f 100644
--- a/src/backend/catalog/partition.c
+++ b/src/backend/catalog/partition.c
@@ -105,6 +105,24 @@ typedef struct PartitionRangeBound
 	bool		lower;			/* this is the lower (vs upper) bound */
 } PartitionRangeBound;
 
+/*-----------------------
+ * PartitionDispatchData - information of partitions of one partitioned table
+ *						   in a partition tree
+ *
+ *	partkey		Partition key of the table
+ *	partdesc	Partition descriptor of the table
+ *	indexes		Array with partdesc->nparts members (for details on what the
+ *				individual value represents, see the comments in
+ *				RelationGetPartitionDispatchInfo())
+ *-----------------------
+ */
+typedef struct PartitionDispatchData
+{
+	PartitionKey	partkey;	/* Points into the table's relcache entry */
+	PartitionDesc	partdesc;	/* Ditto */
+	int			   *indexes;
+} PartitionDispatchData;
+
 static int32 qsort_partition_list_value_cmp(const void *a, const void *b,
 							   void *arg);
 static int32 qsort_partition_rbound_cmp(const void *a, const void *b,
@@ -981,181 +999,165 @@ get_partition_qual_relid(Oid relid)
 }
 
 /*
- * Append OIDs of rel's partitions to the list 'partoids' and for each OID,
- * append pointer rel to the list 'parents'.
- */
-#define APPEND_REL_PARTITION_OIDS(rel, partoids, parents) \
-	do\
-	{\
-		int		i;\
-		for (i = 0; i < (rel)->rd_partdesc->nparts; i++)\
-		{\
-			(partoids) = lappend_oid((partoids), (rel)->rd_partdesc->oids[i]);\
-			(parents) = lappend((parents), (rel));\
-		}\
-	} while(0)
-
-/*
  * RelationGetPartitionDispatchInfo
- *		Returns information necessary to route tuples down a partition tree
+ *		Returns necessary information for each partition in the partition
+ *		tree rooted at rel
  *
- * The number of elements in the returned array (that is, the number of
- * PartitionDispatch objects for the partitioned tables in the partition tree)
- * is returned in *num_parted and a list of the OIDs of all the leaf
- * partitions of rel is returned in *leaf_part_oids.
+ * Information returned includes the following: *ptinfos contains a list of
+ * PartitionedTableInfo objects, one for each partitioned table (with at least
+ * one member, that is, one for the root partitioned table), *leaf_part_oids
+ * contains a list of the OIDs of of all the leaf partitions.
  *
- * All the relations in the partition tree (including 'rel') must have been
- * locked (using at least the AccessShareLock) by the caller.
+ * We require that the caller has locked at least the partitioned tables in the
+ * partition tree (including 'rel') using at least the AccessShareLock,
+ * because we need to look at their relcache entries to get PartitionKey and
+ * PartitionDesc.
  */
-PartitionDispatch *
+void
 RelationGetPartitionDispatchInfo(Relation rel,
-								 int *num_parted, List **leaf_part_oids)
+								 List **ptinfos, List **leaf_part_oids)
 {
-	PartitionDispatchData **pd;
-	List	   *all_parts = NIL,
-			   *all_parents = NIL,
-			   *parted_rels,
-			   *parted_rel_parents;
+	List	   *all_parts,
+			   *all_parents;
 	ListCell   *lc1,
 			   *lc2;
 	int			i,
-				k,
 				offset;
 
 	/*
 	 * We rely on the relcache to traverse the partition tree to build both
-	 * the leaf partition OIDs list and the array of PartitionDispatch objects
-	 * for the partitioned tables in the tree.  That means every partitioned
-	 * table in the tree must be locked, which is fine since we require the
-	 * caller to lock all the partitions anyway.
+	 * the leaf partition OIDs list and the list of PartitionedTableInfo
+	 * objects for partitioned tables.  That means every partitioned table in
+	 * the tree must be locked, which is fine since the callers must have done
+	 * that already.
 	 *
 	 * For every partitioned table in the tree, starting with the root
 	 * partitioned table, add its relcache entry to parted_rels, while also
 	 * queuing its partitions (in the order in which they appear in the
 	 * partition descriptor) to be looked at later in the same loop.  This is
 	 * a bit tricky but works because the foreach() macro doesn't fetch the
-	 * next list element until the bottom of the loop.
+	 * next list element until the bottom of the loop.  Non-partitioned tables
+	 * are simply added to the leaf partitions list.
 	 */
-	*num_parted = 1;
-	parted_rels = list_make1(rel);
-	/* Root partitioned table has no parent, so NULL for parent */
-	parted_rel_parents = list_make1(NULL);
-	APPEND_REL_PARTITION_OIDS(rel, all_parts, all_parents);
+	i = offset = 0;
+	*ptinfos = *leaf_part_oids = NIL;
+
+	/* Start with the root table. */
+	all_parts = list_make1_oid(RelationGetRelid(rel));
+	all_parents = list_make1_oid(InvalidOid);
 	forboth(lc1, all_parts, lc2, all_parents)
 	{
-		Oid			partrelid = lfirst_oid(lc1);
-		Relation	parent = lfirst(lc2);
+		Oid		partrelid = lfirst_oid(lc1);
+		Oid		parentrelid = lfirst_oid(lc2);
 
 		if (get_rel_relkind(partrelid) == RELKIND_PARTITIONED_TABLE)
 		{
-			/*
-			 * Already locked by the caller.  Note that it is the
-			 * responsibility of the caller to close the below relcache entry,
-			 * once done using the information being collected here (for
-			 * example, in ExecEndModifyTable).
-			 */
-			Relation	partrel = heap_open(partrelid, NoLock);
+			int		j,
+					k;
+			Relation		partrel;
+			PartitionKey	partkey;
+			PartitionDesc	partdesc;
+			PartitionedTableInfo   *ptinfo;
+			PartitionDispatch		pd;
+
+			if (partrelid != RelationGetRelid(rel))
+				partrel = heap_open(partrelid, NoLock);
+			else
+				partrel = rel;
 
-			(*num_parted)++;
-			parted_rels = lappend(parted_rels, partrel);
-			parted_rel_parents = lappend(parted_rel_parents, parent);
-			APPEND_REL_PARTITION_OIDS(partrel, all_parts, all_parents);
-		}
-	}
+			partkey = RelationGetPartitionKey(partrel);
+			partdesc = RelationGetPartitionDesc(partrel);
+
+			ptinfo = (PartitionedTableInfo *)
+									palloc0(sizeof(PartitionedTableInfo));
+			ptinfo->relid = partrelid;
+			ptinfo->parentid = parentrelid;
+
+			ptinfo->pd = pd = (PartitionDispatchData *)
+									palloc0(sizeof(PartitionDispatchData));
+			pd->partkey = partkey;
 
-	/*
-	 * We want to create two arrays - one for leaf partitions and another for
-	 * partitioned tables (including the root table and internal partitions).
-	 * While we only create the latter here, leaf partition array of suitable
-	 * objects (such as, ResultRelInfo) is created by the caller using the
-	 * list of OIDs we return.  Indexes into these arrays get assigned in a
-	 * breadth-first manner, whereby partitions of any given level are placed
-	 * consecutively in the respective arrays.
-	 */
-	pd = (PartitionDispatchData **) palloc(*num_parted *
-										   sizeof(PartitionDispatchData *));
-	*leaf_part_oids = NIL;
-	i = k = offset = 0;
-	forboth(lc1, parted_rels, lc2, parted_rel_parents)
-	{
-		Relation	partrel = lfirst(lc1);
-		Relation	parent = lfirst(lc2);
-		PartitionKey partkey = RelationGetPartitionKey(partrel);
-		TupleDesc	tupdesc = RelationGetDescr(partrel);
-		PartitionDesc partdesc = RelationGetPartitionDesc(partrel);
-		int			j,
-					m;
-
-		pd[i] = (PartitionDispatch) palloc(sizeof(PartitionDispatchData));
-		pd[i]->reldesc = partrel;
-		pd[i]->key = partkey;
-		pd[i]->keystate = NIL;
-		pd[i]->partdesc = partdesc;
-		if (parent != NULL)
-		{
 			/*
-			 * For every partitioned table other than root, we must store a
-			 * tuple table slot initialized with its tuple descriptor and a
-			 * tuple conversion map to convert a tuple from its parent's
-			 * rowtype to its own. That is to make sure that we are looking at
-			 * the correct row using the correct tuple descriptor when
-			 * computing its partition key for tuple routing.
+			 * XXX- do we need a pinning mechanism for partition descriptors
+			 * so that there references can be managed independently of
+			 * the parent relcache entry? Like PinPartitionDesc(partdesc)?
 			 */
-			pd[i]->tupslot = MakeSingleTupleTableSlot(tupdesc);
-			pd[i]->tupmap = convert_tuples_by_name(RelationGetDescr(parent),
-												   tupdesc,
-												   gettext_noop("could not convert row type"));
-		}
-		else
-		{
-			/* Not required for the root partitioned table */
-			pd[i]->tupslot = NULL;
-			pd[i]->tupmap = NULL;
-		}
-		pd[i]->indexes = (int *) palloc(partdesc->nparts * sizeof(int));
+			pd->partdesc = partdesc;
 
-		/*
-		 * Indexes corresponding to the internal partitions are multiplied by
-		 * -1 to distinguish them from those of leaf partitions.  Encountering
-		 * an index >= 0 means we found a leaf partition, which is immediately
-		 * returned as the partition we are looking for.  A negative index
-		 * means we found a partitioned table, whose PartitionDispatch object
-		 * is located at the above index multiplied back by -1.  Using the
-		 * PartitionDispatch object, search is continued further down the
-		 * partition tree.
-		 */
-		m = 0;
-		for (j = 0; j < partdesc->nparts; j++)
-		{
-			Oid			partrelid = partdesc->oids[j];
+			/*
+			 * The values contained in the following array correspond to
+			 * indexes of this table's partitions in the global sequence of
+			 * all the partitions contained in the partition tree rooted at
+			 * rel, traversed in a breadh-first manner.  The values should be
+			 * such that we will be able to distinguish the leaf partitions
+			 * from the non-leaf partitions, because they are returned to
+			 * to the caller in separate structures from where they will be
+			 * accessed.  The way that's done is described below:
+			 *
+			 * Leaf partition OIDs are put into the global leaf_part_oids list,
+			 * and for each one, the value stored is its ordinal position in
+			 * the list minus 1.
+			 *
+			 * PartitionedTableInfo objects corresponding to partitions that
+			 * are partitioned tables are put into the global ptinfos[] list,
+			 * and for each one, the value stored is its ordinal position in
+			 * the list multiplied by -1.
+			 *
+			 * So while looking at the values in the indexes array, if one
+			 * gets zero or a positive value, then it's a leaf partition,
+			 * Otherwise, it's a partitioned table.
+			 */
+			pd->indexes = (int *) palloc(partdesc->nparts * sizeof(int));
 
-			if (get_rel_relkind(partrelid) != RELKIND_PARTITIONED_TABLE)
-			{
-				*leaf_part_oids = lappend_oid(*leaf_part_oids, partrelid);
-				pd[i]->indexes[j] = k++;
-			}
-			else
+			k = 0;
+			for (j = 0; j < partdesc->nparts; j++)
 			{
+				Oid			partrelid = partdesc->oids[j];
+
 				/*
-				 * offset denotes the number of partitioned tables of upper
-				 * levels including those of the current level.  Any partition
-				 * of this table must belong to the next level and hence will
-				 * be placed after the last partitioned table of this level.
+				 * Queue this partition so that it will be processed later
+				 * by the outer loop.
 				 */
-				pd[i]->indexes[j] = -(1 + offset + m);
-				m++;
+				all_parts = lappend_oid(all_parts, partrelid);
+				all_parents = lappend_oid(all_parents,
+										  RelationGetRelid(partrel));
+
+				if (get_rel_relkind(partrelid) != RELKIND_PARTITIONED_TABLE)
+				{
+					*leaf_part_oids = lappend_oid(*leaf_part_oids, partrelid);
+					pd->indexes[j] = i++;
+				}
+				else
+				{
+					/*
+					 * offset denotes the number of partitioned tables that
+					 * we have already processed.  k counts the number of
+					 * partitions of this table that were found to be
+					 * partitioned tables.
+					 */
+					pd->indexes[j] = -(1 + offset + k);
+					k++;
+				}
 			}
-		}
-		i++;
 
-		/*
-		 * This counts the number of partitioned tables at upper levels
-		 * including those of the current level.
-		 */
-		offset += m;
+			offset += k;
+
+			/*
+			 * Release the relation descriptor.  Lock that we have on the
+			 * table will keep the PartitionDesc that is pointing into
+			 * RelationData intact, a pointer to which hope to keep
+			 * through this transaction's commit.
+			 * (XXX - how true is that?)
+			 */
+			if (partrel != rel)
+				heap_close(partrel, NoLock);
+
+			*ptinfos = lappend(*ptinfos, ptinfo);
+		}
 	}
 
-	return pd;
+	Assert(i == list_length(*leaf_part_oids));
+	Assert((offset + 1) == list_length(*ptinfos));
 }
 
 /* Module-local functions */
@@ -1872,7 +1874,7 @@ generate_partition_qual(Relation rel)
  * ----------------
  */
 void
-FormPartitionKeyDatum(PartitionDispatch pd,
+FormPartitionKeyDatum(PartitionKeyInfo *keyinfo,
 					  TupleTableSlot *slot,
 					  EState *estate,
 					  Datum *values,
@@ -1881,20 +1883,21 @@ FormPartitionKeyDatum(PartitionDispatch pd,
 	ListCell   *partexpr_item;
 	int			i;
 
-	if (pd->key->partexprs != NIL && pd->keystate == NIL)
+	if (keyinfo->key->partexprs != NIL && keyinfo->keystate == NIL)
 	{
 		/* Check caller has set up context correctly */
 		Assert(estate != NULL &&
 			   GetPerTupleExprContext(estate)->ecxt_scantuple == slot);
 
 		/* First time through, set up expression evaluation state */
-		pd->keystate = ExecPrepareExprList(pd->key->partexprs, estate);
+		keyinfo->keystate = ExecPrepareExprList(keyinfo->key->partexprs,
+												estate);
 	}
 
-	partexpr_item = list_head(pd->keystate);
-	for (i = 0; i < pd->key->partnatts; i++)
+	partexpr_item = list_head(keyinfo->keystate);
+	for (i = 0; i < keyinfo->key->partnatts; i++)
 	{
-		AttrNumber	keycol = pd->key->partattrs[i];
+		AttrNumber	keycol = keyinfo->key->partattrs[i];
 		Datum		datum;
 		bool		isNull;
 
@@ -1931,13 +1934,13 @@ FormPartitionKeyDatum(PartitionDispatch pd,
  * the latter case.
  */
 int
-get_partition_for_tuple(PartitionDispatch *pd,
+get_partition_for_tuple(PartitionTupleRoutingInfo **ptrinfos,
 						TupleTableSlot *slot,
 						EState *estate,
-						PartitionDispatchData **failed_at,
+						PartitionTupleRoutingInfo **failed_at,
 						TupleTableSlot **failed_slot)
 {
-	PartitionDispatch parent;
+	PartitionTupleRoutingInfo *parent;
 	Datum		values[PARTITION_MAX_KEYS];
 	bool		isnull[PARTITION_MAX_KEYS];
 	int			cur_offset,
@@ -1948,11 +1951,11 @@ get_partition_for_tuple(PartitionDispatch *pd,
 	TupleTableSlot *ecxt_scantuple_old = ecxt->ecxt_scantuple;
 
 	/* start with the root partitioned table */
-	parent = pd[0];
+	parent = ptrinfos[0];
 	while (true)
 	{
-		PartitionKey key = parent->key;
-		PartitionDesc partdesc = parent->partdesc;
+		PartitionKey  key = parent->pd->partkey;
+		PartitionDesc partdesc = parent->pd->partdesc;
 		TupleTableSlot *myslot = parent->tupslot;
 		TupleConversionMap *map = parent->tupmap;
 
@@ -1984,7 +1987,7 @@ get_partition_for_tuple(PartitionDispatch *pd,
 		 * So update ecxt_scantuple accordingly.
 		 */
 		ecxt->ecxt_scantuple = slot;
-		FormPartitionKeyDatum(parent, slot, estate, values, isnull);
+		FormPartitionKeyDatum(parent->keyinfo, slot, estate, values, isnull);
 
 		if (key->strategy == PARTITION_STRATEGY_RANGE)
 		{
@@ -2055,13 +2058,13 @@ get_partition_for_tuple(PartitionDispatch *pd,
 			*failed_slot = slot;
 			break;
 		}
-		else if (parent->indexes[cur_index] >= 0)
+		else if (parent->pd->indexes[cur_index] >= 0)
 		{
-			result = parent->indexes[cur_index];
+			result = parent->pd->indexes[cur_index];
 			break;
 		}
 		else
-			parent = pd[-parent->indexes[cur_index]];
+			parent = ptrinfos[-parent->pd->indexes[cur_index]];
 	}
 
 error_exit:
diff --git a/src/backend/commands/copy.c b/src/backend/commands/copy.c
index a258965c20..e17a339349 100644
--- a/src/backend/commands/copy.c
+++ b/src/backend/commands/copy.c
@@ -165,8 +165,8 @@ typedef struct CopyStateData
 	bool		volatile_defexprs;	/* is any of defexprs volatile? */
 	List	   *range_table;
 
-	PartitionDispatch *partition_dispatch_info;
-	int			num_dispatch;	/* Number of entries in the above array */
+	PartitionTupleRoutingInfo **ptrinfos;
+	int			num_parted;		/* Number of entries in the above array */
 	int			num_partitions; /* Number of members in the following arrays */
 	ResultRelInfo *partitions;	/* Per partition result relation */
 	TupleConversionMap **partition_tupconv_maps;
@@ -1425,7 +1425,7 @@ BeginCopy(ParseState *pstate,
 		/* Initialize state for CopyFrom tuple routing. */
 		if (is_from && rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
 		{
-			PartitionDispatch *partition_dispatch_info;
+			PartitionTupleRoutingInfo **ptrinfos;
 			ResultRelInfo *partitions;
 			TupleConversionMap **partition_tupconv_maps;
 			TupleTableSlot *partition_tuple_slot;
@@ -1434,13 +1434,13 @@ BeginCopy(ParseState *pstate,
 
 			ExecSetupPartitionTupleRouting(rel,
 										   1,
-										   &partition_dispatch_info,
+										   &ptrinfos,
 										   &partitions,
 										   &partition_tupconv_maps,
 										   &partition_tuple_slot,
 										   &num_parted, &num_partitions);
-			cstate->partition_dispatch_info = partition_dispatch_info;
-			cstate->num_dispatch = num_parted;
+			cstate->ptrinfos = ptrinfos;
+			cstate->num_parted = num_parted;
 			cstate->partitions = partitions;
 			cstate->num_partitions = num_partitions;
 			cstate->partition_tupconv_maps = partition_tupconv_maps;
@@ -2495,7 +2495,7 @@ CopyFrom(CopyState cstate)
 	if ((resultRelInfo->ri_TrigDesc != NULL &&
 		 (resultRelInfo->ri_TrigDesc->trig_insert_before_row ||
 		  resultRelInfo->ri_TrigDesc->trig_insert_instead_row)) ||
-		cstate->partition_dispatch_info != NULL ||
+		cstate->ptrinfos != NULL ||
 		cstate->volatile_defexprs)
 	{
 		useHeapMultiInsert = false;
@@ -2573,7 +2573,7 @@ CopyFrom(CopyState cstate)
 		ExecStoreTuple(tuple, slot, InvalidBuffer, false);
 
 		/* Determine the partition to heap_insert the tuple into */
-		if (cstate->partition_dispatch_info)
+		if (cstate->ptrinfos)
 		{
 			int			leaf_part_index;
 			TupleConversionMap *map;
@@ -2587,7 +2587,7 @@ CopyFrom(CopyState cstate)
 			 * partition, respectively.
 			 */
 			leaf_part_index = ExecFindPartition(resultRelInfo,
-												cstate->partition_dispatch_info,
+												cstate->ptrinfos,
 												slot,
 												estate);
 			Assert(leaf_part_index >= 0 &&
@@ -2819,23 +2819,20 @@ CopyFrom(CopyState cstate)
 
 	ExecCloseIndices(resultRelInfo);
 
-	/* Close all the partitioned tables, leaf partitions, and their indices */
-	if (cstate->partition_dispatch_info)
+	/* Close all the leaf partitions and their indices */
+	if (cstate->ptrinfos)
 	{
 		int			i;
 
 		/*
-		 * Remember cstate->partition_dispatch_info[0] corresponds to the root
-		 * partitioned table, which we must not try to close, because it is
-		 * the main target table of COPY that will be closed eventually by
-		 * DoCopy().  Also, tupslot is NULL for the root partitioned table.
+		 * cstate->ptrinfo[0] corresponds to the root partitioned table, for
+		 * which we didn't create tupslot.
 		 */
-		for (i = 1; i < cstate->num_dispatch; i++)
+		for (i = 1; i < cstate->num_parted; i++)
 		{
-			PartitionDispatch pd = cstate->partition_dispatch_info[i];
+			PartitionTupleRoutingInfo *ptrinfo = cstate->ptrinfos[i];
 
-			heap_close(pd->reldesc, NoLock);
-			ExecDropSingleTupleTableSlot(pd->tupslot);
+			ExecDropSingleTupleTableSlot(ptrinfo->tupslot);
 		}
 		for (i = 0; i < cstate->num_partitions; i++)
 		{
diff --git a/src/backend/executor/execMain.c b/src/backend/executor/execMain.c
index 3db8b6f971..790fd8f208 100644
--- a/src/backend/executor/execMain.c
+++ b/src/backend/executor/execMain.c
@@ -3215,8 +3215,8 @@ EvalPlanQualEnd(EPQState *epqstate)
  * tuple routing for partitioned tables
  *
  * Output arguments:
- * 'pd' receives an array of PartitionDispatch objects with one entry for
- *		every partitioned table in the partition tree
+ * 'ptrinfos' receives an array of PartitionTupleRoutingInfo objects with one
+ *		entry for each partitioned table in the partition tree
  * 'partitions' receives an array of ResultRelInfo objects with one entry for
  *		every leaf partition in the partition tree
  * 'tup_conv_maps' receives an array of TupleConversionMap objects with one
@@ -3238,7 +3238,7 @@ EvalPlanQualEnd(EPQState *epqstate)
 void
 ExecSetupPartitionTupleRouting(Relation rel,
 							   Index resultRTindex,
-							   PartitionDispatch **pd,
+							   PartitionTupleRoutingInfo ***ptrinfos,
 							   ResultRelInfo **partitions,
 							   TupleConversionMap ***tup_conv_maps,
 							   TupleTableSlot **partition_tuple_slot,
@@ -3246,10 +3246,12 @@ ExecSetupPartitionTupleRouting(Relation rel,
 {
 	TupleDesc	tupDesc = RelationGetDescr(rel);
 	List	   *leaf_parts;
+	List	   *ptinfos = NIL;
 	ListCell   *cell;
 	int			i;
 	ResultRelInfo *leaf_part_rri;
 	List	   *all_parts;
+	Relation	parent;
 
 	/*
 	 * Get the information about the partition tree after locking all the
@@ -3258,7 +3260,125 @@ ExecSetupPartitionTupleRouting(Relation rel,
 	all_parts = find_all_inheritors(RelationGetRelid(rel), RowExclusiveLock,
 									NULL, NULL);
 	list_free(all_parts);
-	*pd = RelationGetPartitionDispatchInfo(rel, num_parted, &leaf_parts);
+
+	RelationGetPartitionDispatchInfo(rel, &ptinfos, &leaf_parts);
+
+	/*
+	 * The ptinfos list contains PartitionedTableInfo objects for all the
+	 * partitioned tables in the partition tree.  Using the information
+	 * therein, we construct an array of PartitionTupleRoutingInfo objects
+	 * to be used during tuple-routing.
+	 */
+	*num_parted = list_length(ptinfos);
+	*ptrinfos = (PartitionTupleRoutingInfo **) palloc0(*num_parted *
+										sizeof(PartitionTupleRoutingInfo *));
+	/*
+	 * Free the ptinfos List structure itself as we go through (open-coded
+	 * list_free).
+	 */
+	i = 0;
+	cell = list_head(ptinfos);
+	parent = NULL;
+	while (cell)
+	{
+		ListCell   *tmp = cell;
+		PartitionedTableInfo *ptinfo = lfirst(tmp),
+							 *next_ptinfo = NULL;
+		Relation		partrel;
+		PartitionTupleRoutingInfo *ptrinfo;
+
+		if (lnext(tmp))
+			next_ptinfo = lfirst(lnext(tmp));
+
+		/* As mentioned above, the partitioned tables have been locked. */
+		if (ptinfo->relid != RelationGetRelid(rel))
+			partrel = heap_open(ptinfo->relid, NoLock);
+		else
+			partrel = rel;
+
+		ptrinfo = (PartitionTupleRoutingInfo *)
+							palloc0(sizeof(PartitionTupleRoutingInfo));
+		ptrinfo->relid = ptinfo->relid;
+
+		/* Stash a reference to this PartitionDispatch. */
+		ptrinfo->pd = ptinfo->pd;
+
+		/* State for extracting partition key from tuples will go here. */
+		ptrinfo->keyinfo = (PartitionKeyInfo *)
+								palloc0(sizeof(PartitionKeyInfo));
+		ptrinfo->keyinfo->key = RelationGetPartitionKey(partrel);
+		ptrinfo->keyinfo->keystate = NIL;
+
+		/*
+		 * For every partitioned table other than root, we must store a tuple
+		 * table slot initialized with its tuple descriptor and a tuple
+		 * conversion map to convert a tuple from its parent's rowtype to its
+		 * own.  That is to make sure that we are looking at the correct row
+		 * using the correct tuple descriptor when computing its partition key
+		 * for tuple routing.
+		 */
+		if (ptinfo->parentid != InvalidOid)
+		{
+			TupleDesc	tupdesc = RelationGetDescr(partrel);
+
+			/* Open the parent relation descriptor if not already done. */
+			if (ptinfo->parentid == RelationGetRelid(rel))
+			{
+				parent = rel;
+			}
+			else if (parent == NULL)
+			{
+				/* Locked by RelationGetPartitionDispatchInfo(). */
+				parent = heap_open(ptinfo->parentid, NoLock);
+			}
+
+			ptrinfo->tupslot = MakeSingleTupleTableSlot(tupdesc);
+			ptrinfo->tupmap = convert_tuples_by_name(RelationGetDescr(parent),
+													 tupdesc,
+								  gettext_noop("could not convert row type"));
+
+			/*
+			 * Close the parent descriptor, if the next partitioned table in
+			 * the list is not a sibling, because it will have a different
+			 * parent if so.
+			 */
+			if (parent != NULL && parent != rel &&
+				next_ptinfo != NULL &&
+				next_ptinfo->parentid != ptinfo->parentid)
+			{
+				heap_close(parent, NoLock);
+				parent = NULL;
+			}
+
+			/*
+			 * Release the relation descriptor.  Lock that we have on the
+			 * table will keep the PartitionDesc that is pointing into
+			 * RelationData intact, a pointer to which hope to keep
+			 * through this transaction's commit.
+			 * (XXX - how true is that?)
+			 */
+			if (partrel != rel)
+				heap_close(partrel, NoLock);
+		}
+		else
+		{
+			/* Not required for the root partitioned table */
+			ptrinfo->tupslot = NULL;
+			ptrinfo->tupmap = NULL;
+		}
+
+		(*ptrinfos)[i++] = ptrinfo;
+
+		/* Free the ListCell. */
+		cell = lnext(cell);
+		pfree(tmp);
+	}
+
+	/* Free the List itself. */
+	if (ptinfos)
+		pfree(ptinfos);
+
+	/* For leaf partitions, we build ResultRelInfos and TupleConversionMaps. */
 	*num_partitions = list_length(leaf_parts);
 	*partitions = (ResultRelInfo *) palloc(*num_partitions *
 										   sizeof(ResultRelInfo));
@@ -3284,7 +3404,7 @@ ExecSetupPartitionTupleRouting(Relation rel,
 		 * All the partitions were locked above.  Note that the relcache
 		 * entries will be closed by ExecEndModifyTable().
 		 */
-		partrel = heap_open(lfirst_oid(cell), NoLock);
+		partrel = heap_open(lfirst_oid(cell), RowExclusiveLock);
 		part_tupdesc = RelationGetDescr(partrel);
 
 		/*
@@ -3297,7 +3417,7 @@ ExecSetupPartitionTupleRouting(Relation rel,
 		 * partition from the parent's type to the partition's.
 		 */
 		(*tup_conv_maps)[i] = convert_tuples_by_name(tupDesc, part_tupdesc,
-													 gettext_noop("could not convert row type"));
+								 gettext_noop("could not convert row type"));
 
 		InitResultRelInfo(leaf_part_rri,
 						  partrel,
@@ -3331,11 +3451,13 @@ ExecSetupPartitionTupleRouting(Relation rel,
  * by get_partition_for_tuple() unchanged.
  */
 int
-ExecFindPartition(ResultRelInfo *resultRelInfo, PartitionDispatch *pd,
-				  TupleTableSlot *slot, EState *estate)
+ExecFindPartition(ResultRelInfo *resultRelInfo,
+				  PartitionTupleRoutingInfo **ptrinfos,
+				  TupleTableSlot *slot,
+				  EState *estate)
 {
 	int			result;
-	PartitionDispatchData *failed_at;
+	PartitionTupleRoutingInfo *failed_at;
 	TupleTableSlot *failed_slot;
 
 	/*
@@ -3345,7 +3467,7 @@ ExecFindPartition(ResultRelInfo *resultRelInfo, PartitionDispatch *pd,
 	if (resultRelInfo->ri_PartitionCheck)
 		ExecPartitionCheck(resultRelInfo, slot, estate);
 
-	result = get_partition_for_tuple(pd, slot, estate,
+	result = get_partition_for_tuple(ptrinfos, slot, estate,
 									 &failed_at, &failed_slot);
 	if (result < 0)
 	{
@@ -3355,9 +3477,9 @@ ExecFindPartition(ResultRelInfo *resultRelInfo, PartitionDispatch *pd,
 		char	   *val_desc;
 		ExprContext *ecxt = GetPerTupleExprContext(estate);
 
-		failed_rel = failed_at->reldesc;
+		failed_rel = heap_open(failed_at->relid, NoLock);
 		ecxt->ecxt_scantuple = failed_slot;
-		FormPartitionKeyDatum(failed_at, failed_slot, estate,
+		FormPartitionKeyDatum(failed_at->keyinfo, failed_slot, estate,
 							  key_values, key_isnull);
 		val_desc = ExecBuildSlotPartitionKeyDescription(failed_rel,
 														key_values,
diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c
index 36b2b43bc6..9cf974c938 100644
--- a/src/backend/executor/nodeModifyTable.c
+++ b/src/backend/executor/nodeModifyTable.c
@@ -277,7 +277,7 @@ ExecInsert(ModifyTableState *mtstate,
 	resultRelInfo = estate->es_result_relation_info;
 
 	/* Determine the partition to heap_insert the tuple into */
-	if (mtstate->mt_partition_dispatch_info)
+	if (mtstate->mt_ptrinfos)
 	{
 		int			leaf_part_index;
 		TupleConversionMap *map;
@@ -291,7 +291,7 @@ ExecInsert(ModifyTableState *mtstate,
 		 * respectively.
 		 */
 		leaf_part_index = ExecFindPartition(resultRelInfo,
-											mtstate->mt_partition_dispatch_info,
+											mtstate->mt_ptrinfos,
 											slot,
 											estate);
 		Assert(leaf_part_index >= 0 &&
@@ -1486,7 +1486,7 @@ ExecSetupTransitionCaptureState(ModifyTableState *mtstate, EState *estate)
 		int			numResultRelInfos;
 
 		/* Find the set of partitions so that we can find their TupleDescs. */
-		if (mtstate->mt_partition_dispatch_info != NULL)
+		if (mtstate->mt_ptrinfos != NULL)
 		{
 			/*
 			 * For INSERT via partitioned table, so we need TupleDescs based
@@ -1910,7 +1910,7 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 	if (operation == CMD_INSERT &&
 		rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
 	{
-		PartitionDispatch *partition_dispatch_info;
+		PartitionTupleRoutingInfo **ptrinfos;
 		ResultRelInfo *partitions;
 		TupleConversionMap **partition_tupconv_maps;
 		TupleTableSlot *partition_tuple_slot;
@@ -1919,13 +1919,13 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 
 		ExecSetupPartitionTupleRouting(rel,
 									   node->nominalRelation,
-									   &partition_dispatch_info,
+									   &ptrinfos,
 									   &partitions,
 									   &partition_tupconv_maps,
 									   &partition_tuple_slot,
 									   &num_parted, &num_partitions);
-		mtstate->mt_partition_dispatch_info = partition_dispatch_info;
-		mtstate->mt_num_dispatch = num_parted;
+		mtstate->mt_ptrinfos = ptrinfos;
+		mtstate->mt_num_parted = num_parted;
 		mtstate->mt_partitions = partitions;
 		mtstate->mt_num_partitions = num_partitions;
 		mtstate->mt_partition_tupconv_maps = partition_tupconv_maps;
@@ -2335,19 +2335,16 @@ ExecEndModifyTable(ModifyTableState *node)
 	}
 
 	/*
-	 * Close all the partitioned tables, leaf partitions, and their indices
+	 * Close all the leaf partitions and their indices.
 	 *
-	 * Remember node->mt_partition_dispatch_info[0] corresponds to the root
-	 * partitioned table, which we must not try to close, because it is the
-	 * main target table of the query that will be closed by ExecEndPlan().
-	 * Also, tupslot is NULL for the root partitioned table.
+	 * node->mt_partition_dispatch_info[0] corresponds to the root partitioned
+	 * table, for which we didn't create tupslot.
 	 */
-	for (i = 1; i < node->mt_num_dispatch; i++)
+	for (i = 1; i < node->mt_num_parted; i++)
 	{
-		PartitionDispatch pd = node->mt_partition_dispatch_info[i];
+		PartitionTupleRoutingInfo *ptrinfo = node->mt_ptrinfos[i];
 
-		heap_close(pd->reldesc, NoLock);
-		ExecDropSingleTupleTableSlot(pd->tupslot);
+		ExecDropSingleTupleTableSlot(ptrinfo->tupslot);
 	}
 	for (i = 0; i < node->mt_num_partitions; i++)
 	{
diff --git a/src/backend/optimizer/prep/prepunion.c b/src/backend/optimizer/prep/prepunion.c
index 734a7e55df..2d6f3900c3 100644
--- a/src/backend/optimizer/prep/prepunion.c
+++ b/src/backend/optimizer/prep/prepunion.c
@@ -1459,48 +1459,30 @@ expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti)
 	 */
 	if (rte->relkind == RELKIND_PARTITIONED_TABLE)
 	{
-		List   *leaf_part_oids;
-		int		num_parted,
-				i;
-		PartitionDispatch *pds;
+		List   *leaf_part_oids,
+			   *ptinfos;
 
 		/* Discard the original list. */
 		list_free(inhOIDs);
 		inhOIDs = NIL;
 
 		/* Request partitioning information. */
-		pds = RelationGetPartitionDispatchInfo(oldrelation, &num_parted,
-											   &leaf_part_oids);
+		RelationGetPartitionDispatchInfo(oldrelation, &ptinfos,
+										 &leaf_part_oids);
 
 		/*
 		 * First collect the partitioned child table OIDs, which includes the
 		 * root parent at the head.
 		 */
-		for (i = 0; i < num_parted; i++)
+		foreach(l, ptinfos)
 		{
-			PartitionDispatch pd = pds[i];
+			PartitionedTableInfo *ptinfo = lfirst(l);
 
-			inhOIDs = lappend_oid(inhOIDs, RelationGetRelid(pd->reldesc));
+			inhOIDs = lappend_oid(inhOIDs, ptinfo->relid);
 		}
 
 		/* Concatenate the leaf partition OIDs. */
 		inhOIDs = list_concat(inhOIDs, leaf_part_oids);
-
-		/*
-		 * Release the resources that RelationGetPartitionDispatchInfo
-		 * acquired for us but we don't really need in this case.  Note that
-		 * we don't touch the root partitioned table itself by starting the
-		 * loop with 1, not 0.
-		 */
-		for (i = 1; i < num_parted; i++)
-		{
-			PartitionDispatch pd = pds[i];
-
-			heap_close(pd->reldesc, NoLock);
-			ExecDropSingleTupleTableSlot(pd->tupslot);
-			if (pd->tupmap)
-				pfree(pd->tupmap);
-		}
 	}
 
 	/* Scan the inheritance set and expand it */
diff --git a/src/include/catalog/partition.h b/src/include/catalog/partition.h
index 2283c675e9..7b53baf847 100644
--- a/src/include/catalog/partition.h
+++ b/src/include/catalog/partition.h
@@ -39,36 +39,23 @@ typedef struct PartitionDescData
 
 typedef struct PartitionDescData *PartitionDesc;
 
-/*-----------------------
- * PartitionDispatch - information about one partitioned table in a partition
- * hierarchy required to route a tuple to one of its partitions
- *
- *	reldesc		Relation descriptor of the table
- *	key			Partition key information of the table
- *	keystate	Execution state required for expressions in the partition key
- *	partdesc	Partition descriptor of the table
- *	tupslot		A standalone TupleTableSlot initialized with this table's tuple
- *				descriptor
- *	tupmap		TupleConversionMap to convert from the parent's rowtype to
- *				this table's rowtype (when extracting the partition key of a
- *				tuple just before routing it through this table)
- *	indexes		Array with partdesc->nparts members (for details on what
- *				individual members represent, see how they are set in
- *				RelationGetPartitionDispatchInfo())
- *-----------------------
+typedef struct PartitionDispatchData *PartitionDispatch;
+
+/*
+ * Information about one partitioned table in a given partition tree
  */
-typedef struct PartitionDispatchData
+typedef struct PartitionedTableInfo
 {
-	Relation	reldesc;
-	PartitionKey key;
-	List	   *keystate;		/* list of ExprState */
-	PartitionDesc partdesc;
-	TupleTableSlot *tupslot;
-	TupleConversionMap *tupmap;
-	int		   *indexes;
-} PartitionDispatchData;
+	Oid				relid;
+	Oid				parentid;
 
-typedef struct PartitionDispatchData *PartitionDispatch;
+	/*
+	 * This contains information about bounds of the partitions of this
+	 * table and about where individual partitions are placed in the global
+	 * partition tree.
+	 */
+	PartitionDispatch pd;
+} PartitionedTableInfo;
 
 extern void RelationBuildPartitionDesc(Relation relation);
 extern bool partition_bounds_equal(int partnatts, int16 *parttyplen,
@@ -86,17 +73,18 @@ extern List *map_partition_varattnos(List *expr, int target_varno,
 extern List *RelationGetPartitionQual(Relation rel);
 extern Expr *get_partition_qual_relid(Oid relid);
 
+extern void RelationGetPartitionDispatchInfo(Relation rel,
+								 List **ptinfos, List **leaf_part_oids);
+
 /* For tuple routing */
-extern PartitionDispatch *RelationGetPartitionDispatchInfo(Relation rel,
-								 int *num_parted, List **leaf_part_oids);
-extern void FormPartitionKeyDatum(PartitionDispatch pd,
+extern void FormPartitionKeyDatum(PartitionKeyInfo *keyinfo,
 					  TupleTableSlot *slot,
 					  EState *estate,
 					  Datum *values,
 					  bool *isnull);
-extern int get_partition_for_tuple(PartitionDispatch *pd,
+extern int get_partition_for_tuple(PartitionTupleRoutingInfo **ptrinfos,
 						TupleTableSlot *slot,
 						EState *estate,
-						PartitionDispatchData **failed_at,
+						PartitionTupleRoutingInfo **failed_at,
 						TupleTableSlot **failed_slot);
 #endif							/* PARTITION_H */
diff --git a/src/include/executor/executor.h b/src/include/executor/executor.h
index 60326f9d03..6e1d3a6d2f 100644
--- a/src/include/executor/executor.h
+++ b/src/include/executor/executor.h
@@ -208,13 +208,13 @@ extern void EvalPlanQualSetTuple(EPQState *epqstate, Index rti,
 extern HeapTuple EvalPlanQualGetTuple(EPQState *epqstate, Index rti);
 extern void ExecSetupPartitionTupleRouting(Relation rel,
 							   Index resultRTindex,
-							   PartitionDispatch **pd,
+							   PartitionTupleRoutingInfo ***ptrinfos,
 							   ResultRelInfo **partitions,
 							   TupleConversionMap ***tup_conv_maps,
 							   TupleTableSlot **partition_tuple_slot,
 							   int *num_parted, int *num_partitions);
 extern int ExecFindPartition(ResultRelInfo *resultRelInfo,
-				  PartitionDispatch *pd,
+				  PartitionTupleRoutingInfo **ptrinfos,
 				  TupleTableSlot *slot,
 				  EState *estate);
 
diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h
index 577499465d..07e50e0914 100644
--- a/src/include/nodes/execnodes.h
+++ b/src/include/nodes/execnodes.h
@@ -414,6 +414,55 @@ typedef struct ResultRelInfo
 	Relation	ri_PartitionRoot;
 } ResultRelInfo;
 
+/* Forward declarations, to avoid including other headers */
+typedef struct PartitionKeyData *PartitionKey;
+typedef struct PartitionDispatchData *PartitionDispatch;
+
+/*
+ * PartitionKeyInfoData - execution state for the partition key of a
+ *						  partitioned table
+ *
+ * keystate is the execution state required for expressions contained in the
+ * partition key.  It is NIL until initialized by FormPartitionKeyDatum() if
+ * and when it is called; for example, during tuple routing through a given
+ * partitioned table.
+ */
+typedef struct PartitionKeyInfo
+{
+	PartitionKey	key;		/* Points into the table's relcache entry */
+	List		   *keystate;
+} PartitionKeyInfo;
+
+/*
+ * PartitionTupleRoutingInfo - information required for tuple-routing
+ *							   through one partitioned table in a partition
+ *							   tree
+ */
+typedef struct PartitionTupleRoutingInfo
+{
+	/* OID of the table */
+	Oid				relid;
+
+	/* Information about the table's partitions */
+	PartitionDispatch	pd;
+
+	/* See comment above the definition of PartitionKeyInfo */
+	PartitionKeyInfo   *keyinfo;
+
+	/*
+	 * A standalone TupleTableSlot initialized with this table's tuple
+	 * descriptor
+	 */
+	TupleTableSlot *tupslot;
+
+	/*
+	 * TupleConversionMap to convert from the parent's rowtype to this table's
+	 * rowtype (when extracting the partition key of a tuple just before
+	 * routing it through this table)
+	 */
+	TupleConversionMap *tupmap;
+} PartitionTupleRoutingInfo;
+
 /* ----------------
  *	  EState information
  *
@@ -970,9 +1019,9 @@ typedef struct ModifyTableState
 	TupleTableSlot *mt_existing;	/* slot to store existing target tuple in */
 	List	   *mt_excludedtlist;	/* the excluded pseudo relation's tlist  */
 	TupleTableSlot *mt_conflproj;	/* CONFLICT ... SET ... projection target */
-	struct PartitionDispatchData **mt_partition_dispatch_info;
 	/* Tuple-routing support info */
-	int			mt_num_dispatch;	/* Number of entries in the above array */
+	struct PartitionTupleRoutingInfo **mt_ptrinfos;
+	int			mt_num_parted;		/* Number of entries in the above array */
 	int			mt_num_partitions;	/* Number of members in the following
 									 * arrays */
 	ResultRelInfo *mt_partitions;	/* Per partition result relation */
-- 
2.11.0

From e9ad9f947d6d553ce8ec29feb8560dff48f166b6 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Wed, 16 Aug 2017 11:36:14 +0900
Subject: [PATCH 1/3] Relieve RelationGetPartitionDispatchInfo() of doing any
 locking

Anyone who wants to call RelationGetPartitionDispatchInfo() must first
acquire locks using find_all_inheritors.

Doing it this way gets rid of the possibility of a deadlock when partitions
are concurrently locked, because RelationGetPartitionDispatchInfo would lock
the partitions in one order and find_all_inheritors would in another.

Reported-by: Amit Khandekar, Robert Haas
Reports: https://postgr.es/m/CAJ3gD9fdjk2O8aPMXidCeYeB-mFB%3DwY9ZLfe8cQOfG4bTqVGyQ%40mail.gmail.com
         https://postgr.es/m/CA%2BTgmobwbh12OJerqAGyPEjb_%2B2y7T0nqRKTcjed6L4NTET6Fg%40mail.gmail.com
---
 src/backend/catalog/partition.c |   52 ++++++++++++++++++---------------------
 src/backend/executor/execMain.c |    7 +++---
 src/include/catalog/partition.h |    3 +--
 3 files changed, 29 insertions(+), 33 deletions(-)

diff --git a/src/backend/catalog/partition.c b/src/backend/catalog/partition.c
index c1a307c..e5dc42d 100644
--- a/src/backend/catalog/partition.c
+++ b/src/backend/catalog/partition.c
@@ -998,14 +998,22 @@ get_partition_qual_relid(Oid relid)
 /*
  * RelationGetPartitionDispatchInfo
  *		Returns information necessary to route tuples down a partition tree
+ *		rooted at "rel" as an array of PartitionDispatch entries.
  *
- * All the partitions will be locked with lockmode, unless it is NoLock.
- * A list of the OIDs of all the leaf partitions of rel is returned in
- * *leaf_part_oids.
+ * The array contains as many entries as the number of partitioned tables in
+ * the partition tree. The number of entries is returned in "num_parted". The
+ * functions also returns a list of the OIDs of all the leaf partitions of rel
+ * in "leaf_part_oids".
+ *
+ * The function traverses the the partition tree using relcaches of partitioned
+ * tables within it. Hence all the relations in the partition tree including
+ * the root must have been locked (with at least AccessShareLock) by the caller
+ * typically using find_all_inheritors() to preserve the locking order to avoid
+ * deadlocks.
  */
 PartitionDispatch *
-RelationGetPartitionDispatchInfo(Relation rel, int lockmode,
-								 int *num_parted, List **leaf_part_oids)
+RelationGetPartitionDispatchInfo(Relation rel, int *num_parted,
+								 List **leaf_part_oids)
 {
 	PartitionDispatchData **pd;
 	List	   *all_parts = NIL,
@@ -1019,14 +1027,12 @@ RelationGetPartitionDispatchInfo(Relation rel, int lockmode,
 				offset;
 
 	/*
-	 * Lock partitions and make a list of the partitioned ones to prepare
-	 * their PartitionDispatch objects below.
-	 *
-	 * Cannot use find_all_inheritors() here, because then the order of OIDs
-	 * in parted_rels list would be unknown, which does not help, because we
-	 * assign indexes within individual PartitionDispatch in an order that is
-	 * predetermined (determined by the order of OIDs in individual partition
-	 * descriptors).
+	 * For every partitioned table in the tree, starting with the root
+	 * partitioned table, add its relcache entry to parted_rels, while also
+	 * queuing its partitions (in the order in which they appear in the
+	 * partition descriptor) to be looked at later in the same loop.  This is
+	 * a bit tricky but works because the foreach() macro doesn't fetch the
+	 * next list element until the bottom of the loop.
 	 */
 	*num_parted = 1;
 	parted_rels = list_make1(rel);
@@ -1035,29 +1041,19 @@ RelationGetPartitionDispatchInfo(Relation rel, int lockmode,
 	APPEND_REL_PARTITION_OIDS(rel, all_parts, all_parents);
 	forboth(lc1, all_parts, lc2, all_parents)
 	{
-		Relation	partrel = heap_open(lfirst_oid(lc1), lockmode);
+		Oid			partrelid = lfirst_oid(lc1);
 		Relation	parent = lfirst(lc2);
-		PartitionDesc partdesc = RelationGetPartitionDesc(partrel);
 
-		/*
-		 * If this partition is a partitioned table, add its children to the
-		 * end of the list, so that they are processed as well.
-		 */
-		if (partdesc)
+		if (get_rel_relkind(partrelid) == RELKIND_PARTITIONED_TABLE)
 		{
+			/* Already locked by the caller. */
+			Relation	partrel = heap_open(partrelid, NoLock);
+
 			(*num_parted)++;
 			parted_rels = lappend(parted_rels, partrel);
 			parted_rel_parents = lappend(parted_rel_parents, parent);
 			APPEND_REL_PARTITION_OIDS(partrel, all_parts, all_parents);
 		}
-		else
-			heap_close(partrel, NoLock);
-
-		/*
-		 * We keep the partitioned ones open until we're done using the
-		 * information being collected here (for example, see
-		 * ExecEndModifyTable).
-		 */
 	}
 
 	/*
diff --git a/src/backend/executor/execMain.c b/src/backend/executor/execMain.c
index 6671a25..91a3766 100644
--- a/src/backend/executor/execMain.c
+++ b/src/backend/executor/execMain.c
@@ -43,6 +43,7 @@
 #include "access/xact.h"
 #include "catalog/namespace.h"
 #include "catalog/partition.h"
+#include "catalog/pg_inherits_fn.h"
 #include "catalog/pg_publication.h"
 #include "commands/matview.h"
 #include "commands/trigger.h"
@@ -3249,9 +3250,9 @@ ExecSetupPartitionTupleRouting(Relation rel,
 	int			i;
 	ResultRelInfo *leaf_part_rri;
 
-	/* Get the tuple-routing information and lock partitions */
-	*pd = RelationGetPartitionDispatchInfo(rel, RowExclusiveLock, num_parted,
-										   &leaf_parts);
+	/* Get the tuple-routing information after locking all the partitions */
+	find_all_inheritors(RelationGetRelid(rel), RowExclusiveLock, NULL);
+	*pd = RelationGetPartitionDispatchInfo(rel, num_parted, &leaf_parts);
 	*num_partitions = list_length(leaf_parts);
 	*partitions = (ResultRelInfo *) palloc(*num_partitions *
 										   sizeof(ResultRelInfo));
diff --git a/src/include/catalog/partition.h b/src/include/catalog/partition.h
index bef7a0f..2283c67 100644
--- a/src/include/catalog/partition.h
+++ b/src/include/catalog/partition.h
@@ -88,8 +88,7 @@ extern Expr *get_partition_qual_relid(Oid relid);
 
 /* For tuple routing */
 extern PartitionDispatch *RelationGetPartitionDispatchInfo(Relation rel,
-								 int lockmode, int *num_parted,
-								 List **leaf_part_oids);
+								 int *num_parted, List **leaf_part_oids);
 extern void FormPartitionKeyDatum(PartitionDispatch pd,
 					  TupleTableSlot *slot,
 					  EState *estate,
-- 
1.7.9.5

From 365409b9d7cf723a65b832804bc5002d83ae15d5 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Wed, 16 Aug 2017 11:36:14 +0900
Subject: [PATCH 1/3] Relieve RelationGetPartitionDispatchInfo() of doing any
 locking

Anyone who wants to call RelationGetPartitionDispatchInfo() must first
acquire locks using find_all_inheritors.

Doing it this way gets rid of the possibility of a deadlock when partitions
are concurrently locked, because RelationGetPartitionDispatchInfo would lock
the partitions in one order and find_all_inheritors would in another.

Reported-by: Amit Khandekar, Robert Haas
Reports: https://postgr.es/m/CAJ3gD9fdjk2O8aPMXidCeYeB-mFB%3DwY9ZLfe8cQOfG4bTqVGyQ%40mail.gmail.com
         https://postgr.es/m/CA%2BTgmobwbh12OJerqAGyPEjb_%2B2y7T0nqRKTcjed6L4NTET6Fg%40mail.gmail.com
---
 src/backend/catalog/partition.c | 55 ++++++++++++++++++++++-------------------
 src/backend/executor/execMain.c | 10 +++++---
 src/include/catalog/partition.h |  3 +--
 3 files changed, 37 insertions(+), 31 deletions(-)

diff --git a/src/backend/catalog/partition.c b/src/backend/catalog/partition.c
index c1a307c8d3..96a64ce6b2 100644
--- a/src/backend/catalog/partition.c
+++ b/src/backend/catalog/partition.c
@@ -999,12 +999,16 @@ get_partition_qual_relid(Oid relid)
  * RelationGetPartitionDispatchInfo
  *		Returns information necessary to route tuples down a partition tree
  *
- * All the partitions will be locked with lockmode, unless it is NoLock.
- * A list of the OIDs of all the leaf partitions of rel is returned in
- * *leaf_part_oids.
+ * The number of elements in the returned array (that is, the number of
+ * PartitionDispatch objects for the partitioned tables in the partition tree)
+ * is returned in *num_parted and a list of the OIDs of all the leaf
+ * partitions of rel is returned in *leaf_part_oids.
+ *
+ * All the relations in the partition tree (including 'rel') must have been
+ * locked (using at least the AccessShareLock) by the caller.
  */
 PartitionDispatch *
-RelationGetPartitionDispatchInfo(Relation rel, int lockmode,
+RelationGetPartitionDispatchInfo(Relation rel,
 								 int *num_parted, List **leaf_part_oids)
 {
 	PartitionDispatchData **pd;
@@ -1019,14 +1023,18 @@ RelationGetPartitionDispatchInfo(Relation rel, int lockmode,
 				offset;
 
 	/*
-	 * Lock partitions and make a list of the partitioned ones to prepare
-	 * their PartitionDispatch objects below.
+	 * We rely on the relcache to traverse the partition tree to build both
+	 * the leaf partition OIDs list and the array of PartitionDispatch objects
+	 * for the partitioned tables in the tree.  That means every partitioned
+	 * table in the tree must be locked, which is fine since we require the
+	 * caller to lock all the partitions anyway.
 	 *
-	 * Cannot use find_all_inheritors() here, because then the order of OIDs
-	 * in parted_rels list would be unknown, which does not help, because we
-	 * assign indexes within individual PartitionDispatch in an order that is
-	 * predetermined (determined by the order of OIDs in individual partition
-	 * descriptors).
+	 * For every partitioned table in the tree, starting with the root
+	 * partitioned table, add its relcache entry to parted_rels, while also
+	 * queuing its partitions (in the order in which they appear in the
+	 * partition descriptor) to be looked at later in the same loop.  This is
+	 * a bit tricky but works because the foreach() macro doesn't fetch the
+	 * next list element until the bottom of the loop.
 	 */
 	*num_parted = 1;
 	parted_rels = list_make1(rel);
@@ -1035,29 +1043,24 @@ RelationGetPartitionDispatchInfo(Relation rel, int lockmode,
 	APPEND_REL_PARTITION_OIDS(rel, all_parts, all_parents);
 	forboth(lc1, all_parts, lc2, all_parents)
 	{
-		Relation	partrel = heap_open(lfirst_oid(lc1), lockmode);
+		Oid			partrelid = lfirst_oid(lc1);
 		Relation	parent = lfirst(lc2);
-		PartitionDesc partdesc = RelationGetPartitionDesc(partrel);
 
-		/*
-		 * If this partition is a partitioned table, add its children to the
-		 * end of the list, so that they are processed as well.
-		 */
-		if (partdesc)
+		if (get_rel_relkind(partrelid) == RELKIND_PARTITIONED_TABLE)
 		{
+			/*
+			 * Already locked by the caller.  Note that it is the
+			 * responsibility of the caller to close the below relcache entry,
+			 * once done using the information being collected here (for
+			 * example, in ExecEndModifyTable).
+			 */
+			Relation	partrel = heap_open(partrelid, NoLock);
+
 			(*num_parted)++;
 			parted_rels = lappend(parted_rels, partrel);
 			parted_rel_parents = lappend(parted_rel_parents, parent);
 			APPEND_REL_PARTITION_OIDS(partrel, all_parts, all_parents);
 		}
-		else
-			heap_close(partrel, NoLock);
-
-		/*
-		 * We keep the partitioned ones open until we're done using the
-		 * information being collected here (for example, see
-		 * ExecEndModifyTable).
-		 */
 	}
 
 	/*
diff --git a/src/backend/executor/execMain.c b/src/backend/executor/execMain.c
index 6671a25ffb..74071eede6 100644
--- a/src/backend/executor/execMain.c
+++ b/src/backend/executor/execMain.c
@@ -43,6 +43,7 @@
 #include "access/xact.h"
 #include "catalog/namespace.h"
 #include "catalog/partition.h"
+#include "catalog/pg_inherits_fn.h"
 #include "catalog/pg_publication.h"
 #include "commands/matview.h"
 #include "commands/trigger.h"
@@ -3249,9 +3250,12 @@ ExecSetupPartitionTupleRouting(Relation rel,
 	int			i;
 	ResultRelInfo *leaf_part_rri;
 
-	/* Get the tuple-routing information and lock partitions */
-	*pd = RelationGetPartitionDispatchInfo(rel, RowExclusiveLock, num_parted,
-										   &leaf_parts);
+	/*
+	 * Get the information about the partition tree after locking all the
+	 * partitions.
+	 */
+	(void) find_all_inheritors(RelationGetRelid(rel), RowExclusiveLock, NULL);
+	*pd = RelationGetPartitionDispatchInfo(rel, num_parted, &leaf_parts);
 	*num_partitions = list_length(leaf_parts);
 	*partitions = (ResultRelInfo *) palloc(*num_partitions *
 										   sizeof(ResultRelInfo));
diff --git a/src/include/catalog/partition.h b/src/include/catalog/partition.h
index bef7a0f5fb..2283c675e9 100644
--- a/src/include/catalog/partition.h
+++ b/src/include/catalog/partition.h
@@ -88,8 +88,7 @@ extern Expr *get_partition_qual_relid(Oid relid);
 
 /* For tuple routing */
 extern PartitionDispatch *RelationGetPartitionDispatchInfo(Relation rel,
-								 int lockmode, int *num_parted,
-								 List **leaf_part_oids);
+								 int *num_parted, List **leaf_part_oids);
 extern void FormPartitionKeyDatum(PartitionDispatch pd,
 					  TupleTableSlot *slot,
 					  EState *estate,
-- 
2.11.0

From 48f066bcf49cad67ce141cf490e9ae98c3f98568 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Wed, 9 Aug 2017 15:52:36 +0900
Subject: [PATCH 2/3] Teach expand_inherited_rtentry to use partition bound
 order

After locking the child tables using find_all_inheritors, we discard
the list of child table OIDs that it generates and rebuild the same
using the information returned by RelationGetPartitionDispatchInfo.
---
 src/backend/optimizer/prep/prepunion.c | 51 ++++++++++++++++++++++++++++++++++
 1 file changed, 51 insertions(+)

diff --git a/src/backend/optimizer/prep/prepunion.c b/src/backend/optimizer/prep/prepunion.c
index 6d8f8938b2..e730c24ee4 100644
--- a/src/backend/optimizer/prep/prepunion.c
+++ b/src/backend/optimizer/prep/prepunion.c
@@ -33,6 +33,7 @@
 #include "access/heapam.h"
 #include "access/htup_details.h"
 #include "access/sysattr.h"
+#include "catalog/partition.h"
 #include "catalog/pg_inherits_fn.h"
 #include "catalog/pg_type.h"
 #include "miscadmin.h"
@@ -1452,6 +1453,56 @@ expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti)
 	 */
 	oldrelation = heap_open(parentOID, NoLock);
 
+	/*
+	 * For partitioned tables, we arrange the child table OIDs such that they
+	 * appear in the partition bound order.
+	 */
+	if (rte->relkind == RELKIND_PARTITIONED_TABLE)
+	{
+		List   *leaf_part_oids;
+		int		num_parted,
+				i;
+		PartitionDispatch *pds;
+
+		/* Discard the original list. */
+		list_free(inhOIDs);
+		inhOIDs = NIL;
+
+		/* Request partitioning information. */
+		pds = RelationGetPartitionDispatchInfo(oldrelation, &num_parted,
+											   &leaf_part_oids);
+
+		/*
+		 * First collect the partitioned child table OIDs, which includes the
+		 * root parent at the head.
+		 */
+		for (i = 0; i < num_parted; i++)
+		{
+			PartitionDispatch pd = pds[i];
+
+			inhOIDs = lappend_oid(inhOIDs, RelationGetRelid(pd->reldesc));
+		}
+
+		/* Concatenate the leaf partition OIDs. */
+		inhOIDs = list_concat(inhOIDs, leaf_part_oids);
+
+		/*
+		 * Release the resources that RelationGetPartitionDispatchInfo
+		 * acquired for us but we don't really need in this case.  Note that
+		 * we don't touch the root partitioned table itself by starting the
+		 * loop with 1, not 0.
+		 */
+		for (i = 1; i < num_parted; i++)
+		{
+			PartitionDispatch pd = pds[i];
+
+			heap_close(pd->reldesc, NoLock);
+			ExecDropSingleTupleTableSlot(pd->tupslot);
+			if (pd->tupmap)
+				pfree(pd->tupmap);
+		}
+	}
+
 	/* Scan the inheritance set and expand it */
 	appinfos = NIL;
 	has_child = false;
-- 
2.11.0

From 45301124931fda224ea3ab70146c5a6c4a72dbca Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Mon, 24 Jul 2017 18:59:57 +0900
Subject: [PATCH 3/3] Decouple RelationGetPartitionDispatchInfo() from executor

Currently it and the structure it generates viz. PartitionDispatch
objects are too coupled with the executor's tuple-routing code.  In
particular, it's pretty undesirable that it makes it the responsibility
of the caller to release some resources, such as relcache references
and tuple table slots.  That makes it harder to use in places other
than where it's currently being used.

After this refactoring, ExecSetupPartitionTupleRouting() now needs to
do some of the work that was previously done in
RelationGetPartitionDispatchInfo() and expand_inherited_rtentry() no
longer needs to do some things that it used to.
---
 src/backend/catalog/partition.c        | 309 +++++++++++++++++----------------
 src/backend/commands/copy.c            |  35 ++--
 src/backend/executor/execMain.c        | 145 ++++++++++++++--
 src/backend/executor/nodeModifyTable.c |  29 ++--
 src/backend/optimizer/prep/prepunion.c |  32 +---
 src/include/catalog/partition.h        |  52 +++---
 src/include/executor/executor.h        |   4 +-
 src/include/nodes/execnodes.h          |  53 +++++-
 8 files changed, 398 insertions(+), 261 deletions(-)

diff --git a/src/backend/catalog/partition.c b/src/backend/catalog/partition.c
index 96a64ce6b2..7618e4cb31 100644
--- a/src/backend/catalog/partition.c
+++ b/src/backend/catalog/partition.c
@@ -105,6 +105,24 @@ typedef struct PartitionRangeBound
 	bool		lower;			/* this is the lower (vs upper) bound */
 } PartitionRangeBound;
 
+/*-----------------------
+ * PartitionDispatchData - information of partitions of one partitioned table
+ *						   in a partition tree
+ *
+ *	partkey		Partition key of the table
+ *	partdesc	Partition descriptor of the table
+ *	indexes		Array with partdesc->nparts members (for details on what the
+ *				individual value represents, see the comments in
+ *				RelationGetPartitionDispatchInfo())
+ *-----------------------
+ */
+typedef struct PartitionDispatchData
+{
+	PartitionKey	partkey;	/* Points into the table's relcache entry */
+	PartitionDesc	partdesc;	/* Ditto */
+	int			   *indexes;
+} PartitionDispatchData;
+
 static int32 qsort_partition_list_value_cmp(const void *a, const void *b,
 							   void *arg);
 static int32 qsort_partition_rbound_cmp(const void *a, const void *b,
@@ -981,181 +999,165 @@ get_partition_qual_relid(Oid relid)
 }
 
 /*
- * Append OIDs of rel's partitions to the list 'partoids' and for each OID,
- * append pointer rel to the list 'parents'.
- */
-#define APPEND_REL_PARTITION_OIDS(rel, partoids, parents) \
-	do\
-	{\
-		int		i;\
-		for (i = 0; i < (rel)->rd_partdesc->nparts; i++)\
-		{\
-			(partoids) = lappend_oid((partoids), (rel)->rd_partdesc->oids[i]);\
-			(parents) = lappend((parents), (rel));\
-		}\
-	} while(0)
-
-/*
  * RelationGetPartitionDispatchInfo
- *		Returns information necessary to route tuples down a partition tree
+ *		Returns necessary information for each partition in the partition
+ *		tree rooted at rel
  *
- * The number of elements in the returned array (that is, the number of
- * PartitionDispatch objects for the partitioned tables in the partition tree)
- * is returned in *num_parted and a list of the OIDs of all the leaf
- * partitions of rel is returned in *leaf_part_oids.
+ * Information returned includes the following: *ptinfos contains a list of
+ * PartitionedTableInfo objects, one for each partitioned table (with at least
+ * one member, that is, one for the root partitioned table), *leaf_part_oids
+ * contains a list of the OIDs of of all the leaf partitions.
  *
- * All the relations in the partition tree (including 'rel') must have been
- * locked (using at least the AccessShareLock) by the caller.
+ * We require that the caller has locked at least the partitioned tables in the
+ * partition tree (including 'rel') using at least the AccessShareLock,
+ * because we need to look at their relcache entries to get PartitionKey and
+ * PartitionDesc.
  */
-PartitionDispatch *
+void
 RelationGetPartitionDispatchInfo(Relation rel,
-								 int *num_parted, List **leaf_part_oids)
+								 List **ptinfos, List **leaf_part_oids)
 {
-	PartitionDispatchData **pd;
-	List	   *all_parts = NIL,
-			   *all_parents = NIL,
-			   *parted_rels,
-			   *parted_rel_parents;
+	List	   *all_parts,
+			   *all_parents;
 	ListCell   *lc1,
 			   *lc2;
 	int			i,
-				k,
 				offset;
 
 	/*
 	 * We rely on the relcache to traverse the partition tree to build both
-	 * the leaf partition OIDs list and the array of PartitionDispatch objects
-	 * for the partitioned tables in the tree.  That means every partitioned
-	 * table in the tree must be locked, which is fine since we require the
-	 * caller to lock all the partitions anyway.
+	 * the leaf partition OIDs list and the list of PartitionedTableInfo
+	 * objects for partitioned tables.  That means every partitioned table in
+	 * the tree must be locked, which is fine since the callers must have done
+	 * that already.
 	 *
 	 * For every partitioned table in the tree, starting with the root
 	 * partitioned table, add its relcache entry to parted_rels, while also
 	 * queuing its partitions (in the order in which they appear in the
 	 * partition descriptor) to be looked at later in the same loop.  This is
 	 * a bit tricky but works because the foreach() macro doesn't fetch the
-	 * next list element until the bottom of the loop.
+	 * next list element until the bottom of the loop.  Non-partitioned tables
+	 * are simply added to the leaf partitions list.
 	 */
-	*num_parted = 1;
-	parted_rels = list_make1(rel);
-	/* Root partitioned table has no parent, so NULL for parent */
-	parted_rel_parents = list_make1(NULL);
-	APPEND_REL_PARTITION_OIDS(rel, all_parts, all_parents);
+	i = offset = 0;
+	*ptinfos = *leaf_part_oids = NIL;
+
+	/* Start with the root table. */
+	all_parts = list_make1_oid(RelationGetRelid(rel));
+	all_parents = list_make1_oid(InvalidOid);
 	forboth(lc1, all_parts, lc2, all_parents)
 	{
-		Oid			partrelid = lfirst_oid(lc1);
-		Relation	parent = lfirst(lc2);
+		Oid		partrelid = lfirst_oid(lc1);
+		Oid		parentrelid = lfirst_oid(lc2);
 
 		if (get_rel_relkind(partrelid) == RELKIND_PARTITIONED_TABLE)
 		{
-			/*
-			 * Already locked by the caller.  Note that it is the
-			 * responsibility of the caller to close the below relcache entry,
-			 * once done using the information being collected here (for
-			 * example, in ExecEndModifyTable).
-			 */
-			Relation	partrel = heap_open(partrelid, NoLock);
+			int		j,
+					k;
+			Relation		partrel;
+			PartitionKey	partkey;
+			PartitionDesc	partdesc;
+			PartitionedTableInfo   *ptinfo;
+			PartitionDispatch		pd;
+
+			if (partrelid != RelationGetRelid(rel))
+				partrel = heap_open(partrelid, NoLock);
+			else
+				partrel = rel;
 
-			(*num_parted)++;
-			parted_rels = lappend(parted_rels, partrel);
-			parted_rel_parents = lappend(parted_rel_parents, parent);
-			APPEND_REL_PARTITION_OIDS(partrel, all_parts, all_parents);
-		}
-	}
+			partkey = RelationGetPartitionKey(partrel);
+			partdesc = RelationGetPartitionDesc(partrel);
+
+			ptinfo = (PartitionedTableInfo *)
+									palloc0(sizeof(PartitionedTableInfo));
+			ptinfo->relid = partrelid;
+			ptinfo->parentid = parentrelid;
+
+			ptinfo->pd = pd = (PartitionDispatchData *)
+									palloc0(sizeof(PartitionDispatchData));
+			pd->partkey = partkey;
 
-	/*
-	 * We want to create two arrays - one for leaf partitions and another for
-	 * partitioned tables (including the root table and internal partitions).
-	 * While we only create the latter here, leaf partition array of suitable
-	 * objects (such as, ResultRelInfo) is created by the caller using the
-	 * list of OIDs we return.  Indexes into these arrays get assigned in a
-	 * breadth-first manner, whereby partitions of any given level are placed
-	 * consecutively in the respective arrays.
-	 */
-	pd = (PartitionDispatchData **) palloc(*num_parted *
-										   sizeof(PartitionDispatchData *));
-	*leaf_part_oids = NIL;
-	i = k = offset = 0;
-	forboth(lc1, parted_rels, lc2, parted_rel_parents)
-	{
-		Relation	partrel = lfirst(lc1);
-		Relation	parent = lfirst(lc2);
-		PartitionKey partkey = RelationGetPartitionKey(partrel);
-		TupleDesc	tupdesc = RelationGetDescr(partrel);
-		PartitionDesc partdesc = RelationGetPartitionDesc(partrel);
-		int			j,
-					m;
-
-		pd[i] = (PartitionDispatch) palloc(sizeof(PartitionDispatchData));
-		pd[i]->reldesc = partrel;
-		pd[i]->key = partkey;
-		pd[i]->keystate = NIL;
-		pd[i]->partdesc = partdesc;
-		if (parent != NULL)
-		{
 			/*
-			 * For every partitioned table other than root, we must store a
-			 * tuple table slot initialized with its tuple descriptor and a
-			 * tuple conversion map to convert a tuple from its parent's
-			 * rowtype to its own. That is to make sure that we are looking at
-			 * the correct row using the correct tuple descriptor when
-			 * computing its partition key for tuple routing.
+			 * XXX- do we need a pinning mechanism for partition descriptors
+			 * so that there references can be managed independently of
+			 * the parent relcache entry? Like PinPartitionDesc(partdesc)?
 			 */
-			pd[i]->tupslot = MakeSingleTupleTableSlot(tupdesc);
-			pd[i]->tupmap = convert_tuples_by_name(RelationGetDescr(parent),
-												   tupdesc,
-												   gettext_noop("could not convert row type"));
-		}
-		else
-		{
-			/* Not required for the root partitioned table */
-			pd[i]->tupslot = NULL;
-			pd[i]->tupmap = NULL;
-		}
-		pd[i]->indexes = (int *) palloc(partdesc->nparts * sizeof(int));
+			pd->partdesc = partdesc;
 
-		/*
-		 * Indexes corresponding to the internal partitions are multiplied by
-		 * -1 to distinguish them from those of leaf partitions.  Encountering
-		 * an index >= 0 means we found a leaf partition, which is immediately
-		 * returned as the partition we are looking for.  A negative index
-		 * means we found a partitioned table, whose PartitionDispatch object
-		 * is located at the above index multiplied back by -1.  Using the
-		 * PartitionDispatch object, search is continued further down the
-		 * partition tree.
-		 */
-		m = 0;
-		for (j = 0; j < partdesc->nparts; j++)
-		{
-			Oid			partrelid = partdesc->oids[j];
+			/*
+			 * The values contained in the following array correspond to
+			 * indexes of this table's partitions in the global sequence of
+			 * all the partitions contained in the partition tree rooted at
+			 * rel, traversed in a breadh-first manner.  The values should be
+			 * such that we will be able to distinguish the leaf partitions
+			 * from the non-leaf partitions, because they are returned to
+			 * to the caller in separate structures from where they will be
+			 * accessed.  The way that's done is described below:
+			 *
+			 * Leaf partition OIDs are put into the global leaf_part_oids list,
+			 * and for each one, the value stored is its ordinal position in
+			 * the list minus 1.
+			 *
+			 * PartitionedTableInfo objects corresponding to partitions that
+			 * are partitioned tables are put into the global ptinfos[] list,
+			 * and for each one, the value stored is its ordinal position in
+			 * the list multiplied by -1.
+			 *
+			 * So while looking at the values in the indexes array, if one
+			 * gets zero or a positive value, then it's a leaf partition,
+			 * Otherwise, it's a partitioned table.
+			 */
+			pd->indexes = (int *) palloc(partdesc->nparts * sizeof(int));
 
-			if (get_rel_relkind(partrelid) != RELKIND_PARTITIONED_TABLE)
-			{
-				*leaf_part_oids = lappend_oid(*leaf_part_oids, partrelid);
-				pd[i]->indexes[j] = k++;
-			}
-			else
+			k = 0;
+			for (j = 0; j < partdesc->nparts; j++)
 			{
+				Oid			partrelid = partdesc->oids[j];
+
 				/*
-				 * offset denotes the number of partitioned tables of upper
-				 * levels including those of the current level.  Any partition
-				 * of this table must belong to the next level and hence will
-				 * be placed after the last partitioned table of this level.
+				 * Queue this partition so that it will be processed later
+				 * by the outer loop.
 				 */
-				pd[i]->indexes[j] = -(1 + offset + m);
-				m++;
+				all_parts = lappend_oid(all_parts, partrelid);
+				all_parents = lappend_oid(all_parents,
+										  RelationGetRelid(partrel));
+
+				if (get_rel_relkind(partrelid) != RELKIND_PARTITIONED_TABLE)
+				{
+					*leaf_part_oids = lappend_oid(*leaf_part_oids, partrelid);
+					pd->indexes[j] = i++;
+				}
+				else
+				{
+					/*
+					 * offset denotes the number of partitioned tables that
+					 * we have already processed.  k counts the number of
+					 * partitions of this table that were found to be
+					 * partitioned tables.
+					 */
+					pd->indexes[j] = -(1 + offset + k);
+					k++;
+				}
 			}
-		}
-		i++;
 
-		/*
-		 * This counts the number of partitioned tables at upper levels
-		 * including those of the current level.
-		 */
-		offset += m;
+			offset += k;
+
+			/*
+			 * Release the relation descriptor.  Lock that we have on the
+			 * table will keep the PartitionDesc that is pointing into
+			 * RelationData intact, a pointer to which hope to keep
+			 * through this transaction's commit.
+			 * (XXX - how true is that?)
+			 */
+			if (partrel != rel)
+				heap_close(partrel, NoLock);
+
+			*ptinfos = lappend(*ptinfos, ptinfo);
+		}
 	}
 
-	return pd;
+	Assert(i == list_length(*leaf_part_oids));
+	Assert((offset + 1) == list_length(*ptinfos));
 }
 
 /* Module-local functions */
@@ -1872,7 +1874,7 @@ generate_partition_qual(Relation rel)
  * ----------------
  */
 void
-FormPartitionKeyDatum(PartitionDispatch pd,
+FormPartitionKeyDatum(PartitionKeyInfo *keyinfo,
 					  TupleTableSlot *slot,
 					  EState *estate,
 					  Datum *values,
@@ -1881,20 +1883,21 @@ FormPartitionKeyDatum(PartitionDispatch pd,
 	ListCell   *partexpr_item;
 	int			i;
 
-	if (pd->key->partexprs != NIL && pd->keystate == NIL)
+	if (keyinfo->key->partexprs != NIL && keyinfo->keystate == NIL)
 	{
 		/* Check caller has set up context correctly */
 		Assert(estate != NULL &&
 			   GetPerTupleExprContext(estate)->ecxt_scantuple == slot);
 
 		/* First time through, set up expression evaluation state */
-		pd->keystate = ExecPrepareExprList(pd->key->partexprs, estate);
+		keyinfo->keystate = ExecPrepareExprList(keyinfo->key->partexprs,
+												estate);
 	}
 
-	partexpr_item = list_head(pd->keystate);
-	for (i = 0; i < pd->key->partnatts; i++)
+	partexpr_item = list_head(keyinfo->keystate);
+	for (i = 0; i < keyinfo->key->partnatts; i++)
 	{
-		AttrNumber	keycol = pd->key->partattrs[i];
+		AttrNumber	keycol = keyinfo->key->partattrs[i];
 		Datum		datum;
 		bool		isNull;
 
@@ -1931,13 +1934,13 @@ FormPartitionKeyDatum(PartitionDispatch pd,
  * the latter case.
  */
 int
-get_partition_for_tuple(PartitionDispatch *pd,
+get_partition_for_tuple(PartitionTupleRoutingInfo **ptrinfos,
 						TupleTableSlot *slot,
 						EState *estate,
-						PartitionDispatchData **failed_at,
+						PartitionTupleRoutingInfo **failed_at,
 						TupleTableSlot **failed_slot)
 {
-	PartitionDispatch parent;
+	PartitionTupleRoutingInfo *parent;
 	Datum		values[PARTITION_MAX_KEYS];
 	bool		isnull[PARTITION_MAX_KEYS];
 	int			cur_offset,
@@ -1948,11 +1951,11 @@ get_partition_for_tuple(PartitionDispatch *pd,
 	TupleTableSlot *ecxt_scantuple_old = ecxt->ecxt_scantuple;
 
 	/* start with the root partitioned table */
-	parent = pd[0];
+	parent = ptrinfos[0];
 	while (true)
 	{
-		PartitionKey key = parent->key;
-		PartitionDesc partdesc = parent->partdesc;
+		PartitionKey  key = parent->pd->partkey;
+		PartitionDesc partdesc = parent->pd->partdesc;
 		TupleTableSlot *myslot = parent->tupslot;
 		TupleConversionMap *map = parent->tupmap;
 
@@ -1984,7 +1987,7 @@ get_partition_for_tuple(PartitionDispatch *pd,
 		 * So update ecxt_scantuple accordingly.
 		 */
 		ecxt->ecxt_scantuple = slot;
-		FormPartitionKeyDatum(parent, slot, estate, values, isnull);
+		FormPartitionKeyDatum(parent->keyinfo, slot, estate, values, isnull);
 
 		if (key->strategy == PARTITION_STRATEGY_RANGE)
 		{
@@ -2055,13 +2058,13 @@ get_partition_for_tuple(PartitionDispatch *pd,
 			*failed_slot = slot;
 			break;
 		}
-		else if (parent->indexes[cur_index] >= 0)
+		else if (parent->pd->indexes[cur_index] >= 0)
 		{
-			result = parent->indexes[cur_index];
+			result = parent->pd->indexes[cur_index];
 			break;
 		}
 		else
-			parent = pd[-parent->indexes[cur_index]];
+			parent = ptrinfos[-parent->pd->indexes[cur_index]];
 	}
 
 error_exit:
diff --git a/src/backend/commands/copy.c b/src/backend/commands/copy.c
index a258965c20..e17a339349 100644
--- a/src/backend/commands/copy.c
+++ b/src/backend/commands/copy.c
@@ -165,8 +165,8 @@ typedef struct CopyStateData
 	bool		volatile_defexprs;	/* is any of defexprs volatile? */
 	List	   *range_table;
 
-	PartitionDispatch *partition_dispatch_info;
-	int			num_dispatch;	/* Number of entries in the above array */
+	PartitionTupleRoutingInfo **ptrinfos;
+	int			num_parted;		/* Number of entries in the above array */
 	int			num_partitions; /* Number of members in the following arrays */
 	ResultRelInfo *partitions;	/* Per partition result relation */
 	TupleConversionMap **partition_tupconv_maps;
@@ -1425,7 +1425,7 @@ BeginCopy(ParseState *pstate,
 		/* Initialize state for CopyFrom tuple routing. */
 		if (is_from && rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
 		{
-			PartitionDispatch *partition_dispatch_info;
+			PartitionTupleRoutingInfo **ptrinfos;
 			ResultRelInfo *partitions;
 			TupleConversionMap **partition_tupconv_maps;
 			TupleTableSlot *partition_tuple_slot;
@@ -1434,13 +1434,13 @@ BeginCopy(ParseState *pstate,
 
 			ExecSetupPartitionTupleRouting(rel,
 										   1,
-										   &partition_dispatch_info,
+										   &ptrinfos,
 										   &partitions,
 										   &partition_tupconv_maps,
 										   &partition_tuple_slot,
 										   &num_parted, &num_partitions);
-			cstate->partition_dispatch_info = partition_dispatch_info;
-			cstate->num_dispatch = num_parted;
+			cstate->ptrinfos = ptrinfos;
+			cstate->num_parted = num_parted;
 			cstate->partitions = partitions;
 			cstate->num_partitions = num_partitions;
 			cstate->partition_tupconv_maps = partition_tupconv_maps;
@@ -2495,7 +2495,7 @@ CopyFrom(CopyState cstate)
 	if ((resultRelInfo->ri_TrigDesc != NULL &&
 		 (resultRelInfo->ri_TrigDesc->trig_insert_before_row ||
 		  resultRelInfo->ri_TrigDesc->trig_insert_instead_row)) ||
-		cstate->partition_dispatch_info != NULL ||
+		cstate->ptrinfos != NULL ||
 		cstate->volatile_defexprs)
 	{
 		useHeapMultiInsert = false;
@@ -2573,7 +2573,7 @@ CopyFrom(CopyState cstate)
 		ExecStoreTuple(tuple, slot, InvalidBuffer, false);
 
 		/* Determine the partition to heap_insert the tuple into */
-		if (cstate->partition_dispatch_info)
+		if (cstate->ptrinfos)
 		{
 			int			leaf_part_index;
 			TupleConversionMap *map;
@@ -2587,7 +2587,7 @@ CopyFrom(CopyState cstate)
 			 * partition, respectively.
 			 */
 			leaf_part_index = ExecFindPartition(resultRelInfo,
-												cstate->partition_dispatch_info,
+												cstate->ptrinfos,
 												slot,
 												estate);
 			Assert(leaf_part_index >= 0 &&
@@ -2819,23 +2819,20 @@ CopyFrom(CopyState cstate)
 
 	ExecCloseIndices(resultRelInfo);
 
-	/* Close all the partitioned tables, leaf partitions, and their indices */
-	if (cstate->partition_dispatch_info)
+	/* Close all the leaf partitions and their indices */
+	if (cstate->ptrinfos)
 	{
 		int			i;
 
 		/*
-		 * Remember cstate->partition_dispatch_info[0] corresponds to the root
-		 * partitioned table, which we must not try to close, because it is
-		 * the main target table of COPY that will be closed eventually by
-		 * DoCopy().  Also, tupslot is NULL for the root partitioned table.
+		 * cstate->ptrinfo[0] corresponds to the root partitioned table, for
+		 * which we didn't create tupslot.
 		 */
-		for (i = 1; i < cstate->num_dispatch; i++)
+		for (i = 1; i < cstate->num_parted; i++)
 		{
-			PartitionDispatch pd = cstate->partition_dispatch_info[i];
+			PartitionTupleRoutingInfo *ptrinfo = cstate->ptrinfos[i];
 
-			heap_close(pd->reldesc, NoLock);
-			ExecDropSingleTupleTableSlot(pd->tupslot);
+			ExecDropSingleTupleTableSlot(ptrinfo->tupslot);
 		}
 		for (i = 0; i < cstate->num_partitions; i++)
 		{
diff --git a/src/backend/executor/execMain.c b/src/backend/executor/execMain.c
index 74071eede6..15366fa4cd 100644
--- a/src/backend/executor/execMain.c
+++ b/src/backend/executor/execMain.c
@@ -3215,8 +3215,8 @@ EvalPlanQualEnd(EPQState *epqstate)
  * tuple routing for partitioned tables
  *
  * Output arguments:
- * 'pd' receives an array of PartitionDispatch objects with one entry for
- *		every partitioned table in the partition tree
+ * 'ptrinfos' receives an array of PartitionTupleRoutingInfo objects with one
+ *		entry for each partitioned table in the partition tree
  * 'partitions' receives an array of ResultRelInfo objects with one entry for
  *		every leaf partition in the partition tree
  * 'tup_conv_maps' receives an array of TupleConversionMap objects with one
@@ -3238,7 +3238,7 @@ EvalPlanQualEnd(EPQState *epqstate)
 void
 ExecSetupPartitionTupleRouting(Relation rel,
 							   Index resultRTindex,
-							   PartitionDispatch **pd,
+							   PartitionTupleRoutingInfo ***ptrinfos,
 							   ResultRelInfo **partitions,
 							   TupleConversionMap ***tup_conv_maps,
 							   TupleTableSlot **partition_tuple_slot,
@@ -3246,16 +3246,135 @@ ExecSetupPartitionTupleRouting(Relation rel,
 {
 	TupleDesc	tupDesc = RelationGetDescr(rel);
 	List	   *leaf_parts;
+	List	   *ptinfos = NIL;
 	ListCell   *cell;
 	int			i;
 	ResultRelInfo *leaf_part_rri;
+	Relation	parent;
 
 	/*
 	 * Get the information about the partition tree after locking all the
 	 * partitions.
 	 */
 	(void) find_all_inheritors(RelationGetRelid(rel), RowExclusiveLock, NULL);
-	*pd = RelationGetPartitionDispatchInfo(rel, num_parted, &leaf_parts);
+	RelationGetPartitionDispatchInfo(rel, &ptinfos, &leaf_parts);
+
+	/*
+	 * The ptinfos list contains PartitionedTableInfo objects for all the
+	 * partitioned tables in the partition tree.  Using the information
+	 * therein, we construct an array of PartitionTupleRoutingInfo objects
+	 * to be used during tuple-routing.
+	 */
+	*num_parted = list_length(ptinfos);
+	*ptrinfos = (PartitionTupleRoutingInfo **) palloc0(*num_parted *
+										sizeof(PartitionTupleRoutingInfo *));
+	/*
+	 * Free the ptinfos List structure itself as we go through (open-coded
+	 * list_free).
+	 */
+	i = 0;
+	cell = list_head(ptinfos);
+	parent = NULL;
+	while (cell)
+	{
+		ListCell   *tmp = cell;
+		PartitionedTableInfo *ptinfo = lfirst(tmp),
+							 *next_ptinfo = NULL;
+		Relation		partrel;
+		PartitionTupleRoutingInfo *ptrinfo;
+
+		if (lnext(tmp))
+			next_ptinfo = lfirst(lnext(tmp));
+
+		/* As mentioned above, the partitioned tables have been locked. */
+		if (ptinfo->relid != RelationGetRelid(rel))
+			partrel = heap_open(ptinfo->relid, NoLock);
+		else
+			partrel = rel;
+
+		ptrinfo = (PartitionTupleRoutingInfo *)
+							palloc0(sizeof(PartitionTupleRoutingInfo));
+		ptrinfo->relid = ptinfo->relid;
+
+		/* Stash a reference to this PartitionDispatch. */
+		ptrinfo->pd = ptinfo->pd;
+
+		/* State for extracting partition key from tuples will go here. */
+		ptrinfo->keyinfo = (PartitionKeyInfo *)
+								palloc0(sizeof(PartitionKeyInfo));
+		ptrinfo->keyinfo->key = RelationGetPartitionKey(partrel);
+		ptrinfo->keyinfo->keystate = NIL;
+
+		/*
+		 * For every partitioned table other than root, we must store a tuple
+		 * table slot initialized with its tuple descriptor and a tuple
+		 * conversion map to convert a tuple from its parent's rowtype to its
+		 * own.  That is to make sure that we are looking at the correct row
+		 * using the correct tuple descriptor when computing its partition key
+		 * for tuple routing.
+		 */
+		if (ptinfo->parentid != InvalidOid)
+		{
+			TupleDesc	tupdesc = RelationGetDescr(partrel);
+
+			/* Open the parent relation descriptor if not already done. */
+			if (ptinfo->parentid == RelationGetRelid(rel))
+			{
+				parent = rel;
+			}
+			else if (parent == NULL)
+			{
+				/* Locked by RelationGetPartitionDispatchInfo(). */
+				parent = heap_open(ptinfo->parentid, NoLock);
+			}
+
+			ptrinfo->tupslot = MakeSingleTupleTableSlot(tupdesc);
+			ptrinfo->tupmap = convert_tuples_by_name(RelationGetDescr(parent),
+													 tupdesc,
+								  gettext_noop("could not convert row type"));
+
+			/*
+			 * Close the parent descriptor, if the next partitioned table in
+			 * the list is not a sibling, because it will have a different
+			 * parent if so.
+			 */
+			if (parent != NULL && parent != rel &&
+				next_ptinfo != NULL &&
+				next_ptinfo->parentid != ptinfo->parentid)
+			{
+				heap_close(parent, NoLock);
+				parent = NULL;
+			}
+
+			/*
+			 * Release the relation descriptor.  Lock that we have on the
+			 * table will keep the PartitionDesc that is pointing into
+			 * RelationData intact, a pointer to which hope to keep
+			 * through this transaction's commit.
+			 * (XXX - how true is that?)
+			 */
+			if (partrel != rel)
+				heap_close(partrel, NoLock);
+		}
+		else
+		{
+			/* Not required for the root partitioned table */
+			ptrinfo->tupslot = NULL;
+			ptrinfo->tupmap = NULL;
+		}
+
+		(*ptrinfos)[i++] = ptrinfo;
+
+		/* Free the ListCell. */
+		cell = lnext(cell);
+		pfree(tmp);
+	}
+
+	/* Free the List itself. */
+	if (ptinfos)
+		pfree(ptinfos);
+
+	/* For leaf partitions, we build ResultRelInfos and TupleConversionMaps. */
 	*num_partitions = list_length(leaf_parts);
 	*partitions = (ResultRelInfo *) palloc(*num_partitions *
 										   sizeof(ResultRelInfo));
@@ -3282,7 +3401,7 @@ ExecSetupPartitionTupleRouting(Relation rel,
 		 * Note that each of the relations in *partitions are eventually
 		 * closed by the caller.
 		 */
-		partrel = heap_open(lfirst_oid(cell), NoLock);
+		partrel = heap_open(lfirst_oid(cell), RowExclusiveLock);
 		part_tupdesc = RelationGetDescr(partrel);
 
 		/*
@@ -3295,7 +3414,7 @@ ExecSetupPartitionTupleRouting(Relation rel,
 		 * partition from the parent's type to the partition's.
 		 */
 		(*tup_conv_maps)[i] = convert_tuples_by_name(tupDesc, part_tupdesc,
-													 gettext_noop("could not convert row type"));
+								 gettext_noop("could not convert row type"));
 
 		InitResultRelInfo(leaf_part_rri,
 						  partrel,
@@ -3329,11 +3448,13 @@ ExecSetupPartitionTupleRouting(Relation rel,
  * by get_partition_for_tuple() unchanged.
  */
 int
-ExecFindPartition(ResultRelInfo *resultRelInfo, PartitionDispatch *pd,
-				  TupleTableSlot *slot, EState *estate)
+ExecFindPartition(ResultRelInfo *resultRelInfo,
+				  PartitionTupleRoutingInfo **ptrinfos,
+				  TupleTableSlot *slot,
+				  EState *estate)
 {
 	int			result;
-	PartitionDispatchData *failed_at;
+	PartitionTupleRoutingInfo *failed_at;
 	TupleTableSlot *failed_slot;
 
 	/*
@@ -3343,7 +3464,7 @@ ExecFindPartition(ResultRelInfo *resultRelInfo, PartitionDispatch *pd,
 	if (resultRelInfo->ri_PartitionCheck)
 		ExecPartitionCheck(resultRelInfo, slot, estate);
 
-	result = get_partition_for_tuple(pd, slot, estate,
+	result = get_partition_for_tuple(ptrinfos, slot, estate,
 									 &failed_at, &failed_slot);
 	if (result < 0)
 	{
@@ -3353,9 +3474,9 @@ ExecFindPartition(ResultRelInfo *resultRelInfo, PartitionDispatch *pd,
 		char	   *val_desc;
 		ExprContext *ecxt = GetPerTupleExprContext(estate);
 
-		failed_rel = failed_at->reldesc;
+		failed_rel = heap_open(failed_at->relid, NoLock);
 		ecxt->ecxt_scantuple = failed_slot;
-		FormPartitionKeyDatum(failed_at, failed_slot, estate,
+		FormPartitionKeyDatum(failed_at->keyinfo, failed_slot, estate,
 							  key_values, key_isnull);
 		val_desc = ExecBuildSlotPartitionKeyDescription(failed_rel,
 														key_values,
diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c
index 36b2b43bc6..9cf974c938 100644
--- a/src/backend/executor/nodeModifyTable.c
+++ b/src/backend/executor/nodeModifyTable.c
@@ -277,7 +277,7 @@ ExecInsert(ModifyTableState *mtstate,
 	resultRelInfo = estate->es_result_relation_info;
 
 	/* Determine the partition to heap_insert the tuple into */
-	if (mtstate->mt_partition_dispatch_info)
+	if (mtstate->mt_ptrinfos)
 	{
 		int			leaf_part_index;
 		TupleConversionMap *map;
@@ -291,7 +291,7 @@ ExecInsert(ModifyTableState *mtstate,
 		 * respectively.
 		 */
 		leaf_part_index = ExecFindPartition(resultRelInfo,
-											mtstate->mt_partition_dispatch_info,
+											mtstate->mt_ptrinfos,
 											slot,
 											estate);
 		Assert(leaf_part_index >= 0 &&
@@ -1486,7 +1486,7 @@ ExecSetupTransitionCaptureState(ModifyTableState *mtstate, EState *estate)
 		int			numResultRelInfos;
 
 		/* Find the set of partitions so that we can find their TupleDescs. */
-		if (mtstate->mt_partition_dispatch_info != NULL)
+		if (mtstate->mt_ptrinfos != NULL)
 		{
 			/*
 			 * For INSERT via partitioned table, so we need TupleDescs based
@@ -1910,7 +1910,7 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 	if (operation == CMD_INSERT &&
 		rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
 	{
-		PartitionDispatch *partition_dispatch_info;
+		PartitionTupleRoutingInfo **ptrinfos;
 		ResultRelInfo *partitions;
 		TupleConversionMap **partition_tupconv_maps;
 		TupleTableSlot *partition_tuple_slot;
@@ -1919,13 +1919,13 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 
 		ExecSetupPartitionTupleRouting(rel,
 									   node->nominalRelation,
-									   &partition_dispatch_info,
+									   &ptrinfos,
 									   &partitions,
 									   &partition_tupconv_maps,
 									   &partition_tuple_slot,
 									   &num_parted, &num_partitions);
-		mtstate->mt_partition_dispatch_info = partition_dispatch_info;
-		mtstate->mt_num_dispatch = num_parted;
+		mtstate->mt_ptrinfos = ptrinfos;
+		mtstate->mt_num_parted = num_parted;
 		mtstate->mt_partitions = partitions;
 		mtstate->mt_num_partitions = num_partitions;
 		mtstate->mt_partition_tupconv_maps = partition_tupconv_maps;
@@ -2335,19 +2335,16 @@ ExecEndModifyTable(ModifyTableState *node)
 	}
 
 	/*
-	 * Close all the partitioned tables, leaf partitions, and their indices
+	 * Close all the leaf partitions and their indices.
 	 *
-	 * Remember node->mt_partition_dispatch_info[0] corresponds to the root
-	 * partitioned table, which we must not try to close, because it is the
-	 * main target table of the query that will be closed by ExecEndPlan().
-	 * Also, tupslot is NULL for the root partitioned table.
+	 * node->mt_partition_dispatch_info[0] corresponds to the root partitioned
+	 * table, for which we didn't create tupslot.
 	 */
-	for (i = 1; i < node->mt_num_dispatch; i++)
+	for (i = 1; i < node->mt_num_parted; i++)
 	{
-		PartitionDispatch pd = node->mt_partition_dispatch_info[i];
+		PartitionTupleRoutingInfo *ptrinfo = node->mt_ptrinfos[i];
 
-		heap_close(pd->reldesc, NoLock);
-		ExecDropSingleTupleTableSlot(pd->tupslot);
+		ExecDropSingleTupleTableSlot(ptrinfo->tupslot);
 	}
 	for (i = 0; i < node->mt_num_partitions; i++)
 	{
diff --git a/src/backend/optimizer/prep/prepunion.c b/src/backend/optimizer/prep/prepunion.c
index e730c24ee4..6abfbec236 100644
--- a/src/backend/optimizer/prep/prepunion.c
+++ b/src/backend/optimizer/prep/prepunion.c
@@ -1459,48 +1459,30 @@ expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti)
 	 */
 	if (rte->relkind == RELKIND_PARTITIONED_TABLE)
 	{
-		List   *leaf_part_oids;
-		int		num_parted,
-				i;
-		PartitionDispatch *pds;
+		List   *leaf_part_oids,
+			   *ptinfos;
 
 		/* Discard the original list. */
 		list_free(inhOIDs);
 		inhOIDs = NIL;
 
 		/* Request partitioning information. */
-		pds = RelationGetPartitionDispatchInfo(oldrelation, &num_parted,
-											   &leaf_part_oids);
+		RelationGetPartitionDispatchInfo(oldrelation, &ptinfos,
+										 &leaf_part_oids);
 
 		/*
 		 * First collect the partitioned child table OIDs, which includes the
 		 * root parent at the head.
 		 */
-		for (i = 0; i < num_parted; i++)
+		foreach(l, ptinfos)
 		{
-			PartitionDispatch pd = pds[i];
+			PartitionedTableInfo *ptinfo = lfirst(l);
 
-			inhOIDs = lappend_oid(inhOIDs, RelationGetRelid(pd->reldesc));
+			inhOIDs = lappend_oid(inhOIDs, ptinfo->relid);
 		}
 
 		/* Concatenate the leaf partition OIDs. */
 		inhOIDs = list_concat(inhOIDs, leaf_part_oids);
-
-		/*
-		 * Release the resources that RelationGetPartitionDispatchInfo
-		 * acquired for us but we don't really need in this case.  Note that
-		 * we don't touch the root partitioned table itself by starting the
-		 * loop with 1, not 0.
-		 */
-		for (i = 1; i < num_parted; i++)
-		{
-			PartitionDispatch pd = pds[i];
-
-			heap_close(pd->reldesc, NoLock);
-			ExecDropSingleTupleTableSlot(pd->tupslot);
-			if (pd->tupmap)
-				pfree(pd->tupmap);
-		}
 	}
 
 	/* Scan the inheritance set and expand it */
diff --git a/src/include/catalog/partition.h b/src/include/catalog/partition.h
index 2283c675e9..7b53baf847 100644
--- a/src/include/catalog/partition.h
+++ b/src/include/catalog/partition.h
@@ -39,36 +39,23 @@ typedef struct PartitionDescData
 
 typedef struct PartitionDescData *PartitionDesc;
 
-/*-----------------------
- * PartitionDispatch - information about one partitioned table in a partition
- * hierarchy required to route a tuple to one of its partitions
- *
- *	reldesc		Relation descriptor of the table
- *	key			Partition key information of the table
- *	keystate	Execution state required for expressions in the partition key
- *	partdesc	Partition descriptor of the table
- *	tupslot		A standalone TupleTableSlot initialized with this table's tuple
- *				descriptor
- *	tupmap		TupleConversionMap to convert from the parent's rowtype to
- *				this table's rowtype (when extracting the partition key of a
- *				tuple just before routing it through this table)
- *	indexes		Array with partdesc->nparts members (for details on what
- *				individual members represent, see how they are set in
- *				RelationGetPartitionDispatchInfo())
- *-----------------------
+typedef struct PartitionDispatchData *PartitionDispatch;
+
+/*
+ * Information about one partitioned table in a given partition tree
  */
-typedef struct PartitionDispatchData
+typedef struct PartitionedTableInfo
 {
-	Relation	reldesc;
-	PartitionKey key;
-	List	   *keystate;		/* list of ExprState */
-	PartitionDesc partdesc;
-	TupleTableSlot *tupslot;
-	TupleConversionMap *tupmap;
-	int		   *indexes;
-} PartitionDispatchData;
+	Oid				relid;
+	Oid				parentid;
 
-typedef struct PartitionDispatchData *PartitionDispatch;
+	/*
+	 * This contains information about bounds of the partitions of this
+	 * table and about where individual partitions are placed in the global
+	 * partition tree.
+	 */
+	PartitionDispatch pd;
+} PartitionedTableInfo;
 
 extern void RelationBuildPartitionDesc(Relation relation);
 extern bool partition_bounds_equal(int partnatts, int16 *parttyplen,
@@ -86,17 +73,18 @@ extern List *map_partition_varattnos(List *expr, int target_varno,
 extern List *RelationGetPartitionQual(Relation rel);
 extern Expr *get_partition_qual_relid(Oid relid);
 
+extern void RelationGetPartitionDispatchInfo(Relation rel,
+								 List **ptinfos, List **leaf_part_oids);
+
 /* For tuple routing */
-extern PartitionDispatch *RelationGetPartitionDispatchInfo(Relation rel,
-								 int *num_parted, List **leaf_part_oids);
-extern void FormPartitionKeyDatum(PartitionDispatch pd,
+extern void FormPartitionKeyDatum(PartitionKeyInfo *keyinfo,
 					  TupleTableSlot *slot,
 					  EState *estate,
 					  Datum *values,
 					  bool *isnull);
-extern int get_partition_for_tuple(PartitionDispatch *pd,
+extern int get_partition_for_tuple(PartitionTupleRoutingInfo **ptrinfos,
 						TupleTableSlot *slot,
 						EState *estate,
-						PartitionDispatchData **failed_at,
+						PartitionTupleRoutingInfo **failed_at,
 						TupleTableSlot **failed_slot);
 #endif							/* PARTITION_H */
diff --git a/src/include/executor/executor.h b/src/include/executor/executor.h
index 60326f9d03..6e1d3a6d2f 100644
--- a/src/include/executor/executor.h
+++ b/src/include/executor/executor.h
@@ -208,13 +208,13 @@ extern void EvalPlanQualSetTuple(EPQState *epqstate, Index rti,
 extern HeapTuple EvalPlanQualGetTuple(EPQState *epqstate, Index rti);
 extern void ExecSetupPartitionTupleRouting(Relation rel,
 							   Index resultRTindex,
-							   PartitionDispatch **pd,
+							   PartitionTupleRoutingInfo ***ptrinfos,
 							   ResultRelInfo **partitions,
 							   TupleConversionMap ***tup_conv_maps,
 							   TupleTableSlot **partition_tuple_slot,
 							   int *num_parted, int *num_partitions);
 extern int ExecFindPartition(ResultRelInfo *resultRelInfo,
-				  PartitionDispatch *pd,
+				  PartitionTupleRoutingInfo **ptrinfos,
 				  TupleTableSlot *slot,
 				  EState *estate);
 
diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h
index 577499465d..07e50e0914 100644
--- a/src/include/nodes/execnodes.h
+++ b/src/include/nodes/execnodes.h
@@ -414,6 +414,55 @@ typedef struct ResultRelInfo
 	Relation	ri_PartitionRoot;
 } ResultRelInfo;
 
+/* Forward declarations, to avoid including other headers */
+typedef struct PartitionKeyData *PartitionKey;
+typedef struct PartitionDispatchData *PartitionDispatch;
+
+/*
+ * PartitionKeyInfoData - execution state for the partition key of a
+ *						  partitioned table
+ *
+ * keystate is the execution state required for expressions contained in the
+ * partition key.  It is NIL until initialized by FormPartitionKeyDatum() if
+ * and when it is called; for example, during tuple routing through a given
+ * partitioned table.
+ */
+typedef struct PartitionKeyInfo
+{
+	PartitionKey	key;		/* Points into the table's relcache entry */
+	List		   *keystate;
+} PartitionKeyInfo;
+
+/*
+ * PartitionTupleRoutingInfo - information required for tuple-routing
+ *							   through one partitioned table in a partition
+ *							   tree
+ */
+typedef struct PartitionTupleRoutingInfo
+{
+	/* OID of the table */
+	Oid				relid;
+
+	/* Information about the table's partitions */
+	PartitionDispatch	pd;
+
+	/* See comment above the definition of PartitionKeyInfo */
+	PartitionKeyInfo   *keyinfo;
+
+	/*
+	 * A standalone TupleTableSlot initialized with this table's tuple
+	 * descriptor
+	 */
+	TupleTableSlot *tupslot;
+
+	/*
+	 * TupleConversionMap to convert from the parent's rowtype to this table's
+	 * rowtype (when extracting the partition key of a tuple just before
+	 * routing it through this table)
+	 */
+	TupleConversionMap *tupmap;
+} PartitionTupleRoutingInfo;
+
 /* ----------------
  *	  EState information
  *
@@ -970,9 +1019,9 @@ typedef struct ModifyTableState
 	TupleTableSlot *mt_existing;	/* slot to store existing target tuple in */
 	List	   *mt_excludedtlist;	/* the excluded pseudo relation's tlist  */
 	TupleTableSlot *mt_conflproj;	/* CONFLICT ... SET ... projection target */
-	struct PartitionDispatchData **mt_partition_dispatch_info;
 	/* Tuple-routing support info */
-	int			mt_num_dispatch;	/* Number of entries in the above array */
+	struct PartitionTupleRoutingInfo **mt_ptrinfos;
+	int			mt_num_parted;		/* Number of entries in the above array */
 	int			mt_num_partitions;	/* Number of members in the following
 									 * arrays */
 	ResultRelInfo *mt_partitions;	/* Per partition result relation */
-- 
2.11.0

From b86fd0e920e4bc49b17a2dba9e848420ec99c22b Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Mon, 24 Jul 2017 18:59:57 +0900
Subject: [PATCH 1/2] Decouple RelationGetPartitionDispatchInfo() from executor

Currently it and the structure it generates viz. PartitionDispatch
objects are too coupled with the executor's tuple-routing code.  In
particular, it's pretty undesirable that it makes it the responsibility
of the caller to release some resources, such as relcache references
and tuple table slots.  That makes it harder to use in places other
than where it's currently being used.

After this refactoring, ExecSetupPartitionTupleRouting() now needs to
do some of the work that was previously done in
RelationGetPartitionDispatchInfo() and expand_inherited_rtentry() no
longer needs to do some things that it used to.
---
 src/backend/catalog/partition.c        | 309 +++++++++++++++++----------------
 src/backend/commands/copy.c            |  35 ++--
 src/backend/executor/execMain.c        | 145 ++++++++++++++--
 src/backend/executor/nodeModifyTable.c |  29 ++--
 src/include/catalog/partition.h        |  52 +++---
 src/include/executor/executor.h        |   4 +-
 src/include/nodes/execnodes.h          |  53 +++++-
 7 files changed, 391 insertions(+), 236 deletions(-)

diff --git a/src/backend/catalog/partition.c b/src/backend/catalog/partition.c
index 96a64ce6b2..7618e4cb31 100644
--- a/src/backend/catalog/partition.c
+++ b/src/backend/catalog/partition.c
@@ -105,6 +105,24 @@ typedef struct PartitionRangeBound
 	bool		lower;			/* this is the lower (vs upper) bound */
 } PartitionRangeBound;
 
+/*-----------------------
+ * PartitionDispatchData - information of partitions of one partitioned table
+ *						   in a partition tree
+ *
+ *	partkey		Partition key of the table
+ *	partdesc	Partition descriptor of the table
+ *	indexes		Array with partdesc->nparts members (for details on what the
+ *				individual value represents, see the comments in
+ *				RelationGetPartitionDispatchInfo())
+ *-----------------------
+ */
+typedef struct PartitionDispatchData
+{
+	PartitionKey	partkey;	/* Points into the table's relcache entry */
+	PartitionDesc	partdesc;	/* Ditto */
+	int			   *indexes;
+} PartitionDispatchData;
+
 static int32 qsort_partition_list_value_cmp(const void *a, const void *b,
 							   void *arg);
 static int32 qsort_partition_rbound_cmp(const void *a, const void *b,
@@ -981,181 +999,165 @@ get_partition_qual_relid(Oid relid)
 }
 
 /*
- * Append OIDs of rel's partitions to the list 'partoids' and for each OID,
- * append pointer rel to the list 'parents'.
- */
-#define APPEND_REL_PARTITION_OIDS(rel, partoids, parents) \
-	do\
-	{\
-		int		i;\
-		for (i = 0; i < (rel)->rd_partdesc->nparts; i++)\
-		{\
-			(partoids) = lappend_oid((partoids), (rel)->rd_partdesc->oids[i]);\
-			(parents) = lappend((parents), (rel));\
-		}\
-	} while(0)
-
-/*
  * RelationGetPartitionDispatchInfo
- *		Returns information necessary to route tuples down a partition tree
+ *		Returns necessary information for each partition in the partition
+ *		tree rooted at rel
  *
- * The number of elements in the returned array (that is, the number of
- * PartitionDispatch objects for the partitioned tables in the partition tree)
- * is returned in *num_parted and a list of the OIDs of all the leaf
- * partitions of rel is returned in *leaf_part_oids.
+ * Information returned includes the following: *ptinfos contains a list of
+ * PartitionedTableInfo objects, one for each partitioned table (with at least
+ * one member, that is, one for the root partitioned table), *leaf_part_oids
+ * contains a list of the OIDs of of all the leaf partitions.
  *
- * All the relations in the partition tree (including 'rel') must have been
- * locked (using at least the AccessShareLock) by the caller.
+ * We require that the caller has locked at least the partitioned tables in the
+ * partition tree (including 'rel') using at least the AccessShareLock,
+ * because we need to look at their relcache entries to get PartitionKey and
+ * PartitionDesc.
  */
-PartitionDispatch *
+void
 RelationGetPartitionDispatchInfo(Relation rel,
-								 int *num_parted, List **leaf_part_oids)
+								 List **ptinfos, List **leaf_part_oids)
 {
-	PartitionDispatchData **pd;
-	List	   *all_parts = NIL,
-			   *all_parents = NIL,
-			   *parted_rels,
-			   *parted_rel_parents;
+	List	   *all_parts,
+			   *all_parents;
 	ListCell   *lc1,
 			   *lc2;
 	int			i,
-				k,
 				offset;
 
 	/*
 	 * We rely on the relcache to traverse the partition tree to build both
-	 * the leaf partition OIDs list and the array of PartitionDispatch objects
-	 * for the partitioned tables in the tree.  That means every partitioned
-	 * table in the tree must be locked, which is fine since we require the
-	 * caller to lock all the partitions anyway.
+	 * the leaf partition OIDs list and the list of PartitionedTableInfo
+	 * objects for partitioned tables.  That means every partitioned table in
+	 * the tree must be locked, which is fine since the callers must have done
+	 * that already.
 	 *
 	 * For every partitioned table in the tree, starting with the root
 	 * partitioned table, add its relcache entry to parted_rels, while also
 	 * queuing its partitions (in the order in which they appear in the
 	 * partition descriptor) to be looked at later in the same loop.  This is
 	 * a bit tricky but works because the foreach() macro doesn't fetch the
-	 * next list element until the bottom of the loop.
+	 * next list element until the bottom of the loop.  Non-partitioned tables
+	 * are simply added to the leaf partitions list.
 	 */
-	*num_parted = 1;
-	parted_rels = list_make1(rel);
-	/* Root partitioned table has no parent, so NULL for parent */
-	parted_rel_parents = list_make1(NULL);
-	APPEND_REL_PARTITION_OIDS(rel, all_parts, all_parents);
+	i = offset = 0;
+	*ptinfos = *leaf_part_oids = NIL;
+
+	/* Start with the root table. */
+	all_parts = list_make1_oid(RelationGetRelid(rel));
+	all_parents = list_make1_oid(InvalidOid);
 	forboth(lc1, all_parts, lc2, all_parents)
 	{
-		Oid			partrelid = lfirst_oid(lc1);
-		Relation	parent = lfirst(lc2);
+		Oid		partrelid = lfirst_oid(lc1);
+		Oid		parentrelid = lfirst_oid(lc2);
 
 		if (get_rel_relkind(partrelid) == RELKIND_PARTITIONED_TABLE)
 		{
-			/*
-			 * Already locked by the caller.  Note that it is the
-			 * responsibility of the caller to close the below relcache entry,
-			 * once done using the information being collected here (for
-			 * example, in ExecEndModifyTable).
-			 */
-			Relation	partrel = heap_open(partrelid, NoLock);
+			int		j,
+					k;
+			Relation		partrel;
+			PartitionKey	partkey;
+			PartitionDesc	partdesc;
+			PartitionedTableInfo   *ptinfo;
+			PartitionDispatch		pd;
+
+			if (partrelid != RelationGetRelid(rel))
+				partrel = heap_open(partrelid, NoLock);
+			else
+				partrel = rel;
 
-			(*num_parted)++;
-			parted_rels = lappend(parted_rels, partrel);
-			parted_rel_parents = lappend(parted_rel_parents, parent);
-			APPEND_REL_PARTITION_OIDS(partrel, all_parts, all_parents);
-		}
-	}
+			partkey = RelationGetPartitionKey(partrel);
+			partdesc = RelationGetPartitionDesc(partrel);
+
+			ptinfo = (PartitionedTableInfo *)
+									palloc0(sizeof(PartitionedTableInfo));
+			ptinfo->relid = partrelid;
+			ptinfo->parentid = parentrelid;
+
+			ptinfo->pd = pd = (PartitionDispatchData *)
+									palloc0(sizeof(PartitionDispatchData));
+			pd->partkey = partkey;
 
-	/*
-	 * We want to create two arrays - one for leaf partitions and another for
-	 * partitioned tables (including the root table and internal partitions).
-	 * While we only create the latter here, leaf partition array of suitable
-	 * objects (such as, ResultRelInfo) is created by the caller using the
-	 * list of OIDs we return.  Indexes into these arrays get assigned in a
-	 * breadth-first manner, whereby partitions of any given level are placed
-	 * consecutively in the respective arrays.
-	 */
-	pd = (PartitionDispatchData **) palloc(*num_parted *
-										   sizeof(PartitionDispatchData *));
-	*leaf_part_oids = NIL;
-	i = k = offset = 0;
-	forboth(lc1, parted_rels, lc2, parted_rel_parents)
-	{
-		Relation	partrel = lfirst(lc1);
-		Relation	parent = lfirst(lc2);
-		PartitionKey partkey = RelationGetPartitionKey(partrel);
-		TupleDesc	tupdesc = RelationGetDescr(partrel);
-		PartitionDesc partdesc = RelationGetPartitionDesc(partrel);
-		int			j,
-					m;
-
-		pd[i] = (PartitionDispatch) palloc(sizeof(PartitionDispatchData));
-		pd[i]->reldesc = partrel;
-		pd[i]->key = partkey;
-		pd[i]->keystate = NIL;
-		pd[i]->partdesc = partdesc;
-		if (parent != NULL)
-		{
 			/*
-			 * For every partitioned table other than root, we must store a
-			 * tuple table slot initialized with its tuple descriptor and a
-			 * tuple conversion map to convert a tuple from its parent's
-			 * rowtype to its own. That is to make sure that we are looking at
-			 * the correct row using the correct tuple descriptor when
-			 * computing its partition key for tuple routing.
+			 * XXX- do we need a pinning mechanism for partition descriptors
+			 * so that there references can be managed independently of
+			 * the parent relcache entry? Like PinPartitionDesc(partdesc)?
 			 */
-			pd[i]->tupslot = MakeSingleTupleTableSlot(tupdesc);
-			pd[i]->tupmap = convert_tuples_by_name(RelationGetDescr(parent),
-												   tupdesc,
-												   gettext_noop("could not convert row type"));
-		}
-		else
-		{
-			/* Not required for the root partitioned table */
-			pd[i]->tupslot = NULL;
-			pd[i]->tupmap = NULL;
-		}
-		pd[i]->indexes = (int *) palloc(partdesc->nparts * sizeof(int));
+			pd->partdesc = partdesc;
 
-		/*
-		 * Indexes corresponding to the internal partitions are multiplied by
-		 * -1 to distinguish them from those of leaf partitions.  Encountering
-		 * an index >= 0 means we found a leaf partition, which is immediately
-		 * returned as the partition we are looking for.  A negative index
-		 * means we found a partitioned table, whose PartitionDispatch object
-		 * is located at the above index multiplied back by -1.  Using the
-		 * PartitionDispatch object, search is continued further down the
-		 * partition tree.
-		 */
-		m = 0;
-		for (j = 0; j < partdesc->nparts; j++)
-		{
-			Oid			partrelid = partdesc->oids[j];
+			/*
+			 * The values contained in the following array correspond to
+			 * indexes of this table's partitions in the global sequence of
+			 * all the partitions contained in the partition tree rooted at
+			 * rel, traversed in a breadh-first manner.  The values should be
+			 * such that we will be able to distinguish the leaf partitions
+			 * from the non-leaf partitions, because they are returned to
+			 * to the caller in separate structures from where they will be
+			 * accessed.  The way that's done is described below:
+			 *
+			 * Leaf partition OIDs are put into the global leaf_part_oids list,
+			 * and for each one, the value stored is its ordinal position in
+			 * the list minus 1.
+			 *
+			 * PartitionedTableInfo objects corresponding to partitions that
+			 * are partitioned tables are put into the global ptinfos[] list,
+			 * and for each one, the value stored is its ordinal position in
+			 * the list multiplied by -1.
+			 *
+			 * So while looking at the values in the indexes array, if one
+			 * gets zero or a positive value, then it's a leaf partition,
+			 * Otherwise, it's a partitioned table.
+			 */
+			pd->indexes = (int *) palloc(partdesc->nparts * sizeof(int));
 
-			if (get_rel_relkind(partrelid) != RELKIND_PARTITIONED_TABLE)
-			{
-				*leaf_part_oids = lappend_oid(*leaf_part_oids, partrelid);
-				pd[i]->indexes[j] = k++;
-			}
-			else
+			k = 0;
+			for (j = 0; j < partdesc->nparts; j++)
 			{
+				Oid			partrelid = partdesc->oids[j];
+
 				/*
-				 * offset denotes the number of partitioned tables of upper
-				 * levels including those of the current level.  Any partition
-				 * of this table must belong to the next level and hence will
-				 * be placed after the last partitioned table of this level.
+				 * Queue this partition so that it will be processed later
+				 * by the outer loop.
 				 */
-				pd[i]->indexes[j] = -(1 + offset + m);
-				m++;
+				all_parts = lappend_oid(all_parts, partrelid);
+				all_parents = lappend_oid(all_parents,
+										  RelationGetRelid(partrel));
+
+				if (get_rel_relkind(partrelid) != RELKIND_PARTITIONED_TABLE)
+				{
+					*leaf_part_oids = lappend_oid(*leaf_part_oids, partrelid);
+					pd->indexes[j] = i++;
+				}
+				else
+				{
+					/*
+					 * offset denotes the number of partitioned tables that
+					 * we have already processed.  k counts the number of
+					 * partitions of this table that were found to be
+					 * partitioned tables.
+					 */
+					pd->indexes[j] = -(1 + offset + k);
+					k++;
+				}
 			}
-		}
-		i++;
 
-		/*
-		 * This counts the number of partitioned tables at upper levels
-		 * including those of the current level.
-		 */
-		offset += m;
+			offset += k;
+
+			/*
+			 * Release the relation descriptor.  Lock that we have on the
+			 * table will keep the PartitionDesc that is pointing into
+			 * RelationData intact, a pointer to which hope to keep
+			 * through this transaction's commit.
+			 * (XXX - how true is that?)
+			 */
+			if (partrel != rel)
+				heap_close(partrel, NoLock);
+
+			*ptinfos = lappend(*ptinfos, ptinfo);
+		}
 	}
 
-	return pd;
+	Assert(i == list_length(*leaf_part_oids));
+	Assert((offset + 1) == list_length(*ptinfos));
 }
 
 /* Module-local functions */
@@ -1872,7 +1874,7 @@ generate_partition_qual(Relation rel)
  * ----------------
  */
 void
-FormPartitionKeyDatum(PartitionDispatch pd,
+FormPartitionKeyDatum(PartitionKeyInfo *keyinfo,
 					  TupleTableSlot *slot,
 					  EState *estate,
 					  Datum *values,
@@ -1881,20 +1883,21 @@ FormPartitionKeyDatum(PartitionDispatch pd,
 	ListCell   *partexpr_item;
 	int			i;
 
-	if (pd->key->partexprs != NIL && pd->keystate == NIL)
+	if (keyinfo->key->partexprs != NIL && keyinfo->keystate == NIL)
 	{
 		/* Check caller has set up context correctly */
 		Assert(estate != NULL &&
 			   GetPerTupleExprContext(estate)->ecxt_scantuple == slot);
 
 		/* First time through, set up expression evaluation state */
-		pd->keystate = ExecPrepareExprList(pd->key->partexprs, estate);
+		keyinfo->keystate = ExecPrepareExprList(keyinfo->key->partexprs,
+												estate);
 	}
 
-	partexpr_item = list_head(pd->keystate);
-	for (i = 0; i < pd->key->partnatts; i++)
+	partexpr_item = list_head(keyinfo->keystate);
+	for (i = 0; i < keyinfo->key->partnatts; i++)
 	{
-		AttrNumber	keycol = pd->key->partattrs[i];
+		AttrNumber	keycol = keyinfo->key->partattrs[i];
 		Datum		datum;
 		bool		isNull;
 
@@ -1931,13 +1934,13 @@ FormPartitionKeyDatum(PartitionDispatch pd,
  * the latter case.
  */
 int
-get_partition_for_tuple(PartitionDispatch *pd,
+get_partition_for_tuple(PartitionTupleRoutingInfo **ptrinfos,
 						TupleTableSlot *slot,
 						EState *estate,
-						PartitionDispatchData **failed_at,
+						PartitionTupleRoutingInfo **failed_at,
 						TupleTableSlot **failed_slot)
 {
-	PartitionDispatch parent;
+	PartitionTupleRoutingInfo *parent;
 	Datum		values[PARTITION_MAX_KEYS];
 	bool		isnull[PARTITION_MAX_KEYS];
 	int			cur_offset,
@@ -1948,11 +1951,11 @@ get_partition_for_tuple(PartitionDispatch *pd,
 	TupleTableSlot *ecxt_scantuple_old = ecxt->ecxt_scantuple;
 
 	/* start with the root partitioned table */
-	parent = pd[0];
+	parent = ptrinfos[0];
 	while (true)
 	{
-		PartitionKey key = parent->key;
-		PartitionDesc partdesc = parent->partdesc;
+		PartitionKey  key = parent->pd->partkey;
+		PartitionDesc partdesc = parent->pd->partdesc;
 		TupleTableSlot *myslot = parent->tupslot;
 		TupleConversionMap *map = parent->tupmap;
 
@@ -1984,7 +1987,7 @@ get_partition_for_tuple(PartitionDispatch *pd,
 		 * So update ecxt_scantuple accordingly.
 		 */
 		ecxt->ecxt_scantuple = slot;
-		FormPartitionKeyDatum(parent, slot, estate, values, isnull);
+		FormPartitionKeyDatum(parent->keyinfo, slot, estate, values, isnull);
 
 		if (key->strategy == PARTITION_STRATEGY_RANGE)
 		{
@@ -2055,13 +2058,13 @@ get_partition_for_tuple(PartitionDispatch *pd,
 			*failed_slot = slot;
 			break;
 		}
-		else if (parent->indexes[cur_index] >= 0)
+		else if (parent->pd->indexes[cur_index] >= 0)
 		{
-			result = parent->indexes[cur_index];
+			result = parent->pd->indexes[cur_index];
 			break;
 		}
 		else
-			parent = pd[-parent->indexes[cur_index]];
+			parent = ptrinfos[-parent->pd->indexes[cur_index]];
 	}
 
 error_exit:
diff --git a/src/backend/commands/copy.c b/src/backend/commands/copy.c
index a258965c20..e17a339349 100644
--- a/src/backend/commands/copy.c
+++ b/src/backend/commands/copy.c
@@ -165,8 +165,8 @@ typedef struct CopyStateData
 	bool		volatile_defexprs;	/* is any of defexprs volatile? */
 	List	   *range_table;
 
-	PartitionDispatch *partition_dispatch_info;
-	int			num_dispatch;	/* Number of entries in the above array */
+	PartitionTupleRoutingInfo **ptrinfos;
+	int			num_parted;		/* Number of entries in the above array */
 	int			num_partitions; /* Number of members in the following arrays */
 	ResultRelInfo *partitions;	/* Per partition result relation */
 	TupleConversionMap **partition_tupconv_maps;
@@ -1425,7 +1425,7 @@ BeginCopy(ParseState *pstate,
 		/* Initialize state for CopyFrom tuple routing. */
 		if (is_from && rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
 		{
-			PartitionDispatch *partition_dispatch_info;
+			PartitionTupleRoutingInfo **ptrinfos;
 			ResultRelInfo *partitions;
 			TupleConversionMap **partition_tupconv_maps;
 			TupleTableSlot *partition_tuple_slot;
@@ -1434,13 +1434,13 @@ BeginCopy(ParseState *pstate,
 
 			ExecSetupPartitionTupleRouting(rel,
 										   1,
-										   &partition_dispatch_info,
+										   &ptrinfos,
 										   &partitions,
 										   &partition_tupconv_maps,
 										   &partition_tuple_slot,
 										   &num_parted, &num_partitions);
-			cstate->partition_dispatch_info = partition_dispatch_info;
-			cstate->num_dispatch = num_parted;
+			cstate->ptrinfos = ptrinfos;
+			cstate->num_parted = num_parted;
 			cstate->partitions = partitions;
 			cstate->num_partitions = num_partitions;
 			cstate->partition_tupconv_maps = partition_tupconv_maps;
@@ -2495,7 +2495,7 @@ CopyFrom(CopyState cstate)
 	if ((resultRelInfo->ri_TrigDesc != NULL &&
 		 (resultRelInfo->ri_TrigDesc->trig_insert_before_row ||
 		  resultRelInfo->ri_TrigDesc->trig_insert_instead_row)) ||
-		cstate->partition_dispatch_info != NULL ||
+		cstate->ptrinfos != NULL ||
 		cstate->volatile_defexprs)
 	{
 		useHeapMultiInsert = false;
@@ -2573,7 +2573,7 @@ CopyFrom(CopyState cstate)
 		ExecStoreTuple(tuple, slot, InvalidBuffer, false);
 
 		/* Determine the partition to heap_insert the tuple into */
-		if (cstate->partition_dispatch_info)
+		if (cstate->ptrinfos)
 		{
 			int			leaf_part_index;
 			TupleConversionMap *map;
@@ -2587,7 +2587,7 @@ CopyFrom(CopyState cstate)
 			 * partition, respectively.
 			 */
 			leaf_part_index = ExecFindPartition(resultRelInfo,
-												cstate->partition_dispatch_info,
+												cstate->ptrinfos,
 												slot,
 												estate);
 			Assert(leaf_part_index >= 0 &&
@@ -2819,23 +2819,20 @@ CopyFrom(CopyState cstate)
 
 	ExecCloseIndices(resultRelInfo);
 
-	/* Close all the partitioned tables, leaf partitions, and their indices */
-	if (cstate->partition_dispatch_info)
+	/* Close all the leaf partitions and their indices */
+	if (cstate->ptrinfos)
 	{
 		int			i;
 
 		/*
-		 * Remember cstate->partition_dispatch_info[0] corresponds to the root
-		 * partitioned table, which we must not try to close, because it is
-		 * the main target table of COPY that will be closed eventually by
-		 * DoCopy().  Also, tupslot is NULL for the root partitioned table.
+		 * cstate->ptrinfo[0] corresponds to the root partitioned table, for
+		 * which we didn't create tupslot.
 		 */
-		for (i = 1; i < cstate->num_dispatch; i++)
+		for (i = 1; i < cstate->num_parted; i++)
 		{
-			PartitionDispatch pd = cstate->partition_dispatch_info[i];
+			PartitionTupleRoutingInfo *ptrinfo = cstate->ptrinfos[i];
 
-			heap_close(pd->reldesc, NoLock);
-			ExecDropSingleTupleTableSlot(pd->tupslot);
+			ExecDropSingleTupleTableSlot(ptrinfo->tupslot);
 		}
 		for (i = 0; i < cstate->num_partitions; i++)
 		{
diff --git a/src/backend/executor/execMain.c b/src/backend/executor/execMain.c
index 74071eede6..15366fa4cd 100644
--- a/src/backend/executor/execMain.c
+++ b/src/backend/executor/execMain.c
@@ -3215,8 +3215,8 @@ EvalPlanQualEnd(EPQState *epqstate)
  * tuple routing for partitioned tables
  *
  * Output arguments:
- * 'pd' receives an array of PartitionDispatch objects with one entry for
- *		every partitioned table in the partition tree
+ * 'ptrinfos' receives an array of PartitionTupleRoutingInfo objects with one
+ *		entry for each partitioned table in the partition tree
  * 'partitions' receives an array of ResultRelInfo objects with one entry for
  *		every leaf partition in the partition tree
  * 'tup_conv_maps' receives an array of TupleConversionMap objects with one
@@ -3238,7 +3238,7 @@ EvalPlanQualEnd(EPQState *epqstate)
 void
 ExecSetupPartitionTupleRouting(Relation rel,
 							   Index resultRTindex,
-							   PartitionDispatch **pd,
+							   PartitionTupleRoutingInfo ***ptrinfos,
 							   ResultRelInfo **partitions,
 							   TupleConversionMap ***tup_conv_maps,
 							   TupleTableSlot **partition_tuple_slot,
@@ -3246,16 +3246,135 @@ ExecSetupPartitionTupleRouting(Relation rel,
 {
 	TupleDesc	tupDesc = RelationGetDescr(rel);
 	List	   *leaf_parts;
+	List	   *ptinfos = NIL;
 	ListCell   *cell;
 	int			i;
 	ResultRelInfo *leaf_part_rri;
+	Relation	parent;
 
 	/*
 	 * Get the information about the partition tree after locking all the
 	 * partitions.
 	 */
 	(void) find_all_inheritors(RelationGetRelid(rel), RowExclusiveLock, NULL);
-	*pd = RelationGetPartitionDispatchInfo(rel, num_parted, &leaf_parts);
+	RelationGetPartitionDispatchInfo(rel, &ptinfos, &leaf_parts);
+
+	/*
+	 * The ptinfos list contains PartitionedTableInfo objects for all the
+	 * partitioned tables in the partition tree.  Using the information
+	 * therein, we construct an array of PartitionTupleRoutingInfo objects
+	 * to be used during tuple-routing.
+	 */
+	*num_parted = list_length(ptinfos);
+	*ptrinfos = (PartitionTupleRoutingInfo **) palloc0(*num_parted *
+										sizeof(PartitionTupleRoutingInfo *));
+	/*
+	 * Free the ptinfos List structure itself as we go through (open-coded
+	 * list_free).
+	 */
+	i = 0;
+	cell = list_head(ptinfos);
+	parent = NULL;
+	while (cell)
+	{
+		ListCell   *tmp = cell;
+		PartitionedTableInfo *ptinfo = lfirst(tmp),
+							 *next_ptinfo = NULL;
+		Relation		partrel;
+		PartitionTupleRoutingInfo *ptrinfo;
+
+		if (lnext(tmp))
+			next_ptinfo = lfirst(lnext(tmp));
+
+		/* As mentioned above, the partitioned tables have been locked. */
+		if (ptinfo->relid != RelationGetRelid(rel))
+			partrel = heap_open(ptinfo->relid, NoLock);
+		else
+			partrel = rel;
+
+		ptrinfo = (PartitionTupleRoutingInfo *)
+							palloc0(sizeof(PartitionTupleRoutingInfo));
+		ptrinfo->relid = ptinfo->relid;
+
+		/* Stash a reference to this PartitionDispatch. */
+		ptrinfo->pd = ptinfo->pd;
+
+		/* State for extracting partition key from tuples will go here. */
+		ptrinfo->keyinfo = (PartitionKeyInfo *)
+								palloc0(sizeof(PartitionKeyInfo));
+		ptrinfo->keyinfo->key = RelationGetPartitionKey(partrel);
+		ptrinfo->keyinfo->keystate = NIL;
+
+		/*
+		 * For every partitioned table other than root, we must store a tuple
+		 * table slot initialized with its tuple descriptor and a tuple
+		 * conversion map to convert a tuple from its parent's rowtype to its
+		 * own.  That is to make sure that we are looking at the correct row
+		 * using the correct tuple descriptor when computing its partition key
+		 * for tuple routing.
+		 */
+		if (ptinfo->parentid != InvalidOid)
+		{
+			TupleDesc	tupdesc = RelationGetDescr(partrel);
+
+			/* Open the parent relation descriptor if not already done. */
+			if (ptinfo->parentid == RelationGetRelid(rel))
+			{
+				parent = rel;
+			}
+			else if (parent == NULL)
+			{
+				/* Locked by RelationGetPartitionDispatchInfo(). */
+				parent = heap_open(ptinfo->parentid, NoLock);
+			}
+
+			ptrinfo->tupslot = MakeSingleTupleTableSlot(tupdesc);
+			ptrinfo->tupmap = convert_tuples_by_name(RelationGetDescr(parent),
+													 tupdesc,
+								  gettext_noop("could not convert row type"));
+
+			/*
+			 * Close the parent descriptor, if the next partitioned table in
+			 * the list is not a sibling, because it will have a different
+			 * parent if so.
+			 */
+			if (parent != NULL && parent != rel &&
+				next_ptinfo != NULL &&
+				next_ptinfo->parentid != ptinfo->parentid)
+			{
+				heap_close(parent, NoLock);
+				parent = NULL;
+			}
+
+			/*
+			 * Release the relation descriptor.  Lock that we have on the
+			 * table will keep the PartitionDesc that is pointing into
+			 * RelationData intact, a pointer to which hope to keep
+			 * through this transaction's commit.
+			 * (XXX - how true is that?)
+			 */
+			if (partrel != rel)
+				heap_close(partrel, NoLock);
+		}
+		else
+		{
+			/* Not required for the root partitioned table */
+			ptrinfo->tupslot = NULL;
+			ptrinfo->tupmap = NULL;
+		}
+
+		(*ptrinfos)[i++] = ptrinfo;
+
+		/* Free the ListCell. */
+		cell = lnext(cell);
+		pfree(tmp);
+	}
+
+	/* Free the List itself. */
+	if (ptinfos)
+		pfree(ptinfos);
+
+	/* For leaf partitions, we build ResultRelInfos and TupleConversionMaps. */
 	*num_partitions = list_length(leaf_parts);
 	*partitions = (ResultRelInfo *) palloc(*num_partitions *
 										   sizeof(ResultRelInfo));
@@ -3282,7 +3401,7 @@ ExecSetupPartitionTupleRouting(Relation rel,
 		 * Note that each of the relations in *partitions are eventually
 		 * closed by the caller.
 		 */
-		partrel = heap_open(lfirst_oid(cell), NoLock);
+		partrel = heap_open(lfirst_oid(cell), RowExclusiveLock);
 		part_tupdesc = RelationGetDescr(partrel);
 
 		/*
@@ -3295,7 +3414,7 @@ ExecSetupPartitionTupleRouting(Relation rel,
 		 * partition from the parent's type to the partition's.
 		 */
 		(*tup_conv_maps)[i] = convert_tuples_by_name(tupDesc, part_tupdesc,
-													 gettext_noop("could not convert row type"));
+								 gettext_noop("could not convert row type"));
 
 		InitResultRelInfo(leaf_part_rri,
 						  partrel,
@@ -3329,11 +3448,13 @@ ExecSetupPartitionTupleRouting(Relation rel,
  * by get_partition_for_tuple() unchanged.
  */
 int
-ExecFindPartition(ResultRelInfo *resultRelInfo, PartitionDispatch *pd,
-				  TupleTableSlot *slot, EState *estate)
+ExecFindPartition(ResultRelInfo *resultRelInfo,
+				  PartitionTupleRoutingInfo **ptrinfos,
+				  TupleTableSlot *slot,
+				  EState *estate)
 {
 	int			result;
-	PartitionDispatchData *failed_at;
+	PartitionTupleRoutingInfo *failed_at;
 	TupleTableSlot *failed_slot;
 
 	/*
@@ -3343,7 +3464,7 @@ ExecFindPartition(ResultRelInfo *resultRelInfo, PartitionDispatch *pd,
 	if (resultRelInfo->ri_PartitionCheck)
 		ExecPartitionCheck(resultRelInfo, slot, estate);
 
-	result = get_partition_for_tuple(pd, slot, estate,
+	result = get_partition_for_tuple(ptrinfos, slot, estate,
 									 &failed_at, &failed_slot);
 	if (result < 0)
 	{
@@ -3353,9 +3474,9 @@ ExecFindPartition(ResultRelInfo *resultRelInfo, PartitionDispatch *pd,
 		char	   *val_desc;
 		ExprContext *ecxt = GetPerTupleExprContext(estate);
 
-		failed_rel = failed_at->reldesc;
+		failed_rel = heap_open(failed_at->relid, NoLock);
 		ecxt->ecxt_scantuple = failed_slot;
-		FormPartitionKeyDatum(failed_at, failed_slot, estate,
+		FormPartitionKeyDatum(failed_at->keyinfo, failed_slot, estate,
 							  key_values, key_isnull);
 		val_desc = ExecBuildSlotPartitionKeyDescription(failed_rel,
 														key_values,
diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c
index 36b2b43bc6..9cf974c938 100644
--- a/src/backend/executor/nodeModifyTable.c
+++ b/src/backend/executor/nodeModifyTable.c
@@ -277,7 +277,7 @@ ExecInsert(ModifyTableState *mtstate,
 	resultRelInfo = estate->es_result_relation_info;
 
 	/* Determine the partition to heap_insert the tuple into */
-	if (mtstate->mt_partition_dispatch_info)
+	if (mtstate->mt_ptrinfos)
 	{
 		int			leaf_part_index;
 		TupleConversionMap *map;
@@ -291,7 +291,7 @@ ExecInsert(ModifyTableState *mtstate,
 		 * respectively.
 		 */
 		leaf_part_index = ExecFindPartition(resultRelInfo,
-											mtstate->mt_partition_dispatch_info,
+											mtstate->mt_ptrinfos,
 											slot,
 											estate);
 		Assert(leaf_part_index >= 0 &&
@@ -1486,7 +1486,7 @@ ExecSetupTransitionCaptureState(ModifyTableState *mtstate, EState *estate)
 		int			numResultRelInfos;
 
 		/* Find the set of partitions so that we can find their TupleDescs. */
-		if (mtstate->mt_partition_dispatch_info != NULL)
+		if (mtstate->mt_ptrinfos != NULL)
 		{
 			/*
 			 * For INSERT via partitioned table, so we need TupleDescs based
@@ -1910,7 +1910,7 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 	if (operation == CMD_INSERT &&
 		rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
 	{
-		PartitionDispatch *partition_dispatch_info;
+		PartitionTupleRoutingInfo **ptrinfos;
 		ResultRelInfo *partitions;
 		TupleConversionMap **partition_tupconv_maps;
 		TupleTableSlot *partition_tuple_slot;
@@ -1919,13 +1919,13 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 
 		ExecSetupPartitionTupleRouting(rel,
 									   node->nominalRelation,
-									   &partition_dispatch_info,
+									   &ptrinfos,
 									   &partitions,
 									   &partition_tupconv_maps,
 									   &partition_tuple_slot,
 									   &num_parted, &num_partitions);
-		mtstate->mt_partition_dispatch_info = partition_dispatch_info;
-		mtstate->mt_num_dispatch = num_parted;
+		mtstate->mt_ptrinfos = ptrinfos;
+		mtstate->mt_num_parted = num_parted;
 		mtstate->mt_partitions = partitions;
 		mtstate->mt_num_partitions = num_partitions;
 		mtstate->mt_partition_tupconv_maps = partition_tupconv_maps;
@@ -2335,19 +2335,16 @@ ExecEndModifyTable(ModifyTableState *node)
 	}
 
 	/*
-	 * Close all the partitioned tables, leaf partitions, and their indices
+	 * Close all the leaf partitions and their indices.
 	 *
-	 * Remember node->mt_partition_dispatch_info[0] corresponds to the root
-	 * partitioned table, which we must not try to close, because it is the
-	 * main target table of the query that will be closed by ExecEndPlan().
-	 * Also, tupslot is NULL for the root partitioned table.
+	 * node->mt_partition_dispatch_info[0] corresponds to the root partitioned
+	 * table, for which we didn't create tupslot.
 	 */
-	for (i = 1; i < node->mt_num_dispatch; i++)
+	for (i = 1; i < node->mt_num_parted; i++)
 	{
-		PartitionDispatch pd = node->mt_partition_dispatch_info[i];
+		PartitionTupleRoutingInfo *ptrinfo = node->mt_ptrinfos[i];
 
-		heap_close(pd->reldesc, NoLock);
-		ExecDropSingleTupleTableSlot(pd->tupslot);
+		ExecDropSingleTupleTableSlot(ptrinfo->tupslot);
 	}
 	for (i = 0; i < node->mt_num_partitions; i++)
 	{
diff --git a/src/include/catalog/partition.h b/src/include/catalog/partition.h
index 2283c675e9..7b53baf847 100644
--- a/src/include/catalog/partition.h
+++ b/src/include/catalog/partition.h
@@ -39,36 +39,23 @@ typedef struct PartitionDescData
 
 typedef struct PartitionDescData *PartitionDesc;
 
-/*-----------------------
- * PartitionDispatch - information about one partitioned table in a partition
- * hierarchy required to route a tuple to one of its partitions
- *
- *	reldesc		Relation descriptor of the table
- *	key			Partition key information of the table
- *	keystate	Execution state required for expressions in the partition key
- *	partdesc	Partition descriptor of the table
- *	tupslot		A standalone TupleTableSlot initialized with this table's tuple
- *				descriptor
- *	tupmap		TupleConversionMap to convert from the parent's rowtype to
- *				this table's rowtype (when extracting the partition key of a
- *				tuple just before routing it through this table)
- *	indexes		Array with partdesc->nparts members (for details on what
- *				individual members represent, see how they are set in
- *				RelationGetPartitionDispatchInfo())
- *-----------------------
+typedef struct PartitionDispatchData *PartitionDispatch;
+
+/*
+ * Information about one partitioned table in a given partition tree
  */
-typedef struct PartitionDispatchData
+typedef struct PartitionedTableInfo
 {
-	Relation	reldesc;
-	PartitionKey key;
-	List	   *keystate;		/* list of ExprState */
-	PartitionDesc partdesc;
-	TupleTableSlot *tupslot;
-	TupleConversionMap *tupmap;
-	int		   *indexes;
-} PartitionDispatchData;
+	Oid				relid;
+	Oid				parentid;
 
-typedef struct PartitionDispatchData *PartitionDispatch;
+	/*
+	 * This contains information about bounds of the partitions of this
+	 * table and about where individual partitions are placed in the global
+	 * partition tree.
+	 */
+	PartitionDispatch pd;
+} PartitionedTableInfo;
 
 extern void RelationBuildPartitionDesc(Relation relation);
 extern bool partition_bounds_equal(int partnatts, int16 *parttyplen,
@@ -86,17 +73,18 @@ extern List *map_partition_varattnos(List *expr, int target_varno,
 extern List *RelationGetPartitionQual(Relation rel);
 extern Expr *get_partition_qual_relid(Oid relid);
 
+extern void RelationGetPartitionDispatchInfo(Relation rel,
+								 List **ptinfos, List **leaf_part_oids);
+
 /* For tuple routing */
-extern PartitionDispatch *RelationGetPartitionDispatchInfo(Relation rel,
-								 int *num_parted, List **leaf_part_oids);
-extern void FormPartitionKeyDatum(PartitionDispatch pd,
+extern void FormPartitionKeyDatum(PartitionKeyInfo *keyinfo,
 					  TupleTableSlot *slot,
 					  EState *estate,
 					  Datum *values,
 					  bool *isnull);
-extern int get_partition_for_tuple(PartitionDispatch *pd,
+extern int get_partition_for_tuple(PartitionTupleRoutingInfo **ptrinfos,
 						TupleTableSlot *slot,
 						EState *estate,
-						PartitionDispatchData **failed_at,
+						PartitionTupleRoutingInfo **failed_at,
 						TupleTableSlot **failed_slot);
 #endif							/* PARTITION_H */
diff --git a/src/include/executor/executor.h b/src/include/executor/executor.h
index 60326f9d03..6e1d3a6d2f 100644
--- a/src/include/executor/executor.h
+++ b/src/include/executor/executor.h
@@ -208,13 +208,13 @@ extern void EvalPlanQualSetTuple(EPQState *epqstate, Index rti,
 extern HeapTuple EvalPlanQualGetTuple(EPQState *epqstate, Index rti);
 extern void ExecSetupPartitionTupleRouting(Relation rel,
 							   Index resultRTindex,
-							   PartitionDispatch **pd,
+							   PartitionTupleRoutingInfo ***ptrinfos,
 							   ResultRelInfo **partitions,
 							   TupleConversionMap ***tup_conv_maps,
 							   TupleTableSlot **partition_tuple_slot,
 							   int *num_parted, int *num_partitions);
 extern int ExecFindPartition(ResultRelInfo *resultRelInfo,
-				  PartitionDispatch *pd,
+				  PartitionTupleRoutingInfo **ptrinfos,
 				  TupleTableSlot *slot,
 				  EState *estate);
 
diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h
index 577499465d..07e50e0914 100644
--- a/src/include/nodes/execnodes.h
+++ b/src/include/nodes/execnodes.h
@@ -414,6 +414,55 @@ typedef struct ResultRelInfo
 	Relation	ri_PartitionRoot;
 } ResultRelInfo;
 
+/* Forward declarations, to avoid including other headers */
+typedef struct PartitionKeyData *PartitionKey;
+typedef struct PartitionDispatchData *PartitionDispatch;
+
+/*
+ * PartitionKeyInfoData - execution state for the partition key of a
+ *						  partitioned table
+ *
+ * keystate is the execution state required for expressions contained in the
+ * partition key.  It is NIL until initialized by FormPartitionKeyDatum() if
+ * and when it is called; for example, during tuple routing through a given
+ * partitioned table.
+ */
+typedef struct PartitionKeyInfo
+{
+	PartitionKey	key;		/* Points into the table's relcache entry */
+	List		   *keystate;
+} PartitionKeyInfo;
+
+/*
+ * PartitionTupleRoutingInfo - information required for tuple-routing
+ *							   through one partitioned table in a partition
+ *							   tree
+ */
+typedef struct PartitionTupleRoutingInfo
+{
+	/* OID of the table */
+	Oid				relid;
+
+	/* Information about the table's partitions */
+	PartitionDispatch	pd;
+
+	/* See comment above the definition of PartitionKeyInfo */
+	PartitionKeyInfo   *keyinfo;
+
+	/*
+	 * A standalone TupleTableSlot initialized with this table's tuple
+	 * descriptor
+	 */
+	TupleTableSlot *tupslot;
+
+	/*
+	 * TupleConversionMap to convert from the parent's rowtype to this table's
+	 * rowtype (when extracting the partition key of a tuple just before
+	 * routing it through this table)
+	 */
+	TupleConversionMap *tupmap;
+} PartitionTupleRoutingInfo;
+
 /* ----------------
  *	  EState information
  *
@@ -970,9 +1019,9 @@ typedef struct ModifyTableState
 	TupleTableSlot *mt_existing;	/* slot to store existing target tuple in */
 	List	   *mt_excludedtlist;	/* the excluded pseudo relation's tlist  */
 	TupleTableSlot *mt_conflproj;	/* CONFLICT ... SET ... projection target */
-	struct PartitionDispatchData **mt_partition_dispatch_info;
 	/* Tuple-routing support info */
-	int			mt_num_dispatch;	/* Number of entries in the above array */
+	struct PartitionTupleRoutingInfo **mt_ptrinfos;
+	int			mt_num_parted;		/* Number of entries in the above array */
 	int			mt_num_partitions;	/* Number of members in the following
 									 * arrays */
 	ResultRelInfo *mt_partitions;	/* Per partition result relation */
-- 
2.11.0

From 593b8dba9e859344bb3402786014201a3fa1e363 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Wed, 9 Aug 2017 15:52:36 +0900
Subject: [PATCH 2/2] Teach expand_inherited_rtentry to use partition bound
 order

After locking the child tables using find_all_inheritors, we discard
the list of child table OIDs that it generates and rebuild the same
using the information returned by RelationGetPartitionDispatchInfo.
---
 src/backend/optimizer/prep/prepunion.c | 33 +++++++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)

diff --git a/src/backend/optimizer/prep/prepunion.c b/src/backend/optimizer/prep/prepunion.c
index f43c3f3007..dad6892c4d 100644
--- a/src/backend/optimizer/prep/prepunion.c
+++ b/src/backend/optimizer/prep/prepunion.c
@@ -33,6 +33,7 @@
 #include "access/heapam.h"
 #include "access/htup_details.h"
 #include "access/sysattr.h"
+#include "catalog/partition.h"
 #include "catalog/pg_inherits_fn.h"
 #include "catalog/pg_type.h"
 #include "miscadmin.h"
@@ -1452,6 +1453,38 @@ expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti)
 	 */
 	oldrelation = heap_open(parentOID, NoLock);
 
+	/*
+	 * For partitioned tables, we arrange the child table OIDs such that they
+	 * appear in the partition bound order.
+	 */
+	if (rte->relkind == RELKIND_PARTITIONED_TABLE)
+	{
+		List   *leaf_part_oids,
+			   *ptinfos;
+
+		/* Discard the original list. */
+		list_free(inhOIDs);
+		inhOIDs = NIL;
+
+		/* Request partitioning information. */
+		RelationGetPartitionDispatchInfo(oldrelation, &ptinfos,
+										 &leaf_part_oids);
+
+		/*
+		 * First collect the partitioned child table OIDs, which includes the
+		 * root parent at the head.
+		 */
+		foreach(l, ptinfos)
+		{
+			PartitionedTableInfo *ptinfo = lfirst(l);
+
+			inhOIDs = lappend_oid(inhOIDs, ptinfo->relid);
+		}
+
+		/* Concatenate the leaf partition OIDs. */
+		inhOIDs = list_concat(inhOIDs, leaf_part_oids);
+	}
+
 	/* Scan the inheritance set and expand it */
 	appinfos = NIL;
 	has_child = false;
-- 
2.11.0

From 0cf8ab795fd3a8db462e8c692cfaa73f19e71ed6 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Mon, 24 Jul 2017 18:59:57 +0900
Subject: [PATCH 1/2] Decouple RelationGetPartitionDispatchInfo() from executor

Currently it and the structure it generates viz. PartitionDispatch
objects are too coupled with the executor's tuple-routing code.  In
particular, it's pretty undesirable that it makes it the responsibility
of the caller to release some resources, such as relcache references
and tuple table slots.  That makes it harder to use in places other
than where it's currently being used.

After this refactoring, ExecSetupPartitionTupleRouting() now needs to
do some of the work that was previously done in
RelationGetPartitionDispatchInfo() and expand_inherited_rtentry() no
longer needs to do some things that it used to.
---
 src/backend/catalog/partition.c        | 309 +++++++++++++++++----------------
 src/backend/commands/copy.c            |  37 ++--
 src/backend/executor/execMain.c        | 145 ++++++++++++++--
 src/backend/executor/nodeModifyTable.c |  35 ++--
 src/include/catalog/partition.h        |  52 +++---
 src/include/executor/executor.h        |   4 +-
 src/include/nodes/execnodes.h          |  53 +++++-
 7 files changed, 398 insertions(+), 237 deletions(-)

diff --git a/src/backend/catalog/partition.c b/src/backend/catalog/partition.c
index 96a64ce6b2..7618e4cb31 100644
--- a/src/backend/catalog/partition.c
+++ b/src/backend/catalog/partition.c
@@ -105,6 +105,24 @@ typedef struct PartitionRangeBound
 	bool		lower;			/* this is the lower (vs upper) bound */
 } PartitionRangeBound;
 
+/*-----------------------
+ * PartitionDispatchData - information of partitions of one partitioned table
+ *						   in a partition tree
+ *
+ *	partkey		Partition key of the table
+ *	partdesc	Partition descriptor of the table
+ *	indexes		Array with partdesc->nparts members (for details on what the
+ *				individual value represents, see the comments in
+ *				RelationGetPartitionDispatchInfo())
+ *-----------------------
+ */
+typedef struct PartitionDispatchData
+{
+	PartitionKey	partkey;	/* Points into the table's relcache entry */
+	PartitionDesc	partdesc;	/* Ditto */
+	int			   *indexes;
+} PartitionDispatchData;
+
 static int32 qsort_partition_list_value_cmp(const void *a, const void *b,
 							   void *arg);
 static int32 qsort_partition_rbound_cmp(const void *a, const void *b,
@@ -981,181 +999,165 @@ get_partition_qual_relid(Oid relid)
 }
 
 /*
- * Append OIDs of rel's partitions to the list 'partoids' and for each OID,
- * append pointer rel to the list 'parents'.
- */
-#define APPEND_REL_PARTITION_OIDS(rel, partoids, parents) \
-	do\
-	{\
-		int		i;\
-		for (i = 0; i < (rel)->rd_partdesc->nparts; i++)\
-		{\
-			(partoids) = lappend_oid((partoids), (rel)->rd_partdesc->oids[i]);\
-			(parents) = lappend((parents), (rel));\
-		}\
-	} while(0)
-
-/*
  * RelationGetPartitionDispatchInfo
- *		Returns information necessary to route tuples down a partition tree
+ *		Returns necessary information for each partition in the partition
+ *		tree rooted at rel
  *
- * The number of elements in the returned array (that is, the number of
- * PartitionDispatch objects for the partitioned tables in the partition tree)
- * is returned in *num_parted and a list of the OIDs of all the leaf
- * partitions of rel is returned in *leaf_part_oids.
+ * Information returned includes the following: *ptinfos contains a list of
+ * PartitionedTableInfo objects, one for each partitioned table (with at least
+ * one member, that is, one for the root partitioned table), *leaf_part_oids
+ * contains a list of the OIDs of of all the leaf partitions.
  *
- * All the relations in the partition tree (including 'rel') must have been
- * locked (using at least the AccessShareLock) by the caller.
+ * We require that the caller has locked at least the partitioned tables in the
+ * partition tree (including 'rel') using at least the AccessShareLock,
+ * because we need to look at their relcache entries to get PartitionKey and
+ * PartitionDesc.
  */
-PartitionDispatch *
+void
 RelationGetPartitionDispatchInfo(Relation rel,
-								 int *num_parted, List **leaf_part_oids)
+								 List **ptinfos, List **leaf_part_oids)
 {
-	PartitionDispatchData **pd;
-	List	   *all_parts = NIL,
-			   *all_parents = NIL,
-			   *parted_rels,
-			   *parted_rel_parents;
+	List	   *all_parts,
+			   *all_parents;
 	ListCell   *lc1,
 			   *lc2;
 	int			i,
-				k,
 				offset;
 
 	/*
 	 * We rely on the relcache to traverse the partition tree to build both
-	 * the leaf partition OIDs list and the array of PartitionDispatch objects
-	 * for the partitioned tables in the tree.  That means every partitioned
-	 * table in the tree must be locked, which is fine since we require the
-	 * caller to lock all the partitions anyway.
+	 * the leaf partition OIDs list and the list of PartitionedTableInfo
+	 * objects for partitioned tables.  That means every partitioned table in
+	 * the tree must be locked, which is fine since the callers must have done
+	 * that already.
 	 *
 	 * For every partitioned table in the tree, starting with the root
 	 * partitioned table, add its relcache entry to parted_rels, while also
 	 * queuing its partitions (in the order in which they appear in the
 	 * partition descriptor) to be looked at later in the same loop.  This is
 	 * a bit tricky but works because the foreach() macro doesn't fetch the
-	 * next list element until the bottom of the loop.
+	 * next list element until the bottom of the loop.  Non-partitioned tables
+	 * are simply added to the leaf partitions list.
 	 */
-	*num_parted = 1;
-	parted_rels = list_make1(rel);
-	/* Root partitioned table has no parent, so NULL for parent */
-	parted_rel_parents = list_make1(NULL);
-	APPEND_REL_PARTITION_OIDS(rel, all_parts, all_parents);
+	i = offset = 0;
+	*ptinfos = *leaf_part_oids = NIL;
+
+	/* Start with the root table. */
+	all_parts = list_make1_oid(RelationGetRelid(rel));
+	all_parents = list_make1_oid(InvalidOid);
 	forboth(lc1, all_parts, lc2, all_parents)
 	{
-		Oid			partrelid = lfirst_oid(lc1);
-		Relation	parent = lfirst(lc2);
+		Oid		partrelid = lfirst_oid(lc1);
+		Oid		parentrelid = lfirst_oid(lc2);
 
 		if (get_rel_relkind(partrelid) == RELKIND_PARTITIONED_TABLE)
 		{
-			/*
-			 * Already locked by the caller.  Note that it is the
-			 * responsibility of the caller to close the below relcache entry,
-			 * once done using the information being collected here (for
-			 * example, in ExecEndModifyTable).
-			 */
-			Relation	partrel = heap_open(partrelid, NoLock);
+			int		j,
+					k;
+			Relation		partrel;
+			PartitionKey	partkey;
+			PartitionDesc	partdesc;
+			PartitionedTableInfo   *ptinfo;
+			PartitionDispatch		pd;
+
+			if (partrelid != RelationGetRelid(rel))
+				partrel = heap_open(partrelid, NoLock);
+			else
+				partrel = rel;
 
-			(*num_parted)++;
-			parted_rels = lappend(parted_rels, partrel);
-			parted_rel_parents = lappend(parted_rel_parents, parent);
-			APPEND_REL_PARTITION_OIDS(partrel, all_parts, all_parents);
-		}
-	}
+			partkey = RelationGetPartitionKey(partrel);
+			partdesc = RelationGetPartitionDesc(partrel);
+
+			ptinfo = (PartitionedTableInfo *)
+									palloc0(sizeof(PartitionedTableInfo));
+			ptinfo->relid = partrelid;
+			ptinfo->parentid = parentrelid;
+
+			ptinfo->pd = pd = (PartitionDispatchData *)
+									palloc0(sizeof(PartitionDispatchData));
+			pd->partkey = partkey;
 
-	/*
-	 * We want to create two arrays - one for leaf partitions and another for
-	 * partitioned tables (including the root table and internal partitions).
-	 * While we only create the latter here, leaf partition array of suitable
-	 * objects (such as, ResultRelInfo) is created by the caller using the
-	 * list of OIDs we return.  Indexes into these arrays get assigned in a
-	 * breadth-first manner, whereby partitions of any given level are placed
-	 * consecutively in the respective arrays.
-	 */
-	pd = (PartitionDispatchData **) palloc(*num_parted *
-										   sizeof(PartitionDispatchData *));
-	*leaf_part_oids = NIL;
-	i = k = offset = 0;
-	forboth(lc1, parted_rels, lc2, parted_rel_parents)
-	{
-		Relation	partrel = lfirst(lc1);
-		Relation	parent = lfirst(lc2);
-		PartitionKey partkey = RelationGetPartitionKey(partrel);
-		TupleDesc	tupdesc = RelationGetDescr(partrel);
-		PartitionDesc partdesc = RelationGetPartitionDesc(partrel);
-		int			j,
-					m;
-
-		pd[i] = (PartitionDispatch) palloc(sizeof(PartitionDispatchData));
-		pd[i]->reldesc = partrel;
-		pd[i]->key = partkey;
-		pd[i]->keystate = NIL;
-		pd[i]->partdesc = partdesc;
-		if (parent != NULL)
-		{
 			/*
-			 * For every partitioned table other than root, we must store a
-			 * tuple table slot initialized with its tuple descriptor and a
-			 * tuple conversion map to convert a tuple from its parent's
-			 * rowtype to its own. That is to make sure that we are looking at
-			 * the correct row using the correct tuple descriptor when
-			 * computing its partition key for tuple routing.
+			 * XXX- do we need a pinning mechanism for partition descriptors
+			 * so that there references can be managed independently of
+			 * the parent relcache entry? Like PinPartitionDesc(partdesc)?
 			 */
-			pd[i]->tupslot = MakeSingleTupleTableSlot(tupdesc);
-			pd[i]->tupmap = convert_tuples_by_name(RelationGetDescr(parent),
-												   tupdesc,
-												   gettext_noop("could not convert row type"));
-		}
-		else
-		{
-			/* Not required for the root partitioned table */
-			pd[i]->tupslot = NULL;
-			pd[i]->tupmap = NULL;
-		}
-		pd[i]->indexes = (int *) palloc(partdesc->nparts * sizeof(int));
+			pd->partdesc = partdesc;
 
-		/*
-		 * Indexes corresponding to the internal partitions are multiplied by
-		 * -1 to distinguish them from those of leaf partitions.  Encountering
-		 * an index >= 0 means we found a leaf partition, which is immediately
-		 * returned as the partition we are looking for.  A negative index
-		 * means we found a partitioned table, whose PartitionDispatch object
-		 * is located at the above index multiplied back by -1.  Using the
-		 * PartitionDispatch object, search is continued further down the
-		 * partition tree.
-		 */
-		m = 0;
-		for (j = 0; j < partdesc->nparts; j++)
-		{
-			Oid			partrelid = partdesc->oids[j];
+			/*
+			 * The values contained in the following array correspond to
+			 * indexes of this table's partitions in the global sequence of
+			 * all the partitions contained in the partition tree rooted at
+			 * rel, traversed in a breadh-first manner.  The values should be
+			 * such that we will be able to distinguish the leaf partitions
+			 * from the non-leaf partitions, because they are returned to
+			 * to the caller in separate structures from where they will be
+			 * accessed.  The way that's done is described below:
+			 *
+			 * Leaf partition OIDs are put into the global leaf_part_oids list,
+			 * and for each one, the value stored is its ordinal position in
+			 * the list minus 1.
+			 *
+			 * PartitionedTableInfo objects corresponding to partitions that
+			 * are partitioned tables are put into the global ptinfos[] list,
+			 * and for each one, the value stored is its ordinal position in
+			 * the list multiplied by -1.
+			 *
+			 * So while looking at the values in the indexes array, if one
+			 * gets zero or a positive value, then it's a leaf partition,
+			 * Otherwise, it's a partitioned table.
+			 */
+			pd->indexes = (int *) palloc(partdesc->nparts * sizeof(int));
 
-			if (get_rel_relkind(partrelid) != RELKIND_PARTITIONED_TABLE)
-			{
-				*leaf_part_oids = lappend_oid(*leaf_part_oids, partrelid);
-				pd[i]->indexes[j] = k++;
-			}
-			else
+			k = 0;
+			for (j = 0; j < partdesc->nparts; j++)
 			{
+				Oid			partrelid = partdesc->oids[j];
+
 				/*
-				 * offset denotes the number of partitioned tables of upper
-				 * levels including those of the current level.  Any partition
-				 * of this table must belong to the next level and hence will
-				 * be placed after the last partitioned table of this level.
+				 * Queue this partition so that it will be processed later
+				 * by the outer loop.
 				 */
-				pd[i]->indexes[j] = -(1 + offset + m);
-				m++;
+				all_parts = lappend_oid(all_parts, partrelid);
+				all_parents = lappend_oid(all_parents,
+										  RelationGetRelid(partrel));
+
+				if (get_rel_relkind(partrelid) != RELKIND_PARTITIONED_TABLE)
+				{
+					*leaf_part_oids = lappend_oid(*leaf_part_oids, partrelid);
+					pd->indexes[j] = i++;
+				}
+				else
+				{
+					/*
+					 * offset denotes the number of partitioned tables that
+					 * we have already processed.  k counts the number of
+					 * partitions of this table that were found to be
+					 * partitioned tables.
+					 */
+					pd->indexes[j] = -(1 + offset + k);
+					k++;
+				}
 			}
-		}
-		i++;
 
-		/*
-		 * This counts the number of partitioned tables at upper levels
-		 * including those of the current level.
-		 */
-		offset += m;
+			offset += k;
+
+			/*
+			 * Release the relation descriptor.  Lock that we have on the
+			 * table will keep the PartitionDesc that is pointing into
+			 * RelationData intact, a pointer to which hope to keep
+			 * through this transaction's commit.
+			 * (XXX - how true is that?)
+			 */
+			if (partrel != rel)
+				heap_close(partrel, NoLock);
+
+			*ptinfos = lappend(*ptinfos, ptinfo);
+		}
 	}
 
-	return pd;
+	Assert(i == list_length(*leaf_part_oids));
+	Assert((offset + 1) == list_length(*ptinfos));
 }
 
 /* Module-local functions */
@@ -1872,7 +1874,7 @@ generate_partition_qual(Relation rel)
  * ----------------
  */
 void
-FormPartitionKeyDatum(PartitionDispatch pd,
+FormPartitionKeyDatum(PartitionKeyInfo *keyinfo,
 					  TupleTableSlot *slot,
 					  EState *estate,
 					  Datum *values,
@@ -1881,20 +1883,21 @@ FormPartitionKeyDatum(PartitionDispatch pd,
 	ListCell   *partexpr_item;
 	int			i;
 
-	if (pd->key->partexprs != NIL && pd->keystate == NIL)
+	if (keyinfo->key->partexprs != NIL && keyinfo->keystate == NIL)
 	{
 		/* Check caller has set up context correctly */
 		Assert(estate != NULL &&
 			   GetPerTupleExprContext(estate)->ecxt_scantuple == slot);
 
 		/* First time through, set up expression evaluation state */
-		pd->keystate = ExecPrepareExprList(pd->key->partexprs, estate);
+		keyinfo->keystate = ExecPrepareExprList(keyinfo->key->partexprs,
+												estate);
 	}
 
-	partexpr_item = list_head(pd->keystate);
-	for (i = 0; i < pd->key->partnatts; i++)
+	partexpr_item = list_head(keyinfo->keystate);
+	for (i = 0; i < keyinfo->key->partnatts; i++)
 	{
-		AttrNumber	keycol = pd->key->partattrs[i];
+		AttrNumber	keycol = keyinfo->key->partattrs[i];
 		Datum		datum;
 		bool		isNull;
 
@@ -1931,13 +1934,13 @@ FormPartitionKeyDatum(PartitionDispatch pd,
  * the latter case.
  */
 int
-get_partition_for_tuple(PartitionDispatch *pd,
+get_partition_for_tuple(PartitionTupleRoutingInfo **ptrinfos,
 						TupleTableSlot *slot,
 						EState *estate,
-						PartitionDispatchData **failed_at,
+						PartitionTupleRoutingInfo **failed_at,
 						TupleTableSlot **failed_slot)
 {
-	PartitionDispatch parent;
+	PartitionTupleRoutingInfo *parent;
 	Datum		values[PARTITION_MAX_KEYS];
 	bool		isnull[PARTITION_MAX_KEYS];
 	int			cur_offset,
@@ -1948,11 +1951,11 @@ get_partition_for_tuple(PartitionDispatch *pd,
 	TupleTableSlot *ecxt_scantuple_old = ecxt->ecxt_scantuple;
 
 	/* start with the root partitioned table */
-	parent = pd[0];
+	parent = ptrinfos[0];
 	while (true)
 	{
-		PartitionKey key = parent->key;
-		PartitionDesc partdesc = parent->partdesc;
+		PartitionKey  key = parent->pd->partkey;
+		PartitionDesc partdesc = parent->pd->partdesc;
 		TupleTableSlot *myslot = parent->tupslot;
 		TupleConversionMap *map = parent->tupmap;
 
@@ -1984,7 +1987,7 @@ get_partition_for_tuple(PartitionDispatch *pd,
 		 * So update ecxt_scantuple accordingly.
 		 */
 		ecxt->ecxt_scantuple = slot;
-		FormPartitionKeyDatum(parent, slot, estate, values, isnull);
+		FormPartitionKeyDatum(parent->keyinfo, slot, estate, values, isnull);
 
 		if (key->strategy == PARTITION_STRATEGY_RANGE)
 		{
@@ -2055,13 +2058,13 @@ get_partition_for_tuple(PartitionDispatch *pd,
 			*failed_slot = slot;
 			break;
 		}
-		else if (parent->indexes[cur_index] >= 0)
+		else if (parent->pd->indexes[cur_index] >= 0)
 		{
-			result = parent->indexes[cur_index];
+			result = parent->pd->indexes[cur_index];
 			break;
 		}
 		else
-			parent = pd[-parent->indexes[cur_index]];
+			parent = ptrinfos[-parent->pd->indexes[cur_index]];
 	}
 
 error_exit:
diff --git a/src/backend/commands/copy.c b/src/backend/commands/copy.c
index cfa3f059c2..b0c596345b 100644
--- a/src/backend/commands/copy.c
+++ b/src/backend/commands/copy.c
@@ -165,8 +165,8 @@ typedef struct CopyStateData
 	bool		volatile_defexprs;	/* is any of defexprs volatile? */
 	List	   *range_table;
 
-	PartitionDispatch *partition_dispatch_info;
-	int			num_dispatch;	/* Number of entries in the above array */
+	PartitionTupleRoutingInfo **ptrinfos;
+	int			num_parted;		/* Number of entries in the above array */
 	int			num_partitions; /* Number of members in the following arrays */
 	ResultRelInfo *partitions;	/* Per partition result relation */
 	TupleConversionMap **partition_tupconv_maps;
@@ -2445,7 +2445,7 @@ CopyFrom(CopyState cstate)
 	 */
 	if (cstate->rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
 	{
-		PartitionDispatch *partition_dispatch_info;
+		PartitionTupleRoutingInfo **ptrinfos;
 		ResultRelInfo *partitions;
 		TupleConversionMap **partition_tupconv_maps;
 		TupleTableSlot *partition_tuple_slot;
@@ -2455,13 +2455,13 @@ CopyFrom(CopyState cstate)
 		ExecSetupPartitionTupleRouting(cstate->rel,
 									   1,
 									   estate,
-									   &partition_dispatch_info,
+									   &ptrinfos,
 									   &partitions,
 									   &partition_tupconv_maps,
 									   &partition_tuple_slot,
 									   &num_parted, &num_partitions);
-		cstate->partition_dispatch_info = partition_dispatch_info;
-		cstate->num_dispatch = num_parted;
+		cstate->ptrinfos = ptrinfos;
+		cstate->num_parted = num_parted;
 		cstate->partitions = partitions;
 		cstate->num_partitions = num_partitions;
 		cstate->partition_tupconv_maps = partition_tupconv_maps;
@@ -2502,7 +2502,7 @@ CopyFrom(CopyState cstate)
 	if ((resultRelInfo->ri_TrigDesc != NULL &&
 		 (resultRelInfo->ri_TrigDesc->trig_insert_before_row ||
 		  resultRelInfo->ri_TrigDesc->trig_insert_instead_row)) ||
-		cstate->partition_dispatch_info != NULL ||
+		cstate->ptrinfos != NULL ||
 		cstate->volatile_defexprs)
 	{
 		useHeapMultiInsert = false;
@@ -2580,7 +2580,7 @@ CopyFrom(CopyState cstate)
 		ExecStoreTuple(tuple, slot, InvalidBuffer, false);
 
 		/* Determine the partition to heap_insert the tuple into */
-		if (cstate->partition_dispatch_info)
+		if (cstate->ptrinfos)
 		{
 			int			leaf_part_index;
 			TupleConversionMap *map;
@@ -2594,7 +2594,7 @@ CopyFrom(CopyState cstate)
 			 * partition, respectively.
 			 */
 			leaf_part_index = ExecFindPartition(resultRelInfo,
-												cstate->partition_dispatch_info,
+												cstate->ptrinfos,
 												slot,
 												estate);
 			Assert(leaf_part_index >= 0 &&
@@ -2826,24 +2826,23 @@ CopyFrom(CopyState cstate)
 
 	ExecCloseIndices(resultRelInfo);
 
-	/* Close all the partitioned tables, leaf partitions, and their indices */
-	if (cstate->partition_dispatch_info)
+	/* Release some resources that we acquired for tuple-routing. */
+	if (cstate->ptrinfos)
 	{
 		int			i;
 
 		/*
-		 * Remember cstate->partition_dispatch_info[0] corresponds to the root
-		 * partitioned table, which we must not try to close, because it is
-		 * the main target table of COPY that will be closed eventually by
-		 * DoCopy().  Also, tupslot is NULL for the root partitioned table.
+		 * cstate->ptrinfos[0] corresponds to the root partitioned table, for
+		 * which we didn't create tupslot.
 		 */
-		for (i = 1; i < cstate->num_dispatch; i++)
+		for (i = 1; i < cstate->num_parted; i++)
 		{
-			PartitionDispatch pd = cstate->partition_dispatch_info[i];
+			PartitionTupleRoutingInfo *ptrinfo = cstate->ptrinfos[i];
 
-			heap_close(pd->reldesc, NoLock);
-			ExecDropSingleTupleTableSlot(pd->tupslot);
+			ExecDropSingleTupleTableSlot(ptrinfo->tupslot);
 		}
+
+		/* Close all the leaf partitions and their indices */
 		for (i = 0; i < cstate->num_partitions; i++)
 		{
 			ResultRelInfo *resultRelInfo = cstate->partitions + i;
diff --git a/src/backend/executor/execMain.c b/src/backend/executor/execMain.c
index 2946a0edee..a03188aba3 100644
--- a/src/backend/executor/execMain.c
+++ b/src/backend/executor/execMain.c
@@ -3236,8 +3236,8 @@ EvalPlanQualEnd(EPQState *epqstate)
  * tuple routing for partitioned tables
  *
  * Output arguments:
- * 'pd' receives an array of PartitionDispatch objects with one entry for
- *		every partitioned table in the partition tree
+ * 'ptrinfos' receives an array of PartitionTupleRoutingInfo objects with one
+ *		entry for each partitioned table in the partition tree
  * 'partitions' receives an array of ResultRelInfo objects with one entry for
  *		every leaf partition in the partition tree
  * 'tup_conv_maps' receives an array of TupleConversionMap objects with one
@@ -3260,7 +3260,7 @@ void
 ExecSetupPartitionTupleRouting(Relation rel,
 							   Index resultRTindex,
 							   EState *estate,
-							   PartitionDispatch **pd,
+							   PartitionTupleRoutingInfo ***ptrinfos,
 							   ResultRelInfo **partitions,
 							   TupleConversionMap ***tup_conv_maps,
 							   TupleTableSlot **partition_tuple_slot,
@@ -3268,16 +3268,135 @@ ExecSetupPartitionTupleRouting(Relation rel,
 {
 	TupleDesc	tupDesc = RelationGetDescr(rel);
 	List	   *leaf_parts;
+	List	   *ptinfos = NIL;
 	ListCell   *cell;
 	int			i;
 	ResultRelInfo *leaf_part_rri;
+	Relation	parent;
 
 	/*
 	 * Get the information about the partition tree after locking all the
 	 * partitions.
 	 */
 	(void) find_all_inheritors(RelationGetRelid(rel), RowExclusiveLock, NULL);
-	*pd = RelationGetPartitionDispatchInfo(rel, num_parted, &leaf_parts);
+	RelationGetPartitionDispatchInfo(rel, &ptinfos, &leaf_parts);
+
+	/*
+	 * The ptinfos list contains PartitionedTableInfo objects for all the
+	 * partitioned tables in the partition tree.  Using the information
+	 * therein, we construct an array of PartitionTupleRoutingInfo objects
+	 * to be used during tuple-routing.
+	 */
+	*num_parted = list_length(ptinfos);
+	*ptrinfos = (PartitionTupleRoutingInfo **) palloc0(*num_parted *
+										sizeof(PartitionTupleRoutingInfo *));
+	/*
+	 * Free the ptinfos List structure itself as we go through (open-coded
+	 * list_free).
+	 */
+	i = 0;
+	cell = list_head(ptinfos);
+	parent = NULL;
+	while (cell)
+	{
+		ListCell   *tmp = cell;
+		PartitionedTableInfo *ptinfo = lfirst(tmp),
+							 *next_ptinfo = NULL;
+		Relation		partrel;
+		PartitionTupleRoutingInfo *ptrinfo;
+
+		if (lnext(tmp))
+			next_ptinfo = lfirst(lnext(tmp));
+
+		/* As mentioned above, the partitioned tables have been locked. */
+		if (ptinfo->relid != RelationGetRelid(rel))
+			partrel = heap_open(ptinfo->relid, NoLock);
+		else
+			partrel = rel;
+
+		ptrinfo = (PartitionTupleRoutingInfo *)
+							palloc0(sizeof(PartitionTupleRoutingInfo));
+		ptrinfo->relid = ptinfo->relid;
+
+		/* Stash a reference to this PartitionDispatch. */
+		ptrinfo->pd = ptinfo->pd;
+
+		/* State for extracting partition key from tuples will go here. */
+		ptrinfo->keyinfo = (PartitionKeyInfo *)
+								palloc0(sizeof(PartitionKeyInfo));
+		ptrinfo->keyinfo->key = RelationGetPartitionKey(partrel);
+		ptrinfo->keyinfo->keystate = NIL;
+
+		/*
+		 * For every partitioned table other than root, we must store a tuple
+		 * table slot initialized with its tuple descriptor and a tuple
+		 * conversion map to convert a tuple from its parent's rowtype to its
+		 * own.  That is to make sure that we are looking at the correct row
+		 * using the correct tuple descriptor when computing its partition key
+		 * for tuple routing.
+		 */
+		if (ptinfo->parentid != InvalidOid)
+		{
+			TupleDesc	tupdesc = RelationGetDescr(partrel);
+
+			/* Open the parent relation descriptor if not already done. */
+			if (ptinfo->parentid == RelationGetRelid(rel))
+			{
+				parent = rel;
+			}
+			else if (parent == NULL)
+			{
+				/* Locked by RelationGetPartitionDispatchInfo(). */
+				parent = heap_open(ptinfo->parentid, NoLock);
+			}
+
+			ptrinfo->tupslot = MakeSingleTupleTableSlot(tupdesc);
+			ptrinfo->tupmap = convert_tuples_by_name(RelationGetDescr(parent),
+													 tupdesc,
+								  gettext_noop("could not convert row type"));
+
+			/*
+			 * Close the parent descriptor, if the next partitioned table in
+			 * the list is not a sibling, because it will have a different
+			 * parent if so.
+			 */
+			if (parent != NULL && parent != rel &&
+				next_ptinfo != NULL &&
+				next_ptinfo->parentid != ptinfo->parentid)
+			{
+				heap_close(parent, NoLock);
+				parent = NULL;
+			}
+
+			/*
+			 * Release the relation descriptor.  Lock that we have on the
+			 * table will keep the PartitionDesc that is pointing into
+			 * RelationData intact, a pointer to which hope to keep
+			 * through this transaction's commit.
+			 * (XXX - how true is that?)
+			 */
+			if (partrel != rel)
+				heap_close(partrel, NoLock);
+		}
+		else
+		{
+			/* Not required for the root partitioned table */
+			ptrinfo->tupslot = NULL;
+			ptrinfo->tupmap = NULL;
+		}
+
+		(*ptrinfos)[i++] = ptrinfo;
+
+		/* Free the ListCell. */
+		cell = lnext(cell);
+		pfree(tmp);
+	}
+
+	/* Free the List itself. */
+	if (ptinfos)
+		pfree(ptinfos);
+
+	/* For leaf partitions, we build ResultRelInfos and TupleConversionMaps. */
 	*num_partitions = list_length(leaf_parts);
 	*partitions = (ResultRelInfo *) palloc(*num_partitions *
 										   sizeof(ResultRelInfo));
@@ -3304,7 +3423,7 @@ ExecSetupPartitionTupleRouting(Relation rel,
 		 * Note that each of the relations in *partitions are eventually
 		 * closed by the caller.
 		 */
-		partrel = heap_open(lfirst_oid(cell), NoLock);
+		partrel = heap_open(lfirst_oid(cell), RowExclusiveLock);
 		part_tupdesc = RelationGetDescr(partrel);
 
 		/*
@@ -3317,7 +3436,7 @@ ExecSetupPartitionTupleRouting(Relation rel,
 		 * partition from the parent's type to the partition's.
 		 */
 		(*tup_conv_maps)[i] = convert_tuples_by_name(tupDesc, part_tupdesc,
-													 gettext_noop("could not convert row type"));
+								 gettext_noop("could not convert row type"));
 
 		InitResultRelInfo(leaf_part_rri,
 						  partrel,
@@ -3354,11 +3473,13 @@ ExecSetupPartitionTupleRouting(Relation rel,
  * by get_partition_for_tuple() unchanged.
  */
 int
-ExecFindPartition(ResultRelInfo *resultRelInfo, PartitionDispatch *pd,
-				  TupleTableSlot *slot, EState *estate)
+ExecFindPartition(ResultRelInfo *resultRelInfo,
+				  PartitionTupleRoutingInfo **ptrinfos,
+				  TupleTableSlot *slot,
+				  EState *estate)
 {
 	int			result;
-	PartitionDispatchData *failed_at;
+	PartitionTupleRoutingInfo *failed_at;
 	TupleTableSlot *failed_slot;
 
 	/*
@@ -3368,7 +3489,7 @@ ExecFindPartition(ResultRelInfo *resultRelInfo, PartitionDispatch *pd,
 	if (resultRelInfo->ri_PartitionCheck)
 		ExecPartitionCheck(resultRelInfo, slot, estate);
 
-	result = get_partition_for_tuple(pd, slot, estate,
+	result = get_partition_for_tuple(ptrinfos, slot, estate,
 									 &failed_at, &failed_slot);
 	if (result < 0)
 	{
@@ -3378,9 +3499,9 @@ ExecFindPartition(ResultRelInfo *resultRelInfo, PartitionDispatch *pd,
 		char	   *val_desc;
 		ExprContext *ecxt = GetPerTupleExprContext(estate);
 
-		failed_rel = failed_at->reldesc;
+		failed_rel = heap_open(failed_at->relid, NoLock);
 		ecxt->ecxt_scantuple = failed_slot;
-		FormPartitionKeyDatum(failed_at, failed_slot, estate,
+		FormPartitionKeyDatum(failed_at->keyinfo, failed_slot, estate,
 							  key_values, key_isnull);
 		val_desc = ExecBuildSlotPartitionKeyDescription(failed_rel,
 														key_values,
diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c
index e12721a9b6..c5deed4685 100644
--- a/src/backend/executor/nodeModifyTable.c
+++ b/src/backend/executor/nodeModifyTable.c
@@ -278,7 +278,7 @@ ExecInsert(ModifyTableState *mtstate,
 	resultRelInfo = estate->es_result_relation_info;
 
 	/* Determine the partition to heap_insert the tuple into */
-	if (mtstate->mt_partition_dispatch_info)
+	if (mtstate->mt_ptrinfos)
 	{
 		int			leaf_part_index;
 		TupleConversionMap *map;
@@ -292,7 +292,7 @@ ExecInsert(ModifyTableState *mtstate,
 		 * respectively.
 		 */
 		leaf_part_index = ExecFindPartition(resultRelInfo,
-											mtstate->mt_partition_dispatch_info,
+											mtstate->mt_ptrinfos,
 											slot,
 											estate);
 		Assert(leaf_part_index >= 0 &&
@@ -1487,7 +1487,7 @@ ExecSetupTransitionCaptureState(ModifyTableState *mtstate, EState *estate)
 		int			numResultRelInfos;
 
 		/* Find the set of partitions so that we can find their TupleDescs. */
-		if (mtstate->mt_partition_dispatch_info != NULL)
+		if (mtstate->mt_ptrinfos != NULL)
 		{
 			/*
 			 * For INSERT via partitioned table, so we need TupleDescs based
@@ -1911,7 +1911,7 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 	if (operation == CMD_INSERT &&
 		rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
 	{
-		PartitionDispatch *partition_dispatch_info;
+		PartitionTupleRoutingInfo **ptrinfos;
 		ResultRelInfo *partitions;
 		TupleConversionMap **partition_tupconv_maps;
 		TupleTableSlot *partition_tuple_slot;
@@ -1921,13 +1921,13 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 		ExecSetupPartitionTupleRouting(rel,
 									   node->nominalRelation,
 									   estate,
-									   &partition_dispatch_info,
+									   &ptrinfos,
 									   &partitions,
 									   &partition_tupconv_maps,
 									   &partition_tuple_slot,
 									   &num_parted, &num_partitions);
-		mtstate->mt_partition_dispatch_info = partition_dispatch_info;
-		mtstate->mt_num_dispatch = num_parted;
+		mtstate->mt_ptrinfos = ptrinfos;
+		mtstate->mt_num_parted = num_parted;
 		mtstate->mt_partitions = partitions;
 		mtstate->mt_num_partitions = num_partitions;
 		mtstate->mt_partition_tupconv_maps = partition_tupconv_maps;
@@ -2336,21 +2336,22 @@ ExecEndModifyTable(ModifyTableState *node)
 														   resultRelInfo);
 	}
 
+	/* Release some resources that we acquired for tuple-routing. */
+
 	/*
-	 * Close all the partitioned tables, leaf partitions, and their indices
-	 *
-	 * Remember node->mt_partition_dispatch_info[0] corresponds to the root
-	 * partitioned table, which we must not try to close, because it is the
-	 * main target table of the query that will be closed by ExecEndPlan().
-	 * Also, tupslot is NULL for the root partitioned table.
+	 * node->mt_ptrinfos[0] corresponds to the root partitioned table, for
+	 * which we didn't create tupslot.
 	 */
-	for (i = 1; i < node->mt_num_dispatch; i++)
+	for (i = 1; i < node->mt_num_parted; i++)
 	{
-		PartitionDispatch pd = node->mt_partition_dispatch_info[i];
+		PartitionTupleRoutingInfo *ptrinfo = node->mt_ptrinfos[i];
 
-		heap_close(pd->reldesc, NoLock);
-		ExecDropSingleTupleTableSlot(pd->tupslot);
+		ExecDropSingleTupleTableSlot(ptrinfo->tupslot);
 	}
+
+	/*
+	 * Close all the leaf partitions and their indices.
+	 */
 	for (i = 0; i < node->mt_num_partitions; i++)
 	{
 		ResultRelInfo *resultRelInfo = node->mt_partitions + i;
diff --git a/src/include/catalog/partition.h b/src/include/catalog/partition.h
index 2283c675e9..7b53baf847 100644
--- a/src/include/catalog/partition.h
+++ b/src/include/catalog/partition.h
@@ -39,36 +39,23 @@ typedef struct PartitionDescData
 
 typedef struct PartitionDescData *PartitionDesc;
 
-/*-----------------------
- * PartitionDispatch - information about one partitioned table in a partition
- * hierarchy required to route a tuple to one of its partitions
- *
- *	reldesc		Relation descriptor of the table
- *	key			Partition key information of the table
- *	keystate	Execution state required for expressions in the partition key
- *	partdesc	Partition descriptor of the table
- *	tupslot		A standalone TupleTableSlot initialized with this table's tuple
- *				descriptor
- *	tupmap		TupleConversionMap to convert from the parent's rowtype to
- *				this table's rowtype (when extracting the partition key of a
- *				tuple just before routing it through this table)
- *	indexes		Array with partdesc->nparts members (for details on what
- *				individual members represent, see how they are set in
- *				RelationGetPartitionDispatchInfo())
- *-----------------------
+typedef struct PartitionDispatchData *PartitionDispatch;
+
+/*
+ * Information about one partitioned table in a given partition tree
  */
-typedef struct PartitionDispatchData
+typedef struct PartitionedTableInfo
 {
-	Relation	reldesc;
-	PartitionKey key;
-	List	   *keystate;		/* list of ExprState */
-	PartitionDesc partdesc;
-	TupleTableSlot *tupslot;
-	TupleConversionMap *tupmap;
-	int		   *indexes;
-} PartitionDispatchData;
+	Oid				relid;
+	Oid				parentid;
 
-typedef struct PartitionDispatchData *PartitionDispatch;
+	/*
+	 * This contains information about bounds of the partitions of this
+	 * table and about where individual partitions are placed in the global
+	 * partition tree.
+	 */
+	PartitionDispatch pd;
+} PartitionedTableInfo;
 
 extern void RelationBuildPartitionDesc(Relation relation);
 extern bool partition_bounds_equal(int partnatts, int16 *parttyplen,
@@ -86,17 +73,18 @@ extern List *map_partition_varattnos(List *expr, int target_varno,
 extern List *RelationGetPartitionQual(Relation rel);
 extern Expr *get_partition_qual_relid(Oid relid);
 
+extern void RelationGetPartitionDispatchInfo(Relation rel,
+								 List **ptinfos, List **leaf_part_oids);
+
 /* For tuple routing */
-extern PartitionDispatch *RelationGetPartitionDispatchInfo(Relation rel,
-								 int *num_parted, List **leaf_part_oids);
-extern void FormPartitionKeyDatum(PartitionDispatch pd,
+extern void FormPartitionKeyDatum(PartitionKeyInfo *keyinfo,
 					  TupleTableSlot *slot,
 					  EState *estate,
 					  Datum *values,
 					  bool *isnull);
-extern int get_partition_for_tuple(PartitionDispatch *pd,
+extern int get_partition_for_tuple(PartitionTupleRoutingInfo **ptrinfos,
 						TupleTableSlot *slot,
 						EState *estate,
-						PartitionDispatchData **failed_at,
+						PartitionTupleRoutingInfo **failed_at,
 						TupleTableSlot **failed_slot);
 #endif							/* PARTITION_H */
diff --git a/src/include/executor/executor.h b/src/include/executor/executor.h
index eacbea3c36..44b7cd0fd6 100644
--- a/src/include/executor/executor.h
+++ b/src/include/executor/executor.h
@@ -209,13 +209,13 @@ extern HeapTuple EvalPlanQualGetTuple(EPQState *epqstate, Index rti);
 extern void ExecSetupPartitionTupleRouting(Relation rel,
 							   Index resultRTindex,
 							   EState *estate,
-							   PartitionDispatch **pd,
+							   PartitionTupleRoutingInfo ***ptrinfos,
 							   ResultRelInfo **partitions,
 							   TupleConversionMap ***tup_conv_maps,
 							   TupleTableSlot **partition_tuple_slot,
 							   int *num_parted, int *num_partitions);
 extern int ExecFindPartition(ResultRelInfo *resultRelInfo,
-				  PartitionDispatch *pd,
+				  PartitionTupleRoutingInfo **ptrinfos,
 				  TupleTableSlot *slot,
 				  EState *estate);
 
diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h
index 3272c4b315..2dcbb139fc 100644
--- a/src/include/nodes/execnodes.h
+++ b/src/include/nodes/execnodes.h
@@ -414,6 +414,55 @@ typedef struct ResultRelInfo
 	Relation	ri_PartitionRoot;
 } ResultRelInfo;
 
+/* Forward declarations, to avoid including other headers */
+typedef struct PartitionKeyData *PartitionKey;
+typedef struct PartitionDispatchData *PartitionDispatch;
+
+/*
+ * PartitionKeyInfoData - execution state for the partition key of a
+ *						  partitioned table
+ *
+ * keystate is the execution state required for expressions contained in the
+ * partition key.  It is NIL until initialized by FormPartitionKeyDatum() if
+ * and when it is called; for example, during tuple routing through a given
+ * partitioned table.
+ */
+typedef struct PartitionKeyInfo
+{
+	PartitionKey	key;		/* Points into the table's relcache entry */
+	List		   *keystate;
+} PartitionKeyInfo;
+
+/*
+ * PartitionTupleRoutingInfo - information required for tuple-routing
+ *							   through one partitioned table in a partition
+ *							   tree
+ */
+typedef struct PartitionTupleRoutingInfo
+{
+	/* OID of the table */
+	Oid				relid;
+
+	/* Information about the table's partitions */
+	PartitionDispatch	pd;
+
+	/* See comment above the definition of PartitionKeyInfo */
+	PartitionKeyInfo   *keyinfo;
+
+	/*
+	 * A standalone TupleTableSlot initialized with this table's tuple
+	 * descriptor
+	 */
+	TupleTableSlot *tupslot;
+
+	/*
+	 * TupleConversionMap to convert from the parent's rowtype to this table's
+	 * rowtype (when extracting the partition key of a tuple just before
+	 * routing it through this table)
+	 */
+	TupleConversionMap *tupmap;
+} PartitionTupleRoutingInfo;
+
 /* ----------------
  *	  EState information
  *
@@ -973,9 +1022,9 @@ typedef struct ModifyTableState
 	TupleTableSlot *mt_existing;	/* slot to store existing target tuple in */
 	List	   *mt_excludedtlist;	/* the excluded pseudo relation's tlist  */
 	TupleTableSlot *mt_conflproj;	/* CONFLICT ... SET ... projection target */
-	struct PartitionDispatchData **mt_partition_dispatch_info;
 	/* Tuple-routing support info */
-	int			mt_num_dispatch;	/* Number of entries in the above array */
+	struct PartitionTupleRoutingInfo **mt_ptrinfos;
+	int			mt_num_parted;		/* Number of entries in the above array */
 	int			mt_num_partitions;	/* Number of members in the following
 									 * arrays */
 	ResultRelInfo *mt_partitions;	/* Per partition result relation */
-- 
2.11.0

From df7b8c780fad226b9635b7530018f391acfe7055 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Wed, 9 Aug 2017 15:52:36 +0900
Subject: [PATCH 2/2] Teach expand_inherited_rtentry to use partition bound
 order

After locking the child tables using find_all_inheritors, we discard
the list of child table OIDs that it generates and rebuild the same
using the information returned by RelationGetPartitionDispatchInfo.
---
 src/backend/optimizer/prep/prepunion.c | 33 +++++++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)

diff --git a/src/backend/optimizer/prep/prepunion.c b/src/backend/optimizer/prep/prepunion.c
index e73c819901..68d0d8efa3 100644
--- a/src/backend/optimizer/prep/prepunion.c
+++ b/src/backend/optimizer/prep/prepunion.c
@@ -33,6 +33,7 @@
 #include "access/heapam.h"
 #include "access/htup_details.h"
 #include "access/sysattr.h"
+#include "catalog/partition.h"
 #include "catalog/pg_inherits_fn.h"
 #include "catalog/pg_type.h"
 #include "miscadmin.h"
@@ -1452,6 +1453,38 @@ expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti)
 	 */
 	oldrelation = heap_open(parentOID, NoLock);
 
+	/*
+	 * For partitioned tables, we arrange the child table OIDs such that they
+	 * appear in the partition bound order.
+	 */
+	if (rte->relkind == RELKIND_PARTITIONED_TABLE)
+	{
+		List   *leaf_part_oids,
+			   *ptinfos;
+
+		/* Discard the original list. */
+		list_free(inhOIDs);
+		inhOIDs = NIL;
+
+		/* Request partitioning information. */
+		RelationGetPartitionDispatchInfo(oldrelation, &ptinfos,
+										 &leaf_part_oids);
+
+		/*
+		 * First collect the partitioned child table OIDs, which includes the
+		 * root parent at the head.
+		 */
+		foreach(l, ptinfos)
+		{
+			PartitionedTableInfo *ptinfo = lfirst(l);
+
+			inhOIDs = lappend_oid(inhOIDs, ptinfo->relid);
+		}
+
+		/* Concatenate the leaf partition OIDs. */
+		inhOIDs = list_concat(inhOIDs, leaf_part_oids);
+	}
+
 	/* Scan the inheritance set and expand it */
 	appinfos = NIL;
 	has_child = false;
-- 
2.11.0

From fb4bd4818c4faa08b3c4d37709f01dc55f256a46 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Mon, 24 Jul 2017 18:59:57 +0900
Subject: [PATCH 1/2] Decouple RelationGetPartitionDispatchInfo() from executor

Currently it and the structure it generates viz. PartitionDispatch
objects are too coupled with the executor's tuple-routing code.  In
particular, it's pretty undesirable that it makes it the responsibility
of the caller to release some resources, such as executor tuple table
slots, tuple-conversion maps, etc.  That makes it harder to use in
places other than where it's currently being used.

After this refactoring, ExecSetupPartitionTupleRouting() now needs to
do some of the work that was previously done in
RelationGetPartitionDispatchInfo().
---
 src/backend/catalog/partition.c        | 278 +++++++++++++++------------------
 src/backend/commands/copy.c            |  37 +++--
 src/backend/executor/execMain.c        | 124 +++++++++++++--
 src/backend/executor/nodeModifyTable.c |  37 +++--
 src/include/catalog/partition.h        |  34 ++--
 src/include/executor/executor.h        |   4 +-
 src/include/nodes/execnodes.h          |  40 ++++-
 7 files changed, 326 insertions(+), 228 deletions(-)

diff --git a/src/backend/catalog/partition.c b/src/backend/catalog/partition.c
index 96a64ce6b2..25fc4583de 100644
--- a/src/backend/catalog/partition.c
+++ b/src/backend/catalog/partition.c
@@ -981,181 +981,147 @@ get_partition_qual_relid(Oid relid)
 }
 
 /*
- * Append OIDs of rel's partitions to the list 'partoids' and for each OID,
- * append pointer rel to the list 'parents'.
- */
-#define APPEND_REL_PARTITION_OIDS(rel, partoids, parents) \
-	do\
-	{\
-		int		i;\
-		for (i = 0; i < (rel)->rd_partdesc->nparts; i++)\
-		{\
-			(partoids) = lappend_oid((partoids), (rel)->rd_partdesc->oids[i]);\
-			(parents) = lappend((parents), (rel));\
-		}\
-	} while(0)
-
-/*
  * RelationGetPartitionDispatchInfo
- *		Returns information necessary to route tuples down a partition tree
+ *		Returns necessary information for each partition in the partition
+ *		tree rooted at rel
  *
- * The number of elements in the returned array (that is, the number of
- * PartitionDispatch objects for the partitioned tables in the partition tree)
- * is returned in *num_parted and a list of the OIDs of all the leaf
- * partitions of rel is returned in *leaf_part_oids.
+ * A list of PartitionDispatch objects is returned, which contains one object
+ * for each partitioned table in the partition tree (with at least one member,
+ * that is, the one for the root partitioned table).  Also, upon return,
+ * *leaf_part_oids will contain a list of the OIDs of all the leaf partitions
+ * in the partition tree.
  *
- * All the relations in the partition tree (including 'rel') must have been
- * locked (using at least the AccessShareLock) by the caller.
+ * We require that the caller has locked at least the partitioned tables in
+ * the partition tree (including 'rel') using at least the AccessShareLock,
+ * because we need to look at their relcache entries to examine its
+ * PartitionDesc.
+ *
+ * It's the responsibility of the caller to close the relation descriptor
+ * reference contained in each PartitionDispatch object.
  */
-PartitionDispatch *
-RelationGetPartitionDispatchInfo(Relation rel,
-								 int *num_parted, List **leaf_part_oids)
+List *
+RelationGetPartitionDispatchInfo(Relation rel, List **leaf_part_oids)
 {
-	PartitionDispatchData **pd;
-	List	   *all_parts = NIL,
-			   *all_parents = NIL,
-			   *parted_rels,
-			   *parted_rel_parents;
+	List	   *result = NIL,
+			   *all_parts,
+			   *all_parents;
 	ListCell   *lc1,
 			   *lc2;
 	int			i,
-				k,
 				offset;
 
 	/*
 	 * We rely on the relcache to traverse the partition tree to build both
-	 * the leaf partition OIDs list and the array of PartitionDispatch objects
-	 * for the partitioned tables in the tree.  That means every partitioned
-	 * table in the tree must be locked, which is fine since we require the
-	 * caller to lock all the partitions anyway.
+	 * the leaf partition OIDs list and the list of PartitionDispatch objects
+	 * for the partitioned tables.  That means every partitioned table in the
+	 * tree must be locked, which is fine since the callers must have done
+	 * that already.
 	 *
 	 * For every partitioned table in the tree, starting with the root
 	 * partitioned table, add its relcache entry to parted_rels, while also
 	 * queuing its partitions (in the order in which they appear in the
 	 * partition descriptor) to be looked at later in the same loop.  This is
 	 * a bit tricky but works because the foreach() macro doesn't fetch the
-	 * next list element until the bottom of the loop.
+	 * next list element until the bottom of the loop.  Non-partitioned tables
+	 * are simply added to the leaf partitions list.
 	 */
-	*num_parted = 1;
-	parted_rels = list_make1(rel);
-	/* Root partitioned table has no parent, so NULL for parent */
-	parted_rel_parents = list_make1(NULL);
-	APPEND_REL_PARTITION_OIDS(rel, all_parts, all_parents);
+	i = offset = 0;
+	*leaf_part_oids = NIL;
+
+	/* Start with the root table. */
+	all_parts = list_make1_oid(RelationGetRelid(rel));
+	all_parents = list_make1_oid(InvalidOid);
 	forboth(lc1, all_parts, lc2, all_parents)
 	{
-		Oid			partrelid = lfirst_oid(lc1);
-		Relation	parent = lfirst(lc2);
+		Oid		partrelid = lfirst_oid(lc1);
+		Oid		parentrelid = lfirst_oid(lc2);
 
 		if (get_rel_relkind(partrelid) == RELKIND_PARTITIONED_TABLE)
 		{
-			/*
-			 * Already locked by the caller.  Note that it is the
-			 * responsibility of the caller to close the below relcache entry,
-			 * once done using the information being collected here (for
-			 * example, in ExecEndModifyTable).
-			 */
-			Relation	partrel = heap_open(partrelid, NoLock);
+			int		j,
+					k;
+			Relation	partrel;
+			PartitionDesc		partdesc;
+			PartitionDispatch	pd;
+
+			if (partrelid != RelationGetRelid(rel))
+				partrel = heap_open(partrelid, NoLock);
+			else
+				partrel = rel;
 
-			(*num_parted)++;
-			parted_rels = lappend(parted_rels, partrel);
-			parted_rel_parents = lappend(parted_rel_parents, parent);
-			APPEND_REL_PARTITION_OIDS(partrel, all_parts, all_parents);
-		}
-	}
+			partdesc = RelationGetPartitionDesc(partrel);
+
+			pd = (PartitionDispatchData *)
+									palloc0(sizeof(PartitionDispatchData));
+			pd->reldesc = partrel;
+			pd->parentoid = parentrelid;
 
-	/*
-	 * We want to create two arrays - one for leaf partitions and another for
-	 * partitioned tables (including the root table and internal partitions).
-	 * While we only create the latter here, leaf partition array of suitable
-	 * objects (such as, ResultRelInfo) is created by the caller using the
-	 * list of OIDs we return.  Indexes into these arrays get assigned in a
-	 * breadth-first manner, whereby partitions of any given level are placed
-	 * consecutively in the respective arrays.
-	 */
-	pd = (PartitionDispatchData **) palloc(*num_parted *
-										   sizeof(PartitionDispatchData *));
-	*leaf_part_oids = NIL;
-	i = k = offset = 0;
-	forboth(lc1, parted_rels, lc2, parted_rel_parents)
-	{
-		Relation	partrel = lfirst(lc1);
-		Relation	parent = lfirst(lc2);
-		PartitionKey partkey = RelationGetPartitionKey(partrel);
-		TupleDesc	tupdesc = RelationGetDescr(partrel);
-		PartitionDesc partdesc = RelationGetPartitionDesc(partrel);
-		int			j,
-					m;
-
-		pd[i] = (PartitionDispatch) palloc(sizeof(PartitionDispatchData));
-		pd[i]->reldesc = partrel;
-		pd[i]->key = partkey;
-		pd[i]->keystate = NIL;
-		pd[i]->partdesc = partdesc;
-		if (parent != NULL)
-		{
 			/*
-			 * For every partitioned table other than root, we must store a
-			 * tuple table slot initialized with its tuple descriptor and a
-			 * tuple conversion map to convert a tuple from its parent's
-			 * rowtype to its own. That is to make sure that we are looking at
-			 * the correct row using the correct tuple descriptor when
-			 * computing its partition key for tuple routing.
+			 * The values contained in the following array correspond to
+			 * indexes of this table's partitions in the global sequence of
+			 * all the partitions contained in the partition tree rooted at
+			 * rel, traversed in a breadh-first manner.  The values should be
+			 * such that we will be able to distinguish the leaf partitions
+			 * from the non-leaf partitions, because they are returned to
+			 * to the caller in separate structures from where they will be
+			 * accessed.  The way that's done is described below:
+			 *
+			 * Leaf partition OIDs are put into the global leaf_part_oids list,
+			 * and for each one, the value stored is its ordinal position in
+			 * the list minus 1.
+			 *
+			 * PartitionDispatch objects corresponding to partitions that
+			 * are partitioned tables are put into the global result list,
+			 * and for each one, the value stored is its ordinal position in
+			 * the list multiplied by -1.
+			 *
+			 * So, when examining the values in the indexes array, getting a
+			 * value >= 0 means the corresponding partition is a leaf
+			 * partition.  Otherwise, it's a partitioned table.
 			 */
-			pd[i]->tupslot = MakeSingleTupleTableSlot(tupdesc);
-			pd[i]->tupmap = convert_tuples_by_name(RelationGetDescr(parent),
-												   tupdesc,
-												   gettext_noop("could not convert row type"));
-		}
-		else
-		{
-			/* Not required for the root partitioned table */
-			pd[i]->tupslot = NULL;
-			pd[i]->tupmap = NULL;
-		}
-		pd[i]->indexes = (int *) palloc(partdesc->nparts * sizeof(int));
-
-		/*
-		 * Indexes corresponding to the internal partitions are multiplied by
-		 * -1 to distinguish them from those of leaf partitions.  Encountering
-		 * an index >= 0 means we found a leaf partition, which is immediately
-		 * returned as the partition we are looking for.  A negative index
-		 * means we found a partitioned table, whose PartitionDispatch object
-		 * is located at the above index multiplied back by -1.  Using the
-		 * PartitionDispatch object, search is continued further down the
-		 * partition tree.
-		 */
-		m = 0;
-		for (j = 0; j < partdesc->nparts; j++)
-		{
-			Oid			partrelid = partdesc->oids[j];
+			pd->indexes = (int *) palloc(partdesc->nparts * sizeof(int));
 
-			if (get_rel_relkind(partrelid) != RELKIND_PARTITIONED_TABLE)
-			{
-				*leaf_part_oids = lappend_oid(*leaf_part_oids, partrelid);
-				pd[i]->indexes[j] = k++;
-			}
-			else
+			k = 0;
+			for (j = 0; j < partdesc->nparts; j++)
 			{
+				Oid			partrelid = partdesc->oids[j];
+
 				/*
-				 * offset denotes the number of partitioned tables of upper
-				 * levels including those of the current level.  Any partition
-				 * of this table must belong to the next level and hence will
-				 * be placed after the last partitioned table of this level.
+				 * Queue this partition so that it will be processed later
+				 * by the outer loop.
 				 */
-				pd[i]->indexes[j] = -(1 + offset + m);
-				m++;
+				all_parts = lappend_oid(all_parts, partrelid);
+				all_parents = lappend_oid(all_parents,
+										  RelationGetRelid(partrel));
+
+				if (get_rel_relkind(partrelid) != RELKIND_PARTITIONED_TABLE)
+				{
+					*leaf_part_oids = lappend_oid(*leaf_part_oids, partrelid);
+					pd->indexes[j] = i++;
+				}
+				else
+				{
+					/*
+					 * offset denotes the number of partitioned tables that
+					 * we have already processed.  k counts the number of
+					 * partitions of this table that were found to be
+					 * partitioned tables.
+					 */
+					pd->indexes[j] = -(1 + offset + k);
+					k++;
+				}
 			}
-		}
-		i++;
 
-		/*
-		 * This counts the number of partitioned tables at upper levels
-		 * including those of the current level.
-		 */
-		offset += m;
+			offset += k;
+
+			result = lappend(result, pd);
+		}
 	}
 
-	return pd;
+	Assert(i == list_length(*leaf_part_oids));
+	Assert((offset + 1) == list_length(result));
+
+	return result;
 }
 
 /* Module-local functions */
@@ -1860,7 +1826,7 @@ generate_partition_qual(Relation rel)
  *			Construct values[] and isnull[] arrays for the partition key
  *			of a tuple.
  *
- *	pd				Partition dispatch object of the partitioned table
+ *	ptrinfo			PartitionTupleRoutingInfo object of the table
  *	slot			Heap tuple from which to extract partition key
  *	estate			executor state for evaluating any partition key
  *					expressions (must be non-NULL)
@@ -1872,29 +1838,30 @@ generate_partition_qual(Relation rel)
  * ----------------
  */
 void
-FormPartitionKeyDatum(PartitionDispatch pd,
+FormPartitionKeyDatum(PartitionTupleRoutingInfo *ptrinfo,
 					  TupleTableSlot *slot,
 					  EState *estate,
 					  Datum *values,
 					  bool *isnull)
 {
+	PartitionKey	key = RelationGetPartitionKey(ptrinfo->pd->reldesc);
 	ListCell   *partexpr_item;
 	int			i;
 
-	if (pd->key->partexprs != NIL && pd->keystate == NIL)
+	if (key->partexprs != NIL && ptrinfo->keystate == NIL)
 	{
 		/* Check caller has set up context correctly */
 		Assert(estate != NULL &&
 			   GetPerTupleExprContext(estate)->ecxt_scantuple == slot);
 
 		/* First time through, set up expression evaluation state */
-		pd->keystate = ExecPrepareExprList(pd->key->partexprs, estate);
+		ptrinfo->keystate = ExecPrepareExprList(key->partexprs, estate);
 	}
 
-	partexpr_item = list_head(pd->keystate);
-	for (i = 0; i < pd->key->partnatts; i++)
+	partexpr_item = list_head(ptrinfo->keystate);
+	for (i = 0; i < key->partnatts; i++)
 	{
-		AttrNumber	keycol = pd->key->partattrs[i];
+		AttrNumber	keycol = key->partattrs[i];
 		Datum		datum;
 		bool		isNull;
 
@@ -1931,13 +1898,13 @@ FormPartitionKeyDatum(PartitionDispatch pd,
  * the latter case.
  */
 int
-get_partition_for_tuple(PartitionDispatch *pd,
+get_partition_for_tuple(PartitionTupleRoutingInfo **ptrinfos,
 						TupleTableSlot *slot,
 						EState *estate,
-						PartitionDispatchData **failed_at,
+						PartitionTupleRoutingInfo **failed_at,
 						TupleTableSlot **failed_slot)
 {
-	PartitionDispatch parent;
+	PartitionTupleRoutingInfo *parent;
 	Datum		values[PARTITION_MAX_KEYS];
 	bool		isnull[PARTITION_MAX_KEYS];
 	int			cur_offset,
@@ -1948,11 +1915,12 @@ get_partition_for_tuple(PartitionDispatch *pd,
 	TupleTableSlot *ecxt_scantuple_old = ecxt->ecxt_scantuple;
 
 	/* start with the root partitioned table */
-	parent = pd[0];
+	parent = ptrinfos[0];
 	while (true)
 	{
-		PartitionKey key = parent->key;
-		PartitionDesc partdesc = parent->partdesc;
+		PartitionDispatch	pd = parent->pd;
+		PartitionKey  key = RelationGetPartitionKey(pd->reldesc);
+		PartitionDesc partdesc = RelationGetPartitionDesc(pd->reldesc);
 		TupleTableSlot *myslot = parent->tupslot;
 		TupleConversionMap *map = parent->tupmap;
 
@@ -2055,13 +2023,13 @@ get_partition_for_tuple(PartitionDispatch *pd,
 			*failed_slot = slot;
 			break;
 		}
-		else if (parent->indexes[cur_index] >= 0)
+		else if (pd->indexes[cur_index] >= 0)
 		{
-			result = parent->indexes[cur_index];
+			result = pd->indexes[cur_index];
 			break;
 		}
 		else
-			parent = pd[-parent->indexes[cur_index]];
+			parent = ptrinfos[-pd->indexes[cur_index]];
 	}
 
 error_exit:
diff --git a/src/backend/commands/copy.c b/src/backend/commands/copy.c
index cfa3f059c2..b0c596345b 100644
--- a/src/backend/commands/copy.c
+++ b/src/backend/commands/copy.c
@@ -165,8 +165,8 @@ typedef struct CopyStateData
 	bool		volatile_defexprs;	/* is any of defexprs volatile? */
 	List	   *range_table;
 
-	PartitionDispatch *partition_dispatch_info;
-	int			num_dispatch;	/* Number of entries in the above array */
+	PartitionTupleRoutingInfo **ptrinfos;
+	int			num_parted;		/* Number of entries in the above array */
 	int			num_partitions; /* Number of members in the following arrays */
 	ResultRelInfo *partitions;	/* Per partition result relation */
 	TupleConversionMap **partition_tupconv_maps;
@@ -2445,7 +2445,7 @@ CopyFrom(CopyState cstate)
 	 */
 	if (cstate->rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
 	{
-		PartitionDispatch *partition_dispatch_info;
+		PartitionTupleRoutingInfo **ptrinfos;
 		ResultRelInfo *partitions;
 		TupleConversionMap **partition_tupconv_maps;
 		TupleTableSlot *partition_tuple_slot;
@@ -2455,13 +2455,13 @@ CopyFrom(CopyState cstate)
 		ExecSetupPartitionTupleRouting(cstate->rel,
 									   1,
 									   estate,
-									   &partition_dispatch_info,
+									   &ptrinfos,
 									   &partitions,
 									   &partition_tupconv_maps,
 									   &partition_tuple_slot,
 									   &num_parted, &num_partitions);
-		cstate->partition_dispatch_info = partition_dispatch_info;
-		cstate->num_dispatch = num_parted;
+		cstate->ptrinfos = ptrinfos;
+		cstate->num_parted = num_parted;
 		cstate->partitions = partitions;
 		cstate->num_partitions = num_partitions;
 		cstate->partition_tupconv_maps = partition_tupconv_maps;
@@ -2502,7 +2502,7 @@ CopyFrom(CopyState cstate)
 	if ((resultRelInfo->ri_TrigDesc != NULL &&
 		 (resultRelInfo->ri_TrigDesc->trig_insert_before_row ||
 		  resultRelInfo->ri_TrigDesc->trig_insert_instead_row)) ||
-		cstate->partition_dispatch_info != NULL ||
+		cstate->ptrinfos != NULL ||
 		cstate->volatile_defexprs)
 	{
 		useHeapMultiInsert = false;
@@ -2580,7 +2580,7 @@ CopyFrom(CopyState cstate)
 		ExecStoreTuple(tuple, slot, InvalidBuffer, false);
 
 		/* Determine the partition to heap_insert the tuple into */
-		if (cstate->partition_dispatch_info)
+		if (cstate->ptrinfos)
 		{
 			int			leaf_part_index;
 			TupleConversionMap *map;
@@ -2594,7 +2594,7 @@ CopyFrom(CopyState cstate)
 			 * partition, respectively.
 			 */
 			leaf_part_index = ExecFindPartition(resultRelInfo,
-												cstate->partition_dispatch_info,
+												cstate->ptrinfos,
 												slot,
 												estate);
 			Assert(leaf_part_index >= 0 &&
@@ -2826,24 +2826,23 @@ CopyFrom(CopyState cstate)
 
 	ExecCloseIndices(resultRelInfo);
 
-	/* Close all the partitioned tables, leaf partitions, and their indices */
-	if (cstate->partition_dispatch_info)
+	/* Release some resources that we acquired for tuple-routing. */
+	if (cstate->ptrinfos)
 	{
 		int			i;
 
 		/*
-		 * Remember cstate->partition_dispatch_info[0] corresponds to the root
-		 * partitioned table, which we must not try to close, because it is
-		 * the main target table of COPY that will be closed eventually by
-		 * DoCopy().  Also, tupslot is NULL for the root partitioned table.
+		 * cstate->ptrinfos[0] corresponds to the root partitioned table, for
+		 * which we didn't create tupslot.
 		 */
-		for (i = 1; i < cstate->num_dispatch; i++)
+		for (i = 1; i < cstate->num_parted; i++)
 		{
-			PartitionDispatch pd = cstate->partition_dispatch_info[i];
+			PartitionTupleRoutingInfo *ptrinfo = cstate->ptrinfos[i];
 
-			heap_close(pd->reldesc, NoLock);
-			ExecDropSingleTupleTableSlot(pd->tupslot);
+			ExecDropSingleTupleTableSlot(ptrinfo->tupslot);
 		}
+
+		/* Close all the leaf partitions and their indices */
 		for (i = 0; i < cstate->num_partitions; i++)
 		{
 			ResultRelInfo *resultRelInfo = cstate->partitions + i;
diff --git a/src/backend/executor/execMain.c b/src/backend/executor/execMain.c
index 2946a0edee..493ade0e78 100644
--- a/src/backend/executor/execMain.c
+++ b/src/backend/executor/execMain.c
@@ -3236,8 +3236,8 @@ EvalPlanQualEnd(EPQState *epqstate)
  * tuple routing for partitioned tables
  *
  * Output arguments:
- * 'pd' receives an array of PartitionDispatch objects with one entry for
- *		every partitioned table in the partition tree
+ * 'ptrinfos' receives an array of PartitionTupleRoutingInfo objects with one
+ *		entry for each partitioned table in the partition tree
  * 'partitions' receives an array of ResultRelInfo objects with one entry for
  *		every leaf partition in the partition tree
  * 'tup_conv_maps' receives an array of TupleConversionMap objects with one
@@ -3260,7 +3260,7 @@ void
 ExecSetupPartitionTupleRouting(Relation rel,
 							   Index resultRTindex,
 							   EState *estate,
-							   PartitionDispatch **pd,
+							   PartitionTupleRoutingInfo ***ptrinfos,
 							   ResultRelInfo **partitions,
 							   TupleConversionMap ***tup_conv_maps,
 							   TupleTableSlot **partition_tuple_slot,
@@ -3268,16 +3268,116 @@ ExecSetupPartitionTupleRouting(Relation rel,
 {
 	TupleDesc	tupDesc = RelationGetDescr(rel);
 	List	   *leaf_parts;
+	List	   *pdlist;
 	ListCell   *cell;
 	int			i;
 	ResultRelInfo *leaf_part_rri;
+	Relation	parent;
 
 	/*
 	 * Get the information about the partition tree after locking all the
 	 * partitions.
 	 */
 	(void) find_all_inheritors(RelationGetRelid(rel), RowExclusiveLock, NULL);
-	*pd = RelationGetPartitionDispatchInfo(rel, num_parted, &leaf_parts);
+	pdlist = RelationGetPartitionDispatchInfo(rel, &leaf_parts);
+
+	/*
+	 * The pdlist list contains PartitionDispatch objects for all the
+	 * partitioned tables in the partition tree.  Using the information
+	 * therein, we construct an array of PartitionTupleRoutingInfo objects
+	 * to be used during tuple-routing.
+	 */
+	*num_parted = list_length(pdlist);
+	*ptrinfos = (PartitionTupleRoutingInfo **) palloc0(*num_parted *
+										sizeof(PartitionTupleRoutingInfo *));
+	/*
+	 * Free the ptinfos List structure itself as we go through (open-coded
+	 * list_free).
+	 */
+	i = 0;
+	cell = list_head(pdlist);
+	parent = NULL;
+	while (cell)
+	{
+		ListCell   *tmp = cell;
+		PartitionDispatch	pd = lfirst(tmp),
+							next_pd = NULL;
+		Relation		partrel;
+		PartitionTupleRoutingInfo *ptrinfo;
+
+		if (lnext(tmp))
+			next_pd = lfirst(lnext(tmp));
+
+		partrel = pd->reldesc;
+
+		ptrinfo = (PartitionTupleRoutingInfo *)
+							palloc0(sizeof(PartitionTupleRoutingInfo));
+		/* Stash a reference to this PartitionDispatch. */
+		ptrinfo->pd = pd;
+
+		/* State for extracting partition key from tuples will go here. */
+		ptrinfo->keystate = NIL;
+
+		/*
+		 * For every partitioned table other than root, we must store a tuple
+		 * table slot initialized with its tuple descriptor and a tuple
+		 * conversion map to convert a tuple from its parent's rowtype to its
+		 * own.  That is to make sure that we are looking at the correct row
+		 * using the correct tuple descriptor when computing its partition key
+		 * for tuple routing.
+		 */
+		if (pd->parentoid != InvalidOid)
+		{
+			TupleDesc	tupdesc = RelationGetDescr(partrel);
+
+			/* Open the parent relation descriptor if not already done. */
+			if (pd->parentoid == RelationGetRelid(rel))
+			{
+				parent = rel;
+			}
+			else if (parent == NULL)
+			{
+				/* Locked by RelationGetPartitionDispatchInfo(). */
+				parent = heap_open(pd->parentoid, NoLock);
+			}
+
+			ptrinfo->tupslot = MakeSingleTupleTableSlot(tupdesc);
+			ptrinfo->tupmap = convert_tuples_by_name(RelationGetDescr(parent),
+													 tupdesc,
+								  gettext_noop("could not convert row type"));
+
+			/*
+			 * Close the parent descriptor, if the next partitioned table in
+			 * the list is not a sibling, because it will have a different
+			 * parent if so.
+			 */
+			if (parent != NULL && parent != rel &&
+				next_pd != NULL &&
+				next_pd->parentoid != pd->parentoid)
+			{
+				heap_close(parent, NoLock);
+				parent = NULL;
+			}
+		}
+		else
+		{
+			/* Not required for the root partitioned table */
+			ptrinfo->tupslot = NULL;
+			ptrinfo->tupmap = NULL;
+		}
+
+		(*ptrinfos)[i++] = ptrinfo;
+
+		/* Free the ListCell. */
+		cell = lnext(cell);
+		pfree(tmp);
+	}
+
+	/* Free the List itself. */
+	if (pdlist)
+		pfree(pdlist);
+
+	/* For leaf partitions, we build ResultRelInfos and TupleConversionMaps. */
 	*num_partitions = list_length(leaf_parts);
 	*partitions = (ResultRelInfo *) palloc(*num_partitions *
 										   sizeof(ResultRelInfo));
@@ -3304,7 +3404,7 @@ ExecSetupPartitionTupleRouting(Relation rel,
 		 * Note that each of the relations in *partitions are eventually
 		 * closed by the caller.
 		 */
-		partrel = heap_open(lfirst_oid(cell), NoLock);
+		partrel = heap_open(lfirst_oid(cell), RowExclusiveLock);
 		part_tupdesc = RelationGetDescr(partrel);
 
 		/*
@@ -3317,7 +3417,7 @@ ExecSetupPartitionTupleRouting(Relation rel,
 		 * partition from the parent's type to the partition's.
 		 */
 		(*tup_conv_maps)[i] = convert_tuples_by_name(tupDesc, part_tupdesc,
-													 gettext_noop("could not convert row type"));
+								 gettext_noop("could not convert row type"));
 
 		InitResultRelInfo(leaf_part_rri,
 						  partrel,
@@ -3354,11 +3454,13 @@ ExecSetupPartitionTupleRouting(Relation rel,
  * by get_partition_for_tuple() unchanged.
  */
 int
-ExecFindPartition(ResultRelInfo *resultRelInfo, PartitionDispatch *pd,
-				  TupleTableSlot *slot, EState *estate)
+ExecFindPartition(ResultRelInfo *resultRelInfo,
+				  PartitionTupleRoutingInfo **ptrinfos,
+				  TupleTableSlot *slot,
+				  EState *estate)
 {
 	int			result;
-	PartitionDispatchData *failed_at;
+	PartitionTupleRoutingInfo *failed_at;
 	TupleTableSlot *failed_slot;
 
 	/*
@@ -3368,7 +3470,7 @@ ExecFindPartition(ResultRelInfo *resultRelInfo, PartitionDispatch *pd,
 	if (resultRelInfo->ri_PartitionCheck)
 		ExecPartitionCheck(resultRelInfo, slot, estate);
 
-	result = get_partition_for_tuple(pd, slot, estate,
+	result = get_partition_for_tuple(ptrinfos, slot, estate,
 									 &failed_at, &failed_slot);
 	if (result < 0)
 	{
@@ -3378,7 +3480,7 @@ ExecFindPartition(ResultRelInfo *resultRelInfo, PartitionDispatch *pd,
 		char	   *val_desc;
 		ExprContext *ecxt = GetPerTupleExprContext(estate);
 
-		failed_rel = failed_at->reldesc;
+		failed_rel = failed_at->pd->reldesc;
 		ecxt->ecxt_scantuple = failed_slot;
 		FormPartitionKeyDatum(failed_at, failed_slot, estate,
 							  key_values, key_isnull);
diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c
index e12721a9b6..753ee13985 100644
--- a/src/backend/executor/nodeModifyTable.c
+++ b/src/backend/executor/nodeModifyTable.c
@@ -278,7 +278,7 @@ ExecInsert(ModifyTableState *mtstate,
 	resultRelInfo = estate->es_result_relation_info;
 
 	/* Determine the partition to heap_insert the tuple into */
-	if (mtstate->mt_partition_dispatch_info)
+	if (mtstate->mt_ptrinfos)
 	{
 		int			leaf_part_index;
 		TupleConversionMap *map;
@@ -292,7 +292,7 @@ ExecInsert(ModifyTableState *mtstate,
 		 * respectively.
 		 */
 		leaf_part_index = ExecFindPartition(resultRelInfo,
-											mtstate->mt_partition_dispatch_info,
+											mtstate->mt_ptrinfos,
 											slot,
 											estate);
 		Assert(leaf_part_index >= 0 &&
@@ -1487,7 +1487,7 @@ ExecSetupTransitionCaptureState(ModifyTableState *mtstate, EState *estate)
 		int			numResultRelInfos;
 
 		/* Find the set of partitions so that we can find their TupleDescs. */
-		if (mtstate->mt_partition_dispatch_info != NULL)
+		if (mtstate->mt_ptrinfos != NULL)
 		{
 			/*
 			 * For INSERT via partitioned table, so we need TupleDescs based
@@ -1911,7 +1911,7 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 	if (operation == CMD_INSERT &&
 		rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
 	{
-		PartitionDispatch *partition_dispatch_info;
+		PartitionTupleRoutingInfo **ptrinfos;
 		ResultRelInfo *partitions;
 		TupleConversionMap **partition_tupconv_maps;
 		TupleTableSlot *partition_tuple_slot;
@@ -1921,13 +1921,13 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 		ExecSetupPartitionTupleRouting(rel,
 									   node->nominalRelation,
 									   estate,
-									   &partition_dispatch_info,
+									   &ptrinfos,
 									   &partitions,
 									   &partition_tupconv_maps,
 									   &partition_tuple_slot,
 									   &num_parted, &num_partitions);
-		mtstate->mt_partition_dispatch_info = partition_dispatch_info;
-		mtstate->mt_num_dispatch = num_parted;
+		mtstate->mt_ptrinfos = ptrinfos;
+		mtstate->mt_num_parted = num_parted;
 		mtstate->mt_partitions = partitions;
 		mtstate->mt_num_partitions = num_partitions;
 		mtstate->mt_partition_tupconv_maps = partition_tupconv_maps;
@@ -2336,21 +2336,24 @@ ExecEndModifyTable(ModifyTableState *node)
 														   resultRelInfo);
 	}
 
+	/* Release some resources that we acquired for tuple-routing. */
+
 	/*
-	 * Close all the partitioned tables, leaf partitions, and their indices
-	 *
-	 * Remember node->mt_partition_dispatch_info[0] corresponds to the root
-	 * partitioned table, which we must not try to close, because it is the
-	 * main target table of the query that will be closed by ExecEndPlan().
-	 * Also, tupslot is NULL for the root partitioned table.
+	 * node->mt_ptrinfos[0] corresponds to the root partitioned table, for
+	 * which we didn't create tupslot.  Also, its relation descriptor will
+	 * be closed in ExecEndPlan().
 	 */
-	for (i = 1; i < node->mt_num_dispatch; i++)
+	for (i = 1; i < node->mt_num_parted; i++)
 	{
-		PartitionDispatch pd = node->mt_partition_dispatch_info[i];
+		PartitionTupleRoutingInfo *ptrinfo = node->mt_ptrinfos[i];
 
-		heap_close(pd->reldesc, NoLock);
-		ExecDropSingleTupleTableSlot(pd->tupslot);
+		heap_close(ptrinfo->pd->reldesc, NoLock);
+		ExecDropSingleTupleTableSlot(ptrinfo->tupslot);
 	}
+
+	/*
+	 * Close all the leaf partitions and their indices.
+	 */
 	for (i = 0; i < node->mt_num_partitions; i++)
 	{
 		ResultRelInfo *resultRelInfo = node->mt_partitions + i;
diff --git a/src/include/catalog/partition.h b/src/include/catalog/partition.h
index 2283c675e9..73cfb4e937 100644
--- a/src/include/catalog/partition.h
+++ b/src/include/catalog/partition.h
@@ -40,31 +40,20 @@ typedef struct PartitionDescData
 typedef struct PartitionDescData *PartitionDesc;
 
 /*-----------------------
- * PartitionDispatch - information about one partitioned table in a partition
- * hierarchy required to route a tuple to one of its partitions
+ * PartitionDispatchData - information of partitions of one partitioned table
+ *						   in a partition tree
  *
  *	reldesc		Relation descriptor of the table
- *	key			Partition key information of the table
- *	keystate	Execution state required for expressions in the partition key
- *	partdesc	Partition descriptor of the table
- *	tupslot		A standalone TupleTableSlot initialized with this table's tuple
- *				descriptor
- *	tupmap		TupleConversionMap to convert from the parent's rowtype to
- *				this table's rowtype (when extracting the partition key of a
- *				tuple just before routing it through this table)
- *	indexes		Array with partdesc->nparts members (for details on what
- *				individual members represent, see how they are set in
+ *	parentoid	OID of the parent table (InvalidOid if root partitioned table)
+ *	indexes		Array with reldesc->rd_partdesc->nparts members (for details on
+ *				what the individual value represents, see the comments in
  *				RelationGetPartitionDispatchInfo())
  *-----------------------
  */
 typedef struct PartitionDispatchData
 {
 	Relation	reldesc;
-	PartitionKey key;
-	List	   *keystate;		/* list of ExprState */
-	PartitionDesc partdesc;
-	TupleTableSlot *tupslot;
-	TupleConversionMap *tupmap;
+	Oid			parentoid;
 	int		   *indexes;
 } PartitionDispatchData;
 
@@ -86,17 +75,18 @@ extern List *map_partition_varattnos(List *expr, int target_varno,
 extern List *RelationGetPartitionQual(Relation rel);
 extern Expr *get_partition_qual_relid(Oid relid);
 
+extern List *RelationGetPartitionDispatchInfo(Relation rel,
+								 List **leaf_part_oids);
+
 /* For tuple routing */
-extern PartitionDispatch *RelationGetPartitionDispatchInfo(Relation rel,
-								 int *num_parted, List **leaf_part_oids);
-extern void FormPartitionKeyDatum(PartitionDispatch pd,
+extern void FormPartitionKeyDatum(PartitionTupleRoutingInfo *ptrinfo,
 					  TupleTableSlot *slot,
 					  EState *estate,
 					  Datum *values,
 					  bool *isnull);
-extern int get_partition_for_tuple(PartitionDispatch *pd,
+extern int get_partition_for_tuple(PartitionTupleRoutingInfo **ptrinfos,
 						TupleTableSlot *slot,
 						EState *estate,
-						PartitionDispatchData **failed_at,
+						PartitionTupleRoutingInfo **failed_at,
 						TupleTableSlot **failed_slot);
 #endif							/* PARTITION_H */
diff --git a/src/include/executor/executor.h b/src/include/executor/executor.h
index eacbea3c36..44b7cd0fd6 100644
--- a/src/include/executor/executor.h
+++ b/src/include/executor/executor.h
@@ -209,13 +209,13 @@ extern HeapTuple EvalPlanQualGetTuple(EPQState *epqstate, Index rti);
 extern void ExecSetupPartitionTupleRouting(Relation rel,
 							   Index resultRTindex,
 							   EState *estate,
-							   PartitionDispatch **pd,
+							   PartitionTupleRoutingInfo ***ptrinfos,
 							   ResultRelInfo **partitions,
 							   TupleConversionMap ***tup_conv_maps,
 							   TupleTableSlot **partition_tuple_slot,
 							   int *num_parted, int *num_partitions);
 extern int ExecFindPartition(ResultRelInfo *resultRelInfo,
-				  PartitionDispatch *pd,
+				  PartitionTupleRoutingInfo **ptrinfos,
 				  TupleTableSlot *slot,
 				  EState *estate);
 
diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h
index 3272c4b315..ab28169a96 100644
--- a/src/include/nodes/execnodes.h
+++ b/src/include/nodes/execnodes.h
@@ -414,6 +414,42 @@ typedef struct ResultRelInfo
 	Relation	ri_PartitionRoot;
 } ResultRelInfo;
 
+/* Forward declarations, to avoid including other headers */
+typedef struct PartitionDispatchData *PartitionDispatch;
+
+/*
+ * PartitionTupleRoutingInfo - information required for tuple-routing
+ *							   through one partitioned table in a partition
+ *							   tree
+ */
+typedef struct PartitionTupleRoutingInfo
+{
+
+	/* Information about the table's partitions */
+	PartitionDispatch	pd;
+
+	/*
+	 * The execution state required for expressions contained in the partition
+	 * key.  It is NIL until initialized by FormPartitionKeyDatum() if and when
+	 * it is called; for example, the first time a tuple is routed through this
+	 * table.
+	 */
+	List   *keystate;
+
+	/*
+	 * A standalone TupleTableSlot initialized with this table's tuple
+	 * descriptor
+	 */
+	TupleTableSlot *tupslot;
+
+	/*
+	 * TupleConversionMap to convert from the parent's rowtype to this table's
+	 * rowtype (when extracting the partition key of a tuple just before
+	 * routing it through this table)
+	 */
+	TupleConversionMap *tupmap;
+} PartitionTupleRoutingInfo;
+
 /* ----------------
  *	  EState information
  *
@@ -973,9 +1009,9 @@ typedef struct ModifyTableState
 	TupleTableSlot *mt_existing;	/* slot to store existing target tuple in */
 	List	   *mt_excludedtlist;	/* the excluded pseudo relation's tlist  */
 	TupleTableSlot *mt_conflproj;	/* CONFLICT ... SET ... projection target */
-	struct PartitionDispatchData **mt_partition_dispatch_info;
 	/* Tuple-routing support info */
-	int			mt_num_dispatch;	/* Number of entries in the above array */
+	struct PartitionTupleRoutingInfo **mt_ptrinfos;
+	int			mt_num_parted;		/* Number of entries in the above array */
 	int			mt_num_partitions;	/* Number of members in the following
 									 * arrays */
 	ResultRelInfo *mt_partitions;	/* Per partition result relation */
-- 
2.11.0

From b23ce2d7acbb89636c61b5e10c93211b052ef61a Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Wed, 9 Aug 2017 15:52:36 +0900
Subject: [PATCH 2/2] Teach expand_inherited_rtentry to use partition bound
 order

After locking the child tables using find_all_inheritors, we discard
the list of child table OIDs that it generates and rebuild the same
using the information returned by RelationGetPartitionDispatchInfo.
---
 src/backend/optimizer/prep/prepunion.c | 35 ++++++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)

diff --git a/src/backend/optimizer/prep/prepunion.c b/src/backend/optimizer/prep/prepunion.c
index e73c819901..1ae1a851d4 100644
--- a/src/backend/optimizer/prep/prepunion.c
+++ b/src/backend/optimizer/prep/prepunion.c
@@ -33,6 +33,7 @@
 #include "access/heapam.h"
 #include "access/htup_details.h"
 #include "access/sysattr.h"
+#include "catalog/partition.h"
 #include "catalog/pg_inherits_fn.h"
 #include "catalog/pg_type.h"
 #include "miscadmin.h"
@@ -1452,6 +1453,40 @@ expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti)
 	 */
 	oldrelation = heap_open(parentOID, NoLock);
 
+	/*
+	 * For partitioned tables, we arrange the child table OIDs such that they
+	 * appear in the partition bound order.
+	 */
+	if (rte->relkind == RELKIND_PARTITIONED_TABLE)
+	{
+		List   *leaf_part_oids,
+			   *pdlist;
+
+		/* Discard the original list. */
+		list_free(inhOIDs);
+		inhOIDs = NIL;
+
+		/* Request partitioning information. */
+		pdlist = RelationGetPartitionDispatchInfo(oldrelation,
+												  &leaf_part_oids);
+
+		/*
+		 * First collect the partitioned child table OIDs, which includes the
+		 * root parent at the head.
+		 */
+		foreach(l, pdlist)
+		{
+			PartitionDispatch	pd = lfirst(l);
+
+			inhOIDs = lappend_oid(inhOIDs, RelationGetRelid(pd->reldesc));
+			if (pd->reldesc != oldrelation)
+				heap_close(pd->reldesc, NoLock);
+		}
+
+		/* Concatenate the leaf partition OIDs. */
+		inhOIDs = list_concat(inhOIDs, leaf_part_oids);
+	}
+
 	/* Scan the inheritance set and expand it */
 	appinfos = NIL;
 	has_child = false;
-- 
2.11.0

From 9dd8e6f6bd3636f8c125c71e6d1c65bf606a2a22 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Wed, 30 Aug 2017 10:02:05 +0900
Subject: [PATCH 1/2] Decouple RelationGetPartitionDispatchInfo() from executor

Currently it and the structure it generates viz. PartitionDispatch
objects are too coupled with the executor's tuple-routing code.  In
particular, it's pretty undesirable that it makes it the responsibility
of the caller to release some resources, such as executor tuple table
slots, tuple-conversion maps, etc.  That makes it harder to use in
places other than where it's currently being used.

After this refactoring, ExecSetupPartitionTupleRouting() now needs to
do some of the work that was previously done in
RelationGetPartitionDispatchInfo().
---
 src/backend/catalog/partition.c        | 53 +++++++-------------
 src/backend/commands/copy.c            | 32 +++++++------
 src/backend/executor/execMain.c        | 88 ++++++++++++++++++++++++++++++----
 src/backend/executor/nodeModifyTable.c | 37 +++++++-------
 src/include/catalog/partition.h        | 20 +++-----
 src/include/executor/executor.h        |  4 +-
 src/include/nodes/execnodes.h          | 40 +++++++++++++++-
 7 files changed, 181 insertions(+), 93 deletions(-)

diff --git a/src/backend/catalog/partition.c b/src/backend/catalog/partition.c
index 96a64ce6b2..c92756ecd5 100644
--- a/src/backend/catalog/partition.c
+++ b/src/backend/catalog/partition.c
@@ -1081,7 +1081,6 @@ RelationGetPartitionDispatchInfo(Relation rel,
 		Relation	partrel = lfirst(lc1);
 		Relation	parent = lfirst(lc2);
 		PartitionKey partkey = RelationGetPartitionKey(partrel);
-		TupleDesc	tupdesc = RelationGetDescr(partrel);
 		PartitionDesc partdesc = RelationGetPartitionDesc(partrel);
 		int			j,
 					m;
@@ -1089,29 +1088,12 @@ RelationGetPartitionDispatchInfo(Relation rel,
 		pd[i] = (PartitionDispatch) palloc(sizeof(PartitionDispatchData));
 		pd[i]->reldesc = partrel;
 		pd[i]->key = partkey;
-		pd[i]->keystate = NIL;
 		pd[i]->partdesc = partdesc;
 		if (parent != NULL)
-		{
-			/*
-			 * For every partitioned table other than root, we must store a
-			 * tuple table slot initialized with its tuple descriptor and a
-			 * tuple conversion map to convert a tuple from its parent's
-			 * rowtype to its own. That is to make sure that we are looking at
-			 * the correct row using the correct tuple descriptor when
-			 * computing its partition key for tuple routing.
-			 */
-			pd[i]->tupslot = MakeSingleTupleTableSlot(tupdesc);
-			pd[i]->tupmap = convert_tuples_by_name(RelationGetDescr(parent),
-												   tupdesc,
-												   gettext_noop("could not convert row type"));
-		}
+			pd[i]->parentoid = RelationGetRelid(parent);
 		else
-		{
-			/* Not required for the root partitioned table */
-			pd[i]->tupslot = NULL;
-			pd[i]->tupmap = NULL;
-		}
+			pd[i]->parentoid = InvalidOid;
+
 		pd[i]->indexes = (int *) palloc(partdesc->nparts * sizeof(int));
 
 		/*
@@ -1860,7 +1842,7 @@ generate_partition_qual(Relation rel)
  *			Construct values[] and isnull[] arrays for the partition key
  *			of a tuple.
  *
- *	pd				Partition dispatch object of the partitioned table
+ *	ptrinfo			PartitionTupleRoutingInfo object of the table
  *	slot			Heap tuple from which to extract partition key
  *	estate			executor state for evaluating any partition key
  *					expressions (must be non-NULL)
@@ -1872,26 +1854,27 @@ generate_partition_qual(Relation rel)
  * ----------------
  */
 void
-FormPartitionKeyDatum(PartitionDispatch pd,
+FormPartitionKeyDatum(PartitionTupleRoutingInfo *ptrinfo,
 					  TupleTableSlot *slot,
 					  EState *estate,
 					  Datum *values,
 					  bool *isnull)
 {
+	PartitionDispatch	pd = ptrinfo->pd;
 	ListCell   *partexpr_item;
 	int			i;
 
-	if (pd->key->partexprs != NIL && pd->keystate == NIL)
+	if (pd->key->partexprs != NIL && ptrinfo->keystate == NIL)
 	{
 		/* Check caller has set up context correctly */
 		Assert(estate != NULL &&
 			   GetPerTupleExprContext(estate)->ecxt_scantuple == slot);
 
 		/* First time through, set up expression evaluation state */
-		pd->keystate = ExecPrepareExprList(pd->key->partexprs, estate);
+		ptrinfo->keystate = ExecPrepareExprList(pd->key->partexprs, estate);
 	}
 
-	partexpr_item = list_head(pd->keystate);
+	partexpr_item = list_head(ptrinfo->keystate);
 	for (i = 0; i < pd->key->partnatts; i++)
 	{
 		AttrNumber	keycol = pd->key->partattrs[i];
@@ -1931,13 +1914,13 @@ FormPartitionKeyDatum(PartitionDispatch pd,
  * the latter case.
  */
 int
-get_partition_for_tuple(PartitionDispatch *pd,
+get_partition_for_tuple(PartitionTupleRoutingInfo **ptrinfos,
 						TupleTableSlot *slot,
 						EState *estate,
-						PartitionDispatchData **failed_at,
+						PartitionTupleRoutingInfo **failed_at,
 						TupleTableSlot **failed_slot)
 {
-	PartitionDispatch parent;
+	PartitionTupleRoutingInfo *parent;
 	Datum		values[PARTITION_MAX_KEYS];
 	bool		isnull[PARTITION_MAX_KEYS];
 	int			cur_offset,
@@ -1948,11 +1931,11 @@ get_partition_for_tuple(PartitionDispatch *pd,
 	TupleTableSlot *ecxt_scantuple_old = ecxt->ecxt_scantuple;
 
 	/* start with the root partitioned table */
-	parent = pd[0];
+	parent = ptrinfos[0];
 	while (true)
 	{
-		PartitionKey key = parent->key;
-		PartitionDesc partdesc = parent->partdesc;
+		PartitionKey  key = parent->pd->key;
+		PartitionDesc partdesc = parent->pd->partdesc;
 		TupleTableSlot *myslot = parent->tupslot;
 		TupleConversionMap *map = parent->tupmap;
 
@@ -2055,13 +2038,13 @@ get_partition_for_tuple(PartitionDispatch *pd,
 			*failed_slot = slot;
 			break;
 		}
-		else if (parent->indexes[cur_index] >= 0)
+		else if (parent->pd->indexes[cur_index] >= 0)
 		{
-			result = parent->indexes[cur_index];
+			result = parent->pd->indexes[cur_index];
 			break;
 		}
 		else
-			parent = pd[-parent->indexes[cur_index]];
+			parent = ptrinfos[-parent->pd->indexes[cur_index]];
 	}
 
 error_exit:
diff --git a/src/backend/commands/copy.c b/src/backend/commands/copy.c
index cfa3f059c2..288d6a1ab2 100644
--- a/src/backend/commands/copy.c
+++ b/src/backend/commands/copy.c
@@ -165,8 +165,8 @@ typedef struct CopyStateData
 	bool		volatile_defexprs;	/* is any of defexprs volatile? */
 	List	   *range_table;
 
-	PartitionDispatch *partition_dispatch_info;
-	int			num_dispatch;	/* Number of entries in the above array */
+	PartitionTupleRoutingInfo **ptrinfos;
+	int			num_parted;		/* Number of entries in the above array */
 	int			num_partitions; /* Number of members in the following arrays */
 	ResultRelInfo *partitions;	/* Per partition result relation */
 	TupleConversionMap **partition_tupconv_maps;
@@ -2445,7 +2445,7 @@ CopyFrom(CopyState cstate)
 	 */
 	if (cstate->rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
 	{
-		PartitionDispatch *partition_dispatch_info;
+		PartitionTupleRoutingInfo **ptrinfos;
 		ResultRelInfo *partitions;
 		TupleConversionMap **partition_tupconv_maps;
 		TupleTableSlot *partition_tuple_slot;
@@ -2455,13 +2455,13 @@ CopyFrom(CopyState cstate)
 		ExecSetupPartitionTupleRouting(cstate->rel,
 									   1,
 									   estate,
-									   &partition_dispatch_info,
+									   &ptrinfos,
 									   &partitions,
 									   &partition_tupconv_maps,
 									   &partition_tuple_slot,
 									   &num_parted, &num_partitions);
-		cstate->partition_dispatch_info = partition_dispatch_info;
-		cstate->num_dispatch = num_parted;
+		cstate->ptrinfos = ptrinfos;
+		cstate->num_parted = num_parted;
 		cstate->partitions = partitions;
 		cstate->num_partitions = num_partitions;
 		cstate->partition_tupconv_maps = partition_tupconv_maps;
@@ -2502,7 +2502,7 @@ CopyFrom(CopyState cstate)
 	if ((resultRelInfo->ri_TrigDesc != NULL &&
 		 (resultRelInfo->ri_TrigDesc->trig_insert_before_row ||
 		  resultRelInfo->ri_TrigDesc->trig_insert_instead_row)) ||
-		cstate->partition_dispatch_info != NULL ||
+		cstate->ptrinfos != NULL ||
 		cstate->volatile_defexprs)
 	{
 		useHeapMultiInsert = false;
@@ -2580,7 +2580,7 @@ CopyFrom(CopyState cstate)
 		ExecStoreTuple(tuple, slot, InvalidBuffer, false);
 
 		/* Determine the partition to heap_insert the tuple into */
-		if (cstate->partition_dispatch_info)
+		if (cstate->ptrinfos)
 		{
 			int			leaf_part_index;
 			TupleConversionMap *map;
@@ -2594,7 +2594,7 @@ CopyFrom(CopyState cstate)
 			 * partition, respectively.
 			 */
 			leaf_part_index = ExecFindPartition(resultRelInfo,
-												cstate->partition_dispatch_info,
+												cstate->ptrinfos,
 												slot,
 												estate);
 			Assert(leaf_part_index >= 0 &&
@@ -2826,8 +2826,8 @@ CopyFrom(CopyState cstate)
 
 	ExecCloseIndices(resultRelInfo);
 
-	/* Close all the partitioned tables, leaf partitions, and their indices */
-	if (cstate->partition_dispatch_info)
+	/* Release some resources that we acquired for tuple-routing. */
+	if (cstate->ptrinfos)
 	{
 		int			i;
 
@@ -2837,13 +2837,15 @@ CopyFrom(CopyState cstate)
 		 * the main target table of COPY that will be closed eventually by
 		 * DoCopy().  Also, tupslot is NULL for the root partitioned table.
 		 */
-		for (i = 1; i < cstate->num_dispatch; i++)
+		for (i = 1; i < cstate->num_parted; i++)
 		{
-			PartitionDispatch pd = cstate->partition_dispatch_info[i];
+			PartitionTupleRoutingInfo *ptrinfo = cstate->ptrinfos[i];
 
-			heap_close(pd->reldesc, NoLock);
-			ExecDropSingleTupleTableSlot(pd->tupslot);
+			heap_close(ptrinfo->pd->reldesc, NoLock);
+			ExecDropSingleTupleTableSlot(ptrinfo->tupslot);
 		}
+
+		/* Close all the leaf partitions and their indices */
 		for (i = 0; i < cstate->num_partitions; i++)
 		{
 			ResultRelInfo *resultRelInfo = cstate->partitions + i;
diff --git a/src/backend/executor/execMain.c b/src/backend/executor/execMain.c
index 2946a0edee..23ed2c55b9 100644
--- a/src/backend/executor/execMain.c
+++ b/src/backend/executor/execMain.c
@@ -3236,8 +3236,8 @@ EvalPlanQualEnd(EPQState *epqstate)
  * tuple routing for partitioned tables
  *
  * Output arguments:
- * 'pd' receives an array of PartitionDispatch objects with one entry for
- *		every partitioned table in the partition tree
+ * 'ptrinfos' receives an array of PartitionTupleRoutingInfo objects with one
+ *		entry for each partitioned table in the partition tree
  * 'partitions' receives an array of ResultRelInfo objects with one entry for
  *		every leaf partition in the partition tree
  * 'tup_conv_maps' receives an array of TupleConversionMap objects with one
@@ -3260,7 +3260,7 @@ void
 ExecSetupPartitionTupleRouting(Relation rel,
 							   Index resultRTindex,
 							   EState *estate,
-							   PartitionDispatch **pd,
+							   PartitionTupleRoutingInfo ***ptrinfos,
 							   ResultRelInfo **partitions,
 							   TupleConversionMap ***tup_conv_maps,
 							   TupleTableSlot **partition_tuple_slot,
@@ -3268,16 +3268,84 @@ ExecSetupPartitionTupleRouting(Relation rel,
 {
 	TupleDesc	tupDesc = RelationGetDescr(rel);
 	List	   *leaf_parts;
+	PartitionDispatch *pds;
 	ListCell   *cell;
 	int			i;
 	ResultRelInfo *leaf_part_rri;
+	Relation	parent;
 
 	/*
 	 * Get the information about the partition tree after locking all the
 	 * partitions.
 	 */
 	(void) find_all_inheritors(RelationGetRelid(rel), RowExclusiveLock, NULL);
-	*pd = RelationGetPartitionDispatchInfo(rel, num_parted, &leaf_parts);
+	pds = RelationGetPartitionDispatchInfo(rel, num_parted, &leaf_parts);
+
+	/*
+	 * Construct PartitionTupleRoutingInfo objects, one for each partitioned
+	 * table in the tree, using its PartitionDispatch in the pds array.
+	 */
+	*ptrinfos = (PartitionTupleRoutingInfo **) palloc0(*num_parted *
+										sizeof(PartitionTupleRoutingInfo *));
+	parent = NULL;
+	for (i = 0; i < *num_parted; i++)
+	{
+		PartitionTupleRoutingInfo *ptrinfo;
+
+		ptrinfo = (PartitionTupleRoutingInfo *)
+							palloc0(sizeof(PartitionTupleRoutingInfo));
+		/* Stash a reference to this PartitionDispatch. */
+		ptrinfo->pd = pds[i];
+
+		/* State for extracting partition key from tuples will go here. */
+		ptrinfo->keystate = NIL;
+
+		/*
+		 * For every partitioned table other than root, we must store a tuple
+		 * table slot initialized with its tuple descriptor and a tuple
+		 * conversion map to convert a tuple from its parent's rowtype to its
+		 * own.  That is to make sure that we are looking at the correct row
+		 * using the correct tuple descriptor when computing its partition key
+		 * for tuple routing.
+		 */
+		if (pds[i]->parentoid != InvalidOid)
+		{
+			TupleDesc	tupdesc = RelationGetDescr(pds[i]->reldesc);
+
+			/* Open the parent relation descriptor if not already done. */
+			if (pds[i]->parentoid == RelationGetRelid(rel))
+				parent = rel;
+			else if (parent == NULL)
+				/* Locked by RelationGetPartitionDispatchInfo(). */
+				parent = heap_open(pds[i]->parentoid, NoLock);
+
+			ptrinfo->tupslot = MakeSingleTupleTableSlot(tupdesc);
+			ptrinfo->tupmap = convert_tuples_by_name(RelationGetDescr(parent),
+													 tupdesc,
+								  gettext_noop("could not convert row type"));
+			/*
+			 * Close the parent descriptor, if the next partitioned table in
+			 * the list is not a sibling, because it will have a different
+			 * parent if so.
+			 */
+			if (parent != NULL && parent != rel && i + 1 < *num_parted &&
+				pds[i + 1]->parentoid != pds[i]->parentoid)
+			{
+				heap_close(parent, NoLock);
+				parent = NULL;
+			}
+		}
+		else
+		{
+			/* Not required for the root partitioned table */
+			ptrinfo->tupslot = NULL;
+			ptrinfo->tupmap = NULL;
+		}
+
+		(*ptrinfos)[i] = ptrinfo;
+	}
+
+	/* For leaf partitions, we build ResultRelInfos and TupleConversionMaps. */
 	*num_partitions = list_length(leaf_parts);
 	*partitions = (ResultRelInfo *) palloc(*num_partitions *
 										   sizeof(ResultRelInfo));
@@ -3354,11 +3422,13 @@ ExecSetupPartitionTupleRouting(Relation rel,
  * by get_partition_for_tuple() unchanged.
  */
 int
-ExecFindPartition(ResultRelInfo *resultRelInfo, PartitionDispatch *pd,
-				  TupleTableSlot *slot, EState *estate)
+ExecFindPartition(ResultRelInfo *resultRelInfo,
+				  PartitionTupleRoutingInfo **ptrinfos,
+				  TupleTableSlot *slot,
+				  EState *estate)
 {
 	int			result;
-	PartitionDispatchData *failed_at;
+	PartitionTupleRoutingInfo *failed_at;
 	TupleTableSlot *failed_slot;
 
 	/*
@@ -3368,7 +3438,7 @@ ExecFindPartition(ResultRelInfo *resultRelInfo, PartitionDispatch *pd,
 	if (resultRelInfo->ri_PartitionCheck)
 		ExecPartitionCheck(resultRelInfo, slot, estate);
 
-	result = get_partition_for_tuple(pd, slot, estate,
+	result = get_partition_for_tuple(ptrinfos, slot, estate,
 									 &failed_at, &failed_slot);
 	if (result < 0)
 	{
@@ -3378,7 +3448,7 @@ ExecFindPartition(ResultRelInfo *resultRelInfo, PartitionDispatch *pd,
 		char	   *val_desc;
 		ExprContext *ecxt = GetPerTupleExprContext(estate);
 
-		failed_rel = failed_at->reldesc;
+		failed_rel = failed_at->pd->reldesc;
 		ecxt->ecxt_scantuple = failed_slot;
 		FormPartitionKeyDatum(failed_at, failed_slot, estate,
 							  key_values, key_isnull);
diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c
index e12721a9b6..753ee13985 100644
--- a/src/backend/executor/nodeModifyTable.c
+++ b/src/backend/executor/nodeModifyTable.c
@@ -278,7 +278,7 @@ ExecInsert(ModifyTableState *mtstate,
 	resultRelInfo = estate->es_result_relation_info;
 
 	/* Determine the partition to heap_insert the tuple into */
-	if (mtstate->mt_partition_dispatch_info)
+	if (mtstate->mt_ptrinfos)
 	{
 		int			leaf_part_index;
 		TupleConversionMap *map;
@@ -292,7 +292,7 @@ ExecInsert(ModifyTableState *mtstate,
 		 * respectively.
 		 */
 		leaf_part_index = ExecFindPartition(resultRelInfo,
-											mtstate->mt_partition_dispatch_info,
+											mtstate->mt_ptrinfos,
 											slot,
 											estate);
 		Assert(leaf_part_index >= 0 &&
@@ -1487,7 +1487,7 @@ ExecSetupTransitionCaptureState(ModifyTableState *mtstate, EState *estate)
 		int			numResultRelInfos;
 
 		/* Find the set of partitions so that we can find their TupleDescs. */
-		if (mtstate->mt_partition_dispatch_info != NULL)
+		if (mtstate->mt_ptrinfos != NULL)
 		{
 			/*
 			 * For INSERT via partitioned table, so we need TupleDescs based
@@ -1911,7 +1911,7 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 	if (operation == CMD_INSERT &&
 		rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
 	{
-		PartitionDispatch *partition_dispatch_info;
+		PartitionTupleRoutingInfo **ptrinfos;
 		ResultRelInfo *partitions;
 		TupleConversionMap **partition_tupconv_maps;
 		TupleTableSlot *partition_tuple_slot;
@@ -1921,13 +1921,13 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 		ExecSetupPartitionTupleRouting(rel,
 									   node->nominalRelation,
 									   estate,
-									   &partition_dispatch_info,
+									   &ptrinfos,
 									   &partitions,
 									   &partition_tupconv_maps,
 									   &partition_tuple_slot,
 									   &num_parted, &num_partitions);
-		mtstate->mt_partition_dispatch_info = partition_dispatch_info;
-		mtstate->mt_num_dispatch = num_parted;
+		mtstate->mt_ptrinfos = ptrinfos;
+		mtstate->mt_num_parted = num_parted;
 		mtstate->mt_partitions = partitions;
 		mtstate->mt_num_partitions = num_partitions;
 		mtstate->mt_partition_tupconv_maps = partition_tupconv_maps;
@@ -2336,21 +2336,24 @@ ExecEndModifyTable(ModifyTableState *node)
 														   resultRelInfo);
 	}
 
+	/* Release some resources that we acquired for tuple-routing. */
+
 	/*
-	 * Close all the partitioned tables, leaf partitions, and their indices
-	 *
-	 * Remember node->mt_partition_dispatch_info[0] corresponds to the root
-	 * partitioned table, which we must not try to close, because it is the
-	 * main target table of the query that will be closed by ExecEndPlan().
-	 * Also, tupslot is NULL for the root partitioned table.
+	 * node->mt_ptrinfos[0] corresponds to the root partitioned table, for
+	 * which we didn't create tupslot.  Also, its relation descriptor will
+	 * be closed in ExecEndPlan().
 	 */
-	for (i = 1; i < node->mt_num_dispatch; i++)
+	for (i = 1; i < node->mt_num_parted; i++)
 	{
-		PartitionDispatch pd = node->mt_partition_dispatch_info[i];
+		PartitionTupleRoutingInfo *ptrinfo = node->mt_ptrinfos[i];
 
-		heap_close(pd->reldesc, NoLock);
-		ExecDropSingleTupleTableSlot(pd->tupslot);
+		heap_close(ptrinfo->pd->reldesc, NoLock);
+		ExecDropSingleTupleTableSlot(ptrinfo->tupslot);
 	}
+
+	/*
+	 * Close all the leaf partitions and their indices.
+	 */
 	for (i = 0; i < node->mt_num_partitions; i++)
 	{
 		ResultRelInfo *resultRelInfo = node->mt_partitions + i;
diff --git a/src/include/catalog/partition.h b/src/include/catalog/partition.h
index 2283c675e9..1091dd572c 100644
--- a/src/include/catalog/partition.h
+++ b/src/include/catalog/partition.h
@@ -45,13 +45,8 @@ typedef struct PartitionDescData *PartitionDesc;
  *
  *	reldesc		Relation descriptor of the table
  *	key			Partition key information of the table
- *	keystate	Execution state required for expressions in the partition key
  *	partdesc	Partition descriptor of the table
- *	tupslot		A standalone TupleTableSlot initialized with this table's tuple
- *				descriptor
- *	tupmap		TupleConversionMap to convert from the parent's rowtype to
- *				this table's rowtype (when extracting the partition key of a
- *				tuple just before routing it through this table)
+ *	parentoid	OID of the parent table (InvalidOid if root partitioned table)
  *	indexes		Array with partdesc->nparts members (for details on what
  *				individual members represent, see how they are set in
  *				RelationGetPartitionDispatchInfo())
@@ -61,10 +56,8 @@ typedef struct PartitionDispatchData
 {
 	Relation	reldesc;
 	PartitionKey key;
-	List	   *keystate;		/* list of ExprState */
 	PartitionDesc partdesc;
-	TupleTableSlot *tupslot;
-	TupleConversionMap *tupmap;
+	Oid			parentoid;
 	int		   *indexes;
 } PartitionDispatchData;
 
@@ -86,17 +79,18 @@ extern List *map_partition_varattnos(List *expr, int target_varno,
 extern List *RelationGetPartitionQual(Relation rel);
 extern Expr *get_partition_qual_relid(Oid relid);
 
-/* For tuple routing */
 extern PartitionDispatch *RelationGetPartitionDispatchInfo(Relation rel,
 								 int *num_parted, List **leaf_part_oids);
-extern void FormPartitionKeyDatum(PartitionDispatch pd,
+
+/* For tuple routing */
+extern void FormPartitionKeyDatum(PartitionTupleRoutingInfo *ptrinfo,
 					  TupleTableSlot *slot,
 					  EState *estate,
 					  Datum *values,
 					  bool *isnull);
-extern int get_partition_for_tuple(PartitionDispatch *pd,
+extern int get_partition_for_tuple(PartitionTupleRoutingInfo **ptrinfos,
 						TupleTableSlot *slot,
 						EState *estate,
-						PartitionDispatchData **failed_at,
+						PartitionTupleRoutingInfo **failed_at,
 						TupleTableSlot **failed_slot);
 #endif							/* PARTITION_H */
diff --git a/src/include/executor/executor.h b/src/include/executor/executor.h
index f48a603dae..04422e1a6f 100644
--- a/src/include/executor/executor.h
+++ b/src/include/executor/executor.h
@@ -209,13 +209,13 @@ extern HeapTuple EvalPlanQualGetTuple(EPQState *epqstate, Index rti);
 extern void ExecSetupPartitionTupleRouting(Relation rel,
 							   Index resultRTindex,
 							   EState *estate,
-							   PartitionDispatch **pd,
+							   PartitionTupleRoutingInfo ***ptrinfos,
 							   ResultRelInfo **partitions,
 							   TupleConversionMap ***tup_conv_maps,
 							   TupleTableSlot **partition_tuple_slot,
 							   int *num_parted, int *num_partitions);
 extern int ExecFindPartition(ResultRelInfo *resultRelInfo,
-				  PartitionDispatch *pd,
+				  PartitionTupleRoutingInfo **ptrinfos,
 				  TupleTableSlot *slot,
 				  EState *estate);
 
diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h
index d1565e7496..c0925c5f76 100644
--- a/src/include/nodes/execnodes.h
+++ b/src/include/nodes/execnodes.h
@@ -414,6 +414,42 @@ typedef struct ResultRelInfo
 	Relation	ri_PartitionRoot;
 } ResultRelInfo;
 
+/* Forward declarations, to avoid including other headers */
+typedef struct PartitionDispatchData *PartitionDispatch;
+
+/*
+ * PartitionTupleRoutingInfo - information required for tuple-routing
+ *							   through one partitioned table in a partition
+ *							   tree
+ */
+typedef struct PartitionTupleRoutingInfo
+{
+
+	/* Information about the table's partitions */
+	PartitionDispatch	pd;
+
+	/*
+	 * The execution state required for expressions contained in the partition
+	 * key.  It is NIL until initialized by FormPartitionKeyDatum() if and when
+	 * it is called; for example, the first time a tuple is routed through this
+	 * table.
+	 */
+	List   *keystate;
+
+	/*
+	 * A standalone TupleTableSlot initialized with this table's tuple
+	 * descriptor
+	 */
+	TupleTableSlot *tupslot;
+
+	/*
+	 * TupleConversionMap to convert from the parent's rowtype to this table's
+	 * rowtype (when extracting the partition key of a tuple just before
+	 * routing it through this table)
+	 */
+	TupleConversionMap *tupmap;
+} PartitionTupleRoutingInfo;
+
 /* ----------------
  *	  EState information
  *
@@ -973,9 +1009,9 @@ typedef struct ModifyTableState
 	TupleTableSlot *mt_existing;	/* slot to store existing target tuple in */
 	List	   *mt_excludedtlist;	/* the excluded pseudo relation's tlist  */
 	TupleTableSlot *mt_conflproj;	/* CONFLICT ... SET ... projection target */
-	struct PartitionDispatchData **mt_partition_dispatch_info;
 	/* Tuple-routing support info */
-	int			mt_num_dispatch;	/* Number of entries in the above array */
+	struct PartitionTupleRoutingInfo **mt_ptrinfos;
+	int			mt_num_parted;		/* Number of entries in the above array */
 	int			mt_num_partitions;	/* Number of members in the following
 									 * arrays */
 	ResultRelInfo *mt_partitions;	/* Per partition result relation */
-- 
2.11.0

From 2d77335d834e5a20fb0f07c13d647f74e0f39082 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Wed, 9 Aug 2017 15:52:36 +0900
Subject: [PATCH 2/2] Teach expand_inherited_rtentry to use partition bound
 order

After locking the child tables using find_all_inheritors, we discard
the list of child table OIDs that it generates and rebuild the same
using the information returned by RelationGetPartitionDispatchInfo.
---
 src/backend/optimizer/prep/prepunion.c | 35 ++++++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)

diff --git a/src/backend/optimizer/prep/prepunion.c b/src/backend/optimizer/prep/prepunion.c
index e73c819901..2202ad9941 100644
--- a/src/backend/optimizer/prep/prepunion.c
+++ b/src/backend/optimizer/prep/prepunion.c
@@ -33,6 +33,7 @@
 #include "access/heapam.h"
 #include "access/htup_details.h"
 #include "access/sysattr.h"
+#include "catalog/partition.h"
 #include "catalog/pg_inherits_fn.h"
 #include "catalog/pg_type.h"
 #include "miscadmin.h"
@@ -1452,6 +1453,40 @@ expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti)
 	 */
 	oldrelation = heap_open(parentOID, NoLock);
 
+	/*
+	 * For partitioned tables, we arrange the child table OIDs such that they
+	 * appear in the partition bound order.
+	 */
+	if (rte->relkind == RELKIND_PARTITIONED_TABLE)
+	{
+		List   *leaf_part_oids;
+		int		num_parted,
+				i;
+		PartitionDispatch *pds;
+
+		/* Discard the original list. */
+		list_free(inhOIDs);
+		inhOIDs = NIL;
+
+		/* Request partitioning information. */
+		pds = RelationGetPartitionDispatchInfo(oldrelation, &num_parted,
+											   &leaf_part_oids);
+
+		/*
+		 * First collect the partitioned child table OIDs, which includes the
+		 * root parent at the head.
+		 */
+		for (i = 0; i < num_parted; i++)
+		{
+			inhOIDs = lappend_oid(inhOIDs, RelationGetRelid(pds[i]->reldesc));
+			if (pds[i]->reldesc != oldrelation)
+				heap_close(pds[i]->reldesc, NoLock);
+		}
+
+		/* Concatenate the leaf partition OIDs. */
+		inhOIDs = list_concat(inhOIDs, leaf_part_oids);
+	}
+
 	/* Scan the inheritance set and expand it */
 	appinfos = NIL;
 	has_child = false;
-- 
2.11.0

From 6adb696b45bd2bc6814adf52851508706b27f0ad Mon Sep 17 00:00:00 2001
From: Robert Haas <rhaas@postgresql.org>
Date: Wed, 30 Aug 2017 12:53:43 -0400
Subject: [PATCH 1/2] expand_single_inheritance_child

---
 src/backend/optimizer/prep/prepunion.c | 225 +++++++++++++++++++--------------
 1 file changed, 127 insertions(+), 98 deletions(-)

diff --git a/src/backend/optimizer/prep/prepunion.c b/src/backend/optimizer/prep/prepunion.c
index e73c819901..870a4a6bfd 100644
--- a/src/backend/optimizer/prep/prepunion.c
+++ b/src/backend/optimizer/prep/prepunion.c
@@ -100,6 +100,12 @@ 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_single_inheritance_child(PlannerInfo *root,
+								RangeTblEntry *rte,
+								Index rti, Relation oldrelation,
+								PlanRowMark *oldrc, Relation newrelation,
+								bool *has_child, List **appinfos,
+								List **partitioned_child_rels);
 static void make_inh_translation_list(Relation oldrelation,
 						  Relation newrelation,
 						  Index newvarno,
@@ -1459,9 +1465,6 @@ expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti)
 	{
 		Oid			childOID = lfirst_oid(l);
 		Relation	newrelation;
-		RangeTblEntry *childrte;
-		Index		childRTindex;
-		AppendRelInfo *appinfo;
 
 		/* Open rel if needed; we already have required locks */
 		if (childOID != parentOID)
@@ -1481,101 +1484,10 @@ expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti)
 			continue;
 		}
 
-		/*
-		 * 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(rte);
-		childrte->relid = childOID;
-		childrte->relkind = newrelation->rd_rel->relkind;
-		childrte->inh = false;
-		childrte->requiredPerms = 0;
-		childrte->securityQuals = NIL;
-		parse->rtable = lappend(parse->rtable, childrte);
-		childRTindex = list_length(parse->rtable);
-
-		/*
-		 * Build an AppendRelInfo for this parent and child, unless the child
-		 * is a partitioned table.
-		 */
-		if (childrte->relkind != RELKIND_PARTITIONED_TABLE)
-		{
-			/* Remember if we saw a real child. */
-			if (childOID != parentOID)
-				has_child = true;
-
-			appinfo = makeNode(AppendRelInfo);
-			appinfo->parent_relid = rti;
-			appinfo->child_relid = childRTindex;
-			appinfo->parent_reltype = oldrelation->rd_rel->reltype;
-			appinfo->child_reltype = newrelation->rd_rel->reltype;
-			make_inh_translation_list(oldrelation, newrelation, 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(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);
-			}
-		}
-		else
-			partitioned_child_rels = lappend_int(partitioned_child_rels,
-												 childRTindex);
-
-		/*
-		 * Build a PlanRowMark if parent is marked FOR UPDATE/SHARE.
-		 */
-		if (oldrc)
-		{
-			PlanRowMark *newrc = makeNode(PlanRowMark);
-
-			newrc->rti = childRTindex;
-			newrc->prti = rti;
-			newrc->rowmarkId = oldrc->rowmarkId;
-			/* Reselect rowmark type, because relkind might not match parent */
-			newrc->markType = select_rowmark_type(childrte, oldrc->strength);
-			newrc->allMarkTypes = (1 << newrc->markType);
-			newrc->strength = oldrc->strength;
-			newrc->waitPolicy = oldrc->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).
-			 */
-			newrc->isParent = (childrte->relkind == RELKIND_PARTITIONED_TABLE);
-
-			/* Include child's rowmark type in parent's allMarkTypes */
-			oldrc->allMarkTypes |= newrc->allMarkTypes;
-
-			root->rowMarks = lappend(root->rowMarks, newrc);
-		}
+		expand_single_inheritance_child(root, rte, rti, oldrelation, oldrc,
+										newrelation,
+										&has_child, &appinfos,
+										&partitioned_child_rels);
 
 		/* Close child relations, but keep locks */
 		if (childOID != parentOID)
@@ -1621,6 +1533,123 @@ expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti)
 }
 
 /*
+ * expand_single_inheritance_child
+ *		Expand a single inheritance child, if needed.
+ *
+ * If this is a temp table of another backend, we'll return without doing
+ * anything at all.  Otherwise, we'll build a RangeTblEntry and either a
+ * PartitionedChildRelInfo or AppendRelInfo as appropriate, plus maybe a
+ * PlanRowMark.
+ */
+static void
+expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *rte,
+								Index rti, Relation oldrelation,
+								PlanRowMark *oldrc, Relation newrelation,
+								bool *has_child, List **appinfos,
+								List **partitioned_child_rels)
+{
+	Query	   *parse = root->parse;
+	Oid			parentOID = RelationGetRelid(oldrelation);
+	Oid			childOID = RelationGetRelid(newrelation);
+	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(rte);
+	childrte->relid = childOID;
+	childrte->relkind = newrelation->rd_rel->relkind;
+	childrte->inh = false;
+	childrte->requiredPerms = 0;
+	childrte->securityQuals = NIL;
+	parse->rtable = lappend(parse->rtable, childrte);
+	childRTindex = list_length(parse->rtable);
+
+	/*
+	 * Build an AppendRelInfo for this parent and child, unless the child is a
+	 * partitioned table.
+	 */
+	if (childrte->relkind != RELKIND_PARTITIONED_TABLE)
+	{
+		/* Remember if we saw a real child. */
+		if (childOID != parentOID)
+			*has_child = true;
+
+		appinfo = makeNode(AppendRelInfo);
+		appinfo->parent_relid = rti;
+		appinfo->child_relid = childRTindex;
+		appinfo->parent_reltype = oldrelation->rd_rel->reltype;
+		appinfo->child_reltype = newrelation->rd_rel->reltype;
+		make_inh_translation_list(oldrelation, newrelation, 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(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);
+		}
+	}
+	else
+		*partitioned_child_rels = lappend_int(*partitioned_child_rels,
+											  childRTindex);
+
+	/*
+	 * Build a PlanRowMark if parent is marked FOR UPDATE/SHARE.
+	 */
+	if (oldrc)
+	{
+		PlanRowMark *newrc = makeNode(PlanRowMark);
+
+		newrc->rti = childRTindex;
+		newrc->prti = rti;
+		newrc->rowmarkId = oldrc->rowmarkId;
+		/* Reselect rowmark type, because relkind might not match parent */
+		newrc->markType = select_rowmark_type(childrte, oldrc->strength);
+		newrc->allMarkTypes = (1 << newrc->markType);
+		newrc->strength = oldrc->strength;
+		newrc->waitPolicy = oldrc->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).
+		 */
+		newrc->isParent = (childrte->relkind == RELKIND_PARTITIONED_TABLE);
+
+		/* Include child's rowmark type in parent's allMarkTypes */
+		oldrc->allMarkTypes |= newrc->allMarkTypes;
+
+		root->rowMarks = lappend(root->rowMarks, newrc);
+	}
+}
+
+/*
  * make_inh_translation_list
  *	  Build the list of translations from parent Vars to child Vars for
  *	  an inheritance child.
-- 
2.11.0 (Apple Git-81)

From a0b1b7c2eadaebd236c48d9017effdf7c20fafc4 Mon Sep 17 00:00:00 2001
From: Robert Haas <rhaas@postgresql.org>
Date: Wed, 30 Aug 2017 15:22:08 -0400
Subject: [PATCH 2/2] EIBO

---
 src/backend/optimizer/prep/prepunion.c | 126 ++++++++++++++++++++++++++-------
 src/test/regress/expected/insert.out   |   4 +-
 2 files changed, 104 insertions(+), 26 deletions(-)

diff --git a/src/backend/optimizer/prep/prepunion.c b/src/backend/optimizer/prep/prepunion.c
index 870a4a6bfd..3f5138f54e 100644
--- a/src/backend/optimizer/prep/prepunion.c
+++ b/src/backend/optimizer/prep/prepunion.c
@@ -33,6 +33,7 @@
 #include "access/heapam.h"
 #include "access/htup_details.h"
 #include "access/sysattr.h"
+#include "catalog/partition.h"
 #include "catalog/pg_inherits_fn.h"
 #include "catalog/pg_type.h"
 #include "miscadmin.h"
@@ -100,6 +101,13 @@ 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_partitions_recursively(PlannerInfo *root,
+							  RangeTblEntry *rte,
+							  Index rti, Relation oldrelation,
+							  PlanRowMark *oldrc, PartitionDesc partdesc,
+							  LOCKMODE lockmode,
+							  bool *has_child, List **appinfos,
+							  List **partitioned_child_rels);
 static void expand_single_inheritance_child(PlannerInfo *root,
 								RangeTblEntry *rte,
 								Index rti, Relation oldrelation,
@@ -1461,37 +1469,62 @@ expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti)
 	/* Scan the inheritance set and expand it */
 	appinfos = NIL;
 	has_child = false;
-	foreach(l, inhOIDs)
+	if (RelationGetPartitionDesc(oldrelation) != NULL)
 	{
-		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 this table has partitions, recursively expand them in the order
+		 * in which they appear in the PartitionDesc.  But first, expand the
+		 * parent itself.
 		 */
-		if (childOID != parentOID && RELATION_IS_OTHER_TEMP(newrelation))
-		{
-			heap_close(newrelation, lockmode);
-			continue;
-		}
-
 		expand_single_inheritance_child(root, rte, rti, oldrelation, oldrc,
-										newrelation,
+										oldrelation,
 										&has_child, &appinfos,
 										&partitioned_child_rels);
+		expand_partitions_recursively(root, rte, rti, oldrelation, oldrc,
+									  RelationGetPartitionDesc(oldrelation),
+									  lockmode,
+									  &has_child, &appinfos,
+									  &partitioned_child_rels);
+	}
+	else
+	{
+		/*
+		 * 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;
 
-		/* Close child relations, but keep locks */
-		if (childOID != parentOID)
-			heap_close(newrelation, NoLock);
+			/* 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,
+											&has_child, &appinfos,
+											&partitioned_child_rels);
+
+			/* Close child relations, but keep locks */
+			if (childOID != parentOID)
+				heap_close(newrelation, NoLock);
+		}
 	}
 
 	heap_close(oldrelation, NoLock);
@@ -1532,6 +1565,51 @@ expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti)
 	root->append_rel_list = list_concat(root->append_rel_list, appinfos);
 }
 
+static void
+expand_partitions_recursively(PlannerInfo *root, RangeTblEntry *rte,
+							  Index rti, Relation oldrelation,
+							  PlanRowMark *oldrc, PartitionDesc partdesc,
+							  LOCKMODE lockmode,
+							  bool *has_child, List **appinfos,
+							  List **partitioned_child_rels)
+{
+	int			i;
+
+	check_stack_depth();
+
+	for (i = 0; i < partdesc->nparts; i++)
+	{
+		Oid			childOID = partdesc->oids[i];
+		Relation	newrelation;
+
+		/* Open rel; we already have required locks */
+		newrelation = heap_open(childOID, NoLock);
+
+		/* As in expand_inherited_rtentry, skip non-local temp tables */
+		if (RELATION_IS_OTHER_TEMP(newrelation))
+		{
+			heap_close(newrelation, lockmode);
+			continue;
+		}
+
+		expand_single_inheritance_child(root, rte, rti, oldrelation, oldrc,
+										newrelation,
+										has_child, appinfos,
+										partitioned_child_rels);
+
+		/* If this child is itself partitioned, recurse */
+		if (newrelation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
+			expand_partitions_recursively(root, rte, rti, oldrelation, oldrc,
+										  RelationGetPartitionDesc(newrelation),
+										  lockmode,
+										  has_child, appinfos,
+										  partitioned_child_rels);
+
+		/* Close child relation, but keep locks */
+		heap_close(newrelation, NoLock);
+	}
+}
+
 /*
  * expand_single_inheritance_child
  *		Expand a single inheritance child, if needed.
diff --git a/src/test/regress/expected/insert.out b/src/test/regress/expected/insert.out
index a2d9469592..e159d62b66 100644
--- a/src/test/regress/expected/insert.out
+++ b/src/test/regress/expected/insert.out
@@ -278,12 +278,12 @@ select tableoid::regclass, * from list_parted;
 -------------+----+----
  part_aa_bb  | aA |   
  part_cc_dd  | cC |  1
- part_null   |    |  0
- part_null   |    |  1
  part_ee_ff1 | ff |  1
  part_ee_ff1 | EE |  1
  part_ee_ff2 | ff | 11
  part_ee_ff2 | EE | 10
+ part_null   |    |  0
+ part_null   |    |  1
 (8 rows)
 
 -- some more tests to exercise tuple-routing with multi-level partitioning
-- 
2.11.0 (Apple Git-81)

From ed494bff369e43ff92128b9bd9c553eb19dffdc6 Mon Sep 17 00:00:00 2001
From: Robert Haas <rhaas@postgresql.org>
Date: Wed, 30 Aug 2017 12:53:43 -0400
Subject: [PATCH 1/2] expand_single_inheritance_child by Robert

with

My changes to Rename arguments to and variables in
expand_single_inheritance_child() in accordance to their usage in the
function.
---
 src/backend/optimizer/prep/prepunion.c |  225 ++++++++++++++++++--------------
 1 file changed, 127 insertions(+), 98 deletions(-)

diff --git a/src/backend/optimizer/prep/prepunion.c b/src/backend/optimizer/prep/prepunion.c
index e73c819..bb8f1ce 100644
--- a/src/backend/optimizer/prep/prepunion.c
+++ b/src/backend/optimizer/prep/prepunion.c
@@ -100,6 +100,12 @@ 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_single_inheritance_child(PlannerInfo *root,
+								RangeTblEntry *parentrte,
+								Index parentRTindex, Relation parentrel,
+								PlanRowMark *parentrc, Relation childrel,
+								bool *has_child, List **appinfos,
+								List **partitioned_child_rels);
 static void make_inh_translation_list(Relation oldrelation,
 						  Relation newrelation,
 						  Index newvarno,
@@ -1459,9 +1465,6 @@ expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti)
 	{
 		Oid			childOID = lfirst_oid(l);
 		Relation	newrelation;
-		RangeTblEntry *childrte;
-		Index		childRTindex;
-		AppendRelInfo *appinfo;
 
 		/* Open rel if needed; we already have required locks */
 		if (childOID != parentOID)
@@ -1481,101 +1484,10 @@ expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti)
 			continue;
 		}
 
-		/*
-		 * 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(rte);
-		childrte->relid = childOID;
-		childrte->relkind = newrelation->rd_rel->relkind;
-		childrte->inh = false;
-		childrte->requiredPerms = 0;
-		childrte->securityQuals = NIL;
-		parse->rtable = lappend(parse->rtable, childrte);
-		childRTindex = list_length(parse->rtable);
-
-		/*
-		 * Build an AppendRelInfo for this parent and child, unless the child
-		 * is a partitioned table.
-		 */
-		if (childrte->relkind != RELKIND_PARTITIONED_TABLE)
-		{
-			/* Remember if we saw a real child. */
-			if (childOID != parentOID)
-				has_child = true;
-
-			appinfo = makeNode(AppendRelInfo);
-			appinfo->parent_relid = rti;
-			appinfo->child_relid = childRTindex;
-			appinfo->parent_reltype = oldrelation->rd_rel->reltype;
-			appinfo->child_reltype = newrelation->rd_rel->reltype;
-			make_inh_translation_list(oldrelation, newrelation, 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(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);
-			}
-		}
-		else
-			partitioned_child_rels = lappend_int(partitioned_child_rels,
-												 childRTindex);
-
-		/*
-		 * Build a PlanRowMark if parent is marked FOR UPDATE/SHARE.
-		 */
-		if (oldrc)
-		{
-			PlanRowMark *newrc = makeNode(PlanRowMark);
-
-			newrc->rti = childRTindex;
-			newrc->prti = rti;
-			newrc->rowmarkId = oldrc->rowmarkId;
-			/* Reselect rowmark type, because relkind might not match parent */
-			newrc->markType = select_rowmark_type(childrte, oldrc->strength);
-			newrc->allMarkTypes = (1 << newrc->markType);
-			newrc->strength = oldrc->strength;
-			newrc->waitPolicy = oldrc->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).
-			 */
-			newrc->isParent = (childrte->relkind == RELKIND_PARTITIONED_TABLE);
-
-			/* Include child's rowmark type in parent's allMarkTypes */
-			oldrc->allMarkTypes |= newrc->allMarkTypes;
-
-			root->rowMarks = lappend(root->rowMarks, newrc);
-		}
+		expand_single_inheritance_child(root, rte, rti, oldrelation, oldrc,
+										newrelation,
+										&has_child, &appinfos,
+										&partitioned_child_rels);
 
 		/* Close child relations, but keep locks */
 		if (childOID != parentOID)
@@ -1621,6 +1533,123 @@ expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti)
 }
 
 /*
+ * expand_single_inheritance_child
+ *		Expand a single inheritance child, if needed.
+ *
+ * If this is a temp table of another backend, we'll return without doing
+ * anything at all.  Otherwise, we'll set "has_child" to true, build a
+ * RangeTblEntry and either a PartitionedChildRelInfo or AppendRelInfo as
+ * appropriate, plus maybe a PlanRowMark.
+ */
+static void
+expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte,
+								Index parentRTindex, Relation parentrel,
+								PlanRowMark *parentrc, Relation childrel,
+								bool *has_child, List **appinfos,
+								List **partitioned_child_rels)
+{
+	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->relid = childOID;
+	childrte->relkind = childrel->rd_rel->relkind;
+	childrte->inh = false;
+	childrte->requiredPerms = 0;
+	childrte->securityQuals = NIL;
+	parse->rtable = lappend(parse->rtable, childrte);
+	childRTindex = list_length(parse->rtable);
+
+	/*
+	 * Build an AppendRelInfo for this parent and child, unless the child is a
+	 * partitioned table.
+	 */
+	if (childrte->relkind != RELKIND_PARTITIONED_TABLE)
+	{
+		/* Remember if we saw a real child. */
+		if (childOID != parentOID)
+			*has_child = true;
+
+		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);
+		}
+	}
+	else
+		*partitioned_child_rels = lappend_int(*partitioned_child_rels,
+											  childRTindex);
+
+	/*
+	 * Build a PlanRowMark if parent is marked FOR UPDATE/SHARE.
+	 */
+	if (parentrc)
+	{
+		PlanRowMark *childrc = makeNode(PlanRowMark);
+
+		childrc->rti = childRTindex;
+		childrc->prti = parentRTindex;
+		childrc->rowmarkId = parentrc->rowmarkId;
+		/* Reselect rowmark type, because relkind might not match parent */
+		childrc->markType = select_rowmark_type(childrte, parentrc->strength);
+		childrc->allMarkTypes = (1 << childrc->markType);
+		childrc->strength = parentrc->strength;
+		childrc->waitPolicy = 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 parent's allMarkTypes */
+		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.
-- 
1.7.9.5

From faac5b1261497c5cceb246bc7d52cdaff2ac5057 Mon Sep 17 00:00:00 2001
From: Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
Date: Thu, 31 Aug 2017 11:40:11 +0530
Subject: [PATCH 2/2] EIBO patch from Robert

with

my changes to rename arguements to and variables in
expand_partitions_recursively(). Also rename expand_partitions_recursively() to
expand_partitioned_rtentry() inline with expand_inherited_rtentry().
---
 src/backend/optimizer/prep/prepunion.c |  127 ++++++++++++++++++++++++++------
 src/test/regress/expected/insert.out   |    4 +-
 2 files changed, 105 insertions(+), 26 deletions(-)

diff --git a/src/backend/optimizer/prep/prepunion.c b/src/backend/optimizer/prep/prepunion.c
index bb8f1ce..ccf2145 100644
--- a/src/backend/optimizer/prep/prepunion.c
+++ b/src/backend/optimizer/prep/prepunion.c
@@ -33,6 +33,7 @@
 #include "access/heapam.h"
 #include "access/htup_details.h"
 #include "access/sysattr.h"
+#include "catalog/partition.h"
 #include "catalog/pg_inherits_fn.h"
 #include "catalog/pg_type.h"
 #include "miscadmin.h"
@@ -100,6 +101,13 @@ 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 *parentrc, PartitionDesc partdesc,
+						   LOCKMODE lockmode,
+						   bool *has_child, List **appinfos,
+						   List **partitioned_child_rels);
 static void expand_single_inheritance_child(PlannerInfo *root,
 								RangeTblEntry *parentrte,
 								Index parentRTindex, Relation parentrel,
@@ -1461,37 +1469,62 @@ expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti)
 	/* Scan the inheritance set and expand it */
 	appinfos = NIL;
 	has_child = false;
-	foreach(l, inhOIDs)
+	if (RelationGetPartitionDesc(oldrelation) != NULL)
 	{
-		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 this table has partitions, recursively expand them in the order
+		 * in which they appear in the PartitionDesc.  But first, expand the
+		 * parent itself.
 		 */
-		if (childOID != parentOID && RELATION_IS_OTHER_TEMP(newrelation))
-		{
-			heap_close(newrelation, lockmode);
-			continue;
-		}
-
 		expand_single_inheritance_child(root, rte, rti, oldrelation, oldrc,
-										newrelation,
+										oldrelation,
 										&has_child, &appinfos,
 										&partitioned_child_rels);
+		expand_partitioned_rtentry(root, rte, rti, oldrelation, oldrc,
+									  RelationGetPartitionDesc(oldrelation),
+									  lockmode,
+									  &has_child, &appinfos,
+									  &partitioned_child_rels);
+	}
+	else
+	{
+		/*
+		 * 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;
 
-		/* Close child relations, but keep locks */
-		if (childOID != parentOID)
-			heap_close(newrelation, NoLock);
+			/* 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,
+											&has_child, &appinfos,
+											&partitioned_child_rels);
+
+			/* Close child relations, but keep locks */
+			if (childOID != parentOID)
+				heap_close(newrelation, NoLock);
+		}
 	}
 
 	heap_close(oldrelation, NoLock);
@@ -1532,6 +1565,52 @@ expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti)
 	root->append_rel_list = list_concat(root->append_rel_list, appinfos);
 }
 
+static void
+expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte,
+						   Index parentRTindex, Relation parentrel,
+						   PlanRowMark *parentrc, PartitionDesc partdesc,
+						   LOCKMODE lockmode,
+						   bool *has_child, List **appinfos,
+						   List **partitioned_child_rels)
+{
+	int			i;
+
+	check_stack_depth();
+
+	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);
+
+		/* As in expand_inherited_rtentry, skip non-local temp tables */
+		if (RELATION_IS_OTHER_TEMP(childrel))
+		{
+			heap_close(childrel, lockmode);
+			continue;
+		}
+
+		expand_single_inheritance_child(root, parentrte, parentRTindex,
+										parentrel, parentrc, childrel,
+										has_child, appinfos,
+										partitioned_child_rels);
+
+		/* If this child is itself partitioned, recurse */
+		if (childrel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
+			expand_partitioned_rtentry(root, parentrte, parentRTindex,
+										  parentrel, parentrc,
+										  RelationGetPartitionDesc(childrel),
+										  lockmode,
+										  has_child, appinfos,
+										  partitioned_child_rels);
+
+		/* Close child relation, but keep locks */
+		heap_close(childrel, NoLock);
+	}
+}
+
 /*
  * expand_single_inheritance_child
  *		Expand a single inheritance child, if needed.
diff --git a/src/test/regress/expected/insert.out b/src/test/regress/expected/insert.out
index a2d9469..e159d62 100644
--- a/src/test/regress/expected/insert.out
+++ b/src/test/regress/expected/insert.out
@@ -278,12 +278,12 @@ select tableoid::regclass, * from list_parted;
 -------------+----+----
  part_aa_bb  | aA |   
  part_cc_dd  | cC |  1
- part_null   |    |  0
- part_null   |    |  1
  part_ee_ff1 | ff |  1
  part_ee_ff1 | EE |  1
  part_ee_ff2 | ff | 11
  part_ee_ff2 | EE | 10
+ part_null   |    |  0
+ part_null   |    |  1
 (8 rows)
 
 -- some more tests to exercise tuple-routing with multi-level partitioning
-- 
1.7.9.5

From 6956ac321df169f6c26c383ddcb5ea48c1a0071b Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Wed, 30 Aug 2017 10:02:05 +0900
Subject: [PATCH 1/3] Decouple RelationGetPartitionDispatchInfo() from executor

Currently it and the structure it generates viz. PartitionDispatch
objects are too coupled with the executor's tuple-routing code.  In
particular, it's pretty undesirable that it makes it the responsibility
of the caller to release some resources, such as executor tuple table
slots, tuple-conversion maps, etc.  That makes it harder to use in
places other than where it's currently being used.

After this refactoring, ExecSetupPartitionTupleRouting() now needs to
do some of the work that was previously done in
RelationGetPartitionDispatchInfo().
---
 src/backend/catalog/partition.c        | 53 +++++++-------------
 src/backend/commands/copy.c            | 32 +++++++------
 src/backend/executor/execMain.c        | 88 ++++++++++++++++++++++++++++++----
 src/backend/executor/nodeModifyTable.c | 37 +++++++-------
 src/include/catalog/partition.h        | 20 +++-----
 src/include/executor/executor.h        |  4 +-
 src/include/nodes/execnodes.h          | 40 +++++++++++++++-
 7 files changed, 181 insertions(+), 93 deletions(-)

diff --git a/src/backend/catalog/partition.c b/src/backend/catalog/partition.c
index c6bd02f77d..4f594243d3 100644
--- a/src/backend/catalog/partition.c
+++ b/src/backend/catalog/partition.c
@@ -1061,7 +1061,6 @@ RelationGetPartitionDispatchInfo(Relation rel,
 		Relation	partrel = lfirst(lc1);
 		Relation	parent = lfirst(lc2);
 		PartitionKey partkey = RelationGetPartitionKey(partrel);
-		TupleDesc	tupdesc = RelationGetDescr(partrel);
 		PartitionDesc partdesc = RelationGetPartitionDesc(partrel);
 		int			j,
 					m;
@@ -1069,29 +1068,12 @@ RelationGetPartitionDispatchInfo(Relation rel,
 		pd[i] = (PartitionDispatch) palloc(sizeof(PartitionDispatchData));
 		pd[i]->reldesc = partrel;
 		pd[i]->key = partkey;
-		pd[i]->keystate = NIL;
 		pd[i]->partdesc = partdesc;
 		if (parent != NULL)
-		{
-			/*
-			 * For every partitioned table other than root, we must store a
-			 * tuple table slot initialized with its tuple descriptor and a
-			 * tuple conversion map to convert a tuple from its parent's
-			 * rowtype to its own. That is to make sure that we are looking at
-			 * the correct row using the correct tuple descriptor when
-			 * computing its partition key for tuple routing.
-			 */
-			pd[i]->tupslot = MakeSingleTupleTableSlot(tupdesc);
-			pd[i]->tupmap = convert_tuples_by_name(RelationGetDescr(parent),
-												   tupdesc,
-												   gettext_noop("could not convert row type"));
-		}
+			pd[i]->parentoid = RelationGetRelid(parent);
 		else
-		{
-			/* Not required for the root partitioned table */
-			pd[i]->tupslot = NULL;
-			pd[i]->tupmap = NULL;
-		}
+			pd[i]->parentoid = InvalidOid;
+
 		pd[i]->indexes = (int *) palloc(partdesc->nparts * sizeof(int));
 
 		/*
@@ -1840,7 +1822,7 @@ generate_partition_qual(Relation rel)
  *			Construct values[] and isnull[] arrays for the partition key
  *			of a tuple.
  *
- *	pd				Partition dispatch object of the partitioned table
+ *	ptrinfo			PartitionTupleRoutingInfo object of the table
  *	slot			Heap tuple from which to extract partition key
  *	estate			executor state for evaluating any partition key
  *					expressions (must be non-NULL)
@@ -1852,26 +1834,27 @@ generate_partition_qual(Relation rel)
  * ----------------
  */
 void
-FormPartitionKeyDatum(PartitionDispatch pd,
+FormPartitionKeyDatum(PartitionTupleRoutingInfo *ptrinfo,
 					  TupleTableSlot *slot,
 					  EState *estate,
 					  Datum *values,
 					  bool *isnull)
 {
+	PartitionDispatch	pd = ptrinfo->pd;
 	ListCell   *partexpr_item;
 	int			i;
 
-	if (pd->key->partexprs != NIL && pd->keystate == NIL)
+	if (pd->key->partexprs != NIL && ptrinfo->keystate == NIL)
 	{
 		/* Check caller has set up context correctly */
 		Assert(estate != NULL &&
 			   GetPerTupleExprContext(estate)->ecxt_scantuple == slot);
 
 		/* First time through, set up expression evaluation state */
-		pd->keystate = ExecPrepareExprList(pd->key->partexprs, estate);
+		ptrinfo->keystate = ExecPrepareExprList(pd->key->partexprs, estate);
 	}
 
-	partexpr_item = list_head(pd->keystate);
+	partexpr_item = list_head(ptrinfo->keystate);
 	for (i = 0; i < pd->key->partnatts; i++)
 	{
 		AttrNumber	keycol = pd->key->partattrs[i];
@@ -1911,13 +1894,13 @@ FormPartitionKeyDatum(PartitionDispatch pd,
  * the latter case.
  */
 int
-get_partition_for_tuple(PartitionDispatch *pd,
+get_partition_for_tuple(PartitionTupleRoutingInfo **ptrinfos,
 						TupleTableSlot *slot,
 						EState *estate,
-						PartitionDispatchData **failed_at,
+						PartitionTupleRoutingInfo **failed_at,
 						TupleTableSlot **failed_slot)
 {
-	PartitionDispatch parent;
+	PartitionTupleRoutingInfo *parent;
 	Datum		values[PARTITION_MAX_KEYS];
 	bool		isnull[PARTITION_MAX_KEYS];
 	int			result;
@@ -1925,11 +1908,11 @@ get_partition_for_tuple(PartitionDispatch *pd,
 	TupleTableSlot *ecxt_scantuple_old = ecxt->ecxt_scantuple;
 
 	/* start with the root partitioned table */
-	parent = pd[0];
+	parent = ptrinfos[0];
 	while (true)
 	{
-		PartitionKey key = parent->key;
-		PartitionDesc partdesc = parent->partdesc;
+		PartitionKey  key = parent->pd->key;
+		PartitionDesc partdesc = parent->pd->partdesc;
 		TupleTableSlot *myslot = parent->tupslot;
 		TupleConversionMap *map = parent->tupmap;
 		int		cur_index = -1;
@@ -2039,13 +2022,13 @@ get_partition_for_tuple(PartitionDispatch *pd,
 			*failed_slot = slot;
 			break;
 		}
-		else if (parent->indexes[cur_index] >= 0)
+		else if (parent->pd->indexes[cur_index] >= 0)
 		{
-			result = parent->indexes[cur_index];
+			result = parent->pd->indexes[cur_index];
 			break;
 		}
 		else
-			parent = pd[-parent->indexes[cur_index]];
+			parent = ptrinfos[-parent->pd->indexes[cur_index]];
 	}
 
 error_exit:
diff --git a/src/backend/commands/copy.c b/src/backend/commands/copy.c
index cfa3f059c2..288d6a1ab2 100644
--- a/src/backend/commands/copy.c
+++ b/src/backend/commands/copy.c
@@ -165,8 +165,8 @@ typedef struct CopyStateData
 	bool		volatile_defexprs;	/* is any of defexprs volatile? */
 	List	   *range_table;
 
-	PartitionDispatch *partition_dispatch_info;
-	int			num_dispatch;	/* Number of entries in the above array */
+	PartitionTupleRoutingInfo **ptrinfos;
+	int			num_parted;		/* Number of entries in the above array */
 	int			num_partitions; /* Number of members in the following arrays */
 	ResultRelInfo *partitions;	/* Per partition result relation */
 	TupleConversionMap **partition_tupconv_maps;
@@ -2445,7 +2445,7 @@ CopyFrom(CopyState cstate)
 	 */
 	if (cstate->rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
 	{
-		PartitionDispatch *partition_dispatch_info;
+		PartitionTupleRoutingInfo **ptrinfos;
 		ResultRelInfo *partitions;
 		TupleConversionMap **partition_tupconv_maps;
 		TupleTableSlot *partition_tuple_slot;
@@ -2455,13 +2455,13 @@ CopyFrom(CopyState cstate)
 		ExecSetupPartitionTupleRouting(cstate->rel,
 									   1,
 									   estate,
-									   &partition_dispatch_info,
+									   &ptrinfos,
 									   &partitions,
 									   &partition_tupconv_maps,
 									   &partition_tuple_slot,
 									   &num_parted, &num_partitions);
-		cstate->partition_dispatch_info = partition_dispatch_info;
-		cstate->num_dispatch = num_parted;
+		cstate->ptrinfos = ptrinfos;
+		cstate->num_parted = num_parted;
 		cstate->partitions = partitions;
 		cstate->num_partitions = num_partitions;
 		cstate->partition_tupconv_maps = partition_tupconv_maps;
@@ -2502,7 +2502,7 @@ CopyFrom(CopyState cstate)
 	if ((resultRelInfo->ri_TrigDesc != NULL &&
 		 (resultRelInfo->ri_TrigDesc->trig_insert_before_row ||
 		  resultRelInfo->ri_TrigDesc->trig_insert_instead_row)) ||
-		cstate->partition_dispatch_info != NULL ||
+		cstate->ptrinfos != NULL ||
 		cstate->volatile_defexprs)
 	{
 		useHeapMultiInsert = false;
@@ -2580,7 +2580,7 @@ CopyFrom(CopyState cstate)
 		ExecStoreTuple(tuple, slot, InvalidBuffer, false);
 
 		/* Determine the partition to heap_insert the tuple into */
-		if (cstate->partition_dispatch_info)
+		if (cstate->ptrinfos)
 		{
 			int			leaf_part_index;
 			TupleConversionMap *map;
@@ -2594,7 +2594,7 @@ CopyFrom(CopyState cstate)
 			 * partition, respectively.
 			 */
 			leaf_part_index = ExecFindPartition(resultRelInfo,
-												cstate->partition_dispatch_info,
+												cstate->ptrinfos,
 												slot,
 												estate);
 			Assert(leaf_part_index >= 0 &&
@@ -2826,8 +2826,8 @@ CopyFrom(CopyState cstate)
 
 	ExecCloseIndices(resultRelInfo);
 
-	/* Close all the partitioned tables, leaf partitions, and their indices */
-	if (cstate->partition_dispatch_info)
+	/* Release some resources that we acquired for tuple-routing. */
+	if (cstate->ptrinfos)
 	{
 		int			i;
 
@@ -2837,13 +2837,15 @@ CopyFrom(CopyState cstate)
 		 * the main target table of COPY that will be closed eventually by
 		 * DoCopy().  Also, tupslot is NULL for the root partitioned table.
 		 */
-		for (i = 1; i < cstate->num_dispatch; i++)
+		for (i = 1; i < cstate->num_parted; i++)
 		{
-			PartitionDispatch pd = cstate->partition_dispatch_info[i];
+			PartitionTupleRoutingInfo *ptrinfo = cstate->ptrinfos[i];
 
-			heap_close(pd->reldesc, NoLock);
-			ExecDropSingleTupleTableSlot(pd->tupslot);
+			heap_close(ptrinfo->pd->reldesc, NoLock);
+			ExecDropSingleTupleTableSlot(ptrinfo->tupslot);
 		}
+
+		/* Close all the leaf partitions and their indices */
 		for (i = 0; i < cstate->num_partitions; i++)
 		{
 			ResultRelInfo *resultRelInfo = cstate->partitions + i;
diff --git a/src/backend/executor/execMain.c b/src/backend/executor/execMain.c
index 4b594d489c..fe186abe69 100644
--- a/src/backend/executor/execMain.c
+++ b/src/backend/executor/execMain.c
@@ -3243,8 +3243,8 @@ EvalPlanQualEnd(EPQState *epqstate)
  * tuple routing for partitioned tables
  *
  * Output arguments:
- * 'pd' receives an array of PartitionDispatch objects with one entry for
- *		every partitioned table in the partition tree
+ * 'ptrinfos' receives an array of PartitionTupleRoutingInfo objects with one
+ *		entry for each partitioned table in the partition tree
  * 'partitions' receives an array of ResultRelInfo objects with one entry for
  *		every leaf partition in the partition tree
  * 'tup_conv_maps' receives an array of TupleConversionMap objects with one
@@ -3267,7 +3267,7 @@ void
 ExecSetupPartitionTupleRouting(Relation rel,
 							   Index resultRTindex,
 							   EState *estate,
-							   PartitionDispatch **pd,
+							   PartitionTupleRoutingInfo ***ptrinfos,
 							   ResultRelInfo **partitions,
 							   TupleConversionMap ***tup_conv_maps,
 							   TupleTableSlot **partition_tuple_slot,
@@ -3275,16 +3275,84 @@ ExecSetupPartitionTupleRouting(Relation rel,
 {
 	TupleDesc	tupDesc = RelationGetDescr(rel);
 	List	   *leaf_parts;
+	PartitionDispatch *pds;
 	ListCell   *cell;
 	int			i;
 	ResultRelInfo *leaf_part_rri;
+	Relation	parent;
 
 	/*
 	 * Get the information about the partition tree after locking all the
 	 * partitions.
 	 */
 	(void) find_all_inheritors(RelationGetRelid(rel), RowExclusiveLock, NULL);
-	*pd = RelationGetPartitionDispatchInfo(rel, num_parted, &leaf_parts);
+	pds = RelationGetPartitionDispatchInfo(rel, num_parted, &leaf_parts);
+
+	/*
+	 * Construct PartitionTupleRoutingInfo objects, one for each partitioned
+	 * table in the tree, using its PartitionDispatch in the pds array.
+	 */
+	*ptrinfos = (PartitionTupleRoutingInfo **) palloc0(*num_parted *
+										sizeof(PartitionTupleRoutingInfo *));
+	parent = NULL;
+	for (i = 0; i < *num_parted; i++)
+	{
+		PartitionTupleRoutingInfo *ptrinfo;
+
+		ptrinfo = (PartitionTupleRoutingInfo *)
+							palloc0(sizeof(PartitionTupleRoutingInfo));
+		/* Stash a reference to this PartitionDispatch. */
+		ptrinfo->pd = pds[i];
+
+		/* State for extracting partition key from tuples will go here. */
+		ptrinfo->keystate = NIL;
+
+		/*
+		 * For every partitioned table other than root, we must store a tuple
+		 * table slot initialized with its tuple descriptor and a tuple
+		 * conversion map to convert a tuple from its parent's rowtype to its
+		 * own.  That is to make sure that we are looking at the correct row
+		 * using the correct tuple descriptor when computing its partition key
+		 * for tuple routing.
+		 */
+		if (pds[i]->parentoid != InvalidOid)
+		{
+			TupleDesc	tupdesc = RelationGetDescr(pds[i]->reldesc);
+
+			/* Open the parent relation descriptor if not already done. */
+			if (pds[i]->parentoid == RelationGetRelid(rel))
+				parent = rel;
+			else if (parent == NULL)
+				/* Locked by RelationGetPartitionDispatchInfo(). */
+				parent = heap_open(pds[i]->parentoid, NoLock);
+
+			ptrinfo->tupslot = MakeSingleTupleTableSlot(tupdesc);
+			ptrinfo->tupmap = convert_tuples_by_name(RelationGetDescr(parent),
+													 tupdesc,
+								  gettext_noop("could not convert row type"));
+			/*
+			 * Close the parent descriptor, if the next partitioned table in
+			 * the list is not a sibling, because it will have a different
+			 * parent if so.
+			 */
+			if (parent != NULL && parent != rel && i + 1 < *num_parted &&
+				pds[i + 1]->parentoid != pds[i]->parentoid)
+			{
+				heap_close(parent, NoLock);
+				parent = NULL;
+			}
+		}
+		else
+		{
+			/* Not required for the root partitioned table */
+			ptrinfo->tupslot = NULL;
+			ptrinfo->tupmap = NULL;
+		}
+
+		(*ptrinfos)[i] = ptrinfo;
+	}
+
+	/* For leaf partitions, we build ResultRelInfos and TupleConversionMaps. */
 	*num_partitions = list_length(leaf_parts);
 	*partitions = (ResultRelInfo *) palloc(*num_partitions *
 										   sizeof(ResultRelInfo));
@@ -3361,11 +3429,13 @@ ExecSetupPartitionTupleRouting(Relation rel,
  * by get_partition_for_tuple() unchanged.
  */
 int
-ExecFindPartition(ResultRelInfo *resultRelInfo, PartitionDispatch *pd,
-				  TupleTableSlot *slot, EState *estate)
+ExecFindPartition(ResultRelInfo *resultRelInfo,
+				  PartitionTupleRoutingInfo **ptrinfos,
+				  TupleTableSlot *slot,
+				  EState *estate)
 {
 	int			result;
-	PartitionDispatchData *failed_at;
+	PartitionTupleRoutingInfo *failed_at;
 	TupleTableSlot *failed_slot;
 
 	/*
@@ -3375,7 +3445,7 @@ ExecFindPartition(ResultRelInfo *resultRelInfo, PartitionDispatch *pd,
 	if (resultRelInfo->ri_PartitionCheck)
 		ExecPartitionCheck(resultRelInfo, slot, estate);
 
-	result = get_partition_for_tuple(pd, slot, estate,
+	result = get_partition_for_tuple(ptrinfos, slot, estate,
 									 &failed_at, &failed_slot);
 	if (result < 0)
 	{
@@ -3385,7 +3455,7 @@ ExecFindPartition(ResultRelInfo *resultRelInfo, PartitionDispatch *pd,
 		char	   *val_desc;
 		ExprContext *ecxt = GetPerTupleExprContext(estate);
 
-		failed_rel = failed_at->reldesc;
+		failed_rel = failed_at->pd->reldesc;
 		ecxt->ecxt_scantuple = failed_slot;
 		FormPartitionKeyDatum(failed_at, failed_slot, estate,
 							  key_values, key_isnull);
diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c
index bd84778739..06c69c5783 100644
--- a/src/backend/executor/nodeModifyTable.c
+++ b/src/backend/executor/nodeModifyTable.c
@@ -278,7 +278,7 @@ ExecInsert(ModifyTableState *mtstate,
 	resultRelInfo = estate->es_result_relation_info;
 
 	/* Determine the partition to heap_insert the tuple into */
-	if (mtstate->mt_partition_dispatch_info)
+	if (mtstate->mt_ptrinfos)
 	{
 		int			leaf_part_index;
 		TupleConversionMap *map;
@@ -292,7 +292,7 @@ ExecInsert(ModifyTableState *mtstate,
 		 * respectively.
 		 */
 		leaf_part_index = ExecFindPartition(resultRelInfo,
-											mtstate->mt_partition_dispatch_info,
+											mtstate->mt_ptrinfos,
 											slot,
 											estate);
 		Assert(leaf_part_index >= 0 &&
@@ -1487,7 +1487,7 @@ ExecSetupTransitionCaptureState(ModifyTableState *mtstate, EState *estate)
 		int			numResultRelInfos;
 
 		/* Find the set of partitions so that we can find their TupleDescs. */
-		if (mtstate->mt_partition_dispatch_info != NULL)
+		if (mtstate->mt_ptrinfos != NULL)
 		{
 			/*
 			 * For INSERT via partitioned table, so we need TupleDescs based
@@ -1911,7 +1911,7 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 	if (operation == CMD_INSERT &&
 		rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
 	{
-		PartitionDispatch *partition_dispatch_info;
+		PartitionTupleRoutingInfo **ptrinfos;
 		ResultRelInfo *partitions;
 		TupleConversionMap **partition_tupconv_maps;
 		TupleTableSlot *partition_tuple_slot;
@@ -1921,13 +1921,13 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 		ExecSetupPartitionTupleRouting(rel,
 									   node->nominalRelation,
 									   estate,
-									   &partition_dispatch_info,
+									   &ptrinfos,
 									   &partitions,
 									   &partition_tupconv_maps,
 									   &partition_tuple_slot,
 									   &num_parted, &num_partitions);
-		mtstate->mt_partition_dispatch_info = partition_dispatch_info;
-		mtstate->mt_num_dispatch = num_parted;
+		mtstate->mt_ptrinfos = ptrinfos;
+		mtstate->mt_num_parted = num_parted;
 		mtstate->mt_partitions = partitions;
 		mtstate->mt_num_partitions = num_partitions;
 		mtstate->mt_partition_tupconv_maps = partition_tupconv_maps;
@@ -2336,21 +2336,24 @@ ExecEndModifyTable(ModifyTableState *node)
 														   resultRelInfo);
 	}
 
+	/* Release some resources that we acquired for tuple-routing. */
+
 	/*
-	 * Close all the partitioned tables, leaf partitions, and their indices
-	 *
-	 * Remember node->mt_partition_dispatch_info[0] corresponds to the root
-	 * partitioned table, which we must not try to close, because it is the
-	 * main target table of the query that will be closed by ExecEndPlan().
-	 * Also, tupslot is NULL for the root partitioned table.
+	 * node->mt_ptrinfos[0] corresponds to the root partitioned table, for
+	 * which we didn't create tupslot.  Also, its relation descriptor will
+	 * be closed in ExecEndPlan().
 	 */
-	for (i = 1; i < node->mt_num_dispatch; i++)
+	for (i = 1; i < node->mt_num_parted; i++)
 	{
-		PartitionDispatch pd = node->mt_partition_dispatch_info[i];
+		PartitionTupleRoutingInfo *ptrinfo = node->mt_ptrinfos[i];
 
-		heap_close(pd->reldesc, NoLock);
-		ExecDropSingleTupleTableSlot(pd->tupslot);
+		heap_close(ptrinfo->pd->reldesc, NoLock);
+		ExecDropSingleTupleTableSlot(ptrinfo->tupslot);
 	}
+
+	/*
+	 * Close all the leaf partitions and their indices.
+	 */
 	for (i = 0; i < node->mt_num_partitions; i++)
 	{
 		ResultRelInfo *resultRelInfo = node->mt_partitions + i;
diff --git a/src/include/catalog/partition.h b/src/include/catalog/partition.h
index 2283c675e9..1091dd572c 100644
--- a/src/include/catalog/partition.h
+++ b/src/include/catalog/partition.h
@@ -45,13 +45,8 @@ typedef struct PartitionDescData *PartitionDesc;
  *
  *	reldesc		Relation descriptor of the table
  *	key			Partition key information of the table
- *	keystate	Execution state required for expressions in the partition key
  *	partdesc	Partition descriptor of the table
- *	tupslot		A standalone TupleTableSlot initialized with this table's tuple
- *				descriptor
- *	tupmap		TupleConversionMap to convert from the parent's rowtype to
- *				this table's rowtype (when extracting the partition key of a
- *				tuple just before routing it through this table)
+ *	parentoid	OID of the parent table (InvalidOid if root partitioned table)
  *	indexes		Array with partdesc->nparts members (for details on what
  *				individual members represent, see how they are set in
  *				RelationGetPartitionDispatchInfo())
@@ -61,10 +56,8 @@ typedef struct PartitionDispatchData
 {
 	Relation	reldesc;
 	PartitionKey key;
-	List	   *keystate;		/* list of ExprState */
 	PartitionDesc partdesc;
-	TupleTableSlot *tupslot;
-	TupleConversionMap *tupmap;
+	Oid			parentoid;
 	int		   *indexes;
 } PartitionDispatchData;
 
@@ -86,17 +79,18 @@ extern List *map_partition_varattnos(List *expr, int target_varno,
 extern List *RelationGetPartitionQual(Relation rel);
 extern Expr *get_partition_qual_relid(Oid relid);
 
-/* For tuple routing */
 extern PartitionDispatch *RelationGetPartitionDispatchInfo(Relation rel,
 								 int *num_parted, List **leaf_part_oids);
-extern void FormPartitionKeyDatum(PartitionDispatch pd,
+
+/* For tuple routing */
+extern void FormPartitionKeyDatum(PartitionTupleRoutingInfo *ptrinfo,
 					  TupleTableSlot *slot,
 					  EState *estate,
 					  Datum *values,
 					  bool *isnull);
-extern int get_partition_for_tuple(PartitionDispatch *pd,
+extern int get_partition_for_tuple(PartitionTupleRoutingInfo **ptrinfos,
 						TupleTableSlot *slot,
 						EState *estate,
-						PartitionDispatchData **failed_at,
+						PartitionTupleRoutingInfo **failed_at,
 						TupleTableSlot **failed_slot);
 #endif							/* PARTITION_H */
diff --git a/src/include/executor/executor.h b/src/include/executor/executor.h
index 770881849c..aee7a41b31 100644
--- a/src/include/executor/executor.h
+++ b/src/include/executor/executor.h
@@ -209,13 +209,13 @@ extern HeapTuple EvalPlanQualGetTuple(EPQState *epqstate, Index rti);
 extern void ExecSetupPartitionTupleRouting(Relation rel,
 							   Index resultRTindex,
 							   EState *estate,
-							   PartitionDispatch **pd,
+							   PartitionTupleRoutingInfo ***ptrinfos,
 							   ResultRelInfo **partitions,
 							   TupleConversionMap ***tup_conv_maps,
 							   TupleTableSlot **partition_tuple_slot,
 							   int *num_parted, int *num_partitions);
 extern int ExecFindPartition(ResultRelInfo *resultRelInfo,
-				  PartitionDispatch *pd,
+				  PartitionTupleRoutingInfo **ptrinfos,
 				  TupleTableSlot *slot,
 				  EState *estate);
 
diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h
index 90a60abc4d..c554a1b311 100644
--- a/src/include/nodes/execnodes.h
+++ b/src/include/nodes/execnodes.h
@@ -414,6 +414,42 @@ typedef struct ResultRelInfo
 	Relation	ri_PartitionRoot;
 } ResultRelInfo;
 
+/* Forward declarations, to avoid including other headers */
+typedef struct PartitionDispatchData *PartitionDispatch;
+
+/*
+ * PartitionTupleRoutingInfo - information required for tuple-routing
+ *							   through one partitioned table in a partition
+ *							   tree
+ */
+typedef struct PartitionTupleRoutingInfo
+{
+
+	/* Information about the table's partitions */
+	PartitionDispatch	pd;
+
+	/*
+	 * The execution state required for expressions contained in the partition
+	 * key.  It is NIL until initialized by FormPartitionKeyDatum() if and when
+	 * it is called; for example, the first time a tuple is routed through this
+	 * table.
+	 */
+	List   *keystate;
+
+	/*
+	 * A standalone TupleTableSlot initialized with this table's tuple
+	 * descriptor
+	 */
+	TupleTableSlot *tupslot;
+
+	/*
+	 * TupleConversionMap to convert from the parent's rowtype to this table's
+	 * rowtype (when extracting the partition key of a tuple just before
+	 * routing it through this table)
+	 */
+	TupleConversionMap *tupmap;
+} PartitionTupleRoutingInfo;
+
 /* ----------------
  *	  EState information
  *
@@ -973,9 +1009,9 @@ typedef struct ModifyTableState
 	TupleTableSlot *mt_existing;	/* slot to store existing target tuple in */
 	List	   *mt_excludedtlist;	/* the excluded pseudo relation's tlist  */
 	TupleTableSlot *mt_conflproj;	/* CONFLICT ... SET ... projection target */
-	struct PartitionDispatchData **mt_partition_dispatch_info;
 	/* Tuple-routing support info */
-	int			mt_num_dispatch;	/* Number of entries in the above array */
+	struct PartitionTupleRoutingInfo **mt_ptrinfos;
+	int			mt_num_parted;		/* Number of entries in the above array */
 	int			mt_num_partitions;	/* Number of members in the following
 									 * arrays */
 	ResultRelInfo *mt_partitions;	/* Per partition result relation */
-- 
2.11.0

From f95b1cb33159620175e012a471513f9a32d64c43 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Fri, 8 Sep 2017 17:35:10 +0900
Subject: [PATCH 2/3] Make RelationGetPartitionDispatch expansion order
 depth-first

This is so as it matches what the planner is doing with partitioning
inheritance expansion.  Matching with planner order helps because
it helps ease matching the executor's per-partition objects with
planner-created per-partition nodes.
---
 src/backend/catalog/partition.c | 191 ++++++++++++++++------------------------
 1 file changed, 74 insertions(+), 117 deletions(-)

diff --git a/src/backend/catalog/partition.c b/src/backend/catalog/partition.c
index 4f594243d3..a4abe08088 100644
--- a/src/backend/catalog/partition.c
+++ b/src/backend/catalog/partition.c
@@ -139,6 +139,8 @@ static int32 partition_bound_cmp(PartitionKey key,
 static int partition_bound_bsearch(PartitionKey key,
 						PartitionBoundInfo boundinfo,
 						void *probe, bool probe_is_bound, bool *is_equal);
+static void get_partition_dispatch_recurse(Relation rel, Relation parent,
+							   List **pds, List **leaf_part_oids);
 
 /*
  * RelationBuildPartitionDesc
@@ -961,21 +963,6 @@ get_partition_qual_relid(Oid relid)
 }
 
 /*
- * Append OIDs of rel's partitions to the list 'partoids' and for each OID,
- * append pointer rel to the list 'parents'.
- */
-#define APPEND_REL_PARTITION_OIDS(rel, partoids, parents) \
-	do\
-	{\
-		int		i;\
-		for (i = 0; i < (rel)->rd_partdesc->nparts; i++)\
-		{\
-			(partoids) = lappend_oid((partoids), (rel)->rd_partdesc->oids[i]);\
-			(parents) = lappend((parents), (rel));\
-		}\
-	} while(0)
-
-/*
  * RelationGetPartitionDispatchInfo
  *		Returns information necessary to route tuples down a partition tree
  *
@@ -991,16 +978,47 @@ PartitionDispatch *
 RelationGetPartitionDispatchInfo(Relation rel,
 								 int *num_parted, List **leaf_part_oids)
 {
+	List   *pdlist;
 	PartitionDispatchData **pd;
-	List	   *all_parts = NIL,
-			   *all_parents = NIL,
-			   *parted_rels,
-			   *parted_rel_parents;
-	ListCell   *lc1,
-			   *lc2;
-	int			i,
-				k,
-				offset;
+	ListCell *lc;
+	int		i;
+
+	Assert(rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE);
+
+	*num_parted = 0;
+	*leaf_part_oids = NIL;
+
+	get_partition_dispatch_recurse(rel, NULL, &pdlist, leaf_part_oids);
+	*num_parted = list_length(pdlist);
+	pd = (PartitionDispatchData **) palloc(*num_parted *
+										   sizeof(PartitionDispatchData *));
+	i = 0;
+	foreach (lc, pdlist)
+	{
+		pd[i++] = lfirst(lc);
+	}
+
+	return pd;
+}
+
+/*
+ * get_partition_dispatch_recurse
+ *		Recursively expand partition tree rooted at rel
+ *
+ * As the partition tree is expanded in a depth-first manner, we mantain two
+ * global lists: of PartitionDispatch objects corresponding to partitioned
+ * tables in *pds and of the leaf partition OIDs in *leaf_part_oids.
+ */
+static void
+get_partition_dispatch_recurse(Relation rel, Relation parent,
+							   List **pds, List **leaf_part_oids)
+{
+	PartitionDesc	partdesc = RelationGetPartitionDesc(rel);
+	PartitionKey	partkey = RelationGetPartitionKey(rel);
+	PartitionDispatch pd;
+	int			i;
+	int			next_leaf_idx = list_length(*leaf_part_oids),
+				next_parted_idx = list_length(*pds);
 
 	/*
 	 * We rely on the relcache to traverse the partition tree to build both
@@ -1016,108 +1034,47 @@ RelationGetPartitionDispatchInfo(Relation rel,
 	 * a bit tricky but works because the foreach() macro doesn't fetch the
 	 * next list element until the bottom of the loop.
 	 */
-	*num_parted = 1;
-	parted_rels = list_make1(rel);
-	/* Root partitioned table has no parent, so NULL for parent */
-	parted_rel_parents = list_make1(NULL);
-	APPEND_REL_PARTITION_OIDS(rel, all_parts, all_parents);
-	forboth(lc1, all_parts, lc2, all_parents)
+	pd = (PartitionDispatch) palloc(sizeof(PartitionDispatchData));
+	*pds = lappend(*pds, pd);
+	pd->reldesc = rel;
+	pd->key = partkey;
+	pd->partdesc = partdesc;
+	if (parent != NULL)
+		pd->parentoid = RelationGetRelid(parent);
+	else
+		pd->parentoid = InvalidOid;
+	pd->indexes = (int *) palloc(partdesc->nparts * sizeof(int));
+	for (i = 0; i < partdesc->nparts; i++)
 	{
-		Oid			partrelid = lfirst_oid(lc1);
-		Relation	parent = lfirst(lc2);
+		Oid			partrelid = partdesc->oids[i];
 
-		if (get_rel_relkind(partrelid) == RELKIND_PARTITIONED_TABLE)
+		if (get_rel_relkind(partrelid) != RELKIND_PARTITIONED_TABLE)
 		{
-			/*
-			 * Already locked by the caller.  Note that it is the
-			 * responsibility of the caller to close the below relcache entry,
-			 * once done using the information being collected here (for
-			 * example, in ExecEndModifyTable).
-			 */
-			Relation	partrel = heap_open(partrelid, NoLock);
-
-			(*num_parted)++;
-			parted_rels = lappend(parted_rels, partrel);
-			parted_rel_parents = lappend(parted_rel_parents, parent);
-			APPEND_REL_PARTITION_OIDS(partrel, all_parts, all_parents);
+			*leaf_part_oids = lappend_oid(*leaf_part_oids, partrelid);
+			pd->indexes[i] = next_leaf_idx++;
 		}
-	}
-
-	/*
-	 * We want to create two arrays - one for leaf partitions and another for
-	 * partitioned tables (including the root table and internal partitions).
-	 * While we only create the latter here, leaf partition array of suitable
-	 * objects (such as, ResultRelInfo) is created by the caller using the
-	 * list of OIDs we return.  Indexes into these arrays get assigned in a
-	 * breadth-first manner, whereby partitions of any given level are placed
-	 * consecutively in the respective arrays.
-	 */
-	pd = (PartitionDispatchData **) palloc(*num_parted *
-										   sizeof(PartitionDispatchData *));
-	*leaf_part_oids = NIL;
-	i = k = offset = 0;
-	forboth(lc1, parted_rels, lc2, parted_rel_parents)
-	{
-		Relation	partrel = lfirst(lc1);
-		Relation	parent = lfirst(lc2);
-		PartitionKey partkey = RelationGetPartitionKey(partrel);
-		PartitionDesc partdesc = RelationGetPartitionDesc(partrel);
-		int			j,
-					m;
-
-		pd[i] = (PartitionDispatch) palloc(sizeof(PartitionDispatchData));
-		pd[i]->reldesc = partrel;
-		pd[i]->key = partkey;
-		pd[i]->partdesc = partdesc;
-		if (parent != NULL)
-			pd[i]->parentoid = RelationGetRelid(parent);
 		else
-			pd[i]->parentoid = InvalidOid;
-
-		pd[i]->indexes = (int *) palloc(partdesc->nparts * sizeof(int));
-
-		/*
-		 * Indexes corresponding to the internal partitions are multiplied by
-		 * -1 to distinguish them from those of leaf partitions.  Encountering
-		 * an index >= 0 means we found a leaf partition, which is immediately
-		 * returned as the partition we are looking for.  A negative index
-		 * means we found a partitioned table, whose PartitionDispatch object
-		 * is located at the above index multiplied back by -1.  Using the
-		 * PartitionDispatch object, search is continued further down the
-		 * partition tree.
-		 */
-		m = 0;
-		for (j = 0; j < partdesc->nparts; j++)
 		{
-			Oid			partrelid = partdesc->oids[j];
+			Relation partrel = heap_open(partrelid, NoLock);
 
-			if (get_rel_relkind(partrelid) != RELKIND_PARTITIONED_TABLE)
-			{
-				*leaf_part_oids = lappend_oid(*leaf_part_oids, partrelid);
-				pd[i]->indexes[j] = k++;
-			}
-			else
-			{
-				/*
-				 * offset denotes the number of partitioned tables of upper
-				 * levels including those of the current level.  Any partition
-				 * of this table must belong to the next level and hence will
-				 * be placed after the last partitioned table of this level.
-				 */
-				pd[i]->indexes[j] = -(1 + offset + m);
-				m++;
-			}
-		}
-		i++;
+			/*
+			 * offset denotes the number of partitioned tables of upper
+			 * levels including those of the current level.  Any partition
+			 * of this table must belong to the next level and hence will
+			 * be placed after the last partitioned table of this level.
+			 */
+			pd->indexes[i] = -(1 + next_parted_idx);
+			get_partition_dispatch_recurse(partrel, rel, pds, leaf_part_oids);
 
-		/*
-		 * This counts the number of partitioned tables at upper levels
-		 * including those of the current level.
-		 */
-		offset += m;
+			/*
+			 * Fast-forward both leaf partition and parted indexes to account
+			 * for the leaf partitions and PartitionDispatch objects just
+			 * added.
+			 */
+			next_parted_idx += (list_length(*pds) - next_parted_idx - 1);
+			next_leaf_idx += (list_length(*leaf_part_oids) - next_leaf_idx);
+		}
 	}
-
-	return pd;
 }
 
 /* Module-local functions */
-- 
2.11.0

From 0e04cee14a5168e0652c2aa646c169789ae41e8e Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Wed, 30 Aug 2017 10:02:05 +0900
Subject: [PATCH 1/2] Decouple RelationGetPartitionDispatchInfo() from executor

Currently it and the structure it generates viz. PartitionDispatch
objects are too coupled with the executor's tuple-routing code.  In
particular, it's pretty undesirable that it makes it the responsibility
of the caller to release some resources, such as executor tuple table
slots, tuple-conversion maps, etc.  That makes it harder to use in
places other than where it's currently being used.

After this refactoring, ExecSetupPartitionTupleRouting() now needs to
do some of the work that was previously done in
RelationGetPartitionDispatchInfo().
---
 src/backend/catalog/partition.c        | 53 +++++++-------------
 src/backend/commands/copy.c            | 32 +++++++------
 src/backend/executor/execMain.c        | 88 ++++++++++++++++++++++++++++++----
 src/backend/executor/nodeModifyTable.c | 37 +++++++-------
 src/include/catalog/partition.h        | 20 +++-----
 src/include/executor/executor.h        |  4 +-
 src/include/nodes/execnodes.h          | 40 +++++++++++++++-
 7 files changed, 181 insertions(+), 93 deletions(-)

diff --git a/src/backend/catalog/partition.c b/src/backend/catalog/partition.c
index 73eff17202..555b7c21c7 100644
--- a/src/backend/catalog/partition.c
+++ b/src/backend/catalog/partition.c
@@ -1292,7 +1292,6 @@ RelationGetPartitionDispatchInfo(Relation rel,
 		Relation	partrel = lfirst(lc1);
 		Relation	parent = lfirst(lc2);
 		PartitionKey partkey = RelationGetPartitionKey(partrel);
-		TupleDesc	tupdesc = RelationGetDescr(partrel);
 		PartitionDesc partdesc = RelationGetPartitionDesc(partrel);
 		int			j,
 					m;
@@ -1300,29 +1299,12 @@ RelationGetPartitionDispatchInfo(Relation rel,
 		pd[i] = (PartitionDispatch) palloc(sizeof(PartitionDispatchData));
 		pd[i]->reldesc = partrel;
 		pd[i]->key = partkey;
-		pd[i]->keystate = NIL;
 		pd[i]->partdesc = partdesc;
 		if (parent != NULL)
-		{
-			/*
-			 * For every partitioned table other than root, we must store a
-			 * tuple table slot initialized with its tuple descriptor and a
-			 * tuple conversion map to convert a tuple from its parent's
-			 * rowtype to its own. That is to make sure that we are looking at
-			 * the correct row using the correct tuple descriptor when
-			 * computing its partition key for tuple routing.
-			 */
-			pd[i]->tupslot = MakeSingleTupleTableSlot(tupdesc);
-			pd[i]->tupmap = convert_tuples_by_name(RelationGetDescr(parent),
-												   tupdesc,
-												   gettext_noop("could not convert row type"));
-		}
+			pd[i]->parentoid = RelationGetRelid(parent);
 		else
-		{
-			/* Not required for the root partitioned table */
-			pd[i]->tupslot = NULL;
-			pd[i]->tupmap = NULL;
-		}
+			pd[i]->parentoid = InvalidOid;
+
 		pd[i]->indexes = (int *) palloc(partdesc->nparts * sizeof(int));
 
 		/*
@@ -2233,7 +2215,7 @@ generate_partition_qual(Relation rel)
  *			Construct values[] and isnull[] arrays for the partition key
  *			of a tuple.
  *
- *	pd				Partition dispatch object of the partitioned table
+ *	ptrinfo			PartitionTupleRoutingInfo object of the table
  *	slot			Heap tuple from which to extract partition key
  *	estate			executor state for evaluating any partition key
  *					expressions (must be non-NULL)
@@ -2245,26 +2227,27 @@ generate_partition_qual(Relation rel)
  * ----------------
  */
 void
-FormPartitionKeyDatum(PartitionDispatch pd,
+FormPartitionKeyDatum(PartitionTupleRoutingInfo *ptrinfo,
 					  TupleTableSlot *slot,
 					  EState *estate,
 					  Datum *values,
 					  bool *isnull)
 {
+	PartitionDispatch	pd = ptrinfo->pd;
 	ListCell   *partexpr_item;
 	int			i;
 
-	if (pd->key->partexprs != NIL && pd->keystate == NIL)
+	if (pd->key->partexprs != NIL && ptrinfo->keystate == NIL)
 	{
 		/* Check caller has set up context correctly */
 		Assert(estate != NULL &&
 			   GetPerTupleExprContext(estate)->ecxt_scantuple == slot);
 
 		/* First time through, set up expression evaluation state */
-		pd->keystate = ExecPrepareExprList(pd->key->partexprs, estate);
+		ptrinfo->keystate = ExecPrepareExprList(pd->key->partexprs, estate);
 	}
 
-	partexpr_item = list_head(pd->keystate);
+	partexpr_item = list_head(ptrinfo->keystate);
 	for (i = 0; i < pd->key->partnatts; i++)
 	{
 		AttrNumber	keycol = pd->key->partattrs[i];
@@ -2304,13 +2287,13 @@ FormPartitionKeyDatum(PartitionDispatch pd,
  * the latter case.
  */
 int
-get_partition_for_tuple(PartitionDispatch *pd,
+get_partition_for_tuple(PartitionTupleRoutingInfo **ptrinfos,
 						TupleTableSlot *slot,
 						EState *estate,
-						PartitionDispatchData **failed_at,
+						PartitionTupleRoutingInfo **failed_at,
 						TupleTableSlot **failed_slot)
 {
-	PartitionDispatch parent;
+	PartitionTupleRoutingInfo *parent;
 	Datum		values[PARTITION_MAX_KEYS];
 	bool		isnull[PARTITION_MAX_KEYS];
 	int			result;
@@ -2318,11 +2301,11 @@ get_partition_for_tuple(PartitionDispatch *pd,
 	TupleTableSlot *ecxt_scantuple_old = ecxt->ecxt_scantuple;
 
 	/* start with the root partitioned table */
-	parent = pd[0];
+	parent = ptrinfos[0];
 	while (true)
 	{
-		PartitionKey key = parent->key;
-		PartitionDesc partdesc = parent->partdesc;
+		PartitionKey  key = parent->pd->key;
+		PartitionDesc partdesc = parent->pd->partdesc;
 		TupleTableSlot *myslot = parent->tupslot;
 		TupleConversionMap *map = parent->tupmap;
 		int			cur_index = -1;
@@ -2458,13 +2441,13 @@ get_partition_for_tuple(PartitionDispatch *pd,
 			*failed_slot = slot;
 			break;
 		}
-		else if (parent->indexes[cur_index] >= 0)
+		else if (parent->pd->indexes[cur_index] >= 0)
 		{
-			result = parent->indexes[cur_index];
+			result = parent->pd->indexes[cur_index];
 			break;
 		}
 		else
-			parent = pd[-parent->indexes[cur_index]];
+			parent = ptrinfos[-parent->pd->indexes[cur_index]];
 	}
 
 error_exit:
diff --git a/src/backend/commands/copy.c b/src/backend/commands/copy.c
index cfa3f059c2..288d6a1ab2 100644
--- a/src/backend/commands/copy.c
+++ b/src/backend/commands/copy.c
@@ -165,8 +165,8 @@ typedef struct CopyStateData
 	bool		volatile_defexprs;	/* is any of defexprs volatile? */
 	List	   *range_table;
 
-	PartitionDispatch *partition_dispatch_info;
-	int			num_dispatch;	/* Number of entries in the above array */
+	PartitionTupleRoutingInfo **ptrinfos;
+	int			num_parted;		/* Number of entries in the above array */
 	int			num_partitions; /* Number of members in the following arrays */
 	ResultRelInfo *partitions;	/* Per partition result relation */
 	TupleConversionMap **partition_tupconv_maps;
@@ -2445,7 +2445,7 @@ CopyFrom(CopyState cstate)
 	 */
 	if (cstate->rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
 	{
-		PartitionDispatch *partition_dispatch_info;
+		PartitionTupleRoutingInfo **ptrinfos;
 		ResultRelInfo *partitions;
 		TupleConversionMap **partition_tupconv_maps;
 		TupleTableSlot *partition_tuple_slot;
@@ -2455,13 +2455,13 @@ CopyFrom(CopyState cstate)
 		ExecSetupPartitionTupleRouting(cstate->rel,
 									   1,
 									   estate,
-									   &partition_dispatch_info,
+									   &ptrinfos,
 									   &partitions,
 									   &partition_tupconv_maps,
 									   &partition_tuple_slot,
 									   &num_parted, &num_partitions);
-		cstate->partition_dispatch_info = partition_dispatch_info;
-		cstate->num_dispatch = num_parted;
+		cstate->ptrinfos = ptrinfos;
+		cstate->num_parted = num_parted;
 		cstate->partitions = partitions;
 		cstate->num_partitions = num_partitions;
 		cstate->partition_tupconv_maps = partition_tupconv_maps;
@@ -2502,7 +2502,7 @@ CopyFrom(CopyState cstate)
 	if ((resultRelInfo->ri_TrigDesc != NULL &&
 		 (resultRelInfo->ri_TrigDesc->trig_insert_before_row ||
 		  resultRelInfo->ri_TrigDesc->trig_insert_instead_row)) ||
-		cstate->partition_dispatch_info != NULL ||
+		cstate->ptrinfos != NULL ||
 		cstate->volatile_defexprs)
 	{
 		useHeapMultiInsert = false;
@@ -2580,7 +2580,7 @@ CopyFrom(CopyState cstate)
 		ExecStoreTuple(tuple, slot, InvalidBuffer, false);
 
 		/* Determine the partition to heap_insert the tuple into */
-		if (cstate->partition_dispatch_info)
+		if (cstate->ptrinfos)
 		{
 			int			leaf_part_index;
 			TupleConversionMap *map;
@@ -2594,7 +2594,7 @@ CopyFrom(CopyState cstate)
 			 * partition, respectively.
 			 */
 			leaf_part_index = ExecFindPartition(resultRelInfo,
-												cstate->partition_dispatch_info,
+												cstate->ptrinfos,
 												slot,
 												estate);
 			Assert(leaf_part_index >= 0 &&
@@ -2826,8 +2826,8 @@ CopyFrom(CopyState cstate)
 
 	ExecCloseIndices(resultRelInfo);
 
-	/* Close all the partitioned tables, leaf partitions, and their indices */
-	if (cstate->partition_dispatch_info)
+	/* Release some resources that we acquired for tuple-routing. */
+	if (cstate->ptrinfos)
 	{
 		int			i;
 
@@ -2837,13 +2837,15 @@ CopyFrom(CopyState cstate)
 		 * the main target table of COPY that will be closed eventually by
 		 * DoCopy().  Also, tupslot is NULL for the root partitioned table.
 		 */
-		for (i = 1; i < cstate->num_dispatch; i++)
+		for (i = 1; i < cstate->num_parted; i++)
 		{
-			PartitionDispatch pd = cstate->partition_dispatch_info[i];
+			PartitionTupleRoutingInfo *ptrinfo = cstate->ptrinfos[i];
 
-			heap_close(pd->reldesc, NoLock);
-			ExecDropSingleTupleTableSlot(pd->tupslot);
+			heap_close(ptrinfo->pd->reldesc, NoLock);
+			ExecDropSingleTupleTableSlot(ptrinfo->tupslot);
 		}
+
+		/* Close all the leaf partitions and their indices */
 		for (i = 0; i < cstate->num_partitions; i++)
 		{
 			ResultRelInfo *resultRelInfo = cstate->partitions + i;
diff --git a/src/backend/executor/execMain.c b/src/backend/executor/execMain.c
index 4b594d489c..fe186abe69 100644
--- a/src/backend/executor/execMain.c
+++ b/src/backend/executor/execMain.c
@@ -3243,8 +3243,8 @@ EvalPlanQualEnd(EPQState *epqstate)
  * tuple routing for partitioned tables
  *
  * Output arguments:
- * 'pd' receives an array of PartitionDispatch objects with one entry for
- *		every partitioned table in the partition tree
+ * 'ptrinfos' receives an array of PartitionTupleRoutingInfo objects with one
+ *		entry for each partitioned table in the partition tree
  * 'partitions' receives an array of ResultRelInfo objects with one entry for
  *		every leaf partition in the partition tree
  * 'tup_conv_maps' receives an array of TupleConversionMap objects with one
@@ -3267,7 +3267,7 @@ void
 ExecSetupPartitionTupleRouting(Relation rel,
 							   Index resultRTindex,
 							   EState *estate,
-							   PartitionDispatch **pd,
+							   PartitionTupleRoutingInfo ***ptrinfos,
 							   ResultRelInfo **partitions,
 							   TupleConversionMap ***tup_conv_maps,
 							   TupleTableSlot **partition_tuple_slot,
@@ -3275,16 +3275,84 @@ ExecSetupPartitionTupleRouting(Relation rel,
 {
 	TupleDesc	tupDesc = RelationGetDescr(rel);
 	List	   *leaf_parts;
+	PartitionDispatch *pds;
 	ListCell   *cell;
 	int			i;
 	ResultRelInfo *leaf_part_rri;
+	Relation	parent;
 
 	/*
 	 * Get the information about the partition tree after locking all the
 	 * partitions.
 	 */
 	(void) find_all_inheritors(RelationGetRelid(rel), RowExclusiveLock, NULL);
-	*pd = RelationGetPartitionDispatchInfo(rel, num_parted, &leaf_parts);
+	pds = RelationGetPartitionDispatchInfo(rel, num_parted, &leaf_parts);
+
+	/*
+	 * Construct PartitionTupleRoutingInfo objects, one for each partitioned
+	 * table in the tree, using its PartitionDispatch in the pds array.
+	 */
+	*ptrinfos = (PartitionTupleRoutingInfo **) palloc0(*num_parted *
+										sizeof(PartitionTupleRoutingInfo *));
+	parent = NULL;
+	for (i = 0; i < *num_parted; i++)
+	{
+		PartitionTupleRoutingInfo *ptrinfo;
+
+		ptrinfo = (PartitionTupleRoutingInfo *)
+							palloc0(sizeof(PartitionTupleRoutingInfo));
+		/* Stash a reference to this PartitionDispatch. */
+		ptrinfo->pd = pds[i];
+
+		/* State for extracting partition key from tuples will go here. */
+		ptrinfo->keystate = NIL;
+
+		/*
+		 * For every partitioned table other than root, we must store a tuple
+		 * table slot initialized with its tuple descriptor and a tuple
+		 * conversion map to convert a tuple from its parent's rowtype to its
+		 * own.  That is to make sure that we are looking at the correct row
+		 * using the correct tuple descriptor when computing its partition key
+		 * for tuple routing.
+		 */
+		if (pds[i]->parentoid != InvalidOid)
+		{
+			TupleDesc	tupdesc = RelationGetDescr(pds[i]->reldesc);
+
+			/* Open the parent relation descriptor if not already done. */
+			if (pds[i]->parentoid == RelationGetRelid(rel))
+				parent = rel;
+			else if (parent == NULL)
+				/* Locked by RelationGetPartitionDispatchInfo(). */
+				parent = heap_open(pds[i]->parentoid, NoLock);
+
+			ptrinfo->tupslot = MakeSingleTupleTableSlot(tupdesc);
+			ptrinfo->tupmap = convert_tuples_by_name(RelationGetDescr(parent),
+													 tupdesc,
+								  gettext_noop("could not convert row type"));
+			/*
+			 * Close the parent descriptor, if the next partitioned table in
+			 * the list is not a sibling, because it will have a different
+			 * parent if so.
+			 */
+			if (parent != NULL && parent != rel && i + 1 < *num_parted &&
+				pds[i + 1]->parentoid != pds[i]->parentoid)
+			{
+				heap_close(parent, NoLock);
+				parent = NULL;
+			}
+		}
+		else
+		{
+			/* Not required for the root partitioned table */
+			ptrinfo->tupslot = NULL;
+			ptrinfo->tupmap = NULL;
+		}
+
+		(*ptrinfos)[i] = ptrinfo;
+	}
+
+	/* For leaf partitions, we build ResultRelInfos and TupleConversionMaps. */
 	*num_partitions = list_length(leaf_parts);
 	*partitions = (ResultRelInfo *) palloc(*num_partitions *
 										   sizeof(ResultRelInfo));
@@ -3361,11 +3429,13 @@ ExecSetupPartitionTupleRouting(Relation rel,
  * by get_partition_for_tuple() unchanged.
  */
 int
-ExecFindPartition(ResultRelInfo *resultRelInfo, PartitionDispatch *pd,
-				  TupleTableSlot *slot, EState *estate)
+ExecFindPartition(ResultRelInfo *resultRelInfo,
+				  PartitionTupleRoutingInfo **ptrinfos,
+				  TupleTableSlot *slot,
+				  EState *estate)
 {
 	int			result;
-	PartitionDispatchData *failed_at;
+	PartitionTupleRoutingInfo *failed_at;
 	TupleTableSlot *failed_slot;
 
 	/*
@@ -3375,7 +3445,7 @@ ExecFindPartition(ResultRelInfo *resultRelInfo, PartitionDispatch *pd,
 	if (resultRelInfo->ri_PartitionCheck)
 		ExecPartitionCheck(resultRelInfo, slot, estate);
 
-	result = get_partition_for_tuple(pd, slot, estate,
+	result = get_partition_for_tuple(ptrinfos, slot, estate,
 									 &failed_at, &failed_slot);
 	if (result < 0)
 	{
@@ -3385,7 +3455,7 @@ ExecFindPartition(ResultRelInfo *resultRelInfo, PartitionDispatch *pd,
 		char	   *val_desc;
 		ExprContext *ecxt = GetPerTupleExprContext(estate);
 
-		failed_rel = failed_at->reldesc;
+		failed_rel = failed_at->pd->reldesc;
 		ecxt->ecxt_scantuple = failed_slot;
 		FormPartitionKeyDatum(failed_at, failed_slot, estate,
 							  key_values, key_isnull);
diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c
index 49586a3c03..61ea9afa01 100644
--- a/src/backend/executor/nodeModifyTable.c
+++ b/src/backend/executor/nodeModifyTable.c
@@ -278,7 +278,7 @@ ExecInsert(ModifyTableState *mtstate,
 	resultRelInfo = estate->es_result_relation_info;
 
 	/* Determine the partition to heap_insert the tuple into */
-	if (mtstate->mt_partition_dispatch_info)
+	if (mtstate->mt_ptrinfos)
 	{
 		int			leaf_part_index;
 		TupleConversionMap *map;
@@ -292,7 +292,7 @@ ExecInsert(ModifyTableState *mtstate,
 		 * respectively.
 		 */
 		leaf_part_index = ExecFindPartition(resultRelInfo,
-											mtstate->mt_partition_dispatch_info,
+											mtstate->mt_ptrinfos,
 											slot,
 											estate);
 		Assert(leaf_part_index >= 0 &&
@@ -1487,7 +1487,7 @@ ExecSetupTransitionCaptureState(ModifyTableState *mtstate, EState *estate)
 		int			numResultRelInfos;
 
 		/* Find the set of partitions so that we can find their TupleDescs. */
-		if (mtstate->mt_partition_dispatch_info != NULL)
+		if (mtstate->mt_ptrinfos != NULL)
 		{
 			/*
 			 * For INSERT via partitioned table, so we need TupleDescs based
@@ -1911,7 +1911,7 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 	if (operation == CMD_INSERT &&
 		rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
 	{
-		PartitionDispatch *partition_dispatch_info;
+		PartitionTupleRoutingInfo **ptrinfos;
 		ResultRelInfo *partitions;
 		TupleConversionMap **partition_tupconv_maps;
 		TupleTableSlot *partition_tuple_slot;
@@ -1921,13 +1921,13 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 		ExecSetupPartitionTupleRouting(rel,
 									   node->nominalRelation,
 									   estate,
-									   &partition_dispatch_info,
+									   &ptrinfos,
 									   &partitions,
 									   &partition_tupconv_maps,
 									   &partition_tuple_slot,
 									   &num_parted, &num_partitions);
-		mtstate->mt_partition_dispatch_info = partition_dispatch_info;
-		mtstate->mt_num_dispatch = num_parted;
+		mtstate->mt_ptrinfos = ptrinfos;
+		mtstate->mt_num_parted = num_parted;
 		mtstate->mt_partitions = partitions;
 		mtstate->mt_num_partitions = num_partitions;
 		mtstate->mt_partition_tupconv_maps = partition_tupconv_maps;
@@ -2342,21 +2342,24 @@ ExecEndModifyTable(ModifyTableState *node)
 														   resultRelInfo);
 	}
 
+	/* Release some resources that we acquired for tuple-routing. */
+
 	/*
-	 * Close all the partitioned tables, leaf partitions, and their indices
-	 *
-	 * Remember node->mt_partition_dispatch_info[0] corresponds to the root
-	 * partitioned table, which we must not try to close, because it is the
-	 * main target table of the query that will be closed by ExecEndPlan().
-	 * Also, tupslot is NULL for the root partitioned table.
+	 * node->mt_ptrinfos[0] corresponds to the root partitioned table, for
+	 * which we didn't create tupslot.  Also, its relation descriptor will
+	 * be closed in ExecEndPlan().
 	 */
-	for (i = 1; i < node->mt_num_dispatch; i++)
+	for (i = 1; i < node->mt_num_parted; i++)
 	{
-		PartitionDispatch pd = node->mt_partition_dispatch_info[i];
+		PartitionTupleRoutingInfo *ptrinfo = node->mt_ptrinfos[i];
 
-		heap_close(pd->reldesc, NoLock);
-		ExecDropSingleTupleTableSlot(pd->tupslot);
+		heap_close(ptrinfo->pd->reldesc, NoLock);
+		ExecDropSingleTupleTableSlot(ptrinfo->tupslot);
 	}
+
+	/*
+	 * Close all the leaf partitions and their indices.
+	 */
 	for (i = 0; i < node->mt_num_partitions; i++)
 	{
 		ResultRelInfo *resultRelInfo = node->mt_partitions + i;
diff --git a/src/include/catalog/partition.h b/src/include/catalog/partition.h
index 454a940a23..ebf82b55cf 100644
--- a/src/include/catalog/partition.h
+++ b/src/include/catalog/partition.h
@@ -45,13 +45,8 @@ typedef struct PartitionDescData *PartitionDesc;
  *
  *	reldesc		Relation descriptor of the table
  *	key			Partition key information of the table
- *	keystate	Execution state required for expressions in the partition key
  *	partdesc	Partition descriptor of the table
- *	tupslot		A standalone TupleTableSlot initialized with this table's tuple
- *				descriptor
- *	tupmap		TupleConversionMap to convert from the parent's rowtype to
- *				this table's rowtype (when extracting the partition key of a
- *				tuple just before routing it through this table)
+ *	parentoid	OID of the parent table (InvalidOid if root partitioned table)
  *	indexes		Array with partdesc->nparts members (for details on what
  *				individual members represent, see how they are set in
  *				RelationGetPartitionDispatchInfo())
@@ -61,10 +56,8 @@ typedef struct PartitionDispatchData
 {
 	Relation	reldesc;
 	PartitionKey key;
-	List	   *keystate;		/* list of ExprState */
 	PartitionDesc partdesc;
-	TupleTableSlot *tupslot;
-	TupleConversionMap *tupmap;
+	Oid			parentoid;
 	int		   *indexes;
 } PartitionDispatchData;
 
@@ -86,18 +79,19 @@ extern List *map_partition_varattnos(List *expr, int target_varno,
 extern List *RelationGetPartitionQual(Relation rel);
 extern Expr *get_partition_qual_relid(Oid relid);
 
-/* For tuple routing */
 extern PartitionDispatch *RelationGetPartitionDispatchInfo(Relation rel,
 								 int *num_parted, List **leaf_part_oids);
-extern void FormPartitionKeyDatum(PartitionDispatch pd,
+
+/* For tuple routing */
+extern void FormPartitionKeyDatum(PartitionTupleRoutingInfo *ptrinfo,
 					  TupleTableSlot *slot,
 					  EState *estate,
 					  Datum *values,
 					  bool *isnull);
-extern int get_partition_for_tuple(PartitionDispatch *pd,
+extern int get_partition_for_tuple(PartitionTupleRoutingInfo **ptrinfos,
 						TupleTableSlot *slot,
 						EState *estate,
-						PartitionDispatchData **failed_at,
+						PartitionTupleRoutingInfo **failed_at,
 						TupleTableSlot **failed_slot);
 extern Oid	get_default_oid_from_partdesc(PartitionDesc partdesc);
 extern Oid	get_default_partition_oid(Oid parentId);
diff --git a/src/include/executor/executor.h b/src/include/executor/executor.h
index 770881849c..aee7a41b31 100644
--- a/src/include/executor/executor.h
+++ b/src/include/executor/executor.h
@@ -209,13 +209,13 @@ extern HeapTuple EvalPlanQualGetTuple(EPQState *epqstate, Index rti);
 extern void ExecSetupPartitionTupleRouting(Relation rel,
 							   Index resultRTindex,
 							   EState *estate,
-							   PartitionDispatch **pd,
+							   PartitionTupleRoutingInfo ***ptrinfos,
 							   ResultRelInfo **partitions,
 							   TupleConversionMap ***tup_conv_maps,
 							   TupleTableSlot **partition_tuple_slot,
 							   int *num_parted, int *num_partitions);
 extern int ExecFindPartition(ResultRelInfo *resultRelInfo,
-				  PartitionDispatch *pd,
+				  PartitionTupleRoutingInfo **ptrinfos,
 				  TupleTableSlot *slot,
 				  EState *estate);
 
diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h
index 90a60abc4d..c554a1b311 100644
--- a/src/include/nodes/execnodes.h
+++ b/src/include/nodes/execnodes.h
@@ -414,6 +414,42 @@ typedef struct ResultRelInfo
 	Relation	ri_PartitionRoot;
 } ResultRelInfo;
 
+/* Forward declarations, to avoid including other headers */
+typedef struct PartitionDispatchData *PartitionDispatch;
+
+/*
+ * PartitionTupleRoutingInfo - information required for tuple-routing
+ *							   through one partitioned table in a partition
+ *							   tree
+ */
+typedef struct PartitionTupleRoutingInfo
+{
+
+	/* Information about the table's partitions */
+	PartitionDispatch	pd;
+
+	/*
+	 * The execution state required for expressions contained in the partition
+	 * key.  It is NIL until initialized by FormPartitionKeyDatum() if and when
+	 * it is called; for example, the first time a tuple is routed through this
+	 * table.
+	 */
+	List   *keystate;
+
+	/*
+	 * A standalone TupleTableSlot initialized with this table's tuple
+	 * descriptor
+	 */
+	TupleTableSlot *tupslot;
+
+	/*
+	 * TupleConversionMap to convert from the parent's rowtype to this table's
+	 * rowtype (when extracting the partition key of a tuple just before
+	 * routing it through this table)
+	 */
+	TupleConversionMap *tupmap;
+} PartitionTupleRoutingInfo;
+
 /* ----------------
  *	  EState information
  *
@@ -973,9 +1009,9 @@ typedef struct ModifyTableState
 	TupleTableSlot *mt_existing;	/* slot to store existing target tuple in */
 	List	   *mt_excludedtlist;	/* the excluded pseudo relation's tlist  */
 	TupleTableSlot *mt_conflproj;	/* CONFLICT ... SET ... projection target */
-	struct PartitionDispatchData **mt_partition_dispatch_info;
 	/* Tuple-routing support info */
-	int			mt_num_dispatch;	/* Number of entries in the above array */
+	struct PartitionTupleRoutingInfo **mt_ptrinfos;
+	int			mt_num_parted;		/* Number of entries in the above array */
 	int			mt_num_partitions;	/* Number of members in the following
 									 * arrays */
 	ResultRelInfo *mt_partitions;	/* Per partition result relation */
-- 
2.11.0

From e980019fdc688321af809d7d3547d25a3d6ff15f Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Fri, 8 Sep 2017 17:35:10 +0900
Subject: [PATCH 2/2] Make RelationGetPartitionDispatch expansion order
 depth-first

This is so as it matches what the planner is doing with partitioning
inheritance expansion.  Matching with planner order helps because
it helps ease matching the executor's per-partition objects with
planner-created per-partition nodes.
---
 src/backend/catalog/partition.c | 211 ++++++++++++++++------------------------
 1 file changed, 83 insertions(+), 128 deletions(-)

diff --git a/src/backend/catalog/partition.c b/src/backend/catalog/partition.c
index 555b7c21c7..84c63a9ffe 100644
--- a/src/backend/catalog/partition.c
+++ b/src/backend/catalog/partition.c
@@ -147,6 +147,8 @@ static int32 partition_bound_cmp(PartitionKey key,
 static int partition_bound_bsearch(PartitionKey key,
 						PartitionBoundInfo boundinfo,
 						void *probe, bool probe_is_bound, bool *is_equal);
+static void get_partition_dispatch_recurse(Relation rel, Relation parent,
+							   List **pds, List **leaf_part_oids);
 
 /*
  * RelationBuildPartitionDesc
@@ -1192,21 +1194,6 @@ get_partition_qual_relid(Oid relid)
 }
 
 /*
- * Append OIDs of rel's partitions to the list 'partoids' and for each OID,
- * append pointer rel to the list 'parents'.
- */
-#define APPEND_REL_PARTITION_OIDS(rel, partoids, parents) \
-	do\
-	{\
-		int		i;\
-		for (i = 0; i < (rel)->rd_partdesc->nparts; i++)\
-		{\
-			(partoids) = lappend_oid((partoids), (rel)->rd_partdesc->oids[i]);\
-			(parents) = lappend((parents), (rel));\
-		}\
-	} while(0)
-
-/*
  * RelationGetPartitionDispatchInfo
  *		Returns information necessary to route tuples down a partition tree
  *
@@ -1222,133 +1209,101 @@ PartitionDispatch *
 RelationGetPartitionDispatchInfo(Relation rel,
 								 int *num_parted, List **leaf_part_oids)
 {
+	List   *pdlist;
 	PartitionDispatchData **pd;
-	List	   *all_parts = NIL,
-			   *all_parents = NIL,
-			   *parted_rels,
-			   *parted_rel_parents;
-	ListCell   *lc1,
-			   *lc2;
-	int			i,
-				k,
-				offset;
+	ListCell *lc;
+	int		i;
 
-	/*
-	 * We rely on the relcache to traverse the partition tree to build both
-	 * the leaf partition OIDs list and the array of PartitionDispatch objects
-	 * for the partitioned tables in the tree.  That means every partitioned
-	 * table in the tree must be locked, which is fine since we require the
-	 * caller to lock all the partitions anyway.
-	 *
-	 * For every partitioned table in the tree, starting with the root
-	 * partitioned table, add its relcache entry to parted_rels, while also
-	 * queuing its partitions (in the order in which they appear in the
-	 * partition descriptor) to be looked at later in the same loop.  This is
-	 * a bit tricky but works because the foreach() macro doesn't fetch the
-	 * next list element until the bottom of the loop.
-	 */
-	*num_parted = 1;
-	parted_rels = list_make1(rel);
-	/* Root partitioned table has no parent, so NULL for parent */
-	parted_rel_parents = list_make1(NULL);
-	APPEND_REL_PARTITION_OIDS(rel, all_parts, all_parents);
-	forboth(lc1, all_parts, lc2, all_parents)
-	{
-		Oid			partrelid = lfirst_oid(lc1);
-		Relation	parent = lfirst(lc2);
+	Assert(rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE);
 
-		if (get_rel_relkind(partrelid) == RELKIND_PARTITIONED_TABLE)
-		{
-			/*
-			 * Already locked by the caller.  Note that it is the
-			 * responsibility of the caller to close the below relcache entry,
-			 * once done using the information being collected here (for
-			 * example, in ExecEndModifyTable).
-			 */
-			Relation	partrel = heap_open(partrelid, NoLock);
+	*num_parted = 0;
+	*leaf_part_oids = NIL;
 
-			(*num_parted)++;
-			parted_rels = lappend(parted_rels, partrel);
-			parted_rel_parents = lappend(parted_rel_parents, parent);
-			APPEND_REL_PARTITION_OIDS(partrel, all_parts, all_parents);
-		}
+	get_partition_dispatch_recurse(rel, NULL, &pdlist, leaf_part_oids);
+	*num_parted = list_length(pdlist);
+	pd = (PartitionDispatchData **) palloc(*num_parted *
+										   sizeof(PartitionDispatchData *));
+	i = 0;
+	foreach (lc, pdlist)
+	{
+		pd[i++] = lfirst(lc);
 	}
 
+	return pd;
+}
+
+/*
+ * get_partition_dispatch_recurse
+ *		Recursively expand partition tree rooted at rel
+ *
+ * As the partition tree is expanded in a depth-first manner, we mantain two
+ * global lists: of PartitionDispatch objects corresponding to partitioned
+ * tables in *pds and of the leaf partition OIDs in *leaf_part_oids.
+ */
+static void
+get_partition_dispatch_recurse(Relation rel, Relation parent,
+							   List **pds, List **leaf_part_oids)
+{
+	PartitionDesc	partdesc = RelationGetPartitionDesc(rel);
+	PartitionKey	partkey = RelationGetPartitionKey(rel);
+	PartitionDispatch pd;
+	int			i;
+
+	/* Build a PartitionDispatch for this table and add it to *pds. */
+	pd = (PartitionDispatch) palloc(sizeof(PartitionDispatchData));
+	*pds = lappend(*pds, pd);
+	pd->reldesc = rel;
+	pd->key = partkey;
+	pd->partdesc = partdesc;
+	if (parent != NULL)
+		pd->parentoid = RelationGetRelid(parent);
+	else
+		pd->parentoid = InvalidOid;
+
 	/*
-	 * We want to create two arrays - one for leaf partitions and another for
-	 * partitioned tables (including the root table and internal partitions).
-	 * While we only create the latter here, leaf partition array of suitable
-	 * objects (such as, ResultRelInfo) is created by the caller using the
-	 * list of OIDs we return.  Indexes into these arrays get assigned in a
-	 * breadth-first manner, whereby partitions of any given level are placed
-	 * consecutively in the respective arrays.
+	 * Go look at each partition of this table.  If it's a leaf partition,
+	 * simply add its OID to *leaf_part_oids.  If it's a partitioned table,
+	 * recursively call get_partition_dispatch_recurse(), so that its
+	 * partitions are processed as well and a corresponding PartitionDispatch
+	 * object gets added to *pds.
+	 *
+	 * About the values in pd->indexes: for a leaf partition, it contains the
+	 * leaf partition's position in the global list *leaf_part_oids minus 1,
+	 * whereas for a partitioned table partition, it contains the partition's
+	 * position in the global list *pds multiplied by -1.  The latter is
+	 * multiplied by -1 to distinguish partitioned tables from leaf partitions
+	 * when going through the values in pd->indexes.  So, for example, when
+	 * using it during tuple-routing, encountering a value >= 0 means we found
+	 * a leaf partition.  It is immediately returned as the index in the array
+	 * of ResultRelInfos of all the leaf partitions, using which we insert the
+	 * tuple into that leaf partition.  A negative value means we found a
+	 * partitioned table.  The value multiplied back by -1 is returned as the
+	 * index in the array of PartitionDispatch objects of all partitioned
+	 * tables in the tree, using which, search is continued further down the
+	 * partition tree.
 	 */
-	pd = (PartitionDispatchData **) palloc(*num_parted *
-										   sizeof(PartitionDispatchData *));
-	*leaf_part_oids = NIL;
-	i = k = offset = 0;
-	forboth(lc1, parted_rels, lc2, parted_rel_parents)
+	pd->indexes = (int *) palloc(partdesc->nparts * sizeof(int));
+	for (i = 0; i < partdesc->nparts; i++)
 	{
-		Relation	partrel = lfirst(lc1);
-		Relation	parent = lfirst(lc2);
-		PartitionKey partkey = RelationGetPartitionKey(partrel);
-		PartitionDesc partdesc = RelationGetPartitionDesc(partrel);
-		int			j,
-					m;
-
-		pd[i] = (PartitionDispatch) palloc(sizeof(PartitionDispatchData));
-		pd[i]->reldesc = partrel;
-		pd[i]->key = partkey;
-		pd[i]->partdesc = partdesc;
-		if (parent != NULL)
-			pd[i]->parentoid = RelationGetRelid(parent);
-		else
-			pd[i]->parentoid = InvalidOid;
-
-		pd[i]->indexes = (int *) palloc(partdesc->nparts * sizeof(int));
+		Oid			partrelid = partdesc->oids[i];
 
-		/*
-		 * Indexes corresponding to the internal partitions are multiplied by
-		 * -1 to distinguish them from those of leaf partitions.  Encountering
-		 * an index >= 0 means we found a leaf partition, which is immediately
-		 * returned as the partition we are looking for.  A negative index
-		 * means we found a partitioned table, whose PartitionDispatch object
-		 * is located at the above index multiplied back by -1.  Using the
-		 * PartitionDispatch object, search is continued further down the
-		 * partition tree.
-		 */
-		m = 0;
-		for (j = 0; j < partdesc->nparts; j++)
+		if (get_rel_relkind(partrelid) != RELKIND_PARTITIONED_TABLE)
 		{
-			Oid			partrelid = partdesc->oids[j];
-
-			if (get_rel_relkind(partrelid) != RELKIND_PARTITIONED_TABLE)
-			{
-				*leaf_part_oids = lappend_oid(*leaf_part_oids, partrelid);
-				pd[i]->indexes[j] = k++;
-			}
-			else
-			{
-				/*
-				 * offset denotes the number of partitioned tables of upper
-				 * levels including those of the current level.  Any partition
-				 * of this table must belong to the next level and hence will
-				 * be placed after the last partitioned table of this level.
-				 */
-				pd[i]->indexes[j] = -(1 + offset + m);
-				m++;
-			}
+			*leaf_part_oids = lappend_oid(*leaf_part_oids, partrelid);
+			pd->indexes[i] = list_length(*leaf_part_oids) - 1;
 		}
-		i++;
+		else
+		{
+			/*
+			 * We assume all tables in the partition tree were already
+			 * locked by the caller.
+			 */
+			Relation partrel = heap_open(partrelid, NoLock);
 
-		/*
-		 * This counts the number of partitioned tables at upper levels
-		 * including those of the current level.
-		 */
-		offset += m;
+			pd->indexes[i] = -list_length(*pds);
+			get_partition_dispatch_recurse(partrel, rel, pds, leaf_part_oids);
+		}
 	}
-
-	return pd;
 }
 
 /* Module-local functions */
-- 
2.11.0

From 1e99c776eda30c29fdb0e48570d6b3acd6b9a05d Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Fri, 8 Sep 2017 17:35:10 +0900
Subject: [PATCH] Make RelationGetPartitionDispatch expansion order depth-first

This is so as it matches what the planner is doing with partitioning
inheritance expansion.  Matching with planner order helps because
it helps ease matching the executor's per-partition objects with
planner-created per-partition nodes.
---
 src/backend/catalog/partition.c | 242 ++++++++++++++++------------------------
 1 file changed, 99 insertions(+), 143 deletions(-)

diff --git a/src/backend/catalog/partition.c b/src/backend/catalog/partition.c
index 73eff17202..ddb46a80cb 100644
--- a/src/backend/catalog/partition.c
+++ b/src/backend/catalog/partition.c
@@ -147,6 +147,8 @@ static int32 partition_bound_cmp(PartitionKey key,
 static int partition_bound_bsearch(PartitionKey key,
 						PartitionBoundInfo boundinfo,
 						void *probe, bool probe_is_bound, bool *is_equal);
+static void get_partition_dispatch_recurse(Relation rel, Relation parent,
+							   List **pds, List **leaf_part_oids);
 
 /*
  * RelationBuildPartitionDesc
@@ -1192,21 +1194,6 @@ get_partition_qual_relid(Oid relid)
 }
 
 /*
- * Append OIDs of rel's partitions to the list 'partoids' and for each OID,
- * append pointer rel to the list 'parents'.
- */
-#define APPEND_REL_PARTITION_OIDS(rel, partoids, parents) \
-	do\
-	{\
-		int		i;\
-		for (i = 0; i < (rel)->rd_partdesc->nparts; i++)\
-		{\
-			(partoids) = lappend_oid((partoids), (rel)->rd_partdesc->oids[i]);\
-			(parents) = lappend((parents), (rel));\
-		}\
-	} while(0)
-
-/*
  * RelationGetPartitionDispatchInfo
  *		Returns information necessary to route tuples down a partition tree
  *
@@ -1222,151 +1209,120 @@ PartitionDispatch *
 RelationGetPartitionDispatchInfo(Relation rel,
 								 int *num_parted, List **leaf_part_oids)
 {
+	List   *pdlist;
 	PartitionDispatchData **pd;
-	List	   *all_parts = NIL,
-			   *all_parents = NIL,
-			   *parted_rels,
-			   *parted_rel_parents;
-	ListCell   *lc1,
-			   *lc2;
-	int			i,
-				k,
-				offset;
+	ListCell *lc;
+	int		i;
 
-	/*
-	 * We rely on the relcache to traverse the partition tree to build both
-	 * the leaf partition OIDs list and the array of PartitionDispatch objects
-	 * for the partitioned tables in the tree.  That means every partitioned
-	 * table in the tree must be locked, which is fine since we require the
-	 * caller to lock all the partitions anyway.
-	 *
-	 * For every partitioned table in the tree, starting with the root
-	 * partitioned table, add its relcache entry to parted_rels, while also
-	 * queuing its partitions (in the order in which they appear in the
-	 * partition descriptor) to be looked at later in the same loop.  This is
-	 * a bit tricky but works because the foreach() macro doesn't fetch the
-	 * next list element until the bottom of the loop.
-	 */
-	*num_parted = 1;
-	parted_rels = list_make1(rel);
-	/* Root partitioned table has no parent, so NULL for parent */
-	parted_rel_parents = list_make1(NULL);
-	APPEND_REL_PARTITION_OIDS(rel, all_parts, all_parents);
-	forboth(lc1, all_parts, lc2, all_parents)
+	Assert(rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE);
+
+	*num_parted = 0;
+	*leaf_part_oids = NIL;
+
+	get_partition_dispatch_recurse(rel, NULL, &pdlist, leaf_part_oids);
+	*num_parted = list_length(pdlist);
+	pd = (PartitionDispatchData **) palloc(*num_parted *
+										   sizeof(PartitionDispatchData *));
+	i = 0;
+	foreach (lc, pdlist)
 	{
-		Oid			partrelid = lfirst_oid(lc1);
-		Relation	parent = lfirst(lc2);
+		pd[i++] = lfirst(lc);
+	}
 
-		if (get_rel_relkind(partrelid) == RELKIND_PARTITIONED_TABLE)
-		{
-			/*
-			 * Already locked by the caller.  Note that it is the
-			 * responsibility of the caller to close the below relcache entry,
-			 * once done using the information being collected here (for
-			 * example, in ExecEndModifyTable).
-			 */
-			Relation	partrel = heap_open(partrelid, NoLock);
+	return pd;
+}
 
-			(*num_parted)++;
-			parted_rels = lappend(parted_rels, partrel);
-			parted_rel_parents = lappend(parted_rel_parents, parent);
-			APPEND_REL_PARTITION_OIDS(partrel, all_parts, all_parents);
-		}
+/*
+ * get_partition_dispatch_recurse
+ *		Recursively expand partition tree rooted at rel
+ *
+ * As the partition tree is expanded in a depth-first manner, we mantain two
+ * global lists: of PartitionDispatch objects corresponding to partitioned
+ * tables in *pds and of the leaf partition OIDs in *leaf_part_oids.
+ */
+static void
+get_partition_dispatch_recurse(Relation rel, Relation parent,
+							   List **pds, List **leaf_part_oids)
+{
+	TupleDesc		tupdesc = RelationGetDescr(rel);
+	PartitionDesc	partdesc = RelationGetPartitionDesc(rel);
+	PartitionKey	partkey = RelationGetPartitionKey(rel);
+	PartitionDispatch pd;
+	int			i;
+
+	/* Build a PartitionDispatch for this table and add it to *pds. */
+	pd = (PartitionDispatch) palloc(sizeof(PartitionDispatchData));
+	*pds = lappend(*pds, pd);
+	pd->reldesc = rel;
+	pd->key = partkey;
+	pd->keystate = NIL;
+	pd->partdesc = partdesc;
+	if (parent != NULL)
+	{
+		/*
+		 * For every partitioned table other than root, we must store a
+		 * tuple table slot initialized with its tuple descriptor and a
+		 * tuple conversion map to convert a tuple from its parent's
+		 * rowtype to its own. That is to make sure that we are looking at
+		 * the correct row using the correct tuple descriptor when
+		 * computing its partition key for tuple routing.
+		 */
+		pd->tupslot = MakeSingleTupleTableSlot(tupdesc);
+		pd->tupmap = convert_tuples_by_name(RelationGetDescr(parent),
+											tupdesc,
+								gettext_noop("could not convert row type"));
+	}
+	else
+	{
+		/* Not required for the root partitioned table */
+		pd->tupslot = NULL;
+		pd->tupmap = NULL;
 	}
 
 	/*
-	 * We want to create two arrays - one for leaf partitions and another for
-	 * partitioned tables (including the root table and internal partitions).
-	 * While we only create the latter here, leaf partition array of suitable
-	 * objects (such as, ResultRelInfo) is created by the caller using the
-	 * list of OIDs we return.  Indexes into these arrays get assigned in a
-	 * breadth-first manner, whereby partitions of any given level are placed
-	 * consecutively in the respective arrays.
+	 * Go look at each partition of this table.  If it's a leaf partition,
+	 * simply add its OID to *leaf_part_oids.  If it's a partitioned table,
+	 * recursively call get_partition_dispatch_recurse(), so that its
+	 * partitions are processed as well and a corresponding PartitionDispatch
+	 * object gets added to *pds.
+	 *
+	 * About the values in pd->indexes: for a leaf partition, it contains the
+	 * leaf partition's position in the global list *leaf_part_oids minus 1,
+	 * whereas for a partitioned table partition, it contains the partition's
+	 * position in the global list *pds multiplied by -1.  The latter is
+	 * multiplied by -1 to distinguish partitioned tables from leaf partitions
+	 * when going through the values in pd->indexes.  So, for example, when
+	 * using it during tuple-routing, encountering a value >= 0 means we found
+	 * a leaf partition.  It is immediately returned as the index in the array
+	 * of ResultRelInfos of all the leaf partitions, using which we insert the
+	 * tuple into that leaf partition.  A negative value means we found a
+	 * partitioned table.  The value multiplied back by -1 is returned as the
+	 * index in the array of PartitionDispatch objects of all partitioned
+	 * tables in the tree, using which, search is continued further down the
+	 * partition tree.
 	 */
-	pd = (PartitionDispatchData **) palloc(*num_parted *
-										   sizeof(PartitionDispatchData *));
-	*leaf_part_oids = NIL;
-	i = k = offset = 0;
-	forboth(lc1, parted_rels, lc2, parted_rel_parents)
+	pd->indexes = (int *) palloc(partdesc->nparts * sizeof(int));
+	for (i = 0; i < partdesc->nparts; i++)
 	{
-		Relation	partrel = lfirst(lc1);
-		Relation	parent = lfirst(lc2);
-		PartitionKey partkey = RelationGetPartitionKey(partrel);
-		TupleDesc	tupdesc = RelationGetDescr(partrel);
-		PartitionDesc partdesc = RelationGetPartitionDesc(partrel);
-		int			j,
-					m;
-
-		pd[i] = (PartitionDispatch) palloc(sizeof(PartitionDispatchData));
-		pd[i]->reldesc = partrel;
-		pd[i]->key = partkey;
-		pd[i]->keystate = NIL;
-		pd[i]->partdesc = partdesc;
-		if (parent != NULL)
+		Oid			partrelid = partdesc->oids[i];
+
+		if (get_rel_relkind(partrelid) != RELKIND_PARTITIONED_TABLE)
 		{
-			/*
-			 * For every partitioned table other than root, we must store a
-			 * tuple table slot initialized with its tuple descriptor and a
-			 * tuple conversion map to convert a tuple from its parent's
-			 * rowtype to its own. That is to make sure that we are looking at
-			 * the correct row using the correct tuple descriptor when
-			 * computing its partition key for tuple routing.
-			 */
-			pd[i]->tupslot = MakeSingleTupleTableSlot(tupdesc);
-			pd[i]->tupmap = convert_tuples_by_name(RelationGetDescr(parent),
-												   tupdesc,
-												   gettext_noop("could not convert row type"));
+			*leaf_part_oids = lappend_oid(*leaf_part_oids, partrelid);
+			pd->indexes[i] = list_length(*leaf_part_oids) - 1;
 		}
 		else
 		{
-			/* Not required for the root partitioned table */
-			pd[i]->tupslot = NULL;
-			pd[i]->tupmap = NULL;
-		}
-		pd[i]->indexes = (int *) palloc(partdesc->nparts * sizeof(int));
-
-		/*
-		 * Indexes corresponding to the internal partitions are multiplied by
-		 * -1 to distinguish them from those of leaf partitions.  Encountering
-		 * an index >= 0 means we found a leaf partition, which is immediately
-		 * returned as the partition we are looking for.  A negative index
-		 * means we found a partitioned table, whose PartitionDispatch object
-		 * is located at the above index multiplied back by -1.  Using the
-		 * PartitionDispatch object, search is continued further down the
-		 * partition tree.
-		 */
-		m = 0;
-		for (j = 0; j < partdesc->nparts; j++)
-		{
-			Oid			partrelid = partdesc->oids[j];
+			/*
+			 * We assume all tables in the partition tree were already
+			 * locked by the caller.
+			 */
+			Relation partrel = heap_open(partrelid, NoLock);
 
-			if (get_rel_relkind(partrelid) != RELKIND_PARTITIONED_TABLE)
-			{
-				*leaf_part_oids = lappend_oid(*leaf_part_oids, partrelid);
-				pd[i]->indexes[j] = k++;
-			}
-			else
-			{
-				/*
-				 * offset denotes the number of partitioned tables of upper
-				 * levels including those of the current level.  Any partition
-				 * of this table must belong to the next level and hence will
-				 * be placed after the last partitioned table of this level.
-				 */
-				pd[i]->indexes[j] = -(1 + offset + m);
-				m++;
-			}
+			pd->indexes[i] = -list_length(*pds);
+			get_partition_dispatch_recurse(partrel, rel, pds, leaf_part_oids);
 		}
-		i++;
-
-		/*
-		 * This counts the number of partitioned tables at upper levels
-		 * including those of the current level.
-		 */
-		offset += m;
 	}
-
-	return pd;
 }
 
 /* Module-local functions */
-- 
2.11.0

From c2599d52267cc362e059452efe69ddd09b94c083 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Fri, 8 Sep 2017 17:35:10 +0900
Subject: [PATCH] Make RelationGetPartitionDispatch expansion order depth-first

This is so as it matches what the planner is doing with partitioning
inheritance expansion.  Matching with planner order helps because
it helps ease matching the executor's per-partition objects with
planner-created per-partition nodes.
---
 src/backend/catalog/partition.c | 252 +++++++++++++++++-----------------------
 1 file changed, 109 insertions(+), 143 deletions(-)

diff --git a/src/backend/catalog/partition.c b/src/backend/catalog/partition.c
index 73eff17202..36f52ddb98 100644
--- a/src/backend/catalog/partition.c
+++ b/src/backend/catalog/partition.c
@@ -147,6 +147,8 @@ static int32 partition_bound_cmp(PartitionKey key,
 static int partition_bound_bsearch(PartitionKey key,
 						PartitionBoundInfo boundinfo,
 						void *probe, bool probe_is_bound, bool *is_equal);
+static void get_partition_dispatch_recurse(Relation rel, Relation parent,
+							   List **pds, List **leaf_part_oids);
 
 /*
  * RelationBuildPartitionDesc
@@ -1192,21 +1194,6 @@ get_partition_qual_relid(Oid relid)
 }
 
 /*
- * Append OIDs of rel's partitions to the list 'partoids' and for each OID,
- * append pointer rel to the list 'parents'.
- */
-#define APPEND_REL_PARTITION_OIDS(rel, partoids, parents) \
-	do\
-	{\
-		int		i;\
-		for (i = 0; i < (rel)->rd_partdesc->nparts; i++)\
-		{\
-			(partoids) = lappend_oid((partoids), (rel)->rd_partdesc->oids[i]);\
-			(parents) = lappend((parents), (rel));\
-		}\
-	} while(0)
-
-/*
  * RelationGetPartitionDispatchInfo
  *		Returns information necessary to route tuples down a partition tree
  *
@@ -1222,151 +1209,130 @@ PartitionDispatch *
 RelationGetPartitionDispatchInfo(Relation rel,
 								 int *num_parted, List **leaf_part_oids)
 {
+	List   *pdlist;
 	PartitionDispatchData **pd;
-	List	   *all_parts = NIL,
-			   *all_parents = NIL,
-			   *parted_rels,
-			   *parted_rel_parents;
-	ListCell   *lc1,
-			   *lc2;
-	int			i,
-				k,
-				offset;
+	ListCell *lc;
+	int		i;
 
-	/*
-	 * We rely on the relcache to traverse the partition tree to build both
-	 * the leaf partition OIDs list and the array of PartitionDispatch objects
-	 * for the partitioned tables in the tree.  That means every partitioned
-	 * table in the tree must be locked, which is fine since we require the
-	 * caller to lock all the partitions anyway.
-	 *
-	 * For every partitioned table in the tree, starting with the root
-	 * partitioned table, add its relcache entry to parted_rels, while also
-	 * queuing its partitions (in the order in which they appear in the
-	 * partition descriptor) to be looked at later in the same loop.  This is
-	 * a bit tricky but works because the foreach() macro doesn't fetch the
-	 * next list element until the bottom of the loop.
-	 */
-	*num_parted = 1;
-	parted_rels = list_make1(rel);
-	/* Root partitioned table has no parent, so NULL for parent */
-	parted_rel_parents = list_make1(NULL);
-	APPEND_REL_PARTITION_OIDS(rel, all_parts, all_parents);
-	forboth(lc1, all_parts, lc2, all_parents)
+	Assert(rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE);
+
+	*num_parted = 0;
+	*leaf_part_oids = NIL;
+
+	get_partition_dispatch_recurse(rel, NULL, &pdlist, leaf_part_oids);
+	*num_parted = list_length(pdlist);
+	pd = (PartitionDispatchData **) palloc(*num_parted *
+										   sizeof(PartitionDispatchData *));
+	i = 0;
+	foreach (lc, pdlist)
 	{
-		Oid			partrelid = lfirst_oid(lc1);
-		Relation	parent = lfirst(lc2);
+		pd[i++] = lfirst(lc);
+	}
 
-		if (get_rel_relkind(partrelid) == RELKIND_PARTITIONED_TABLE)
-		{
-			/*
-			 * Already locked by the caller.  Note that it is the
-			 * responsibility of the caller to close the below relcache entry,
-			 * once done using the information being collected here (for
-			 * example, in ExecEndModifyTable).
-			 */
-			Relation	partrel = heap_open(partrelid, NoLock);
+	return pd;
+}
 
-			(*num_parted)++;
-			parted_rels = lappend(parted_rels, partrel);
-			parted_rel_parents = lappend(parted_rel_parents, parent);
-			APPEND_REL_PARTITION_OIDS(partrel, all_parts, all_parents);
-		}
+/*
+ * get_partition_dispatch_recurse
+ *		Recursively expand partition tree rooted at rel
+ *
+ * As the partition tree is expanded in a depth-first manner, we mantain two
+ * global lists: of PartitionDispatch objects corresponding to partitioned
+ * tables in *pds and of the leaf partition OIDs in *leaf_part_oids.
+ *
+ * Note that the order of OIDs of leaf partitions in leaf_part_oids matches
+ * the order in which the planner's expand_partitioned_rtentry() processes
+ * them.  So, the N'th entry in leaf_part_oids will correspond to the N'th
+ * child of the Append/ModifyTable node for rel, provided the latter contains
+ * all leaf partitions of rel.  If the latter skips some leaf partitions,
+ * because they were pruned by the planner, simply skip the corresponding
+ * entries from leaf_part_oids.
+ */
+static void
+get_partition_dispatch_recurse(Relation rel, Relation parent,
+							   List **pds, List **leaf_part_oids)
+{
+	TupleDesc		tupdesc = RelationGetDescr(rel);
+	PartitionDesc	partdesc = RelationGetPartitionDesc(rel);
+	PartitionKey	partkey = RelationGetPartitionKey(rel);
+	PartitionDispatch pd;
+	int			i;
+
+	check_stack_depth();
+
+	/* Build a PartitionDispatch for this table and add it to *pds. */
+	pd = (PartitionDispatch) palloc(sizeof(PartitionDispatchData));
+	*pds = lappend(*pds, pd);
+	pd->reldesc = rel;
+	pd->key = partkey;
+	pd->keystate = NIL;
+	pd->partdesc = partdesc;
+	if (parent != NULL)
+	{
+		/*
+		 * For every partitioned table other than the root, we must store a
+		 * tuple table slot initialized with its tuple descriptor and a
+		 * tuple conversion map to convert a tuple from its parent's
+		 * rowtype to its own. That is to make sure that we are looking at
+		 * the correct row using the correct tuple descriptor when
+		 * computing its partition key for tuple routing.
+		 */
+		pd->tupslot = MakeSingleTupleTableSlot(tupdesc);
+		pd->tupmap = convert_tuples_by_name(RelationGetDescr(parent),
+											tupdesc,
+								gettext_noop("could not convert row type"));
+	}
+	else
+	{
+		/* Not required for the root partitioned table */
+		pd->tupslot = NULL;
+		pd->tupmap = NULL;
 	}
 
 	/*
-	 * We want to create two arrays - one for leaf partitions and another for
-	 * partitioned tables (including the root table and internal partitions).
-	 * While we only create the latter here, leaf partition array of suitable
-	 * objects (such as, ResultRelInfo) is created by the caller using the
-	 * list of OIDs we return.  Indexes into these arrays get assigned in a
-	 * breadth-first manner, whereby partitions of any given level are placed
-	 * consecutively in the respective arrays.
+	 * Go look at each partition of this table.  If it's a leaf partition,
+	 * simply add its OID to *leaf_part_oids.  If it's a partitioned table,
+	 * recursively call get_partition_dispatch_recurse(), so that its
+	 * partitions are processed as well and a corresponding PartitionDispatch
+	 * object gets added to *pds.
+	 *
+	 * About the values in pd->indexes: for a leaf partition, it contains the
+	 * leaf partition's position in the global list *leaf_part_oids minus 1,
+	 * whereas for a partitioned table partition, it contains the partition's
+	 * position in the global list *pds multiplied by -1.  The latter is
+	 * multiplied by -1 to distinguish partitioned tables from leaf partitions
+	 * when going through the values in pd->indexes.  So, for example, when
+	 * using it during tuple-routing, encountering a value >= 0 means we found
+	 * a leaf partition.  It is immediately returned as the index in the array
+	 * of ResultRelInfos of all the leaf partitions, using which we insert the
+	 * tuple into that leaf partition.  A negative value means we found a
+	 * partitioned table.  The value multiplied by -1 is returned as the index
+	 * in the array of PartitionDispatch objects of all partitioned tables in
+	 * the tree.  This value is used to continue the search in the next level
+	 * of the partition tree.
 	 */
-	pd = (PartitionDispatchData **) palloc(*num_parted *
-										   sizeof(PartitionDispatchData *));
-	*leaf_part_oids = NIL;
-	i = k = offset = 0;
-	forboth(lc1, parted_rels, lc2, parted_rel_parents)
+	pd->indexes = (int *) palloc(partdesc->nparts * sizeof(int));
+	for (i = 0; i < partdesc->nparts; i++)
 	{
-		Relation	partrel = lfirst(lc1);
-		Relation	parent = lfirst(lc2);
-		PartitionKey partkey = RelationGetPartitionKey(partrel);
-		TupleDesc	tupdesc = RelationGetDescr(partrel);
-		PartitionDesc partdesc = RelationGetPartitionDesc(partrel);
-		int			j,
-					m;
-
-		pd[i] = (PartitionDispatch) palloc(sizeof(PartitionDispatchData));
-		pd[i]->reldesc = partrel;
-		pd[i]->key = partkey;
-		pd[i]->keystate = NIL;
-		pd[i]->partdesc = partdesc;
-		if (parent != NULL)
+		Oid			partrelid = partdesc->oids[i];
+
+		if (get_rel_relkind(partrelid) != RELKIND_PARTITIONED_TABLE)
 		{
-			/*
-			 * For every partitioned table other than root, we must store a
-			 * tuple table slot initialized with its tuple descriptor and a
-			 * tuple conversion map to convert a tuple from its parent's
-			 * rowtype to its own. That is to make sure that we are looking at
-			 * the correct row using the correct tuple descriptor when
-			 * computing its partition key for tuple routing.
-			 */
-			pd[i]->tupslot = MakeSingleTupleTableSlot(tupdesc);
-			pd[i]->tupmap = convert_tuples_by_name(RelationGetDescr(parent),
-												   tupdesc,
-												   gettext_noop("could not convert row type"));
+			*leaf_part_oids = lappend_oid(*leaf_part_oids, partrelid);
+			pd->indexes[i] = list_length(*leaf_part_oids) - 1;
 		}
 		else
 		{
-			/* Not required for the root partitioned table */
-			pd[i]->tupslot = NULL;
-			pd[i]->tupmap = NULL;
-		}
-		pd[i]->indexes = (int *) palloc(partdesc->nparts * sizeof(int));
-
-		/*
-		 * Indexes corresponding to the internal partitions are multiplied by
-		 * -1 to distinguish them from those of leaf partitions.  Encountering
-		 * an index >= 0 means we found a leaf partition, which is immediately
-		 * returned as the partition we are looking for.  A negative index
-		 * means we found a partitioned table, whose PartitionDispatch object
-		 * is located at the above index multiplied back by -1.  Using the
-		 * PartitionDispatch object, search is continued further down the
-		 * partition tree.
-		 */
-		m = 0;
-		for (j = 0; j < partdesc->nparts; j++)
-		{
-			Oid			partrelid = partdesc->oids[j];
+			/*
+			 * We assume all tables in the partition tree were already
+			 * locked by the caller.
+			 */
+			Relation partrel = heap_open(partrelid, NoLock);
 
-			if (get_rel_relkind(partrelid) != RELKIND_PARTITIONED_TABLE)
-			{
-				*leaf_part_oids = lappend_oid(*leaf_part_oids, partrelid);
-				pd[i]->indexes[j] = k++;
-			}
-			else
-			{
-				/*
-				 * offset denotes the number of partitioned tables of upper
-				 * levels including those of the current level.  Any partition
-				 * of this table must belong to the next level and hence will
-				 * be placed after the last partitioned table of this level.
-				 */
-				pd[i]->indexes[j] = -(1 + offset + m);
-				m++;
-			}
+			pd->indexes[i] = -list_length(*pds);
+			get_partition_dispatch_recurse(partrel, rel, pds, leaf_part_oids);
 		}
-		i++;
-
-		/*
-		 * This counts the number of partitioned tables at upper levels
-		 * including those of the current level.
-		 */
-		offset += m;
 	}
-
-	return pd;
 }
 
 /* Module-local functions */
-- 
2.11.0