non-bulk inserts and tuple routing

From 187683f6ea153e8be1a5c067b3546e70b15ccd47 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Tue, 19 Dec 2017 10:43:45 +0900
Subject: [PATCH v2 1/4] Teach CopyFrom to use ModifyTableState for
 tuple-routing

This removes all fields of CopyStateData that were meant for
tuple routing and instead uses ModifyTableState that has all those
fields, including transition_tupconv_maps.  In COPY's case,
transition_tupconv_maps is only required if tuple routing is being
used, so it's safe.
---
 src/backend/commands/copy.c | 33 ++++++++++++++++++---------------
 1 file changed, 18 insertions(+), 15 deletions(-)

diff --git a/src/backend/commands/copy.c b/src/backend/commands/copy.c
index 6bfca2a4af..242dc56d87 100644
--- a/src/backend/commands/copy.c
+++ b/src/backend/commands/copy.c
@@ -166,11 +166,7 @@ typedef struct CopyStateData
 	bool		volatile_defexprs;	/* is any of defexprs volatile? */
 	List	   *range_table;
 
-	/* Tuple-routing support info */
-	PartitionTupleRouting *partition_tuple_routing;
-
 	TransitionCaptureState *transition_capture;
-	TupleConversionMap **transition_tupconv_maps;
 
 	/*
 	 * These variables are used to reduce overhead in textual COPY FROM.
@@ -2286,6 +2282,7 @@ CopyFrom(CopyState cstate)
 	ResultRelInfo *resultRelInfo;
 	ResultRelInfo *saved_resultRelInfo = NULL;
 	EState	   *estate = CreateExecutorState(); /* for ExecConstraints() */
+	ModifyTableState *mtstate = makeNode(ModifyTableState);
 	ExprContext *econtext;
 	TupleTableSlot *myslot;
 	MemoryContext oldcontext = CurrentMemoryContext;
@@ -2304,6 +2301,8 @@ CopyFrom(CopyState cstate)
 	Size		bufferedTuplesSize = 0;
 	int			firstBufferedLineNo = 0;
 
+	PartitionTupleRouting *proute = NULL;
+
 	Assert(cstate->rel);
 
 	/*
@@ -2469,10 +2468,15 @@ CopyFrom(CopyState cstate)
 	 */
 	if (cstate->rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
 	{
-		PartitionTupleRouting *proute;
+		ModifyTable *node = makeNode(ModifyTable);
 
-		proute = cstate->partition_tuple_routing =
-			ExecSetupPartitionTupleRouting(NULL, cstate->rel, 1, estate);
+		/* Just need make this field appear valid. */
+		node->nominalRelation = 1;
+		mtstate->ps.plan = (Plan *) node;
+		mtstate->ps.state = estate;
+		mtstate->resultRelInfo = resultRelInfo;
+		proute = mtstate->mt_partition_tuple_routing =
+			ExecSetupPartitionTupleRouting(mtstate, cstate->rel, 1, estate);
 
 		/*
 		 * If we are capturing transition tuples, they may need to be
@@ -2484,11 +2488,11 @@ CopyFrom(CopyState cstate)
 		{
 			int			i;
 
-			cstate->transition_tupconv_maps = (TupleConversionMap **)
+			mtstate->mt_transition_tupconv_maps = (TupleConversionMap **)
 				palloc0(sizeof(TupleConversionMap *) * proute->num_partitions);
 			for (i = 0; i < proute->num_partitions; ++i)
 			{
-				cstate->transition_tupconv_maps[i] =
+				mtstate->mt_transition_tupconv_maps[i] =
 					convert_tuples_by_name(RelationGetDescr(proute->partitions[i]->ri_RelationDesc),
 										   RelationGetDescr(cstate->rel),
 										   gettext_noop("could not convert row type"));
@@ -2509,7 +2513,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_tuple_routing != NULL ||
+		mtstate->mt_partition_tuple_routing != NULL ||
 		cstate->volatile_defexprs)
 	{
 		useHeapMultiInsert = false;
@@ -2584,11 +2588,10 @@ CopyFrom(CopyState cstate)
 		ExecStoreTuple(tuple, slot, InvalidBuffer, false);
 
 		/* Determine the partition to heap_insert the tuple into */
-		if (cstate->partition_tuple_routing)
+		if (cstate->rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
 		{
 			int			leaf_part_index;
 			TupleConversionMap *map;
-			PartitionTupleRouting *proute = cstate->partition_tuple_routing;
 
 			/*
 			 * Away we go ... If we end up not finding a partition after all,
@@ -2651,7 +2654,7 @@ CopyFrom(CopyState cstate)
 					 */
 					cstate->transition_capture->tcs_original_insert_tuple = NULL;
 					cstate->transition_capture->tcs_map =
-						cstate->transition_tupconv_maps[leaf_part_index];
+						mtstate->mt_transition_tupconv_maps[leaf_part_index];
 				}
 				else
 				{
@@ -2832,8 +2835,8 @@ CopyFrom(CopyState cstate)
 	ExecCloseIndices(resultRelInfo);
 
 	/* Close all the partitioned tables, leaf partitions, and their indices */
-	if (cstate->partition_tuple_routing)
-		ExecCleanupTupleRouting(cstate->partition_tuple_routing);
+	if (proute)
+		ExecCleanupTupleRouting(proute);
 
 	/* Close any trigger target relations */
 	ExecCleanUpTriggerState(estate);
-- 
2.11.0

From c05bbc58f7e994d21df210a16985911bc4954f50 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Tue, 19 Dec 2017 13:56:25 +0900
Subject: [PATCH v2 2/4] ExecFindPartition refactoring

---
 src/backend/commands/copy.c            |  5 +----
 src/backend/executor/execPartition.c   | 15 +++++++--------
 src/backend/executor/nodeModifyTable.c |  5 +----
 src/include/executor/execPartition.h   |  5 +----
 4 files changed, 10 insertions(+), 20 deletions(-)

diff --git a/src/backend/commands/copy.c b/src/backend/commands/copy.c
index 242dc56d87..8c724b8695 100644
--- a/src/backend/commands/copy.c
+++ b/src/backend/commands/copy.c
@@ -2601,10 +2601,7 @@ CopyFrom(CopyState cstate)
 			 * will get us the ResultRelInfo and TupleConversionMap for the
 			 * partition, respectively.
 			 */
-			leaf_part_index = ExecFindPartition(resultRelInfo,
-												proute->partition_dispatch_info,
-												slot,
-												estate);
+			leaf_part_index = ExecFindPartition(mtstate, slot);
 			Assert(leaf_part_index >= 0 &&
 				   leaf_part_index < proute->num_partitions);
 
diff --git a/src/backend/executor/execPartition.c b/src/backend/executor/execPartition.c
index 8c0d2df63c..21d230881a 100644
--- a/src/backend/executor/execPartition.c
+++ b/src/backend/executor/execPartition.c
@@ -140,11 +140,7 @@ ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
 }
 
 /*
- * ExecFindPartition -- Find a leaf partition in the partition tree rooted
- * at parent, for the heap tuple contained in *slot
- *
- * estate must be non-NULL; we'll need it to compute any expressions in the
- * partition key(s)
+ * ExecFindPartition -- Find a leaf partition for tuple contained in slot
  *
  * If no leaf partition is found, this routine errors out with the appropriate
  * error message, else it returns the leaf partition sequence number
@@ -152,14 +148,17 @@ ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
  * the partition tree.
  */
 int
-ExecFindPartition(ResultRelInfo *resultRelInfo, PartitionDispatch *pd,
-				  TupleTableSlot *slot, EState *estate)
+ExecFindPartition(ModifyTableState *mtstate, TupleTableSlot *slot)
 {
+	EState	   *estate = mtstate->ps.state;
 	int			result;
 	Datum		values[PARTITION_MAX_KEYS];
 	bool		isnull[PARTITION_MAX_KEYS];
 	Relation	rel;
-	PartitionDispatch parent;
+	PartitionTupleRouting *proute = mtstate->mt_partition_tuple_routing;
+	PartitionDispatch  *pd = proute->partition_dispatch_info,
+						parent;
+	ResultRelInfo *resultRelInfo = mtstate->resultRelInfo;
 	ExprContext *ecxt = GetPerTupleExprContext(estate);
 	TupleTableSlot *ecxt_scantuple_old = ecxt->ecxt_scantuple;
 
diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c
index c5eca1bb74..9a8f667d72 100644
--- a/src/backend/executor/nodeModifyTable.c
+++ b/src/backend/executor/nodeModifyTable.c
@@ -292,10 +292,7 @@ ExecInsert(ModifyTableState *mtstate,
 		 * get us the ResultRelInfo and TupleConversionMap for the partition,
 		 * respectively.
 		 */
-		leaf_part_index = ExecFindPartition(resultRelInfo,
-											proute->partition_dispatch_info,
-											slot,
-											estate);
+		leaf_part_index = ExecFindPartition(mtstate, slot);
 		Assert(leaf_part_index >= 0 &&
 			   leaf_part_index < proute->num_partitions);
 
diff --git a/src/include/executor/execPartition.h b/src/include/executor/execPartition.h
index b5df357acd..79dad58828 100644
--- a/src/include/executor/execPartition.h
+++ b/src/include/executor/execPartition.h
@@ -86,10 +86,7 @@ typedef struct PartitionTupleRouting
 extern PartitionTupleRouting *ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
 							   Relation rel, Index resultRTindex,
 							   EState *estate);
-extern int ExecFindPartition(ResultRelInfo *resultRelInfo,
-				  PartitionDispatch *pd,
-				  TupleTableSlot *slot,
-				  EState *estate);
 extern void ExecCleanupTupleRouting(PartitionTupleRouting *proute);
+extern int ExecFindPartition(ModifyTableState *mtstate, TupleTableSlot *slot);
 
 #endif							/* EXECPARTITION_H */
-- 
2.11.0

From cb5aeacf77cd11dc460fe5d2e2a4398359188e43 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Tue, 19 Dec 2017 16:20:09 +0900
Subject: [PATCH v2 3/4] ExecSetupPartitionTupleRouting refactoring

---
 src/backend/commands/copy.c            |  2 +-
 src/backend/executor/execPartition.c   | 14 +++++++++++---
 src/backend/executor/nodeModifyTable.c |  4 +---
 src/include/executor/execPartition.h   |  3 +--
 4 files changed, 14 insertions(+), 9 deletions(-)

diff --git a/src/backend/commands/copy.c b/src/backend/commands/copy.c
index 8c724b8695..13f1b5b3e1 100644
--- a/src/backend/commands/copy.c
+++ b/src/backend/commands/copy.c
@@ -2476,7 +2476,7 @@ CopyFrom(CopyState cstate)
 		mtstate->ps.state = estate;
 		mtstate->resultRelInfo = resultRelInfo;
 		proute = mtstate->mt_partition_tuple_routing =
-			ExecSetupPartitionTupleRouting(mtstate, cstate->rel, 1, estate);
+			ExecSetupPartitionTupleRouting(mtstate, cstate->rel);
 
 		/*
 		 * If we are capturing transition tuples, they may need to be
diff --git a/src/backend/executor/execPartition.c b/src/backend/executor/execPartition.c
index 21d230881a..be15189f1d 100644
--- a/src/backend/executor/execPartition.c
+++ b/src/backend/executor/execPartition.c
@@ -46,14 +46,15 @@ static char *ExecBuildSlotPartitionKeyDescription(Relation rel,
  * RowExclusiveLock mode upon return from this function.
  */
 PartitionTupleRouting *
-ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
-							   Relation rel, Index resultRTindex,
-							   EState *estate)
+ExecSetupPartitionTupleRouting(ModifyTableState *mtstate, Relation rel)
 {
 	TupleDesc	tupDesc = RelationGetDescr(rel);
 	List	   *leaf_parts;
 	ListCell   *cell;
 	int			i;
+	EState	   *estate = mtstate->ps.state;
+	ModifyTable *node = (ModifyTable *) mtstate->ps.plan;
+	Index		resultRTindex = node->nominalRelation;
 	ResultRelInfo *leaf_part_rri;
 	PartitionTupleRouting *proute;
 
@@ -67,8 +68,15 @@ ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
 		RelationGetPartitionDispatchInfo(rel, &proute->num_dispatch,
 										 &leaf_parts);
 	proute->num_partitions = list_length(leaf_parts);
+
+	/*
+	 * Allocate an array of ResultRelInfo pointers, but actual
+	 * ResultRelInfo's will be allocated if and when needed.  See
+	 * ExecFindPartition where it's done.
+	 */
 	proute->partitions = (ResultRelInfo **) palloc(proute->num_partitions *
 												   sizeof(ResultRelInfo *));
+	/* Here too, actual TupleConversionMap's will be allocated later. */
 	proute->partition_tupconv_maps =
 		(TupleConversionMap **) palloc0(proute->num_partitions *
 										sizeof(TupleConversionMap *));
diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c
index 9a8f667d72..0bd47ef3ab 100644
--- a/src/backend/executor/nodeModifyTable.c
+++ b/src/backend/executor/nodeModifyTable.c
@@ -1934,9 +1934,7 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 		rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
 	{
 		proute = mtstate->mt_partition_tuple_routing =
-			ExecSetupPartitionTupleRouting(mtstate,
-										   rel, node->nominalRelation,
-										   estate);
+			ExecSetupPartitionTupleRouting(mtstate, rel);
 		num_partitions = proute->num_partitions;
 	}
 
diff --git a/src/include/executor/execPartition.h b/src/include/executor/execPartition.h
index 79dad58828..b3517e2ee0 100644
--- a/src/include/executor/execPartition.h
+++ b/src/include/executor/execPartition.h
@@ -84,8 +84,7 @@ typedef struct PartitionTupleRouting
 } PartitionTupleRouting;
 
 extern PartitionTupleRouting *ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
-							   Relation rel, Index resultRTindex,
-							   EState *estate);
+							   Relation rel);
 extern void ExecCleanupTupleRouting(PartitionTupleRouting *proute);
 extern int ExecFindPartition(ModifyTableState *mtstate, TupleTableSlot *slot);
 
-- 
2.11.0

From ce6ae497836a6e46b8b769e7da31fc6b0bca0c3d Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Wed, 1 Nov 2017 10:31:21 +0900
Subject: [PATCH v2 4/4] During tuple-routing, initialize per-partition objects
 lazily

Those objects include ResultRelInfo, tuple conversion map,
WITH CHECK OPTION quals and RETURNING projections.

This means we don't allocate these objects for partitions that are
never inserted into.
---
 src/backend/commands/copy.c            |  16 +--
 src/backend/executor/execPartition.c   | 239 ++++++++++++++++++++++++---------
 src/backend/executor/nodeModifyTable.c | 111 ++-------------
 src/include/executor/execPartition.h   |   1 +
 4 files changed, 188 insertions(+), 179 deletions(-)

diff --git a/src/backend/commands/copy.c b/src/backend/commands/copy.c
index 13f1b5b3e1..a6a5409770 100644
--- a/src/backend/commands/copy.c
+++ b/src/backend/commands/copy.c
@@ -2482,22 +2482,13 @@ CopyFrom(CopyState cstate)
 		 * If we are capturing transition tuples, they may need to be
 		 * converted from partition format back to partitioned table format
 		 * (this is only ever necessary if a BEFORE trigger modifies the
-		 * tuple).
+		 * tuple).  Note that we don't allocate the actual maps here; they'll
+		 * be allocated by ExecInitPartitionResultRelInfo() if and when
+		 * needed.
 		 */
 		if (cstate->transition_capture != NULL)
-		{
-			int			i;
-
 			mtstate->mt_transition_tupconv_maps = (TupleConversionMap **)
 				palloc0(sizeof(TupleConversionMap *) * proute->num_partitions);
-			for (i = 0; i < proute->num_partitions; ++i)
-			{
-				mtstate->mt_transition_tupconv_maps[i] =
-					convert_tuples_by_name(RelationGetDescr(proute->partitions[i]->ri_RelationDesc),
-										   RelationGetDescr(cstate->rel),
-										   gettext_noop("could not convert row type"));
-			}
-		}
 	}
 
 	/*
@@ -2622,6 +2613,7 @@ CopyFrom(CopyState cstate)
 			 */
 			saved_resultRelInfo = resultRelInfo;
 			resultRelInfo = proute->partitions[leaf_part_index];
+			Assert(resultRelInfo != NULL);
 
 			/* We do not yet have a way to insert into a foreign partition */
 			if (resultRelInfo->ri_FdwRoutine)
diff --git a/src/backend/executor/execPartition.c b/src/backend/executor/execPartition.c
index be15189f1d..0654490e9c 100644
--- a/src/backend/executor/execPartition.c
+++ b/src/backend/executor/execPartition.c
@@ -23,6 +23,8 @@
 #include "utils/rls.h"
 #include "utils/ruleutils.h"
 
+static void ExecInitPartitionResultRelInfo(ModifyTableState *mtstate,
+					int partidx);
 static PartitionDispatch *RelationGetPartitionDispatchInfo(Relation rel,
 								 int *num_parted, List **leaf_part_oids);
 static void get_partition_dispatch_recurse(Relation rel, Relation parent,
@@ -48,15 +50,10 @@ static char *ExecBuildSlotPartitionKeyDescription(Relation rel,
 PartitionTupleRouting *
 ExecSetupPartitionTupleRouting(ModifyTableState *mtstate, Relation rel)
 {
-	TupleDesc	tupDesc = RelationGetDescr(rel);
 	List	   *leaf_parts;
 	ListCell   *cell;
 	int			i;
-	EState	   *estate = mtstate->ps.state;
-	ModifyTable *node = (ModifyTable *) mtstate->ps.plan;
-	Index		resultRTindex = node->nominalRelation;
-	ResultRelInfo *leaf_part_rri;
-	PartitionTupleRouting *proute;
+	PartitionTupleRouting *proute = mtstate->mt_partition_tuple_routing;
 
 	/*
 	 * Get the information about the partition tree after locking all the
@@ -68,19 +65,23 @@ ExecSetupPartitionTupleRouting(ModifyTableState *mtstate, Relation rel)
 		RelationGetPartitionDispatchInfo(rel, &proute->num_dispatch,
 										 &leaf_parts);
 	proute->num_partitions = list_length(leaf_parts);
+	proute->partition_oids = (Oid *) palloc0(proute->num_partitions *
+											 sizeof(Oid));
+	i = 0;
+	foreach (cell, leaf_parts)
+		proute->partition_oids[i++] = lfirst_oid(cell);
 
 	/*
 	 * Allocate an array of ResultRelInfo pointers, but actual
 	 * ResultRelInfo's will be allocated if and when needed.  See
 	 * ExecFindPartition where it's done.
 	 */
-	proute->partitions = (ResultRelInfo **) palloc(proute->num_partitions *
-												   sizeof(ResultRelInfo *));
+	proute->partitions = (ResultRelInfo **) palloc0(proute->num_partitions *
+													sizeof(ResultRelInfo *));
 	/* Here too, actual TupleConversionMap's will be allocated later. */
 	proute->partition_tupconv_maps =
 		(TupleConversionMap **) palloc0(proute->num_partitions *
 										sizeof(TupleConversionMap *));
-
 	/*
 	 * Initialize an empty slot that will be used to manipulate tuples of any
 	 * given partition's rowtype.  It is attached to the caller-specified node
@@ -89,61 +90,6 @@ ExecSetupPartitionTupleRouting(ModifyTableState *mtstate, Relation rel)
 	 */
 	proute->partition_tuple_slot = MakeTupleTableSlot();
 
-	leaf_part_rri = (ResultRelInfo *) palloc0(proute->num_partitions *
-											  sizeof(ResultRelInfo));
-	i = 0;
-	foreach(cell, leaf_parts)
-	{
-		Relation	partrel;
-		TupleDesc	part_tupdesc;
-
-		/*
-		 * We locked all the partitions above including the leaf partitions.
-		 * Note that each of the relations in proute->partitions are
-		 * eventually closed by the caller.
-		 */
-		partrel = heap_open(lfirst_oid(cell), NoLock);
-		part_tupdesc = RelationGetDescr(partrel);
-
-		/*
-		 * Save a tuple conversion map to convert a tuple routed to this
-		 * partition from the parent's type to the partition's.
-		 */
-		proute->partition_tupconv_maps[i] =
-			convert_tuples_by_name(tupDesc, part_tupdesc,
-								   gettext_noop("could not convert row type"));
-
-		InitResultRelInfo(leaf_part_rri,
-						  partrel,
-						  resultRTindex,
-						  rel,
-						  estate->es_instrument);
-
-		/*
-		 * Verify result relation is a valid target for INSERT.
-		 */
-		CheckValidResultRel(leaf_part_rri, CMD_INSERT);
-
-		/*
-		 * Open partition indices.  The user may have asked to check for
-		 * conflicts within this leaf partition and do "nothing" instead of
-		 * throwing an error.  Be prepared in that case by initializing the
-		 * index information needed by ExecInsert() to perform speculative
-		 * insertions.
-		 */
-		if (leaf_part_rri->ri_RelationDesc->rd_rel->relhasindex &&
-			leaf_part_rri->ri_IndexRelationDescs == NULL)
-			ExecOpenIndices(leaf_part_rri,
-							mtstate != NULL &&
-							mtstate->mt_onconflict != ONCONFLICT_NONE);
-
-		estate->es_leaf_result_relations =
-			lappend(estate->es_leaf_result_relations, leaf_part_rri);
-
-		proute->partitions[i] = leaf_part_rri++;
-		i++;
-	}
-
 	return proute;
 }
 
@@ -261,6 +207,8 @@ ExecFindPartition(ModifyTableState *mtstate, TupleTableSlot *slot)
 				 val_desc ? errdetail("Partition key of the failing row contains %s.", val_desc) : 0));
 	}
 
+	/* Initialize the partition result rel, if not done already. */
+	ExecInitPartitionResultRelInfo(mtstate, result);
 	ecxt->ecxt_scantuple = ecxt_scantuple_old;
 	return result;
 }
@@ -295,8 +243,11 @@ ExecCleanupTupleRouting(PartitionTupleRouting * proute)
 	{
 		ResultRelInfo *resultRelInfo = proute->partitions[i];
 
-		ExecCloseIndices(resultRelInfo);
-		heap_close(resultRelInfo->ri_RelationDesc, NoLock);
+		if (resultRelInfo)
+		{
+			ExecCloseIndices(resultRelInfo);
+			heap_close(resultRelInfo->ri_RelationDesc, NoLock);
+		}
 	}
 
 	/* Release the standalone partition tuple descriptor, if any */
@@ -305,6 +256,162 @@ ExecCleanupTupleRouting(PartitionTupleRouting * proute)
 }
 
 /*
+ * ExecInitPartitionResultRelInfo
+ *		Initialize ResultRelInfo for a partition if not done already
+ */
+static void
+ExecInitPartitionResultRelInfo(ModifyTableState *mtstate, int partidx)
+{
+	EState	   *estate = mtstate->ps.state;
+	Relation	rootrel = mtstate->resultRelInfo->ri_RelationDesc;
+	Index		resultRTindex = mtstate->resultRelInfo->ri_RangeTableIndex;
+	ModifyTable *node = (ModifyTable *) mtstate->ps.plan;
+	PartitionTupleRouting *proute = mtstate->mt_partition_tuple_routing;
+	Relation	partrel;
+	TupleDesc	tupDesc = RelationGetDescr(rootrel),
+				part_tupdesc;
+
+	/* Nothing to do if already set.*/
+	if (proute->partitions[partidx])
+		return;
+
+	proute->partitions[partidx] = (ResultRelInfo *)
+											palloc0(sizeof(ResultRelInfo));
+
+	/*
+	 * We locked all the partitions in ExecSetupPartitionTupleRouting
+	 * including the leaf partitions.
+	 */
+	partrel = heap_open(proute->partition_oids[partidx], NoLock);
+	part_tupdesc = RelationGetDescr(partrel);
+	InitResultRelInfo(proute->partitions[partidx],
+					  partrel,
+					  resultRTindex,
+					  rootrel,
+					  estate->es_instrument);
+
+	/*
+	 * Verify result relation is a valid target for INSERT.
+	 */
+	CheckValidResultRel(proute->partitions[partidx], CMD_INSERT);
+
+	/*
+	 * Open partition indices.  The user may have asked to check for
+	 * conflicts within this leaf partition and do "nothing" instead of
+	 * throwing an error.  Be prepared in that case by initializing the
+	 * index information needed by ExecInsert() to perform speculative
+	 * insertions.
+	 */
+	if (partrel->rd_rel->relhasindex &&
+		proute->partitions[partidx]->ri_IndexRelationDescs == NULL)
+		ExecOpenIndices(proute->partitions[partidx],
+						mtstate->mt_onconflict != ONCONFLICT_NONE);
+
+	/*
+	 * Save a tuple conversion map to convert a tuple routed to this
+	 * partition from the parent's type to the partition's.
+	 */
+	proute->partition_tupconv_maps[partidx] =
+							convert_tuples_by_name(tupDesc, part_tupdesc,
+											   gettext_noop("could not convert row type"));
+
+	/*
+	 * Also, if needed, the map to convert from partition's rowtype to the
+	 * parent's that is needed to store the partition's tuples into the
+	 * transition tuplestore which only accepts tuples of parent's rowtype.
+	 */
+	if (mtstate->mt_transition_tupconv_maps)
+		mtstate->mt_transition_tupconv_maps[partidx] =
+							convert_tuples_by_name(part_tupdesc, tupDesc,
+											   gettext_noop("could not convert row type"));
+
+	/*
+	 * Build WITH CHECK OPTION constraints for each leaf partition rel. Note
+	 * that we didn't build the withCheckOptionList for each partition within
+	 * the planner, but simple translation of the varattnos for each partition
+	 * will suffice.  This only occurs for the INSERT case; UPDATE/DELETE
+	 * cases are handled above.
+	 */
+	if (node && node->withCheckOptionLists != NIL)
+	{
+		List	   *wcoList;
+		List	   *mapped_wcoList;
+		List	   *wcoExprs = NIL;
+		ListCell   *ll;
+
+		/*
+		 * In case of INSERT on partitioned tables, there is only one plan.
+		 * Likewise, there is only one WITH CHECK OPTIONS list, not one per
+		 * partition.  We make a copy of the WCO qual for each partition; note
+		 * that, if there are SubPlans in there, they all end up attached to
+		 * the one parent Plan node.
+		 */
+		Assert(mtstate->operation == CMD_INSERT &&
+			   list_length(node->withCheckOptionLists) == 1 &&
+			   mtstate->mt_nplans == 1);
+		wcoList = linitial(node->withCheckOptionLists);
+		mapped_wcoList = map_partition_varattnos(wcoList,
+												 resultRTindex,
+												 partrel, rootrel, NULL);
+		foreach(ll, mapped_wcoList)
+		{
+			WithCheckOption *wco = castNode(WithCheckOption, lfirst(ll));
+			ExprState  *wcoExpr = ExecInitQual(castNode(List, wco->qual),
+											   mtstate->mt_plans[0]);
+			wcoExprs = lappend(wcoExprs, wcoExpr);
+		}
+
+		proute->partitions[partidx]->ri_WithCheckOptions = mapped_wcoList;
+		proute->partitions[partidx]->ri_WithCheckOptionExprs = wcoExprs;
+	}
+
+	/*
+	 * Build a projection for each leaf partition rel.  Note that we
+	 * didn't build the returningList for each partition within the
+	 * planner, but simple translation of the varattnos for each partition
+	 * will suffice.  This only occurs for the INSERT case; UPDATE/DELETE
+	 * are handled above.
+	 */
+	if (node && node->returningLists != NIL)
+	{
+		TupleTableSlot *slot;
+		ExprContext *econtext;
+		List	   *returningList;
+		List	   *rlist;
+
+		returningList = linitial(node->returningLists);
+
+		/*
+		 * Initialize result tuple slot and assign its rowtype using the first
+		 * RETURNING list.  We assume the rest will look the same.
+		 */
+		tupDesc = ExecTypeFromTL(returningList, false);
+
+		/* Set up a slot for the output of the RETURNING projection(s) */
+		ExecInitResultTupleSlot(estate, &mtstate->ps);
+		ExecAssignResultType(&mtstate->ps, tupDesc);
+		slot = mtstate->ps.ps_ResultTupleSlot;
+
+		/* Need an econtext too */
+		if (mtstate->ps.ps_ExprContext == NULL)
+			ExecAssignExprContext(estate, &mtstate->ps);
+		econtext = mtstate->ps.ps_ExprContext;
+
+		rlist = map_partition_varattnos(returningList,
+										resultRTindex,
+										partrel, rootrel, NULL);
+		proute->partitions[partidx]->ri_projectReturning =
+				ExecBuildProjectionInfo(rlist, econtext, slot, &mtstate->ps,
+										part_tupdesc);
+	}
+
+	/* Note that the entries in this list appear in no predetermined order. */
+	estate->es_leaf_result_relations =
+								lappend(estate->es_leaf_result_relations,
+										proute->partitions[partidx]);
+}
+
+/*
  * RelationGetPartitionDispatchInfo
  *		Returns information necessary to route tuples down a partition tree
  *
diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c
index 0bd47ef3ab..fd1390a508 100644
--- a/src/backend/executor/nodeModifyTable.c
+++ b/src/backend/executor/nodeModifyTable.c
@@ -302,6 +302,7 @@ ExecInsert(ModifyTableState *mtstate,
 		 */
 		saved_resultRelInfo = resultRelInfo;
 		resultRelInfo = proute->partitions[leaf_part_index];
+		Assert(resultRelInfo != NULL);
 
 		/* We do not yet have a way to insert into a foreign partition */
 		if (resultRelInfo->ri_FdwRoutine)
@@ -1512,23 +1513,14 @@ ExecSetupTransitionCaptureState(ModifyTableState *mtstate, EState *estate)
 		mtstate->mt_transition_tupconv_maps = (TupleConversionMap **)
 			palloc0(sizeof(TupleConversionMap *) * numResultRelInfos);
 
-		/* Choose the right set of partitions */
+		/*
+		 * If partition tuple-routing is active, we can't have partition
+		 * ResultRelInfo's just yet, so return in that case.  Instead,
+		 * the conversion map will be initialized in
+		 * ExecInitPartitionResultRelInfo() if and when needed.
+		 */
 		if (proute != NULL)
-		{
-			/*
-			 * For tuple routing among partitions, we need TupleDescs based on
-			 * the partition routing table.
-			 */
-			ResultRelInfo **resultRelInfos = proute->partitions;
-
-			for (i = 0; i < numResultRelInfos; ++i)
-			{
-				mtstate->mt_transition_tupconv_maps[i] =
-					convert_tuples_by_name(RelationGetDescr(resultRelInfos[i]->ri_RelationDesc),
-										   RelationGetDescr(targetRelInfo->ri_RelationDesc),
-										   gettext_noop("could not convert row type"));
-			}
-		}
+			return;
 		else
 		{
 			/* Otherwise we need the ResultRelInfo for each subplan. */
@@ -1830,8 +1822,6 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 	ListCell   *l;
 	int			i;
 	Relation	rel;
-	PartitionTupleRouting *proute = NULL;
-	int			num_partitions = 0;
 
 	/* check for unsupported flags */
 	Assert(!(eflags & (EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK)));
@@ -1932,11 +1922,8 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 	rel = mtstate->resultRelInfo->ri_RelationDesc;
 	if (operation == CMD_INSERT &&
 		rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
-	{
-		proute = mtstate->mt_partition_tuple_routing =
-			ExecSetupPartitionTupleRouting(mtstate, rel);
-		num_partitions = proute->num_partitions;
-	}
+		mtstate->mt_partition_tuple_routing =
+						ExecSetupPartitionTupleRouting(mtstate, rel);
 
 	/*
 	 * Build state for collecting transition tuples.  This requires having a
@@ -1972,65 +1959,12 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 	}
 
 	/*
-	 * Build WITH CHECK OPTION constraints for each leaf partition rel. Note
-	 * that we didn't build the withCheckOptionList for each partition within
-	 * the planner, but simple translation of the varattnos for each partition
-	 * will suffice.  This only occurs for the INSERT case; UPDATE/DELETE
-	 * cases are handled above.
-	 */
-	if (node->withCheckOptionLists != NIL && num_partitions > 0)
-	{
-		List	   *wcoList;
-		PlanState  *plan;
-
-		/*
-		 * In case of INSERT on partitioned tables, there is only one plan.
-		 * Likewise, there is only one WITH CHECK OPTIONS list, not one per
-		 * partition.  We make a copy of the WCO qual for each partition; note
-		 * that, if there are SubPlans in there, they all end up attached to
-		 * the one parent Plan node.
-		 */
-		Assert(operation == CMD_INSERT &&
-			   list_length(node->withCheckOptionLists) == 1 &&
-			   mtstate->mt_nplans == 1);
-		wcoList = linitial(node->withCheckOptionLists);
-		plan = mtstate->mt_plans[0];
-		for (i = 0; i < num_partitions; i++)
-		{
-			Relation	partrel;
-			List	   *mapped_wcoList;
-			List	   *wcoExprs = NIL;
-			ListCell   *ll;
-
-			resultRelInfo = proute->partitions[i];
-			partrel = resultRelInfo->ri_RelationDesc;
-
-			/* varno = node->nominalRelation */
-			mapped_wcoList = map_partition_varattnos(wcoList,
-													 node->nominalRelation,
-													 partrel, rel, NULL);
-			foreach(ll, mapped_wcoList)
-			{
-				WithCheckOption *wco = castNode(WithCheckOption, lfirst(ll));
-				ExprState  *wcoExpr = ExecInitQual(castNode(List, wco->qual),
-												   plan);
-
-				wcoExprs = lappend(wcoExprs, wcoExpr);
-			}
-
-			resultRelInfo->ri_WithCheckOptions = mapped_wcoList;
-			resultRelInfo->ri_WithCheckOptionExprs = wcoExprs;
-		}
-	}
-
-	/*
 	 * Initialize RETURNING projections if needed.
 	 */
 	if (node->returningLists)
 	{
 		TupleTableSlot *slot;
 		ExprContext *econtext;
-		List	   *returningList;
 
 		/*
 		 * Initialize result tuple slot and assign its rowtype using the first
@@ -2061,31 +1995,6 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 										resultRelInfo->ri_RelationDesc->rd_att);
 			resultRelInfo++;
 		}
-
-		/*
-		 * Build a projection for each leaf partition rel.  Note that we
-		 * didn't build the returningList for each partition within the
-		 * planner, but simple translation of the varattnos for each partition
-		 * will suffice.  This only occurs for the INSERT case; UPDATE/DELETE
-		 * are handled above.
-		 */
-		returningList = linitial(node->returningLists);
-		for (i = 0; i < num_partitions; i++)
-		{
-			Relation	partrel;
-			List	   *rlist;
-
-			resultRelInfo = proute->partitions[i];
-			partrel = resultRelInfo->ri_RelationDesc;
-
-			/* varno = node->nominalRelation */
-			rlist = map_partition_varattnos(returningList,
-											node->nominalRelation,
-											partrel, rel, NULL);
-			resultRelInfo->ri_projectReturning =
-				ExecBuildProjectionInfo(rlist, econtext, slot, &mtstate->ps,
-										resultRelInfo->ri_RelationDesc->rd_att);
-		}
 	}
 	else
 	{
diff --git a/src/include/executor/execPartition.h b/src/include/executor/execPartition.h
index b3517e2ee0..cd256551bb 100644
--- a/src/include/executor/execPartition.h
+++ b/src/include/executor/execPartition.h
@@ -79,6 +79,7 @@ typedef struct PartitionTupleRouting
 	int			num_dispatch;
 	ResultRelInfo **partitions;
 	int			num_partitions;
+	Oid		   *partition_oids;
 	TupleConversionMap **partition_tupconv_maps;
 	TupleTableSlot *partition_tuple_slot;
 } PartitionTupleRouting;
-- 
2.11.0

From 4b6cf902fa10819d29d021c36fec1200f72db11d Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Tue, 19 Dec 2017 10:43:45 +0900
Subject: [PATCH v3 1/3] Teach CopyFrom to use ModifyTableState for
 tuple-routing

This removes all fields of CopyStateData that were meant for
tuple routing and instead uses ModifyTableState that has all those
fields, including transition_tupconv_maps.  In COPY's case,
transition_tupconv_maps is only required if tuple routing is being
used, so it's safe.
---
 src/backend/commands/copy.c | 26 +++++++++++++++-----------
 1 file changed, 15 insertions(+), 11 deletions(-)

diff --git a/src/backend/commands/copy.c b/src/backend/commands/copy.c
index 04a24c6082..251676b321 100644
--- a/src/backend/commands/copy.c
+++ b/src/backend/commands/copy.c
@@ -166,9 +166,6 @@ typedef struct CopyStateData
 	bool		volatile_defexprs;	/* is any of defexprs volatile? */
 	List	   *range_table;
 
-	/* Tuple-routing support info */
-	PartitionTupleRouting *partition_tuple_routing;
-
 	TransitionCaptureState *transition_capture;
 
 	/*
@@ -2285,6 +2282,7 @@ CopyFrom(CopyState cstate)
 	ResultRelInfo *resultRelInfo;
 	ResultRelInfo *saved_resultRelInfo = NULL;
 	EState	   *estate = CreateExecutorState(); /* for ExecConstraints() */
+	ModifyTableState *mtstate = makeNode(ModifyTableState);
 	ExprContext *econtext;
 	TupleTableSlot *myslot;
 	MemoryContext oldcontext = CurrentMemoryContext;
@@ -2303,6 +2301,8 @@ CopyFrom(CopyState cstate)
 	Size		bufferedTuplesSize = 0;
 	int			firstBufferedLineNo = 0;
 
+	PartitionTupleRouting *proute = NULL;
+
 	Assert(cstate->rel);
 
 	/*
@@ -2468,10 +2468,15 @@ CopyFrom(CopyState cstate)
 	 */
 	if (cstate->rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
 	{
-		PartitionTupleRouting *proute;
+		ModifyTable *node = makeNode(ModifyTable);
 
-		proute = cstate->partition_tuple_routing =
-			ExecSetupPartitionTupleRouting(NULL, cstate->rel, 1, estate);
+		/* Just need make this field appear valid. */
+		node->nominalRelation = 1;
+		mtstate->ps.plan = (Plan *) node;
+		mtstate->ps.state = estate;
+		mtstate->resultRelInfo = resultRelInfo;
+		proute = mtstate->mt_partition_tuple_routing =
+			ExecSetupPartitionTupleRouting(mtstate, cstate->rel, 1, estate);
 
 		/*
 		 * If we are capturing transition tuples, they may need to be
@@ -2496,7 +2501,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_tuple_routing != NULL ||
+		mtstate->mt_partition_tuple_routing != NULL ||
 		cstate->volatile_defexprs)
 	{
 		useHeapMultiInsert = false;
@@ -2571,10 +2576,9 @@ CopyFrom(CopyState cstate)
 		ExecStoreTuple(tuple, slot, InvalidBuffer, false);
 
 		/* Determine the partition to heap_insert the tuple into */
-		if (cstate->partition_tuple_routing)
+		if (cstate->rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
 		{
 			int			leaf_part_index;
-			PartitionTupleRouting *proute = cstate->partition_tuple_routing;
 
 			/*
 			 * Away we go ... If we end up not finding a partition after all,
@@ -2806,8 +2810,8 @@ CopyFrom(CopyState cstate)
 	ExecCloseIndices(resultRelInfo);
 
 	/* Close all the partitioned tables, leaf partitions, and their indices */
-	if (cstate->partition_tuple_routing)
-		ExecCleanupTupleRouting(cstate->partition_tuple_routing);
+	if (proute)
+		ExecCleanupTupleRouting(proute);
 
 	/* Close any trigger target relations */
 	ExecCleanUpTriggerState(estate);
-- 
2.11.0

From 58a24b5e0ef06e2d4d855afd2beca60a0c171ae8 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Tue, 19 Dec 2017 13:56:25 +0900
Subject: [PATCH v3 2/3] ExecFindPartition refactoring

---
 src/backend/commands/copy.c            |  5 +----
 src/backend/executor/execPartition.c   | 17 +++++++++--------
 src/backend/executor/nodeModifyTable.c |  5 +----
 src/include/executor/execPartition.h   |  5 +----
 4 files changed, 12 insertions(+), 20 deletions(-)

diff --git a/src/backend/commands/copy.c b/src/backend/commands/copy.c
index 251676b321..2096a52cea 100644
--- a/src/backend/commands/copy.c
+++ b/src/backend/commands/copy.c
@@ -2588,10 +2588,7 @@ CopyFrom(CopyState cstate)
 			 * will get us the ResultRelInfo and TupleConversionMap for the
 			 * partition, respectively.
 			 */
-			leaf_part_index = ExecFindPartition(resultRelInfo,
-												proute->partition_dispatch_info,
-												slot,
-												estate);
+			leaf_part_index = ExecFindPartition(mtstate, slot);
 			Assert(leaf_part_index >= 0 &&
 				   leaf_part_index < proute->num_partitions);
 
diff --git a/src/backend/executor/execPartition.c b/src/backend/executor/execPartition.c
index 89b7bb4c60..918cd62cb0 100644
--- a/src/backend/executor/execPartition.c
+++ b/src/backend/executor/execPartition.c
@@ -226,11 +226,7 @@ ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
 }
 
 /*
- * ExecFindPartition -- Find a leaf partition in the partition tree rooted
- * at parent, for the heap tuple contained in *slot
- *
- * estate must be non-NULL; we'll need it to compute any expressions in the
- * partition key(s)
+ * ExecFindPartition -- Find a leaf partition for tuple contained in slot
  *
  * If no leaf partition is found, this routine errors out with the appropriate
  * error message, else it returns the leaf partition sequence number
@@ -238,14 +234,19 @@ ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
  * the partition tree.
  */
 int
-ExecFindPartition(ResultRelInfo *resultRelInfo, PartitionDispatch *pd,
-				  TupleTableSlot *slot, EState *estate)
+ExecFindPartition(ModifyTableState *mtstate, TupleTableSlot *slot)
 {
+	EState	   *estate = mtstate->ps.state;
 	int			result;
 	Datum		values[PARTITION_MAX_KEYS];
 	bool		isnull[PARTITION_MAX_KEYS];
 	Relation	rel;
-	PartitionDispatch parent;
+	PartitionTupleRouting *proute = mtstate->mt_partition_tuple_routing;
+	PartitionDispatch  *pd = proute->partition_dispatch_info,
+						parent;
+	ResultRelInfo *resultRelInfo = (mtstate->rootResultRelInfo != NULL)
+										? mtstate->rootResultRelInfo
+										: mtstate->resultRelInfo;
 	ExprContext *ecxt = GetPerTupleExprContext(estate);
 	TupleTableSlot *ecxt_scantuple_old = ecxt->ecxt_scantuple;
 
diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c
index 6c2f8d4ec0..bd88b41ff6 100644
--- a/src/backend/executor/nodeModifyTable.c
+++ b/src/backend/executor/nodeModifyTable.c
@@ -297,10 +297,7 @@ ExecInsert(ModifyTableState *mtstate,
 		 * get us the ResultRelInfo and TupleConversionMap for the partition,
 		 * respectively.
 		 */
-		leaf_part_index = ExecFindPartition(resultRelInfo,
-											proute->partition_dispatch_info,
-											slot,
-											estate);
+		leaf_part_index = ExecFindPartition(mtstate, slot);
 		Assert(leaf_part_index >= 0 &&
 			   leaf_part_index < proute->num_partitions);
 
diff --git a/src/include/executor/execPartition.h b/src/include/executor/execPartition.h
index 18e08129f8..87c4c3249e 100644
--- a/src/include/executor/execPartition.h
+++ b/src/include/executor/execPartition.h
@@ -103,10 +103,6 @@ typedef struct PartitionTupleRouting
 extern PartitionTupleRouting *ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
 							   Relation rel, Index resultRTindex,
 							   EState *estate);
-extern int ExecFindPartition(ResultRelInfo *resultRelInfo,
-				  PartitionDispatch *pd,
-				  TupleTableSlot *slot,
-				  EState *estate);
 extern void ExecSetupChildParentMapForLeaf(PartitionTupleRouting *proute);
 extern TupleConversionMap *TupConvMapForLeaf(PartitionTupleRouting *proute,
 				  ResultRelInfo *rootRelInfo, int leaf_index);
@@ -115,5 +111,6 @@ extern HeapTuple ConvertPartitionTupleSlot(TupleConversionMap *map,
 						  TupleTableSlot *new_slot,
 						  TupleTableSlot **p_my_slot);
 extern void ExecCleanupTupleRouting(PartitionTupleRouting *proute);
+extern int ExecFindPartition(ModifyTableState *mtstate, TupleTableSlot *slot);
 
 #endif							/* EXECPARTITION_H */
-- 
2.11.0

From f69147bb78e2b89941ad6b1d6af0aed4cbdf17f1 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Tue, 19 Dec 2017 16:20:09 +0900
Subject: [PATCH v3 3/3] During tuple-routing, initialize per-partition objects
 lazily

Those objects include ResultRelInfo, tuple conversion map,
WITH CHECK OPTION quals and RETURNING projections.

This means we don't allocate these objects for partitions that are
never inserted into.
---
 src/backend/commands/copy.c            |   6 +-
 src/backend/executor/execPartition.c   | 504 +++++++++++++++++++++++----------
 src/backend/executor/nodeModifyTable.c | 152 +---------
 src/include/executor/execPartition.h   |  10 +-
 4 files changed, 375 insertions(+), 297 deletions(-)

diff --git a/src/backend/commands/copy.c b/src/backend/commands/copy.c
index 2096a52cea..1000bb4461 100644
--- a/src/backend/commands/copy.c
+++ b/src/backend/commands/copy.c
@@ -2476,7 +2476,7 @@ CopyFrom(CopyState cstate)
 		mtstate->ps.state = estate;
 		mtstate->resultRelInfo = resultRelInfo;
 		proute = mtstate->mt_partition_tuple_routing =
-			ExecSetupPartitionTupleRouting(mtstate, cstate->rel, 1, estate);
+			ExecSetupPartitionTupleRouting(mtstate, cstate->rel);
 
 		/*
 		 * If we are capturing transition tuples, they may need to be
@@ -2609,6 +2609,7 @@ CopyFrom(CopyState cstate)
 			 */
 			saved_resultRelInfo = resultRelInfo;
 			resultRelInfo = proute->partitions[leaf_part_index];
+			Assert(resultRelInfo != NULL);
 
 			/* We do not yet have a way to insert into a foreign partition */
 			if (resultRelInfo->ri_FdwRoutine)
@@ -2638,8 +2639,7 @@ CopyFrom(CopyState cstate)
 					 */
 					cstate->transition_capture->tcs_original_insert_tuple = NULL;
 					cstate->transition_capture->tcs_map =
-						TupConvMapForLeaf(proute, saved_resultRelInfo,
-										  leaf_part_index);
+						TupConvMapForLeaf(mtstate, leaf_part_index);
 				}
 				else
 				{
diff --git a/src/backend/executor/execPartition.c b/src/backend/executor/execPartition.c
index 918cd62cb0..4e8fb01424 100644
--- a/src/backend/executor/execPartition.c
+++ b/src/backend/executor/execPartition.c
@@ -23,6 +23,8 @@
 #include "utils/rls.h"
 #include "utils/ruleutils.h"
 
+static void ExecInitPartitionResultRelInfo(ModifyTableState *mtstate,
+					int partidx);
 static PartitionDispatch *RelationGetPartitionDispatchInfo(Relation rel,
 								 int *num_parted, List **leaf_part_oids);
 static void get_partition_dispatch_recurse(Relation rel, Relation parent,
@@ -44,22 +46,23 @@ static char *ExecBuildSlotPartitionKeyDescription(Relation rel,
  *
  * Note that all the relations in the partition tree are locked using the
  * RowExclusiveLock mode upon return from this function.
+ *
+ * While we allocate the arrays of pointers of various objects for all
+ * partitions here, the objects themselves are lazily allocated and
+ * initialized for a given partition if a tuple is actually routed to it;
+ * see ExecInitPartitionResultRelInfo.
  */
 PartitionTupleRouting *
-ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
-							   Relation rel, Index resultRTindex,
-							   EState *estate)
+ExecSetupPartitionTupleRouting(ModifyTableState *mtstate, Relation rel)
 {
-	TupleDesc	tupDesc = RelationGetDescr(rel);
+	PartitionTupleRouting *proute;
 	List	   *leaf_parts;
 	ListCell   *cell;
-	int			i;
-	ResultRelInfo *leaf_part_arr = NULL,
-			   *update_rri = NULL;
-	int			num_update_rri = 0,
-				update_rri_index = 0;
-	bool		is_update = false;
-	PartitionTupleRouting *proute;
+	int			leaf_index,
+				update_rri_index,
+				num_update_rri;
+	bool		is_update;
+	ResultRelInfo *update_rri;
 
 	/*
 	 * Get the information about the partition tree after locking all the
@@ -71,20 +74,24 @@ ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
 		RelationGetPartitionDispatchInfo(rel, &proute->num_dispatch,
 										 &leaf_parts);
 	proute->num_partitions = list_length(leaf_parts);
-	proute->partitions = (ResultRelInfo **) palloc(proute->num_partitions *
-												   sizeof(ResultRelInfo *));
+	/*
+	 * Actual ResultRelInfo's and TupleConversionMap's are allocated in
+	 * ExecInitResultRelInfo().
+	 */
+	proute->partitions = (ResultRelInfo **) palloc0(proute->num_partitions *
+													sizeof(ResultRelInfo *));
 	proute->parent_child_tupconv_maps =
 		(TupleConversionMap **) palloc0(proute->num_partitions *
 										sizeof(TupleConversionMap *));
+	proute->partition_oids = (Oid *) palloc0(proute->num_partitions *
+											 sizeof(Oid));
 
 	/* Set up details specific to the type of tuple routing we are doing. */
 	if (mtstate && mtstate->operation == CMD_UPDATE)
 	{
-		ModifyTable *node = (ModifyTable *) mtstate->ps.plan;
-
 		is_update = true;
 		update_rri = mtstate->resultRelInfo;
-		num_update_rri = list_length(node->plans);
+		num_update_rri = mtstate->mt_nplans;
 		proute->subplan_partition_offsets =
 			palloc(num_update_rri * sizeof(int));
 
@@ -94,15 +101,29 @@ ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
 		 */
 		proute->root_tuple_slot = MakeTupleTableSlot();
 	}
-	else
+
+	leaf_index = update_rri_index = 0;
+	foreach (cell, leaf_parts)
 	{
+		Oid		leaf_oid = lfirst_oid(cell);
+
+		proute->partition_oids[leaf_index] = leaf_oid;
+
 		/*
-		 * Since we are inserting tuples, we need to create all new result
-		 * rels. Avoid repeated pallocs by allocating memory for all the
-		 * result rels in bulk.
+		 * The per-subplan resultrels and the resultrels of the leaf
+		 * partitions are both in the same canonical order.  So while going
+		 * through the leaf partition oids, we need to keep track of the
+		 * next per-subplan result rel to be looked for in the leaf
+		 * partition resultrels.
 		 */
-		leaf_part_arr = (ResultRelInfo *) palloc0(proute->num_partitions *
-												  sizeof(ResultRelInfo));
+		if (is_update && update_rri_index < num_update_rri &&
+			RelationGetRelid(update_rri[update_rri_index].ri_RelationDesc) == leaf_oid)
+		{
+			proute->subplan_partition_offsets[update_rri_index] = leaf_index;
+			update_rri_index++;
+		}
+
+		leaf_index++;
 	}
 
 	/*
@@ -113,109 +134,6 @@ ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
 	 */
 	proute->partition_tuple_slot = MakeTupleTableSlot();
 
-	i = 0;
-	foreach(cell, leaf_parts)
-	{
-		ResultRelInfo *leaf_part_rri;
-		Relation	partrel = NULL;
-		TupleDesc	part_tupdesc;
-		Oid			leaf_oid = lfirst_oid(cell);
-
-		if (is_update)
-		{
-			/*
-			 * If the leaf partition is already present in the per-subplan
-			 * result rels, we re-use that rather than initialize a new result
-			 * rel. The per-subplan resultrels and the resultrels of the leaf
-			 * partitions are both in the same canonical order. So while going
-			 * through the leaf partition oids, we need to keep track of the
-			 * next per-subplan result rel to be looked for in the leaf
-			 * partition resultrels.
-			 */
-			if (update_rri_index < num_update_rri &&
-				RelationGetRelid(update_rri[update_rri_index].ri_RelationDesc) == leaf_oid)
-			{
-				leaf_part_rri = &update_rri[update_rri_index];
-				partrel = leaf_part_rri->ri_RelationDesc;
-
-				/*
-				 * This is required in order to we convert the partition's
-				 * tuple to be compatible with the root partitioned table's
-				 * tuple descriptor.  When generating the per-subplan result
-				 * rels, this was not set.
-				 */
-				leaf_part_rri->ri_PartitionRoot = rel;
-
-				/* Remember the subplan offset for this ResultRelInfo */
-				proute->subplan_partition_offsets[update_rri_index] = i;
-
-				update_rri_index++;
-			}
-			else
-				leaf_part_rri = (ResultRelInfo *) palloc0(sizeof(ResultRelInfo));
-		}
-		else
-		{
-			/* For INSERTs, we already have an array of result rels allocated */
-			leaf_part_rri = &leaf_part_arr[i];
-		}
-
-		/*
-		 * If we didn't open the partition rel, it means we haven't
-		 * initialized the result rel either.
-		 */
-		if (!partrel)
-		{
-			/*
-			 * We locked all the partitions above including the leaf
-			 * partitions. Note that each of the newly opened relations in
-			 * proute->partitions are eventually closed by the caller.
-			 */
-			partrel = heap_open(leaf_oid, NoLock);
-			InitResultRelInfo(leaf_part_rri,
-							  partrel,
-							  resultRTindex,
-							  rel,
-							  estate->es_instrument);
-		}
-
-		part_tupdesc = RelationGetDescr(partrel);
-
-		/*
-		 * Save a tuple conversion map to convert a tuple routed to this
-		 * partition from the parent's type to the partition's.
-		 */
-		proute->parent_child_tupconv_maps[i] =
-			convert_tuples_by_name(tupDesc, part_tupdesc,
-								   gettext_noop("could not convert row type"));
-
-		/*
-		 * Verify result relation is a valid target for an INSERT.  An UPDATE
-		 * of a partition-key becomes a DELETE+INSERT operation, so this check
-		 * is still required when the operation is CMD_UPDATE.
-		 */
-		CheckValidResultRel(leaf_part_rri, CMD_INSERT);
-
-		/*
-		 * Open partition indices.  The user may have asked to check for
-		 * conflicts within this leaf partition and do "nothing" instead of
-		 * throwing an error.  Be prepared in that case by initializing the
-		 * index information needed by ExecInsert() to perform speculative
-		 * insertions.
-		 */
-		if (leaf_part_rri->ri_RelationDesc->rd_rel->relhasindex &&
-			leaf_part_rri->ri_IndexRelationDescs == NULL)
-			ExecOpenIndices(leaf_part_rri,
-							mtstate != NULL &&
-							mtstate->mt_onconflict != ONCONFLICT_NONE);
-
-		estate->es_leaf_result_relations =
-			lappend(estate->es_leaf_result_relations, leaf_part_rri);
-
-		proute->partitions[i] = leaf_part_rri;
-		i++;
-	}
-
 	/*
 	 * For UPDATE, we should have found all the per-subplan resultrels in the
 	 * leaf partitions.
@@ -341,10 +259,251 @@ ExecFindPartition(ModifyTableState *mtstate, TupleTableSlot *slot)
 				 val_desc ? errdetail("Partition key of the failing row contains %s.", val_desc) : 0));
 	}
 
+	/* Initialize the partition result rel, if not done already. */
+	ExecInitPartitionResultRelInfo(mtstate, result);
 	ecxt->ecxt_scantuple = ecxt_scantuple_old;
 	return result;
 }
 
+static int
+leafpart_index_cmp(const void *arg1, const void *arg2)
+{
+	int		leafidx1 = *(const int *) arg1;
+	int		leafidx2 = *(const int *) arg2;
+
+	if (leafidx1 > leafidx2)
+		return 1;
+	else if (leafidx1 < leafidx2)
+		return -1;
+	return 0;
+}
+
+/*
+ * ExecInitPartitionResultRelInfo
+ *		Initialize ResultRelInfo for a partition if not done already
+ */
+static void
+ExecInitPartitionResultRelInfo(ModifyTableState *mtstate, int partidx)
+{
+	PartitionTupleRouting *proute = mtstate->mt_partition_tuple_routing;
+	Relation	partrel,
+				rootrel;
+	ResultRelInfo *leaf_part_rri;
+	int			firstVarno;
+	Relation	firstResultRel;
+
+	/* Nothing to do if already set.*/
+	if (proute->partitions[partidx])
+		return;
+
+	leaf_part_rri = NULL;
+	rootrel = (mtstate->rootResultRelInfo != NULL)
+						? mtstate->rootResultRelInfo->ri_RelationDesc
+						: mtstate->resultRelInfo->ri_RelationDesc;
+
+	/*
+	 * If we are doing tuple routing for update, try to reuse the
+	 * per-subplan resultrel for this partition that ExecInitModifyTable()
+	 * might already have created.
+	 */
+	if (mtstate && mtstate->operation == CMD_UPDATE)
+	{
+		ResultRelInfo   *update_rri;
+		int   *partidx_entry;
+
+		update_rri = mtstate->resultRelInfo;
+
+		/*
+		 * If the partition got a subplan, we'd be able to find its index
+		 * in proute->subplan_partition_offsets.
+		 */
+		partidx_entry = (int *) bsearch(&partidx,
+										proute->subplan_partition_offsets,
+										mtstate->mt_nplans, sizeof(int),
+										leafpart_index_cmp);
+		if (partidx_entry)
+		{
+			int		update_rri_index =
+							partidx_entry - proute->subplan_partition_offsets;
+
+			Assert (update_rri_index < mtstate->mt_nplans);
+			leaf_part_rri = &update_rri[update_rri_index];
+			partrel = leaf_part_rri->ri_RelationDesc;
+
+			/*
+			 * This is required in order to we convert the partition's
+			 * tuple to be compatible with the root partitioned table's
+			 * tuple descriptor.  When generating the per-subplan result
+			 * rels, this was not set.
+			 */
+			leaf_part_rri->ri_PartitionRoot = rootrel;
+		}
+	}
+
+	/*
+	 * Create new result rel, either if we are *inserting* the new tuple, or
+	 * if we didn't find the result rel above for the update tuple routing
+	 * case.
+	 */
+	if (leaf_part_rri == NULL)
+	{
+		EState	   *estate = mtstate->ps.state;
+		ModifyTable *node = (ModifyTable *) mtstate->ps.plan;
+		Index		resultRTindex = node->nominalRelation;
+
+		leaf_part_rri = (ResultRelInfo *) palloc0(sizeof(ResultRelInfo));
+
+		/*
+		 * We locked all the partitions in ExecSetupPartitionTupleRouting
+		 * including the leaf partitions.
+		 */
+		partrel = heap_open(proute->partition_oids[partidx], NoLock);
+		InitResultRelInfo(leaf_part_rri,
+						  partrel,
+						  resultRTindex,
+						  rootrel,
+						  estate->es_instrument);
+
+		/*
+		 * These are required as reference objects for mapping partition
+		 * attno's in expressions in WithCheckOptions and RETURNING.
+		 */
+		firstVarno = mtstate->resultRelInfo[0].ri_RangeTableIndex;
+		firstResultRel = mtstate->resultRelInfo[0].ri_RelationDesc;
+
+		/*
+		 * Build WITH CHECK OPTION constraints for this partition rel.  Note
+		 * that we didn't build the withCheckOptionList for each partition
+		 * within the planner, but simple translation of the varattnos will
+		 * suffice.  This only occurs for the INSERT case or in the case of
+		 * UPDATE for which we didn't find a result rel above to reuse.
+		 */
+		if (node && node->withCheckOptionLists != NIL)
+		{
+			List	   *wcoList;
+			List	   *mapped_wcoList;
+			List	   *wcoExprs = NIL;
+			ListCell   *ll;
+
+			/*
+			 * In the case of INSERT on partitioned tables, there is only one
+			 * plan.  Likewise, there is only one WCO list, not one per
+			 * partition.  For UPDATE, there would be as many WCO lists as
+			 * there are plans, but we use the first one as reference.  Note
+			 * that if there are SubPlans in there, they all end up attached
+			 * to the one parent Plan node.
+			 */
+			Assert((mtstate->operation == CMD_INSERT &&
+					list_length(node->withCheckOptionLists) == 1 &&
+					mtstate->mt_nplans == 1) ||
+				   (mtstate->operation == CMD_UPDATE &&
+					list_length(node->withCheckOptionLists) ==
+														mtstate->mt_nplans));
+			wcoList = linitial(node->withCheckOptionLists);
+
+			mapped_wcoList = map_partition_varattnos(wcoList,
+													 firstVarno,
+													 partrel, firstResultRel,
+													 NULL);
+			foreach(ll, mapped_wcoList)
+			{
+				WithCheckOption *wco = castNode(WithCheckOption, lfirst(ll));
+				ExprState  *wcoExpr = ExecInitQual(castNode(List, wco->qual),
+												   mtstate->mt_plans[0]);
+				wcoExprs = lappend(wcoExprs, wcoExpr);
+			}
+
+			leaf_part_rri->ri_WithCheckOptions = mapped_wcoList;
+			leaf_part_rri->ri_WithCheckOptionExprs = wcoExprs;
+		}
+
+		/*
+		 * Build the RETURNING projection if any for the partition.  Note that
+		 * we didn't build the returningList for each partition within the
+		 * planner, but simple translation of the varattnos will suffice.
+		 * This only occurs for the INSERT case; in the UPDATE/DELETE cases,
+		 * ExecInitModifyTable() would've initialized this.
+		 */
+		if (node && node->returningLists != NIL)
+		{
+			TupleTableSlot *slot;
+			ExprContext *econtext;
+			List	   *returningList;
+			List	   *rlist;
+			TupleDesc	tupDesc;
+
+			/* See the comment written above for WCO lists. */
+			Assert((mtstate->operation == CMD_INSERT &&
+					list_length(node->returningLists) == 1 &&
+					mtstate->mt_nplans == 1) ||
+				   (mtstate->operation == CMD_UPDATE &&
+					list_length(node->returningLists) ==
+														mtstate->mt_nplans));
+			returningList = linitial(node->returningLists);
+
+			/*
+			 * Initialize result tuple slot and assign its rowtype using the first
+			 * RETURNING list.  We assume the rest will look the same.
+			 */
+			tupDesc = ExecTypeFromTL(returningList, false);
+
+			/* Set up a slot for the output of the RETURNING projection(s) */
+			ExecInitResultTupleSlot(estate, &mtstate->ps);
+			ExecAssignResultType(&mtstate->ps, tupDesc);
+			slot = mtstate->ps.ps_ResultTupleSlot;
+
+			/* Need an econtext too */
+			if (mtstate->ps.ps_ExprContext == NULL)
+				ExecAssignExprContext(estate, &mtstate->ps);
+			econtext = mtstate->ps.ps_ExprContext;
+
+			rlist = map_partition_varattnos(returningList,
+											firstVarno,
+											partrel, firstResultRel, NULL);
+			leaf_part_rri->ri_projectReturning =
+				ExecBuildProjectionInfo(rlist, econtext, slot, &mtstate->ps,
+										RelationGetDescr(partrel));
+		}
+
+		/*
+		 * Note that the entries in this list appear in no predetermined
+		 * order as result of initializing partition result rels as and when
+		 * they're needed.
+		 */
+		estate->es_leaf_result_relations =
+									lappend(estate->es_leaf_result_relations,
+											leaf_part_rri);
+
+		/*
+		 * Open partition indices.  The user may have asked to check for
+		 * conflicts within this leaf partition and do "nothing" instead of
+		 * throwing an error.  Be prepared in that case by initializing the
+		 * index information needed by ExecInsert() to perform speculative
+		 * insertions.
+		 */
+		if (partrel->rd_rel->relhasindex &&
+			leaf_part_rri->ri_IndexRelationDescs == NULL)
+			ExecOpenIndices(leaf_part_rri,
+							mtstate->mt_onconflict != ONCONFLICT_NONE);
+	}
+
+	/*
+	 * Verify result relation is a valid target for INSERT.
+	 */
+	CheckValidResultRel(leaf_part_rri, CMD_INSERT);
+
+	proute->partitions[partidx] = leaf_part_rri;
+
+	/*
+	 * Save a tuple conversion map to convert a tuple routed to this
+	 * partition from the parent's type to the partition's.
+	 */
+	proute->parent_child_tupconv_maps[partidx] =
+							convert_tuples_by_name(RelationGetDescr(rootrel),
+												   RelationGetDescr(partrel),
+											   gettext_noop("could not convert row type"));
+}
+
 /*
  * ExecSetupChildParentMapForLeaf -- Initialize the per-leaf-partition
  * child-to-root tuple conversion map array.
@@ -373,40 +532,90 @@ ExecSetupChildParentMapForLeaf(PartitionTupleRouting *proute)
 }
 
 /*
- * TupConvMapForLeaf -- Get the tuple conversion map for a given leaf partition
- * index.
+ * ChildParentTupConvMap -- Return tuple conversion map to convert tuples of
+ *							'partrel' into those of 'rootrel'
+ *
+ * If the function was previously called for this partition, we would've
+ * either already created the map and stored the same at
+ * proute->child_parent_tupconv_maps[index] or found out that such a map
+ * is not needed and thus set proute->child_parent_map_not_required[index].
  */
-TupleConversionMap *
-TupConvMapForLeaf(PartitionTupleRouting *proute,
-				  ResultRelInfo *rootRelInfo, int leaf_index)
+static TupleConversionMap *
+ChildParentTupConvMap(Relation partrel, Relation rootrel,
+					  PartitionTupleRouting *proute, int index)
 {
-	ResultRelInfo **resultRelInfos = proute->partitions;
-	TupleConversionMap **map;
-	TupleDesc	tupdesc;
+	TupleConversionMap *map;
 
 	/* Don't call this if we're not supposed to be using this type of map. */
 	Assert(proute->child_parent_tupconv_maps != NULL);
 
 	/* If it's already known that we don't need a map, return NULL. */
-	if (proute->child_parent_map_not_required[leaf_index])
+	if (proute->child_parent_map_not_required[index])
 		return NULL;
 
 	/* If we've already got a map, return it. */
-	map = &proute->child_parent_tupconv_maps[leaf_index];
-	if (*map != NULL)
-		return *map;
+	map = proute->child_parent_tupconv_maps[index];
+	if (map != NULL)
+		return map;
 
 	/* No map yet; try to create one. */
-	tupdesc = RelationGetDescr(resultRelInfos[leaf_index]->ri_RelationDesc);
-	*map =
-		convert_tuples_by_name(tupdesc,
-							   RelationGetDescr(rootRelInfo->ri_RelationDesc),
-							   gettext_noop("could not convert row type"));
+	map = convert_tuples_by_name(RelationGetDescr(partrel),
+								 RelationGetDescr(rootrel),
+								 gettext_noop("could not convert row type"));
 
 	/* If it turns out no map is needed, remember for next time. */
-	proute->child_parent_map_not_required[leaf_index] = (*map == NULL);
+	proute->child_parent_map_not_required[index] = (map == NULL);
+
+	return map;
+}
+
+/*
+ * TupConvMapForLeaf -- Get the tuple conversion map for a given leaf partition
+ * index.
+ *
+ * Call this only if it's known that the partition at leaf_index has been
+ * initialized with ExecInitPartitionResultRelInfo().
+ */
+TupleConversionMap *
+TupConvMapForLeaf(ModifyTableState *mtstate, int leaf_index)
+{
+	PartitionTupleRouting *proute = mtstate->mt_partition_tuple_routing;
+	ResultRelInfo **resultrels = proute->partitions,
+				  *rootRelInfo = (mtstate->rootResultRelInfo != NULL)
+									? mtstate->rootResultRelInfo
+									: mtstate->resultRelInfo;
+
+	Assert(resultrels[leaf_index] != NULL);
 
-	return *map;
+	return ChildParentTupConvMap(resultrels[leaf_index]->ri_RelationDesc,
+								 rootRelInfo->ri_RelationDesc,
+								 proute, leaf_index);
+}
+
+/*
+ * TupConvMapForSubplan -- Get the tuple conversion map for a partition given
+ * its subplan index.
+ *
+ * Call this if it's unclear whether the partition's ResultRelInfo has been
+ * initialized in mtstate->mt_partition_tuple_routing.
+ */
+TupleConversionMap *
+TupConvMapForSubplan(ModifyTableState *mtstate, int subplan_index)
+{
+	int		leaf_index;
+	PartitionTupleRouting *proute = mtstate->mt_partition_tuple_routing;
+	ResultRelInfo *resultrels = mtstate->resultRelInfo,
+				  *rootRelInfo = (mtstate->rootResultRelInfo != NULL)
+									? mtstate->rootResultRelInfo
+									: mtstate->resultRelInfo;
+
+	Assert(proute != NULL && proute->subplan_partition_offsets != NULL);
+	leaf_index = proute->subplan_partition_offsets[subplan_index];
+
+	Assert(subplan_index >= 0 && subplan_index < mtstate->mt_nplans);
+	return ChildParentTupConvMap(resultrels[subplan_index].ri_RelationDesc,
+								 rootRelInfo->ri_RelationDesc,
+								 proute, leaf_index);
 }
 
 /*
@@ -488,8 +697,11 @@ ExecCleanupTupleRouting(PartitionTupleRouting *proute)
 			continue;
 		}
 
-		ExecCloseIndices(resultRelInfo);
-		heap_close(resultRelInfo->ri_RelationDesc, NoLock);
+		if (resultRelInfo)
+		{
+			ExecCloseIndices(resultRelInfo);
+			heap_close(resultRelInfo->ri_RelationDesc, NoLock);
+		}
 	}
 
 	/* Release the standalone partition tuple descriptors, if any */
diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c
index bd88b41ff6..afd9fbc853 100644
--- a/src/backend/executor/nodeModifyTable.c
+++ b/src/backend/executor/nodeModifyTable.c
@@ -307,6 +307,7 @@ ExecInsert(ModifyTableState *mtstate,
 		 */
 		saved_resultRelInfo = resultRelInfo;
 		resultRelInfo = proute->partitions[leaf_part_index];
+		Assert(resultRelInfo != NULL);
 
 		/* We do not yet have a way to insert into a foreign partition */
 		if (resultRelInfo->ri_FdwRoutine)
@@ -335,8 +336,7 @@ ExecInsert(ModifyTableState *mtstate,
 				mtstate->mt_transition_capture->tcs_original_insert_tuple = NULL;
 
 				mtstate->mt_transition_capture->tcs_map =
-					TupConvMapForLeaf(proute, saved_resultRelInfo,
-									  leaf_part_index);
+					TupConvMapForLeaf(mtstate, leaf_part_index);
 			}
 			else
 			{
@@ -351,8 +351,7 @@ ExecInsert(ModifyTableState *mtstate,
 		if (mtstate->mt_oc_transition_capture != NULL)
 		{
 			mtstate->mt_oc_transition_capture->tcs_map =
-				TupConvMapForLeaf(proute, saved_resultRelInfo,
-								  leaf_part_index);
+				TupConvMapForLeaf(mtstate, leaf_part_index);
 		}
 
 		/*
@@ -1801,26 +1800,10 @@ tupconv_map_for_subplan(ModifyTableState *mtstate, int whichplan)
 	 * array *only* if partition-indexed array is not required.
 	 */
 	if (mtstate->mt_per_subplan_tupconv_maps == NULL)
-	{
-		int			leaf_index;
-		PartitionTupleRouting *proute = mtstate->mt_partition_tuple_routing;
+		return TupConvMapForSubplan(mtstate, whichplan);
 
-		/*
-		 * If subplan-indexed array is NULL, things should have been arranged
-		 * to convert the subplan index to partition index.
-		 */
-		Assert(proute && proute->subplan_partition_offsets != NULL);
-
-		leaf_index = proute->subplan_partition_offsets[whichplan];
-
-		return TupConvMapForLeaf(proute, getTargetResultRelInfo(mtstate),
-								 leaf_index);
-	}
-	else
-	{
-		Assert(whichplan >= 0 && whichplan < mtstate->mt_nplans);
-		return mtstate->mt_per_subplan_tupconv_maps[whichplan];
-	}
+	Assert(whichplan >= 0 && whichplan < mtstate->mt_nplans);
+	return mtstate->mt_per_subplan_tupconv_maps[whichplan];
 }
 
 /* ----------------------------------------------------------------
@@ -2094,14 +2077,10 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 	ResultRelInfo *saved_resultRelInfo;
 	ResultRelInfo *resultRelInfo;
 	Plan	   *subplan;
-	int			firstVarno = 0;
-	Relation	firstResultRel = NULL;
 	ListCell   *l;
 	int			i;
 	Relation	rel;
 	bool		update_tuple_routing_needed = node->partColsUpdated;
-	PartitionTupleRouting *proute = NULL;
-	int			num_partitions = 0;
 
 	/* check for unsupported flags */
 	Assert(!(eflags & (EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK)));
@@ -2224,20 +2203,8 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 	 */
 	if (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE &&
 		(operation == CMD_INSERT || update_tuple_routing_needed))
-	{
-		proute = mtstate->mt_partition_tuple_routing =
-			ExecSetupPartitionTupleRouting(mtstate,
-										   rel, node->nominalRelation,
-										   estate);
-		num_partitions = proute->num_partitions;
-
-		/*
-		 * Below are required as reference objects for mapping partition
-		 * attno's in expressions such as WithCheckOptions and RETURNING.
-		 */
-		firstVarno = mtstate->resultRelInfo[0].ri_RangeTableIndex;
-		firstResultRel = mtstate->resultRelInfo[0].ri_RelationDesc;
-	}
+		mtstate->mt_partition_tuple_routing =
+						ExecSetupPartitionTupleRouting(mtstate, rel);
 
 	/*
 	 * Build state for collecting transition tuples.  This requires having a
@@ -2284,77 +2251,12 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 	}
 
 	/*
-	 * Build WITH CHECK OPTION constraints for each leaf partition rel. Note
-	 * that we didn't build the withCheckOptionList for each partition within
-	 * the planner, but simple translation of the varattnos for each partition
-	 * will suffice.  This only occurs for the INSERT case or for UPDATE row
-	 * movement. DELETEs and local UPDATEs are handled above.
-	 */
-	if (node->withCheckOptionLists != NIL && num_partitions > 0)
-	{
-		List	   *first_wcoList;
-
-		/*
-		 * In case of INSERT on partitioned tables, there is only one plan.
-		 * Likewise, there is only one WITH CHECK OPTIONS list, not one per
-		 * partition. Whereas for UPDATE, there are as many WCOs as there are
-		 * plans. So in either case, use the WCO expression of the first
-		 * resultRelInfo as a reference to calculate attno's for the WCO
-		 * expression of each of the partitions. We make a copy of the WCO
-		 * qual for each partition. Note that, if there are SubPlans in there,
-		 * they all end up attached to the one parent Plan node.
-		 */
-		Assert(update_tuple_routing_needed ||
-			   (operation == CMD_INSERT &&
-				list_length(node->withCheckOptionLists) == 1 &&
-				mtstate->mt_nplans == 1));
-
-		first_wcoList = linitial(node->withCheckOptionLists);
-		for (i = 0; i < num_partitions; i++)
-		{
-			Relation	partrel;
-			List	   *mapped_wcoList;
-			List	   *wcoExprs = NIL;
-			ListCell   *ll;
-
-			resultRelInfo = proute->partitions[i];
-
-			/*
-			 * If we are referring to a resultRelInfo from one of the update
-			 * result rels, that result rel would already have
-			 * WithCheckOptions initialized.
-			 */
-			if (resultRelInfo->ri_WithCheckOptions)
-				continue;
-
-			partrel = resultRelInfo->ri_RelationDesc;
-
-			mapped_wcoList = map_partition_varattnos(first_wcoList,
-													 firstVarno,
-													 partrel, firstResultRel,
-													 NULL);
-			foreach(ll, mapped_wcoList)
-			{
-				WithCheckOption *wco = castNode(WithCheckOption, lfirst(ll));
-				ExprState  *wcoExpr = ExecInitQual(castNode(List, wco->qual),
-												   &mtstate->ps);
-
-				wcoExprs = lappend(wcoExprs, wcoExpr);
-			}
-
-			resultRelInfo->ri_WithCheckOptions = mapped_wcoList;
-			resultRelInfo->ri_WithCheckOptionExprs = wcoExprs;
-		}
-	}
-
-	/*
 	 * Initialize RETURNING projections if needed.
 	 */
 	if (node->returningLists)
 	{
 		TupleTableSlot *slot;
 		ExprContext *econtext;
-		List	   *firstReturningList;
 
 		/*
 		 * Initialize result tuple slot and assign its rowtype using the first
@@ -2385,44 +2287,6 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 										resultRelInfo->ri_RelationDesc->rd_att);
 			resultRelInfo++;
 		}
-
-		/*
-		 * Build a projection for each leaf partition rel.  Note that we
-		 * didn't build the returningList for each partition within the
-		 * planner, but simple translation of the varattnos for each partition
-		 * will suffice.  This only occurs for the INSERT case or for UPDATE
-		 * row movement. DELETEs and local UPDATEs are handled above.
-		 */
-		firstReturningList = linitial(node->returningLists);
-		for (i = 0; i < num_partitions; i++)
-		{
-			Relation	partrel;
-			List	   *rlist;
-
-			resultRelInfo = proute->partitions[i];
-
-			/*
-			 * If we are referring to a resultRelInfo from one of the update
-			 * result rels, that result rel would already have a returningList
-			 * built.
-			 */
-			if (resultRelInfo->ri_projectReturning)
-				continue;
-
-			partrel = resultRelInfo->ri_RelationDesc;
-
-			/*
-			 * Use the returning expression of the first resultRelInfo as a
-			 * reference to calculate attno's for the returning expression of
-			 * each of the partitions.
-			 */
-			rlist = map_partition_varattnos(firstReturningList,
-											firstVarno,
-											partrel, firstResultRel, NULL);
-			resultRelInfo->ri_projectReturning =
-				ExecBuildProjectionInfo(rlist, econtext, slot, &mtstate->ps,
-										resultRelInfo->ri_RelationDesc->rd_att);
-		}
 	}
 	else
 	{
diff --git a/src/include/executor/execPartition.h b/src/include/executor/execPartition.h
index 87c4c3249e..d5881c312b 100644
--- a/src/include/executor/execPartition.h
+++ b/src/include/executor/execPartition.h
@@ -96,16 +96,18 @@ typedef struct PartitionTupleRouting
 	TupleConversionMap **child_parent_tupconv_maps;
 	bool	   *child_parent_map_not_required;
 	int		   *subplan_partition_offsets;
+	Oid		   *partition_oids;
 	TupleTableSlot *partition_tuple_slot;
 	TupleTableSlot *root_tuple_slot;
 } PartitionTupleRouting;
 
 extern PartitionTupleRouting *ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
-							   Relation rel, Index resultRTindex,
-							   EState *estate);
+							   Relation rel);
 extern void ExecSetupChildParentMapForLeaf(PartitionTupleRouting *proute);
-extern TupleConversionMap *TupConvMapForLeaf(PartitionTupleRouting *proute,
-				  ResultRelInfo *rootRelInfo, int leaf_index);
+extern TupleConversionMap *TupConvMapForLeaf(ModifyTableState *mtstate,
+				  int leaf_index);
+extern TupleConversionMap *TupConvMapForSubplan(ModifyTableState *mtstate,
+				  int subplan_index);
 extern HeapTuple ConvertPartitionTupleSlot(TupleConversionMap *map,
 						  HeapTuple tuple,
 						  TupleTableSlot *new_slot,
-- 
2.11.0

From 250fe77e304a0f0841f2d7978405c2a32fdeb7a2 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Tue, 19 Dec 2017 10:43:45 +0900
Subject: [PATCH v4 1/3] Teach CopyFrom to use ModifyTableState for
 tuple-routing

This removes all fields of CopyStateData that were meant for
tuple routing and instead uses ModifyTableState that has all those
fields, including transition_tupconv_maps.  In COPY's case,
transition_tupconv_maps is only required if tuple routing is being
used, so it's safe.
---
 src/backend/commands/copy.c | 26 +++++++++++++++-----------
 1 file changed, 15 insertions(+), 11 deletions(-)

diff --git a/src/backend/commands/copy.c b/src/backend/commands/copy.c
index 04a24c6082..251676b321 100644
--- a/src/backend/commands/copy.c
+++ b/src/backend/commands/copy.c
@@ -166,9 +166,6 @@ typedef struct CopyStateData
 	bool		volatile_defexprs;	/* is any of defexprs volatile? */
 	List	   *range_table;
 
-	/* Tuple-routing support info */
-	PartitionTupleRouting *partition_tuple_routing;
-
 	TransitionCaptureState *transition_capture;
 
 	/*
@@ -2285,6 +2282,7 @@ CopyFrom(CopyState cstate)
 	ResultRelInfo *resultRelInfo;
 	ResultRelInfo *saved_resultRelInfo = NULL;
 	EState	   *estate = CreateExecutorState(); /* for ExecConstraints() */
+	ModifyTableState *mtstate = makeNode(ModifyTableState);
 	ExprContext *econtext;
 	TupleTableSlot *myslot;
 	MemoryContext oldcontext = CurrentMemoryContext;
@@ -2303,6 +2301,8 @@ CopyFrom(CopyState cstate)
 	Size		bufferedTuplesSize = 0;
 	int			firstBufferedLineNo = 0;
 
+	PartitionTupleRouting *proute = NULL;
+
 	Assert(cstate->rel);
 
 	/*
@@ -2468,10 +2468,15 @@ CopyFrom(CopyState cstate)
 	 */
 	if (cstate->rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
 	{
-		PartitionTupleRouting *proute;
+		ModifyTable *node = makeNode(ModifyTable);
 
-		proute = cstate->partition_tuple_routing =
-			ExecSetupPartitionTupleRouting(NULL, cstate->rel, 1, estate);
+		/* Just need make this field appear valid. */
+		node->nominalRelation = 1;
+		mtstate->ps.plan = (Plan *) node;
+		mtstate->ps.state = estate;
+		mtstate->resultRelInfo = resultRelInfo;
+		proute = mtstate->mt_partition_tuple_routing =
+			ExecSetupPartitionTupleRouting(mtstate, cstate->rel, 1, estate);
 
 		/*
 		 * If we are capturing transition tuples, they may need to be
@@ -2496,7 +2501,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_tuple_routing != NULL ||
+		mtstate->mt_partition_tuple_routing != NULL ||
 		cstate->volatile_defexprs)
 	{
 		useHeapMultiInsert = false;
@@ -2571,10 +2576,9 @@ CopyFrom(CopyState cstate)
 		ExecStoreTuple(tuple, slot, InvalidBuffer, false);
 
 		/* Determine the partition to heap_insert the tuple into */
-		if (cstate->partition_tuple_routing)
+		if (cstate->rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
 		{
 			int			leaf_part_index;
-			PartitionTupleRouting *proute = cstate->partition_tuple_routing;
 
 			/*
 			 * Away we go ... If we end up not finding a partition after all,
@@ -2806,8 +2810,8 @@ CopyFrom(CopyState cstate)
 	ExecCloseIndices(resultRelInfo);
 
 	/* Close all the partitioned tables, leaf partitions, and their indices */
-	if (cstate->partition_tuple_routing)
-		ExecCleanupTupleRouting(cstate->partition_tuple_routing);
+	if (proute)
+		ExecCleanupTupleRouting(proute);
 
 	/* Close any trigger target relations */
 	ExecCleanUpTriggerState(estate);
-- 
2.11.0

From 96f0b1fed760e8b921f2d1e5be72ad864f9dd3f6 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Tue, 19 Dec 2017 13:56:25 +0900
Subject: [PATCH v4 2/3] ExecFindPartition refactoring

---
 src/backend/commands/copy.c            |  5 +----
 src/backend/executor/execPartition.c   | 17 +++++++++--------
 src/backend/executor/nodeModifyTable.c |  5 +----
 src/include/executor/execPartition.h   |  5 +----
 4 files changed, 12 insertions(+), 20 deletions(-)

diff --git a/src/backend/commands/copy.c b/src/backend/commands/copy.c
index 251676b321..2096a52cea 100644
--- a/src/backend/commands/copy.c
+++ b/src/backend/commands/copy.c
@@ -2588,10 +2588,7 @@ CopyFrom(CopyState cstate)
 			 * will get us the ResultRelInfo and TupleConversionMap for the
 			 * partition, respectively.
 			 */
-			leaf_part_index = ExecFindPartition(resultRelInfo,
-												proute->partition_dispatch_info,
-												slot,
-												estate);
+			leaf_part_index = ExecFindPartition(mtstate, slot);
 			Assert(leaf_part_index >= 0 &&
 				   leaf_part_index < proute->num_partitions);
 
diff --git a/src/backend/executor/execPartition.c b/src/backend/executor/execPartition.c
index 106a96d910..947adf3032 100644
--- a/src/backend/executor/execPartition.c
+++ b/src/backend/executor/execPartition.c
@@ -227,11 +227,7 @@ ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
 }
 
 /*
- * ExecFindPartition -- Find a leaf partition in the partition tree rooted
- * at parent, for the heap tuple contained in *slot
- *
- * estate must be non-NULL; we'll need it to compute any expressions in the
- * partition key(s)
+ * ExecFindPartition -- Find a leaf partition for tuple contained in slot
  *
  * If no leaf partition is found, this routine errors out with the appropriate
  * error message, else it returns the leaf partition sequence number
@@ -239,14 +235,19 @@ ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
  * the partition tree.
  */
 int
-ExecFindPartition(ResultRelInfo *resultRelInfo, PartitionDispatch *pd,
-				  TupleTableSlot *slot, EState *estate)
+ExecFindPartition(ModifyTableState *mtstate, TupleTableSlot *slot)
 {
+	EState	   *estate = mtstate->ps.state;
 	int			result;
 	Datum		values[PARTITION_MAX_KEYS];
 	bool		isnull[PARTITION_MAX_KEYS];
 	Relation	rel;
-	PartitionDispatch parent;
+	PartitionTupleRouting *proute = mtstate->mt_partition_tuple_routing;
+	PartitionDispatch  *pd = proute->partition_dispatch_info,
+						parent;
+	ResultRelInfo *resultRelInfo = (mtstate->rootResultRelInfo != NULL)
+										? mtstate->rootResultRelInfo
+										: mtstate->resultRelInfo;
 	ExprContext *ecxt = GetPerTupleExprContext(estate);
 	TupleTableSlot *ecxt_scantuple_old = ecxt->ecxt_scantuple;
 
diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c
index 828e1b0015..d2df9e94cf 100644
--- a/src/backend/executor/nodeModifyTable.c
+++ b/src/backend/executor/nodeModifyTable.c
@@ -297,10 +297,7 @@ ExecInsert(ModifyTableState *mtstate,
 		 * get us the ResultRelInfo and TupleConversionMap for the partition,
 		 * respectively.
 		 */
-		leaf_part_index = ExecFindPartition(resultRelInfo,
-											proute->partition_dispatch_info,
-											slot,
-											estate);
+		leaf_part_index = ExecFindPartition(mtstate, slot);
 		Assert(leaf_part_index >= 0 &&
 			   leaf_part_index < proute->num_partitions);
 
diff --git a/src/include/executor/execPartition.h b/src/include/executor/execPartition.h
index 3df9c498bb..7373f60ffb 100644
--- a/src/include/executor/execPartition.h
+++ b/src/include/executor/execPartition.h
@@ -105,10 +105,6 @@ typedef struct PartitionTupleRouting
 extern PartitionTupleRouting *ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
 							   Relation rel, Index resultRTindex,
 							   EState *estate);
-extern int ExecFindPartition(ResultRelInfo *resultRelInfo,
-				  PartitionDispatch *pd,
-				  TupleTableSlot *slot,
-				  EState *estate);
 extern void ExecSetupChildParentMapForLeaf(PartitionTupleRouting *proute);
 extern TupleConversionMap *TupConvMapForLeaf(PartitionTupleRouting *proute,
 				  ResultRelInfo *rootRelInfo, int leaf_index);
@@ -117,5 +113,6 @@ extern HeapTuple ConvertPartitionTupleSlot(TupleConversionMap *map,
 						  TupleTableSlot *new_slot,
 						  TupleTableSlot **p_my_slot);
 extern void ExecCleanupTupleRouting(PartitionTupleRouting *proute);
+extern int ExecFindPartition(ModifyTableState *mtstate, TupleTableSlot *slot);
 
 #endif							/* EXECPARTITION_H */
-- 
2.11.0

From c821f1e30e3c33424fec52a7b1e1a7c28cbacba9 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Tue, 19 Dec 2017 16:20:09 +0900
Subject: [PATCH v4 3/3] During tuple-routing, initialize per-partition objects
 lazily

Those objects include ResultRelInfo, tuple conversion map,
WITH CHECK OPTION quals and RETURNING projections.

This means we don't allocate these objects for partitions that are
never inserted into.
---
 src/backend/commands/copy.c            |   6 +-
 src/backend/executor/execPartition.c   | 506 +++++++++++++++++++++++----------
 src/backend/executor/nodeModifyTable.c | 153 +---------
 src/include/executor/execPartition.h   |  10 +-
 4 files changed, 377 insertions(+), 298 deletions(-)

diff --git a/src/backend/commands/copy.c b/src/backend/commands/copy.c
index 2096a52cea..1000bb4461 100644
--- a/src/backend/commands/copy.c
+++ b/src/backend/commands/copy.c
@@ -2476,7 +2476,7 @@ CopyFrom(CopyState cstate)
 		mtstate->ps.state = estate;
 		mtstate->resultRelInfo = resultRelInfo;
 		proute = mtstate->mt_partition_tuple_routing =
-			ExecSetupPartitionTupleRouting(mtstate, cstate->rel, 1, estate);
+			ExecSetupPartitionTupleRouting(mtstate, cstate->rel);
 
 		/*
 		 * If we are capturing transition tuples, they may need to be
@@ -2609,6 +2609,7 @@ CopyFrom(CopyState cstate)
 			 */
 			saved_resultRelInfo = resultRelInfo;
 			resultRelInfo = proute->partitions[leaf_part_index];
+			Assert(resultRelInfo != NULL);
 
 			/* We do not yet have a way to insert into a foreign partition */
 			if (resultRelInfo->ri_FdwRoutine)
@@ -2638,8 +2639,7 @@ CopyFrom(CopyState cstate)
 					 */
 					cstate->transition_capture->tcs_original_insert_tuple = NULL;
 					cstate->transition_capture->tcs_map =
-						TupConvMapForLeaf(proute, saved_resultRelInfo,
-										  leaf_part_index);
+						TupConvMapForLeaf(mtstate, leaf_part_index);
 				}
 				else
 				{
diff --git a/src/backend/executor/execPartition.c b/src/backend/executor/execPartition.c
index 947adf3032..088f1fafd9 100644
--- a/src/backend/executor/execPartition.c
+++ b/src/backend/executor/execPartition.c
@@ -23,6 +23,8 @@
 #include "utils/rls.h"
 #include "utils/ruleutils.h"
 
+static void ExecInitPartitionResultRelInfo(ModifyTableState *mtstate,
+					int partidx);
 static PartitionDispatch *RelationGetPartitionDispatchInfo(Relation rel,
 								 int *num_parted, List **leaf_part_oids);
 static void get_partition_dispatch_recurse(Relation rel, Relation parent,
@@ -44,22 +46,23 @@ static char *ExecBuildSlotPartitionKeyDescription(Relation rel,
  *
  * Note that all the relations in the partition tree are locked using the
  * RowExclusiveLock mode upon return from this function.
+ *
+ * While we allocate the arrays of pointers of various objects for all
+ * partitions here, the objects themselves are lazily allocated and
+ * initialized for a given partition if a tuple is actually routed to it;
+ * see ExecInitPartitionResultRelInfo.
  */
 PartitionTupleRouting *
-ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
-							   Relation rel, Index resultRTindex,
-							   EState *estate)
+ExecSetupPartitionTupleRouting(ModifyTableState *mtstate, Relation rel)
 {
-	TupleDesc	tupDesc = RelationGetDescr(rel);
+	PartitionTupleRouting *proute;
 	List	   *leaf_parts;
 	ListCell   *cell;
-	int			i;
-	ResultRelInfo *leaf_part_arr = NULL,
-			   *update_rri = NULL;
-	int			num_update_rri = 0,
-				update_rri_index = 0;
-	bool		is_update = false;
-	PartitionTupleRouting *proute;
+	int			leaf_index,
+				update_rri_index,
+				num_update_rri;
+	bool		is_update;
+	ResultRelInfo *update_rri;
 
 	/*
 	 * Get the information about the partition tree after locking all the
@@ -71,20 +74,24 @@ ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
 		RelationGetPartitionDispatchInfo(rel, &proute->num_dispatch,
 										 &leaf_parts);
 	proute->num_partitions = list_length(leaf_parts);
-	proute->partitions = (ResultRelInfo **) palloc(proute->num_partitions *
-												   sizeof(ResultRelInfo *));
+	/*
+	 * Actual ResultRelInfo's and TupleConversionMap's are allocated in
+	 * ExecInitResultRelInfo().
+	 */
+	proute->partitions = (ResultRelInfo **) palloc0(proute->num_partitions *
+													sizeof(ResultRelInfo *));
 	proute->parent_child_tupconv_maps =
 		(TupleConversionMap **) palloc0(proute->num_partitions *
 										sizeof(TupleConversionMap *));
+	proute->partition_oids = (Oid *) palloc0(proute->num_partitions *
+											 sizeof(Oid));
 
 	/* Set up details specific to the type of tuple routing we are doing. */
 	if (mtstate && mtstate->operation == CMD_UPDATE)
 	{
-		ModifyTable *node = (ModifyTable *) mtstate->ps.plan;
-
 		is_update = true;
 		update_rri = mtstate->resultRelInfo;
-		num_update_rri = list_length(node->plans);
+		num_update_rri = mtstate->mt_nplans;
 		proute->subplan_partition_offsets =
 			palloc(num_update_rri * sizeof(int));
 		proute->num_subplan_partition_offsets = num_update_rri;
@@ -95,15 +102,29 @@ ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
 		 */
 		proute->root_tuple_slot = MakeTupleTableSlot();
 	}
-	else
+
+	leaf_index = update_rri_index = 0;
+	foreach (cell, leaf_parts)
 	{
+		Oid		leaf_oid = lfirst_oid(cell);
+
+		proute->partition_oids[leaf_index] = leaf_oid;
+
 		/*
-		 * Since we are inserting tuples, we need to create all new result
-		 * rels. Avoid repeated pallocs by allocating memory for all the
-		 * result rels in bulk.
+		 * The per-subplan resultrels and the resultrels of the leaf
+		 * partitions are both in the same canonical order.  So while going
+		 * through the leaf partition oids, we need to keep track of the
+		 * next per-subplan result rel to be looked for in the leaf
+		 * partition resultrels.
 		 */
-		leaf_part_arr = (ResultRelInfo *) palloc0(proute->num_partitions *
-												  sizeof(ResultRelInfo));
+		if (is_update && update_rri_index < num_update_rri &&
+			RelationGetRelid(update_rri[update_rri_index].ri_RelationDesc) == leaf_oid)
+		{
+			proute->subplan_partition_offsets[update_rri_index] = leaf_index;
+			update_rri_index++;
+		}
+
+		leaf_index++;
 	}
 
 	/*
@@ -114,109 +135,6 @@ ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
 	 */
 	proute->partition_tuple_slot = MakeTupleTableSlot();
 
-	i = 0;
-	foreach(cell, leaf_parts)
-	{
-		ResultRelInfo *leaf_part_rri;
-		Relation	partrel = NULL;
-		TupleDesc	part_tupdesc;
-		Oid			leaf_oid = lfirst_oid(cell);
-
-		if (is_update)
-		{
-			/*
-			 * If the leaf partition is already present in the per-subplan
-			 * result rels, we re-use that rather than initialize a new result
-			 * rel. The per-subplan resultrels and the resultrels of the leaf
-			 * partitions are both in the same canonical order. So while going
-			 * through the leaf partition oids, we need to keep track of the
-			 * next per-subplan result rel to be looked for in the leaf
-			 * partition resultrels.
-			 */
-			if (update_rri_index < num_update_rri &&
-				RelationGetRelid(update_rri[update_rri_index].ri_RelationDesc) == leaf_oid)
-			{
-				leaf_part_rri = &update_rri[update_rri_index];
-				partrel = leaf_part_rri->ri_RelationDesc;
-
-				/*
-				 * This is required in order to we convert the partition's
-				 * tuple to be compatible with the root partitioned table's
-				 * tuple descriptor.  When generating the per-subplan result
-				 * rels, this was not set.
-				 */
-				leaf_part_rri->ri_PartitionRoot = rel;
-
-				/* Remember the subplan offset for this ResultRelInfo */
-				proute->subplan_partition_offsets[update_rri_index] = i;
-
-				update_rri_index++;
-			}
-			else
-				leaf_part_rri = (ResultRelInfo *) palloc0(sizeof(ResultRelInfo));
-		}
-		else
-		{
-			/* For INSERTs, we already have an array of result rels allocated */
-			leaf_part_rri = &leaf_part_arr[i];
-		}
-
-		/*
-		 * If we didn't open the partition rel, it means we haven't
-		 * initialized the result rel either.
-		 */
-		if (!partrel)
-		{
-			/*
-			 * We locked all the partitions above including the leaf
-			 * partitions. Note that each of the newly opened relations in
-			 * proute->partitions are eventually closed by the caller.
-			 */
-			partrel = heap_open(leaf_oid, NoLock);
-			InitResultRelInfo(leaf_part_rri,
-							  partrel,
-							  resultRTindex,
-							  rel,
-							  estate->es_instrument);
-		}
-
-		part_tupdesc = RelationGetDescr(partrel);
-
-		/*
-		 * Save a tuple conversion map to convert a tuple routed to this
-		 * partition from the parent's type to the partition's.
-		 */
-		proute->parent_child_tupconv_maps[i] =
-			convert_tuples_by_name(tupDesc, part_tupdesc,
-								   gettext_noop("could not convert row type"));
-
-		/*
-		 * Verify result relation is a valid target for an INSERT.  An UPDATE
-		 * of a partition-key becomes a DELETE+INSERT operation, so this check
-		 * is still required when the operation is CMD_UPDATE.
-		 */
-		CheckValidResultRel(leaf_part_rri, CMD_INSERT);
-
-		/*
-		 * Open partition indices.  The user may have asked to check for
-		 * conflicts within this leaf partition and do "nothing" instead of
-		 * throwing an error.  Be prepared in that case by initializing the
-		 * index information needed by ExecInsert() to perform speculative
-		 * insertions.
-		 */
-		if (leaf_part_rri->ri_RelationDesc->rd_rel->relhasindex &&
-			leaf_part_rri->ri_IndexRelationDescs == NULL)
-			ExecOpenIndices(leaf_part_rri,
-							mtstate != NULL &&
-							mtstate->mt_onconflict != ONCONFLICT_NONE);
-
-		estate->es_leaf_result_relations =
-			lappend(estate->es_leaf_result_relations, leaf_part_rri);
-
-		proute->partitions[i] = leaf_part_rri;
-		i++;
-	}
-
 	/*
 	 * For UPDATE, we should have found all the per-subplan resultrels in the
 	 * leaf partitions.
@@ -342,10 +260,251 @@ ExecFindPartition(ModifyTableState *mtstate, TupleTableSlot *slot)
 				 val_desc ? errdetail("Partition key of the failing row contains %s.", val_desc) : 0));
 	}
 
+	/* Initialize the partition result rel, if not done already. */
+	ExecInitPartitionResultRelInfo(mtstate, result);
 	ecxt->ecxt_scantuple = ecxt_scantuple_old;
 	return result;
 }
 
+static int
+leafpart_index_cmp(const void *arg1, const void *arg2)
+{
+	int		leafidx1 = *(const int *) arg1;
+	int		leafidx2 = *(const int *) arg2;
+
+	if (leafidx1 > leafidx2)
+		return 1;
+	else if (leafidx1 < leafidx2)
+		return -1;
+	return 0;
+}
+
+/*
+ * ExecInitPartitionResultRelInfo
+ *		Initialize ResultRelInfo for a partition if not done already
+ */
+static void
+ExecInitPartitionResultRelInfo(ModifyTableState *mtstate, int partidx)
+{
+	PartitionTupleRouting *proute = mtstate->mt_partition_tuple_routing;
+	Relation	partrel,
+				rootrel;
+	ResultRelInfo *leaf_part_rri;
+	int			firstVarno;
+	Relation	firstResultRel;
+
+	/* Nothing to do if already set.*/
+	if (proute->partitions[partidx])
+		return;
+
+	leaf_part_rri = NULL;
+	rootrel = (mtstate->rootResultRelInfo != NULL)
+						? mtstate->rootResultRelInfo->ri_RelationDesc
+						: mtstate->resultRelInfo->ri_RelationDesc;
+
+	/*
+	 * If we are doing tuple routing for update, try to reuse the
+	 * per-subplan resultrel for this partition that ExecInitModifyTable()
+	 * might already have created.
+	 */
+	if (mtstate && mtstate->operation == CMD_UPDATE)
+	{
+		ResultRelInfo   *update_rri;
+		int   *partidx_entry;
+
+		update_rri = mtstate->resultRelInfo;
+
+		/*
+		 * If the partition got a subplan, we'd be able to find its index
+		 * in proute->subplan_partition_offsets.
+		 */
+		partidx_entry = (int *) bsearch(&partidx,
+										proute->subplan_partition_offsets,
+										mtstate->mt_nplans, sizeof(int),
+										leafpart_index_cmp);
+		if (partidx_entry)
+		{
+			int		update_rri_index =
+							partidx_entry - proute->subplan_partition_offsets;
+
+			Assert (update_rri_index < mtstate->mt_nplans);
+			leaf_part_rri = &update_rri[update_rri_index];
+			partrel = leaf_part_rri->ri_RelationDesc;
+
+			/*
+			 * This is required in order to we convert the partition's
+			 * tuple to be compatible with the root partitioned table's
+			 * tuple descriptor.  When generating the per-subplan result
+			 * rels, this was not set.
+			 */
+			leaf_part_rri->ri_PartitionRoot = rootrel;
+		}
+	}
+
+	/*
+	 * Create new result rel, either if we are *inserting* the new tuple, or
+	 * if we didn't find the result rel above for the update tuple routing
+	 * case.
+	 */
+	if (leaf_part_rri == NULL)
+	{
+		EState	   *estate = mtstate->ps.state;
+		ModifyTable *node = (ModifyTable *) mtstate->ps.plan;
+		Index		resultRTindex = node->nominalRelation;
+
+		leaf_part_rri = (ResultRelInfo *) palloc0(sizeof(ResultRelInfo));
+
+		/*
+		 * We locked all the partitions in ExecSetupPartitionTupleRouting
+		 * including the leaf partitions.
+		 */
+		partrel = heap_open(proute->partition_oids[partidx], NoLock);
+		InitResultRelInfo(leaf_part_rri,
+						  partrel,
+						  resultRTindex,
+						  rootrel,
+						  estate->es_instrument);
+
+		/*
+		 * These are required as reference objects for mapping partition
+		 * attno's in expressions in WithCheckOptions and RETURNING.
+		 */
+		firstVarno = mtstate->resultRelInfo[0].ri_RangeTableIndex;
+		firstResultRel = mtstate->resultRelInfo[0].ri_RelationDesc;
+
+		/*
+		 * Build WITH CHECK OPTION constraints for this partition rel.  Note
+		 * that we didn't build the withCheckOptionList for each partition
+		 * within the planner, but simple translation of the varattnos will
+		 * suffice.  This only occurs for the INSERT case or in the case of
+		 * UPDATE for which we didn't find a result rel above to reuse.
+		 */
+		if (node && node->withCheckOptionLists != NIL)
+		{
+			List	   *wcoList;
+			List	   *mapped_wcoList;
+			List	   *wcoExprs = NIL;
+			ListCell   *ll;
+
+			/*
+			 * In the case of INSERT on partitioned tables, there is only one
+			 * plan.  Likewise, there is only one WCO list, not one per
+			 * partition.  For UPDATE, there would be as many WCO lists as
+			 * there are plans, but we use the first one as reference.  Note
+			 * that if there are SubPlans in there, they all end up attached
+			 * to the one parent Plan node.
+			 */
+			Assert((mtstate->operation == CMD_INSERT &&
+					list_length(node->withCheckOptionLists) == 1 &&
+					mtstate->mt_nplans == 1) ||
+				   (mtstate->operation == CMD_UPDATE &&
+					list_length(node->withCheckOptionLists) ==
+														mtstate->mt_nplans));
+			wcoList = linitial(node->withCheckOptionLists);
+
+			mapped_wcoList = map_partition_varattnos(wcoList,
+													 firstVarno,
+													 partrel, firstResultRel,
+													 NULL);
+			foreach(ll, mapped_wcoList)
+			{
+				WithCheckOption *wco = castNode(WithCheckOption, lfirst(ll));
+				ExprState  *wcoExpr = ExecInitQual(castNode(List, wco->qual),
+												   mtstate->mt_plans[0]);
+				wcoExprs = lappend(wcoExprs, wcoExpr);
+			}
+
+			leaf_part_rri->ri_WithCheckOptions = mapped_wcoList;
+			leaf_part_rri->ri_WithCheckOptionExprs = wcoExprs;
+		}
+
+		/*
+		 * Build the RETURNING projection if any for the partition.  Note that
+		 * we didn't build the returningList for each partition within the
+		 * planner, but simple translation of the varattnos will suffice.
+		 * This only occurs for the INSERT case; in the UPDATE/DELETE cases,
+		 * ExecInitModifyTable() would've initialized this.
+		 */
+		if (node && node->returningLists != NIL)
+		{
+			TupleTableSlot *slot;
+			ExprContext *econtext;
+			List	   *returningList;
+			List	   *rlist;
+			TupleDesc	tupDesc;
+
+			/* See the comment written above for WCO lists. */
+			Assert((mtstate->operation == CMD_INSERT &&
+					list_length(node->returningLists) == 1 &&
+					mtstate->mt_nplans == 1) ||
+				   (mtstate->operation == CMD_UPDATE &&
+					list_length(node->returningLists) ==
+														mtstate->mt_nplans));
+			returningList = linitial(node->returningLists);
+
+			/*
+			 * Initialize result tuple slot and assign its rowtype using the first
+			 * RETURNING list.  We assume the rest will look the same.
+			 */
+			tupDesc = ExecTypeFromTL(returningList, false);
+
+			/* Set up a slot for the output of the RETURNING projection(s) */
+			ExecInitResultTupleSlot(estate, &mtstate->ps);
+			ExecAssignResultType(&mtstate->ps, tupDesc);
+			slot = mtstate->ps.ps_ResultTupleSlot;
+
+			/* Need an econtext too */
+			if (mtstate->ps.ps_ExprContext == NULL)
+				ExecAssignExprContext(estate, &mtstate->ps);
+			econtext = mtstate->ps.ps_ExprContext;
+
+			rlist = map_partition_varattnos(returningList,
+											firstVarno,
+											partrel, firstResultRel, NULL);
+			leaf_part_rri->ri_projectReturning =
+				ExecBuildProjectionInfo(rlist, econtext, slot, &mtstate->ps,
+										RelationGetDescr(partrel));
+		}
+
+		/*
+		 * Note that the entries in this list appear in no predetermined
+		 * order as result of initializing partition result rels as and when
+		 * they're needed.
+		 */
+		estate->es_leaf_result_relations =
+									lappend(estate->es_leaf_result_relations,
+											leaf_part_rri);
+
+		/*
+		 * Open partition indices.  The user may have asked to check for
+		 * conflicts within this leaf partition and do "nothing" instead of
+		 * throwing an error.  Be prepared in that case by initializing the
+		 * index information needed by ExecInsert() to perform speculative
+		 * insertions.
+		 */
+		if (partrel->rd_rel->relhasindex &&
+			leaf_part_rri->ri_IndexRelationDescs == NULL)
+			ExecOpenIndices(leaf_part_rri,
+							mtstate->mt_onconflict != ONCONFLICT_NONE);
+	}
+
+	/*
+	 * Verify result relation is a valid target for INSERT.
+	 */
+	CheckValidResultRel(leaf_part_rri, CMD_INSERT);
+
+	proute->partitions[partidx] = leaf_part_rri;
+
+	/*
+	 * Save a tuple conversion map to convert a tuple routed to this
+	 * partition from the parent's type to the partition's.
+	 */
+	proute->parent_child_tupconv_maps[partidx] =
+							convert_tuples_by_name(RelationGetDescr(rootrel),
+												   RelationGetDescr(partrel),
+											   gettext_noop("could not convert row type"));
+}
+
 /*
  * ExecSetupChildParentMapForLeaf -- Initialize the per-leaf-partition
  * child-to-root tuple conversion map array.
@@ -374,40 +533,92 @@ ExecSetupChildParentMapForLeaf(PartitionTupleRouting *proute)
 }
 
 /*
- * TupConvMapForLeaf -- Get the tuple conversion map for a given leaf partition
- * index.
+ * ChildParentTupConvMap -- Return tuple conversion map to convert tuples of
+ *							'partrel' into those of 'rootrel'
+ *
+ * If the function was previously called for this partition, we would've
+ * either already created the map and stored the same at
+ * proute->child_parent_tupconv_maps[index] or found out that such a map
+ * is not needed and thus set proute->child_parent_map_not_required[index].
  */
-TupleConversionMap *
-TupConvMapForLeaf(PartitionTupleRouting *proute,
-				  ResultRelInfo *rootRelInfo, int leaf_index)
+static TupleConversionMap *
+ChildParentTupConvMap(Relation partrel, Relation rootrel,
+					  PartitionTupleRouting *proute, int index)
 {
-	ResultRelInfo **resultRelInfos = proute->partitions;
-	TupleConversionMap **map;
-	TupleDesc	tupdesc;
+	TupleConversionMap *map;
 
 	/* Don't call this if we're not supposed to be using this type of map. */
 	Assert(proute->child_parent_tupconv_maps != NULL);
 
 	/* If it's already known that we don't need a map, return NULL. */
-	if (proute->child_parent_map_not_required[leaf_index])
+	if (proute->child_parent_map_not_required[index])
 		return NULL;
 
 	/* If we've already got a map, return it. */
-	map = &proute->child_parent_tupconv_maps[leaf_index];
-	if (*map != NULL)
-		return *map;
+	map = proute->child_parent_tupconv_maps[index];
+	if (map != NULL)
+		return map;
 
 	/* No map yet; try to create one. */
-	tupdesc = RelationGetDescr(resultRelInfos[leaf_index]->ri_RelationDesc);
-	*map =
-		convert_tuples_by_name(tupdesc,
-							   RelationGetDescr(rootRelInfo->ri_RelationDesc),
-							   gettext_noop("could not convert row type"));
+	map = convert_tuples_by_name(RelationGetDescr(partrel),
+								 RelationGetDescr(rootrel),
+								 gettext_noop("could not convert row type"));
 
 	/* If it turns out no map is needed, remember for next time. */
-	proute->child_parent_map_not_required[leaf_index] = (*map == NULL);
+	proute->child_parent_map_not_required[index] = (map == NULL);
+
+	return map;
+}
+
+/*
+ * TupConvMapForLeaf -- Get the tuple conversion map for a given leaf partition
+ * index.
+ *
+ * Call this only if it's known that the partition at leaf_index has been
+ * initialized with ExecInitPartitionResultRelInfo().
+ */
+TupleConversionMap *
+TupConvMapForLeaf(ModifyTableState *mtstate, int leaf_index)
+{
+	PartitionTupleRouting *proute = mtstate->mt_partition_tuple_routing;
+	ResultRelInfo **resultrels = proute->partitions,
+				  *rootRelInfo = (mtstate->rootResultRelInfo != NULL)
+									? mtstate->rootResultRelInfo
+									: mtstate->resultRelInfo;
+
+	Assert(resultrels[leaf_index] != NULL);
 
-	return *map;
+	return ChildParentTupConvMap(resultrels[leaf_index]->ri_RelationDesc,
+								 rootRelInfo->ri_RelationDesc,
+								 proute, leaf_index);
+}
+
+/*
+ * TupConvMapForSubplan -- Get the tuple conversion map for a partition given
+ * its subplan index.
+ *
+ * Call this if it's unclear whether the partition's ResultRelInfo has been
+ * initialized in mtstate->mt_partition_tuple_routing.
+ */
+TupleConversionMap *
+TupConvMapForSubplan(ModifyTableState *mtstate, int subplan_index)
+{
+	int		leaf_index;
+	PartitionTupleRouting *proute = mtstate->mt_partition_tuple_routing;
+	ResultRelInfo *resultrels = mtstate->resultRelInfo,
+				  *rootRelInfo = (mtstate->rootResultRelInfo != NULL)
+									? mtstate->rootResultRelInfo
+									: mtstate->resultRelInfo;
+
+	Assert(proute != NULL &&
+		   proute->subplan_partition_offsets != NULL &&
+		   subplan_index < proute->num_subplan_partition_offsets);
+	leaf_index = proute->subplan_partition_offsets[subplan_index];
+
+	Assert(subplan_index >= 0 && subplan_index < mtstate->mt_nplans);
+	return ChildParentTupConvMap(resultrels[subplan_index].ri_RelationDesc,
+								 rootRelInfo->ri_RelationDesc,
+								 proute, leaf_index);
 }
 
 /*
@@ -490,8 +701,11 @@ ExecCleanupTupleRouting(PartitionTupleRouting *proute)
 			continue;
 		}
 
-		ExecCloseIndices(resultRelInfo);
-		heap_close(resultRelInfo->ri_RelationDesc, NoLock);
+		if (resultRelInfo)
+		{
+			ExecCloseIndices(resultRelInfo);
+			heap_close(resultRelInfo->ri_RelationDesc, NoLock);
+		}
 	}
 
 	/* Release the standalone partition tuple descriptors, if any */
diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c
index d2df9e94cf..afd9fbc853 100644
--- a/src/backend/executor/nodeModifyTable.c
+++ b/src/backend/executor/nodeModifyTable.c
@@ -307,6 +307,7 @@ ExecInsert(ModifyTableState *mtstate,
 		 */
 		saved_resultRelInfo = resultRelInfo;
 		resultRelInfo = proute->partitions[leaf_part_index];
+		Assert(resultRelInfo != NULL);
 
 		/* We do not yet have a way to insert into a foreign partition */
 		if (resultRelInfo->ri_FdwRoutine)
@@ -335,8 +336,7 @@ ExecInsert(ModifyTableState *mtstate,
 				mtstate->mt_transition_capture->tcs_original_insert_tuple = NULL;
 
 				mtstate->mt_transition_capture->tcs_map =
-					TupConvMapForLeaf(proute, saved_resultRelInfo,
-									  leaf_part_index);
+					TupConvMapForLeaf(mtstate, leaf_part_index);
 			}
 			else
 			{
@@ -351,8 +351,7 @@ ExecInsert(ModifyTableState *mtstate,
 		if (mtstate->mt_oc_transition_capture != NULL)
 		{
 			mtstate->mt_oc_transition_capture->tcs_map =
-				TupConvMapForLeaf(proute, saved_resultRelInfo,
-								  leaf_part_index);
+				TupConvMapForLeaf(mtstate, leaf_part_index);
 		}
 
 		/*
@@ -1801,27 +1800,10 @@ tupconv_map_for_subplan(ModifyTableState *mtstate, int whichplan)
 	 * array *only* if partition-indexed array is not required.
 	 */
 	if (mtstate->mt_per_subplan_tupconv_maps == NULL)
-	{
-		int			leaf_index;
-		PartitionTupleRouting *proute = mtstate->mt_partition_tuple_routing;
+		return TupConvMapForSubplan(mtstate, whichplan);
 
-		/*
-		 * If subplan-indexed array is NULL, things should have been arranged
-		 * to convert the subplan index to partition index.
-		 */
-		Assert(proute && proute->subplan_partition_offsets != NULL &&
-			   whichplan < proute->num_subplan_partition_offsets);
-
-		leaf_index = proute->subplan_partition_offsets[whichplan];
-
-		return TupConvMapForLeaf(proute, getTargetResultRelInfo(mtstate),
-								 leaf_index);
-	}
-	else
-	{
-		Assert(whichplan >= 0 && whichplan < mtstate->mt_nplans);
-		return mtstate->mt_per_subplan_tupconv_maps[whichplan];
-	}
+	Assert(whichplan >= 0 && whichplan < mtstate->mt_nplans);
+	return mtstate->mt_per_subplan_tupconv_maps[whichplan];
 }
 
 /* ----------------------------------------------------------------
@@ -2095,14 +2077,10 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 	ResultRelInfo *saved_resultRelInfo;
 	ResultRelInfo *resultRelInfo;
 	Plan	   *subplan;
-	int			firstVarno = 0;
-	Relation	firstResultRel = NULL;
 	ListCell   *l;
 	int			i;
 	Relation	rel;
 	bool		update_tuple_routing_needed = node->partColsUpdated;
-	PartitionTupleRouting *proute = NULL;
-	int			num_partitions = 0;
 
 	/* check for unsupported flags */
 	Assert(!(eflags & (EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK)));
@@ -2225,20 +2203,8 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 	 */
 	if (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE &&
 		(operation == CMD_INSERT || update_tuple_routing_needed))
-	{
-		proute = mtstate->mt_partition_tuple_routing =
-			ExecSetupPartitionTupleRouting(mtstate,
-										   rel, node->nominalRelation,
-										   estate);
-		num_partitions = proute->num_partitions;
-
-		/*
-		 * Below are required as reference objects for mapping partition
-		 * attno's in expressions such as WithCheckOptions and RETURNING.
-		 */
-		firstVarno = mtstate->resultRelInfo[0].ri_RangeTableIndex;
-		firstResultRel = mtstate->resultRelInfo[0].ri_RelationDesc;
-	}
+		mtstate->mt_partition_tuple_routing =
+						ExecSetupPartitionTupleRouting(mtstate, rel);
 
 	/*
 	 * Build state for collecting transition tuples.  This requires having a
@@ -2285,77 +2251,12 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 	}
 
 	/*
-	 * Build WITH CHECK OPTION constraints for each leaf partition rel. Note
-	 * that we didn't build the withCheckOptionList for each partition within
-	 * the planner, but simple translation of the varattnos for each partition
-	 * will suffice.  This only occurs for the INSERT case or for UPDATE row
-	 * movement. DELETEs and local UPDATEs are handled above.
-	 */
-	if (node->withCheckOptionLists != NIL && num_partitions > 0)
-	{
-		List	   *first_wcoList;
-
-		/*
-		 * In case of INSERT on partitioned tables, there is only one plan.
-		 * Likewise, there is only one WITH CHECK OPTIONS list, not one per
-		 * partition. Whereas for UPDATE, there are as many WCOs as there are
-		 * plans. So in either case, use the WCO expression of the first
-		 * resultRelInfo as a reference to calculate attno's for the WCO
-		 * expression of each of the partitions. We make a copy of the WCO
-		 * qual for each partition. Note that, if there are SubPlans in there,
-		 * they all end up attached to the one parent Plan node.
-		 */
-		Assert(update_tuple_routing_needed ||
-			   (operation == CMD_INSERT &&
-				list_length(node->withCheckOptionLists) == 1 &&
-				mtstate->mt_nplans == 1));
-
-		first_wcoList = linitial(node->withCheckOptionLists);
-		for (i = 0; i < num_partitions; i++)
-		{
-			Relation	partrel;
-			List	   *mapped_wcoList;
-			List	   *wcoExprs = NIL;
-			ListCell   *ll;
-
-			resultRelInfo = proute->partitions[i];
-
-			/*
-			 * If we are referring to a resultRelInfo from one of the update
-			 * result rels, that result rel would already have
-			 * WithCheckOptions initialized.
-			 */
-			if (resultRelInfo->ri_WithCheckOptions)
-				continue;
-
-			partrel = resultRelInfo->ri_RelationDesc;
-
-			mapped_wcoList = map_partition_varattnos(first_wcoList,
-													 firstVarno,
-													 partrel, firstResultRel,
-													 NULL);
-			foreach(ll, mapped_wcoList)
-			{
-				WithCheckOption *wco = castNode(WithCheckOption, lfirst(ll));
-				ExprState  *wcoExpr = ExecInitQual(castNode(List, wco->qual),
-												   &mtstate->ps);
-
-				wcoExprs = lappend(wcoExprs, wcoExpr);
-			}
-
-			resultRelInfo->ri_WithCheckOptions = mapped_wcoList;
-			resultRelInfo->ri_WithCheckOptionExprs = wcoExprs;
-		}
-	}
-
-	/*
 	 * Initialize RETURNING projections if needed.
 	 */
 	if (node->returningLists)
 	{
 		TupleTableSlot *slot;
 		ExprContext *econtext;
-		List	   *firstReturningList;
 
 		/*
 		 * Initialize result tuple slot and assign its rowtype using the first
@@ -2386,44 +2287,6 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 										resultRelInfo->ri_RelationDesc->rd_att);
 			resultRelInfo++;
 		}
-
-		/*
-		 * Build a projection for each leaf partition rel.  Note that we
-		 * didn't build the returningList for each partition within the
-		 * planner, but simple translation of the varattnos for each partition
-		 * will suffice.  This only occurs for the INSERT case or for UPDATE
-		 * row movement. DELETEs and local UPDATEs are handled above.
-		 */
-		firstReturningList = linitial(node->returningLists);
-		for (i = 0; i < num_partitions; i++)
-		{
-			Relation	partrel;
-			List	   *rlist;
-
-			resultRelInfo = proute->partitions[i];
-
-			/*
-			 * If we are referring to a resultRelInfo from one of the update
-			 * result rels, that result rel would already have a returningList
-			 * built.
-			 */
-			if (resultRelInfo->ri_projectReturning)
-				continue;
-
-			partrel = resultRelInfo->ri_RelationDesc;
-
-			/*
-			 * Use the returning expression of the first resultRelInfo as a
-			 * reference to calculate attno's for the returning expression of
-			 * each of the partitions.
-			 */
-			rlist = map_partition_varattnos(firstReturningList,
-											firstVarno,
-											partrel, firstResultRel, NULL);
-			resultRelInfo->ri_projectReturning =
-				ExecBuildProjectionInfo(rlist, econtext, slot, &mtstate->ps,
-										resultRelInfo->ri_RelationDesc->rd_att);
-		}
 	}
 	else
 	{
diff --git a/src/include/executor/execPartition.h b/src/include/executor/execPartition.h
index 7373f60ffb..b1c08f6581 100644
--- a/src/include/executor/execPartition.h
+++ b/src/include/executor/execPartition.h
@@ -91,6 +91,7 @@ typedef struct PartitionTupleRouting
 {
 	PartitionDispatch *partition_dispatch_info;
 	int			num_dispatch;
+	Oid		   *partition_oids;
 	ResultRelInfo **partitions;
 	int			num_partitions;
 	TupleConversionMap **parent_child_tupconv_maps;
@@ -103,11 +104,12 @@ typedef struct PartitionTupleRouting
 } PartitionTupleRouting;
 
 extern PartitionTupleRouting *ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
-							   Relation rel, Index resultRTindex,
-							   EState *estate);
+							   Relation rel);
 extern void ExecSetupChildParentMapForLeaf(PartitionTupleRouting *proute);
-extern TupleConversionMap *TupConvMapForLeaf(PartitionTupleRouting *proute,
-				  ResultRelInfo *rootRelInfo, int leaf_index);
+extern TupleConversionMap *TupConvMapForLeaf(ModifyTableState *mtstate,
+				  int leaf_index);
+extern TupleConversionMap *TupConvMapForSubplan(ModifyTableState *mtstate,
+				  int subplan_index);
 extern HeapTuple ConvertPartitionTupleSlot(TupleConversionMap *map,
 						  HeapTuple tuple,
 						  TupleTableSlot *new_slot,
-- 
2.11.0

From 03ec63385251f31bdf95006258617d10eda94709 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Mon, 5 Feb 2018 13:38:05 +0900
Subject: [PATCH v24 1/2] Refactor partition tuple conversion maps handling
 code

tupconv_map_for_subplan() currently assumes that it gets to use
the Relation pointer for *all* leaf partitions.  That is, both those
that exist in mtstate->resultRelInfo array and those that don't and
hence would be initialized by ExecSetupPartitionTupleRouting().
However, an upcoming patch will change ExecSetupPartitionTupleRouting
such that leaf partitions' ResultRelInfo are no longer initialized
there.  So make it stop relying on the latter.
---
 src/backend/executor/execPartition.c   | 87 ++++++++++++++++++++++++++--------
 src/backend/executor/nodeModifyTable.c | 23 ++-------
 src/include/executor/execPartition.h   |  2 +
 3 files changed, 73 insertions(+), 39 deletions(-)

diff --git a/src/backend/executor/execPartition.c b/src/backend/executor/execPartition.c
index 106a96d910..f2a920f4c3 100644
--- a/src/backend/executor/execPartition.c
+++ b/src/backend/executor/execPartition.c
@@ -373,40 +373,89 @@ ExecSetupChildParentMapForLeaf(PartitionTupleRouting *proute)
 }
 
 /*
- * TupConvMapForLeaf -- Get the tuple conversion map for a given leaf partition
- * index.
+ * ChildParentTupConvMap -- Return tuple conversion map to convert tuples of
+ *							'partrel' into those of 'rootrel'
+ *
+ * If the function was previously called for this partition, we would've
+ * either already created the map and stored the same at
+ * proute->child_parent_tupconv_maps[index] or found out that such a map
+ * is not needed and thus set proute->child_parent_map_not_required[index].
  */
-TupleConversionMap *
-TupConvMapForLeaf(PartitionTupleRouting *proute,
-				  ResultRelInfo *rootRelInfo, int leaf_index)
+static TupleConversionMap *
+ChildParentTupConvMap(Relation partrel, Relation rootrel,
+					  PartitionTupleRouting *proute, int index)
 {
-	ResultRelInfo **resultRelInfos = proute->partitions;
-	TupleConversionMap **map;
-	TupleDesc	tupdesc;
+	TupleConversionMap *map;
 
 	/* Don't call this if we're not supposed to be using this type of map. */
 	Assert(proute->child_parent_tupconv_maps != NULL);
 
 	/* If it's already known that we don't need a map, return NULL. */
-	if (proute->child_parent_map_not_required[leaf_index])
+	if (proute->child_parent_map_not_required[index])
 		return NULL;
 
 	/* If we've already got a map, return it. */
-	map = &proute->child_parent_tupconv_maps[leaf_index];
-	if (*map != NULL)
-		return *map;
+	map = proute->child_parent_tupconv_maps[index];
+	if (map != NULL)
+		return map;
 
 	/* No map yet; try to create one. */
-	tupdesc = RelationGetDescr(resultRelInfos[leaf_index]->ri_RelationDesc);
-	*map =
-		convert_tuples_by_name(tupdesc,
-							   RelationGetDescr(rootRelInfo->ri_RelationDesc),
-							   gettext_noop("could not convert row type"));
+	map = convert_tuples_by_name(RelationGetDescr(partrel),
+								 RelationGetDescr(rootrel),
+								 gettext_noop("could not convert row type"));
 
 	/* If it turns out no map is needed, remember for next time. */
-	proute->child_parent_map_not_required[leaf_index] = (*map == NULL);
+	proute->child_parent_map_not_required[index] = (map == NULL);
+
+	return map;
+}
+
+/*
+ * TupConvMapForLeaf -- Get the tuple conversion map for a given leaf partition
+ * index.
+ *
+ * Call this only if it's known that the partition at leaf_index has been
+ * initialized.
+ */
+TupleConversionMap *
+TupConvMapForLeaf(PartitionTupleRouting *proute,
+				  ResultRelInfo *rootRelInfo, int leaf_index)
+{
+	ResultRelInfo **resultrels = proute->partitions;
+
+	Assert(resultrels[leaf_index] != NULL);
 
-	return *map;
+	return ChildParentTupConvMap(resultrels[leaf_index]->ri_RelationDesc,
+								 rootRelInfo->ri_RelationDesc, proute,
+								 leaf_index);
+}
+
+/*
+ * TupConvMapForSubplan -- Get the tuple conversion map for a partition given
+ * its subplan index.
+ *
+ * Call this if it's unclear whether the partition's ResultRelInfo has been
+ * initialized in mtstate->mt_partition_tuple_routing.
+ */
+TupleConversionMap *
+TupConvMapForSubplan(ModifyTableState *mtstate, int subplan_index)
+{
+	int		leaf_index;
+	PartitionTupleRouting *proute = mtstate->mt_partition_tuple_routing;
+	ResultRelInfo *resultrels = mtstate->resultRelInfo,
+				  *rootRelInfo = (mtstate->rootResultRelInfo != NULL)
+									? mtstate->rootResultRelInfo
+									: mtstate->resultRelInfo;
+
+	Assert(proute != NULL &&
+		   proute->subplan_partition_offsets != NULL &&
+		   subplan_index < proute->num_subplan_partition_offsets);
+	leaf_index = proute->subplan_partition_offsets[subplan_index];
+
+	Assert(subplan_index >= 0 && subplan_index < mtstate->mt_nplans);
+	return ChildParentTupConvMap(resultrels[subplan_index].ri_RelationDesc,
+								 rootRelInfo->ri_RelationDesc,
+								 proute, leaf_index);
 }
 
 /*
diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c
index 2a8ecbd830..d054da5330 100644
--- a/src/backend/executor/nodeModifyTable.c
+++ b/src/backend/executor/nodeModifyTable.c
@@ -1804,27 +1804,10 @@ tupconv_map_for_subplan(ModifyTableState *mtstate, int whichplan)
 	 * array *only* if partition-indexed array is not required.
 	 */
 	if (mtstate->mt_per_subplan_tupconv_maps == NULL)
-	{
-		int			leaf_index;
-		PartitionTupleRouting *proute = mtstate->mt_partition_tuple_routing;
-
-		/*
-		 * If subplan-indexed array is NULL, things should have been arranged
-		 * to convert the subplan index to partition index.
-		 */
-		Assert(proute && proute->subplan_partition_offsets != NULL &&
-			   whichplan < proute->num_subplan_partition_offsets);
+		return TupConvMapForSubplan(mtstate, whichplan);
 
-		leaf_index = proute->subplan_partition_offsets[whichplan];
-
-		return TupConvMapForLeaf(proute, getTargetResultRelInfo(mtstate),
-								 leaf_index);
-	}
-	else
-	{
-		Assert(whichplan >= 0 && whichplan < mtstate->mt_nplans);
-		return mtstate->mt_per_subplan_tupconv_maps[whichplan];
-	}
+	Assert(whichplan >= 0 && whichplan < mtstate->mt_nplans);
+	return mtstate->mt_per_subplan_tupconv_maps[whichplan];
 }
 
 /* ----------------------------------------------------------------
diff --git a/src/include/executor/execPartition.h b/src/include/executor/execPartition.h
index 3df9c498bb..a75a37060a 100644
--- a/src/include/executor/execPartition.h
+++ b/src/include/executor/execPartition.h
@@ -112,6 +112,8 @@ extern int ExecFindPartition(ResultRelInfo *resultRelInfo,
 extern void ExecSetupChildParentMapForLeaf(PartitionTupleRouting *proute);
 extern TupleConversionMap *TupConvMapForLeaf(PartitionTupleRouting *proute,
 				  ResultRelInfo *rootRelInfo, int leaf_index);
+extern TupleConversionMap *TupConvMapForSubplan(ModifyTableState *mtstate,
+				int subplan_index);
 extern HeapTuple ConvertPartitionTupleSlot(TupleConversionMap *map,
 						  HeapTuple tuple,
 						  TupleTableSlot *new_slot,
-- 
2.11.0

From 316c54eb48d9973a2859a31a993d065efa791299 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Tue, 19 Dec 2017 16:20:09 +0900
Subject: [PATCH v24 2/2] During tuple-routing, initialize per-partition
 objects lazily

Those objects include ResultRelInfo, tuple conversion map,
WITH CHECK OPTION quals and RETURNING projections.

This means we don't allocate these objects for partitions that are
never inserted into.
---
 src/backend/commands/copy.c            |   7 +-
 src/backend/executor/execPartition.c   | 409 +++++++++++++++++++++++----------
 src/backend/executor/nodeModifyTable.c | 128 +----------
 src/include/executor/execPartition.h   |   8 +-
 4 files changed, 302 insertions(+), 250 deletions(-)

diff --git a/src/backend/commands/copy.c b/src/backend/commands/copy.c
index b3933df9af..d69d88c8a8 100644
--- a/src/backend/commands/copy.c
+++ b/src/backend/commands/copy.c
@@ -2470,7 +2470,7 @@ CopyFrom(CopyState cstate)
 		PartitionTupleRouting *proute;
 
 		proute = cstate->partition_tuple_routing =
-			ExecSetupPartitionTupleRouting(NULL, cstate->rel, 1, estate);
+			ExecSetupPartitionTupleRouting(NULL, cstate->rel);
 
 		/*
 		 * If we are capturing transition tuples, they may need to be
@@ -2590,6 +2590,10 @@ CopyFrom(CopyState cstate)
 			Assert(leaf_part_index >= 0 &&
 				   leaf_part_index < proute->num_partitions);
 
+			/* Initialize partition info, if not done already. */
+			ExecInitPartitionInfo(NULL, resultRelInfo, proute, estate,
+								  leaf_part_index);
+
 			/*
 			 * If this tuple is mapped to a partition that is not same as the
 			 * previous one, we'd better make the bulk insert mechanism gets a
@@ -2607,6 +2611,7 @@ CopyFrom(CopyState cstate)
 			 */
 			saved_resultRelInfo = resultRelInfo;
 			resultRelInfo = proute->partitions[leaf_part_index];
+			Assert(resultRelInfo != NULL);
 
 			/* We do not yet have a way to insert into a foreign partition */
 			if (resultRelInfo->ri_FdwRoutine)
diff --git a/src/backend/executor/execPartition.c b/src/backend/executor/execPartition.c
index f2a920f4c3..6386dea5fb 100644
--- a/src/backend/executor/execPartition.c
+++ b/src/backend/executor/execPartition.c
@@ -44,22 +44,23 @@ static char *ExecBuildSlotPartitionKeyDescription(Relation rel,
  *
  * Note that all the relations in the partition tree are locked using the
  * RowExclusiveLock mode upon return from this function.
+ *
+ * While we allocate the arrays of pointers of various objects for all
+ * partitions here, the objects themselves are lazily allocated and
+ * initialized for a given partition if a tuple is actually routed to it;
+ * see ExecInitPartitionInfo.
  */
 PartitionTupleRouting *
-ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
-							   Relation rel, Index resultRTindex,
-							   EState *estate)
+ExecSetupPartitionTupleRouting(ModifyTableState *mtstate, Relation rel)
 {
-	TupleDesc	tupDesc = RelationGetDescr(rel);
+	PartitionTupleRouting *proute;
 	List	   *leaf_parts;
 	ListCell   *cell;
-	int			i;
-	ResultRelInfo *leaf_part_arr = NULL,
-			   *update_rri = NULL;
-	int			num_update_rri = 0,
-				update_rri_index = 0;
+	int			leaf_index,
+				update_rri_index,
+				num_update_rri;
 	bool		is_update = false;
-	PartitionTupleRouting *proute;
+	ResultRelInfo *update_rri;
 
 	/*
 	 * Get the information about the partition tree after locking all the
@@ -71,20 +72,24 @@ ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
 		RelationGetPartitionDispatchInfo(rel, &proute->num_dispatch,
 										 &leaf_parts);
 	proute->num_partitions = list_length(leaf_parts);
-	proute->partitions = (ResultRelInfo **) palloc(proute->num_partitions *
-												   sizeof(ResultRelInfo *));
+	/*
+	 * Actual ResultRelInfo's and TupleConversionMap's are allocated in
+	 * ExecInitResultRelInfo().
+	 */
+	proute->partitions = (ResultRelInfo **) palloc0(proute->num_partitions *
+													sizeof(ResultRelInfo *));
 	proute->parent_child_tupconv_maps =
 		(TupleConversionMap **) palloc0(proute->num_partitions *
 										sizeof(TupleConversionMap *));
+	proute->partition_oids = (Oid *) palloc0(proute->num_partitions *
+											 sizeof(Oid));
 
 	/* Set up details specific to the type of tuple routing we are doing. */
 	if (mtstate && mtstate->operation == CMD_UPDATE)
 	{
-		ModifyTable *node = (ModifyTable *) mtstate->ps.plan;
-
 		is_update = true;
 		update_rri = mtstate->resultRelInfo;
-		num_update_rri = list_length(node->plans);
+		num_update_rri = mtstate->mt_nplans;
 		proute->subplan_partition_offsets =
 			palloc(num_update_rri * sizeof(int));
 		proute->num_subplan_partition_offsets = num_update_rri;
@@ -95,15 +100,29 @@ ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
 		 */
 		proute->root_tuple_slot = MakeTupleTableSlot();
 	}
-	else
+
+	leaf_index = update_rri_index = 0;
+	foreach (cell, leaf_parts)
 	{
+		Oid		leaf_oid = lfirst_oid(cell);
+
+		proute->partition_oids[leaf_index] = leaf_oid;
+
 		/*
-		 * Since we are inserting tuples, we need to create all new result
-		 * rels. Avoid repeated pallocs by allocating memory for all the
-		 * result rels in bulk.
+		 * The per-subplan resultrels and the resultrels of the leaf
+		 * partitions are both in the same canonical order.  So while going
+		 * through the leaf partition oids, we need to keep track of the
+		 * next per-subplan result rel to be looked for in the leaf
+		 * partition resultrels.
 		 */
-		leaf_part_arr = (ResultRelInfo *) palloc0(proute->num_partitions *
-												  sizeof(ResultRelInfo));
+		if (is_update && update_rri_index < num_update_rri &&
+			RelationGetRelid(update_rri[update_rri_index].ri_RelationDesc) == leaf_oid)
+		{
+			proute->subplan_partition_offsets[update_rri_index] = leaf_index;
+			update_rri_index++;
+		}
+
+		leaf_index++;
 	}
 
 	/*
@@ -114,109 +133,6 @@ ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
 	 */
 	proute->partition_tuple_slot = MakeTupleTableSlot();
 
-	i = 0;
-	foreach(cell, leaf_parts)
-	{
-		ResultRelInfo *leaf_part_rri;
-		Relation	partrel = NULL;
-		TupleDesc	part_tupdesc;
-		Oid			leaf_oid = lfirst_oid(cell);
-
-		if (is_update)
-		{
-			/*
-			 * If the leaf partition is already present in the per-subplan
-			 * result rels, we re-use that rather than initialize a new result
-			 * rel. The per-subplan resultrels and the resultrels of the leaf
-			 * partitions are both in the same canonical order. So while going
-			 * through the leaf partition oids, we need to keep track of the
-			 * next per-subplan result rel to be looked for in the leaf
-			 * partition resultrels.
-			 */
-			if (update_rri_index < num_update_rri &&
-				RelationGetRelid(update_rri[update_rri_index].ri_RelationDesc) == leaf_oid)
-			{
-				leaf_part_rri = &update_rri[update_rri_index];
-				partrel = leaf_part_rri->ri_RelationDesc;
-
-				/*
-				 * This is required in order to we convert the partition's
-				 * tuple to be compatible with the root partitioned table's
-				 * tuple descriptor.  When generating the per-subplan result
-				 * rels, this was not set.
-				 */
-				leaf_part_rri->ri_PartitionRoot = rel;
-
-				/* Remember the subplan offset for this ResultRelInfo */
-				proute->subplan_partition_offsets[update_rri_index] = i;
-
-				update_rri_index++;
-			}
-			else
-				leaf_part_rri = (ResultRelInfo *) palloc0(sizeof(ResultRelInfo));
-		}
-		else
-		{
-			/* For INSERTs, we already have an array of result rels allocated */
-			leaf_part_rri = &leaf_part_arr[i];
-		}
-
-		/*
-		 * If we didn't open the partition rel, it means we haven't
-		 * initialized the result rel either.
-		 */
-		if (!partrel)
-		{
-			/*
-			 * We locked all the partitions above including the leaf
-			 * partitions. Note that each of the newly opened relations in
-			 * proute->partitions are eventually closed by the caller.
-			 */
-			partrel = heap_open(leaf_oid, NoLock);
-			InitResultRelInfo(leaf_part_rri,
-							  partrel,
-							  resultRTindex,
-							  rel,
-							  estate->es_instrument);
-		}
-
-		part_tupdesc = RelationGetDescr(partrel);
-
-		/*
-		 * Save a tuple conversion map to convert a tuple routed to this
-		 * partition from the parent's type to the partition's.
-		 */
-		proute->parent_child_tupconv_maps[i] =
-			convert_tuples_by_name(tupDesc, part_tupdesc,
-								   gettext_noop("could not convert row type"));
-
-		/*
-		 * Verify result relation is a valid target for an INSERT.  An UPDATE
-		 * of a partition-key becomes a DELETE+INSERT operation, so this check
-		 * is still required when the operation is CMD_UPDATE.
-		 */
-		CheckValidResultRel(leaf_part_rri, CMD_INSERT);
-
-		/*
-		 * Open partition indices.  The user may have asked to check for
-		 * conflicts within this leaf partition and do "nothing" instead of
-		 * throwing an error.  Be prepared in that case by initializing the
-		 * index information needed by ExecInsert() to perform speculative
-		 * insertions.
-		 */
-		if (leaf_part_rri->ri_RelationDesc->rd_rel->relhasindex &&
-			leaf_part_rri->ri_IndexRelationDescs == NULL)
-			ExecOpenIndices(leaf_part_rri,
-							mtstate != NULL &&
-							mtstate->mt_onconflict != ONCONFLICT_NONE);
-
-		estate->es_leaf_result_relations =
-			lappend(estate->es_leaf_result_relations, leaf_part_rri);
-
-		proute->partitions[i] = leaf_part_rri;
-		i++;
-	}
-
 	/*
 	 * For UPDATE, we should have found all the per-subplan resultrels in the
 	 * leaf partitions.
@@ -345,6 +261,244 @@ ExecFindPartition(ResultRelInfo *resultRelInfo, PartitionDispatch *pd,
 	return result;
 }
 
+static int
+leafpart_index_cmp(const void *arg1, const void *arg2)
+{
+	int		leafidx1 = *(const int *) arg1;
+	int		leafidx2 = *(const int *) arg2;
+
+	if (leafidx1 > leafidx2)
+		return 1;
+	else if (leafidx1 < leafidx2)
+		return -1;
+	return 0;
+}
+
+/*
+ * ExecInitPartitionInfo
+ *		Initialize ResultRelInfo and other information for a partition if not
+ *		already done
+ */
+void
+ExecInitPartitionInfo(ModifyTableState *mtstate,
+					  ResultRelInfo *resultRelInfo,
+					  PartitionTupleRouting *proute,
+					  EState *estate, int partidx)
+{
+	Relation	partrel,
+				rootrel;
+	ResultRelInfo *leaf_part_rri;
+
+	/* Nothing to do if already set. */
+	if (proute->partitions[partidx])
+		return;
+
+	leaf_part_rri = NULL;
+	rootrel = resultRelInfo->ri_RelationDesc;
+
+	/*
+	 * If we are doing tuple routing for update, try to reuse the
+	 * per-subplan resultrel for this partition that ExecInitModifyTable()
+	 * might already have created.
+	 */
+	if (mtstate && mtstate->operation == CMD_UPDATE)
+	{
+		int   *partidx_entry;
+
+		/*
+		 * If the partition's ResultRelInfo has already been created, we'd
+		 * find its index in proute->subplan_partition_offsets.
+		 */
+		partidx_entry = (int *) bsearch(&partidx,
+										proute->subplan_partition_offsets,
+										mtstate->mt_nplans, sizeof(int),
+										leafpart_index_cmp);
+		if (partidx_entry)
+		{
+			int		update_rri_index =
+							partidx_entry - proute->subplan_partition_offsets;
+
+			Assert (update_rri_index < mtstate->mt_nplans);
+			leaf_part_rri = &mtstate->resultRelInfo[update_rri_index];
+			partrel = leaf_part_rri->ri_RelationDesc;
+
+			/*
+			 * This is required in order to we convert the partition's
+			 * tuple to be compatible with the root partitioned table's
+			 * tuple descriptor.  When generating the per-subplan result
+			 * rels, this was not set.
+			 */
+			leaf_part_rri->ri_PartitionRoot = rootrel;
+		}
+	}
+
+	/*
+	 * Create new result rel, either if we are *inserting* the new tuple, or
+	 * if we didn't find the result rel above for the update tuple routing
+	 * case.
+	 */
+	if (leaf_part_rri == NULL)
+	{
+		int			firstVarno;
+		Relation	firstResultRel;
+		ModifyTable *node = NULL;
+
+		if (mtstate)
+		{
+			node = (ModifyTable *) mtstate->ps.plan;
+			firstVarno = mtstate->resultRelInfo[0].ri_RangeTableIndex;
+			firstResultRel = mtstate->resultRelInfo[0].ri_RelationDesc;
+		}
+
+		leaf_part_rri = (ResultRelInfo *) palloc0(sizeof(ResultRelInfo));
+
+		/*
+		 * We locked all the partitions in ExecSetupPartitionTupleRouting
+		 * including the leaf partitions.
+		 */
+		partrel = heap_open(proute->partition_oids[partidx], NoLock);
+		InitResultRelInfo(leaf_part_rri,
+						  partrel,
+						  node ? node->nominalRelation : 1,
+						  rootrel,
+						  estate->es_instrument);
+
+		/*
+		 * Build WITH CHECK OPTION constraints for this partition rel.  Note
+		 * that we didn't build the withCheckOptionList for each partition
+		 * within the planner, but simple translation of the varattnos will
+		 * suffice.  This only occurs for the INSERT case or in the case of
+		 * UPDATE for which we didn't find a result rel above to reuse.
+		 */
+		if (node && node->withCheckOptionLists != NIL)
+		{
+			List	   *wcoList;
+			List	   *mapped_wcoList;
+			List	   *wcoExprs = NIL;
+			ListCell   *ll;
+
+			/*
+			 * In the case of INSERT on partitioned tables, there is only one
+			 * plan.  Likewise, there is only one WCO list, not one per
+			 * partition.  For UPDATE, there would be as many WCO lists as
+			 * there are plans, but we use the first one as reference.  Note
+			 * that if there are SubPlans in there, they all end up attached
+			 * to the one parent Plan node.
+			 */
+			Assert((node->operation == CMD_INSERT &&
+					list_length(node->withCheckOptionLists) == 1 &&
+					list_length(node->plans) == 1) ||
+				   (node->operation == CMD_UPDATE &&
+					list_length(node->withCheckOptionLists) ==
+					list_length(node->plans)));
+			wcoList = linitial(node->withCheckOptionLists);
+
+			mapped_wcoList = map_partition_varattnos(wcoList,
+													 firstVarno,
+													 partrel, firstResultRel,
+													 NULL);
+			foreach(ll, mapped_wcoList)
+			{
+				WithCheckOption *wco = castNode(WithCheckOption, lfirst(ll));
+				ExprState  *wcoExpr = ExecInitQual(castNode(List, wco->qual),
+												   mtstate->mt_plans[0]);
+				wcoExprs = lappend(wcoExprs, wcoExpr);
+			}
+
+			leaf_part_rri->ri_WithCheckOptions = mapped_wcoList;
+			leaf_part_rri->ri_WithCheckOptionExprs = wcoExprs;
+		}
+
+		/*
+		 * Build the RETURNING projection if any for the partition.  Note that
+		 * we didn't build the returningList for each partition within the
+		 * planner, but simple translation of the varattnos will suffice.
+		 * This only occurs for the INSERT case; in the UPDATE/DELETE cases,
+		 * ExecInitModifyTable() would've initialized this.
+		 */
+		if (node && node->returningLists != NIL)
+		{
+			TupleTableSlot *slot;
+			ExprContext *econtext;
+			List	   *returningList;
+			List	   *rlist;
+			TupleDesc	tupDesc;
+
+			/* See the comment written above for WCO lists. */
+			Assert((node->operation == CMD_INSERT &&
+					list_length(node->returningLists) == 1 &&
+					list_length(node->plans) == 1) ||
+				   (node->operation == CMD_UPDATE &&
+					list_length(node->returningLists) ==
+					list_length(node->plans)));
+			returningList = linitial(node->returningLists);
+
+			/*
+			 * Initialize result tuple slot and assign its rowtype using the first
+			 * RETURNING list.  We assume the rest will look the same.
+			 */
+			tupDesc = ExecTypeFromTL(returningList, false);
+
+			/* Set up a slot for the output of the RETURNING projection(s) */
+			ExecInitResultTupleSlot(estate, &mtstate->ps);
+			ExecAssignResultType(&mtstate->ps, tupDesc);
+			slot = mtstate->ps.ps_ResultTupleSlot;
+
+			/* Need an econtext too */
+			if (mtstate->ps.ps_ExprContext == NULL)
+				ExecAssignExprContext(estate, &mtstate->ps);
+			econtext = mtstate->ps.ps_ExprContext;
+
+			rlist = map_partition_varattnos(returningList,
+											firstVarno,
+											partrel, firstResultRel, NULL);
+			leaf_part_rri->ri_projectReturning =
+				ExecBuildProjectionInfo(rlist, econtext, slot, &mtstate->ps,
+										RelationGetDescr(partrel));
+		}
+
+		/*
+		 * Open partition indices.  The user may have asked to check for
+		 * conflicts within this leaf partition and do "nothing" instead of
+		 * throwing an error.  Be prepared in that case by initializing the
+		 * index information needed by ExecInsert() to perform speculative
+		 * insertions.
+		 */
+		if (partrel->rd_rel->relhasindex &&
+			leaf_part_rri->ri_IndexRelationDescs == NULL)
+			ExecOpenIndices(leaf_part_rri,
+							mtstate != NULL &&
+							mtstate->mt_onconflict != ONCONFLICT_NONE);
+	}
+
+	/*
+	 * Verify result relation is a valid target for an INSERT.  An UPDATE
+	 * of a partition-key becomes a DELETE+INSERT operation, so this check
+	 * is still required when the operation is CMD_UPDATE.
+	 */
+	CheckValidResultRel(leaf_part_rri, CMD_INSERT);
+
+	proute->partitions[partidx] = leaf_part_rri;
+
+	/*
+	 * Note that the entries in this list appear in no predetermined order,
+	 * because partition result rels are initialized as and when they're
+	 * needed.
+	 */
+	estate->es_leaf_result_relations =
+								lappend(estate->es_leaf_result_relations,
+										leaf_part_rri);
+
+	/*
+	 * Save a tuple conversion map to convert a tuple routed to this
+	 * partition from the parent's type to the partition's.
+	 */
+	proute->parent_child_tupconv_maps[partidx] =
+							convert_tuples_by_name(RelationGetDescr(rootrel),
+												   RelationGetDescr(partrel),
+											   gettext_noop("could not convert row type"));
+}
+
 /*
  * ExecSetupChildParentMapForLeaf -- Initialize the per-leaf-partition
  * child-to-root tuple conversion map array.
@@ -538,8 +692,11 @@ ExecCleanupTupleRouting(PartitionTupleRouting *proute)
 			continue;
 		}
 
-		ExecCloseIndices(resultRelInfo);
-		heap_close(resultRelInfo->ri_RelationDesc, NoLock);
+		if (resultRelInfo)
+		{
+			ExecCloseIndices(resultRelInfo);
+			heap_close(resultRelInfo->ri_RelationDesc, NoLock);
+		}
 	}
 
 	/* Release the standalone partition tuple descriptors, if any */
diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c
index d054da5330..15ca3281c9 100644
--- a/src/backend/executor/nodeModifyTable.c
+++ b/src/backend/executor/nodeModifyTable.c
@@ -304,12 +304,17 @@ ExecInsert(ModifyTableState *mtstate,
 		Assert(leaf_part_index >= 0 &&
 			   leaf_part_index < proute->num_partitions);
 
+		/* Initialize partition info, if not done already. */
+		ExecInitPartitionInfo(mtstate, resultRelInfo, proute, estate,
+							  leaf_part_index);
+
 		/*
 		 * Save the old ResultRelInfo and switch to the one corresponding to
 		 * the selected partition.
 		 */
 		saved_resultRelInfo = resultRelInfo;
 		resultRelInfo = proute->partitions[leaf_part_index];
+		Assert(resultRelInfo != NULL);
 
 		/* We do not yet have a way to insert into a foreign partition */
 		if (resultRelInfo->ri_FdwRoutine)
@@ -2081,14 +2086,10 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 	ResultRelInfo *saved_resultRelInfo;
 	ResultRelInfo *resultRelInfo;
 	Plan	   *subplan;
-	int			firstVarno = 0;
-	Relation	firstResultRel = NULL;
 	ListCell   *l;
 	int			i;
 	Relation	rel;
 	bool		update_tuple_routing_needed = node->partColsUpdated;
-	PartitionTupleRouting *proute = NULL;
-	int			num_partitions = 0;
 
 	/* check for unsupported flags */
 	Assert(!(eflags & (EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK)));
@@ -2211,20 +2212,8 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 	 */
 	if (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE &&
 		(operation == CMD_INSERT || update_tuple_routing_needed))
-	{
-		proute = mtstate->mt_partition_tuple_routing =
-			ExecSetupPartitionTupleRouting(mtstate,
-										   rel, node->nominalRelation,
-										   estate);
-		num_partitions = proute->num_partitions;
-
-		/*
-		 * Below are required as reference objects for mapping partition
-		 * attno's in expressions such as WithCheckOptions and RETURNING.
-		 */
-		firstVarno = mtstate->resultRelInfo[0].ri_RangeTableIndex;
-		firstResultRel = mtstate->resultRelInfo[0].ri_RelationDesc;
-	}
+		mtstate->mt_partition_tuple_routing =
+						ExecSetupPartitionTupleRouting(mtstate, rel);
 
 	/*
 	 * Build state for collecting transition tuples.  This requires having a
@@ -2271,77 +2260,12 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 	}
 
 	/*
-	 * Build WITH CHECK OPTION constraints for each leaf partition rel. Note
-	 * that we didn't build the withCheckOptionList for each partition within
-	 * the planner, but simple translation of the varattnos for each partition
-	 * will suffice.  This only occurs for the INSERT case or for UPDATE row
-	 * movement. DELETEs and local UPDATEs are handled above.
-	 */
-	if (node->withCheckOptionLists != NIL && num_partitions > 0)
-	{
-		List	   *first_wcoList;
-
-		/*
-		 * In case of INSERT on partitioned tables, there is only one plan.
-		 * Likewise, there is only one WITH CHECK OPTIONS list, not one per
-		 * partition. Whereas for UPDATE, there are as many WCOs as there are
-		 * plans. So in either case, use the WCO expression of the first
-		 * resultRelInfo as a reference to calculate attno's for the WCO
-		 * expression of each of the partitions. We make a copy of the WCO
-		 * qual for each partition. Note that, if there are SubPlans in there,
-		 * they all end up attached to the one parent Plan node.
-		 */
-		Assert(update_tuple_routing_needed ||
-			   (operation == CMD_INSERT &&
-				list_length(node->withCheckOptionLists) == 1 &&
-				mtstate->mt_nplans == 1));
-
-		first_wcoList = linitial(node->withCheckOptionLists);
-		for (i = 0; i < num_partitions; i++)
-		{
-			Relation	partrel;
-			List	   *mapped_wcoList;
-			List	   *wcoExprs = NIL;
-			ListCell   *ll;
-
-			resultRelInfo = proute->partitions[i];
-
-			/*
-			 * If we are referring to a resultRelInfo from one of the update
-			 * result rels, that result rel would already have
-			 * WithCheckOptions initialized.
-			 */
-			if (resultRelInfo->ri_WithCheckOptions)
-				continue;
-
-			partrel = resultRelInfo->ri_RelationDesc;
-
-			mapped_wcoList = map_partition_varattnos(first_wcoList,
-													 firstVarno,
-													 partrel, firstResultRel,
-													 NULL);
-			foreach(ll, mapped_wcoList)
-			{
-				WithCheckOption *wco = castNode(WithCheckOption, lfirst(ll));
-				ExprState  *wcoExpr = ExecInitQual(castNode(List, wco->qual),
-												   &mtstate->ps);
-
-				wcoExprs = lappend(wcoExprs, wcoExpr);
-			}
-
-			resultRelInfo->ri_WithCheckOptions = mapped_wcoList;
-			resultRelInfo->ri_WithCheckOptionExprs = wcoExprs;
-		}
-	}
-
-	/*
 	 * Initialize RETURNING projections if needed.
 	 */
 	if (node->returningLists)
 	{
 		TupleTableSlot *slot;
 		ExprContext *econtext;
-		List	   *firstReturningList;
 
 		/*
 		 * Initialize result tuple slot and assign its rowtype using the first
@@ -2372,44 +2296,6 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 										resultRelInfo->ri_RelationDesc->rd_att);
 			resultRelInfo++;
 		}
-
-		/*
-		 * Build a projection for each leaf partition rel.  Note that we
-		 * didn't build the returningList for each partition within the
-		 * planner, but simple translation of the varattnos for each partition
-		 * will suffice.  This only occurs for the INSERT case or for UPDATE
-		 * row movement. DELETEs and local UPDATEs are handled above.
-		 */
-		firstReturningList = linitial(node->returningLists);
-		for (i = 0; i < num_partitions; i++)
-		{
-			Relation	partrel;
-			List	   *rlist;
-
-			resultRelInfo = proute->partitions[i];
-
-			/*
-			 * If we are referring to a resultRelInfo from one of the update
-			 * result rels, that result rel would already have a returningList
-			 * built.
-			 */
-			if (resultRelInfo->ri_projectReturning)
-				continue;
-
-			partrel = resultRelInfo->ri_RelationDesc;
-
-			/*
-			 * Use the returning expression of the first resultRelInfo as a
-			 * reference to calculate attno's for the returning expression of
-			 * each of the partitions.
-			 */
-			rlist = map_partition_varattnos(firstReturningList,
-											firstVarno,
-											partrel, firstResultRel, NULL);
-			resultRelInfo->ri_projectReturning =
-				ExecBuildProjectionInfo(rlist, econtext, slot, &mtstate->ps,
-										resultRelInfo->ri_RelationDesc->rd_att);
-		}
 	}
 	else
 	{
diff --git a/src/include/executor/execPartition.h b/src/include/executor/execPartition.h
index a75a37060a..4a62b9f1ff 100644
--- a/src/include/executor/execPartition.h
+++ b/src/include/executor/execPartition.h
@@ -91,6 +91,7 @@ typedef struct PartitionTupleRouting
 {
 	PartitionDispatch *partition_dispatch_info;
 	int			num_dispatch;
+	Oid		   *partition_oids;
 	ResultRelInfo **partitions;
 	int			num_partitions;
 	TupleConversionMap **parent_child_tupconv_maps;
@@ -103,12 +104,15 @@ typedef struct PartitionTupleRouting
 } PartitionTupleRouting;
 
 extern PartitionTupleRouting *ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
-							   Relation rel, Index resultRTindex,
-							   EState *estate);
+							   Relation rel);
 extern int ExecFindPartition(ResultRelInfo *resultRelInfo,
 				  PartitionDispatch *pd,
 				  TupleTableSlot *slot,
 				  EState *estate);
+extern void ExecInitPartitionInfo(ModifyTableState *mtstate,
+					ResultRelInfo *resultRelInfo,
+					PartitionTupleRouting *proute,
+					EState *estate, int partidx);
 extern void ExecSetupChildParentMapForLeaf(PartitionTupleRouting *proute);
 extern TupleConversionMap *TupConvMapForLeaf(PartitionTupleRouting *proute,
 				  ResultRelInfo *rootRelInfo, int leaf_index);
-- 
2.11.0

From 8e1e08ce34e52c22c40cc03aeae23e38f1b8e3f1 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Tue, 19 Dec 2017 16:20:09 +0900
Subject: [PATCH v6] During tuple-routing, initialize per-partition objects
 lazily

Those objects include ResultRelInfo, tuple conversion map,
WITH CHECK OPTION quals and RETURNING projections.

This means we don't allocate these objects for partitions that are
never inserted into.
---
 src/backend/commands/copy.c            |  10 +-
 src/backend/executor/execPartition.c   | 303 ++++++++++++++++++++++++---------
 src/backend/executor/nodeModifyTable.c | 131 ++------------
 src/include/executor/execPartition.h   |   9 +-
 4 files changed, 248 insertions(+), 205 deletions(-)

diff --git a/src/backend/commands/copy.c b/src/backend/commands/copy.c
index b3933df9af..118452b602 100644
--- a/src/backend/commands/copy.c
+++ b/src/backend/commands/copy.c
@@ -2470,7 +2470,7 @@ CopyFrom(CopyState cstate)
 		PartitionTupleRouting *proute;
 
 		proute = cstate->partition_tuple_routing =
-			ExecSetupPartitionTupleRouting(NULL, cstate->rel, 1, estate);
+			ExecSetupPartitionTupleRouting(NULL, cstate->rel);
 
 		/*
 		 * If we are capturing transition tuples, they may need to be
@@ -2607,6 +2607,14 @@ CopyFrom(CopyState cstate)
 			 */
 			saved_resultRelInfo = resultRelInfo;
 			resultRelInfo = proute->partitions[leaf_part_index];
+			if (resultRelInfo == NULL)
+			{
+				resultRelInfo = ExecInitPartitionInfo(NULL,
+													  saved_resultRelInfo,
+													  proute, estate,
+													  leaf_part_index);
+				Assert(resultRelInfo != NULL);
+			}
 
 			/* We do not yet have a way to insert into a foreign partition */
 			if (resultRelInfo->ri_FdwRoutine)
diff --git a/src/backend/executor/execPartition.c b/src/backend/executor/execPartition.c
index 4048c3ebc6..1c16a2b5aa 100644
--- a/src/backend/executor/execPartition.c
+++ b/src/backend/executor/execPartition.c
@@ -44,18 +44,23 @@ static char *ExecBuildSlotPartitionKeyDescription(Relation rel,
  *
  * Note that all the relations in the partition tree are locked using the
  * RowExclusiveLock mode upon return from this function.
+ *
+ * While we allocate the arrays of pointers of ResultRelInfo and
+ * TupleConversionMap for all partitions here, actual objects themselves are
+ * lazily allocated for a given partition if a tuple is actually routed to it;
+ * see ExecInitPartitionInfo.  However, if the function is invoked for update
+ * tuple routing, caller would already have initialized ResultRelInfo's for
+ * some of the partitions, which are reused and assigned to their respective
+ * slot in the aforementioned array.
  */
 PartitionTupleRouting *
-ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
-							   Relation rel, Index resultRTindex,
-							   EState *estate)
+ExecSetupPartitionTupleRouting(ModifyTableState *mtstate, Relation rel)
 {
 	TupleDesc	tupDesc = RelationGetDescr(rel);
 	List	   *leaf_parts;
 	ListCell   *cell;
 	int			i;
-	ResultRelInfo *leaf_part_arr = NULL,
-			   *update_rri = NULL;
+	ResultRelInfo *update_rri = NULL;
 	int			num_update_rri = 0,
 				update_rri_index = 0;
 	bool		is_update = false;
@@ -76,6 +81,8 @@ ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
 	proute->parent_child_tupconv_maps =
 		(TupleConversionMap **) palloc0(proute->num_partitions *
 										sizeof(TupleConversionMap *));
+	proute->partition_oids = (Oid *) palloc(proute->num_partitions *
+											sizeof(Oid));
 
 	/* Set up details specific to the type of tuple routing we are doing. */
 	if (mtstate && mtstate->operation == CMD_UPDATE)
@@ -95,16 +102,6 @@ ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
 		 */
 		proute->root_tuple_slot = MakeTupleTableSlot();
 	}
-	else
-	{
-		/*
-		 * Since we are inserting tuples, we need to create all new result
-		 * rels. Avoid repeated pallocs by allocating memory for all the
-		 * result rels in bulk.
-		 */
-		leaf_part_arr = (ResultRelInfo *) palloc0(proute->num_partitions *
-												  sizeof(ResultRelInfo));
-	}
 
 	/*
 	 * Initialize an empty slot that will be used to manipulate tuples of any
@@ -117,11 +114,12 @@ ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
 	i = 0;
 	foreach(cell, leaf_parts)
 	{
-		ResultRelInfo *leaf_part_rri;
+		ResultRelInfo *leaf_part_rri = NULL;
 		Relation	partrel = NULL;
 		TupleDesc	part_tupdesc;
 		Oid			leaf_oid = lfirst_oid(cell);
 
+		proute->partition_oids[i] = leaf_oid;
 		if (is_update)
 		{
 			/*
@@ -151,73 +149,34 @@ ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
 				proute->subplan_partition_offsets[update_rri_index] = i;
 
 				update_rri_index++;
-			}
-			else
-				leaf_part_rri = (ResultRelInfo *) palloc0(sizeof(ResultRelInfo));
-		}
-		else
-		{
-			/* For INSERTs, we already have an array of result rels allocated */
-			leaf_part_rri = &leaf_part_arr[i];
-		}
-
-		/*
-		 * If we didn't open the partition rel, it means we haven't
-		 * initialized the result rel either.
-		 */
-		if (!partrel)
-		{
-			/*
-			 * We locked all the partitions above including the leaf
-			 * partitions. Note that each of the newly opened relations in
-			 * proute->partitions are eventually closed by the caller.
-			 */
-			partrel = heap_open(leaf_oid, NoLock);
-			InitResultRelInfo(leaf_part_rri,
-							  partrel,
-							  resultRTindex,
-							  rel,
-							  estate->es_instrument);
-
-			/*
-			 * Since we've just initialized this ResultRelInfo, it's not in
-			 * any list attached to the estate as yet.  Add it, so that it can
-			 * be found later.
-			 */
-			estate->es_tuple_routing_result_relations =
-						lappend(estate->es_tuple_routing_result_relations,
-								leaf_part_rri);
-		}
 
-		part_tupdesc = RelationGetDescr(partrel);
+				part_tupdesc = RelationGetDescr(partrel);
 
-		/*
-		 * Save a tuple conversion map to convert a tuple routed to this
-		 * partition from the parent's type to the partition's.
-		 */
-		proute->parent_child_tupconv_maps[i] =
-			convert_tuples_by_name(tupDesc, part_tupdesc,
-								   gettext_noop("could not convert row type"));
+				/*
+				 * Save a tuple conversion map to convert a tuple routed to
+				 * this partition from the parent's type to the partition's.
+				 */
+				proute->parent_child_tupconv_maps[i] =
+					convert_tuples_by_name(tupDesc, part_tupdesc,
+							   gettext_noop("could not convert row type"));
 
-		/*
-		 * Verify result relation is a valid target for an INSERT.  An UPDATE
-		 * of a partition-key becomes a DELETE+INSERT operation, so this check
-		 * is still required when the operation is CMD_UPDATE.
-		 */
-		CheckValidResultRel(leaf_part_rri, CMD_INSERT);
+				/*
+				 * Verify result relation is a valid target for an INSERT.  An
+				 * UPDATE of a partition-key becomes a DELETE+INSERT operation,
+				 * so this check is required even when the operation is
+				 * CMD_UPDATE.
+				 */
+				CheckValidResultRel(leaf_part_rri, CMD_INSERT);
 
-		/*
-		 * Open partition indices.  The user may have asked to check for
-		 * conflicts within this leaf partition and do "nothing" instead of
-		 * throwing an error.  Be prepared in that case by initializing the
-		 * index information needed by ExecInsert() to perform speculative
-		 * insertions.
-		 */
-		if (leaf_part_rri->ri_RelationDesc->rd_rel->relhasindex &&
-			leaf_part_rri->ri_IndexRelationDescs == NULL)
-			ExecOpenIndices(leaf_part_rri,
-							mtstate != NULL &&
-							mtstate->mt_onconflict != ONCONFLICT_NONE);
+				/*
+				 * Open partition indices.  We wouldn't need speculative
+				 * insertions though.
+				 */
+				if (leaf_part_rri->ri_RelationDesc->rd_rel->relhasindex &&
+					leaf_part_rri->ri_IndexRelationDescs == NULL)
+					ExecOpenIndices(leaf_part_rri, false);
+			}
+		}
 
 		proute->partitions[i] = leaf_part_rri;
 		i++;
@@ -352,6 +311,185 @@ ExecFindPartition(ResultRelInfo *resultRelInfo, PartitionDispatch *pd,
 }
 
 /*
+ * ExecInitPartitionInfo
+ *		Initialize ResultRelInfo and other information for a partition if not
+ *		already done
+ *
+ * Returns the ResultRelInfo
+ */
+ResultRelInfo *
+ExecInitPartitionInfo(ModifyTableState *mtstate,
+					  ResultRelInfo *resultRelInfo,
+					  PartitionTupleRouting *proute,
+					  EState *estate, int partidx)
+{
+	Relation	rootrel = resultRelInfo->ri_RelationDesc,
+				partrel;
+	ResultRelInfo *leaf_part_rri;
+	int			firstVarno;
+	Relation	firstResultRel;
+	ModifyTable *node = NULL;
+
+	if (mtstate)
+	{
+		node = (ModifyTable *) mtstate->ps.plan;
+		firstVarno = mtstate->resultRelInfo[0].ri_RangeTableIndex;
+		firstResultRel = mtstate->resultRelInfo[0].ri_RelationDesc;
+	}
+
+	/*
+	 * We locked all the partitions in ExecSetupPartitionTupleRouting
+	 * including the leaf partitions.
+	 */
+	partrel = heap_open(proute->partition_oids[partidx], NoLock);
+	leaf_part_rri = (ResultRelInfo *) palloc0(sizeof(ResultRelInfo));
+	InitResultRelInfo(leaf_part_rri,
+					  partrel,
+					  node ? node->nominalRelation : 1,
+					  rootrel,
+					  estate->es_instrument);
+
+	/*
+	 * Verify result relation is a valid target for an INSERT.  An UPDATE
+	 * of a partition-key becomes a DELETE+INSERT operation, so this check
+	 * is still required when the operation is CMD_UPDATE.
+	 */
+	CheckValidResultRel(leaf_part_rri, CMD_INSERT);
+
+	/*
+	 * Since we've just initialized this ResultRelInfo, it's not in
+	 * any list attached to the estate as yet.  Add it, so that it can
+	 * be found later.
+	 *
+	 * Note that the entries in this list appear in no predetermined
+	 * order, because partition result rels are initialized as and when
+	 * they're needed.
+	 */
+	estate->es_tuple_routing_result_relations =
+					lappend(estate->es_tuple_routing_result_relations,
+							leaf_part_rri);
+
+	/*
+	 * Open partition indices.  The user may have asked to check for
+	 * conflicts within this leaf partition and do "nothing" instead of
+	 * throwing an error.  Be prepared in that case by initializing the
+	 * index information needed by ExecInsert() to perform speculative
+	 * insertions.
+	 */
+	if (partrel->rd_rel->relhasindex &&
+		leaf_part_rri->ri_IndexRelationDescs == NULL)
+		ExecOpenIndices(leaf_part_rri,
+						(mtstate != NULL &&
+						 mtstate->mt_onconflict != ONCONFLICT_NONE));
+
+	/*
+	 * Build WITH CHECK OPTION constraints for this partition rel.  Note
+	 * that we didn't build the withCheckOptionList for each partition
+	 * within the planner, but simple translation of the varattnos will
+	 * suffice.  This only occurs for the INSERT case or in the case of
+	 * UPDATE for which we didn't find a result rel above to reuse.
+	 */
+	if (node && node->withCheckOptionLists != NIL)
+	{
+		List	   *wcoList;
+		List	   *mapped_wcoList;
+		List	   *wcoExprs = NIL;
+		ListCell   *ll;
+
+		/*
+		 * In the case of INSERT on partitioned tables, there is only one
+		 * plan.  Likewise, there is only one WCO list, not one per
+		 * partition.  For UPDATE, there would be as many WCO lists as
+		 * there are plans, but we use the first one as reference.  Note
+		 * that if there are SubPlans in there, they all end up attached
+		 * to the one parent Plan node.
+		 */
+		Assert((node->operation == CMD_INSERT &&
+				list_length(node->withCheckOptionLists) == 1 &&
+				list_length(node->plans) == 1) ||
+			   (node->operation == CMD_UPDATE &&
+				list_length(node->withCheckOptionLists) ==
+				list_length(node->plans)));
+		wcoList = linitial(node->withCheckOptionLists);
+
+		mapped_wcoList = map_partition_varattnos(wcoList, firstVarno,
+												 partrel, firstResultRel,
+												 NULL);
+		foreach(ll, mapped_wcoList)
+		{
+			WithCheckOption *wco = castNode(WithCheckOption, lfirst(ll));
+			ExprState  *wcoExpr = ExecInitQual(castNode(List, wco->qual),
+											   mtstate->mt_plans[0]);
+			wcoExprs = lappend(wcoExprs, wcoExpr);
+		}
+
+		leaf_part_rri->ri_WithCheckOptions = mapped_wcoList;
+		leaf_part_rri->ri_WithCheckOptionExprs = wcoExprs;
+	}
+
+	/*
+	 * Build the RETURNING projection if any for the partition.  Note that
+	 * we didn't build the returningList for each partition within the
+	 * planner, but simple translation of the varattnos will suffice.
+	 * This only occurs for the INSERT case; in the UPDATE/DELETE cases,
+	 * ExecInitModifyTable() would've initialized this.
+	 */
+	if (node && node->returningLists != NIL)
+	{
+		TupleTableSlot *slot;
+		ExprContext *econtext;
+		List	   *returningList;
+		List	   *rlist;
+		TupleDesc	tupDesc;
+
+		/* See the comment written above for WCO lists. */
+		Assert((node->operation == CMD_INSERT &&
+				list_length(node->returningLists) == 1 &&
+				list_length(node->plans) == 1) ||
+			   (node->operation == CMD_UPDATE &&
+				list_length(node->returningLists) ==
+				list_length(node->plans)));
+		returningList = linitial(node->returningLists);
+
+		/*
+		 * Initialize result tuple slot and assign its rowtype using the first
+		 * RETURNING list.  We assume the rest will look the same.
+		 */
+		tupDesc = ExecTypeFromTL(returningList, false);
+
+		/* Set up a slot for the output of the RETURNING projection(s) */
+		ExecInitResultTupleSlot(estate, &mtstate->ps);
+		ExecAssignResultType(&mtstate->ps, tupDesc);
+		slot = mtstate->ps.ps_ResultTupleSlot;
+
+		/* Need an econtext too */
+		if (mtstate->ps.ps_ExprContext == NULL)
+			ExecAssignExprContext(estate, &mtstate->ps);
+		econtext = mtstate->ps.ps_ExprContext;
+
+		rlist = map_partition_varattnos(returningList, firstVarno,
+										partrel, firstResultRel, NULL);
+		leaf_part_rri->ri_projectReturning =
+			ExecBuildProjectionInfo(rlist, econtext, slot, &mtstate->ps,
+									RelationGetDescr(partrel));
+	}
+
+	Assert (proute->partitions[partidx] == NULL);
+	proute->partitions[partidx] = leaf_part_rri;
+
+	/*
+	 * Save a tuple conversion map to convert a tuple routed to this
+	 * partition from the parent's type to the partition's.
+	 */
+	proute->parent_child_tupconv_maps[partidx] =
+							convert_tuples_by_name(RelationGetDescr(rootrel),
+												   RelationGetDescr(partrel),
+											   gettext_noop("could not convert row type"));
+
+	return leaf_part_rri;
+}
+
+/*
  * ExecSetupChildParentMapForLeaf -- Initialize the per-leaf-partition
  * child-to-root tuple conversion map array.
  *
@@ -495,8 +633,11 @@ ExecCleanupTupleRouting(PartitionTupleRouting *proute)
 			continue;
 		}
 
-		ExecCloseIndices(resultRelInfo);
-		heap_close(resultRelInfo->ri_RelationDesc, NoLock);
+		if (resultRelInfo)
+		{
+			ExecCloseIndices(resultRelInfo);
+			heap_close(resultRelInfo->ri_RelationDesc, NoLock);
+		}
 	}
 
 	/* Release the standalone partition tuple descriptors, if any */
diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c
index 2a8ecbd830..36e2041755 100644
--- a/src/backend/executor/nodeModifyTable.c
+++ b/src/backend/executor/nodeModifyTable.c
@@ -310,6 +310,14 @@ ExecInsert(ModifyTableState *mtstate,
 		 */
 		saved_resultRelInfo = resultRelInfo;
 		resultRelInfo = proute->partitions[leaf_part_index];
+		if (resultRelInfo == NULL)
+		{
+			resultRelInfo = ExecInitPartitionInfo(mtstate,
+												  saved_resultRelInfo,
+												  proute, estate,
+												  leaf_part_index);
+			Assert(resultRelInfo != NULL);
+		}
 
 		/* We do not yet have a way to insert into a foreign partition */
 		if (resultRelInfo->ri_FdwRoutine)
@@ -2098,14 +2106,10 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 	ResultRelInfo *saved_resultRelInfo;
 	ResultRelInfo *resultRelInfo;
 	Plan	   *subplan;
-	int			firstVarno = 0;
-	Relation	firstResultRel = NULL;
 	ListCell   *l;
 	int			i;
 	Relation	rel;
 	bool		update_tuple_routing_needed = node->partColsUpdated;
-	PartitionTupleRouting *proute = NULL;
-	int			num_partitions = 0;
 
 	/* check for unsupported flags */
 	Assert(!(eflags & (EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK)));
@@ -2228,20 +2232,8 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 	 */
 	if (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE &&
 		(operation == CMD_INSERT || update_tuple_routing_needed))
-	{
-		proute = mtstate->mt_partition_tuple_routing =
-			ExecSetupPartitionTupleRouting(mtstate,
-										   rel, node->nominalRelation,
-										   estate);
-		num_partitions = proute->num_partitions;
-
-		/*
-		 * Below are required as reference objects for mapping partition
-		 * attno's in expressions such as WithCheckOptions and RETURNING.
-		 */
-		firstVarno = mtstate->resultRelInfo[0].ri_RangeTableIndex;
-		firstResultRel = mtstate->resultRelInfo[0].ri_RelationDesc;
-	}
+		mtstate->mt_partition_tuple_routing =
+						ExecSetupPartitionTupleRouting(mtstate, rel);
 
 	/*
 	 * Build state for collecting transition tuples.  This requires having a
@@ -2288,77 +2280,12 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 	}
 
 	/*
-	 * Build WITH CHECK OPTION constraints for each leaf partition rel. Note
-	 * that we didn't build the withCheckOptionList for each partition within
-	 * the planner, but simple translation of the varattnos for each partition
-	 * will suffice.  This only occurs for the INSERT case or for UPDATE row
-	 * movement. DELETEs and local UPDATEs are handled above.
-	 */
-	if (node->withCheckOptionLists != NIL && num_partitions > 0)
-	{
-		List	   *first_wcoList;
-
-		/*
-		 * In case of INSERT on partitioned tables, there is only one plan.
-		 * Likewise, there is only one WITH CHECK OPTIONS list, not one per
-		 * partition. Whereas for UPDATE, there are as many WCOs as there are
-		 * plans. So in either case, use the WCO expression of the first
-		 * resultRelInfo as a reference to calculate attno's for the WCO
-		 * expression of each of the partitions. We make a copy of the WCO
-		 * qual for each partition. Note that, if there are SubPlans in there,
-		 * they all end up attached to the one parent Plan node.
-		 */
-		Assert(update_tuple_routing_needed ||
-			   (operation == CMD_INSERT &&
-				list_length(node->withCheckOptionLists) == 1 &&
-				mtstate->mt_nplans == 1));
-
-		first_wcoList = linitial(node->withCheckOptionLists);
-		for (i = 0; i < num_partitions; i++)
-		{
-			Relation	partrel;
-			List	   *mapped_wcoList;
-			List	   *wcoExprs = NIL;
-			ListCell   *ll;
-
-			resultRelInfo = proute->partitions[i];
-
-			/*
-			 * If we are referring to a resultRelInfo from one of the update
-			 * result rels, that result rel would already have
-			 * WithCheckOptions initialized.
-			 */
-			if (resultRelInfo->ri_WithCheckOptions)
-				continue;
-
-			partrel = resultRelInfo->ri_RelationDesc;
-
-			mapped_wcoList = map_partition_varattnos(first_wcoList,
-													 firstVarno,
-													 partrel, firstResultRel,
-													 NULL);
-			foreach(ll, mapped_wcoList)
-			{
-				WithCheckOption *wco = castNode(WithCheckOption, lfirst(ll));
-				ExprState  *wcoExpr = ExecInitQual(castNode(List, wco->qual),
-												   &mtstate->ps);
-
-				wcoExprs = lappend(wcoExprs, wcoExpr);
-			}
-
-			resultRelInfo->ri_WithCheckOptions = mapped_wcoList;
-			resultRelInfo->ri_WithCheckOptionExprs = wcoExprs;
-		}
-	}
-
-	/*
 	 * Initialize RETURNING projections if needed.
 	 */
 	if (node->returningLists)
 	{
 		TupleTableSlot *slot;
 		ExprContext *econtext;
-		List	   *firstReturningList;
 
 		/*
 		 * Initialize result tuple slot and assign its rowtype using the first
@@ -2389,44 +2316,6 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 										resultRelInfo->ri_RelationDesc->rd_att);
 			resultRelInfo++;
 		}
-
-		/*
-		 * Build a projection for each leaf partition rel.  Note that we
-		 * didn't build the returningList for each partition within the
-		 * planner, but simple translation of the varattnos for each partition
-		 * will suffice.  This only occurs for the INSERT case or for UPDATE
-		 * row movement. DELETEs and local UPDATEs are handled above.
-		 */
-		firstReturningList = linitial(node->returningLists);
-		for (i = 0; i < num_partitions; i++)
-		{
-			Relation	partrel;
-			List	   *rlist;
-
-			resultRelInfo = proute->partitions[i];
-
-			/*
-			 * If we are referring to a resultRelInfo from one of the update
-			 * result rels, that result rel would already have a returningList
-			 * built.
-			 */
-			if (resultRelInfo->ri_projectReturning)
-				continue;
-
-			partrel = resultRelInfo->ri_RelationDesc;
-
-			/*
-			 * Use the returning expression of the first resultRelInfo as a
-			 * reference to calculate attno's for the returning expression of
-			 * each of the partitions.
-			 */
-			rlist = map_partition_varattnos(firstReturningList,
-											firstVarno,
-											partrel, firstResultRel, NULL);
-			resultRelInfo->ri_projectReturning =
-				ExecBuildProjectionInfo(rlist, econtext, slot, &mtstate->ps,
-										resultRelInfo->ri_RelationDesc->rd_att);
-		}
 	}
 	else
 	{
diff --git a/src/include/executor/execPartition.h b/src/include/executor/execPartition.h
index 3df9c498bb..e94718608f 100644
--- a/src/include/executor/execPartition.h
+++ b/src/include/executor/execPartition.h
@@ -58,6 +58,7 @@ typedef struct PartitionDispatchData *PartitionDispatch;
  *								partition tree.
  * num_dispatch					number of partitioned tables in the partition
  *								tree (= length of partition_dispatch_info[])
+ * partition_oids				Array of leaf partitions OIDs
  * partitions					Array of ResultRelInfo* objects with one entry
  *								for every leaf partition in the partition tree.
  * num_partitions				Number of leaf partitions in the partition tree
@@ -91,6 +92,7 @@ typedef struct PartitionTupleRouting
 {
 	PartitionDispatch *partition_dispatch_info;
 	int			num_dispatch;
+	Oid		   *partition_oids;
 	ResultRelInfo **partitions;
 	int			num_partitions;
 	TupleConversionMap **parent_child_tupconv_maps;
@@ -103,12 +105,15 @@ typedef struct PartitionTupleRouting
 } PartitionTupleRouting;
 
 extern PartitionTupleRouting *ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
-							   Relation rel, Index resultRTindex,
-							   EState *estate);
+							   Relation rel);
 extern int ExecFindPartition(ResultRelInfo *resultRelInfo,
 				  PartitionDispatch *pd,
 				  TupleTableSlot *slot,
 				  EState *estate);
+extern ResultRelInfo *ExecInitPartitionInfo(ModifyTableState *mtstate,
+					ResultRelInfo *resultRelInfo,
+					PartitionTupleRouting *proute,
+					EState *estate, int partidx);
 extern void ExecSetupChildParentMapForLeaf(PartitionTupleRouting *proute);
 extern TupleConversionMap *TupConvMapForLeaf(PartitionTupleRouting *proute,
 				  ResultRelInfo *rootRelInfo, int leaf_index);
-- 
2.11.0

From 93a0fdedf326a930a7113489250ab2ddd1f478e3 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Tue, 19 Dec 2017 16:20:09 +0900
Subject: [PATCH v7] During tuple-routing, initialize per-partition objects
 lazily

Those objects include ResultRelInfo, tuple conversion map,
WITH CHECK OPTION quals and RETURNING projections.

This means we don't allocate these objects for partitions that are
never inserted into.
---
 src/backend/commands/copy.c            |  10 +-
 src/backend/executor/execPartition.c   | 302 ++++++++++++++++++++++++---------
 src/backend/executor/nodeModifyTable.c | 131 ++------------
 src/include/executor/execPartition.h   |   9 +-
 4 files changed, 244 insertions(+), 208 deletions(-)

diff --git a/src/backend/commands/copy.c b/src/backend/commands/copy.c
index b3933df9af..118452b602 100644
--- a/src/backend/commands/copy.c
+++ b/src/backend/commands/copy.c
@@ -2470,7 +2470,7 @@ CopyFrom(CopyState cstate)
 		PartitionTupleRouting *proute;
 
 		proute = cstate->partition_tuple_routing =
-			ExecSetupPartitionTupleRouting(NULL, cstate->rel, 1, estate);
+			ExecSetupPartitionTupleRouting(NULL, cstate->rel);
 
 		/*
 		 * If we are capturing transition tuples, they may need to be
@@ -2607,6 +2607,14 @@ CopyFrom(CopyState cstate)
 			 */
 			saved_resultRelInfo = resultRelInfo;
 			resultRelInfo = proute->partitions[leaf_part_index];
+			if (resultRelInfo == NULL)
+			{
+				resultRelInfo = ExecInitPartitionInfo(NULL,
+													  saved_resultRelInfo,
+													  proute, estate,
+													  leaf_part_index);
+				Assert(resultRelInfo != NULL);
+			}
 
 			/* We do not yet have a way to insert into a foreign partition */
 			if (resultRelInfo->ri_FdwRoutine)
diff --git a/src/backend/executor/execPartition.c b/src/backend/executor/execPartition.c
index 4048c3ebc6..9e3910a4a6 100644
--- a/src/backend/executor/execPartition.c
+++ b/src/backend/executor/execPartition.c
@@ -44,18 +44,23 @@ static char *ExecBuildSlotPartitionKeyDescription(Relation rel,
  *
  * Note that all the relations in the partition tree are locked using the
  * RowExclusiveLock mode upon return from this function.
+ *
+ * While we allocate the arrays of pointers of ResultRelInfo and
+ * TupleConversionMap for all partitions here, actual objects themselves are
+ * lazily allocated for a given partition if a tuple is actually routed to it;
+ * see ExecInitPartitionInfo.  However, if the function is invoked for update
+ * tuple routing, caller would already have initialized ResultRelInfo's for
+ * some of the partitions, which are reused and assigned to their respective
+ * slot in the aforementioned array.
  */
 PartitionTupleRouting *
-ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
-							   Relation rel, Index resultRTindex,
-							   EState *estate)
+ExecSetupPartitionTupleRouting(ModifyTableState *mtstate, Relation rel)
 {
 	TupleDesc	tupDesc = RelationGetDescr(rel);
 	List	   *leaf_parts;
 	ListCell   *cell;
 	int			i;
-	ResultRelInfo *leaf_part_arr = NULL,
-			   *update_rri = NULL;
+	ResultRelInfo *update_rri = NULL;
 	int			num_update_rri = 0,
 				update_rri_index = 0;
 	bool		is_update = false;
@@ -76,6 +81,8 @@ ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
 	proute->parent_child_tupconv_maps =
 		(TupleConversionMap **) palloc0(proute->num_partitions *
 										sizeof(TupleConversionMap *));
+	proute->partition_oids = (Oid *) palloc(proute->num_partitions *
+											sizeof(Oid));
 
 	/* Set up details specific to the type of tuple routing we are doing. */
 	if (mtstate && mtstate->operation == CMD_UPDATE)
@@ -95,16 +102,6 @@ ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
 		 */
 		proute->root_tuple_slot = MakeTupleTableSlot();
 	}
-	else
-	{
-		/*
-		 * Since we are inserting tuples, we need to create all new result
-		 * rels. Avoid repeated pallocs by allocating memory for all the
-		 * result rels in bulk.
-		 */
-		leaf_part_arr = (ResultRelInfo *) palloc0(proute->num_partitions *
-												  sizeof(ResultRelInfo));
-	}
 
 	/*
 	 * Initialize an empty slot that will be used to manipulate tuples of any
@@ -117,11 +114,10 @@ ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
 	i = 0;
 	foreach(cell, leaf_parts)
 	{
-		ResultRelInfo *leaf_part_rri;
-		Relation	partrel = NULL;
-		TupleDesc	part_tupdesc;
+		ResultRelInfo *leaf_part_rri = NULL;
 		Oid			leaf_oid = lfirst_oid(cell);
 
+		proute->partition_oids[i] = leaf_oid;
 		if (is_update)
 		{
 			/*
@@ -136,6 +132,9 @@ ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
 			if (update_rri_index < num_update_rri &&
 				RelationGetRelid(update_rri[update_rri_index].ri_RelationDesc) == leaf_oid)
 			{
+				Relation	partrel = NULL;
+				TupleDesc	part_tupdesc;
+
 				leaf_part_rri = &update_rri[update_rri_index];
 				partrel = leaf_part_rri->ri_RelationDesc;
 
@@ -151,73 +150,26 @@ ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
 				proute->subplan_partition_offsets[update_rri_index] = i;
 
 				update_rri_index++;
-			}
-			else
-				leaf_part_rri = (ResultRelInfo *) palloc0(sizeof(ResultRelInfo));
-		}
-		else
-		{
-			/* For INSERTs, we already have an array of result rels allocated */
-			leaf_part_rri = &leaf_part_arr[i];
-		}
-
-		/*
-		 * If we didn't open the partition rel, it means we haven't
-		 * initialized the result rel either.
-		 */
-		if (!partrel)
-		{
-			/*
-			 * We locked all the partitions above including the leaf
-			 * partitions. Note that each of the newly opened relations in
-			 * proute->partitions are eventually closed by the caller.
-			 */
-			partrel = heap_open(leaf_oid, NoLock);
-			InitResultRelInfo(leaf_part_rri,
-							  partrel,
-							  resultRTindex,
-							  rel,
-							  estate->es_instrument);
-
-			/*
-			 * Since we've just initialized this ResultRelInfo, it's not in
-			 * any list attached to the estate as yet.  Add it, so that it can
-			 * be found later.
-			 */
-			estate->es_tuple_routing_result_relations =
-						lappend(estate->es_tuple_routing_result_relations,
-								leaf_part_rri);
-		}
-
-		part_tupdesc = RelationGetDescr(partrel);
 
-		/*
-		 * Save a tuple conversion map to convert a tuple routed to this
-		 * partition from the parent's type to the partition's.
-		 */
-		proute->parent_child_tupconv_maps[i] =
-			convert_tuples_by_name(tupDesc, part_tupdesc,
-								   gettext_noop("could not convert row type"));
+				part_tupdesc = RelationGetDescr(partrel);
 
-		/*
-		 * Verify result relation is a valid target for an INSERT.  An UPDATE
-		 * of a partition-key becomes a DELETE+INSERT operation, so this check
-		 * is still required when the operation is CMD_UPDATE.
-		 */
-		CheckValidResultRel(leaf_part_rri, CMD_INSERT);
+				/*
+				 * Save a tuple conversion map to convert a tuple routed to
+				 * this partition from the parent's type to the partition's.
+				 */
+				proute->parent_child_tupconv_maps[i] =
+					convert_tuples_by_name(tupDesc, part_tupdesc,
+							   gettext_noop("could not convert row type"));
 
-		/*
-		 * Open partition indices.  The user may have asked to check for
-		 * conflicts within this leaf partition and do "nothing" instead of
-		 * throwing an error.  Be prepared in that case by initializing the
-		 * index information needed by ExecInsert() to perform speculative
-		 * insertions.
-		 */
-		if (leaf_part_rri->ri_RelationDesc->rd_rel->relhasindex &&
-			leaf_part_rri->ri_IndexRelationDescs == NULL)
-			ExecOpenIndices(leaf_part_rri,
-							mtstate != NULL &&
-							mtstate->mt_onconflict != ONCONFLICT_NONE);
+				/*
+				 * Verify result relation is a valid target for an INSERT.  An
+				 * UPDATE of a partition-key becomes a DELETE+INSERT operation,
+				 * so this check is required even when the operation is
+				 * CMD_UPDATE.
+				 */
+				CheckValidResultRel(leaf_part_rri, CMD_INSERT);
+			}
+		}
 
 		proute->partitions[i] = leaf_part_rri;
 		i++;
@@ -352,6 +304,185 @@ ExecFindPartition(ResultRelInfo *resultRelInfo, PartitionDispatch *pd,
 }
 
 /*
+ * ExecInitPartitionInfo
+ *		Initialize ResultRelInfo and other information for a partition if not
+ *		already done
+ *
+ * Returns the ResultRelInfo
+ */
+ResultRelInfo *
+ExecInitPartitionInfo(ModifyTableState *mtstate,
+					  ResultRelInfo *resultRelInfo,
+					  PartitionTupleRouting *proute,
+					  EState *estate, int partidx)
+{
+	Relation	rootrel = resultRelInfo->ri_RelationDesc,
+				partrel;
+	ResultRelInfo *leaf_part_rri;
+	int			firstVarno;
+	Relation	firstResultRel;
+	ModifyTable *node = NULL;
+
+	if (mtstate)
+	{
+		node = (ModifyTable *) mtstate->ps.plan;
+		firstVarno = mtstate->resultRelInfo[0].ri_RangeTableIndex;
+		firstResultRel = mtstate->resultRelInfo[0].ri_RelationDesc;
+	}
+
+	/*
+	 * We locked all the partitions in ExecSetupPartitionTupleRouting
+	 * including the leaf partitions.
+	 */
+	partrel = heap_open(proute->partition_oids[partidx], NoLock);
+	leaf_part_rri = (ResultRelInfo *) palloc0(sizeof(ResultRelInfo));
+	InitResultRelInfo(leaf_part_rri,
+					  partrel,
+					  node ? node->nominalRelation : 1,
+					  rootrel,
+					  estate->es_instrument);
+
+	/*
+	 * Verify result relation is a valid target for an INSERT.  An UPDATE
+	 * of a partition-key becomes a DELETE+INSERT operation, so this check
+	 * is still required when the operation is CMD_UPDATE.
+	 */
+	CheckValidResultRel(leaf_part_rri, CMD_INSERT);
+
+	/*
+	 * Since we've just initialized this ResultRelInfo, it's not in
+	 * any list attached to the estate as yet.  Add it, so that it can
+	 * be found later.
+	 *
+	 * Note that the entries in this list appear in no predetermined
+	 * order, because partition result rels are initialized as and when
+	 * they're needed.
+	 */
+	estate->es_tuple_routing_result_relations =
+					lappend(estate->es_tuple_routing_result_relations,
+							leaf_part_rri);
+
+	/*
+	 * Open partition indices.  The user may have asked to check for
+	 * conflicts within this leaf partition and do "nothing" instead of
+	 * throwing an error.  Be prepared in that case by initializing the
+	 * index information needed by ExecInsert() to perform speculative
+	 * insertions.
+	 */
+	if (partrel->rd_rel->relhasindex &&
+		leaf_part_rri->ri_IndexRelationDescs == NULL)
+		ExecOpenIndices(leaf_part_rri,
+						(mtstate != NULL &&
+						 mtstate->mt_onconflict != ONCONFLICT_NONE));
+
+	/*
+	 * Build WITH CHECK OPTION constraints for this partition rel.  Note
+	 * that we didn't build the withCheckOptionList for each partition
+	 * within the planner, but simple translation of the varattnos will
+	 * suffice.  This only occurs for the INSERT case or in the case of
+	 * UPDATE for which we didn't find a result rel above to reuse.
+	 */
+	if (node && node->withCheckOptionLists != NIL)
+	{
+		List	   *wcoList;
+		List	   *mapped_wcoList;
+		List	   *wcoExprs = NIL;
+		ListCell   *ll;
+
+		/*
+		 * In the case of INSERT on partitioned tables, there is only one
+		 * plan.  Likewise, there is only one WCO list, not one per
+		 * partition.  For UPDATE, there would be as many WCO lists as
+		 * there are plans, but we use the first one as reference.  Note
+		 * that if there are SubPlans in there, they all end up attached
+		 * to the one parent Plan node.
+		 */
+		Assert((node->operation == CMD_INSERT &&
+				list_length(node->withCheckOptionLists) == 1 &&
+				list_length(node->plans) == 1) ||
+			   (node->operation == CMD_UPDATE &&
+				list_length(node->withCheckOptionLists) ==
+				list_length(node->plans)));
+		wcoList = linitial(node->withCheckOptionLists);
+
+		mapped_wcoList = map_partition_varattnos(wcoList, firstVarno,
+												 partrel, firstResultRel,
+												 NULL);
+		foreach(ll, mapped_wcoList)
+		{
+			WithCheckOption *wco = castNode(WithCheckOption, lfirst(ll));
+			ExprState  *wcoExpr = ExecInitQual(castNode(List, wco->qual),
+											   mtstate->mt_plans[0]);
+			wcoExprs = lappend(wcoExprs, wcoExpr);
+		}
+
+		leaf_part_rri->ri_WithCheckOptions = mapped_wcoList;
+		leaf_part_rri->ri_WithCheckOptionExprs = wcoExprs;
+	}
+
+	/*
+	 * Build the RETURNING projection if any for the partition.  Note that
+	 * we didn't build the returningList for each partition within the
+	 * planner, but simple translation of the varattnos will suffice.
+	 * This only occurs for the INSERT case; in the UPDATE/DELETE cases,
+	 * ExecInitModifyTable() would've initialized this.
+	 */
+	if (node && node->returningLists != NIL)
+	{
+		TupleTableSlot *slot;
+		ExprContext *econtext;
+		List	   *returningList;
+		List	   *rlist;
+		TupleDesc	tupDesc;
+
+		/* See the comment written above for WCO lists. */
+		Assert((node->operation == CMD_INSERT &&
+				list_length(node->returningLists) == 1 &&
+				list_length(node->plans) == 1) ||
+			   (node->operation == CMD_UPDATE &&
+				list_length(node->returningLists) ==
+				list_length(node->plans)));
+		returningList = linitial(node->returningLists);
+
+		/*
+		 * Initialize result tuple slot and assign its rowtype using the first
+		 * RETURNING list.  We assume the rest will look the same.
+		 */
+		tupDesc = ExecTypeFromTL(returningList, false);
+
+		/* Set up a slot for the output of the RETURNING projection(s) */
+		ExecInitResultTupleSlot(estate, &mtstate->ps);
+		ExecAssignResultType(&mtstate->ps, tupDesc);
+		slot = mtstate->ps.ps_ResultTupleSlot;
+
+		/* Need an econtext too */
+		if (mtstate->ps.ps_ExprContext == NULL)
+			ExecAssignExprContext(estate, &mtstate->ps);
+		econtext = mtstate->ps.ps_ExprContext;
+
+		rlist = map_partition_varattnos(returningList, firstVarno,
+										partrel, firstResultRel, NULL);
+		leaf_part_rri->ri_projectReturning =
+			ExecBuildProjectionInfo(rlist, econtext, slot, &mtstate->ps,
+									RelationGetDescr(partrel));
+	}
+
+	Assert (proute->partitions[partidx] == NULL);
+	proute->partitions[partidx] = leaf_part_rri;
+
+	/*
+	 * Save a tuple conversion map to convert a tuple routed to this
+	 * partition from the parent's type to the partition's.
+	 */
+	proute->parent_child_tupconv_maps[partidx] =
+							convert_tuples_by_name(RelationGetDescr(rootrel),
+												   RelationGetDescr(partrel),
+											   gettext_noop("could not convert row type"));
+
+	return leaf_part_rri;
+}
+
+/*
  * ExecSetupChildParentMapForLeaf -- Initialize the per-leaf-partition
  * child-to-root tuple conversion map array.
  *
@@ -495,8 +626,11 @@ ExecCleanupTupleRouting(PartitionTupleRouting *proute)
 			continue;
 		}
 
-		ExecCloseIndices(resultRelInfo);
-		heap_close(resultRelInfo->ri_RelationDesc, NoLock);
+		if (resultRelInfo)
+		{
+			ExecCloseIndices(resultRelInfo);
+			heap_close(resultRelInfo->ri_RelationDesc, NoLock);
+		}
 	}
 
 	/* Release the standalone partition tuple descriptors, if any */
diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c
index 2a8ecbd830..36e2041755 100644
--- a/src/backend/executor/nodeModifyTable.c
+++ b/src/backend/executor/nodeModifyTable.c
@@ -310,6 +310,14 @@ ExecInsert(ModifyTableState *mtstate,
 		 */
 		saved_resultRelInfo = resultRelInfo;
 		resultRelInfo = proute->partitions[leaf_part_index];
+		if (resultRelInfo == NULL)
+		{
+			resultRelInfo = ExecInitPartitionInfo(mtstate,
+												  saved_resultRelInfo,
+												  proute, estate,
+												  leaf_part_index);
+			Assert(resultRelInfo != NULL);
+		}
 
 		/* We do not yet have a way to insert into a foreign partition */
 		if (resultRelInfo->ri_FdwRoutine)
@@ -2098,14 +2106,10 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 	ResultRelInfo *saved_resultRelInfo;
 	ResultRelInfo *resultRelInfo;
 	Plan	   *subplan;
-	int			firstVarno = 0;
-	Relation	firstResultRel = NULL;
 	ListCell   *l;
 	int			i;
 	Relation	rel;
 	bool		update_tuple_routing_needed = node->partColsUpdated;
-	PartitionTupleRouting *proute = NULL;
-	int			num_partitions = 0;
 
 	/* check for unsupported flags */
 	Assert(!(eflags & (EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK)));
@@ -2228,20 +2232,8 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 	 */
 	if (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE &&
 		(operation == CMD_INSERT || update_tuple_routing_needed))
-	{
-		proute = mtstate->mt_partition_tuple_routing =
-			ExecSetupPartitionTupleRouting(mtstate,
-										   rel, node->nominalRelation,
-										   estate);
-		num_partitions = proute->num_partitions;
-
-		/*
-		 * Below are required as reference objects for mapping partition
-		 * attno's in expressions such as WithCheckOptions and RETURNING.
-		 */
-		firstVarno = mtstate->resultRelInfo[0].ri_RangeTableIndex;
-		firstResultRel = mtstate->resultRelInfo[0].ri_RelationDesc;
-	}
+		mtstate->mt_partition_tuple_routing =
+						ExecSetupPartitionTupleRouting(mtstate, rel);
 
 	/*
 	 * Build state for collecting transition tuples.  This requires having a
@@ -2288,77 +2280,12 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 	}
 
 	/*
-	 * Build WITH CHECK OPTION constraints for each leaf partition rel. Note
-	 * that we didn't build the withCheckOptionList for each partition within
-	 * the planner, but simple translation of the varattnos for each partition
-	 * will suffice.  This only occurs for the INSERT case or for UPDATE row
-	 * movement. DELETEs and local UPDATEs are handled above.
-	 */
-	if (node->withCheckOptionLists != NIL && num_partitions > 0)
-	{
-		List	   *first_wcoList;
-
-		/*
-		 * In case of INSERT on partitioned tables, there is only one plan.
-		 * Likewise, there is only one WITH CHECK OPTIONS list, not one per
-		 * partition. Whereas for UPDATE, there are as many WCOs as there are
-		 * plans. So in either case, use the WCO expression of the first
-		 * resultRelInfo as a reference to calculate attno's for the WCO
-		 * expression of each of the partitions. We make a copy of the WCO
-		 * qual for each partition. Note that, if there are SubPlans in there,
-		 * they all end up attached to the one parent Plan node.
-		 */
-		Assert(update_tuple_routing_needed ||
-			   (operation == CMD_INSERT &&
-				list_length(node->withCheckOptionLists) == 1 &&
-				mtstate->mt_nplans == 1));
-
-		first_wcoList = linitial(node->withCheckOptionLists);
-		for (i = 0; i < num_partitions; i++)
-		{
-			Relation	partrel;
-			List	   *mapped_wcoList;
-			List	   *wcoExprs = NIL;
-			ListCell   *ll;
-
-			resultRelInfo = proute->partitions[i];
-
-			/*
-			 * If we are referring to a resultRelInfo from one of the update
-			 * result rels, that result rel would already have
-			 * WithCheckOptions initialized.
-			 */
-			if (resultRelInfo->ri_WithCheckOptions)
-				continue;
-
-			partrel = resultRelInfo->ri_RelationDesc;
-
-			mapped_wcoList = map_partition_varattnos(first_wcoList,
-													 firstVarno,
-													 partrel, firstResultRel,
-													 NULL);
-			foreach(ll, mapped_wcoList)
-			{
-				WithCheckOption *wco = castNode(WithCheckOption, lfirst(ll));
-				ExprState  *wcoExpr = ExecInitQual(castNode(List, wco->qual),
-												   &mtstate->ps);
-
-				wcoExprs = lappend(wcoExprs, wcoExpr);
-			}
-
-			resultRelInfo->ri_WithCheckOptions = mapped_wcoList;
-			resultRelInfo->ri_WithCheckOptionExprs = wcoExprs;
-		}
-	}
-
-	/*
 	 * Initialize RETURNING projections if needed.
 	 */
 	if (node->returningLists)
 	{
 		TupleTableSlot *slot;
 		ExprContext *econtext;
-		List	   *firstReturningList;
 
 		/*
 		 * Initialize result tuple slot and assign its rowtype using the first
@@ -2389,44 +2316,6 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 										resultRelInfo->ri_RelationDesc->rd_att);
 			resultRelInfo++;
 		}
-
-		/*
-		 * Build a projection for each leaf partition rel.  Note that we
-		 * didn't build the returningList for each partition within the
-		 * planner, but simple translation of the varattnos for each partition
-		 * will suffice.  This only occurs for the INSERT case or for UPDATE
-		 * row movement. DELETEs and local UPDATEs are handled above.
-		 */
-		firstReturningList = linitial(node->returningLists);
-		for (i = 0; i < num_partitions; i++)
-		{
-			Relation	partrel;
-			List	   *rlist;
-
-			resultRelInfo = proute->partitions[i];
-
-			/*
-			 * If we are referring to a resultRelInfo from one of the update
-			 * result rels, that result rel would already have a returningList
-			 * built.
-			 */
-			if (resultRelInfo->ri_projectReturning)
-				continue;
-
-			partrel = resultRelInfo->ri_RelationDesc;
-
-			/*
-			 * Use the returning expression of the first resultRelInfo as a
-			 * reference to calculate attno's for the returning expression of
-			 * each of the partitions.
-			 */
-			rlist = map_partition_varattnos(firstReturningList,
-											firstVarno,
-											partrel, firstResultRel, NULL);
-			resultRelInfo->ri_projectReturning =
-				ExecBuildProjectionInfo(rlist, econtext, slot, &mtstate->ps,
-										resultRelInfo->ri_RelationDesc->rd_att);
-		}
 	}
 	else
 	{
diff --git a/src/include/executor/execPartition.h b/src/include/executor/execPartition.h
index 3df9c498bb..e94718608f 100644
--- a/src/include/executor/execPartition.h
+++ b/src/include/executor/execPartition.h
@@ -58,6 +58,7 @@ typedef struct PartitionDispatchData *PartitionDispatch;
  *								partition tree.
  * num_dispatch					number of partitioned tables in the partition
  *								tree (= length of partition_dispatch_info[])
+ * partition_oids				Array of leaf partitions OIDs
  * partitions					Array of ResultRelInfo* objects with one entry
  *								for every leaf partition in the partition tree.
  * num_partitions				Number of leaf partitions in the partition tree
@@ -91,6 +92,7 @@ typedef struct PartitionTupleRouting
 {
 	PartitionDispatch *partition_dispatch_info;
 	int			num_dispatch;
+	Oid		   *partition_oids;
 	ResultRelInfo **partitions;
 	int			num_partitions;
 	TupleConversionMap **parent_child_tupconv_maps;
@@ -103,12 +105,15 @@ typedef struct PartitionTupleRouting
 } PartitionTupleRouting;
 
 extern PartitionTupleRouting *ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
-							   Relation rel, Index resultRTindex,
-							   EState *estate);
+							   Relation rel);
 extern int ExecFindPartition(ResultRelInfo *resultRelInfo,
 				  PartitionDispatch *pd,
 				  TupleTableSlot *slot,
 				  EState *estate);
+extern ResultRelInfo *ExecInitPartitionInfo(ModifyTableState *mtstate,
+					ResultRelInfo *resultRelInfo,
+					PartitionTupleRouting *proute,
+					EState *estate, int partidx);
 extern void ExecSetupChildParentMapForLeaf(PartitionTupleRouting *proute);
 extern TupleConversionMap *TupConvMapForLeaf(PartitionTupleRouting *proute,
 				  ResultRelInfo *rootRelInfo, int leaf_index);
-- 
2.11.0

From d4266a3072640b64f758e3de1f896fffbd9332ae Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Tue, 19 Dec 2017 16:20:09 +0900
Subject: [PATCH v8] During tuple-routing, initialize per-partition objects
 lazily

Those objects include ResultRelInfo, tuple conversion map,
WITH CHECK OPTION quals and RETURNING projections.

This means we don't allocate these objects for partitions that are
never inserted into.
---
 src/backend/commands/copy.c            |  10 +-
 src/backend/executor/execPartition.c   | 294 +++++++++++++++++++++++----------
 src/backend/executor/nodeModifyTable.c | 131 ++-------------
 src/include/executor/execPartition.h   |   9 +-
 4 files changed, 237 insertions(+), 207 deletions(-)

diff --git a/src/backend/commands/copy.c b/src/backend/commands/copy.c
index b3933df9af..118452b602 100644
--- a/src/backend/commands/copy.c
+++ b/src/backend/commands/copy.c
@@ -2470,7 +2470,7 @@ CopyFrom(CopyState cstate)
 		PartitionTupleRouting *proute;
 
 		proute = cstate->partition_tuple_routing =
-			ExecSetupPartitionTupleRouting(NULL, cstate->rel, 1, estate);
+			ExecSetupPartitionTupleRouting(NULL, cstate->rel);
 
 		/*
 		 * If we are capturing transition tuples, they may need to be
@@ -2607,6 +2607,14 @@ CopyFrom(CopyState cstate)
 			 */
 			saved_resultRelInfo = resultRelInfo;
 			resultRelInfo = proute->partitions[leaf_part_index];
+			if (resultRelInfo == NULL)
+			{
+				resultRelInfo = ExecInitPartitionInfo(NULL,
+													  saved_resultRelInfo,
+													  proute, estate,
+													  leaf_part_index);
+				Assert(resultRelInfo != NULL);
+			}
 
 			/* We do not yet have a way to insert into a foreign partition */
 			if (resultRelInfo->ri_FdwRoutine)
diff --git a/src/backend/executor/execPartition.c b/src/backend/executor/execPartition.c
index 4048c3ebc6..efcb7f134b 100644
--- a/src/backend/executor/execPartition.c
+++ b/src/backend/executor/execPartition.c
@@ -44,18 +44,23 @@ static char *ExecBuildSlotPartitionKeyDescription(Relation rel,
  *
  * Note that all the relations in the partition tree are locked using the
  * RowExclusiveLock mode upon return from this function.
+ *
+ * While we allocate the arrays of pointers of ResultRelInfo and
+ * TupleConversionMap for all partitions here, actual objects themselves are
+ * lazily allocated for a given partition if a tuple is actually routed to it;
+ * see ExecInitPartitionInfo.  However, if the function is invoked for update
+ * tuple routing, caller would already have initialized ResultRelInfo's for
+ * some of the partitions, which are reused and assigned to their respective
+ * slot in the aforementioned array.
  */
 PartitionTupleRouting *
-ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
-							   Relation rel, Index resultRTindex,
-							   EState *estate)
+ExecSetupPartitionTupleRouting(ModifyTableState *mtstate, Relation rel)
 {
 	TupleDesc	tupDesc = RelationGetDescr(rel);
 	List	   *leaf_parts;
 	ListCell   *cell;
 	int			i;
-	ResultRelInfo *leaf_part_arr = NULL,
-			   *update_rri = NULL;
+	ResultRelInfo *update_rri = NULL;
 	int			num_update_rri = 0,
 				update_rri_index = 0;
 	bool		is_update = false;
@@ -76,6 +81,8 @@ ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
 	proute->parent_child_tupconv_maps =
 		(TupleConversionMap **) palloc0(proute->num_partitions *
 										sizeof(TupleConversionMap *));
+	proute->partition_oids = (Oid *) palloc(proute->num_partitions *
+											sizeof(Oid));
 
 	/* Set up details specific to the type of tuple routing we are doing. */
 	if (mtstate && mtstate->operation == CMD_UPDATE)
@@ -95,16 +102,6 @@ ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
 		 */
 		proute->root_tuple_slot = MakeTupleTableSlot();
 	}
-	else
-	{
-		/*
-		 * Since we are inserting tuples, we need to create all new result
-		 * rels. Avoid repeated pallocs by allocating memory for all the
-		 * result rels in bulk.
-		 */
-		leaf_part_arr = (ResultRelInfo *) palloc0(proute->num_partitions *
-												  sizeof(ResultRelInfo));
-	}
 
 	/*
 	 * Initialize an empty slot that will be used to manipulate tuples of any
@@ -117,11 +114,10 @@ ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
 	i = 0;
 	foreach(cell, leaf_parts)
 	{
-		ResultRelInfo *leaf_part_rri;
-		Relation	partrel = NULL;
-		TupleDesc	part_tupdesc;
+		ResultRelInfo *leaf_part_rri = NULL;
 		Oid			leaf_oid = lfirst_oid(cell);
 
+		proute->partition_oids[i] = leaf_oid;
 		if (is_update)
 		{
 			/*
@@ -136,6 +132,9 @@ ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
 			if (update_rri_index < num_update_rri &&
 				RelationGetRelid(update_rri[update_rri_index].ri_RelationDesc) == leaf_oid)
 			{
+				Relation	partrel;
+				TupleDesc	part_tupdesc;
+
 				leaf_part_rri = &update_rri[update_rri_index];
 				partrel = leaf_part_rri->ri_RelationDesc;
 
@@ -151,73 +150,26 @@ ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
 				proute->subplan_partition_offsets[update_rri_index] = i;
 
 				update_rri_index++;
+
+				part_tupdesc = RelationGetDescr(partrel);
+
+				/*
+				 * Save a tuple conversion map to convert a tuple routed to
+				 * this partition from the parent's type to the partition's.
+				 */
+				proute->parent_child_tupconv_maps[i] =
+					convert_tuples_by_name(tupDesc, part_tupdesc,
+							   gettext_noop("could not convert row type"));
+
+				/*
+				 * Verify result relation is a valid target for an INSERT.  An
+				 * UPDATE of a partition-key becomes a DELETE+INSERT operation,
+				 * so this check is required even when the operation is
+				 * CMD_UPDATE.
+				 */
+				CheckValidResultRel(leaf_part_rri, CMD_INSERT);
 			}
-			else
-				leaf_part_rri = (ResultRelInfo *) palloc0(sizeof(ResultRelInfo));
 		}
-		else
-		{
-			/* For INSERTs, we already have an array of result rels allocated */
-			leaf_part_rri = &leaf_part_arr[i];
-		}
-
-		/*
-		 * If we didn't open the partition rel, it means we haven't
-		 * initialized the result rel either.
-		 */
-		if (!partrel)
-		{
-			/*
-			 * We locked all the partitions above including the leaf
-			 * partitions. Note that each of the newly opened relations in
-			 * proute->partitions are eventually closed by the caller.
-			 */
-			partrel = heap_open(leaf_oid, NoLock);
-			InitResultRelInfo(leaf_part_rri,
-							  partrel,
-							  resultRTindex,
-							  rel,
-							  estate->es_instrument);
-
-			/*
-			 * Since we've just initialized this ResultRelInfo, it's not in
-			 * any list attached to the estate as yet.  Add it, so that it can
-			 * be found later.
-			 */
-			estate->es_tuple_routing_result_relations =
-						lappend(estate->es_tuple_routing_result_relations,
-								leaf_part_rri);
-		}
-
-		part_tupdesc = RelationGetDescr(partrel);
-
-		/*
-		 * Save a tuple conversion map to convert a tuple routed to this
-		 * partition from the parent's type to the partition's.
-		 */
-		proute->parent_child_tupconv_maps[i] =
-			convert_tuples_by_name(tupDesc, part_tupdesc,
-								   gettext_noop("could not convert row type"));
-
-		/*
-		 * Verify result relation is a valid target for an INSERT.  An UPDATE
-		 * of a partition-key becomes a DELETE+INSERT operation, so this check
-		 * is still required when the operation is CMD_UPDATE.
-		 */
-		CheckValidResultRel(leaf_part_rri, CMD_INSERT);
-
-		/*
-		 * Open partition indices.  The user may have asked to check for
-		 * conflicts within this leaf partition and do "nothing" instead of
-		 * throwing an error.  Be prepared in that case by initializing the
-		 * index information needed by ExecInsert() to perform speculative
-		 * insertions.
-		 */
-		if (leaf_part_rri->ri_RelationDesc->rd_rel->relhasindex &&
-			leaf_part_rri->ri_IndexRelationDescs == NULL)
-			ExecOpenIndices(leaf_part_rri,
-							mtstate != NULL &&
-							mtstate->mt_onconflict != ONCONFLICT_NONE);
 
 		proute->partitions[i] = leaf_part_rri;
 		i++;
@@ -352,6 +304,178 @@ ExecFindPartition(ResultRelInfo *resultRelInfo, PartitionDispatch *pd,
 }
 
 /*
+ * ExecInitPartitionInfo
+ *		Initialize ResultRelInfo and other information for a partition if not
+ *		already done
+ *
+ * Returns the ResultRelInfo
+ */
+ResultRelInfo *
+ExecInitPartitionInfo(ModifyTableState *mtstate,
+					  ResultRelInfo *resultRelInfo,
+					  PartitionTupleRouting *proute,
+					  EState *estate, int partidx)
+{
+	Relation	rootrel = resultRelInfo->ri_RelationDesc,
+				partrel;
+	ResultRelInfo *leaf_part_rri;
+	ModifyTable *node = mtstate ? (ModifyTable *) mtstate->ps.plan : NULL;
+
+	/*
+	 * We locked all the partitions in ExecSetupPartitionTupleRouting
+	 * including the leaf partitions.
+	 */
+	partrel = heap_open(proute->partition_oids[partidx], NoLock);
+	leaf_part_rri = (ResultRelInfo *) palloc0(sizeof(ResultRelInfo));
+	InitResultRelInfo(leaf_part_rri,
+					  partrel,
+					  node ? node->nominalRelation : 1,
+					  rootrel,
+					  estate->es_instrument);
+
+	/*
+	 * Verify result relation is a valid target for an INSERT.  An UPDATE
+	 * of a partition-key becomes a DELETE+INSERT operation, so this check
+	 * is still required when the operation is CMD_UPDATE.
+	 */
+	CheckValidResultRel(leaf_part_rri, CMD_INSERT);
+
+	/*
+	 * Since we've just initialized this ResultRelInfo, it's not in
+	 * any list attached to the estate as yet.  Add it, so that it can
+	 * be found later.
+	 *
+	 * Note that the entries in this list appear in no predetermined
+	 * order, because partition result rels are initialized as and when
+	 * they're needed.
+	 */
+	estate->es_tuple_routing_result_relations =
+					lappend(estate->es_tuple_routing_result_relations,
+							leaf_part_rri);
+
+	/*
+	 * Open partition indices.  The user may have asked to check for
+	 * conflicts within this leaf partition and do "nothing" instead of
+	 * throwing an error.  Be prepared in that case by initializing the
+	 * index information needed by ExecInsert() to perform speculative
+	 * insertions.
+	 */
+	if (partrel->rd_rel->relhasindex &&
+		leaf_part_rri->ri_IndexRelationDescs == NULL)
+		ExecOpenIndices(leaf_part_rri,
+						(mtstate != NULL &&
+						 mtstate->mt_onconflict != ONCONFLICT_NONE));
+
+	/*
+	 * Build WITH CHECK OPTION constraints for the partition.  Note that we
+	 * didn't build the withCheckOptionList for partitions within the planner,
+	 * but simple translation of varattnos will suffice.  This only occurs for
+	 * the INSERT case or in the case of UPDATE tuple routing where we didn't
+	 * find a result rel to reuse in ExecSetupPartitionTupleRouting().
+	 */
+	if (node && node->withCheckOptionLists != NIL)
+	{
+		List	   *wcoList;
+		List	   *mapped_wcoList;
+		List	   *wcoExprs = NIL;
+		ListCell   *ll;
+		int		firstVarno = mtstate->resultRelInfo[0].ri_RangeTableIndex;
+		Relation firstResultRel = mtstate->resultRelInfo[0].ri_RelationDesc;
+
+		/*
+		 * In the case of INSERT on partitioned tables, there is only one
+		 * plan.  Likewise, there is only one WCO list, not one per
+		 * partition.  For UPDATE, there would be as many WCO lists as
+		 * there are plans, but we use the first one as reference.  Note
+		 * that if there are SubPlans in there, they all end up attached
+		 * to the one parent Plan node.
+		 */
+		Assert((node->operation == CMD_INSERT &&
+				list_length(node->withCheckOptionLists) == 1 &&
+				list_length(node->plans) == 1) ||
+			   (node->operation == CMD_UPDATE &&
+				list_length(node->withCheckOptionLists) ==
+				list_length(node->plans)));
+		wcoList = linitial(node->withCheckOptionLists);
+
+		mapped_wcoList = map_partition_varattnos(wcoList, firstVarno,
+												 partrel, firstResultRel,
+												 NULL);
+		foreach(ll, mapped_wcoList)
+		{
+			WithCheckOption *wco = castNode(WithCheckOption, lfirst(ll));
+			ExprState  *wcoExpr = ExecInitQual(castNode(List, wco->qual),
+											   mtstate->mt_plans[0]);
+			wcoExprs = lappend(wcoExprs, wcoExpr);
+		}
+
+		leaf_part_rri->ri_WithCheckOptions = mapped_wcoList;
+		leaf_part_rri->ri_WithCheckOptionExprs = wcoExprs;
+	}
+
+	/*
+	 * Build the RETURNING projection if any for the partition.  Note that
+	 * we didn't build the returningList for partitions within the planner,
+	 * but simple translation of varattnos will suffice.  This only occurs for
+	 * the INSERT case or in the case of UPDATE tuple routing where we didn't
+	 * find a result rel to reuse in ExecSetupPartitionTupleRouting().
+	 */
+	if (node && node->returningLists != NIL)
+	{
+		TupleTableSlot *slot;
+		ExprContext *econtext;
+		List	   *returningList;
+		List	   *rlist;
+		TupleDesc	tupDesc;
+		int		firstVarno = mtstate->resultRelInfo[0].ri_RangeTableIndex;
+		Relation firstResultRel = mtstate->resultRelInfo[0].ri_RelationDesc;
+
+		/* See the comment written above for WCO lists. */
+		Assert((node->operation == CMD_INSERT &&
+				list_length(node->returningLists) == 1 &&
+				list_length(node->plans) == 1) ||
+			   (node->operation == CMD_UPDATE &&
+				list_length(node->returningLists) ==
+				list_length(node->plans)));
+		returningList = linitial(node->returningLists);
+
+		/*
+		 * Use the slot that would have been set up in ExecInitModifyTable()
+		 * for the output of the RETURNING projection(s).  Just make sure to
+		 * assign its rowtype using the RETURNING list.
+		 */
+		Assert(mtstate->ps.ps_ResultTupleSlot != NULL);
+		tupDesc = ExecTypeFromTL(returningList, false);
+		ExecAssignResultType(&mtstate->ps, tupDesc);
+		slot = mtstate->ps.ps_ResultTupleSlot;
+
+		/* An expression context must have been set up too */
+		Assert(mtstate->ps.ps_ExprContext != NULL);
+		econtext = mtstate->ps.ps_ExprContext;
+
+		rlist = map_partition_varattnos(returningList, firstVarno,
+										partrel, firstResultRel, NULL);
+		leaf_part_rri->ri_projectReturning =
+			ExecBuildProjectionInfo(rlist, econtext, slot, &mtstate->ps,
+									RelationGetDescr(partrel));
+	}
+
+	Assert (proute->partitions[partidx] == NULL);
+	proute->partitions[partidx] = leaf_part_rri;
+
+	/*
+	 * Save a tuple conversion map to convert a tuple routed to this
+	 * partition from the parent's type to the partition's.
+	 */
+	proute->parent_child_tupconv_maps[partidx] =
+							convert_tuples_by_name(RelationGetDescr(rootrel),
+												   RelationGetDescr(partrel),
+											   gettext_noop("could not convert row type"));
+
+	return leaf_part_rri;
+}
+
+/*
  * ExecSetupChildParentMapForLeaf -- Initialize the per-leaf-partition
  * child-to-root tuple conversion map array.
  *
@@ -477,6 +601,10 @@ ExecCleanupTupleRouting(PartitionTupleRouting *proute)
 	{
 		ResultRelInfo *resultRelInfo = proute->partitions[i];
 
+		/* skip further processsing for uninitialized partitions */
+		if (resultRelInfo == NULL)
+			continue;
+
 		/*
 		 * If this result rel is one of the UPDATE subplan result rels, let
 		 * ExecEndPlan() close it. For INSERT or COPY,
diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c
index 2a8ecbd830..36e2041755 100644
--- a/src/backend/executor/nodeModifyTable.c
+++ b/src/backend/executor/nodeModifyTable.c
@@ -310,6 +310,14 @@ ExecInsert(ModifyTableState *mtstate,
 		 */
 		saved_resultRelInfo = resultRelInfo;
 		resultRelInfo = proute->partitions[leaf_part_index];
+		if (resultRelInfo == NULL)
+		{
+			resultRelInfo = ExecInitPartitionInfo(mtstate,
+												  saved_resultRelInfo,
+												  proute, estate,
+												  leaf_part_index);
+			Assert(resultRelInfo != NULL);
+		}
 
 		/* We do not yet have a way to insert into a foreign partition */
 		if (resultRelInfo->ri_FdwRoutine)
@@ -2098,14 +2106,10 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 	ResultRelInfo *saved_resultRelInfo;
 	ResultRelInfo *resultRelInfo;
 	Plan	   *subplan;
-	int			firstVarno = 0;
-	Relation	firstResultRel = NULL;
 	ListCell   *l;
 	int			i;
 	Relation	rel;
 	bool		update_tuple_routing_needed = node->partColsUpdated;
-	PartitionTupleRouting *proute = NULL;
-	int			num_partitions = 0;
 
 	/* check for unsupported flags */
 	Assert(!(eflags & (EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK)));
@@ -2228,20 +2232,8 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 	 */
 	if (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE &&
 		(operation == CMD_INSERT || update_tuple_routing_needed))
-	{
-		proute = mtstate->mt_partition_tuple_routing =
-			ExecSetupPartitionTupleRouting(mtstate,
-										   rel, node->nominalRelation,
-										   estate);
-		num_partitions = proute->num_partitions;
-
-		/*
-		 * Below are required as reference objects for mapping partition
-		 * attno's in expressions such as WithCheckOptions and RETURNING.
-		 */
-		firstVarno = mtstate->resultRelInfo[0].ri_RangeTableIndex;
-		firstResultRel = mtstate->resultRelInfo[0].ri_RelationDesc;
-	}
+		mtstate->mt_partition_tuple_routing =
+						ExecSetupPartitionTupleRouting(mtstate, rel);
 
 	/*
 	 * Build state for collecting transition tuples.  This requires having a
@@ -2288,77 +2280,12 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 	}
 
 	/*
-	 * Build WITH CHECK OPTION constraints for each leaf partition rel. Note
-	 * that we didn't build the withCheckOptionList for each partition within
-	 * the planner, but simple translation of the varattnos for each partition
-	 * will suffice.  This only occurs for the INSERT case or for UPDATE row
-	 * movement. DELETEs and local UPDATEs are handled above.
-	 */
-	if (node->withCheckOptionLists != NIL && num_partitions > 0)
-	{
-		List	   *first_wcoList;
-
-		/*
-		 * In case of INSERT on partitioned tables, there is only one plan.
-		 * Likewise, there is only one WITH CHECK OPTIONS list, not one per
-		 * partition. Whereas for UPDATE, there are as many WCOs as there are
-		 * plans. So in either case, use the WCO expression of the first
-		 * resultRelInfo as a reference to calculate attno's for the WCO
-		 * expression of each of the partitions. We make a copy of the WCO
-		 * qual for each partition. Note that, if there are SubPlans in there,
-		 * they all end up attached to the one parent Plan node.
-		 */
-		Assert(update_tuple_routing_needed ||
-			   (operation == CMD_INSERT &&
-				list_length(node->withCheckOptionLists) == 1 &&
-				mtstate->mt_nplans == 1));
-
-		first_wcoList = linitial(node->withCheckOptionLists);
-		for (i = 0; i < num_partitions; i++)
-		{
-			Relation	partrel;
-			List	   *mapped_wcoList;
-			List	   *wcoExprs = NIL;
-			ListCell   *ll;
-
-			resultRelInfo = proute->partitions[i];
-
-			/*
-			 * If we are referring to a resultRelInfo from one of the update
-			 * result rels, that result rel would already have
-			 * WithCheckOptions initialized.
-			 */
-			if (resultRelInfo->ri_WithCheckOptions)
-				continue;
-
-			partrel = resultRelInfo->ri_RelationDesc;
-
-			mapped_wcoList = map_partition_varattnos(first_wcoList,
-													 firstVarno,
-													 partrel, firstResultRel,
-													 NULL);
-			foreach(ll, mapped_wcoList)
-			{
-				WithCheckOption *wco = castNode(WithCheckOption, lfirst(ll));
-				ExprState  *wcoExpr = ExecInitQual(castNode(List, wco->qual),
-												   &mtstate->ps);
-
-				wcoExprs = lappend(wcoExprs, wcoExpr);
-			}
-
-			resultRelInfo->ri_WithCheckOptions = mapped_wcoList;
-			resultRelInfo->ri_WithCheckOptionExprs = wcoExprs;
-		}
-	}
-
-	/*
 	 * Initialize RETURNING projections if needed.
 	 */
 	if (node->returningLists)
 	{
 		TupleTableSlot *slot;
 		ExprContext *econtext;
-		List	   *firstReturningList;
 
 		/*
 		 * Initialize result tuple slot and assign its rowtype using the first
@@ -2389,44 +2316,6 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 										resultRelInfo->ri_RelationDesc->rd_att);
 			resultRelInfo++;
 		}
-
-		/*
-		 * Build a projection for each leaf partition rel.  Note that we
-		 * didn't build the returningList for each partition within the
-		 * planner, but simple translation of the varattnos for each partition
-		 * will suffice.  This only occurs for the INSERT case or for UPDATE
-		 * row movement. DELETEs and local UPDATEs are handled above.
-		 */
-		firstReturningList = linitial(node->returningLists);
-		for (i = 0; i < num_partitions; i++)
-		{
-			Relation	partrel;
-			List	   *rlist;
-
-			resultRelInfo = proute->partitions[i];
-
-			/*
-			 * If we are referring to a resultRelInfo from one of the update
-			 * result rels, that result rel would already have a returningList
-			 * built.
-			 */
-			if (resultRelInfo->ri_projectReturning)
-				continue;
-
-			partrel = resultRelInfo->ri_RelationDesc;
-
-			/*
-			 * Use the returning expression of the first resultRelInfo as a
-			 * reference to calculate attno's for the returning expression of
-			 * each of the partitions.
-			 */
-			rlist = map_partition_varattnos(firstReturningList,
-											firstVarno,
-											partrel, firstResultRel, NULL);
-			resultRelInfo->ri_projectReturning =
-				ExecBuildProjectionInfo(rlist, econtext, slot, &mtstate->ps,
-										resultRelInfo->ri_RelationDesc->rd_att);
-		}
 	}
 	else
 	{
diff --git a/src/include/executor/execPartition.h b/src/include/executor/execPartition.h
index 3df9c498bb..e94718608f 100644
--- a/src/include/executor/execPartition.h
+++ b/src/include/executor/execPartition.h
@@ -58,6 +58,7 @@ typedef struct PartitionDispatchData *PartitionDispatch;
  *								partition tree.
  * num_dispatch					number of partitioned tables in the partition
  *								tree (= length of partition_dispatch_info[])
+ * partition_oids				Array of leaf partitions OIDs
  * partitions					Array of ResultRelInfo* objects with one entry
  *								for every leaf partition in the partition tree.
  * num_partitions				Number of leaf partitions in the partition tree
@@ -91,6 +92,7 @@ typedef struct PartitionTupleRouting
 {
 	PartitionDispatch *partition_dispatch_info;
 	int			num_dispatch;
+	Oid		   *partition_oids;
 	ResultRelInfo **partitions;
 	int			num_partitions;
 	TupleConversionMap **parent_child_tupconv_maps;
@@ -103,12 +105,15 @@ typedef struct PartitionTupleRouting
 } PartitionTupleRouting;
 
 extern PartitionTupleRouting *ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
-							   Relation rel, Index resultRTindex,
-							   EState *estate);
+							   Relation rel);
 extern int ExecFindPartition(ResultRelInfo *resultRelInfo,
 				  PartitionDispatch *pd,
 				  TupleTableSlot *slot,
 				  EState *estate);
+extern ResultRelInfo *ExecInitPartitionInfo(ModifyTableState *mtstate,
+					ResultRelInfo *resultRelInfo,
+					PartitionTupleRouting *proute,
+					EState *estate, int partidx);
 extern void ExecSetupChildParentMapForLeaf(PartitionTupleRouting *proute);
 extern TupleConversionMap *TupConvMapForLeaf(PartitionTupleRouting *proute,
 				  ResultRelInfo *rootRelInfo, int leaf_index);
-- 
2.11.0

From e74ce73c574bc1892fa957b105adccf1eada1c5f Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Tue, 19 Dec 2017 16:20:09 +0900
Subject: [PATCH v9] During tuple-routing, initialize per-partition objects
 lazily

Those objects include ResultRelInfo, tuple conversion map,
WITH CHECK OPTION quals and RETURNING projections.

This means we don't allocate these objects for partitions that are
never inserted into.
---
 src/backend/commands/copy.c            |  10 +-
 src/backend/executor/execPartition.c   | 305 ++++++++++++++++++++++++---------
 src/backend/executor/nodeModifyTable.c | 131 ++------------
 src/include/executor/execPartition.h   |   9 +-
 4 files changed, 248 insertions(+), 207 deletions(-)

diff --git a/src/backend/commands/copy.c b/src/backend/commands/copy.c
index b3933df9af..118452b602 100644
--- a/src/backend/commands/copy.c
+++ b/src/backend/commands/copy.c
@@ -2470,7 +2470,7 @@ CopyFrom(CopyState cstate)
 		PartitionTupleRouting *proute;
 
 		proute = cstate->partition_tuple_routing =
-			ExecSetupPartitionTupleRouting(NULL, cstate->rel, 1, estate);
+			ExecSetupPartitionTupleRouting(NULL, cstate->rel);
 
 		/*
 		 * If we are capturing transition tuples, they may need to be
@@ -2607,6 +2607,14 @@ CopyFrom(CopyState cstate)
 			 */
 			saved_resultRelInfo = resultRelInfo;
 			resultRelInfo = proute->partitions[leaf_part_index];
+			if (resultRelInfo == NULL)
+			{
+				resultRelInfo = ExecInitPartitionInfo(NULL,
+													  saved_resultRelInfo,
+													  proute, estate,
+													  leaf_part_index);
+				Assert(resultRelInfo != NULL);
+			}
 
 			/* We do not yet have a way to insert into a foreign partition */
 			if (resultRelInfo->ri_FdwRoutine)
diff --git a/src/backend/executor/execPartition.c b/src/backend/executor/execPartition.c
index 4048c3ebc6..5fa6e2de09 100644
--- a/src/backend/executor/execPartition.c
+++ b/src/backend/executor/execPartition.c
@@ -44,18 +44,23 @@ static char *ExecBuildSlotPartitionKeyDescription(Relation rel,
  *
  * Note that all the relations in the partition tree are locked using the
  * RowExclusiveLock mode upon return from this function.
+ *
+ * While we allocate the arrays of pointers of ResultRelInfo and
+ * TupleConversionMap for all partitions here, actual objects themselves are
+ * lazily allocated for a given partition if a tuple is actually routed to it;
+ * see ExecInitPartitionInfo.  However, if the function is invoked for update
+ * tuple routing, caller would already have initialized ResultRelInfo's for
+ * some of the partitions, which are reused and assigned to their respective
+ * slot in the aforementioned array.
  */
 PartitionTupleRouting *
-ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
-							   Relation rel, Index resultRTindex,
-							   EState *estate)
+ExecSetupPartitionTupleRouting(ModifyTableState *mtstate, Relation rel)
 {
 	TupleDesc	tupDesc = RelationGetDescr(rel);
 	List	   *leaf_parts;
 	ListCell   *cell;
 	int			i;
-	ResultRelInfo *leaf_part_arr = NULL,
-			   *update_rri = NULL;
+	ResultRelInfo *update_rri = NULL;
 	int			num_update_rri = 0,
 				update_rri_index = 0;
 	bool		is_update = false;
@@ -76,6 +81,8 @@ ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
 	proute->parent_child_tupconv_maps =
 		(TupleConversionMap **) palloc0(proute->num_partitions *
 										sizeof(TupleConversionMap *));
+	proute->partition_oids = (Oid *) palloc(proute->num_partitions *
+											sizeof(Oid));
 
 	/* Set up details specific to the type of tuple routing we are doing. */
 	if (mtstate && mtstate->operation == CMD_UPDATE)
@@ -95,16 +102,6 @@ ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
 		 */
 		proute->root_tuple_slot = MakeTupleTableSlot();
 	}
-	else
-	{
-		/*
-		 * Since we are inserting tuples, we need to create all new result
-		 * rels. Avoid repeated pallocs by allocating memory for all the
-		 * result rels in bulk.
-		 */
-		leaf_part_arr = (ResultRelInfo *) palloc0(proute->num_partitions *
-												  sizeof(ResultRelInfo));
-	}
 
 	/*
 	 * Initialize an empty slot that will be used to manipulate tuples of any
@@ -117,11 +114,10 @@ ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
 	i = 0;
 	foreach(cell, leaf_parts)
 	{
-		ResultRelInfo *leaf_part_rri;
-		Relation	partrel = NULL;
-		TupleDesc	part_tupdesc;
+		ResultRelInfo *leaf_part_rri = NULL;
 		Oid			leaf_oid = lfirst_oid(cell);
 
+		proute->partition_oids[i] = leaf_oid;
 		if (is_update)
 		{
 			/*
@@ -136,6 +132,9 @@ ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
 			if (update_rri_index < num_update_rri &&
 				RelationGetRelid(update_rri[update_rri_index].ri_RelationDesc) == leaf_oid)
 			{
+				Relation	partrel;
+				TupleDesc	part_tupdesc;
+
 				leaf_part_rri = &update_rri[update_rri_index];
 				partrel = leaf_part_rri->ri_RelationDesc;
 
@@ -151,73 +150,26 @@ ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
 				proute->subplan_partition_offsets[update_rri_index] = i;
 
 				update_rri_index++;
+
+				part_tupdesc = RelationGetDescr(partrel);
+
+				/*
+				 * Save a tuple conversion map to convert a tuple routed to
+				 * this partition from the parent's type to the partition's.
+				 */
+				proute->parent_child_tupconv_maps[i] =
+					convert_tuples_by_name(tupDesc, part_tupdesc,
+							   gettext_noop("could not convert row type"));
+
+				/*
+				 * Verify result relation is a valid target for an INSERT.  An
+				 * UPDATE of a partition-key becomes a DELETE+INSERT operation,
+				 * so this check is required even when the operation is
+				 * CMD_UPDATE.
+				 */
+				CheckValidResultRel(leaf_part_rri, CMD_INSERT);
 			}
-			else
-				leaf_part_rri = (ResultRelInfo *) palloc0(sizeof(ResultRelInfo));
 		}
-		else
-		{
-			/* For INSERTs, we already have an array of result rels allocated */
-			leaf_part_rri = &leaf_part_arr[i];
-		}
-
-		/*
-		 * If we didn't open the partition rel, it means we haven't
-		 * initialized the result rel either.
-		 */
-		if (!partrel)
-		{
-			/*
-			 * We locked all the partitions above including the leaf
-			 * partitions. Note that each of the newly opened relations in
-			 * proute->partitions are eventually closed by the caller.
-			 */
-			partrel = heap_open(leaf_oid, NoLock);
-			InitResultRelInfo(leaf_part_rri,
-							  partrel,
-							  resultRTindex,
-							  rel,
-							  estate->es_instrument);
-
-			/*
-			 * Since we've just initialized this ResultRelInfo, it's not in
-			 * any list attached to the estate as yet.  Add it, so that it can
-			 * be found later.
-			 */
-			estate->es_tuple_routing_result_relations =
-						lappend(estate->es_tuple_routing_result_relations,
-								leaf_part_rri);
-		}
-
-		part_tupdesc = RelationGetDescr(partrel);
-
-		/*
-		 * Save a tuple conversion map to convert a tuple routed to this
-		 * partition from the parent's type to the partition's.
-		 */
-		proute->parent_child_tupconv_maps[i] =
-			convert_tuples_by_name(tupDesc, part_tupdesc,
-								   gettext_noop("could not convert row type"));
-
-		/*
-		 * Verify result relation is a valid target for an INSERT.  An UPDATE
-		 * of a partition-key becomes a DELETE+INSERT operation, so this check
-		 * is still required when the operation is CMD_UPDATE.
-		 */
-		CheckValidResultRel(leaf_part_rri, CMD_INSERT);
-
-		/*
-		 * Open partition indices.  The user may have asked to check for
-		 * conflicts within this leaf partition and do "nothing" instead of
-		 * throwing an error.  Be prepared in that case by initializing the
-		 * index information needed by ExecInsert() to perform speculative
-		 * insertions.
-		 */
-		if (leaf_part_rri->ri_RelationDesc->rd_rel->relhasindex &&
-			leaf_part_rri->ri_IndexRelationDescs == NULL)
-			ExecOpenIndices(leaf_part_rri,
-							mtstate != NULL &&
-							mtstate->mt_onconflict != ONCONFLICT_NONE);
 
 		proute->partitions[i] = leaf_part_rri;
 		i++;
@@ -352,6 +304,189 @@ ExecFindPartition(ResultRelInfo *resultRelInfo, PartitionDispatch *pd,
 }
 
 /*
+ * ExecInitPartitionInfo
+ *		Initialize ResultRelInfo and other information for a partition if not
+ *		already done
+ *
+ * Returns the ResultRelInfo
+ */
+ResultRelInfo *
+ExecInitPartitionInfo(ModifyTableState *mtstate,
+					  ResultRelInfo *resultRelInfo,
+					  PartitionTupleRouting *proute,
+					  EState *estate, int partidx)
+{
+	Relation	rootrel = resultRelInfo->ri_RelationDesc,
+				partrel;
+	ResultRelInfo *leaf_part_rri;
+	ModifyTable *node = mtstate ? (ModifyTable *) mtstate->ps.plan : NULL;
+
+	/*
+	 * We locked all the partitions in ExecSetupPartitionTupleRouting
+	 * including the leaf partitions.
+	 */
+	partrel = heap_open(proute->partition_oids[partidx], NoLock);
+	leaf_part_rri = (ResultRelInfo *) palloc0(sizeof(ResultRelInfo));
+	InitResultRelInfo(leaf_part_rri,
+					  partrel,
+					  node ? node->nominalRelation : 1,
+					  rootrel,
+					  estate->es_instrument);
+
+	/*
+	 * Verify result relation is a valid target for an INSERT.  An UPDATE
+	 * of a partition-key becomes a DELETE+INSERT operation, so this check
+	 * is still required when the operation is CMD_UPDATE.
+	 */
+	CheckValidResultRel(leaf_part_rri, CMD_INSERT);
+
+	/*
+	 * Since we've just initialized this ResultRelInfo, it's not in
+	 * any list attached to the estate as yet.  Add it, so that it can
+	 * be found later.
+	 *
+	 * Note that the entries in this list appear in no predetermined
+	 * order, because partition result rels are initialized as and when
+	 * they're needed.
+	 */
+	estate->es_tuple_routing_result_relations =
+					lappend(estate->es_tuple_routing_result_relations,
+							leaf_part_rri);
+
+	/*
+	 * Open partition indices.  The user may have asked to check for
+	 * conflicts within this leaf partition and do "nothing" instead of
+	 * throwing an error.  Be prepared in that case by initializing the
+	 * index information needed by ExecInsert() to perform speculative
+	 * insertions.
+	 */
+	if (partrel->rd_rel->relhasindex &&
+		leaf_part_rri->ri_IndexRelationDescs == NULL)
+		ExecOpenIndices(leaf_part_rri,
+						(mtstate != NULL &&
+						 mtstate->mt_onconflict != ONCONFLICT_NONE));
+
+	/*
+	 * Build WITH CHECK OPTION constraints for the partition.  Note that we
+	 * didn't build the withCheckOptionList for partitions within the planner,
+	 * but simple translation of varattnos will suffice.  This only occurs for
+	 * the INSERT case or in the case of UPDATE tuple routing where we didn't
+	 * find a result rel to reuse in ExecSetupPartitionTupleRouting().
+	 */
+	if (node && node->withCheckOptionLists != NIL)
+	{
+		List	   *wcoList;
+		List	   *wcoExprs = NIL;
+		ListCell   *ll;
+		int		firstVarno = mtstate->resultRelInfo[0].ri_RangeTableIndex;
+		Relation firstResultRel = mtstate->resultRelInfo[0].ri_RelationDesc;
+
+		/*
+		 * In the case of INSERT on partitioned tables, there is only one
+		 * plan.  Likewise, there is only one WCO list, not one per
+		 * partition.  For UPDATE, there would be as many WCO lists as
+		 * there are plans, but we use the first one as reference.  Note
+		 * that if there are SubPlans in there, they all end up attached
+		 * to the one parent Plan node.
+		 */
+		Assert((node->operation == CMD_INSERT &&
+				list_length(node->withCheckOptionLists) == 1 &&
+				list_length(node->plans) == 1) ||
+			   (node->operation == CMD_UPDATE &&
+				list_length(node->withCheckOptionLists) ==
+				list_length(node->plans)));
+		wcoList = linitial(node->withCheckOptionLists);
+
+		/*
+		 * Convert Vars in it to contain this partition's attribute numbers.
+		 * Use the WITH CHECK OPTIONS list of the first resultRelInfo as a
+		 * reference to calculate attno's for the returning expression of
+		 * this partition.  In the INSERT case, that refers to the root
+		 * partitioned table, whereas in the UPDATE tuple routing case the
+		 * first partition in the mtstate->resultRelInfo array.  In any case,
+		 * both that relation and this partition should have the same columns,
+		 * so we should be able to map attributes successfully.
+		 */
+		wcoList = map_partition_varattnos(wcoList, firstVarno,
+										  partrel, firstResultRel, NULL);
+		foreach(ll, wcoList)
+		{
+			WithCheckOption *wco = castNode(WithCheckOption, lfirst(ll));
+			ExprState  *wcoExpr = ExecInitQual(castNode(List, wco->qual),
+											   mtstate->mt_plans[0]);
+			wcoExprs = lappend(wcoExprs, wcoExpr);
+		}
+
+		leaf_part_rri->ri_WithCheckOptions = wcoList;
+		leaf_part_rri->ri_WithCheckOptionExprs = wcoExprs;
+	}
+
+	/*
+	 * Build the RETURNING projection for the partition.  Note that we didn't
+	 * build the returningList for partitions within the planner, but simple
+	 * translation of varattnos will suffice.  This only occurs for the INSERT
+	 * case or in the case of UPDATE tuple routing where we didn't find a
+	 * result rel to reuse in ExecSetupPartitionTupleRouting().
+	 */
+	if (node && node->returningLists != NIL)
+	{
+		TupleTableSlot *slot;
+		ExprContext *econtext;
+		List	   *returningList;
+		int		firstVarno = mtstate->resultRelInfo[0].ri_RangeTableIndex;
+		Relation firstResultRel = mtstate->resultRelInfo[0].ri_RelationDesc;
+
+		/* See the comment written above for WCO lists. */
+		Assert((node->operation == CMD_INSERT &&
+				list_length(node->returningLists) == 1 &&
+				list_length(node->plans) == 1) ||
+			   (node->operation == CMD_UPDATE &&
+				list_length(node->returningLists) ==
+				list_length(node->plans)));
+		returningList = linitial(node->returningLists);
+
+		/*
+		 * Convert Vars in it to contain this partition's attribute numbers.
+		 * Use the returning expression of the first resultRelInfo as a
+		 * reference to calculate attno's for the returning expression of
+		 * each of the partitions.  See the comment above for WCO list for
+		 * more details on why this is okay.
+		 */
+		returningList = map_partition_varattnos(returningList, firstVarno,
+												partrel, firstResultRel,
+												NULL);
+
+		/*
+		 * Initialize the projection itself.
+		 *
+		 * Use the slot and the expression context that would have been set up
+		 * in ExecInitModifyTable() for projection's output.
+		 */
+		Assert(mtstate->ps.ps_ResultTupleSlot != NULL);
+		slot = mtstate->ps.ps_ResultTupleSlot;
+		Assert(mtstate->ps.ps_ExprContext != NULL);
+		econtext = mtstate->ps.ps_ExprContext;
+		leaf_part_rri->ri_projectReturning =
+			ExecBuildProjectionInfo(returningList, econtext, slot,
+									&mtstate->ps, RelationGetDescr(partrel));
+	}
+
+	Assert (proute->partitions[partidx] == NULL);
+	proute->partitions[partidx] = leaf_part_rri;
+
+	/*
+	 * Save a tuple conversion map to convert a tuple routed to this
+	 * partition from the parent's type to the partition's.
+	 */
+	proute->parent_child_tupconv_maps[partidx] =
+							convert_tuples_by_name(RelationGetDescr(rootrel),
+												   RelationGetDescr(partrel),
+											   gettext_noop("could not convert row type"));
+
+	return leaf_part_rri;
+}
+
+/*
  * ExecSetupChildParentMapForLeaf -- Initialize the per-leaf-partition
  * child-to-root tuple conversion map array.
  *
@@ -477,6 +612,10 @@ ExecCleanupTupleRouting(PartitionTupleRouting *proute)
 	{
 		ResultRelInfo *resultRelInfo = proute->partitions[i];
 
+		/* skip further processsing for uninitialized partitions */
+		if (resultRelInfo == NULL)
+			continue;
+
 		/*
 		 * If this result rel is one of the UPDATE subplan result rels, let
 		 * ExecEndPlan() close it. For INSERT or COPY,
diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c
index 2a8ecbd830..36e2041755 100644
--- a/src/backend/executor/nodeModifyTable.c
+++ b/src/backend/executor/nodeModifyTable.c
@@ -310,6 +310,14 @@ ExecInsert(ModifyTableState *mtstate,
 		 */
 		saved_resultRelInfo = resultRelInfo;
 		resultRelInfo = proute->partitions[leaf_part_index];
+		if (resultRelInfo == NULL)
+		{
+			resultRelInfo = ExecInitPartitionInfo(mtstate,
+												  saved_resultRelInfo,
+												  proute, estate,
+												  leaf_part_index);
+			Assert(resultRelInfo != NULL);
+		}
 
 		/* We do not yet have a way to insert into a foreign partition */
 		if (resultRelInfo->ri_FdwRoutine)
@@ -2098,14 +2106,10 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 	ResultRelInfo *saved_resultRelInfo;
 	ResultRelInfo *resultRelInfo;
 	Plan	   *subplan;
-	int			firstVarno = 0;
-	Relation	firstResultRel = NULL;
 	ListCell   *l;
 	int			i;
 	Relation	rel;
 	bool		update_tuple_routing_needed = node->partColsUpdated;
-	PartitionTupleRouting *proute = NULL;
-	int			num_partitions = 0;
 
 	/* check for unsupported flags */
 	Assert(!(eflags & (EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK)));
@@ -2228,20 +2232,8 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 	 */
 	if (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE &&
 		(operation == CMD_INSERT || update_tuple_routing_needed))
-	{
-		proute = mtstate->mt_partition_tuple_routing =
-			ExecSetupPartitionTupleRouting(mtstate,
-										   rel, node->nominalRelation,
-										   estate);
-		num_partitions = proute->num_partitions;
-
-		/*
-		 * Below are required as reference objects for mapping partition
-		 * attno's in expressions such as WithCheckOptions and RETURNING.
-		 */
-		firstVarno = mtstate->resultRelInfo[0].ri_RangeTableIndex;
-		firstResultRel = mtstate->resultRelInfo[0].ri_RelationDesc;
-	}
+		mtstate->mt_partition_tuple_routing =
+						ExecSetupPartitionTupleRouting(mtstate, rel);
 
 	/*
 	 * Build state for collecting transition tuples.  This requires having a
@@ -2288,77 +2280,12 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 	}
 
 	/*
-	 * Build WITH CHECK OPTION constraints for each leaf partition rel. Note
-	 * that we didn't build the withCheckOptionList for each partition within
-	 * the planner, but simple translation of the varattnos for each partition
-	 * will suffice.  This only occurs for the INSERT case or for UPDATE row
-	 * movement. DELETEs and local UPDATEs are handled above.
-	 */
-	if (node->withCheckOptionLists != NIL && num_partitions > 0)
-	{
-		List	   *first_wcoList;
-
-		/*
-		 * In case of INSERT on partitioned tables, there is only one plan.
-		 * Likewise, there is only one WITH CHECK OPTIONS list, not one per
-		 * partition. Whereas for UPDATE, there are as many WCOs as there are
-		 * plans. So in either case, use the WCO expression of the first
-		 * resultRelInfo as a reference to calculate attno's for the WCO
-		 * expression of each of the partitions. We make a copy of the WCO
-		 * qual for each partition. Note that, if there are SubPlans in there,
-		 * they all end up attached to the one parent Plan node.
-		 */
-		Assert(update_tuple_routing_needed ||
-			   (operation == CMD_INSERT &&
-				list_length(node->withCheckOptionLists) == 1 &&
-				mtstate->mt_nplans == 1));
-
-		first_wcoList = linitial(node->withCheckOptionLists);
-		for (i = 0; i < num_partitions; i++)
-		{
-			Relation	partrel;
-			List	   *mapped_wcoList;
-			List	   *wcoExprs = NIL;
-			ListCell   *ll;
-
-			resultRelInfo = proute->partitions[i];
-
-			/*
-			 * If we are referring to a resultRelInfo from one of the update
-			 * result rels, that result rel would already have
-			 * WithCheckOptions initialized.
-			 */
-			if (resultRelInfo->ri_WithCheckOptions)
-				continue;
-
-			partrel = resultRelInfo->ri_RelationDesc;
-
-			mapped_wcoList = map_partition_varattnos(first_wcoList,
-													 firstVarno,
-													 partrel, firstResultRel,
-													 NULL);
-			foreach(ll, mapped_wcoList)
-			{
-				WithCheckOption *wco = castNode(WithCheckOption, lfirst(ll));
-				ExprState  *wcoExpr = ExecInitQual(castNode(List, wco->qual),
-												   &mtstate->ps);
-
-				wcoExprs = lappend(wcoExprs, wcoExpr);
-			}
-
-			resultRelInfo->ri_WithCheckOptions = mapped_wcoList;
-			resultRelInfo->ri_WithCheckOptionExprs = wcoExprs;
-		}
-	}
-
-	/*
 	 * Initialize RETURNING projections if needed.
 	 */
 	if (node->returningLists)
 	{
 		TupleTableSlot *slot;
 		ExprContext *econtext;
-		List	   *firstReturningList;
 
 		/*
 		 * Initialize result tuple slot and assign its rowtype using the first
@@ -2389,44 +2316,6 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 										resultRelInfo->ri_RelationDesc->rd_att);
 			resultRelInfo++;
 		}
-
-		/*
-		 * Build a projection for each leaf partition rel.  Note that we
-		 * didn't build the returningList for each partition within the
-		 * planner, but simple translation of the varattnos for each partition
-		 * will suffice.  This only occurs for the INSERT case or for UPDATE
-		 * row movement. DELETEs and local UPDATEs are handled above.
-		 */
-		firstReturningList = linitial(node->returningLists);
-		for (i = 0; i < num_partitions; i++)
-		{
-			Relation	partrel;
-			List	   *rlist;
-
-			resultRelInfo = proute->partitions[i];
-
-			/*
-			 * If we are referring to a resultRelInfo from one of the update
-			 * result rels, that result rel would already have a returningList
-			 * built.
-			 */
-			if (resultRelInfo->ri_projectReturning)
-				continue;
-
-			partrel = resultRelInfo->ri_RelationDesc;
-
-			/*
-			 * Use the returning expression of the first resultRelInfo as a
-			 * reference to calculate attno's for the returning expression of
-			 * each of the partitions.
-			 */
-			rlist = map_partition_varattnos(firstReturningList,
-											firstVarno,
-											partrel, firstResultRel, NULL);
-			resultRelInfo->ri_projectReturning =
-				ExecBuildProjectionInfo(rlist, econtext, slot, &mtstate->ps,
-										resultRelInfo->ri_RelationDesc->rd_att);
-		}
 	}
 	else
 	{
diff --git a/src/include/executor/execPartition.h b/src/include/executor/execPartition.h
index 3df9c498bb..e94718608f 100644
--- a/src/include/executor/execPartition.h
+++ b/src/include/executor/execPartition.h
@@ -58,6 +58,7 @@ typedef struct PartitionDispatchData *PartitionDispatch;
  *								partition tree.
  * num_dispatch					number of partitioned tables in the partition
  *								tree (= length of partition_dispatch_info[])
+ * partition_oids				Array of leaf partitions OIDs
  * partitions					Array of ResultRelInfo* objects with one entry
  *								for every leaf partition in the partition tree.
  * num_partitions				Number of leaf partitions in the partition tree
@@ -91,6 +92,7 @@ typedef struct PartitionTupleRouting
 {
 	PartitionDispatch *partition_dispatch_info;
 	int			num_dispatch;
+	Oid		   *partition_oids;
 	ResultRelInfo **partitions;
 	int			num_partitions;
 	TupleConversionMap **parent_child_tupconv_maps;
@@ -103,12 +105,15 @@ typedef struct PartitionTupleRouting
 } PartitionTupleRouting;
 
 extern PartitionTupleRouting *ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
-							   Relation rel, Index resultRTindex,
-							   EState *estate);
+							   Relation rel);
 extern int ExecFindPartition(ResultRelInfo *resultRelInfo,
 				  PartitionDispatch *pd,
 				  TupleTableSlot *slot,
 				  EState *estate);
+extern ResultRelInfo *ExecInitPartitionInfo(ModifyTableState *mtstate,
+					ResultRelInfo *resultRelInfo,
+					PartitionTupleRouting *proute,
+					EState *estate, int partidx);
 extern void ExecSetupChildParentMapForLeaf(PartitionTupleRouting *proute);
 extern TupleConversionMap *TupConvMapForLeaf(PartitionTupleRouting *proute,
 				  ResultRelInfo *rootRelInfo, int leaf_index);
-- 
2.11.0

From 03c0f265537fc618d5f0de2c7b7e487b89af014d Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Tue, 19 Dec 2017 16:20:09 +0900
Subject: [PATCH v10] During tuple-routing, initialize per-partition objects
 lazily

Those objects include ResultRelInfo, tuple conversion map,
WITH CHECK OPTION quals and RETURNING projections.

This means we don't allocate these objects for partitions that are
never inserted into.
---
 src/backend/commands/copy.c            |  10 +-
 src/backend/executor/execPartition.c   | 309 ++++++++++++++++++++++++---------
 src/backend/executor/nodeModifyTable.c | 131 ++------------
 src/include/executor/execPartition.h   |   9 +-
 4 files changed, 252 insertions(+), 207 deletions(-)

diff --git a/src/backend/commands/copy.c b/src/backend/commands/copy.c
index b3933df9af..118452b602 100644
--- a/src/backend/commands/copy.c
+++ b/src/backend/commands/copy.c
@@ -2470,7 +2470,7 @@ CopyFrom(CopyState cstate)
 		PartitionTupleRouting *proute;
 
 		proute = cstate->partition_tuple_routing =
-			ExecSetupPartitionTupleRouting(NULL, cstate->rel, 1, estate);
+			ExecSetupPartitionTupleRouting(NULL, cstate->rel);
 
 		/*
 		 * If we are capturing transition tuples, they may need to be
@@ -2607,6 +2607,14 @@ CopyFrom(CopyState cstate)
 			 */
 			saved_resultRelInfo = resultRelInfo;
 			resultRelInfo = proute->partitions[leaf_part_index];
+			if (resultRelInfo == NULL)
+			{
+				resultRelInfo = ExecInitPartitionInfo(NULL,
+													  saved_resultRelInfo,
+													  proute, estate,
+													  leaf_part_index);
+				Assert(resultRelInfo != NULL);
+			}
 
 			/* We do not yet have a way to insert into a foreign partition */
 			if (resultRelInfo->ri_FdwRoutine)
diff --git a/src/backend/executor/execPartition.c b/src/backend/executor/execPartition.c
index 4048c3ebc6..dfad50fb11 100644
--- a/src/backend/executor/execPartition.c
+++ b/src/backend/executor/execPartition.c
@@ -44,18 +44,23 @@ static char *ExecBuildSlotPartitionKeyDescription(Relation rel,
  *
  * Note that all the relations in the partition tree are locked using the
  * RowExclusiveLock mode upon return from this function.
+ *
+ * While we allocate the arrays of pointers of ResultRelInfo and
+ * TupleConversionMap for all partitions here, actual objects themselves are
+ * lazily allocated for a given partition if a tuple is actually routed to it;
+ * see ExecInitPartitionInfo.  However, if the function is invoked for update
+ * tuple routing, caller would already have initialized ResultRelInfo's for
+ * some of the partitions, which are reused and assigned to their respective
+ * slot in the aforementioned array.
  */
 PartitionTupleRouting *
-ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
-							   Relation rel, Index resultRTindex,
-							   EState *estate)
+ExecSetupPartitionTupleRouting(ModifyTableState *mtstate, Relation rel)
 {
 	TupleDesc	tupDesc = RelationGetDescr(rel);
 	List	   *leaf_parts;
 	ListCell   *cell;
 	int			i;
-	ResultRelInfo *leaf_part_arr = NULL,
-			   *update_rri = NULL;
+	ResultRelInfo *update_rri = NULL;
 	int			num_update_rri = 0,
 				update_rri_index = 0;
 	bool		is_update = false;
@@ -76,6 +81,8 @@ ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
 	proute->parent_child_tupconv_maps =
 		(TupleConversionMap **) palloc0(proute->num_partitions *
 										sizeof(TupleConversionMap *));
+	proute->partition_oids = (Oid *) palloc(proute->num_partitions *
+											sizeof(Oid));
 
 	/* Set up details specific to the type of tuple routing we are doing. */
 	if (mtstate && mtstate->operation == CMD_UPDATE)
@@ -95,16 +102,6 @@ ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
 		 */
 		proute->root_tuple_slot = MakeTupleTableSlot();
 	}
-	else
-	{
-		/*
-		 * Since we are inserting tuples, we need to create all new result
-		 * rels. Avoid repeated pallocs by allocating memory for all the
-		 * result rels in bulk.
-		 */
-		leaf_part_arr = (ResultRelInfo *) palloc0(proute->num_partitions *
-												  sizeof(ResultRelInfo));
-	}
 
 	/*
 	 * Initialize an empty slot that will be used to manipulate tuples of any
@@ -117,11 +114,10 @@ ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
 	i = 0;
 	foreach(cell, leaf_parts)
 	{
-		ResultRelInfo *leaf_part_rri;
-		Relation	partrel = NULL;
-		TupleDesc	part_tupdesc;
+		ResultRelInfo *leaf_part_rri = NULL;
 		Oid			leaf_oid = lfirst_oid(cell);
 
+		proute->partition_oids[i] = leaf_oid;
 		if (is_update)
 		{
 			/*
@@ -136,6 +132,9 @@ ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
 			if (update_rri_index < num_update_rri &&
 				RelationGetRelid(update_rri[update_rri_index].ri_RelationDesc) == leaf_oid)
 			{
+				Relation	partrel;
+				TupleDesc	part_tupdesc;
+
 				leaf_part_rri = &update_rri[update_rri_index];
 				partrel = leaf_part_rri->ri_RelationDesc;
 
@@ -151,73 +150,26 @@ ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
 				proute->subplan_partition_offsets[update_rri_index] = i;
 
 				update_rri_index++;
+
+				part_tupdesc = RelationGetDescr(partrel);
+
+				/*
+				 * Save a tuple conversion map to convert a tuple routed to
+				 * this partition from the parent's type to the partition's.
+				 */
+				proute->parent_child_tupconv_maps[i] =
+					convert_tuples_by_name(tupDesc, part_tupdesc,
+							   gettext_noop("could not convert row type"));
+
+				/*
+				 * Verify result relation is a valid target for an INSERT.  An
+				 * UPDATE of a partition-key becomes a DELETE+INSERT operation,
+				 * so this check is required even when the operation is
+				 * CMD_UPDATE.
+				 */
+				CheckValidResultRel(leaf_part_rri, CMD_INSERT);
 			}
-			else
-				leaf_part_rri = (ResultRelInfo *) palloc0(sizeof(ResultRelInfo));
 		}
-		else
-		{
-			/* For INSERTs, we already have an array of result rels allocated */
-			leaf_part_rri = &leaf_part_arr[i];
-		}
-
-		/*
-		 * If we didn't open the partition rel, it means we haven't
-		 * initialized the result rel either.
-		 */
-		if (!partrel)
-		{
-			/*
-			 * We locked all the partitions above including the leaf
-			 * partitions. Note that each of the newly opened relations in
-			 * proute->partitions are eventually closed by the caller.
-			 */
-			partrel = heap_open(leaf_oid, NoLock);
-			InitResultRelInfo(leaf_part_rri,
-							  partrel,
-							  resultRTindex,
-							  rel,
-							  estate->es_instrument);
-
-			/*
-			 * Since we've just initialized this ResultRelInfo, it's not in
-			 * any list attached to the estate as yet.  Add it, so that it can
-			 * be found later.
-			 */
-			estate->es_tuple_routing_result_relations =
-						lappend(estate->es_tuple_routing_result_relations,
-								leaf_part_rri);
-		}
-
-		part_tupdesc = RelationGetDescr(partrel);
-
-		/*
-		 * Save a tuple conversion map to convert a tuple routed to this
-		 * partition from the parent's type to the partition's.
-		 */
-		proute->parent_child_tupconv_maps[i] =
-			convert_tuples_by_name(tupDesc, part_tupdesc,
-								   gettext_noop("could not convert row type"));
-
-		/*
-		 * Verify result relation is a valid target for an INSERT.  An UPDATE
-		 * of a partition-key becomes a DELETE+INSERT operation, so this check
-		 * is still required when the operation is CMD_UPDATE.
-		 */
-		CheckValidResultRel(leaf_part_rri, CMD_INSERT);
-
-		/*
-		 * Open partition indices.  The user may have asked to check for
-		 * conflicts within this leaf partition and do "nothing" instead of
-		 * throwing an error.  Be prepared in that case by initializing the
-		 * index information needed by ExecInsert() to perform speculative
-		 * insertions.
-		 */
-		if (leaf_part_rri->ri_RelationDesc->rd_rel->relhasindex &&
-			leaf_part_rri->ri_IndexRelationDescs == NULL)
-			ExecOpenIndices(leaf_part_rri,
-							mtstate != NULL &&
-							mtstate->mt_onconflict != ONCONFLICT_NONE);
 
 		proute->partitions[i] = leaf_part_rri;
 		i++;
@@ -352,6 +304,193 @@ ExecFindPartition(ResultRelInfo *resultRelInfo, PartitionDispatch *pd,
 }
 
 /*
+ * ExecInitPartitionInfo
+ *		Initialize ResultRelInfo and other information for a partition if not
+ *		already done
+ *
+ * Returns the ResultRelInfo
+ */
+ResultRelInfo *
+ExecInitPartitionInfo(ModifyTableState *mtstate,
+					  ResultRelInfo *resultRelInfo,
+					  PartitionTupleRouting *proute,
+					  EState *estate, int partidx)
+{
+	Relation	rootrel = resultRelInfo->ri_RelationDesc,
+				partrel;
+	ResultRelInfo *leaf_part_rri;
+	ModifyTable *node = mtstate ? (ModifyTable *) mtstate->ps.plan : NULL;
+
+	/*
+	 * We locked all the partitions in ExecSetupPartitionTupleRouting
+	 * including the leaf partitions.
+	 */
+	partrel = heap_open(proute->partition_oids[partidx], NoLock);
+	leaf_part_rri = (ResultRelInfo *) palloc0(sizeof(ResultRelInfo));
+	InitResultRelInfo(leaf_part_rri,
+					  partrel,
+					  node ? node->nominalRelation : 1,
+					  rootrel,
+					  estate->es_instrument);
+
+	/*
+	 * Verify result relation is a valid target for an INSERT.  An UPDATE
+	 * of a partition-key becomes a DELETE+INSERT operation, so this check
+	 * is still required when the operation is CMD_UPDATE.
+	 */
+	CheckValidResultRel(leaf_part_rri, CMD_INSERT);
+
+	/*
+	 * Since we've just initialized this ResultRelInfo, it's not in
+	 * any list attached to the estate as yet.  Add it, so that it can
+	 * be found later.
+	 *
+	 * Note that the entries in this list appear in no predetermined
+	 * order, because partition result rels are initialized as and when
+	 * they're needed.
+	 */
+	estate->es_tuple_routing_result_relations =
+					lappend(estate->es_tuple_routing_result_relations,
+							leaf_part_rri);
+
+	/*
+	 * Open partition indices.  The user may have asked to check for
+	 * conflicts within this leaf partition and do "nothing" instead of
+	 * throwing an error.  Be prepared in that case by initializing the
+	 * index information needed by ExecInsert() to perform speculative
+	 * insertions.
+	 */
+	if (partrel->rd_rel->relhasindex &&
+		leaf_part_rri->ri_IndexRelationDescs == NULL)
+		ExecOpenIndices(leaf_part_rri,
+						(mtstate != NULL &&
+						 mtstate->mt_onconflict != ONCONFLICT_NONE));
+
+	/*
+	 * Build WITH CHECK OPTION constraints for the partition.  Note that we
+	 * didn't build the withCheckOptionList for partitions within the planner,
+	 * but simple translation of varattnos will suffice.  This only occurs for
+	 * the INSERT case or in the case of UPDATE tuple routing where we didn't
+	 * find a result rel to reuse in ExecSetupPartitionTupleRouting().
+	 */
+	if (node && node->withCheckOptionLists != NIL)
+	{
+		List	   *wcoList;
+		List	   *wcoExprs = NIL;
+		ListCell   *ll;
+		int		firstVarno = mtstate->resultRelInfo[0].ri_RangeTableIndex;
+		Relation firstResultRel = mtstate->resultRelInfo[0].ri_RelationDesc;
+
+		/*
+		 * In the case of INSERT on partitioned tables, there is only one
+		 * plan.  Likewise, there is only one WCO list, not one per
+		 * partition.  For UPDATE, there would be as many WCO lists as
+		 * there are plans, but we use the first one as reference.
+		 */
+		Assert((node->operation == CMD_INSERT &&
+				list_length(node->withCheckOptionLists) == 1 &&
+				list_length(node->plans) == 1) ||
+			   (node->operation == CMD_UPDATE &&
+				list_length(node->withCheckOptionLists) ==
+				list_length(node->plans)));
+
+		/*
+		 * Use the WITH CHECK OPTIONS list of the first resultRelInfo as a
+		 * reference to calculate attno's for the returning expression of
+		 * this partition.  In the INSERT case, that refers to the root
+		 * partitioned table, whereas in the UPDATE tuple routing case the
+		 * first partition in the mtstate->resultRelInfo array.  In any case,
+		 * both that relation and this partition should have the same columns,
+		 * so we should be able to map attributes successfully.
+		 */
+		wcoList = linitial(node->withCheckOptionLists);
+
+		/*
+		 * Convert Vars in it to contain this partition's attribute numbers.
+		 */
+		wcoList = map_partition_varattnos(wcoList, firstVarno,
+										  partrel, firstResultRel, NULL);
+		foreach(ll, wcoList)
+		{
+			WithCheckOption *wco = castNode(WithCheckOption, lfirst(ll));
+			ExprState  *wcoExpr = ExecInitQual(castNode(List, wco->qual),
+											   mtstate->mt_plans[0]);
+			wcoExprs = lappend(wcoExprs, wcoExpr);
+		}
+
+		leaf_part_rri->ri_WithCheckOptions = wcoList;
+		leaf_part_rri->ri_WithCheckOptionExprs = wcoExprs;
+	}
+
+	/*
+	 * Build the RETURNING projection for the partition.  Note that we didn't
+	 * build the returningList for partitions within the planner, but simple
+	 * translation of varattnos will suffice.  This only occurs for the INSERT
+	 * case or in the case of UPDATE tuple routing where we didn't find a
+	 * result rel to reuse in ExecSetupPartitionTupleRouting().
+	 */
+	if (node && node->returningLists != NIL)
+	{
+		TupleTableSlot *slot;
+		ExprContext *econtext;
+		List	   *returningList;
+		int		firstVarno = mtstate->resultRelInfo[0].ri_RangeTableIndex;
+		Relation firstResultRel = mtstate->resultRelInfo[0].ri_RelationDesc;
+
+		/* See the comment written above for WCO lists. */
+		Assert((node->operation == CMD_INSERT &&
+				list_length(node->returningLists) == 1 &&
+				list_length(node->plans) == 1) ||
+			   (node->operation == CMD_UPDATE &&
+				list_length(node->returningLists) ==
+				list_length(node->plans)));
+
+		/*
+		 * Use the returning expression of the first resultRelInfo as a
+		 * reference to calculate attno's for the returning expression of
+		 * each of the partitions.  See the comment above for WCO list for
+		 * more details on why this is okay.
+		 */
+		returningList = linitial(node->returningLists);
+
+		/*
+		 * Converti Vars in it to contain this partition's attribute numbers.
+		 */
+		returningList = map_partition_varattnos(returningList, firstVarno,
+												partrel, firstResultRel,
+												NULL);
+
+		/*
+		 * Initialize the projection itself.
+		 *
+		 * Use the slot and the expression context that would have been set up
+		 * in ExecInitModifyTable() for projection's output.
+		 */
+		Assert(mtstate->ps.ps_ResultTupleSlot != NULL);
+		slot = mtstate->ps.ps_ResultTupleSlot;
+		Assert(mtstate->ps.ps_ExprContext != NULL);
+		econtext = mtstate->ps.ps_ExprContext;
+		leaf_part_rri->ri_projectReturning =
+			ExecBuildProjectionInfo(returningList, econtext, slot,
+									&mtstate->ps, RelationGetDescr(partrel));
+	}
+
+	Assert (proute->partitions[partidx] == NULL);
+	proute->partitions[partidx] = leaf_part_rri;
+
+	/*
+	 * Save a tuple conversion map to convert a tuple routed to this
+	 * partition from the parent's type to the partition's.
+	 */
+	proute->parent_child_tupconv_maps[partidx] =
+							convert_tuples_by_name(RelationGetDescr(rootrel),
+												   RelationGetDescr(partrel),
+											   gettext_noop("could not convert row type"));
+
+	return leaf_part_rri;
+}
+
+/*
  * ExecSetupChildParentMapForLeaf -- Initialize the per-leaf-partition
  * child-to-root tuple conversion map array.
  *
@@ -477,6 +616,10 @@ ExecCleanupTupleRouting(PartitionTupleRouting *proute)
 	{
 		ResultRelInfo *resultRelInfo = proute->partitions[i];
 
+		/* skip further processsing for uninitialized partitions */
+		if (resultRelInfo == NULL)
+			continue;
+
 		/*
 		 * If this result rel is one of the UPDATE subplan result rels, let
 		 * ExecEndPlan() close it. For INSERT or COPY,
diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c
index 2a8ecbd830..36e2041755 100644
--- a/src/backend/executor/nodeModifyTable.c
+++ b/src/backend/executor/nodeModifyTable.c
@@ -310,6 +310,14 @@ ExecInsert(ModifyTableState *mtstate,
 		 */
 		saved_resultRelInfo = resultRelInfo;
 		resultRelInfo = proute->partitions[leaf_part_index];
+		if (resultRelInfo == NULL)
+		{
+			resultRelInfo = ExecInitPartitionInfo(mtstate,
+												  saved_resultRelInfo,
+												  proute, estate,
+												  leaf_part_index);
+			Assert(resultRelInfo != NULL);
+		}
 
 		/* We do not yet have a way to insert into a foreign partition */
 		if (resultRelInfo->ri_FdwRoutine)
@@ -2098,14 +2106,10 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 	ResultRelInfo *saved_resultRelInfo;
 	ResultRelInfo *resultRelInfo;
 	Plan	   *subplan;
-	int			firstVarno = 0;
-	Relation	firstResultRel = NULL;
 	ListCell   *l;
 	int			i;
 	Relation	rel;
 	bool		update_tuple_routing_needed = node->partColsUpdated;
-	PartitionTupleRouting *proute = NULL;
-	int			num_partitions = 0;
 
 	/* check for unsupported flags */
 	Assert(!(eflags & (EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK)));
@@ -2228,20 +2232,8 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 	 */
 	if (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE &&
 		(operation == CMD_INSERT || update_tuple_routing_needed))
-	{
-		proute = mtstate->mt_partition_tuple_routing =
-			ExecSetupPartitionTupleRouting(mtstate,
-										   rel, node->nominalRelation,
-										   estate);
-		num_partitions = proute->num_partitions;
-
-		/*
-		 * Below are required as reference objects for mapping partition
-		 * attno's in expressions such as WithCheckOptions and RETURNING.
-		 */
-		firstVarno = mtstate->resultRelInfo[0].ri_RangeTableIndex;
-		firstResultRel = mtstate->resultRelInfo[0].ri_RelationDesc;
-	}
+		mtstate->mt_partition_tuple_routing =
+						ExecSetupPartitionTupleRouting(mtstate, rel);
 
 	/*
 	 * Build state for collecting transition tuples.  This requires having a
@@ -2288,77 +2280,12 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 	}
 
 	/*
-	 * Build WITH CHECK OPTION constraints for each leaf partition rel. Note
-	 * that we didn't build the withCheckOptionList for each partition within
-	 * the planner, but simple translation of the varattnos for each partition
-	 * will suffice.  This only occurs for the INSERT case or for UPDATE row
-	 * movement. DELETEs and local UPDATEs are handled above.
-	 */
-	if (node->withCheckOptionLists != NIL && num_partitions > 0)
-	{
-		List	   *first_wcoList;
-
-		/*
-		 * In case of INSERT on partitioned tables, there is only one plan.
-		 * Likewise, there is only one WITH CHECK OPTIONS list, not one per
-		 * partition. Whereas for UPDATE, there are as many WCOs as there are
-		 * plans. So in either case, use the WCO expression of the first
-		 * resultRelInfo as a reference to calculate attno's for the WCO
-		 * expression of each of the partitions. We make a copy of the WCO
-		 * qual for each partition. Note that, if there are SubPlans in there,
-		 * they all end up attached to the one parent Plan node.
-		 */
-		Assert(update_tuple_routing_needed ||
-			   (operation == CMD_INSERT &&
-				list_length(node->withCheckOptionLists) == 1 &&
-				mtstate->mt_nplans == 1));
-
-		first_wcoList = linitial(node->withCheckOptionLists);
-		for (i = 0; i < num_partitions; i++)
-		{
-			Relation	partrel;
-			List	   *mapped_wcoList;
-			List	   *wcoExprs = NIL;
-			ListCell   *ll;
-
-			resultRelInfo = proute->partitions[i];
-
-			/*
-			 * If we are referring to a resultRelInfo from one of the update
-			 * result rels, that result rel would already have
-			 * WithCheckOptions initialized.
-			 */
-			if (resultRelInfo->ri_WithCheckOptions)
-				continue;
-
-			partrel = resultRelInfo->ri_RelationDesc;
-
-			mapped_wcoList = map_partition_varattnos(first_wcoList,
-													 firstVarno,
-													 partrel, firstResultRel,
-													 NULL);
-			foreach(ll, mapped_wcoList)
-			{
-				WithCheckOption *wco = castNode(WithCheckOption, lfirst(ll));
-				ExprState  *wcoExpr = ExecInitQual(castNode(List, wco->qual),
-												   &mtstate->ps);
-
-				wcoExprs = lappend(wcoExprs, wcoExpr);
-			}
-
-			resultRelInfo->ri_WithCheckOptions = mapped_wcoList;
-			resultRelInfo->ri_WithCheckOptionExprs = wcoExprs;
-		}
-	}
-
-	/*
 	 * Initialize RETURNING projections if needed.
 	 */
 	if (node->returningLists)
 	{
 		TupleTableSlot *slot;
 		ExprContext *econtext;
-		List	   *firstReturningList;
 
 		/*
 		 * Initialize result tuple slot and assign its rowtype using the first
@@ -2389,44 +2316,6 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 										resultRelInfo->ri_RelationDesc->rd_att);
 			resultRelInfo++;
 		}
-
-		/*
-		 * Build a projection for each leaf partition rel.  Note that we
-		 * didn't build the returningList for each partition within the
-		 * planner, but simple translation of the varattnos for each partition
-		 * will suffice.  This only occurs for the INSERT case or for UPDATE
-		 * row movement. DELETEs and local UPDATEs are handled above.
-		 */
-		firstReturningList = linitial(node->returningLists);
-		for (i = 0; i < num_partitions; i++)
-		{
-			Relation	partrel;
-			List	   *rlist;
-
-			resultRelInfo = proute->partitions[i];
-
-			/*
-			 * If we are referring to a resultRelInfo from one of the update
-			 * result rels, that result rel would already have a returningList
-			 * built.
-			 */
-			if (resultRelInfo->ri_projectReturning)
-				continue;
-
-			partrel = resultRelInfo->ri_RelationDesc;
-
-			/*
-			 * Use the returning expression of the first resultRelInfo as a
-			 * reference to calculate attno's for the returning expression of
-			 * each of the partitions.
-			 */
-			rlist = map_partition_varattnos(firstReturningList,
-											firstVarno,
-											partrel, firstResultRel, NULL);
-			resultRelInfo->ri_projectReturning =
-				ExecBuildProjectionInfo(rlist, econtext, slot, &mtstate->ps,
-										resultRelInfo->ri_RelationDesc->rd_att);
-		}
 	}
 	else
 	{
diff --git a/src/include/executor/execPartition.h b/src/include/executor/execPartition.h
index 3df9c498bb..e94718608f 100644
--- a/src/include/executor/execPartition.h
+++ b/src/include/executor/execPartition.h
@@ -58,6 +58,7 @@ typedef struct PartitionDispatchData *PartitionDispatch;
  *								partition tree.
  * num_dispatch					number of partitioned tables in the partition
  *								tree (= length of partition_dispatch_info[])
+ * partition_oids				Array of leaf partitions OIDs
  * partitions					Array of ResultRelInfo* objects with one entry
  *								for every leaf partition in the partition tree.
  * num_partitions				Number of leaf partitions in the partition tree
@@ -91,6 +92,7 @@ typedef struct PartitionTupleRouting
 {
 	PartitionDispatch *partition_dispatch_info;
 	int			num_dispatch;
+	Oid		   *partition_oids;
 	ResultRelInfo **partitions;
 	int			num_partitions;
 	TupleConversionMap **parent_child_tupconv_maps;
@@ -103,12 +105,15 @@ typedef struct PartitionTupleRouting
 } PartitionTupleRouting;
 
 extern PartitionTupleRouting *ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
-							   Relation rel, Index resultRTindex,
-							   EState *estate);
+							   Relation rel);
 extern int ExecFindPartition(ResultRelInfo *resultRelInfo,
 				  PartitionDispatch *pd,
 				  TupleTableSlot *slot,
 				  EState *estate);
+extern ResultRelInfo *ExecInitPartitionInfo(ModifyTableState *mtstate,
+					ResultRelInfo *resultRelInfo,
+					PartitionTupleRouting *proute,
+					EState *estate, int partidx);
 extern void ExecSetupChildParentMapForLeaf(PartitionTupleRouting *proute);
 extern TupleConversionMap *TupConvMapForLeaf(PartitionTupleRouting *proute,
 				  ResultRelInfo *rootRelInfo, int leaf_index);
-- 
2.11.0

diff --git a/src/backend/commands/copy.c b/src/backend/commands/copy.c
index b3933df..118452b 100644
--- a/src/backend/commands/copy.c
+++ b/src/backend/commands/copy.c
@@ -2470,7 +2470,7 @@ CopyFrom(CopyState cstate)
 		PartitionTupleRouting *proute;
 
 		proute = cstate->partition_tuple_routing =
-			ExecSetupPartitionTupleRouting(NULL, cstate->rel, 1, estate);
+			ExecSetupPartitionTupleRouting(NULL, cstate->rel);
 
 		/*
 		 * If we are capturing transition tuples, they may need to be
@@ -2607,6 +2607,14 @@ CopyFrom(CopyState cstate)
 			 */
 			saved_resultRelInfo = resultRelInfo;
 			resultRelInfo = proute->partitions[leaf_part_index];
+			if (resultRelInfo == NULL)
+			{
+				resultRelInfo = ExecInitPartitionInfo(NULL,
+													  saved_resultRelInfo,
+													  proute, estate,
+													  leaf_part_index);
+				Assert(resultRelInfo != NULL);
+			}
 
 			/* We do not yet have a way to insert into a foreign partition */
 			if (resultRelInfo->ri_FdwRoutine)
diff --git a/src/backend/executor/execPartition.c b/src/backend/executor/execPartition.c
index 4048c3e..06a7607 100644
--- a/src/backend/executor/execPartition.c
+++ b/src/backend/executor/execPartition.c
@@ -44,18 +44,23 @@ static char *ExecBuildSlotPartitionKeyDescription(Relation rel,
  *
  * Note that all the relations in the partition tree are locked using the
  * RowExclusiveLock mode upon return from this function.
+ *
+ * While we allocate the arrays of pointers of ResultRelInfo and
+ * TupleConversionMap for all partitions here, actual objects themselves are
+ * lazily allocated for a given partition if a tuple is actually routed to it;
+ * see ExecInitPartitionInfo.  However, if the function is invoked for update
+ * tuple routing, caller would already have initialized ResultRelInfo's for
+ * some of the partitions, which are reused and assigned to their respective
+ * slot in the aforementioned array.
  */
 PartitionTupleRouting *
-ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
-							   Relation rel, Index resultRTindex,
-							   EState *estate)
+ExecSetupPartitionTupleRouting(ModifyTableState *mtstate, Relation rel)
 {
 	TupleDesc	tupDesc = RelationGetDescr(rel);
 	List	   *leaf_parts;
 	ListCell   *cell;
 	int			i;
-	ResultRelInfo *leaf_part_arr = NULL,
-			   *update_rri = NULL;
+	ResultRelInfo *update_rri = NULL;
 	int			num_update_rri = 0,
 				update_rri_index = 0;
 	bool		is_update = false;
@@ -76,6 +81,8 @@ ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
 	proute->parent_child_tupconv_maps =
 		(TupleConversionMap **) palloc0(proute->num_partitions *
 										sizeof(TupleConversionMap *));
+	proute->partition_oids = (Oid *) palloc(proute->num_partitions *
+											sizeof(Oid));
 
 	/* Set up details specific to the type of tuple routing we are doing. */
 	if (mtstate && mtstate->operation == CMD_UPDATE)
@@ -95,16 +102,6 @@ ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
 		 */
 		proute->root_tuple_slot = MakeTupleTableSlot();
 	}
-	else
-	{
-		/*
-		 * Since we are inserting tuples, we need to create all new result
-		 * rels. Avoid repeated pallocs by allocating memory for all the
-		 * result rels in bulk.
-		 */
-		leaf_part_arr = (ResultRelInfo *) palloc0(proute->num_partitions *
-												  sizeof(ResultRelInfo));
-	}
 
 	/*
 	 * Initialize an empty slot that will be used to manipulate tuples of any
@@ -117,11 +114,10 @@ ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
 	i = 0;
 	foreach(cell, leaf_parts)
 	{
-		ResultRelInfo *leaf_part_rri;
-		Relation	partrel = NULL;
-		TupleDesc	part_tupdesc;
+		ResultRelInfo *leaf_part_rri = NULL;
 		Oid			leaf_oid = lfirst_oid(cell);
 
+		proute->partition_oids[i] = leaf_oid;
 		if (is_update)
 		{
 			/*
@@ -136,6 +132,9 @@ ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
 			if (update_rri_index < num_update_rri &&
 				RelationGetRelid(update_rri[update_rri_index].ri_RelationDesc) == leaf_oid)
 			{
+				Relation	partrel;
+				TupleDesc	part_tupdesc;
+
 				leaf_part_rri = &update_rri[update_rri_index];
 				partrel = leaf_part_rri->ri_RelationDesc;
 
@@ -151,73 +150,26 @@ ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
 				proute->subplan_partition_offsets[update_rri_index] = i;
 
 				update_rri_index++;
-			}
-			else
-				leaf_part_rri = (ResultRelInfo *) palloc0(sizeof(ResultRelInfo));
-		}
-		else
-		{
-			/* For INSERTs, we already have an array of result rels allocated */
-			leaf_part_rri = &leaf_part_arr[i];
-		}
 
-		/*
-		 * If we didn't open the partition rel, it means we haven't
-		 * initialized the result rel either.
-		 */
-		if (!partrel)
-		{
-			/*
-			 * We locked all the partitions above including the leaf
-			 * partitions. Note that each of the newly opened relations in
-			 * proute->partitions are eventually closed by the caller.
-			 */
-			partrel = heap_open(leaf_oid, NoLock);
-			InitResultRelInfo(leaf_part_rri,
-							  partrel,
-							  resultRTindex,
-							  rel,
-							  estate->es_instrument);
-
-			/*
-			 * Since we've just initialized this ResultRelInfo, it's not in
-			 * any list attached to the estate as yet.  Add it, so that it can
-			 * be found later.
-			 */
-			estate->es_tuple_routing_result_relations =
-						lappend(estate->es_tuple_routing_result_relations,
-								leaf_part_rri);
-		}
+				part_tupdesc = RelationGetDescr(partrel);
 
-		part_tupdesc = RelationGetDescr(partrel);
-
-		/*
-		 * Save a tuple conversion map to convert a tuple routed to this
-		 * partition from the parent's type to the partition's.
-		 */
-		proute->parent_child_tupconv_maps[i] =
-			convert_tuples_by_name(tupDesc, part_tupdesc,
-								   gettext_noop("could not convert row type"));
-
-		/*
-		 * Verify result relation is a valid target for an INSERT.  An UPDATE
-		 * of a partition-key becomes a DELETE+INSERT operation, so this check
-		 * is still required when the operation is CMD_UPDATE.
-		 */
-		CheckValidResultRel(leaf_part_rri, CMD_INSERT);
+				/*
+				 * Save a tuple conversion map to convert a tuple routed to
+				 * this partition from the parent's type to the partition's.
+				 */
+				proute->parent_child_tupconv_maps[i] =
+					convert_tuples_by_name(tupDesc, part_tupdesc,
+							   gettext_noop("could not convert row type"));
 
-		/*
-		 * Open partition indices.  The user may have asked to check for
-		 * conflicts within this leaf partition and do "nothing" instead of
-		 * throwing an error.  Be prepared in that case by initializing the
-		 * index information needed by ExecInsert() to perform speculative
-		 * insertions.
-		 */
-		if (leaf_part_rri->ri_RelationDesc->rd_rel->relhasindex &&
-			leaf_part_rri->ri_IndexRelationDescs == NULL)
-			ExecOpenIndices(leaf_part_rri,
-							mtstate != NULL &&
-							mtstate->mt_onconflict != ONCONFLICT_NONE);
+				/*
+				 * Verify result relation is a valid target for an INSERT.  An
+				 * UPDATE of a partition-key becomes a DELETE+INSERT operation,
+				 * so this check is required even when the operation is
+				 * CMD_UPDATE.
+				 */
+				CheckValidResultRel(leaf_part_rri, CMD_INSERT);
+			}
+		}
 
 		proute->partitions[i] = leaf_part_rri;
 		i++;
@@ -352,6 +304,193 @@ ExecFindPartition(ResultRelInfo *resultRelInfo, PartitionDispatch *pd,
 }
 
 /*
+ * ExecInitPartitionInfo
+ *		Initialize ResultRelInfo and other information for a partition if not
+ *		already done
+ *
+ * Returns the ResultRelInfo
+ */
+ResultRelInfo *
+ExecInitPartitionInfo(ModifyTableState *mtstate,
+					  ResultRelInfo *resultRelInfo,
+					  PartitionTupleRouting *proute,
+					  EState *estate, int partidx)
+{
+	Relation	rootrel = resultRelInfo->ri_RelationDesc,
+				partrel;
+	ResultRelInfo *leaf_part_rri;
+	ModifyTable *node = mtstate ? (ModifyTable *) mtstate->ps.plan : NULL;
+
+	/*
+	 * We locked all the partitions in ExecSetupPartitionTupleRouting
+	 * including the leaf partitions.
+	 */
+	partrel = heap_open(proute->partition_oids[partidx], NoLock);
+	leaf_part_rri = (ResultRelInfo *) palloc0(sizeof(ResultRelInfo));
+	InitResultRelInfo(leaf_part_rri,
+					  partrel,
+					  node ? node->nominalRelation : 1,
+					  rootrel,
+					  estate->es_instrument);
+
+	/*
+	 * Verify result relation is a valid target for an INSERT.  An UPDATE
+	 * of a partition-key becomes a DELETE+INSERT operation, so this check
+	 * is still required when the operation is CMD_UPDATE.
+	 */
+	CheckValidResultRel(leaf_part_rri, CMD_INSERT);
+
+	/*
+	 * Since we've just initialized this ResultRelInfo, it's not in
+	 * any list attached to the estate as yet.  Add it, so that it can
+	 * be found later.
+	 *
+	 * Note that the entries in this list appear in no predetermined
+	 * order, because partition result rels are initialized as and when
+	 * they're needed.
+	 */
+	estate->es_tuple_routing_result_relations =
+					lappend(estate->es_tuple_routing_result_relations,
+							leaf_part_rri);
+
+	/*
+	 * Open partition indices.  The user may have asked to check for
+	 * conflicts within this leaf partition and do "nothing" instead of
+	 * throwing an error.  Be prepared in that case by initializing the
+	 * index information needed by ExecInsert() to perform speculative
+	 * insertions.
+	 */
+	if (partrel->rd_rel->relhasindex &&
+		leaf_part_rri->ri_IndexRelationDescs == NULL)
+		ExecOpenIndices(leaf_part_rri,
+						(mtstate != NULL &&
+						 mtstate->mt_onconflict != ONCONFLICT_NONE));
+
+	/*
+	 * Build WITH CHECK OPTION constraints for the partition.  Note that we
+	 * didn't build the withCheckOptionList for partitions within the planner,
+	 * but simple translation of varattnos will suffice.  This only occurs for
+	 * the INSERT case or in the case of UPDATE tuple routing where we didn't
+	 * find a result rel to reuse in ExecSetupPartitionTupleRouting().
+	 */
+	if (node && node->withCheckOptionLists != NIL)
+	{
+		List	   *wcoList;
+		List	   *wcoExprs = NIL;
+		ListCell   *ll;
+		int		firstVarno = mtstate->resultRelInfo[0].ri_RangeTableIndex;
+		Relation firstResultRel = mtstate->resultRelInfo[0].ri_RelationDesc;
+
+		/*
+		 * In the case of INSERT on partitioned tables, there is only one
+		 * plan.  Likewise, there is only one WCO list, not one per
+		 * partition.  For UPDATE, there would be as many WCO lists as
+		 * there are plans.
+		 */
+		Assert((node->operation == CMD_INSERT &&
+				list_length(node->withCheckOptionLists) == 1 &&
+				list_length(node->plans) == 1) ||
+			   (node->operation == CMD_UPDATE &&
+				list_length(node->withCheckOptionLists) ==
+				list_length(node->plans)));
+
+		/*
+		 * Use the WCO list of the first plan as a reference to calculate
+		 * attno's for the WCO list of this partition.  In the INSERT case,
+		 * that refers to the root partitioned table, whereas in the UPDATE
+		 * tuple routing case, that refers to the first partition in the
+		 * mtstate->resultRelInfo array.  In any case, both that relation and
+		 * this partition should have the same columns, so we should be able
+		 * to map attributes successfully.
+		 */
+		wcoList = linitial(node->withCheckOptionLists);
+
+		/*
+		 * Convert Vars in it to contain this partition's attribute numbers.
+		 */
+		wcoList = map_partition_varattnos(wcoList, firstVarno,
+										  partrel, firstResultRel, NULL);
+		foreach(ll, wcoList)
+		{
+			WithCheckOption *wco = castNode(WithCheckOption, lfirst(ll));
+			ExprState  *wcoExpr = ExecInitQual(castNode(List, wco->qual),
+											   mtstate->mt_plans[0]);
+			wcoExprs = lappend(wcoExprs, wcoExpr);
+		}
+
+		leaf_part_rri->ri_WithCheckOptions = wcoList;
+		leaf_part_rri->ri_WithCheckOptionExprs = wcoExprs;
+	}
+
+	/*
+	 * Build the RETURNING projection for the partition.  Note that we didn't
+	 * build the returningList for partitions within the planner, but simple
+	 * translation of varattnos will suffice.  This only occurs for the INSERT
+	 * case or in the case of UPDATE tuple routing where we didn't find a
+	 * result rel to reuse in ExecSetupPartitionTupleRouting().
+	 */
+	if (node && node->returningLists != NIL)
+	{
+		TupleTableSlot *slot;
+		ExprContext *econtext;
+		List	   *returningList;
+		int		firstVarno = mtstate->resultRelInfo[0].ri_RangeTableIndex;
+		Relation firstResultRel = mtstate->resultRelInfo[0].ri_RelationDesc;
+
+		/* See the comment above for WCO lists. */
+		Assert((node->operation == CMD_INSERT &&
+				list_length(node->returningLists) == 1 &&
+				list_length(node->plans) == 1) ||
+			   (node->operation == CMD_UPDATE &&
+				list_length(node->returningLists) ==
+				list_length(node->plans)));
+
+		/*
+		 * Use the RETURNING list of the first plan as a reference to
+		 * calculate attno's for the RETURNING list of this partition.  See
+		 * the comment above for WCO lists for more details on why this is
+		 * okay.
+		 */
+		returningList = linitial(node->returningLists);
+
+		/*
+		 * Convert Vars in it to contain this partition's attribute numbers.
+		 */
+		returningList = map_partition_varattnos(returningList, firstVarno,
+												partrel, firstResultRel,
+												NULL);
+
+		/*
+		 * Initialize the projection itself.
+		 *
+		 * Use the slot and the expression context that would have been set up
+		 * in ExecInitModifyTable() for projection's output.
+		 */
+		Assert(mtstate->ps.ps_ResultTupleSlot != NULL);
+		slot = mtstate->ps.ps_ResultTupleSlot;
+		Assert(mtstate->ps.ps_ExprContext != NULL);
+		econtext = mtstate->ps.ps_ExprContext;
+		leaf_part_rri->ri_projectReturning =
+			ExecBuildProjectionInfo(returningList, econtext, slot,
+									&mtstate->ps, RelationGetDescr(partrel));
+	}
+
+	Assert (proute->partitions[partidx] == NULL);
+	proute->partitions[partidx] = leaf_part_rri;
+
+	/*
+	 * Save a tuple conversion map to convert a tuple routed to this
+	 * partition from the parent's type to the partition's.
+	 */
+	proute->parent_child_tupconv_maps[partidx] =
+							convert_tuples_by_name(RelationGetDescr(rootrel),
+												   RelationGetDescr(partrel),
+											   gettext_noop("could not convert row type"));
+
+	return leaf_part_rri;
+}
+
+/*
  * ExecSetupChildParentMapForLeaf -- Initialize the per-leaf-partition
  * child-to-root tuple conversion map array.
  *
@@ -477,6 +616,10 @@ ExecCleanupTupleRouting(PartitionTupleRouting *proute)
 	{
 		ResultRelInfo *resultRelInfo = proute->partitions[i];
 
+		/* skip further processsing for uninitialized partitions */
+		if (resultRelInfo == NULL)
+			continue;
+
 		/*
 		 * If this result rel is one of the UPDATE subplan result rels, let
 		 * ExecEndPlan() close it. For INSERT or COPY,
diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c
index 2a8ecbd..36e2041 100644
--- a/src/backend/executor/nodeModifyTable.c
+++ b/src/backend/executor/nodeModifyTable.c
@@ -310,6 +310,14 @@ ExecInsert(ModifyTableState *mtstate,
 		 */
 		saved_resultRelInfo = resultRelInfo;
 		resultRelInfo = proute->partitions[leaf_part_index];
+		if (resultRelInfo == NULL)
+		{
+			resultRelInfo = ExecInitPartitionInfo(mtstate,
+												  saved_resultRelInfo,
+												  proute, estate,
+												  leaf_part_index);
+			Assert(resultRelInfo != NULL);
+		}
 
 		/* We do not yet have a way to insert into a foreign partition */
 		if (resultRelInfo->ri_FdwRoutine)
@@ -2098,14 +2106,10 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 	ResultRelInfo *saved_resultRelInfo;
 	ResultRelInfo *resultRelInfo;
 	Plan	   *subplan;
-	int			firstVarno = 0;
-	Relation	firstResultRel = NULL;
 	ListCell   *l;
 	int			i;
 	Relation	rel;
 	bool		update_tuple_routing_needed = node->partColsUpdated;
-	PartitionTupleRouting *proute = NULL;
-	int			num_partitions = 0;
 
 	/* check for unsupported flags */
 	Assert(!(eflags & (EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK)));
@@ -2228,20 +2232,8 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 	 */
 	if (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE &&
 		(operation == CMD_INSERT || update_tuple_routing_needed))
-	{
-		proute = mtstate->mt_partition_tuple_routing =
-			ExecSetupPartitionTupleRouting(mtstate,
-										   rel, node->nominalRelation,
-										   estate);
-		num_partitions = proute->num_partitions;
-
-		/*
-		 * Below are required as reference objects for mapping partition
-		 * attno's in expressions such as WithCheckOptions and RETURNING.
-		 */
-		firstVarno = mtstate->resultRelInfo[0].ri_RangeTableIndex;
-		firstResultRel = mtstate->resultRelInfo[0].ri_RelationDesc;
-	}
+		mtstate->mt_partition_tuple_routing =
+						ExecSetupPartitionTupleRouting(mtstate, rel);
 
 	/*
 	 * Build state for collecting transition tuples.  This requires having a
@@ -2288,77 +2280,12 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 	}
 
 	/*
-	 * Build WITH CHECK OPTION constraints for each leaf partition rel. Note
-	 * that we didn't build the withCheckOptionList for each partition within
-	 * the planner, but simple translation of the varattnos for each partition
-	 * will suffice.  This only occurs for the INSERT case or for UPDATE row
-	 * movement. DELETEs and local UPDATEs are handled above.
-	 */
-	if (node->withCheckOptionLists != NIL && num_partitions > 0)
-	{
-		List	   *first_wcoList;
-
-		/*
-		 * In case of INSERT on partitioned tables, there is only one plan.
-		 * Likewise, there is only one WITH CHECK OPTIONS list, not one per
-		 * partition. Whereas for UPDATE, there are as many WCOs as there are
-		 * plans. So in either case, use the WCO expression of the first
-		 * resultRelInfo as a reference to calculate attno's for the WCO
-		 * expression of each of the partitions. We make a copy of the WCO
-		 * qual for each partition. Note that, if there are SubPlans in there,
-		 * they all end up attached to the one parent Plan node.
-		 */
-		Assert(update_tuple_routing_needed ||
-			   (operation == CMD_INSERT &&
-				list_length(node->withCheckOptionLists) == 1 &&
-				mtstate->mt_nplans == 1));
-
-		first_wcoList = linitial(node->withCheckOptionLists);
-		for (i = 0; i < num_partitions; i++)
-		{
-			Relation	partrel;
-			List	   *mapped_wcoList;
-			List	   *wcoExprs = NIL;
-			ListCell   *ll;
-
-			resultRelInfo = proute->partitions[i];
-
-			/*
-			 * If we are referring to a resultRelInfo from one of the update
-			 * result rels, that result rel would already have
-			 * WithCheckOptions initialized.
-			 */
-			if (resultRelInfo->ri_WithCheckOptions)
-				continue;
-
-			partrel = resultRelInfo->ri_RelationDesc;
-
-			mapped_wcoList = map_partition_varattnos(first_wcoList,
-													 firstVarno,
-													 partrel, firstResultRel,
-													 NULL);
-			foreach(ll, mapped_wcoList)
-			{
-				WithCheckOption *wco = castNode(WithCheckOption, lfirst(ll));
-				ExprState  *wcoExpr = ExecInitQual(castNode(List, wco->qual),
-												   &mtstate->ps);
-
-				wcoExprs = lappend(wcoExprs, wcoExpr);
-			}
-
-			resultRelInfo->ri_WithCheckOptions = mapped_wcoList;
-			resultRelInfo->ri_WithCheckOptionExprs = wcoExprs;
-		}
-	}
-
-	/*
 	 * Initialize RETURNING projections if needed.
 	 */
 	if (node->returningLists)
 	{
 		TupleTableSlot *slot;
 		ExprContext *econtext;
-		List	   *firstReturningList;
 
 		/*
 		 * Initialize result tuple slot and assign its rowtype using the first
@@ -2389,44 +2316,6 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 										resultRelInfo->ri_RelationDesc->rd_att);
 			resultRelInfo++;
 		}
-
-		/*
-		 * Build a projection for each leaf partition rel.  Note that we
-		 * didn't build the returningList for each partition within the
-		 * planner, but simple translation of the varattnos for each partition
-		 * will suffice.  This only occurs for the INSERT case or for UPDATE
-		 * row movement. DELETEs and local UPDATEs are handled above.
-		 */
-		firstReturningList = linitial(node->returningLists);
-		for (i = 0; i < num_partitions; i++)
-		{
-			Relation	partrel;
-			List	   *rlist;
-
-			resultRelInfo = proute->partitions[i];
-
-			/*
-			 * If we are referring to a resultRelInfo from one of the update
-			 * result rels, that result rel would already have a returningList
-			 * built.
-			 */
-			if (resultRelInfo->ri_projectReturning)
-				continue;
-
-			partrel = resultRelInfo->ri_RelationDesc;
-
-			/*
-			 * Use the returning expression of the first resultRelInfo as a
-			 * reference to calculate attno's for the returning expression of
-			 * each of the partitions.
-			 */
-			rlist = map_partition_varattnos(firstReturningList,
-											firstVarno,
-											partrel, firstResultRel, NULL);
-			resultRelInfo->ri_projectReturning =
-				ExecBuildProjectionInfo(rlist, econtext, slot, &mtstate->ps,
-										resultRelInfo->ri_RelationDesc->rd_att);
-		}
 	}
 	else
 	{
diff --git a/src/include/executor/execPartition.h b/src/include/executor/execPartition.h
index 3df9c49..e947186 100644
--- a/src/include/executor/execPartition.h
+++ b/src/include/executor/execPartition.h
@@ -58,6 +58,7 @@ typedef struct PartitionDispatchData *PartitionDispatch;
  *								partition tree.
  * num_dispatch					number of partitioned tables in the partition
  *								tree (= length of partition_dispatch_info[])
+ * partition_oids				Array of leaf partitions OIDs
  * partitions					Array of ResultRelInfo* objects with one entry
  *								for every leaf partition in the partition tree.
  * num_partitions				Number of leaf partitions in the partition tree
@@ -91,6 +92,7 @@ typedef struct PartitionTupleRouting
 {
 	PartitionDispatch *partition_dispatch_info;
 	int			num_dispatch;
+	Oid		   *partition_oids;
 	ResultRelInfo **partitions;
 	int			num_partitions;
 	TupleConversionMap **parent_child_tupconv_maps;
@@ -103,12 +105,15 @@ typedef struct PartitionTupleRouting
 } PartitionTupleRouting;
 
 extern PartitionTupleRouting *ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
-							   Relation rel, Index resultRTindex,
-							   EState *estate);
+							   Relation rel);
 extern int ExecFindPartition(ResultRelInfo *resultRelInfo,
 				  PartitionDispatch *pd,
 				  TupleTableSlot *slot,
 				  EState *estate);
+extern ResultRelInfo *ExecInitPartitionInfo(ModifyTableState *mtstate,
+					ResultRelInfo *resultRelInfo,
+					PartitionTupleRouting *proute,
+					EState *estate, int partidx);
 extern void ExecSetupChildParentMapForLeaf(PartitionTupleRouting *proute);
 extern TupleConversionMap *TupConvMapForLeaf(PartitionTupleRouting *proute,
 				  ResultRelInfo *rootRelInfo, int leaf_index);

From 20852fe6cc2f1b8bd57d8bae528083c9f8092dab Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Mon, 19 Feb 2018 13:15:44 +0900
Subject: [PATCH v11] During tuple-routing, initialize per-partition objects
 lazily

Those objects include ResultRelInfo, tuple conversion map,
WITH CHECK OPTION quals and RETURNING projections.

This means we don't allocate these objects for partitions that are
never inserted into.
---
 src/backend/commands/copy.c            |  10 +-
 src/backend/executor/execPartition.c   | 309 ++++++++++++++++++++++++---------
 src/backend/executor/nodeModifyTable.c | 131 ++------------
 src/include/executor/execPartition.h   |   9 +-
 4 files changed, 252 insertions(+), 207 deletions(-)

diff --git a/src/backend/commands/copy.c b/src/backend/commands/copy.c
index d5883c98d1..4562a5121d 100644
--- a/src/backend/commands/copy.c
+++ b/src/backend/commands/copy.c
@@ -2469,7 +2469,7 @@ CopyFrom(CopyState cstate)
 		PartitionTupleRouting *proute;
 
 		proute = cstate->partition_tuple_routing =
-			ExecSetupPartitionTupleRouting(NULL, cstate->rel, 1, estate);
+			ExecSetupPartitionTupleRouting(NULL, cstate->rel);
 
 		/*
 		 * If we are capturing transition tuples, they may need to be
@@ -2606,6 +2606,14 @@ CopyFrom(CopyState cstate)
 			 */
 			saved_resultRelInfo = resultRelInfo;
 			resultRelInfo = proute->partitions[leaf_part_index];
+			if (resultRelInfo == NULL)
+			{
+				resultRelInfo = ExecInitPartitionInfo(NULL,
+													  saved_resultRelInfo,
+													  proute, estate,
+													  leaf_part_index);
+				Assert(resultRelInfo != NULL);
+			}
 
 			/* We do not yet have a way to insert into a foreign partition */
 			if (resultRelInfo->ri_FdwRoutine)
diff --git a/src/backend/executor/execPartition.c b/src/backend/executor/execPartition.c
index 00523ce250..04f76b123a 100644
--- a/src/backend/executor/execPartition.c
+++ b/src/backend/executor/execPartition.c
@@ -44,18 +44,23 @@ static char *ExecBuildSlotPartitionKeyDescription(Relation rel,
  *
  * Note that all the relations in the partition tree are locked using the
  * RowExclusiveLock mode upon return from this function.
+ *
+ * While we allocate the arrays of pointers of ResultRelInfo and
+ * TupleConversionMap for all partitions here, actual objects themselves are
+ * lazily allocated for a given partition if a tuple is actually routed to it;
+ * see ExecInitPartitionInfo.  However, if the function is invoked for update
+ * tuple routing, caller would already have initialized ResultRelInfo's for
+ * some of the partitions, which are reused and assigned to their respective
+ * slot in the aforementioned array.
  */
 PartitionTupleRouting *
-ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
-							   Relation rel, Index resultRTindex,
-							   EState *estate)
+ExecSetupPartitionTupleRouting(ModifyTableState *mtstate, Relation rel)
 {
 	TupleDesc	tupDesc = RelationGetDescr(rel);
 	List	   *leaf_parts;
 	ListCell   *cell;
 	int			i;
-	ResultRelInfo *leaf_part_arr = NULL,
-			   *update_rri = NULL;
+	ResultRelInfo *update_rri = NULL;
 	int			num_update_rri = 0,
 				update_rri_index = 0;
 	bool		is_update = false;
@@ -76,6 +81,8 @@ ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
 	proute->parent_child_tupconv_maps =
 		(TupleConversionMap **) palloc0(proute->num_partitions *
 										sizeof(TupleConversionMap *));
+	proute->partition_oids = (Oid *) palloc(proute->num_partitions *
+											sizeof(Oid));
 
 	/* Set up details specific to the type of tuple routing we are doing. */
 	if (mtstate && mtstate->operation == CMD_UPDATE)
@@ -95,16 +102,6 @@ ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
 		 */
 		proute->root_tuple_slot = MakeTupleTableSlot(NULL);
 	}
-	else
-	{
-		/*
-		 * Since we are inserting tuples, we need to create all new result
-		 * rels. Avoid repeated pallocs by allocating memory for all the
-		 * result rels in bulk.
-		 */
-		leaf_part_arr = (ResultRelInfo *) palloc0(proute->num_partitions *
-												  sizeof(ResultRelInfo));
-	}
 
 	/*
 	 * Initialize an empty slot that will be used to manipulate tuples of any
@@ -117,11 +114,10 @@ ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
 	i = 0;
 	foreach(cell, leaf_parts)
 	{
-		ResultRelInfo *leaf_part_rri;
-		Relation	partrel = NULL;
-		TupleDesc	part_tupdesc;
+		ResultRelInfo *leaf_part_rri = NULL;
 		Oid			leaf_oid = lfirst_oid(cell);
 
+		proute->partition_oids[i] = leaf_oid;
 		if (is_update)
 		{
 			/*
@@ -136,6 +132,9 @@ ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
 			if (update_rri_index < num_update_rri &&
 				RelationGetRelid(update_rri[update_rri_index].ri_RelationDesc) == leaf_oid)
 			{
+				Relation	partrel;
+				TupleDesc	part_tupdesc;
+
 				leaf_part_rri = &update_rri[update_rri_index];
 				partrel = leaf_part_rri->ri_RelationDesc;
 
@@ -151,73 +150,26 @@ ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
 				proute->subplan_partition_offsets[update_rri_index] = i;
 
 				update_rri_index++;
+
+				part_tupdesc = RelationGetDescr(partrel);
+
+				/*
+				 * Save a tuple conversion map to convert a tuple routed to
+				 * this partition from the parent's type to the partition's.
+				 */
+				proute->parent_child_tupconv_maps[i] =
+					convert_tuples_by_name(tupDesc, part_tupdesc,
+							   gettext_noop("could not convert row type"));
+
+				/*
+				 * Verify result relation is a valid target for an INSERT.  An
+				 * UPDATE of a partition-key becomes a DELETE+INSERT operation,
+				 * so this check is required even when the operation is
+				 * CMD_UPDATE.
+				 */
+				CheckValidResultRel(leaf_part_rri, CMD_INSERT);
 			}
-			else
-				leaf_part_rri = (ResultRelInfo *) palloc0(sizeof(ResultRelInfo));
 		}
-		else
-		{
-			/* For INSERTs, we already have an array of result rels allocated */
-			leaf_part_rri = &leaf_part_arr[i];
-		}
-
-		/*
-		 * If we didn't open the partition rel, it means we haven't
-		 * initialized the result rel either.
-		 */
-		if (!partrel)
-		{
-			/*
-			 * We locked all the partitions above including the leaf
-			 * partitions. Note that each of the newly opened relations in
-			 * proute->partitions are eventually closed by the caller.
-			 */
-			partrel = heap_open(leaf_oid, NoLock);
-			InitResultRelInfo(leaf_part_rri,
-							  partrel,
-							  resultRTindex,
-							  rel,
-							  estate->es_instrument);
-
-			/*
-			 * Since we've just initialized this ResultRelInfo, it's not in
-			 * any list attached to the estate as yet.  Add it, so that it can
-			 * be found later.
-			 */
-			estate->es_tuple_routing_result_relations =
-						lappend(estate->es_tuple_routing_result_relations,
-								leaf_part_rri);
-		}
-
-		part_tupdesc = RelationGetDescr(partrel);
-
-		/*
-		 * Save a tuple conversion map to convert a tuple routed to this
-		 * partition from the parent's type to the partition's.
-		 */
-		proute->parent_child_tupconv_maps[i] =
-			convert_tuples_by_name(tupDesc, part_tupdesc,
-								   gettext_noop("could not convert row type"));
-
-		/*
-		 * Verify result relation is a valid target for an INSERT.  An UPDATE
-		 * of a partition-key becomes a DELETE+INSERT operation, so this check
-		 * is still required when the operation is CMD_UPDATE.
-		 */
-		CheckValidResultRel(leaf_part_rri, CMD_INSERT);
-
-		/*
-		 * Open partition indices.  The user may have asked to check for
-		 * conflicts within this leaf partition and do "nothing" instead of
-		 * throwing an error.  Be prepared in that case by initializing the
-		 * index information needed by ExecInsert() to perform speculative
-		 * insertions.
-		 */
-		if (leaf_part_rri->ri_RelationDesc->rd_rel->relhasindex &&
-			leaf_part_rri->ri_IndexRelationDescs == NULL)
-			ExecOpenIndices(leaf_part_rri,
-							mtstate != NULL &&
-							mtstate->mt_onconflict != ONCONFLICT_NONE);
 
 		proute->partitions[i] = leaf_part_rri;
 		i++;
@@ -352,6 +304,193 @@ ExecFindPartition(ResultRelInfo *resultRelInfo, PartitionDispatch *pd,
 }
 
 /*
+ * ExecInitPartitionInfo
+ *		Initialize ResultRelInfo and other information for a partition if not
+ *		already done
+ *
+ * Returns the ResultRelInfo
+ */
+ResultRelInfo *
+ExecInitPartitionInfo(ModifyTableState *mtstate,
+					  ResultRelInfo *resultRelInfo,
+					  PartitionTupleRouting *proute,
+					  EState *estate, int partidx)
+{
+	Relation	rootrel = resultRelInfo->ri_RelationDesc,
+				partrel;
+	ResultRelInfo *leaf_part_rri;
+	ModifyTable *node = mtstate ? (ModifyTable *) mtstate->ps.plan : NULL;
+
+	/*
+	 * We locked all the partitions in ExecSetupPartitionTupleRouting
+	 * including the leaf partitions.
+	 */
+	partrel = heap_open(proute->partition_oids[partidx], NoLock);
+	leaf_part_rri = (ResultRelInfo *) palloc0(sizeof(ResultRelInfo));
+	InitResultRelInfo(leaf_part_rri,
+					  partrel,
+					  node ? node->nominalRelation : 1,
+					  rootrel,
+					  estate->es_instrument);
+
+	/*
+	 * Verify result relation is a valid target for an INSERT.  An UPDATE
+	 * of a partition-key becomes a DELETE+INSERT operation, so this check
+	 * is still required when the operation is CMD_UPDATE.
+	 */
+	CheckValidResultRel(leaf_part_rri, CMD_INSERT);
+
+	/*
+	 * Since we've just initialized this ResultRelInfo, it's not in
+	 * any list attached to the estate as yet.  Add it, so that it can
+	 * be found later.
+	 *
+	 * Note that the entries in this list appear in no predetermined
+	 * order, because partition result rels are initialized as and when
+	 * they're needed.
+	 */
+	estate->es_tuple_routing_result_relations =
+					lappend(estate->es_tuple_routing_result_relations,
+							leaf_part_rri);
+
+	/*
+	 * Open partition indices.  The user may have asked to check for
+	 * conflicts within this leaf partition and do "nothing" instead of
+	 * throwing an error.  Be prepared in that case by initializing the
+	 * index information needed by ExecInsert() to perform speculative
+	 * insertions.
+	 */
+	if (partrel->rd_rel->relhasindex &&
+		leaf_part_rri->ri_IndexRelationDescs == NULL)
+		ExecOpenIndices(leaf_part_rri,
+						(mtstate != NULL &&
+						 mtstate->mt_onconflict != ONCONFLICT_NONE));
+
+	/*
+	 * Build WITH CHECK OPTION constraints for the partition.  Note that we
+	 * didn't build the withCheckOptionList for partitions within the planner,
+	 * but simple translation of varattnos will suffice.  This only occurs for
+	 * the INSERT case or in the case of UPDATE tuple routing where we didn't
+	 * find a result rel to reuse in ExecSetupPartitionTupleRouting().
+	 */
+	if (node && node->withCheckOptionLists != NIL)
+	{
+		List	   *wcoList;
+		List	   *wcoExprs = NIL;
+		ListCell   *ll;
+		int		firstVarno = mtstate->resultRelInfo[0].ri_RangeTableIndex;
+		Relation firstResultRel = mtstate->resultRelInfo[0].ri_RelationDesc;
+
+		/*
+		 * In the case of INSERT on partitioned tables, there is only one
+		 * plan.  Likewise, there is only one WCO list, not one per
+		 * partition.  For UPDATE, there would be as many WCO lists as
+		 * there are plans.
+		 */
+		Assert((node->operation == CMD_INSERT &&
+				list_length(node->withCheckOptionLists) == 1 &&
+				list_length(node->plans) == 1) ||
+			   (node->operation == CMD_UPDATE &&
+				list_length(node->withCheckOptionLists) ==
+				list_length(node->plans)));
+
+		/*
+		 * Use the WCO list of the first plan as a reference to calculate
+		 * attno's for the WCO list of this partition.  In the INSERT case,
+		 * that refers to the root partitioned table, whereas in the UPDATE
+		 * tuple routing case, that refers to the first partition in the
+		 * mtstate->resultRelInfo array.  In any case, both that relation and
+		 * this partition should have the same columns, so we should be able
+		 * to map attributes successfully.
+		 */
+		wcoList = linitial(node->withCheckOptionLists);
+
+		/*
+		 * Convert Vars in it to contain this partition's attribute numbers.
+		 */
+		wcoList = map_partition_varattnos(wcoList, firstVarno,
+										  partrel, firstResultRel, NULL);
+		foreach(ll, wcoList)
+		{
+			WithCheckOption *wco = castNode(WithCheckOption, lfirst(ll));
+			ExprState  *wcoExpr = ExecInitQual(castNode(List, wco->qual),
+											   mtstate->mt_plans[0]);
+			wcoExprs = lappend(wcoExprs, wcoExpr);
+		}
+
+		leaf_part_rri->ri_WithCheckOptions = wcoList;
+		leaf_part_rri->ri_WithCheckOptionExprs = wcoExprs;
+	}
+
+	/*
+	 * Build the RETURNING projection for the partition.  Note that we didn't
+	 * build the returningList for partitions within the planner, but simple
+	 * translation of varattnos will suffice.  This only occurs for the INSERT
+	 * case or in the case of UPDATE tuple routing where we didn't find a
+	 * result rel to reuse in ExecSetupPartitionTupleRouting().
+	 */
+	if (node && node->returningLists != NIL)
+	{
+		TupleTableSlot *slot;
+		ExprContext *econtext;
+		List	   *returningList;
+		int		firstVarno = mtstate->resultRelInfo[0].ri_RangeTableIndex;
+		Relation firstResultRel = mtstate->resultRelInfo[0].ri_RelationDesc;
+
+		/* See the comment above for WCO lists. */
+		Assert((node->operation == CMD_INSERT &&
+				list_length(node->returningLists) == 1 &&
+				list_length(node->plans) == 1) ||
+			   (node->operation == CMD_UPDATE &&
+				list_length(node->returningLists) ==
+				list_length(node->plans)));
+
+		/*
+		 * Use the RETURNING list of the first plan as a reference to
+		 * calculate attno's for the RETURNING list of this partition.  See
+		 * the comment above for WCO lists for more details on why this is
+		 * okay.
+		 */
+		returningList = linitial(node->returningLists);
+
+		/*
+		 * Convert Vars in it to contain this partition's attribute numbers.
+		 */
+		returningList = map_partition_varattnos(returningList, firstVarno,
+												partrel, firstResultRel,
+												NULL);
+
+		/*
+		 * Initialize the projection itself.
+		 *
+		 * Use the slot and the expression context that would have been set up
+		 * in ExecInitModifyTable() for projection's output.
+		 */
+		Assert(mtstate->ps.ps_ResultTupleSlot != NULL);
+		slot = mtstate->ps.ps_ResultTupleSlot;
+		Assert(mtstate->ps.ps_ExprContext != NULL);
+		econtext = mtstate->ps.ps_ExprContext;
+		leaf_part_rri->ri_projectReturning =
+			ExecBuildProjectionInfo(returningList, econtext, slot,
+									&mtstate->ps, RelationGetDescr(partrel));
+	}
+
+	Assert (proute->partitions[partidx] == NULL);
+	proute->partitions[partidx] = leaf_part_rri;
+
+	/*
+	 * Save a tuple conversion map to convert a tuple routed to this
+	 * partition from the parent's type to the partition's.
+	 */
+	proute->parent_child_tupconv_maps[partidx] =
+							convert_tuples_by_name(RelationGetDescr(rootrel),
+												   RelationGetDescr(partrel),
+											   gettext_noop("could not convert row type"));
+
+	return leaf_part_rri;
+}
+
+/*
  * ExecSetupChildParentMapForLeaf -- Initialize the per-leaf-partition
  * child-to-root tuple conversion map array.
  *
@@ -477,6 +616,10 @@ ExecCleanupTupleRouting(PartitionTupleRouting *proute)
 	{
 		ResultRelInfo *resultRelInfo = proute->partitions[i];
 
+		/* skip further processsing for uninitialized partitions */
+		if (resultRelInfo == NULL)
+			continue;
+
 		/*
 		 * If this result rel is one of the UPDATE subplan result rels, let
 		 * ExecEndPlan() close it. For INSERT or COPY,
diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c
index 93c03cfb07..87a4a92072 100644
--- a/src/backend/executor/nodeModifyTable.c
+++ b/src/backend/executor/nodeModifyTable.c
@@ -310,6 +310,14 @@ ExecInsert(ModifyTableState *mtstate,
 		 */
 		saved_resultRelInfo = resultRelInfo;
 		resultRelInfo = proute->partitions[leaf_part_index];
+		if (resultRelInfo == NULL)
+		{
+			resultRelInfo = ExecInitPartitionInfo(mtstate,
+												  saved_resultRelInfo,
+												  proute, estate,
+												  leaf_part_index);
+			Assert(resultRelInfo != NULL);
+		}
 
 		/* We do not yet have a way to insert into a foreign partition */
 		if (resultRelInfo->ri_FdwRoutine)
@@ -2098,14 +2106,10 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 	ResultRelInfo *saved_resultRelInfo;
 	ResultRelInfo *resultRelInfo;
 	Plan	   *subplan;
-	int			firstVarno = 0;
-	Relation	firstResultRel = NULL;
 	ListCell   *l;
 	int			i;
 	Relation	rel;
 	bool		update_tuple_routing_needed = node->partColsUpdated;
-	PartitionTupleRouting *proute = NULL;
-	int			num_partitions = 0;
 
 	/* check for unsupported flags */
 	Assert(!(eflags & (EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK)));
@@ -2228,20 +2232,8 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 	 */
 	if (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE &&
 		(operation == CMD_INSERT || update_tuple_routing_needed))
-	{
-		proute = mtstate->mt_partition_tuple_routing =
-			ExecSetupPartitionTupleRouting(mtstate,
-										   rel, node->nominalRelation,
-										   estate);
-		num_partitions = proute->num_partitions;
-
-		/*
-		 * Below are required as reference objects for mapping partition
-		 * attno's in expressions such as WithCheckOptions and RETURNING.
-		 */
-		firstVarno = mtstate->resultRelInfo[0].ri_RangeTableIndex;
-		firstResultRel = mtstate->resultRelInfo[0].ri_RelationDesc;
-	}
+		mtstate->mt_partition_tuple_routing =
+						ExecSetupPartitionTupleRouting(mtstate, rel);
 
 	/*
 	 * Build state for collecting transition tuples.  This requires having a
@@ -2288,77 +2280,12 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 	}
 
 	/*
-	 * Build WITH CHECK OPTION constraints for each leaf partition rel. Note
-	 * that we didn't build the withCheckOptionList for each partition within
-	 * the planner, but simple translation of the varattnos for each partition
-	 * will suffice.  This only occurs for the INSERT case or for UPDATE row
-	 * movement. DELETEs and local UPDATEs are handled above.
-	 */
-	if (node->withCheckOptionLists != NIL && num_partitions > 0)
-	{
-		List	   *first_wcoList;
-
-		/*
-		 * In case of INSERT on partitioned tables, there is only one plan.
-		 * Likewise, there is only one WITH CHECK OPTIONS list, not one per
-		 * partition. Whereas for UPDATE, there are as many WCOs as there are
-		 * plans. So in either case, use the WCO expression of the first
-		 * resultRelInfo as a reference to calculate attno's for the WCO
-		 * expression of each of the partitions. We make a copy of the WCO
-		 * qual for each partition. Note that, if there are SubPlans in there,
-		 * they all end up attached to the one parent Plan node.
-		 */
-		Assert(update_tuple_routing_needed ||
-			   (operation == CMD_INSERT &&
-				list_length(node->withCheckOptionLists) == 1 &&
-				mtstate->mt_nplans == 1));
-
-		first_wcoList = linitial(node->withCheckOptionLists);
-		for (i = 0; i < num_partitions; i++)
-		{
-			Relation	partrel;
-			List	   *mapped_wcoList;
-			List	   *wcoExprs = NIL;
-			ListCell   *ll;
-
-			resultRelInfo = proute->partitions[i];
-
-			/*
-			 * If we are referring to a resultRelInfo from one of the update
-			 * result rels, that result rel would already have
-			 * WithCheckOptions initialized.
-			 */
-			if (resultRelInfo->ri_WithCheckOptions)
-				continue;
-
-			partrel = resultRelInfo->ri_RelationDesc;
-
-			mapped_wcoList = map_partition_varattnos(first_wcoList,
-													 firstVarno,
-													 partrel, firstResultRel,
-													 NULL);
-			foreach(ll, mapped_wcoList)
-			{
-				WithCheckOption *wco = castNode(WithCheckOption, lfirst(ll));
-				ExprState  *wcoExpr = ExecInitQual(castNode(List, wco->qual),
-												   &mtstate->ps);
-
-				wcoExprs = lappend(wcoExprs, wcoExpr);
-			}
-
-			resultRelInfo->ri_WithCheckOptions = mapped_wcoList;
-			resultRelInfo->ri_WithCheckOptionExprs = wcoExprs;
-		}
-	}
-
-	/*
 	 * Initialize RETURNING projections if needed.
 	 */
 	if (node->returningLists)
 	{
 		TupleTableSlot *slot;
 		ExprContext *econtext;
-		List	   *firstReturningList;
 
 		/*
 		 * Initialize result tuple slot and assign its rowtype using the first
@@ -2388,44 +2315,6 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 										resultRelInfo->ri_RelationDesc->rd_att);
 			resultRelInfo++;
 		}
-
-		/*
-		 * Build a projection for each leaf partition rel.  Note that we
-		 * didn't build the returningList for each partition within the
-		 * planner, but simple translation of the varattnos for each partition
-		 * will suffice.  This only occurs for the INSERT case or for UPDATE
-		 * row movement. DELETEs and local UPDATEs are handled above.
-		 */
-		firstReturningList = linitial(node->returningLists);
-		for (i = 0; i < num_partitions; i++)
-		{
-			Relation	partrel;
-			List	   *rlist;
-
-			resultRelInfo = proute->partitions[i];
-
-			/*
-			 * If we are referring to a resultRelInfo from one of the update
-			 * result rels, that result rel would already have a returningList
-			 * built.
-			 */
-			if (resultRelInfo->ri_projectReturning)
-				continue;
-
-			partrel = resultRelInfo->ri_RelationDesc;
-
-			/*
-			 * Use the returning expression of the first resultRelInfo as a
-			 * reference to calculate attno's for the returning expression of
-			 * each of the partitions.
-			 */
-			rlist = map_partition_varattnos(firstReturningList,
-											firstVarno,
-											partrel, firstResultRel, NULL);
-			resultRelInfo->ri_projectReturning =
-				ExecBuildProjectionInfo(rlist, econtext, slot, &mtstate->ps,
-										resultRelInfo->ri_RelationDesc->rd_att);
-		}
 	}
 	else
 	{
diff --git a/src/include/executor/execPartition.h b/src/include/executor/execPartition.h
index 3df9c498bb..e94718608f 100644
--- a/src/include/executor/execPartition.h
+++ b/src/include/executor/execPartition.h
@@ -58,6 +58,7 @@ typedef struct PartitionDispatchData *PartitionDispatch;
  *								partition tree.
  * num_dispatch					number of partitioned tables in the partition
  *								tree (= length of partition_dispatch_info[])
+ * partition_oids				Array of leaf partitions OIDs
  * partitions					Array of ResultRelInfo* objects with one entry
  *								for every leaf partition in the partition tree.
  * num_partitions				Number of leaf partitions in the partition tree
@@ -91,6 +92,7 @@ typedef struct PartitionTupleRouting
 {
 	PartitionDispatch *partition_dispatch_info;
 	int			num_dispatch;
+	Oid		   *partition_oids;
 	ResultRelInfo **partitions;
 	int			num_partitions;
 	TupleConversionMap **parent_child_tupconv_maps;
@@ -103,12 +105,15 @@ typedef struct PartitionTupleRouting
 } PartitionTupleRouting;
 
 extern PartitionTupleRouting *ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
-							   Relation rel, Index resultRTindex,
-							   EState *estate);
+							   Relation rel);
 extern int ExecFindPartition(ResultRelInfo *resultRelInfo,
 				  PartitionDispatch *pd,
 				  TupleTableSlot *slot,
 				  EState *estate);
+extern ResultRelInfo *ExecInitPartitionInfo(ModifyTableState *mtstate,
+					ResultRelInfo *resultRelInfo,
+					PartitionTupleRouting *proute,
+					EState *estate, int partidx);
 extern void ExecSetupChildParentMapForLeaf(PartitionTupleRouting *proute);
 extern TupleConversionMap *TupConvMapForLeaf(PartitionTupleRouting *proute,
 				  ResultRelInfo *rootRelInfo, int leaf_index);
-- 
2.11.0

diff --git a/src/backend/commands/copy.c b/src/backend/commands/copy.c
index d5883c9..4562a51 100644
--- a/src/backend/commands/copy.c
+++ b/src/backend/commands/copy.c
@@ -2469,7 +2469,7 @@ CopyFrom(CopyState cstate)
 		PartitionTupleRouting *proute;
 
 		proute = cstate->partition_tuple_routing =
-			ExecSetupPartitionTupleRouting(NULL, cstate->rel, 1, estate);
+			ExecSetupPartitionTupleRouting(NULL, cstate->rel);
 
 		/*
 		 * If we are capturing transition tuples, they may need to be
@@ -2606,6 +2606,14 @@ CopyFrom(CopyState cstate)
 			 */
 			saved_resultRelInfo = resultRelInfo;
 			resultRelInfo = proute->partitions[leaf_part_index];
+			if (resultRelInfo == NULL)
+			{
+				resultRelInfo = ExecInitPartitionInfo(NULL,
+													  saved_resultRelInfo,
+													  proute, estate,
+													  leaf_part_index);
+				Assert(resultRelInfo != NULL);
+			}
 
 			/* We do not yet have a way to insert into a foreign partition */
 			if (resultRelInfo->ri_FdwRoutine)
diff --git a/src/backend/executor/execPartition.c b/src/backend/executor/execPartition.c
index 00523ce..d35dac1 100644
--- a/src/backend/executor/execPartition.c
+++ b/src/backend/executor/execPartition.c
@@ -44,18 +44,23 @@ static char *ExecBuildSlotPartitionKeyDescription(Relation rel,
  *
  * Note that all the relations in the partition tree are locked using the
  * RowExclusiveLock mode upon return from this function.
+ *
+ * While we allocate the arrays of pointers of ResultRelInfo and
+ * TupleConversionMap for all partitions here, actual objects themselves are
+ * lazily allocated for a given partition if a tuple is actually routed to it;
+ * see ExecInitPartitionInfo.  However, if the function is invoked for update
+ * tuple routing, caller would already have initialized ResultRelInfo's for
+ * some of the partitions, which are reused and assigned to their respective
+ * slot in the aforementioned array.
  */
 PartitionTupleRouting *
-ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
-							   Relation rel, Index resultRTindex,
-							   EState *estate)
+ExecSetupPartitionTupleRouting(ModifyTableState *mtstate, Relation rel)
 {
 	TupleDesc	tupDesc = RelationGetDescr(rel);
 	List	   *leaf_parts;
 	ListCell   *cell;
 	int			i;
-	ResultRelInfo *leaf_part_arr = NULL,
-			   *update_rri = NULL;
+	ResultRelInfo *update_rri = NULL;
 	int			num_update_rri = 0,
 				update_rri_index = 0;
 	bool		is_update = false;
@@ -76,6 +81,8 @@ ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
 	proute->parent_child_tupconv_maps =
 		(TupleConversionMap **) palloc0(proute->num_partitions *
 										sizeof(TupleConversionMap *));
+	proute->partition_oids = (Oid *) palloc(proute->num_partitions *
+											sizeof(Oid));
 
 	/* Set up details specific to the type of tuple routing we are doing. */
 	if (mtstate && mtstate->operation == CMD_UPDATE)
@@ -95,16 +102,6 @@ ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
 		 */
 		proute->root_tuple_slot = MakeTupleTableSlot(NULL);
 	}
-	else
-	{
-		/*
-		 * Since we are inserting tuples, we need to create all new result
-		 * rels. Avoid repeated pallocs by allocating memory for all the
-		 * result rels in bulk.
-		 */
-		leaf_part_arr = (ResultRelInfo *) palloc0(proute->num_partitions *
-												  sizeof(ResultRelInfo));
-	}
 
 	/*
 	 * Initialize an empty slot that will be used to manipulate tuples of any
@@ -117,11 +114,10 @@ ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
 	i = 0;
 	foreach(cell, leaf_parts)
 	{
-		ResultRelInfo *leaf_part_rri;
-		Relation	partrel = NULL;
-		TupleDesc	part_tupdesc;
+		ResultRelInfo *leaf_part_rri = NULL;
 		Oid			leaf_oid = lfirst_oid(cell);
 
+		proute->partition_oids[i] = leaf_oid;
 		if (is_update)
 		{
 			/*
@@ -136,6 +132,9 @@ ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
 			if (update_rri_index < num_update_rri &&
 				RelationGetRelid(update_rri[update_rri_index].ri_RelationDesc) == leaf_oid)
 			{
+				Relation	partrel;
+				TupleDesc	part_tupdesc;
+
 				leaf_part_rri = &update_rri[update_rri_index];
 				partrel = leaf_part_rri->ri_RelationDesc;
 
@@ -151,73 +150,26 @@ ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
 				proute->subplan_partition_offsets[update_rri_index] = i;
 
 				update_rri_index++;
-			}
-			else
-				leaf_part_rri = (ResultRelInfo *) palloc0(sizeof(ResultRelInfo));
-		}
-		else
-		{
-			/* For INSERTs, we already have an array of result rels allocated */
-			leaf_part_rri = &leaf_part_arr[i];
-		}
 
-		/*
-		 * If we didn't open the partition rel, it means we haven't
-		 * initialized the result rel either.
-		 */
-		if (!partrel)
-		{
-			/*
-			 * We locked all the partitions above including the leaf
-			 * partitions. Note that each of the newly opened relations in
-			 * proute->partitions are eventually closed by the caller.
-			 */
-			partrel = heap_open(leaf_oid, NoLock);
-			InitResultRelInfo(leaf_part_rri,
-							  partrel,
-							  resultRTindex,
-							  rel,
-							  estate->es_instrument);
-
-			/*
-			 * Since we've just initialized this ResultRelInfo, it's not in
-			 * any list attached to the estate as yet.  Add it, so that it can
-			 * be found later.
-			 */
-			estate->es_tuple_routing_result_relations =
-						lappend(estate->es_tuple_routing_result_relations,
-								leaf_part_rri);
-		}
-
-		part_tupdesc = RelationGetDescr(partrel);
-
-		/*
-		 * Save a tuple conversion map to convert a tuple routed to this
-		 * partition from the parent's type to the partition's.
-		 */
-		proute->parent_child_tupconv_maps[i] =
-			convert_tuples_by_name(tupDesc, part_tupdesc,
-								   gettext_noop("could not convert row type"));
+				part_tupdesc = RelationGetDescr(partrel);
 
-		/*
-		 * Verify result relation is a valid target for an INSERT.  An UPDATE
-		 * of a partition-key becomes a DELETE+INSERT operation, so this check
-		 * is still required when the operation is CMD_UPDATE.
-		 */
-		CheckValidResultRel(leaf_part_rri, CMD_INSERT);
+				/*
+				 * Save a tuple conversion map to convert a tuple routed to
+				 * this partition from the parent's type to the partition's.
+				 */
+				proute->parent_child_tupconv_maps[i] =
+					convert_tuples_by_name(tupDesc, part_tupdesc,
+							   gettext_noop("could not convert row type"));
 
-		/*
-		 * Open partition indices.  The user may have asked to check for
-		 * conflicts within this leaf partition and do "nothing" instead of
-		 * throwing an error.  Be prepared in that case by initializing the
-		 * index information needed by ExecInsert() to perform speculative
-		 * insertions.
-		 */
-		if (leaf_part_rri->ri_RelationDesc->rd_rel->relhasindex &&
-			leaf_part_rri->ri_IndexRelationDescs == NULL)
-			ExecOpenIndices(leaf_part_rri,
-							mtstate != NULL &&
-							mtstate->mt_onconflict != ONCONFLICT_NONE);
+				/*
+				 * Verify result relation is a valid target for an INSERT.  An
+				 * UPDATE of a partition-key becomes a DELETE+INSERT operation,
+				 * so this check is required even when the operation is
+				 * CMD_UPDATE.
+				 */
+				CheckValidResultRel(leaf_part_rri, CMD_INSERT);
+			}
+		}
 
 		proute->partitions[i] = leaf_part_rri;
 		i++;
@@ -352,6 +304,204 @@ ExecFindPartition(ResultRelInfo *resultRelInfo, PartitionDispatch *pd,
 }
 
 /*
+ * ExecInitPartitionInfo
+ *		Initialize ResultRelInfo and other information for a partition if not
+ *		already done
+ *
+ * Returns the ResultRelInfo
+ */
+ResultRelInfo *
+ExecInitPartitionInfo(ModifyTableState *mtstate,
+					  ResultRelInfo *resultRelInfo,
+					  PartitionTupleRouting *proute,
+					  EState *estate, int partidx)
+{
+	Relation	rootrel = resultRelInfo->ri_RelationDesc,
+				partrel;
+	ResultRelInfo *leaf_part_rri;
+	ModifyTable *node = mtstate ? (ModifyTable *) mtstate->ps.plan : NULL;
+	MemoryContext oldContext;
+
+	/*
+	 * We locked all the partitions in ExecSetupPartitionTupleRouting
+	 * including the leaf partitions.
+	 */
+	partrel = heap_open(proute->partition_oids[partidx], NoLock);
+
+	/*
+	 * Keep ResultRelInfo and other information for this partition in the
+	 * per-query memory context so they'll survive throughout the query.
+	 */
+	oldContext = MemoryContextSwitchTo(estate->es_query_cxt);
+
+	leaf_part_rri = (ResultRelInfo *) palloc0(sizeof(ResultRelInfo));
+	InitResultRelInfo(leaf_part_rri,
+					  partrel,
+					  node ? node->nominalRelation : 1,
+					  rootrel,
+					  estate->es_instrument);
+
+	/*
+	 * Verify result relation is a valid target for an INSERT.  An UPDATE
+	 * of a partition-key becomes a DELETE+INSERT operation, so this check
+	 * is still required when the operation is CMD_UPDATE.
+	 */
+	CheckValidResultRel(leaf_part_rri, CMD_INSERT);
+
+	/*
+	 * Since we've just initialized this ResultRelInfo, it's not in
+	 * any list attached to the estate as yet.  Add it, so that it can
+	 * be found later.
+	 *
+	 * Note that the entries in this list appear in no predetermined
+	 * order, because partition result rels are initialized as and when
+	 * they're needed.
+	 */
+	estate->es_tuple_routing_result_relations =
+					lappend(estate->es_tuple_routing_result_relations,
+							leaf_part_rri);
+
+	/*
+	 * Open partition indices.  The user may have asked to check for
+	 * conflicts within this leaf partition and do "nothing" instead of
+	 * throwing an error.  Be prepared in that case by initializing the
+	 * index information needed by ExecInsert() to perform speculative
+	 * insertions.
+	 */
+	if (partrel->rd_rel->relhasindex &&
+		leaf_part_rri->ri_IndexRelationDescs == NULL)
+		ExecOpenIndices(leaf_part_rri,
+						(mtstate != NULL &&
+						 mtstate->mt_onconflict != ONCONFLICT_NONE));
+
+	/*
+	 * Build WITH CHECK OPTION constraints for the partition.  Note that we
+	 * didn't build the withCheckOptionList for partitions within the planner,
+	 * but simple translation of varattnos will suffice.  This only occurs for
+	 * the INSERT case or in the case of UPDATE tuple routing where we didn't
+	 * find a result rel to reuse in ExecSetupPartitionTupleRouting().
+	 */
+	if (node && node->withCheckOptionLists != NIL)
+	{
+		List	   *wcoList;
+		List	   *wcoExprs = NIL;
+		ListCell   *ll;
+		int		firstVarno = mtstate->resultRelInfo[0].ri_RangeTableIndex;
+		Relation firstResultRel = mtstate->resultRelInfo[0].ri_RelationDesc;
+
+		/*
+		 * In the case of INSERT on partitioned tables, there is only one
+		 * plan.  Likewise, there is only one WCO list, not one per
+		 * partition.  For UPDATE, there would be as many WCO lists as
+		 * there are plans.
+		 */
+		Assert((node->operation == CMD_INSERT &&
+				list_length(node->withCheckOptionLists) == 1 &&
+				list_length(node->plans) == 1) ||
+			   (node->operation == CMD_UPDATE &&
+				list_length(node->withCheckOptionLists) ==
+				list_length(node->plans)));
+
+		/*
+		 * Use the WCO list of the first plan as a reference to calculate
+		 * attno's for the WCO list of this partition.  In the INSERT case,
+		 * that refers to the root partitioned table, whereas in the UPDATE
+		 * tuple routing case, that refers to the first partition in the
+		 * mtstate->resultRelInfo array.  In any case, both that relation and
+		 * this partition should have the same columns, so we should be able
+		 * to map attributes successfully.
+		 */
+		wcoList = linitial(node->withCheckOptionLists);
+
+		/*
+		 * Convert Vars in it to contain this partition's attribute numbers.
+		 */
+		wcoList = map_partition_varattnos(wcoList, firstVarno,
+										  partrel, firstResultRel, NULL);
+		foreach(ll, wcoList)
+		{
+			WithCheckOption *wco = castNode(WithCheckOption, lfirst(ll));
+			ExprState  *wcoExpr = ExecInitQual(castNode(List, wco->qual),
+											   mtstate->mt_plans[0]);
+
+			wcoExprs = lappend(wcoExprs, wcoExpr);
+		}
+
+		leaf_part_rri->ri_WithCheckOptions = wcoList;
+		leaf_part_rri->ri_WithCheckOptionExprs = wcoExprs;
+	}
+
+	/*
+	 * Build the RETURNING projection for the partition.  Note that we didn't
+	 * build the returningList for partitions within the planner, but simple
+	 * translation of varattnos will suffice.  This only occurs for the INSERT
+	 * case or in the case of UPDATE tuple routing where we didn't find a
+	 * result rel to reuse in ExecSetupPartitionTupleRouting().
+	 */
+	if (node && node->returningLists != NIL)
+	{
+		TupleTableSlot *slot;
+		ExprContext *econtext;
+		List	   *returningList;
+		int		firstVarno = mtstate->resultRelInfo[0].ri_RangeTableIndex;
+		Relation firstResultRel = mtstate->resultRelInfo[0].ri_RelationDesc;
+
+		/* See the comment above for WCO lists. */
+		Assert((node->operation == CMD_INSERT &&
+				list_length(node->returningLists) == 1 &&
+				list_length(node->plans) == 1) ||
+			   (node->operation == CMD_UPDATE &&
+				list_length(node->returningLists) ==
+				list_length(node->plans)));
+
+		/*
+		 * Use the RETURNING list of the first plan as a reference to
+		 * calculate attno's for the RETURNING list of this partition.  See
+		 * the comment above for WCO lists for more details on why this is
+		 * okay.
+		 */
+		returningList = linitial(node->returningLists);
+
+		/*
+		 * Convert Vars in it to contain this partition's attribute numbers.
+		 */
+		returningList = map_partition_varattnos(returningList, firstVarno,
+												partrel, firstResultRel,
+												NULL);
+
+		/*
+		 * Initialize the projection itself.
+		 *
+		 * Use the slot and the expression context that would have been set up
+		 * in ExecInitModifyTable() for projection's output.
+		 */
+		Assert(mtstate->ps.ps_ResultTupleSlot != NULL);
+		slot = mtstate->ps.ps_ResultTupleSlot;
+		Assert(mtstate->ps.ps_ExprContext != NULL);
+		econtext = mtstate->ps.ps_ExprContext;
+		leaf_part_rri->ri_projectReturning =
+			ExecBuildProjectionInfo(returningList, econtext, slot,
+									&mtstate->ps, RelationGetDescr(partrel));
+	}
+
+	Assert (proute->partitions[partidx] == NULL);
+	proute->partitions[partidx] = leaf_part_rri;
+
+	/*
+	 * Save a tuple conversion map to convert a tuple routed to this
+	 * partition from the parent's type to the partition's.
+	 */
+	proute->parent_child_tupconv_maps[partidx] =
+							convert_tuples_by_name(RelationGetDescr(rootrel),
+												   RelationGetDescr(partrel),
+											   gettext_noop("could not convert row type"));
+
+	MemoryContextSwitchTo(oldContext);
+
+	return leaf_part_rri;
+}
+
+/*
  * ExecSetupChildParentMapForLeaf -- Initialize the per-leaf-partition
  * child-to-root tuple conversion map array.
  *
@@ -477,6 +627,10 @@ ExecCleanupTupleRouting(PartitionTupleRouting *proute)
 	{
 		ResultRelInfo *resultRelInfo = proute->partitions[i];
 
+		/* skip further processsing for uninitialized partitions */
+		if (resultRelInfo == NULL)
+			continue;
+
 		/*
 		 * If this result rel is one of the UPDATE subplan result rels, let
 		 * ExecEndPlan() close it. For INSERT or COPY,
diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c
index 93c03cf..87a4a92 100644
--- a/src/backend/executor/nodeModifyTable.c
+++ b/src/backend/executor/nodeModifyTable.c
@@ -310,6 +310,14 @@ ExecInsert(ModifyTableState *mtstate,
 		 */
 		saved_resultRelInfo = resultRelInfo;
 		resultRelInfo = proute->partitions[leaf_part_index];
+		if (resultRelInfo == NULL)
+		{
+			resultRelInfo = ExecInitPartitionInfo(mtstate,
+												  saved_resultRelInfo,
+												  proute, estate,
+												  leaf_part_index);
+			Assert(resultRelInfo != NULL);
+		}
 
 		/* We do not yet have a way to insert into a foreign partition */
 		if (resultRelInfo->ri_FdwRoutine)
@@ -2098,14 +2106,10 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 	ResultRelInfo *saved_resultRelInfo;
 	ResultRelInfo *resultRelInfo;
 	Plan	   *subplan;
-	int			firstVarno = 0;
-	Relation	firstResultRel = NULL;
 	ListCell   *l;
 	int			i;
 	Relation	rel;
 	bool		update_tuple_routing_needed = node->partColsUpdated;
-	PartitionTupleRouting *proute = NULL;
-	int			num_partitions = 0;
 
 	/* check for unsupported flags */
 	Assert(!(eflags & (EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK)));
@@ -2228,20 +2232,8 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 	 */
 	if (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE &&
 		(operation == CMD_INSERT || update_tuple_routing_needed))
-	{
-		proute = mtstate->mt_partition_tuple_routing =
-			ExecSetupPartitionTupleRouting(mtstate,
-										   rel, node->nominalRelation,
-										   estate);
-		num_partitions = proute->num_partitions;
-
-		/*
-		 * Below are required as reference objects for mapping partition
-		 * attno's in expressions such as WithCheckOptions and RETURNING.
-		 */
-		firstVarno = mtstate->resultRelInfo[0].ri_RangeTableIndex;
-		firstResultRel = mtstate->resultRelInfo[0].ri_RelationDesc;
-	}
+		mtstate->mt_partition_tuple_routing =
+						ExecSetupPartitionTupleRouting(mtstate, rel);
 
 	/*
 	 * Build state for collecting transition tuples.  This requires having a
@@ -2288,77 +2280,12 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 	}
 
 	/*
-	 * Build WITH CHECK OPTION constraints for each leaf partition rel. Note
-	 * that we didn't build the withCheckOptionList for each partition within
-	 * the planner, but simple translation of the varattnos for each partition
-	 * will suffice.  This only occurs for the INSERT case or for UPDATE row
-	 * movement. DELETEs and local UPDATEs are handled above.
-	 */
-	if (node->withCheckOptionLists != NIL && num_partitions > 0)
-	{
-		List	   *first_wcoList;
-
-		/*
-		 * In case of INSERT on partitioned tables, there is only one plan.
-		 * Likewise, there is only one WITH CHECK OPTIONS list, not one per
-		 * partition. Whereas for UPDATE, there are as many WCOs as there are
-		 * plans. So in either case, use the WCO expression of the first
-		 * resultRelInfo as a reference to calculate attno's for the WCO
-		 * expression of each of the partitions. We make a copy of the WCO
-		 * qual for each partition. Note that, if there are SubPlans in there,
-		 * they all end up attached to the one parent Plan node.
-		 */
-		Assert(update_tuple_routing_needed ||
-			   (operation == CMD_INSERT &&
-				list_length(node->withCheckOptionLists) == 1 &&
-				mtstate->mt_nplans == 1));
-
-		first_wcoList = linitial(node->withCheckOptionLists);
-		for (i = 0; i < num_partitions; i++)
-		{
-			Relation	partrel;
-			List	   *mapped_wcoList;
-			List	   *wcoExprs = NIL;
-			ListCell   *ll;
-
-			resultRelInfo = proute->partitions[i];
-
-			/*
-			 * If we are referring to a resultRelInfo from one of the update
-			 * result rels, that result rel would already have
-			 * WithCheckOptions initialized.
-			 */
-			if (resultRelInfo->ri_WithCheckOptions)
-				continue;
-
-			partrel = resultRelInfo->ri_RelationDesc;
-
-			mapped_wcoList = map_partition_varattnos(first_wcoList,
-													 firstVarno,
-													 partrel, firstResultRel,
-													 NULL);
-			foreach(ll, mapped_wcoList)
-			{
-				WithCheckOption *wco = castNode(WithCheckOption, lfirst(ll));
-				ExprState  *wcoExpr = ExecInitQual(castNode(List, wco->qual),
-												   &mtstate->ps);
-
-				wcoExprs = lappend(wcoExprs, wcoExpr);
-			}
-
-			resultRelInfo->ri_WithCheckOptions = mapped_wcoList;
-			resultRelInfo->ri_WithCheckOptionExprs = wcoExprs;
-		}
-	}
-
-	/*
 	 * Initialize RETURNING projections if needed.
 	 */
 	if (node->returningLists)
 	{
 		TupleTableSlot *slot;
 		ExprContext *econtext;
-		List	   *firstReturningList;
 
 		/*
 		 * Initialize result tuple slot and assign its rowtype using the first
@@ -2388,44 +2315,6 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 										resultRelInfo->ri_RelationDesc->rd_att);
 			resultRelInfo++;
 		}
-
-		/*
-		 * Build a projection for each leaf partition rel.  Note that we
-		 * didn't build the returningList for each partition within the
-		 * planner, but simple translation of the varattnos for each partition
-		 * will suffice.  This only occurs for the INSERT case or for UPDATE
-		 * row movement. DELETEs and local UPDATEs are handled above.
-		 */
-		firstReturningList = linitial(node->returningLists);
-		for (i = 0; i < num_partitions; i++)
-		{
-			Relation	partrel;
-			List	   *rlist;
-
-			resultRelInfo = proute->partitions[i];
-
-			/*
-			 * If we are referring to a resultRelInfo from one of the update
-			 * result rels, that result rel would already have a returningList
-			 * built.
-			 */
-			if (resultRelInfo->ri_projectReturning)
-				continue;
-
-			partrel = resultRelInfo->ri_RelationDesc;
-
-			/*
-			 * Use the returning expression of the first resultRelInfo as a
-			 * reference to calculate attno's for the returning expression of
-			 * each of the partitions.
-			 */
-			rlist = map_partition_varattnos(firstReturningList,
-											firstVarno,
-											partrel, firstResultRel, NULL);
-			resultRelInfo->ri_projectReturning =
-				ExecBuildProjectionInfo(rlist, econtext, slot, &mtstate->ps,
-										resultRelInfo->ri_RelationDesc->rd_att);
-		}
 	}
 	else
 	{
diff --git a/src/include/executor/execPartition.h b/src/include/executor/execPartition.h
index 3df9c49..e947186 100644
--- a/src/include/executor/execPartition.h
+++ b/src/include/executor/execPartition.h
@@ -58,6 +58,7 @@ typedef struct PartitionDispatchData *PartitionDispatch;
  *								partition tree.
  * num_dispatch					number of partitioned tables in the partition
  *								tree (= length of partition_dispatch_info[])
+ * partition_oids				Array of leaf partitions OIDs
  * partitions					Array of ResultRelInfo* objects with one entry
  *								for every leaf partition in the partition tree.
  * num_partitions				Number of leaf partitions in the partition tree
@@ -91,6 +92,7 @@ typedef struct PartitionTupleRouting
 {
 	PartitionDispatch *partition_dispatch_info;
 	int			num_dispatch;
+	Oid		   *partition_oids;
 	ResultRelInfo **partitions;
 	int			num_partitions;
 	TupleConversionMap **parent_child_tupconv_maps;
@@ -103,12 +105,15 @@ typedef struct PartitionTupleRouting
 } PartitionTupleRouting;
 
 extern PartitionTupleRouting *ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
-							   Relation rel, Index resultRTindex,
-							   EState *estate);
+							   Relation rel);
 extern int ExecFindPartition(ResultRelInfo *resultRelInfo,
 				  PartitionDispatch *pd,
 				  TupleTableSlot *slot,
 				  EState *estate);
+extern ResultRelInfo *ExecInitPartitionInfo(ModifyTableState *mtstate,
+					ResultRelInfo *resultRelInfo,
+					PartitionTupleRouting *proute,
+					EState *estate, int partidx);
 extern void ExecSetupChildParentMapForLeaf(PartitionTupleRouting *proute);
 extern TupleConversionMap *TupConvMapForLeaf(PartitionTupleRouting *proute,
 				  ResultRelInfo *rootRelInfo, int leaf_index);

diff --git a/src/include/executor/execPartition.h b/src/include/executor/execPartition.h
index e94718608f..08a994bce1 100644
--- a/src/include/executor/execPartition.h
+++ b/src/include/executor/execPartition.h
@@ -58,11 +58,15 @@ typedef struct PartitionDispatchData *PartitionDispatch;
  *								partition tree.
  * num_dispatch					number of partitioned tables in the partition
  *								tree (= length of partition_dispatch_info[])
- * partition_oids				Array of leaf partitions OIDs
+ * partition_oids				Array of leaf partitions OIDs with one entry
+ *								for every leaf partition in the partition tree,
+ *								initialized in full by
+ *								ExecSetupPartitionTupleRouting.
  * partitions					Array of ResultRelInfo* objects with one entry
- *								for every leaf partition in the partition tree.
+ *								for every leaf partition in the partition tree,
+ *								initialized lazily.
  * num_partitions				Number of leaf partitions in the partition tree
- *								(= 'partitions' array length)
+ *								(= 'partitions_oid'/'partitions' array length)
  * parent_child_tupconv_maps	Array of TupleConversionMap objects with one
  *								entry for every leaf partition (required to
  *								convert tuple from the root table's rowtype to

diff --git a/src/backend/executor/execPartition.c b/src/backend/executor/execPartition.c
index 54efc9e545..f6fe7cd61d 100644
--- a/src/backend/executor/execPartition.c
+++ b/src/backend/executor/execPartition.c
@@ -413,7 +413,7 @@ ExecInitPartitionInfo(ModifyTableState *mtstate,
 		{
 			WithCheckOption *wco = castNode(WithCheckOption, lfirst(ll));
 			ExprState  *wcoExpr = ExecInitQual(castNode(List, wco->qual),
-											   mtstate->mt_plans[0]);
+											   &mtstate->ps);
 
 			wcoExprs = lappend(wcoExprs, wcoExpr);
 		}