Skip partition tuple routing with constant partition key

diff --git a/src/backend/executor/execPartition.c b/src/backend/executor/execPartition.c
index 606c920b06..2735945c6c 100644
--- a/src/backend/executor/execPartition.c
+++ b/src/backend/executor/execPartition.c
@@ -150,6 +150,7 @@ typedef struct PartitionDispatchData
 	PartitionDesc partdesc;
 	TupleTableSlot *tupslot;
 	AttrMap    *tupmap;
+	ResultRelInfo *lastPartInfo;
 	int			indexes[FLEXIBLE_ARRAY_MEMBER];
 }			PartitionDispatchData;
 
@@ -291,6 +292,35 @@ ExecFindPartition(ModifyTableState *mtstate,
 
 		CHECK_FOR_INTERRUPTS();
 
+		/*
+		 * Check if the saved partition accepts this tuple by evaluating its
+		 * partition constraint against the tuple.  If it does, we save a trip
+		 * to get_partition_for_tuple(), which can be a slightly more expensive
+		 * way to get the same partition, especially if there are many
+		 * partitions to search through.
+		 */
+		if (dispatch->lastPartInfo)
+		{
+			TupleTableSlot *tmpslot;
+			TupleConversionMap *map;
+
+			rri = dispatch->lastPartInfo;
+			map = rri->ri_RootToPartitionMap;
+			if (map)
+				tmpslot = execute_attr_map_slot(map->attrMap, rootslot,
+												rri->ri_PartitionTupleSlot);
+			else
+				tmpslot = rootslot;
+			if (ExecPartitionCheck(rri, tmpslot, estate, false))
+			{
+				/* and restore ecxt's scantuple */
+				ecxt->ecxt_scantuple = ecxt_scantuple_saved;
+				MemoryContextSwitchTo(oldcxt);
+				return rri;
+			}
+			dispatch->lastPartInfo = rri = NULL;
+		}
+
 		rel = dispatch->reldesc;
 		partdesc = dispatch->partdesc;
 
@@ -372,6 +402,19 @@ ExecFindPartition(ModifyTableState *mtstate,
 			}
 			Assert(rri != NULL);
 
+			/*
+			 * Remember this partition for the next tuple inserted into this
+			 * parent; see at the top of this loop how it's decided whether
+			 * the next tuple can indeed reuse this partition.
+			 *
+			 * Do this only if we have range/list partitions, because only
+			 * in that case it's conceivable that consecutively inserted rows
+			 * tend to go into the same partition.
+			 */
+			if ((dispatch->key->strategy == PARTITION_STRATEGY_RANGE ||
+				 dispatch->key->strategy == PARTITION_STRATEGY_RANGE))
+				dispatch->lastPartInfo = rri;
+
 			/* Signal to terminate the loop */
 			dispatch = NULL;
 		}
@@ -1051,6 +1094,8 @@ ExecInitPartitionDispatchInfo(EState *estate,
 		pd->tupslot = NULL;
 	}
 
+	pd->lastPartInfo = NULL;
+
 	/*
 	 * Initialize with -1 to signify that the corresponding partition's
 	 * ResultRelInfo or PartitionDispatch has not been created yet.

diff --git a/src/backend/executor/execPartition.c b/src/backend/executor/execPartition.c
index 606c920b06..2348eb3154 100644
--- a/src/backend/executor/execPartition.c
+++ b/src/backend/executor/execPartition.c
@@ -133,6 +133,12 @@ struct PartitionTupleRouting
  *		routing it through this table). A NULL value is stored if no tuple
  *		conversion is required.
  *
+ * lastPartInfo
+ * 		If non-NULL, ResultRelInfo for the partition that was most recently
+ * 		chosen as the routing target; ExecFindPartition() checks if the
+ * 		same one can be used for the current row before applying the tuple-
+ * 		routing algorithm to it.
+ *
  * indexes
  *		Array of partdesc->nparts elements.  For leaf partitions the index
  *		corresponds to the partition's ResultRelInfo in the encapsulating
@@ -150,6 +156,7 @@ typedef struct PartitionDispatchData
 	PartitionDesc partdesc;
 	TupleTableSlot *tupslot;
 	AttrMap    *tupmap;
+	ResultRelInfo *lastPartInfo;
 	int			indexes[FLEXIBLE_ARRAY_MEMBER];
 }			PartitionDispatchData;
 
@@ -291,6 +298,35 @@ ExecFindPartition(ModifyTableState *mtstate,
 
 		CHECK_FOR_INTERRUPTS();
 
+		/*
+		 * Check if the saved partition accepts this tuple by evaluating its
+		 * partition constraint against the tuple.  If it does, we save a trip
+		 * to get_partition_for_tuple(), which can be a slightly more expensive
+		 * way to get the same partition, especially if there are many
+		 * partitions to search through.
+		 */
+		if (dispatch->lastPartInfo)
+		{
+			TupleTableSlot *tmpslot;
+			TupleConversionMap *map;
+
+			rri = dispatch->lastPartInfo;
+			map = rri->ri_RootToPartitionMap;
+			if (map)
+				tmpslot = execute_attr_map_slot(map->attrMap, rootslot,
+												rri->ri_PartitionTupleSlot);
+			else
+				tmpslot = rootslot;
+			if (ExecPartitionCheck(rri, tmpslot, estate, false))
+			{
+				/* and restore ecxt's scantuple */
+				ecxt->ecxt_scantuple = ecxt_scantuple_saved;
+				MemoryContextSwitchTo(oldcxt);
+				return rri;
+			}
+			dispatch->lastPartInfo = rri = NULL;
+		}
+
 		rel = dispatch->reldesc;
 		partdesc = dispatch->partdesc;
 
@@ -372,6 +408,19 @@ ExecFindPartition(ModifyTableState *mtstate,
 			}
 			Assert(rri != NULL);
 
+			/*
+			 * Remember this partition for the next tuple inserted into this
+			 * parent; see at the top of this loop how it's decided whether
+			 * the next tuple can indeed reuse this partition.
+			 *
+			 * Do this only if we have range/list partitions, because only
+			 * in that case it's conceivable that consecutively inserted rows
+			 * tend to go into the same partition.
+			 */
+			if ((dispatch->key->strategy == PARTITION_STRATEGY_RANGE ||
+				 dispatch->key->strategy == PARTITION_STRATEGY_LIST))
+				dispatch->lastPartInfo = rri;
+
 			/* Signal to terminate the loop */
 			dispatch = NULL;
 		}
@@ -1051,6 +1100,8 @@ ExecInitPartitionDispatchInfo(EState *estate,
 		pd->tupslot = NULL;
 	}
 
+	pd->lastPartInfo = NULL;
+
 	/*
 	 * Initialize with -1 to signify that the corresponding partition's
 	 * ResultRelInfo or PartitionDispatch has not been created yet.

From 1c2fe94ba8d103d76e41dca2dd0a4198e1e3170f Mon Sep 17 00:00:00 2001
From: houzj <houzj.fnst@cn.fujitsu.com>
Date: Mon, 24 May 2021 08:54:15 +0800
Subject: [PATCH] improving-ExecPartitionCheck

Currently for a normal partition key it will first generate a CHECK expression
Like : [Keyexpression IS NOT NULL AND Keyexpression > lowboud AND Keyexpression < lowboud].
In this case, Keyexpression will be re-executed which will bring some overhead.

Instead, I think we can try to do the following step:
1)extract the Keyexpression from the CHECK expression
2)evaluate the key expression in advance
3)pass the result of key expression to do the partition CHECK.
In this way ,we only execute the key expression once which looks more efficient.

---
 src/backend/commands/tablecmds.c      |   6 +-
 src/backend/executor/execMain.c       | 114 +++++++++++++++++++++-
 src/backend/optimizer/util/plancat.c  |   2 +-
 src/backend/partitioning/partbounds.c | 176 +++++++++++++++++++++++++++++++---
 src/backend/utils/cache/partcache.c   |  48 ++++++++--
 src/backend/utils/cache/relcache.c    |   2 +
 src/include/nodes/execnodes.h         |   9 ++
 src/include/partitioning/partbounds.h |   2 +-
 src/include/partitioning/partdefs.h   |   2 +
 src/include/utils/partcache.h         |   8 +-
 src/include/utils/rel.h               |   1 +
 11 files changed, 344 insertions(+), 26 deletions(-)

diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c
index ebc6203..d0dc337 100644
--- a/src/backend/commands/tablecmds.c
+++ b/src/backend/commands/tablecmds.c
@@ -17279,9 +17279,9 @@ ATExecAttachPartition(List **wqueue, Relation rel, PartitionCmd *cmd,
 	 * If the parent itself is a partition, make sure to include its
 	 * constraint as well.
 	 */
-	partBoundConstraint = get_qual_from_partbound(attachrel, rel, cmd->bound);
+	partBoundConstraint = get_qual_from_partbound(attachrel, rel, cmd->bound, NULL);
 	partConstraint = list_concat(partBoundConstraint,
-								 RelationGetPartitionQual(rel));
+								 RelationGetPartitionQual(rel, NULL));
 
 	/* Skip validation if there are no constraints to validate. */
 	if (partConstraint)
@@ -18083,7 +18083,7 @@ DetachAddConstraintIfNeeded(List **wqueue, Relation partRel)
 {
 	List	   *constraintExpr;
 
-	constraintExpr = RelationGetPartitionQual(partRel);
+	constraintExpr = RelationGetPartitionQual(partRel, NULL);
 	constraintExpr = (List *) eval_const_expressions(NULL, (Node *) constraintExpr);
 
 	/*
diff --git a/src/backend/executor/execMain.c b/src/backend/executor/execMain.c
index b3ce4ba..f2da243 100644
--- a/src/backend/executor/execMain.c
+++ b/src/backend/executor/execMain.c
@@ -53,6 +53,7 @@
 #include "jit/jit.h"
 #include "mb/pg_wchar.h"
 #include "miscadmin.h"
+#include "nodes/nodeFuncs.h"
 #include "parser/parsetree.h"
 #include "storage/bufmgr.h"
 #include "storage/lmgr.h"
@@ -1699,6 +1700,7 @@ ExecPartitionCheck(ResultRelInfo *resultRelInfo, TupleTableSlot *slot,
 {
 	ExprContext *econtext;
 	bool		success;
+	ListCell   *lc;
 
 	/*
 	 * If first time through, build expression state tree for the partition
@@ -1709,12 +1711,80 @@ ExecPartitionCheck(ResultRelInfo *resultRelInfo, TupleTableSlot *slot,
 	 */
 	if (resultRelInfo->ri_PartitionCheckExpr == NULL)
 	{
+		int				i;
+		PartKeyContext	partkeycontext;
+		TupleDesc		tupdesc,
+						coltupdesc;
+		List		   *keyexpr_list;
+
 		/*
 		 * Ensure that the qual tree and prepared expression are in the
 		 * query-lifespan context.
 		 */
 		MemoryContext oldcxt = MemoryContextSwitchTo(estate->es_query_cxt);
-		List	   *qual = RelationGetPartitionQual(resultRelInfo->ri_RelationDesc);
+		List	   *qual;
+
+		/*
+		 * Extract the key expressions from the partition check expression to
+		 * avoid re-execution.
+		 */
+
+		/* The attno for key expr starts after the plain column */
+		partkeycontext.keycol_no = slot->tts_tupleDescriptor->natts + 1;
+		partkeycontext.keyexpr_list = NIL;
+		partkeycontext.keyexpr_varattno = NULL;
+
+		qual = RelationGetPartitionQual(resultRelInfo->ri_RelationDesc,
+										&partkeycontext);
+
+		keyexpr_list = partkeycontext.keyexpr_list;
+		resultRelInfo->ri_PartitionKeyExpr = NIL;
+		resultRelInfo->ri_PartitionKeySlot = NULL;
+
+
+		if (keyexpr_list != NIL)
+		{
+			/*
+			 * Build a slot which contains both the partition key and plain
+			 * column
+			 */
+			coltupdesc = slot->tts_tupleDescriptor;
+
+			tupdesc = CreateTemplateTupleDesc(partkeycontext.keycol_no - 1);
+
+			/* Copy the plain column */
+			TupleDescCopy(tupdesc, coltupdesc);
+
+			/* XXX adjust the natts */
+			tupdesc->natts = partkeycontext.keycol_no - 1;
+
+			/* Save the partition key list */
+			i = coltupdesc->natts + 1;
+			foreach(lc, keyexpr_list)
+			{
+				Node *e = lfirst(lc);
+
+				TupleDescInitEntry(tupdesc, i,
+								   NULL,
+								   exprType(e),
+								   exprTypmod(e),
+								   0);
+
+				TupleDescInitEntryCollation(tupdesc,
+											i,
+											exprCollation(e));
+
+				/* initialize each key expression for execution */
+				resultRelInfo->ri_PartitionKeyExpr =
+					lappend(resultRelInfo->ri_PartitionKeyExpr,
+							ExecPrepareExpr((Expr *) e, estate));
+
+				i++;
+			}
+
+			resultRelInfo->ri_PartitionKeySlot =
+				MakeTupleTableSlot(tupdesc, slot->tts_ops);
+		}
 
 		resultRelInfo->ri_PartitionCheckExpr = ExecPrepareCheck(qual, estate);
 		MemoryContextSwitchTo(oldcxt);
@@ -1726,6 +1796,48 @@ ExecPartitionCheck(ResultRelInfo *resultRelInfo, TupleTableSlot *slot,
 	 */
 	econtext = GetPerTupleExprContext(estate);
 
+	if (resultRelInfo->ri_PartitionKeySlot != NULL)
+		ExecClearTuple(resultRelInfo->ri_PartitionKeySlot);
+
+	/*
+	 * Evaluate the partition expression in advance to avoid re-execution,
+	 * and add the result to the slot to do the partition check.
+	 */
+	foreach(lc, resultRelInfo->ri_PartitionKeyExpr)
+	{
+		Datum		datum;
+		bool		isNull;
+		ExprState  *keystate = lfirst_node(ExprState, lc);
+		int			i = foreach_current_index(lc) +
+						slot->tts_tupleDescriptor->natts;
+
+		econtext->ecxt_scantuple = slot;
+		datum = ExecEvalExprSwitchContext(keystate, econtext, &isNull);
+
+		resultRelInfo->ri_PartitionKeySlot->tts_values[i] = datum;
+		resultRelInfo->ri_PartitionKeySlot->tts_isnull[i] = isNull;
+	}
+
+	/*
+	 * Move the values from original slot to the new slot, then the new data
+	 * is like :
+	 * [col1 , ... colN , keyexpr1's result , ... keyexprN's result]
+	 */
+	if (resultRelInfo->ri_PartitionKeyExpr != NIL)
+	{
+		slot_getallattrs(slot);
+		memcpy(resultRelInfo->ri_PartitionKeySlot->tts_values,
+			   slot->tts_values,
+			   slot->tts_tupleDescriptor->natts * sizeof(Datum));
+
+		memcpy(resultRelInfo->ri_PartitionKeySlot->tts_isnull,
+			   slot->tts_isnull,
+			   slot->tts_tupleDescriptor->natts * sizeof(Datum));
+
+		slot = resultRelInfo->ri_PartitionKeySlot;
+		ExecStoreVirtualTuple(slot);
+	}
+
 	/* Arrange for econtext's scan tuple to be the tuple under test */
 	econtext->ecxt_scantuple = slot;
 
diff --git a/src/backend/optimizer/util/plancat.c b/src/backend/optimizer/util/plancat.c
index c5194fd..f274538 100644
--- a/src/backend/optimizer/util/plancat.c
+++ b/src/backend/optimizer/util/plancat.c
@@ -2399,7 +2399,7 @@ set_baserel_partition_constraint(Relation relation, RelOptInfo *rel)
 	 * implicit-AND format, we'd have to explicitly convert it to explicit-AND
 	 * format and back again.
 	 */
-	partconstr = RelationGetPartitionQual(relation);
+	partconstr = RelationGetPartitionQual(relation, NULL);
 	if (partconstr)
 	{
 		partconstr = (List *) expression_planner((Expr *) partconstr);
diff --git a/src/backend/partitioning/partbounds.c b/src/backend/partitioning/partbounds.c
index 7925fcc..9c551bd 100644
--- a/src/backend/partitioning/partbounds.c
+++ b/src/backend/partitioning/partbounds.c
@@ -231,14 +231,14 @@ static Oid	get_partition_operator(PartitionKey key, int col,
 static List *get_qual_for_hash(Relation parent, PartitionBoundSpec *spec);
 static List *get_qual_for_list(Relation parent, PartitionBoundSpec *spec);
 static List *get_qual_for_range(Relation parent, PartitionBoundSpec *spec,
-								bool for_default);
+								bool for_default, PartKeyContext *context);
 static void get_range_key_properties(PartitionKey key, int keynum,
 									 PartitionRangeDatum *ldatum,
 									 PartitionRangeDatum *udatum,
 									 ListCell **partexprs_item,
 									 Expr **keyCol,
 									 Const **lower_val, Const **upper_val);
-static List *get_range_nulltest(PartitionKey key);
+static List *get_range_nulltest(PartitionKey key, PartKeyContext *context);
 
 /*
  * get_qual_from_partbound
@@ -247,7 +247,7 @@ static List *get_range_nulltest(PartitionKey key);
  */
 List *
 get_qual_from_partbound(Relation rel, Relation parent,
-						PartitionBoundSpec *spec)
+						PartitionBoundSpec *spec, PartKeyContext *context)
 {
 	PartitionKey key = RelationGetPartitionKey(parent);
 	List	   *my_qual = NIL;
@@ -268,7 +268,7 @@ get_qual_from_partbound(Relation rel, Relation parent,
 
 		case PARTITION_STRATEGY_RANGE:
 			Assert(spec->strategy == PARTITION_STRATEGY_RANGE);
-			my_qual = get_qual_for_range(parent, spec, false);
+			my_qual = get_qual_for_range(parent, spec, false, context);
 			break;
 
 		default:
@@ -3153,7 +3153,7 @@ check_default_partition_contents(Relation parent, Relation default_rel,
 
 	new_part_constraints = (new_spec->strategy == PARTITION_STRATEGY_LIST)
 		? get_qual_for_list(parent, new_spec)
-		: get_qual_for_range(parent, new_spec, false);
+		: get_qual_for_range(parent, new_spec, false, NULL);
 	def_part_constraints =
 		get_proposed_default_constraint(new_part_constraints);
 
@@ -4167,7 +4167,7 @@ get_qual_for_list(Relation parent, PartitionBoundSpec *spec)
  */
 static List *
 get_qual_for_range(Relation parent, PartitionBoundSpec *spec,
-				   bool for_default)
+				   bool for_default, PartKeyContext *context)
 {
 	List	   *result = NIL;
 	ListCell   *cell1,
@@ -4190,6 +4190,13 @@ get_qual_for_range(Relation parent, PartitionBoundSpec *spec,
 			   *upper_or_start_datum;
 	bool		need_next_lower_arm,
 				need_next_upper_arm;
+	AttrNumber *keyexpr_varattno = NULL;
+	int			cur_keyexpr_no,
+				old_keyexpr_no;
+
+	if (context != NULL && context->keyexpr_varattno == NULL)
+		context->keyexpr_varattno =
+			palloc0(sizeof(AttrNumber) * list_length(key->partexprs));
 
 	if (spec->is_default)
 	{
@@ -4226,7 +4233,7 @@ get_qual_for_range(Relation parent, PartitionBoundSpec *spec,
 			{
 				List	   *part_qual;
 
-				part_qual = get_qual_for_range(parent, bspec, true);
+				part_qual = get_qual_for_range(parent, bspec, true, context);
 
 				/*
 				 * AND the constraints of the partition and add to
@@ -4251,7 +4258,7 @@ get_qual_for_range(Relation parent, PartitionBoundSpec *spec,
 			 */
 			other_parts_constr =
 				makeBoolExpr(AND_EXPR,
-							 lappend(get_range_nulltest(key),
+							 lappend(get_range_nulltest(key, context),
 									 list_length(or_expr_args) > 1
 									 ? makeBoolExpr(OR_EXPR, or_expr_args,
 													-1)
@@ -4274,7 +4281,13 @@ get_qual_for_range(Relation parent, PartitionBoundSpec *spec,
 	 * to avoid accumulating the NullTest on the same keys for each partition.
 	 */
 	if (!for_default)
-		result = get_range_nulltest(key);
+		result = get_range_nulltest(key, context);
+
+	if (context != NULL)
+		keyexpr_varattno = context->keyexpr_varattno;
+
+	cur_keyexpr_no = 0;
+	old_keyexpr_no = 0;
 
 	/*
 	 * Iterate over the key columns and check if the corresponding lower and
@@ -4295,6 +4308,8 @@ get_qual_for_range(Relation parent, PartitionBoundSpec *spec,
 		ExprState  *test_exprstate;
 		Datum		test_result;
 		bool		isNull;
+		int			key_attno = 0;
+		bool		varattno_saved = false;
 
 		ldatum = castNode(PartitionRangeDatum, lfirst(cell1));
 		udatum = castNode(PartitionRangeDatum, lfirst(cell2));
@@ -4306,12 +4321,33 @@ get_qual_for_range(Relation parent, PartitionBoundSpec *spec,
 		 */
 		partexprs_item_saved = partexprs_item;
 
+		old_keyexpr_no = cur_keyexpr_no;
+
 		get_range_key_properties(key, i, ldatum, udatum,
 								 &partexprs_item,
 								 &keyCol,
 								 &lower_val, &upper_val);
 
 		/*
+		 * Check if we have saved the same key expression, if so , just get
+		 * the attno from keyexpr_varattno
+		 */
+		if (context != NULL && !IsA(keyCol, Var))
+		{
+			if (keyexpr_varattno[cur_keyexpr_no] != 0)
+			{
+				varattno_saved = true;
+				key_attno = keyexpr_varattno[cur_keyexpr_no];
+			}
+			else
+			{
+				varattno_saved = false;
+				key_attno = context->keycol_no;
+			}
+			cur_keyexpr_no++;
+		}
+
+		/*
 		 * If either value is NULL, the corresponding partition bound is
 		 * either MINVALUE or MAXVALUE, and we treat them as unequal, because
 		 * even if they're the same, there is no common value to equate the
@@ -4346,6 +4382,25 @@ get_qual_for_range(Relation parent, PartitionBoundSpec *spec,
 		if (i == key->partnatts - 1)
 			elog(ERROR, "invalid range bound specification");
 
+		/* If key is not a plain column */
+		if (context != NULL && !IsA(keyCol, Var))
+		{
+			/* Save the keyexpr to keyexpr_list if first time meet */
+			if (!varattno_saved)
+			{
+				context->keyexpr_list = lappend(context->keyexpr_list, keyCol);
+				keyexpr_varattno[old_keyexpr_no] = key_attno;
+				context->keycol_no++;
+			}
+
+			keyCol = (Expr *) makeVar(2,
+									key_attno,
+									key->parttypid[i],
+									key->parttypmod[i],
+									key->parttypcoll[i],
+									0);
+		}
+
 		/* Equal, so generate keyCol = lower_val expression */
 		result = lappend(result,
 						 make_partition_op_expr(key, i, BTEqualStrategyNumber,
@@ -4372,11 +4427,16 @@ get_qual_for_range(Relation parent, PartitionBoundSpec *spec,
 		j = i;
 		partexprs_item = partexprs_item_saved;
 
+		cur_keyexpr_no = old_keyexpr_no;
+
 		for_both_cell(cell1, spec->lowerdatums, lower_or_start_datum,
 					  cell2, spec->upperdatums, upper_or_start_datum)
 		{
 			PartitionRangeDatum *ldatum_next = NULL,
 					   *udatum_next = NULL;
+			int			key_attno = 0;
+			bool		varattno_saved = false;
+			Expr		   *temp_keyCol;
 
 			ldatum = castNode(PartitionRangeDatum, lfirst(cell1));
 			if (lnext(spec->lowerdatums, cell1))
@@ -4391,6 +4451,26 @@ get_qual_for_range(Relation parent, PartitionBoundSpec *spec,
 									 &keyCol,
 									 &lower_val, &upper_val);
 
+			/*
+			 * Check if we have saved the same key expression, if so , just get
+			 * the attno from keyexpr_varattno
+			 */
+			temp_keyCol = keyCol;
+			if (context != NULL && !IsA(keyCol, Var))
+			{
+				if (keyexpr_varattno[cur_keyexpr_no] != 0)
+				{
+					varattno_saved = true;
+					key_attno = keyexpr_varattno[cur_keyexpr_no];
+				}
+				else
+				{
+					varattno_saved = false;
+					key_attno = context->keycol_no;
+				}
+				cur_keyexpr_no++;
+			}
+
 			if (need_next_lower_arm && lower_val)
 			{
 				uint16		strategy;
@@ -4410,10 +4490,30 @@ get_qual_for_range(Relation parent, PartitionBoundSpec *spec,
 				else
 					strategy = BTGreaterStrategyNumber;
 
+				/* If key is not a plain column */
+				if (context != NULL && !IsA(keyCol, Var))
+				{
+					/* Save the keyexpr to keyexpr_list if first time meet */
+					if (!varattno_saved)
+					{
+						context->keyexpr_list = lappend(context->keyexpr_list,
+														keyCol);
+						keyexpr_varattno[cur_keyexpr_no - 1] = key_attno;
+						context->keycol_no++;
+					}
+
+					temp_keyCol = (Expr *) makeVar(2,
+											key_attno,
+											key->parttypid[j],
+											key->parttypmod[j],
+											key->parttypcoll[j],
+											0);
+				}
+
 				lower_or_arm_args = lappend(lower_or_arm_args,
 											make_partition_op_expr(key, j,
 																   strategy,
-																   keyCol,
+																   temp_keyCol,
 																   (Expr *) lower_val));
 			}
 
@@ -4434,6 +4534,26 @@ get_qual_for_range(Relation parent, PartitionBoundSpec *spec,
 				else
 					strategy = BTLessStrategyNumber;
 
+				/* If key is not a plain column */
+				if (context != NULL && !IsA(keyCol, Var))
+				{
+					/* Save the keyexpr to keyexpr_list if first time meet */
+					if (keyexpr_varattno[cur_keyexpr_no - 1] == 0)
+					{
+						context->keyexpr_list = lappend(context->keyexpr_list,
+														keyCol);
+						keyexpr_varattno[cur_keyexpr_no - 1] = key_attno;
+						context->keycol_no++;
+					}
+
+					keyCol = (Expr *) makeVar(2,
+											key_attno,
+											key->parttypid[j],
+											key->parttypmod[j],
+											key->parttypcoll[j],
+											0);
+				}
+
 				upper_or_arm_args = lappend(upper_or_arm_args,
 											make_partition_op_expr(key, j,
 																   strategy,
@@ -4506,7 +4626,7 @@ get_qual_for_range(Relation parent, PartitionBoundSpec *spec,
 	 */
 	if (result == NIL)
 		result = for_default
-			? get_range_nulltest(key)
+			? get_range_nulltest(key, context)
 			: list_make1(makeBoolConst(true, false));
 
 	return result;
@@ -4572,13 +4692,15 @@ get_range_key_properties(PartitionKey key, int keynum,
  * keys to be null, so emit an IS NOT NULL expression for each key column.
  */
 static List *
-get_range_nulltest(PartitionKey key)
+get_range_nulltest(PartitionKey key, PartKeyContext *context)
 {
 	List	   *result = NIL;
 	NullTest   *nulltest;
 	ListCell   *partexprs_item;
 	int			i;
+	int			cur_keyexpr_no;
 
+	cur_keyexpr_no = 0;
 	partexprs_item = list_head(key->partexprs);
 	for (i = 0; i < key->partnatts; i++)
 	{
@@ -4598,6 +4720,36 @@ get_range_nulltest(PartitionKey key)
 			if (partexprs_item == NULL)
 				elog(ERROR, "wrong number of partition key expressions");
 			keyCol = copyObject(lfirst(partexprs_item));
+
+			if (context != NULL)
+			{
+				int key_attno;
+
+				if (context->keyexpr_varattno[cur_keyexpr_no] != 0)
+				{
+					key_attno = context->keyexpr_varattno[cur_keyexpr_no];
+				}
+				else
+				{
+					key_attno = context->keycol_no;
+
+					context->keyexpr_list = lappend(context->keyexpr_list,
+													keyCol);
+					context->keyexpr_varattno[cur_keyexpr_no] = key_attno;
+
+					context->keycol_no++;
+				}
+
+				cur_keyexpr_no++;
+
+				keyCol = (Expr *) makeVar(2,
+										key_attno,
+										key->parttypid[i],
+										key->parttypmod[i],
+										key->parttypcoll[i],
+										0);
+			}
+
 			partexprs_item = lnext(key->partexprs, partexprs_item);
 		}
 
diff --git a/src/backend/utils/cache/partcache.c b/src/backend/utils/cache/partcache.c
index 21e60f0..117717b 100644
--- a/src/backend/utils/cache/partcache.c
+++ b/src/backend/utils/cache/partcache.c
@@ -38,7 +38,7 @@
 
 
 static void RelationBuildPartitionKey(Relation relation);
-static List *generate_partition_qual(Relation rel);
+static List *generate_partition_qual(Relation rel, PartKeyContext *context);
 
 /*
  * RelationGetPartitionKey -- get partition key, if relation is partitioned
@@ -273,13 +273,13 @@ RelationBuildPartitionKey(Relation relation)
  * Returns a list of partition quals
  */
 List *
-RelationGetPartitionQual(Relation rel)
+RelationGetPartitionQual(Relation rel, PartKeyContext *context)
 {
 	/* Quick exit */
 	if (!rel->rd_rel->relispartition)
 		return NIL;
 
-	return generate_partition_qual(rel);
+	return generate_partition_qual(rel, context);
 }
 
 /*
@@ -305,7 +305,7 @@ get_partition_qual_relid(Oid relid)
 		Relation	rel = relation_open(relid, AccessShareLock);
 		List	   *and_args;
 
-		and_args = generate_partition_qual(rel);
+		and_args = generate_partition_qual(rel, NULL);
 
 		/* Convert implicit-AND list format to boolean expression */
 		if (and_args == NIL)
@@ -333,7 +333,7 @@ get_partition_qual_relid(Oid relid)
  * into long-lived cache contexts, especially if we fail partway through.
  */
 static List *
-generate_partition_qual(Relation rel)
+generate_partition_qual(Relation rel, PartKeyContext *context)
 {
 	HeapTuple	tuple;
 	MemoryContext oldcxt;
@@ -349,7 +349,18 @@ generate_partition_qual(Relation rel)
 
 	/* If we already cached the result, just return a copy */
 	if (rel->rd_partcheckvalid)
+	{
+		if (context != NULL)
+		{
+			context->keyexpr_list = rel->rd_keyexpr_list;
+			context->keycol_no += list_length(context->keyexpr_list);
+		}
+
 		return copyObject(rel->rd_partcheck);
+	}
+
+	if (context != NULL)
+		context->keyexpr_varattno = NULL;
 
 	/*
 	 * Grab at least an AccessShareLock on the parent table.  Must do this
@@ -376,14 +387,27 @@ generate_partition_qual(Relation rel)
 		bound = castNode(PartitionBoundSpec,
 						 stringToNode(TextDatumGetCString(boundDatum)));
 
-		my_qual = get_qual_from_partbound(rel, parent, bound);
+		my_qual = get_qual_from_partbound(rel, parent, bound, context);
 	}
 
 	ReleaseSysCache(tuple);
 
 	/* Add the parent's quals to the list (if any) */
 	if (parent->rd_rel->relispartition)
-		result = list_concat(generate_partition_qual(parent), my_qual);
+	{
+		List *cur_keyexpr_list;
+		if (context != NULL)
+		{
+			cur_keyexpr_list = context->keyexpr_list;
+			context->keyexpr_list = NIL;
+		}
+
+		result = list_concat(generate_partition_qual(parent, context), my_qual);
+
+		if (context != NULL)
+			context->keyexpr_list = list_concat(context->keyexpr_list,
+					cur_keyexpr_list);
+	}
 	else
 		result = my_qual;
 
@@ -394,10 +418,14 @@ generate_partition_qual(Relation rel)
 	 * here.
 	 */
 	result = map_partition_varattnos(result, 1, rel, parent);
+	if (context != NULL)
+		context->keyexpr_list = map_partition_varattnos(context->keyexpr_list,
+														1, rel, parent);
 
 	/* Assert that we're not leaking any old data during assignments below */
 	Assert(rel->rd_partcheckcxt == NULL);
 	Assert(rel->rd_partcheck == NIL);
+	Assert(rel->rd_keyexpr_list == NIL);
 
 	/*
 	 * Save a copy in the relcache.  The order of these operations is fairly
@@ -416,10 +444,16 @@ generate_partition_qual(Relation rel)
 										  RelationGetRelationName(rel));
 		oldcxt = MemoryContextSwitchTo(rel->rd_partcheckcxt);
 		rel->rd_partcheck = copyObject(result);
+		if (context != NULL)
+			rel->rd_keyexpr_list = copyObject(context->keyexpr_list);
 		MemoryContextSwitchTo(oldcxt);
 	}
 	else
+	{
 		rel->rd_partcheck = NIL;
+		rel->rd_keyexpr_list = NIL;
+	}
+
 	rel->rd_partcheckvalid = true;
 
 	/* Keep the parent locked until commit */
diff --git a/src/backend/utils/cache/relcache.c b/src/backend/utils/cache/relcache.c
index fd05615..f7527da 100644
--- a/src/backend/utils/cache/relcache.c
+++ b/src/backend/utils/cache/relcache.c
@@ -1161,6 +1161,7 @@ RelationBuildDesc(Oid targetRelId, bool insertIt)
 	relation->rd_pdcxt = NULL;
 	relation->rd_pddcxt = NULL;
 	relation->rd_partcheck = NIL;
+	relation->rd_keyexpr_list = NIL;
 	relation->rd_partcheckvalid = false;
 	relation->rd_partcheckcxt = NULL;
 
@@ -6041,6 +6042,7 @@ load_relcache_init_file(bool shared)
 		rel->rd_pdcxt = NULL;
 		rel->rd_pddcxt = NULL;
 		rel->rd_partcheck = NIL;
+		rel->rd_keyexpr_list = NIL;
 		rel->rd_partcheckvalid = false;
 		rel->rd_partcheckcxt = NULL;
 		rel->rd_indexprs = NIL;
diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h
index 7795a69..8dd457c 100644
--- a/src/include/nodes/execnodes.h
+++ b/src/include/nodes/execnodes.h
@@ -497,6 +497,15 @@ typedef struct ResultRelInfo
 	ExprState  *ri_PartitionCheckExpr;
 
 	/*
+	 * Partition Key expressions that used in PartitionCheckExpr
+	 * (NULL if not set up yet)
+	 */
+	List  *ri_PartitionKeyExpr;
+
+	/* Used to evaluate the PartitionCheckExpr (NULL if not set up yet) */
+	TupleTableSlot *ri_PartitionKeySlot;
+
+	/*
 	 * Information needed by tuple routing target relations
 	 *
 	 * RootResultRelInfo gives the target relation mentioned in the query, if
diff --git a/src/include/partitioning/partbounds.h b/src/include/partitioning/partbounds.h
index ebf3ff1..800d4dc 100644
--- a/src/include/partitioning/partbounds.h
+++ b/src/include/partitioning/partbounds.h
@@ -86,7 +86,7 @@ extern uint64 compute_partition_hash_value(int partnatts, FmgrInfo *partsupfunc,
 										   Oid *partcollation,
 										   Datum *values, bool *isnull);
 extern List *get_qual_from_partbound(Relation rel, Relation parent,
-									 PartitionBoundSpec *spec);
+									 PartitionBoundSpec *spec, PartKeyContext *context);
 extern PartitionBoundInfo partition_bounds_create(PartitionBoundSpec **boundspecs,
 												  int nparts, PartitionKey key, int **mapping);
 extern bool partition_bounds_equal(int partnatts, int16 *parttyplen,
diff --git a/src/include/partitioning/partdefs.h b/src/include/partitioning/partdefs.h
index d742b96..be5591c 100644
--- a/src/include/partitioning/partdefs.h
+++ b/src/include/partitioning/partdefs.h
@@ -23,4 +23,6 @@ typedef struct PartitionDescData *PartitionDesc;
 
 typedef struct PartitionDirectoryData *PartitionDirectory;
 
+typedef struct PartKeyContext PartKeyContext;
+
 #endif							/* PARTDEFS_H */
diff --git a/src/include/utils/partcache.h b/src/include/utils/partcache.h
index a451bfb..6f1bcbb 100644
--- a/src/include/utils/partcache.h
+++ b/src/include/utils/partcache.h
@@ -46,9 +46,15 @@ typedef struct PartitionKeyData
 	Oid		   *parttypcoll;
 }			PartitionKeyData;
 
+typedef struct PartKeyContext
+{
+	int keycol_no;
+	List *keyexpr_list;
+	AttrNumber *keyexpr_varattno;
+} PartKeyContext;
 
 extern PartitionKey RelationGetPartitionKey(Relation rel);
-extern List *RelationGetPartitionQual(Relation rel);
+extern List *RelationGetPartitionQual(Relation rel, PartKeyContext *context);
 extern Expr *get_partition_qual_relid(Oid relid);
 
 /*
diff --git a/src/include/utils/rel.h b/src/include/utils/rel.h
index 774ac5b..111287b 100644
--- a/src/include/utils/rel.h
+++ b/src/include/utils/rel.h
@@ -143,6 +143,7 @@ typedef struct RelationData
 
 	/* data managed by RelationGetPartitionQual: */
 	List	   *rd_partcheck;	/* partition CHECK quals */
+	List	   *rd_keyexpr_list;	/* partition key exprs used in CHECK quals */
 	bool		rd_partcheckvalid;	/* true if list has been computed */
 	MemoryContext rd_partcheckcxt;	/* private cxt for rd_partcheck, if any */
 
-- 
2.7.2.windows.1

From 1c2fe94ba8d103d76e41dca2dd0a4198e1e3170f Mon Sep 17 00:00:00 2001
From: houzj <houzj.fnst@cn.fujitsu.com>
Date: Mon, 24 May 2021 08:54:15 +0800
Subject: [PATCH] improving-ExecPartitionCheck

Currently for a normal partition key it will first generate a CHECK expression
Like : [Keyexpression IS NOT NULL AND Keyexpression > lowboud AND Keyexpression < lowboud].
In this case, Keyexpression will be re-executed which will bring some overhead.

Instead, I think we can try to do the following step:
1)extract the Keyexpression from the CHECK expression
2)evaluate the key expression in advance
3)pass the result of key expression to do the partition CHECK.
In this way ,we only execute the key expression once which looks more efficient.

---
 src/backend/commands/tablecmds.c      |   6 +-
 src/backend/executor/execMain.c       | 114 +++++++++++++++++++++-
 src/backend/optimizer/util/plancat.c  |   2 +-
 src/backend/partitioning/partbounds.c | 176 +++++++++++++++++++++++++++++++---
 src/backend/utils/cache/partcache.c   |  48 ++++++++--
 src/backend/utils/cache/relcache.c    |   2 +
 src/include/nodes/execnodes.h         |   9 ++
 src/include/partitioning/partbounds.h |   2 +-
 src/include/partitioning/partdefs.h   |   2 +
 src/include/utils/partcache.h         |   8 +-
 src/include/utils/rel.h               |   1 +
 11 files changed, 344 insertions(+), 26 deletions(-)

diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c
index ebc6203..d0dc337 100644
--- a/src/backend/commands/tablecmds.c
+++ b/src/backend/commands/tablecmds.c
@@ -17279,9 +17279,9 @@ ATExecAttachPartition(List **wqueue, Relation rel, PartitionCmd *cmd,
 	 * If the parent itself is a partition, make sure to include its
 	 * constraint as well.
 	 */
-	partBoundConstraint = get_qual_from_partbound(attachrel, rel, cmd->bound);
+	partBoundConstraint = get_qual_from_partbound(attachrel, rel, cmd->bound, NULL);
 	partConstraint = list_concat(partBoundConstraint,
-								 RelationGetPartitionQual(rel));
+								 RelationGetPartitionQual(rel, NULL));
 
 	/* Skip validation if there are no constraints to validate. */
 	if (partConstraint)
@@ -18083,7 +18083,7 @@ DetachAddConstraintIfNeeded(List **wqueue, Relation partRel)
 {
 	List	   *constraintExpr;
 
-	constraintExpr = RelationGetPartitionQual(partRel);
+	constraintExpr = RelationGetPartitionQual(partRel, NULL);
 	constraintExpr = (List *) eval_const_expressions(NULL, (Node *) constraintExpr);
 
 	/*
diff --git a/src/backend/executor/execMain.c b/src/backend/executor/execMain.c
index b3ce4ba..f2da243 100644
--- a/src/backend/executor/execMain.c
+++ b/src/backend/executor/execMain.c
@@ -53,6 +53,7 @@
 #include "jit/jit.h"
 #include "mb/pg_wchar.h"
 #include "miscadmin.h"
+#include "nodes/nodeFuncs.h"
 #include "parser/parsetree.h"
 #include "storage/bufmgr.h"
 #include "storage/lmgr.h"
@@ -1699,6 +1700,7 @@ ExecPartitionCheck(ResultRelInfo *resultRelInfo, TupleTableSlot *slot,
 {
 	ExprContext *econtext;
 	bool		success;
+	ListCell   *lc;
 
 	/*
 	 * If first time through, build expression state tree for the partition
@@ -1709,12 +1711,80 @@ ExecPartitionCheck(ResultRelInfo *resultRelInfo, TupleTableSlot *slot,
 	 */
 	if (resultRelInfo->ri_PartitionCheckExpr == NULL)
 	{
+		int				i;
+		PartKeyContext	partkeycontext;
+		TupleDesc		tupdesc,
+						coltupdesc;
+		List		   *keyexpr_list;
+
 		/*
 		 * Ensure that the qual tree and prepared expression are in the
 		 * query-lifespan context.
 		 */
 		MemoryContext oldcxt = MemoryContextSwitchTo(estate->es_query_cxt);
-		List	   *qual = RelationGetPartitionQual(resultRelInfo->ri_RelationDesc);
+		List	   *qual;
+
+		/*
+		 * Extract the key expressions from the partition check expression to
+		 * avoid re-execution.
+		 */
+
+		/* The attno for key expr starts after the plain column */
+		partkeycontext.keycol_no = slot->tts_tupleDescriptor->natts + 1;
+		partkeycontext.keyexpr_list = NIL;
+		partkeycontext.keyexpr_varattno = NULL;
+
+		qual = RelationGetPartitionQual(resultRelInfo->ri_RelationDesc,
+										&partkeycontext);
+
+		keyexpr_list = partkeycontext.keyexpr_list;
+		resultRelInfo->ri_PartitionKeyExpr = NIL;
+		resultRelInfo->ri_PartitionKeySlot = NULL;
+
+
+		if (keyexpr_list != NIL)
+		{
+			/*
+			 * Build a slot which contains both the partition key and plain
+			 * column
+			 */
+			coltupdesc = slot->tts_tupleDescriptor;
+
+			tupdesc = CreateTemplateTupleDesc(partkeycontext.keycol_no - 1);
+
+			/* Copy the plain column */
+			TupleDescCopy(tupdesc, coltupdesc);
+
+			/* XXX adjust the natts */
+			tupdesc->natts = partkeycontext.keycol_no - 1;
+
+			/* Save the partition key list */
+			i = coltupdesc->natts + 1;
+			foreach(lc, keyexpr_list)
+			{
+				Node *e = lfirst(lc);
+
+				TupleDescInitEntry(tupdesc, i,
+								   NULL,
+								   exprType(e),
+								   exprTypmod(e),
+								   0);
+
+				TupleDescInitEntryCollation(tupdesc,
+											i,
+											exprCollation(e));
+
+				/* initialize each key expression for execution */
+				resultRelInfo->ri_PartitionKeyExpr =
+					lappend(resultRelInfo->ri_PartitionKeyExpr,
+							ExecPrepareExpr((Expr *) e, estate));
+
+				i++;
+			}
+
+			resultRelInfo->ri_PartitionKeySlot =
+				MakeTupleTableSlot(tupdesc, slot->tts_ops);
+		}
 
 		resultRelInfo->ri_PartitionCheckExpr = ExecPrepareCheck(qual, estate);
 		MemoryContextSwitchTo(oldcxt);
@@ -1726,6 +1796,48 @@ ExecPartitionCheck(ResultRelInfo *resultRelInfo, TupleTableSlot *slot,
 	 */
 	econtext = GetPerTupleExprContext(estate);
 
+	if (resultRelInfo->ri_PartitionKeySlot != NULL)
+		ExecClearTuple(resultRelInfo->ri_PartitionKeySlot);
+
+	/*
+	 * Evaluate the partition expression in advance to avoid re-execution,
+	 * and add the result to the slot to do the partition check.
+	 */
+	foreach(lc, resultRelInfo->ri_PartitionKeyExpr)
+	{
+		Datum		datum;
+		bool		isNull;
+		ExprState  *keystate = lfirst_node(ExprState, lc);
+		int			i = foreach_current_index(lc) +
+						slot->tts_tupleDescriptor->natts;
+
+		econtext->ecxt_scantuple = slot;
+		datum = ExecEvalExprSwitchContext(keystate, econtext, &isNull);
+
+		resultRelInfo->ri_PartitionKeySlot->tts_values[i] = datum;
+		resultRelInfo->ri_PartitionKeySlot->tts_isnull[i] = isNull;
+	}
+
+	/*
+	 * Move the values from original slot to the new slot, then the new data
+	 * is like :
+	 * [col1 , ... colN , keyexpr1's result , ... keyexprN's result]
+	 */
+	if (resultRelInfo->ri_PartitionKeyExpr != NIL)
+	{
+		slot_getallattrs(slot);
+		memcpy(resultRelInfo->ri_PartitionKeySlot->tts_values,
+			   slot->tts_values,
+			   slot->tts_tupleDescriptor->natts * sizeof(Datum));
+
+		memcpy(resultRelInfo->ri_PartitionKeySlot->tts_isnull,
+			   slot->tts_isnull,
+			   slot->tts_tupleDescriptor->natts * sizeof(Datum));
+
+		slot = resultRelInfo->ri_PartitionKeySlot;
+		ExecStoreVirtualTuple(slot);
+	}
+
 	/* Arrange for econtext's scan tuple to be the tuple under test */
 	econtext->ecxt_scantuple = slot;
 
diff --git a/src/backend/optimizer/util/plancat.c b/src/backend/optimizer/util/plancat.c
index c5194fd..f274538 100644
--- a/src/backend/optimizer/util/plancat.c
+++ b/src/backend/optimizer/util/plancat.c
@@ -2399,7 +2399,7 @@ set_baserel_partition_constraint(Relation relation, RelOptInfo *rel)
 	 * implicit-AND format, we'd have to explicitly convert it to explicit-AND
 	 * format and back again.
 	 */
-	partconstr = RelationGetPartitionQual(relation);
+	partconstr = RelationGetPartitionQual(relation, NULL);
 	if (partconstr)
 	{
 		partconstr = (List *) expression_planner((Expr *) partconstr);
diff --git a/src/backend/partitioning/partbounds.c b/src/backend/partitioning/partbounds.c
index 7925fcc..9c551bd 100644
--- a/src/backend/partitioning/partbounds.c
+++ b/src/backend/partitioning/partbounds.c
@@ -231,14 +231,14 @@ static Oid	get_partition_operator(PartitionKey key, int col,
 static List *get_qual_for_hash(Relation parent, PartitionBoundSpec *spec);
 static List *get_qual_for_list(Relation parent, PartitionBoundSpec *spec);
 static List *get_qual_for_range(Relation parent, PartitionBoundSpec *spec,
-								bool for_default);
+								bool for_default, PartKeyContext *context);
 static void get_range_key_properties(PartitionKey key, int keynum,
 									 PartitionRangeDatum *ldatum,
 									 PartitionRangeDatum *udatum,
 									 ListCell **partexprs_item,
 									 Expr **keyCol,
 									 Const **lower_val, Const **upper_val);
-static List *get_range_nulltest(PartitionKey key);
+static List *get_range_nulltest(PartitionKey key, PartKeyContext *context);
 
 /*
  * get_qual_from_partbound
@@ -247,7 +247,7 @@ static List *get_range_nulltest(PartitionKey key);
  */
 List *
 get_qual_from_partbound(Relation rel, Relation parent,
-						PartitionBoundSpec *spec)
+						PartitionBoundSpec *spec, PartKeyContext *context)
 {
 	PartitionKey key = RelationGetPartitionKey(parent);
 	List	   *my_qual = NIL;
@@ -268,7 +268,7 @@ get_qual_from_partbound(Relation rel, Relation parent,
 
 		case PARTITION_STRATEGY_RANGE:
 			Assert(spec->strategy == PARTITION_STRATEGY_RANGE);
-			my_qual = get_qual_for_range(parent, spec, false);
+			my_qual = get_qual_for_range(parent, spec, false, context);
 			break;
 
 		default:
@@ -3153,7 +3153,7 @@ check_default_partition_contents(Relation parent, Relation default_rel,
 
 	new_part_constraints = (new_spec->strategy == PARTITION_STRATEGY_LIST)
 		? get_qual_for_list(parent, new_spec)
-		: get_qual_for_range(parent, new_spec, false);
+		: get_qual_for_range(parent, new_spec, false, NULL);
 	def_part_constraints =
 		get_proposed_default_constraint(new_part_constraints);
 
@@ -4167,7 +4167,7 @@ get_qual_for_list(Relation parent, PartitionBoundSpec *spec)
  */
 static List *
 get_qual_for_range(Relation parent, PartitionBoundSpec *spec,
-				   bool for_default)
+				   bool for_default, PartKeyContext *context)
 {
 	List	   *result = NIL;
 	ListCell   *cell1,
@@ -4190,6 +4190,13 @@ get_qual_for_range(Relation parent, PartitionBoundSpec *spec,
 			   *upper_or_start_datum;
 	bool		need_next_lower_arm,
 				need_next_upper_arm;
+	AttrNumber *keyexpr_varattno = NULL;
+	int			cur_keyexpr_no,
+				old_keyexpr_no;
+
+	if (context != NULL && context->keyexpr_varattno == NULL)
+		context->keyexpr_varattno =
+			palloc0(sizeof(AttrNumber) * list_length(key->partexprs));
 
 	if (spec->is_default)
 	{
@@ -4226,7 +4233,7 @@ get_qual_for_range(Relation parent, PartitionBoundSpec *spec,
 			{
 				List	   *part_qual;
 
-				part_qual = get_qual_for_range(parent, bspec, true);
+				part_qual = get_qual_for_range(parent, bspec, true, context);
 
 				/*
 				 * AND the constraints of the partition and add to
@@ -4251,7 +4258,7 @@ get_qual_for_range(Relation parent, PartitionBoundSpec *spec,
 			 */
 			other_parts_constr =
 				makeBoolExpr(AND_EXPR,
-							 lappend(get_range_nulltest(key),
+							 lappend(get_range_nulltest(key, context),
 									 list_length(or_expr_args) > 1
 									 ? makeBoolExpr(OR_EXPR, or_expr_args,
 													-1)
@@ -4274,7 +4281,13 @@ get_qual_for_range(Relation parent, PartitionBoundSpec *spec,
 	 * to avoid accumulating the NullTest on the same keys for each partition.
 	 */
 	if (!for_default)
-		result = get_range_nulltest(key);
+		result = get_range_nulltest(key, context);
+
+	if (context != NULL)
+		keyexpr_varattno = context->keyexpr_varattno;
+
+	cur_keyexpr_no = 0;
+	old_keyexpr_no = 0;
 
 	/*
 	 * Iterate over the key columns and check if the corresponding lower and
@@ -4295,6 +4308,8 @@ get_qual_for_range(Relation parent, PartitionBoundSpec *spec,
 		ExprState  *test_exprstate;
 		Datum		test_result;
 		bool		isNull;
+		int			key_attno = 0;
+		bool		varattno_saved = false;
 
 		ldatum = castNode(PartitionRangeDatum, lfirst(cell1));
 		udatum = castNode(PartitionRangeDatum, lfirst(cell2));
@@ -4306,12 +4321,33 @@ get_qual_for_range(Relation parent, PartitionBoundSpec *spec,
 		 */
 		partexprs_item_saved = partexprs_item;
 
+		old_keyexpr_no = cur_keyexpr_no;
+
 		get_range_key_properties(key, i, ldatum, udatum,
 								 &partexprs_item,
 								 &keyCol,
 								 &lower_val, &upper_val);
 
 		/*
+		 * Check if we have saved the same key expression, if so , just get
+		 * the attno from keyexpr_varattno
+		 */
+		if (context != NULL && !IsA(keyCol, Var))
+		{
+			if (keyexpr_varattno[cur_keyexpr_no] != 0)
+			{
+				varattno_saved = true;
+				key_attno = keyexpr_varattno[cur_keyexpr_no];
+			}
+			else
+			{
+				varattno_saved = false;
+				key_attno = context->keycol_no;
+			}
+			cur_keyexpr_no++;
+		}
+
+		/*
 		 * If either value is NULL, the corresponding partition bound is
 		 * either MINVALUE or MAXVALUE, and we treat them as unequal, because
 		 * even if they're the same, there is no common value to equate the
@@ -4346,6 +4382,25 @@ get_qual_for_range(Relation parent, PartitionBoundSpec *spec,
 		if (i == key->partnatts - 1)
 			elog(ERROR, "invalid range bound specification");
 
+		/* If key is not a plain column */
+		if (context != NULL && !IsA(keyCol, Var))
+		{
+			/* Save the keyexpr to keyexpr_list if first time meet */
+			if (!varattno_saved)
+			{
+				context->keyexpr_list = lappend(context->keyexpr_list, keyCol);
+				keyexpr_varattno[old_keyexpr_no] = key_attno;
+				context->keycol_no++;
+			}
+
+			keyCol = (Expr *) makeVar(2,
+									key_attno,
+									key->parttypid[i],
+									key->parttypmod[i],
+									key->parttypcoll[i],
+									0);
+		}
+
 		/* Equal, so generate keyCol = lower_val expression */
 		result = lappend(result,
 						 make_partition_op_expr(key, i, BTEqualStrategyNumber,
@@ -4372,11 +4427,16 @@ get_qual_for_range(Relation parent, PartitionBoundSpec *spec,
 		j = i;
 		partexprs_item = partexprs_item_saved;
 
+		cur_keyexpr_no = old_keyexpr_no;
+
 		for_both_cell(cell1, spec->lowerdatums, lower_or_start_datum,
 					  cell2, spec->upperdatums, upper_or_start_datum)
 		{
 			PartitionRangeDatum *ldatum_next = NULL,
 					   *udatum_next = NULL;
+			int			key_attno = 0;
+			bool		varattno_saved = false;
+			Expr		   *temp_keyCol;
 
 			ldatum = castNode(PartitionRangeDatum, lfirst(cell1));
 			if (lnext(spec->lowerdatums, cell1))
@@ -4391,6 +4451,26 @@ get_qual_for_range(Relation parent, PartitionBoundSpec *spec,
 									 &keyCol,
 									 &lower_val, &upper_val);
 
+			/*
+			 * Check if we have saved the same key expression, if so , just get
+			 * the attno from keyexpr_varattno
+			 */
+			temp_keyCol = keyCol;
+			if (context != NULL && !IsA(keyCol, Var))
+			{
+				if (keyexpr_varattno[cur_keyexpr_no] != 0)
+				{
+					varattno_saved = true;
+					key_attno = keyexpr_varattno[cur_keyexpr_no];
+				}
+				else
+				{
+					varattno_saved = false;
+					key_attno = context->keycol_no;
+				}
+				cur_keyexpr_no++;
+			}
+
 			if (need_next_lower_arm && lower_val)
 			{
 				uint16		strategy;
@@ -4410,10 +4490,30 @@ get_qual_for_range(Relation parent, PartitionBoundSpec *spec,
 				else
 					strategy = BTGreaterStrategyNumber;
 
+				/* If key is not a plain column */
+				if (context != NULL && !IsA(keyCol, Var))
+				{
+					/* Save the keyexpr to keyexpr_list if first time meet */
+					if (!varattno_saved)
+					{
+						context->keyexpr_list = lappend(context->keyexpr_list,
+														keyCol);
+						keyexpr_varattno[cur_keyexpr_no - 1] = key_attno;
+						context->keycol_no++;
+					}
+
+					temp_keyCol = (Expr *) makeVar(2,
+											key_attno,
+											key->parttypid[j],
+											key->parttypmod[j],
+											key->parttypcoll[j],
+											0);
+				}
+
 				lower_or_arm_args = lappend(lower_or_arm_args,
 											make_partition_op_expr(key, j,
 																   strategy,
-																   keyCol,
+																   temp_keyCol,
 																   (Expr *) lower_val));
 			}
 
@@ -4434,6 +4534,26 @@ get_qual_for_range(Relation parent, PartitionBoundSpec *spec,
 				else
 					strategy = BTLessStrategyNumber;
 
+				/* If key is not a plain column */
+				if (context != NULL && !IsA(keyCol, Var))
+				{
+					/* Save the keyexpr to keyexpr_list if first time meet */
+					if (keyexpr_varattno[cur_keyexpr_no - 1] == 0)
+					{
+						context->keyexpr_list = lappend(context->keyexpr_list,
+														keyCol);
+						keyexpr_varattno[cur_keyexpr_no - 1] = key_attno;
+						context->keycol_no++;
+					}
+
+					keyCol = (Expr *) makeVar(2,
+											key_attno,
+											key->parttypid[j],
+											key->parttypmod[j],
+											key->parttypcoll[j],
+											0);
+				}
+
 				upper_or_arm_args = lappend(upper_or_arm_args,
 											make_partition_op_expr(key, j,
 																   strategy,
@@ -4506,7 +4626,7 @@ get_qual_for_range(Relation parent, PartitionBoundSpec *spec,
 	 */
 	if (result == NIL)
 		result = for_default
-			? get_range_nulltest(key)
+			? get_range_nulltest(key, context)
 			: list_make1(makeBoolConst(true, false));
 
 	return result;
@@ -4572,13 +4692,15 @@ get_range_key_properties(PartitionKey key, int keynum,
  * keys to be null, so emit an IS NOT NULL expression for each key column.
  */
 static List *
-get_range_nulltest(PartitionKey key)
+get_range_nulltest(PartitionKey key, PartKeyContext *context)
 {
 	List	   *result = NIL;
 	NullTest   *nulltest;
 	ListCell   *partexprs_item;
 	int			i;
+	int			cur_keyexpr_no;
 
+	cur_keyexpr_no = 0;
 	partexprs_item = list_head(key->partexprs);
 	for (i = 0; i < key->partnatts; i++)
 	{
@@ -4598,6 +4720,36 @@ get_range_nulltest(PartitionKey key)
 			if (partexprs_item == NULL)
 				elog(ERROR, "wrong number of partition key expressions");
 			keyCol = copyObject(lfirst(partexprs_item));
+
+			if (context != NULL)
+			{
+				int key_attno;
+
+				if (context->keyexpr_varattno[cur_keyexpr_no] != 0)
+				{
+					key_attno = context->keyexpr_varattno[cur_keyexpr_no];
+				}
+				else
+				{
+					key_attno = context->keycol_no;
+
+					context->keyexpr_list = lappend(context->keyexpr_list,
+													keyCol);
+					context->keyexpr_varattno[cur_keyexpr_no] = key_attno;
+
+					context->keycol_no++;
+				}
+
+				cur_keyexpr_no++;
+
+				keyCol = (Expr *) makeVar(2,
+										key_attno,
+										key->parttypid[i],
+										key->parttypmod[i],
+										key->parttypcoll[i],
+										0);
+			}
+
 			partexprs_item = lnext(key->partexprs, partexprs_item);
 		}
 
diff --git a/src/backend/utils/cache/partcache.c b/src/backend/utils/cache/partcache.c
index 21e60f0..117717b 100644
--- a/src/backend/utils/cache/partcache.c
+++ b/src/backend/utils/cache/partcache.c
@@ -38,7 +38,7 @@
 
 
 static void RelationBuildPartitionKey(Relation relation);
-static List *generate_partition_qual(Relation rel);
+static List *generate_partition_qual(Relation rel, PartKeyContext *context);
 
 /*
  * RelationGetPartitionKey -- get partition key, if relation is partitioned
@@ -273,13 +273,13 @@ RelationBuildPartitionKey(Relation relation)
  * Returns a list of partition quals
  */
 List *
-RelationGetPartitionQual(Relation rel)
+RelationGetPartitionQual(Relation rel, PartKeyContext *context)
 {
 	/* Quick exit */
 	if (!rel->rd_rel->relispartition)
 		return NIL;
 
-	return generate_partition_qual(rel);
+	return generate_partition_qual(rel, context);
 }
 
 /*
@@ -305,7 +305,7 @@ get_partition_qual_relid(Oid relid)
 		Relation	rel = relation_open(relid, AccessShareLock);
 		List	   *and_args;
 
-		and_args = generate_partition_qual(rel);
+		and_args = generate_partition_qual(rel, NULL);
 
 		/* Convert implicit-AND list format to boolean expression */
 		if (and_args == NIL)
@@ -333,7 +333,7 @@ get_partition_qual_relid(Oid relid)
  * into long-lived cache contexts, especially if we fail partway through.
  */
 static List *
-generate_partition_qual(Relation rel)
+generate_partition_qual(Relation rel, PartKeyContext *context)
 {
 	HeapTuple	tuple;
 	MemoryContext oldcxt;
@@ -349,7 +349,18 @@ generate_partition_qual(Relation rel)
 
 	/* If we already cached the result, just return a copy */
 	if (rel->rd_partcheckvalid)
+	{
+		if (context != NULL)
+		{
+			context->keyexpr_list = rel->rd_keyexpr_list;
+			context->keycol_no += list_length(context->keyexpr_list);
+		}
+
 		return copyObject(rel->rd_partcheck);
+	}
+
+	if (context != NULL)
+		context->keyexpr_varattno = NULL;
 
 	/*
 	 * Grab at least an AccessShareLock on the parent table.  Must do this
@@ -376,14 +387,27 @@ generate_partition_qual(Relation rel)
 		bound = castNode(PartitionBoundSpec,
 						 stringToNode(TextDatumGetCString(boundDatum)));
 
-		my_qual = get_qual_from_partbound(rel, parent, bound);
+		my_qual = get_qual_from_partbound(rel, parent, bound, context);
 	}
 
 	ReleaseSysCache(tuple);
 
 	/* Add the parent's quals to the list (if any) */
 	if (parent->rd_rel->relispartition)
-		result = list_concat(generate_partition_qual(parent), my_qual);
+	{
+		List *cur_keyexpr_list;
+		if (context != NULL)
+		{
+			cur_keyexpr_list = context->keyexpr_list;
+			context->keyexpr_list = NIL;
+		}
+
+		result = list_concat(generate_partition_qual(parent, context), my_qual);
+
+		if (context != NULL)
+			context->keyexpr_list = list_concat(context->keyexpr_list,
+					cur_keyexpr_list);
+	}
 	else
 		result = my_qual;
 
@@ -394,10 +418,14 @@ generate_partition_qual(Relation rel)
 	 * here.
 	 */
 	result = map_partition_varattnos(result, 1, rel, parent);
+	if (context != NULL)
+		context->keyexpr_list = map_partition_varattnos(context->keyexpr_list,
+														1, rel, parent);
 
 	/* Assert that we're not leaking any old data during assignments below */
 	Assert(rel->rd_partcheckcxt == NULL);
 	Assert(rel->rd_partcheck == NIL);
+	Assert(rel->rd_keyexpr_list == NIL);
 
 	/*
 	 * Save a copy in the relcache.  The order of these operations is fairly
@@ -416,10 +444,16 @@ generate_partition_qual(Relation rel)
 										  RelationGetRelationName(rel));
 		oldcxt = MemoryContextSwitchTo(rel->rd_partcheckcxt);
 		rel->rd_partcheck = copyObject(result);
+		if (context != NULL)
+			rel->rd_keyexpr_list = copyObject(context->keyexpr_list);
 		MemoryContextSwitchTo(oldcxt);
 	}
 	else
+	{
 		rel->rd_partcheck = NIL;
+		rel->rd_keyexpr_list = NIL;
+	}
+
 	rel->rd_partcheckvalid = true;
 
 	/* Keep the parent locked until commit */
diff --git a/src/backend/utils/cache/relcache.c b/src/backend/utils/cache/relcache.c
index fd05615..f7527da 100644
--- a/src/backend/utils/cache/relcache.c
+++ b/src/backend/utils/cache/relcache.c
@@ -1161,6 +1161,7 @@ RelationBuildDesc(Oid targetRelId, bool insertIt)
 	relation->rd_pdcxt = NULL;
 	relation->rd_pddcxt = NULL;
 	relation->rd_partcheck = NIL;
+	relation->rd_keyexpr_list = NIL;
 	relation->rd_partcheckvalid = false;
 	relation->rd_partcheckcxt = NULL;
 
@@ -6041,6 +6042,7 @@ load_relcache_init_file(bool shared)
 		rel->rd_pdcxt = NULL;
 		rel->rd_pddcxt = NULL;
 		rel->rd_partcheck = NIL;
+		rel->rd_keyexpr_list = NIL;
 		rel->rd_partcheckvalid = false;
 		rel->rd_partcheckcxt = NULL;
 		rel->rd_indexprs = NIL;
diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h
index 7795a69..8dd457c 100644
--- a/src/include/nodes/execnodes.h
+++ b/src/include/nodes/execnodes.h
@@ -497,6 +497,15 @@ typedef struct ResultRelInfo
 	ExprState  *ri_PartitionCheckExpr;
 
 	/*
+	 * Partition Key expressions that used in PartitionCheckExpr
+	 * (NULL if not set up yet)
+	 */
+	List  *ri_PartitionKeyExpr;
+
+	/* Used to evaluate the PartitionCheckExpr (NULL if not set up yet) */
+	TupleTableSlot *ri_PartitionKeySlot;
+
+	/*
 	 * Information needed by tuple routing target relations
 	 *
 	 * RootResultRelInfo gives the target relation mentioned in the query, if
diff --git a/src/include/partitioning/partbounds.h b/src/include/partitioning/partbounds.h
index ebf3ff1..800d4dc 100644
--- a/src/include/partitioning/partbounds.h
+++ b/src/include/partitioning/partbounds.h
@@ -86,7 +86,7 @@ extern uint64 compute_partition_hash_value(int partnatts, FmgrInfo *partsupfunc,
 										   Oid *partcollation,
 										   Datum *values, bool *isnull);
 extern List *get_qual_from_partbound(Relation rel, Relation parent,
-									 PartitionBoundSpec *spec);
+									 PartitionBoundSpec *spec, PartKeyContext *context);
 extern PartitionBoundInfo partition_bounds_create(PartitionBoundSpec **boundspecs,
 												  int nparts, PartitionKey key, int **mapping);
 extern bool partition_bounds_equal(int partnatts, int16 *parttyplen,
diff --git a/src/include/partitioning/partdefs.h b/src/include/partitioning/partdefs.h
index d742b96..be5591c 100644
--- a/src/include/partitioning/partdefs.h
+++ b/src/include/partitioning/partdefs.h
@@ -23,4 +23,6 @@ typedef struct PartitionDescData *PartitionDesc;
 
 typedef struct PartitionDirectoryData *PartitionDirectory;
 
+typedef struct PartKeyContext PartKeyContext;
+
 #endif							/* PARTDEFS_H */
diff --git a/src/include/utils/partcache.h b/src/include/utils/partcache.h
index a451bfb..6f1bcbb 100644
--- a/src/include/utils/partcache.h
+++ b/src/include/utils/partcache.h
@@ -46,9 +46,15 @@ typedef struct PartitionKeyData
 	Oid		   *parttypcoll;
 }			PartitionKeyData;
 
+struct PartKeyContext
+{
+	int keycol_no;
+	List *keyexpr_list;
+	AttrNumber *keyexpr_varattno;
+};
 
 extern PartitionKey RelationGetPartitionKey(Relation rel);
-extern List *RelationGetPartitionQual(Relation rel);
+extern List *RelationGetPartitionQual(Relation rel, PartKeyContext *context);
 extern Expr *get_partition_qual_relid(Oid relid);
 
 /*
diff --git a/src/include/utils/rel.h b/src/include/utils/rel.h
index 774ac5b..111287b 100644
--- a/src/include/utils/rel.h
+++ b/src/include/utils/rel.h
@@ -143,6 +143,7 @@ typedef struct RelationData
 
 	/* data managed by RelationGetPartitionQual: */
 	List	   *rd_partcheck;	/* partition CHECK quals */
+	List	   *rd_keyexpr_list;	/* partition key exprs used in CHECK quals */
 	bool		rd_partcheckvalid;	/* true if list has been computed */
 	MemoryContext rd_partcheckcxt;	/* private cxt for rd_partcheck, if any */
 
-- 
2.7.2.windows.1

diff --git a/src/backend/commands/copyfrom.c b/src/backend/commands/copyfrom.c
index 40a54ad0bd..50eb019da5 100644
--- a/src/backend/commands/copyfrom.c
+++ b/src/backend/commands/copyfrom.c
@@ -1042,7 +1042,8 @@ CopyFrom(CopyFromState cstate)
 				 */
 				if (resultRelInfo->ri_RelationDesc->rd_rel->relispartition &&
 					(proute == NULL || has_before_insert_row_trig))
-					ExecPartitionCheck(resultRelInfo, myslot, estate, true);
+					ExecPartitionCheck(resultRelInfo, myslot, estate, NULL,
+									   true);
 
 				/* Store the slot in the multi-insert buffer, when enabled. */
 				if (insertMethod == CIM_MULTI || leafpart_use_multi_insert)
diff --git a/src/backend/commands/trigger.c b/src/backend/commands/trigger.c
index 07c73f39de..8fc647cd0e 100644
--- a/src/backend/commands/trigger.c
+++ b/src/backend/commands/trigger.c
@@ -2288,7 +2288,7 @@ ExecBRInsertTriggers(EState *estate, ResultRelInfo *relinfo,
 			 * longer fits the partition.  Verify that.
 			 */
 			if (trigger->tgisclone &&
-				!ExecPartitionCheck(relinfo, slot, estate, false))
+				!ExecPartitionCheck(relinfo, slot, estate, NULL, false))
 				ereport(ERROR,
 						(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 						 errmsg("moving row to another partition during a BEFORE FOR EACH ROW trigger is not supported"),
diff --git a/src/backend/executor/execMain.c b/src/backend/executor/execMain.c
index b3ce4bae53..8ddbc6d0c2 100644
--- a/src/backend/executor/execMain.c
+++ b/src/backend/executor/execMain.c
@@ -44,6 +44,7 @@
 #include "access/transam.h"
 #include "access/xact.h"
 #include "catalog/namespace.h"
+#include "catalog/partition.h"
 #include "catalog/pg_publication.h"
 #include "commands/matview.h"
 #include "commands/trigger.h"
@@ -52,6 +53,8 @@
 #include "foreign/fdwapi.h"
 #include "jit/jit.h"
 #include "mb/pg_wchar.h"
+#include "nodes/makefuncs.h"
+#include "nodes/nodeFuncs.h"
 #include "miscadmin.h"
 #include "parser/parsetree.h"
 #include "storage/bufmgr.h"
@@ -1686,6 +1689,32 @@ ExecRelCheck(ResultRelInfo *resultRelInfo,
 	return NULL;
 }
 
+/*
+ * Replaces the occurrence of cxt->matchexpr in the expression tree given by
+ * 'node' by an OUTER var with provided attribute number.
+ */
+typedef struct
+{
+	Expr	   *matchexpr;
+	AttrNumber	varattno;
+} replace_partexpr_with_dummy_var_context;
+
+static Node *
+replace_partexpr_with_dummy_var(Node *node,
+								replace_partexpr_with_dummy_var_context *cxt)
+{
+	if (node == NULL)
+		return NULL;
+
+	if (equal(node, cxt->matchexpr))
+		return (Node *) makeVar(OUTER_VAR, cxt->varattno,
+								exprType(node), exprTypmod(node),
+								exprCollation(node), 0);
+
+	return expression_tree_mutator(node, replace_partexpr_with_dummy_var,
+								   (void *) cxt);
+}
+
 /*
  * ExecPartitionCheck --- check that tuple meets the partition constraint.
  *
@@ -1695,7 +1724,7 @@ ExecRelCheck(ResultRelInfo *resultRelInfo,
  */
 bool
 ExecPartitionCheck(ResultRelInfo *resultRelInfo, TupleTableSlot *slot,
-				   EState *estate, bool emitError)
+				   EState *estate, Relation parentrel, bool emitError)
 {
 	ExprContext *econtext;
 	bool		success;
@@ -1716,6 +1745,50 @@ ExecPartitionCheck(ResultRelInfo *resultRelInfo, TupleTableSlot *slot,
 		MemoryContext oldcxt = MemoryContextSwitchTo(estate->es_query_cxt);
 		List	   *qual = RelationGetPartitionQual(resultRelInfo->ri_RelationDesc);
 
+		/*
+		 * If we have been passed the parent relation, optimize the evaluation
+		 * of partition key expressions.  The way we do that is by replacing
+		 * any occurrences of the individual expressions in this relation's
+		 * partition constraint by dummy Vars marked as coming from the
+		 * "OUTER" relation.  Then when actually executing such modified
+		 * partition constraint tree, we feed the actual partition expression
+		 * values via econtext->ecxt_outertuple; see below.
+		 */
+		if (parentrel)
+		{
+			replace_partexpr_with_dummy_var_context cxt;
+			List   *partexprs = RelationGetPartitionKey(parentrel)->partexprs;
+			ListCell *lc;
+			AttrNumber attrno = 1;
+			TupleDesc	partexprs_tupdesc;
+
+			partexprs_tupdesc = CreateTemplateTupleDesc(list_length(partexprs));
+
+			partexprs = map_partition_varattnos(partexprs, 1,
+												resultRelInfo->ri_RelationDesc,
+												parentrel);
+			foreach(lc, partexprs)
+			{
+				Expr   *expr = lfirst(lc);
+
+				cxt.matchexpr = expr;
+				cxt.varattno = attrno;
+				qual = (List *) replace_partexpr_with_dummy_var((Node *) qual,
+																&cxt);
+
+				resultRelInfo->ri_partitionKeyExprs =
+					lappend(resultRelInfo->ri_partitionKeyExprs,
+							ExecPrepareExpr(expr, estate));
+				TupleDescInitEntry(partexprs_tupdesc, attrno, NULL,
+								   exprType((Node *) expr),
+								   exprTypmod((Node *) expr), 0);
+				attrno++;
+			}
+
+			resultRelInfo->ri_partitionKeyExprsSlot =
+				ExecInitExtraTupleSlot(estate, partexprs_tupdesc, &TTSOpsVirtual);
+		}
+
 		resultRelInfo->ri_PartitionCheckExpr = ExecPrepareCheck(qual, estate);
 		MemoryContextSwitchTo(oldcxt);
 	}
@@ -1729,6 +1802,33 @@ ExecPartitionCheck(ResultRelInfo *resultRelInfo, TupleTableSlot *slot,
 	/* Arrange for econtext's scan tuple to be the tuple under test */
 	econtext->ecxt_scantuple = slot;
 
+	if (resultRelInfo->ri_partitionKeyExprs)
+	{
+		TupleTableSlot *partexprs_slot = resultRelInfo->ri_partitionKeyExprsSlot;
+		Datum	*values;
+		bool	*isnull;
+		ListCell *lc;
+		AttrNumber attrno = 1;
+
+		Assert(partexprs_slot != NULL);
+		ExecClearTuple(partexprs_slot);
+
+		values = partexprs_slot->tts_values;
+		isnull = partexprs_slot->tts_isnull;
+
+		foreach(lc, resultRelInfo->ri_partitionKeyExprs)
+		{
+			ExprState   *partexpr = lfirst(lc);
+
+			values[attrno-1] = ExecEvalExprSwitchContext(partexpr, econtext,
+												  &isnull[attrno-1]);
+			attrno++;
+		}
+		ExecStoreVirtualTuple(partexprs_slot);
+
+		econtext->ecxt_outertuple = partexprs_slot;
+	}
+
 	/*
 	 * As in case of the catalogued constraints, we treat a NULL result as
 	 * success here, not a failure.
diff --git a/src/backend/executor/execPartition.c b/src/backend/executor/execPartition.c
index 2348eb3154..eaabdc6ee1 100644
--- a/src/backend/executor/execPartition.c
+++ b/src/backend/executor/execPartition.c
@@ -287,7 +287,7 @@ ExecFindPartition(ModifyTableState *mtstate,
 	 * routing the tuple if it doesn't belong in the root table itself.
 	 */
 	if (rootResultRelInfo->ri_RelationDesc->rd_rel->relispartition)
-		ExecPartitionCheck(rootResultRelInfo, slot, estate, true);
+		ExecPartitionCheck(rootResultRelInfo, slot, estate, NULL, true);
 
 	/* start with the root partitioned table */
 	dispatch = pd[0];
@@ -298,6 +298,8 @@ ExecFindPartition(ModifyTableState *mtstate,
 
 		CHECK_FOR_INTERRUPTS();
 
+		rel = dispatch->reldesc;
+
 		/*
 		 * Check if the saved partition accepts this tuple by evaluating its
 		 * partition constraint against the tuple.  If it does, we save a trip
@@ -317,7 +319,7 @@ ExecFindPartition(ModifyTableState *mtstate,
 												rri->ri_PartitionTupleSlot);
 			else
 				tmpslot = rootslot;
-			if (ExecPartitionCheck(rri, tmpslot, estate, false))
+			if (ExecPartitionCheck(rri, tmpslot, estate, rel, false))
 			{
 				/* and restore ecxt's scantuple */
 				ecxt->ecxt_scantuple = ecxt_scantuple_saved;
@@ -327,7 +329,6 @@ ExecFindPartition(ModifyTableState *mtstate,
 			dispatch->lastPartInfo = rri = NULL;
 		}
 
-		rel = dispatch->reldesc;
 		partdesc = dispatch->partdesc;
 
 		/*
@@ -513,7 +514,7 @@ ExecFindPartition(ModifyTableState *mtstate,
 					slot = rootslot;
 			}
 
-			ExecPartitionCheck(rri, slot, estate, true);
+			ExecPartitionCheck(rri, slot, estate, NULL, true);
 		}
 	}
 
diff --git a/src/backend/executor/execReplication.c b/src/backend/executor/execReplication.c
index 1e285e0349..9f37f55090 100644
--- a/src/backend/executor/execReplication.c
+++ b/src/backend/executor/execReplication.c
@@ -437,7 +437,7 @@ ExecSimpleRelationInsert(ResultRelInfo *resultRelInfo,
 		if (rel->rd_att->constr)
 			ExecConstraints(resultRelInfo, slot, estate);
 		if (rel->rd_rel->relispartition)
-			ExecPartitionCheck(resultRelInfo, slot, estate, true);
+			ExecPartitionCheck(resultRelInfo, slot, estate, NULL, true);
 
 		/* OK, store the tuple and create index entries for it */
 		simple_table_tuple_insert(resultRelInfo->ri_RelationDesc, slot);
@@ -505,7 +505,7 @@ ExecSimpleRelationUpdate(ResultRelInfo *resultRelInfo,
 		if (rel->rd_att->constr)
 			ExecConstraints(resultRelInfo, slot, estate);
 		if (rel->rd_rel->relispartition)
-			ExecPartitionCheck(resultRelInfo, slot, estate, true);
+			ExecPartitionCheck(resultRelInfo, slot, estate, NULL, true);
 
 		simple_table_tuple_update(rel, tid, slot, estate->es_snapshot,
 								  &update_indexes);
diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c
index 379b056310..c46fff0f7e 100644
--- a/src/backend/executor/nodeModifyTable.c
+++ b/src/backend/executor/nodeModifyTable.c
@@ -791,7 +791,7 @@ ExecInsert(ModifyTableState *mtstate,
 			(resultRelInfo->ri_RootResultRelInfo == NULL ||
 			 (resultRelInfo->ri_TrigDesc &&
 			  resultRelInfo->ri_TrigDesc->trig_insert_before_row)))
-			ExecPartitionCheck(resultRelInfo, slot, estate, true);
+			ExecPartitionCheck(resultRelInfo, slot, estate, NULL, true);
 
 		if (onconflict != ONCONFLICT_NONE && resultRelInfo->ri_NumIndices > 0)
 		{
@@ -1710,7 +1710,7 @@ lreplace:;
 		 */
 		partition_constraint_failed =
 			resultRelationDesc->rd_rel->relispartition &&
-			!ExecPartitionCheck(resultRelInfo, slot, estate, false);
+			!ExecPartitionCheck(resultRelInfo, slot, estate, NULL, false);
 
 		if (!partition_constraint_failed &&
 			resultRelInfo->ri_WithCheckOptions != NIL)
diff --git a/src/backend/replication/logical/worker.c b/src/backend/replication/logical/worker.c
index 6ba447ea97..ee4f7bf06f 100644
--- a/src/backend/replication/logical/worker.c
+++ b/src/backend/replication/logical/worker.c
@@ -1747,7 +1747,7 @@ apply_handle_tuple_routing(ApplyExecutionData *edata,
 				 */
 				if (!partrel->rd_rel->relispartition ||
 					ExecPartitionCheck(partrelinfo, remoteslot_part, estate,
-									   false))
+									   NULL, false))
 				{
 					/*
 					 * Yes, so simply UPDATE the partition.  We don't call
diff --git a/src/include/executor/executor.h b/src/include/executor/executor.h
index 3dc03c913e..c44ac1d7f3 100644
--- a/src/include/executor/executor.h
+++ b/src/include/executor/executor.h
@@ -207,7 +207,8 @@ extern ResultRelInfo *ExecGetTriggerResultRel(EState *estate, Oid relid);
 extern void ExecConstraints(ResultRelInfo *resultRelInfo,
 							TupleTableSlot *slot, EState *estate);
 extern bool ExecPartitionCheck(ResultRelInfo *resultRelInfo,
-							   TupleTableSlot *slot, EState *estate, bool emitError);
+							   TupleTableSlot *slot, EState *estate,
+							   Relation parentrel, bool emitError);
 extern void ExecPartitionCheckEmitError(ResultRelInfo *resultRelInfo,
 										TupleTableSlot *slot, EState *estate);
 extern void ExecWithCheckOptions(WCOKind kind, ResultRelInfo *resultRelInfo,
diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h
index 7795a69490..9984171576 100644
--- a/src/include/nodes/execnodes.h
+++ b/src/include/nodes/execnodes.h
@@ -496,6 +496,13 @@ typedef struct ResultRelInfo
 	/* partition check expression state (NULL if not set up yet) */
 	ExprState  *ri_PartitionCheckExpr;
 
+	/*
+	 * Information used by ExecPartitionCheck() to optimize some cases where
+	 * the parent's partition key contains arbitrary expressions.
+	 */
+	List	   *ri_partitionKeyExprs;
+	TupleTableSlot *ri_partitionKeyExprsSlot;
+
 	/*
 	 * Information needed by tuple routing target relations
 	 *

From 49248c88201a4872d94d890f69ca529d49339a2c Mon Sep 17 00:00:00 2001
From: "houzj.fnst" <houzj.fnst@cn.fujitsu.com>
Date: Mon, 24 May 2021 20:44:31 +0800
Subject: [PATCH] -Recursive-search-parent-partkeyexpr

---
 src/backend/commands/tablecmds.c     |  4 +--
 src/backend/executor/execMain.c      |  7 ++--
 src/backend/optimizer/util/plancat.c |  2 +-
 src/backend/utils/cache/partcache.c  | 48 ++++++++++++++++++++++++----
 src/backend/utils/cache/relcache.c   |  2 ++
 src/include/utils/partcache.h        |  2 +-
 src/include/utils/rel.h              |  1 +
 7 files changed, 51 insertions(+), 15 deletions(-)

diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c
index 11e91c4ad3..e48e4a5631 100644
--- a/src/backend/commands/tablecmds.c
+++ b/src/backend/commands/tablecmds.c
@@ -17280,7 +17280,7 @@ ATExecAttachPartition(List **wqueue, Relation rel, PartitionCmd *cmd,
 	 */
 	partBoundConstraint = get_qual_from_partbound(attachrel, rel, cmd->bound);
 	partConstraint = list_concat(partBoundConstraint,
-								 RelationGetPartitionQual(rel));
+								 RelationGetPartitionQual(rel, NULL));
 
 	/* Skip validation if there are no constraints to validate. */
 	if (partConstraint)
@@ -18082,7 +18082,7 @@ DetachAddConstraintIfNeeded(List **wqueue, Relation partRel)
 {
 	List	   *constraintExpr;
 
-	constraintExpr = RelationGetPartitionQual(partRel);
+	constraintExpr = RelationGetPartitionQual(partRel, NULL);
 	constraintExpr = (List *) eval_const_expressions(NULL, (Node *) constraintExpr);
 
 	/*
diff --git a/src/backend/executor/execMain.c b/src/backend/executor/execMain.c
index 8ddbc6d0c2..91bbc5bc25 100644
--- a/src/backend/executor/execMain.c
+++ b/src/backend/executor/execMain.c
@@ -1738,12 +1738,13 @@ ExecPartitionCheck(ResultRelInfo *resultRelInfo, TupleTableSlot *slot,
 	 */
 	if (resultRelInfo->ri_PartitionCheckExpr == NULL)
 	{
+		List *partexprs = NIL;
 		/*
 		 * Ensure that the qual tree and prepared expression are in the
 		 * query-lifespan context.
 		 */
 		MemoryContext oldcxt = MemoryContextSwitchTo(estate->es_query_cxt);
-		List	   *qual = RelationGetPartitionQual(resultRelInfo->ri_RelationDesc);
+		List	   *qual = RelationGetPartitionQual(resultRelInfo->ri_RelationDesc, &partexprs);
 
 		/*
 		 * If we have been passed the parent relation, optimize the evaluation
@@ -1757,16 +1758,12 @@ ExecPartitionCheck(ResultRelInfo *resultRelInfo, TupleTableSlot *slot,
 		if (parentrel)
 		{
 			replace_partexpr_with_dummy_var_context cxt;
-			List   *partexprs = RelationGetPartitionKey(parentrel)->partexprs;
 			ListCell *lc;
 			AttrNumber attrno = 1;
 			TupleDesc	partexprs_tupdesc;
 
 			partexprs_tupdesc = CreateTemplateTupleDesc(list_length(partexprs));
 
-			partexprs = map_partition_varattnos(partexprs, 1,
-												resultRelInfo->ri_RelationDesc,
-												parentrel);
 			foreach(lc, partexprs)
 			{
 				Expr   *expr = lfirst(lc);
diff --git a/src/backend/optimizer/util/plancat.c b/src/backend/optimizer/util/plancat.c
index c5194fdbbf..f274538ba5 100644
--- a/src/backend/optimizer/util/plancat.c
+++ b/src/backend/optimizer/util/plancat.c
@@ -2399,7 +2399,7 @@ set_baserel_partition_constraint(Relation relation, RelOptInfo *rel)
 	 * implicit-AND format, we'd have to explicitly convert it to explicit-AND
 	 * format and back again.
 	 */
-	partconstr = RelationGetPartitionQual(relation);
+	partconstr = RelationGetPartitionQual(relation, NULL);
 	if (partconstr)
 	{
 		partconstr = (List *) expression_planner((Expr *) partconstr);
diff --git a/src/backend/utils/cache/partcache.c b/src/backend/utils/cache/partcache.c
index 21e60f0c5e..69bc431a69 100644
--- a/src/backend/utils/cache/partcache.c
+++ b/src/backend/utils/cache/partcache.c
@@ -38,7 +38,7 @@
 
 
 static void RelationBuildPartitionKey(Relation relation);
-static List *generate_partition_qual(Relation rel);
+static List *generate_partition_qual(Relation rel, List **partkeys);
 
 /*
  * RelationGetPartitionKey -- get partition key, if relation is partitioned
@@ -273,13 +273,13 @@ RelationBuildPartitionKey(Relation relation)
  * Returns a list of partition quals
  */
 List *
-RelationGetPartitionQual(Relation rel)
+RelationGetPartitionQual(Relation rel, List **partkeys)
 {
 	/* Quick exit */
 	if (!rel->rd_rel->relispartition)
 		return NIL;
 
-	return generate_partition_qual(rel);
+	return generate_partition_qual(rel, partkeys);
 }
 
 /*
@@ -305,7 +305,7 @@ get_partition_qual_relid(Oid relid)
 		Relation	rel = relation_open(relid, AccessShareLock);
 		List	   *and_args;
 
-		and_args = generate_partition_qual(rel);
+		and_args = generate_partition_qual(rel, NULL);
 
 		/* Convert implicit-AND list format to boolean expression */
 		if (and_args == NIL)
@@ -333,7 +333,7 @@ get_partition_qual_relid(Oid relid)
  * into long-lived cache contexts, especially if we fail partway through.
  */
 static List *
-generate_partition_qual(Relation rel)
+generate_partition_qual(Relation rel, List **partkeys)
 {
 	HeapTuple	tuple;
 	MemoryContext oldcxt;
@@ -349,7 +349,12 @@ generate_partition_qual(Relation rel)
 
 	/* If we already cached the result, just return a copy */
 	if (rel->rd_partcheckvalid)
+	{
+		if (partkeys != NULL && rel->rd_keyexpr_list != NIL)
+			*partkeys = list_concat(*partkeys, copyObject(rel->rd_keyexpr_list));
+
 		return copyObject(rel->rd_partcheck);
+	}
 
 	/*
 	 * Grab at least an AccessShareLock on the parent table.  Must do this
@@ -381,9 +386,31 @@ generate_partition_qual(Relation rel)
 
 	ReleaseSysCache(tuple);
 
+	/* Save partition key expressions */
+	if (partkeys != NULL)
+	{
+		PartitionKey key = RelationGetPartitionKey(parent);
+		if (key != NULL && key->partexprs != NIL)
+			*partkeys = list_concat(*partkeys, copyObject(key->partexprs));
+	}
+
 	/* Add the parent's quals to the list (if any) */
 	if (parent->rd_rel->relispartition)
-		result = list_concat(generate_partition_qual(parent), my_qual);
+	{
+		List *temp_partkeys;
+		if (partkeys != NULL)
+		{
+			temp_partkeys = *partkeys;
+			*partkeys = NIL;
+		}
+
+		result = list_concat(generate_partition_qual(parent, partkeys), my_qual);
+
+		if (partkeys != NULL)
+		{
+			*partkeys = list_concat(*partkeys, temp_partkeys);
+		}
+	}
 	else
 		result = my_qual;
 
@@ -394,10 +421,13 @@ generate_partition_qual(Relation rel)
 	 * here.
 	 */
 	result = map_partition_varattnos(result, 1, rel, parent);
+	if (partkeys != NULL)
+		*partkeys = map_partition_varattnos(*partkeys, 1, rel, parent);
 
 	/* Assert that we're not leaking any old data during assignments below */
 	Assert(rel->rd_partcheckcxt == NULL);
 	Assert(rel->rd_partcheck == NIL);
+	Assert(rel->rd_keyexpr_list == NIL);
 
 	/*
 	 * Save a copy in the relcache.  The order of these operations is fairly
@@ -416,10 +446,16 @@ generate_partition_qual(Relation rel)
 										  RelationGetRelationName(rel));
 		oldcxt = MemoryContextSwitchTo(rel->rd_partcheckcxt);
 		rel->rd_partcheck = copyObject(result);
+		if (partkeys != NULL && *partkeys != NIL)
+			rel->rd_keyexpr_list = copyObject(*partkeys);
 		MemoryContextSwitchTo(oldcxt);
 	}
 	else
+	{
 		rel->rd_partcheck = NIL;
+		rel->rd_keyexpr_list = NIL;
+	}
+
 	rel->rd_partcheckvalid = true;
 
 	/* Keep the parent locked until commit */
diff --git a/src/backend/utils/cache/relcache.c b/src/backend/utils/cache/relcache.c
index fd05615e76..f7527da0d8 100644
--- a/src/backend/utils/cache/relcache.c
+++ b/src/backend/utils/cache/relcache.c
@@ -1161,6 +1161,7 @@ RelationBuildDesc(Oid targetRelId, bool insertIt)
 	relation->rd_pdcxt = NULL;
 	relation->rd_pddcxt = NULL;
 	relation->rd_partcheck = NIL;
+	relation->rd_keyexpr_list = NIL;
 	relation->rd_partcheckvalid = false;
 	relation->rd_partcheckcxt = NULL;
 
@@ -6041,6 +6042,7 @@ load_relcache_init_file(bool shared)
 		rel->rd_pdcxt = NULL;
 		rel->rd_pddcxt = NULL;
 		rel->rd_partcheck = NIL;
+		rel->rd_keyexpr_list = NIL;
 		rel->rd_partcheckvalid = false;
 		rel->rd_partcheckcxt = NULL;
 		rel->rd_indexprs = NIL;
diff --git a/src/include/utils/partcache.h b/src/include/utils/partcache.h
index a451bfb239..4762bc9fed 100644
--- a/src/include/utils/partcache.h
+++ b/src/include/utils/partcache.h
@@ -48,7 +48,7 @@ typedef struct PartitionKeyData
 
 
 extern PartitionKey RelationGetPartitionKey(Relation rel);
-extern List *RelationGetPartitionQual(Relation rel);
+extern List *RelationGetPartitionQual(Relation rel, List **partkeys);
 extern Expr *get_partition_qual_relid(Oid relid);
 
 /*
diff --git a/src/include/utils/rel.h b/src/include/utils/rel.h
index 774ac5b2b1..111287b130 100644
--- a/src/include/utils/rel.h
+++ b/src/include/utils/rel.h
@@ -143,6 +143,7 @@ typedef struct RelationData
 
 	/* data managed by RelationGetPartitionQual: */
 	List	   *rd_partcheck;	/* partition CHECK quals */
+	List	   *rd_keyexpr_list;	/* partition key exprs used in CHECK quals */
 	bool		rd_partcheckvalid;	/* true if list has been computed */
 	MemoryContext rd_partcheckcxt;	/* private cxt for rd_partcheck, if any */
 
-- 
2.18.4

From cf659e0b221ddc04f5851b91518cc123be547f21 Mon Sep 17 00:00:00 2001
From: amitlan <amitlangote09@gmail.com>
Date: Tue, 25 May 2021 22:48:47 +0900
Subject: [PATCH 1/2] ExecFindPartition: cache last used partition v3

---
 src/backend/executor/execPartition.c | 198 ++++++++++++++++++++++-----
 1 file changed, 162 insertions(+), 36 deletions(-)

diff --git a/src/backend/executor/execPartition.c b/src/backend/executor/execPartition.c
index 606c920b06..1d0d8e63f6 100644
--- a/src/backend/executor/execPartition.c
+++ b/src/backend/executor/execPartition.c
@@ -133,6 +133,16 @@ struct PartitionTupleRouting
  *		routing it through this table). A NULL value is stored if no tuple
  *		conversion is required.
  *
+ * savedPartInfo
+ *		If non-NULL, ResultRelInfo for the partition that was most recently
+ *		chosen as the routing target; ExecFindPartition() checks if the
+ *		same one can be used for the current row before applying the tuple-
+ *		routing algorithm to it.
+ *
+ * savedDispatchInfo
+ *		If non-NULL, PartititionDispatch for the sub-partitioned partition
+ *		that was most recently chosen as the routing target
+ *
  * indexes
  *		Array of partdesc->nparts elements.  For leaf partitions the index
  *		corresponds to the partition's ResultRelInfo in the encapsulating
@@ -150,6 +160,8 @@ typedef struct PartitionDispatchData
 	PartitionDesc partdesc;
 	TupleTableSlot *tupslot;
 	AttrMap    *tupmap;
+	ResultRelInfo *savedPartInfo;
+	PartitionDispatch savedDispatchInfo;
 	int			indexes[FLEXIBLE_ARRAY_MEMBER];
 }			PartitionDispatchData;
 
@@ -234,6 +246,82 @@ ExecSetupPartitionTupleRouting(EState *estate, Relation rel)
 	return proute;
 }
 
+/*
+ * Remember this partition for the next tuple inserted into this parent; see
+ * CanUseSavedPartitionForTuple() for how it's decided whether a tuple can
+ * indeed reuse this partition.
+ *
+ * Do this only if we have range/list partitions, because only
+ * in that case it's conceivable that consecutively inserted rows
+ * tend to go into the same partition.
+ */
+static inline void
+SavePartitionForNextTuple(PartitionDispatch dispatch,
+						  ResultRelInfo *partInfo,
+						  PartitionDispatch dispatchInfo)
+{
+	if ((dispatch->key->strategy == PARTITION_STRATEGY_RANGE ||
+		 dispatch->key->strategy == PARTITION_STRATEGY_LIST))
+	{
+		dispatch->savedPartInfo = partInfo;
+		dispatch->savedDispatchInfo = dispatchInfo;
+	}
+}
+
+/*
+ * Check if the saved partition accepts this tuple by evaluating its
+ * partition constraint against the tuple.  If it does, we save a trip
+ * to get_partition_for_tuple(), which can be a slightly more expensive
+ * way to get the same partition, especially if there are many
+ * partitions to search through.
+ */
+static inline bool
+CanUseSavedPartitionForTuple(PartitionDispatch dispatch,
+							 TupleTableSlot *rootslot,
+							 EState *estate)
+{
+	if (dispatch->savedPartInfo)
+	{
+		ResultRelInfo *rri;
+		TupleTableSlot *tmpslot;
+		TupleConversionMap *map;
+
+		rri = dispatch->savedPartInfo;
+		map = rri->ri_RootToPartitionMap;
+		if (map)
+			tmpslot = execute_attr_map_slot(map->attrMap, rootslot,
+											rri->ri_PartitionTupleSlot);
+		else
+			tmpslot = rootslot;
+		return ExecPartitionCheck(rri, tmpslot, estate, false);
+	}
+
+	return false;
+}
+
+/*
+ * Convert the tuple to a sub-partitioned partition's layout, if needed.
+ */
+static inline TupleTableSlot *
+ConvertTupleToPartition(PartitionDispatch dispatch,
+						TupleTableSlot *slot,
+						TupleTableSlot **parent_slot)
+{
+	if (dispatch->tupslot)
+	{
+		AttrMap    *map = dispatch->tupmap;
+		TupleTableSlot *tempslot = *parent_slot;
+
+		*parent_slot = dispatch->tupslot;
+		slot = execute_attr_map_slot(map, slot, *parent_slot);
+
+		if (tempslot != NULL)
+			ExecClearTuple(tempslot);
+	}
+
+	return slot;
+}
+
 /*
  * ExecFindPartition -- Return the ResultRelInfo for the leaf partition that
  * the tuple contained in *slot should belong to.
@@ -292,6 +380,34 @@ ExecFindPartition(ModifyTableState *mtstate,
 		CHECK_FOR_INTERRUPTS();
 
 		rel = dispatch->reldesc;
+
+		if (CanUseSavedPartitionForTuple(dispatch, rootslot, estate))
+		{
+			/* If the saved partition is leaf partition, just return it. */
+			if (dispatch->savedDispatchInfo == NULL)
+			{
+				/* Restore ecxt's scantuple before returning. */
+				ecxt->ecxt_scantuple = ecxt_scantuple_saved;
+				MemoryContextSwitchTo(oldcxt);
+				return dispatch->savedPartInfo;
+			}
+			else
+			{
+				/*
+				 * Saved partition is sub-partitioned, so continue the loop to
+				 * find the next level partition.
+				 */
+				dispatch = dispatch->savedDispatchInfo;
+				slot = ConvertTupleToPartition(dispatch, slot, &myslot);
+				continue;
+			}
+		}
+		else
+		{
+			dispatch->savedPartInfo = rri = NULL;
+			dispatch->savedDispatchInfo = NULL;
+		}
+
 		partdesc = dispatch->partdesc;
 
 		/*
@@ -372,6 +488,8 @@ ExecFindPartition(ModifyTableState *mtstate,
 			}
 			Assert(rri != NULL);
 
+			SavePartitionForNextTuple(dispatch, rri, NULL);
+
 			/* Signal to terminate the loop */
 			dispatch = NULL;
 		}
@@ -382,6 +500,8 @@ ExecFindPartition(ModifyTableState *mtstate,
 			 */
 			if (likely(dispatch->indexes[partidx] >= 0))
 			{
+				PartitionDispatch subdispatch;
+
 				/* Already built. */
 				Assert(dispatch->indexes[partidx] < proute->num_dispatch);
 
@@ -391,7 +511,11 @@ ExecFindPartition(ModifyTableState *mtstate,
 				 * Move down to the next partition level and search again
 				 * until we find a leaf partition that matches this tuple
 				 */
-				dispatch = pd[dispatch->indexes[partidx]];
+				subdispatch = pd[dispatch->indexes[partidx]];
+
+				SavePartitionForNextTuple(dispatch, rri, subdispatch);
+
+				dispatch = subdispatch;
 			}
 			else
 			{
@@ -411,24 +535,13 @@ ExecFindPartition(ModifyTableState *mtstate,
 					   dispatch->indexes[partidx] < proute->num_dispatch);
 
 				rri = proute->nonleaf_partitions[dispatch->indexes[partidx]];
-				dispatch = subdispatch;
-			}
 
-			/*
-			 * Convert the tuple to the new parent's layout, if different from
-			 * the previous parent.
-			 */
-			if (dispatch->tupslot)
-			{
-				AttrMap    *map = dispatch->tupmap;
-				TupleTableSlot *tempslot = myslot;
-
-				myslot = dispatch->tupslot;
-				slot = execute_attr_map_slot(map, slot, myslot);
+				SavePartitionForNextTuple(dispatch, rri, subdispatch);
 
-				if (tempslot != NULL)
-					ExecClearTuple(tempslot);
+				dispatch = subdispatch;
 			}
+
+			slot = ConvertTupleToPartition(dispatch, slot, &myslot);
 		}
 
 		/*
@@ -858,27 +971,11 @@ ExecInitPartitionInfo(ModifyTableState *mtstate, EState *estate,
 	return leaf_part_rri;
 }
 
-/*
- * ExecInitRoutingInfo
- *		Set up information needed for translating tuples between root
- *		partitioned table format and partition format, and keep track of it
- *		in PartitionTupleRouting.
- */
-static void
-ExecInitRoutingInfo(ModifyTableState *mtstate,
-					EState *estate,
-					PartitionTupleRouting *proute,
-					PartitionDispatch dispatch,
-					ResultRelInfo *partRelInfo,
-					int partidx,
-					bool is_borrowed_rel)
+static inline void
+InitRootToPartitionMap(ResultRelInfo *partRelInfo,
+					   ResultRelInfo *rootRelInfo,
+					   EState *estate)
 {
-	ResultRelInfo *rootRelInfo = partRelInfo->ri_RootResultRelInfo;
-	MemoryContext oldcxt;
-	int			rri_index;
-
-	oldcxt = MemoryContextSwitchTo(proute->memcxt);
-
 	/*
 	 * Set up a tuple conversion map to convert a tuple routed to the
 	 * partition from the parent's type to the partition's.
@@ -907,6 +1004,30 @@ ExecInitRoutingInfo(ModifyTableState *mtstate,
 	}
 	else
 		partRelInfo->ri_PartitionTupleSlot = NULL;
+}
+
+/*
+ * ExecInitRoutingInfo
+ *		Set up information needed for translating tuples between root
+ *		partitioned table format and partition format, and keep track of it
+ *		in PartitionTupleRouting.
+ */
+static void
+ExecInitRoutingInfo(ModifyTableState *mtstate,
+					EState *estate,
+					PartitionTupleRouting *proute,
+					PartitionDispatch dispatch,
+					ResultRelInfo *partRelInfo,
+					int partidx,
+					bool is_borrowed_rel)
+{
+	ResultRelInfo *rootRelInfo = partRelInfo->ri_RootResultRelInfo;
+	MemoryContext oldcxt;
+	int			rri_index;
+
+	oldcxt = MemoryContextSwitchTo(proute->memcxt);
+
+	InitRootToPartitionMap(partRelInfo, rootRelInfo, estate);
 
 	/*
 	 * If the partition is a foreign table, let the FDW init itself for
@@ -1051,6 +1172,9 @@ ExecInitPartitionDispatchInfo(EState *estate,
 		pd->tupslot = NULL;
 	}
 
+	pd->savedPartInfo = NULL;
+	pd->savedDispatchInfo = NULL;
+
 	/*
 	 * Initialize with -1 to signify that the corresponding partition's
 	 * ResultRelInfo or PartitionDispatch has not been created yet.
@@ -1094,6 +1218,8 @@ ExecInitPartitionDispatchInfo(EState *estate,
 		ResultRelInfo *rri = makeNode(ResultRelInfo);
 
 		InitResultRelInfo(rri, rel, 0, rootResultRelInfo, 0);
+		/* The map is needed in CanUseSavedPartitionForTuple(). */
+		InitRootToPartitionMap(rri, rootResultRelInfo, estate);
 		proute->nonleaf_partitions[dispatchidx] = rri;
 	}
 	else
-- 
2.24.1

From a7909c2b142ef255c034d7d319d09abdeede23eb Mon Sep 17 00:00:00 2001
From: amitlan <amitlangote09@gmail.com>
Date: Tue, 25 May 2021 22:55:12 +0900
Subject: [PATCH 2/2] ExecPartitionCheck: pre-compute partition key expression
 v2

---
 src/backend/executor/execMain.c      | 95 ++++++++++++++++++++++++++++
 src/backend/executor/execPartition.c | 52 +++++++++++++++
 src/include/nodes/execnodes.h        |  9 +++
 3 files changed, 156 insertions(+)

diff --git a/src/backend/executor/execMain.c b/src/backend/executor/execMain.c
index b3ce4bae53..1fc2a9fe82 100644
--- a/src/backend/executor/execMain.c
+++ b/src/backend/executor/execMain.c
@@ -44,6 +44,7 @@
 #include "access/transam.h"
 #include "access/xact.h"
 #include "catalog/namespace.h"
+#include "catalog/partition.h"
 #include "catalog/pg_publication.h"
 #include "commands/matview.h"
 #include "commands/trigger.h"
@@ -52,6 +53,8 @@
 #include "foreign/fdwapi.h"
 #include "jit/jit.h"
 #include "mb/pg_wchar.h"
+#include "nodes/makefuncs.h"
+#include "nodes/nodeFuncs.h"
 #include "miscadmin.h"
 #include "parser/parsetree.h"
 #include "storage/bufmgr.h"
@@ -1686,6 +1689,32 @@ ExecRelCheck(ResultRelInfo *resultRelInfo,
 	return NULL;
 }
 
+/*
+ * Replaces the occurrence of cxt->matchexpr in the expression tree given by
+ * 'node' by an OUTER var with provided attribute number.
+ */
+typedef struct
+{
+	Expr	   *matchexpr;
+	AttrNumber	varattno;
+} replace_partexpr_with_dummy_var_context;
+
+static Node *
+replace_partexpr_with_dummy_var(Node *node,
+								replace_partexpr_with_dummy_var_context *cxt)
+{
+	if (node == NULL)
+		return NULL;
+
+	if (equal(node, cxt->matchexpr))
+		return (Node *) makeVar(OUTER_VAR, cxt->varattno,
+								exprType(node), exprTypmod(node),
+								exprCollation(node), 0);
+
+	return expression_tree_mutator(node, replace_partexpr_with_dummy_var,
+								   (void *) cxt);
+}
+
 /*
  * ExecPartitionCheck --- check that tuple meets the partition constraint.
  *
@@ -1716,6 +1745,45 @@ ExecPartitionCheck(ResultRelInfo *resultRelInfo, TupleTableSlot *slot,
 		MemoryContext oldcxt = MemoryContextSwitchTo(estate->es_query_cxt);
 		List	   *qual = RelationGetPartitionQual(resultRelInfo->ri_RelationDesc);
 
+		/*
+		 * Optimize the evaluation of partition key expressions.  The way we do
+		 * that is by replacing any occurrences of the individual expressions
+		 * in this relation's partition constraint by dummy Vars marked as
+		 * coming from the "OUTER" relation.  Then when actually executing such
+		 * modified partition constraint tree, we feed the actual partition
+		 * expression values via econtext->ecxt_outertuple; see below.
+		 */
+		if (resultRelInfo->ri_partConstrKeyExprs)
+		{
+			List	  *partexprs = resultRelInfo->ri_partConstrKeyExprs;
+			ListCell  *lc;
+			AttrNumber attrno = 1;
+			TupleDesc	partexprs_tupdesc;
+			replace_partexpr_with_dummy_var_context cxt;
+
+			partexprs_tupdesc = CreateTemplateTupleDesc(list_length(partexprs));
+			foreach(lc, partexprs)
+			{
+				Expr   *expr = lfirst(lc);
+
+				cxt.matchexpr = expr;
+				cxt.varattno = attrno;
+				qual = (List *) replace_partexpr_with_dummy_var((Node *) qual,
+																&cxt);
+
+				resultRelInfo->ri_partConstrKeyExprStates =
+					lappend(resultRelInfo->ri_partConstrKeyExprStates,
+							ExecPrepareExpr(expr, estate));
+				TupleDescInitEntry(partexprs_tupdesc, attrno, NULL,
+								   exprType((Node *) expr),
+								   exprTypmod((Node *) expr), 0);
+				attrno++;
+			}
+
+			resultRelInfo->ri_partConstrKeyExprsSlot =
+				ExecInitExtraTupleSlot(estate, partexprs_tupdesc, &TTSOpsVirtual);
+		}
+
 		resultRelInfo->ri_PartitionCheckExpr = ExecPrepareCheck(qual, estate);
 		MemoryContextSwitchTo(oldcxt);
 	}
@@ -1729,6 +1797,33 @@ ExecPartitionCheck(ResultRelInfo *resultRelInfo, TupleTableSlot *slot,
 	/* Arrange for econtext's scan tuple to be the tuple under test */
 	econtext->ecxt_scantuple = slot;
 
+	if (resultRelInfo->ri_partConstrKeyExprStates)
+	{
+		TupleTableSlot *partexprs_slot = resultRelInfo->ri_partConstrKeyExprsSlot;
+		Datum	*values;
+		bool	*isnull;
+		ListCell *lc;
+		AttrNumber attrno = 1;
+
+		Assert(partexprs_slot != NULL);
+		ExecClearTuple(partexprs_slot);
+
+		values = partexprs_slot->tts_values;
+		isnull = partexprs_slot->tts_isnull;
+
+		foreach(lc, resultRelInfo->ri_partConstrKeyExprStates)
+		{
+			ExprState   *partexpr = lfirst(lc);
+
+			values[attrno-1] = ExecEvalExprSwitchContext(partexpr, econtext,
+												  &isnull[attrno-1]);
+			attrno++;
+		}
+		ExecStoreVirtualTuple(partexprs_slot);
+
+		econtext->ecxt_outertuple = partexprs_slot;
+	}
+
 	/*
 	 * As in case of the catalogued constraints, we treat a NULL result as
 	 * success here, not a failure.
diff --git a/src/backend/executor/execPartition.c b/src/backend/executor/execPartition.c
index 1d0d8e63f6..0e689b9c56 100644
--- a/src/backend/executor/execPartition.c
+++ b/src/backend/executor/execPartition.c
@@ -143,6 +143,13 @@ struct PartitionTupleRouting
  *		If non-NULL, PartititionDispatch for the sub-partitioned partition
  *		that was most recently chosen as the routing target
  *
+ * partconstr_keyexprs
+ *		List of expressions present in the partition keys of all ancestors
+ *		of this table including itself, mapped to have the attribute
+ *		numbers of this table.  The field is so named because all of these
+ *		expressions appear in the partition constraint of each of this
+ *		table's partitions.
+ *
  * indexes
  *		Array of partdesc->nparts elements.  For leaf partitions the index
  *		corresponds to the partition's ResultRelInfo in the encapsulating
@@ -162,6 +169,7 @@ typedef struct PartitionDispatchData
 	AttrMap    *tupmap;
 	ResultRelInfo *savedPartInfo;
 	PartitionDispatch savedDispatchInfo;
+	List	   *partconstr_keyexprs;
 	int			indexes[FLEXIBLE_ARRAY_MEMBER];
 }			PartitionDispatchData;
 
@@ -1006,6 +1014,21 @@ InitRootToPartitionMap(ResultRelInfo *partRelInfo,
 		partRelInfo->ri_PartitionTupleSlot = NULL;
 }
 
+/*
+ * Save parent's partition key expressions in the partition ResultRelInfo
+ * after mapping them to have the partition's attribute numbers.
+ */
+static inline void
+InitPartitionConstraintKeyExprs(PartitionDispatch dispatch,
+								ResultRelInfo *partRelInfo)
+{
+	if (dispatch->partconstr_keyexprs)
+		partRelInfo->ri_partConstrKeyExprs =
+			map_partition_varattnos(dispatch->partconstr_keyexprs, 1,
+									partRelInfo->ri_RelationDesc,
+									dispatch->reldesc);
+}
+
 /*
  * ExecInitRoutingInfo
  *		Set up information needed for translating tuples between root
@@ -1057,6 +1080,8 @@ ExecInitRoutingInfo(ModifyTableState *mtstate,
 
 	partRelInfo->ri_CopyMultiInsertBuffer = NULL;
 
+	InitPartitionConstraintKeyExprs(dispatch, partRelInfo);
+
 	/*
 	 * Keep track of it in the PartitionTupleRouting->partitions array.
 	 */
@@ -1175,6 +1200,32 @@ ExecInitPartitionDispatchInfo(EState *estate,
 	pd->savedPartInfo = NULL;
 	pd->savedDispatchInfo = NULL;
 
+	if (pd->key->partexprs != NIL)
+	{
+		pd->partconstr_keyexprs = copyObject(pd->key->partexprs);
+		if (parent_pd)
+		{
+			List   *parent_keyexprs = parent_pd->partconstr_keyexprs;
+
+			if (parent_keyexprs && pd->tupmap)
+			{
+				bool	found_whole_row;
+
+				parent_keyexprs = (List *)
+					map_variable_attnos((Node *) parent_keyexprs, 1, 0,
+										pd->tupmap,
+										RelationGetForm(rel)->reltype,
+										&found_whole_row);
+			}
+			else if (parent_keyexprs)
+				parent_keyexprs = copyObject(parent_keyexprs);
+			pd->partconstr_keyexprs =
+				list_concat(pd->partconstr_keyexprs, parent_keyexprs);
+		}
+	}
+	else
+		pd->partconstr_keyexprs = NIL;
+
 	/*
 	 * Initialize with -1 to signify that the corresponding partition's
 	 * ResultRelInfo or PartitionDispatch has not been created yet.
@@ -1220,6 +1271,7 @@ ExecInitPartitionDispatchInfo(EState *estate,
 		InitResultRelInfo(rri, rel, 0, rootResultRelInfo, 0);
 		/* The map is needed in CanUseSavedPartitionForTuple(). */
 		InitRootToPartitionMap(rri, rootResultRelInfo, estate);
+		InitPartitionConstraintKeyExprs(pd, rri);
 		proute->nonleaf_partitions[dispatchidx] = rri;
 	}
 	else
diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h
index 7795a69490..7f1ce732ea 100644
--- a/src/include/nodes/execnodes.h
+++ b/src/include/nodes/execnodes.h
@@ -496,6 +496,15 @@ typedef struct ResultRelInfo
 	/* partition check expression state (NULL if not set up yet) */
 	ExprState  *ri_PartitionCheckExpr;
 
+	/*
+	 * Information used by ExecPartitionCheck() to optimize some cases where
+	 * the partition's ancestors' partition keys contain arbitrary
+	 * expressions.
+	 */
+	List	   *ri_partConstrKeyExprs;
+	List	   *ri_partConstrKeyExprStates;
+	TupleTableSlot *ri_partConstrKeyExprsSlot;
+
 	/*
 	 * Information needed by tuple routing target relations
 	 *
-- 
2.24.1

From fbe70854e03a75d9e149d303a09b79d5093aba43 Mon Sep 17 00:00:00 2001
From: amitlan <amitlangote09@gmail.com>
Date: Tue, 25 May 2021 22:55:12 +0900
Subject: [PATCH 2/2] ExecPartitionCheck: pre-compute partition key expression
 v2

---
 src/backend/executor/execMain.c      | 95 ++++++++++++++++++++++++++++
 src/backend/executor/execPartition.c | 46 ++++++++++++++
 src/include/nodes/execnodes.h        |  9 +++
 3 files changed, 150 insertions(+)

diff --git a/src/backend/executor/execMain.c b/src/backend/executor/execMain.c
index b3ce4bae53..1fc2a9fe82 100644
--- a/src/backend/executor/execMain.c
+++ b/src/backend/executor/execMain.c
@@ -44,6 +44,7 @@
 #include "access/transam.h"
 #include "access/xact.h"
 #include "catalog/namespace.h"
+#include "catalog/partition.h"
 #include "catalog/pg_publication.h"
 #include "commands/matview.h"
 #include "commands/trigger.h"
@@ -52,6 +53,8 @@
 #include "foreign/fdwapi.h"
 #include "jit/jit.h"
 #include "mb/pg_wchar.h"
+#include "nodes/makefuncs.h"
+#include "nodes/nodeFuncs.h"
 #include "miscadmin.h"
 #include "parser/parsetree.h"
 #include "storage/bufmgr.h"
@@ -1686,6 +1689,32 @@ ExecRelCheck(ResultRelInfo *resultRelInfo,
 	return NULL;
 }
 
+/*
+ * Replaces the occurrence of cxt->matchexpr in the expression tree given by
+ * 'node' by an OUTER var with provided attribute number.
+ */
+typedef struct
+{
+	Expr	   *matchexpr;
+	AttrNumber	varattno;
+} replace_partexpr_with_dummy_var_context;
+
+static Node *
+replace_partexpr_with_dummy_var(Node *node,
+								replace_partexpr_with_dummy_var_context *cxt)
+{
+	if (node == NULL)
+		return NULL;
+
+	if (equal(node, cxt->matchexpr))
+		return (Node *) makeVar(OUTER_VAR, cxt->varattno,
+								exprType(node), exprTypmod(node),
+								exprCollation(node), 0);
+
+	return expression_tree_mutator(node, replace_partexpr_with_dummy_var,
+								   (void *) cxt);
+}
+
 /*
  * ExecPartitionCheck --- check that tuple meets the partition constraint.
  *
@@ -1716,6 +1745,45 @@ ExecPartitionCheck(ResultRelInfo *resultRelInfo, TupleTableSlot *slot,
 		MemoryContext oldcxt = MemoryContextSwitchTo(estate->es_query_cxt);
 		List	   *qual = RelationGetPartitionQual(resultRelInfo->ri_RelationDesc);
 
+		/*
+		 * Optimize the evaluation of partition key expressions.  The way we do
+		 * that is by replacing any occurrences of the individual expressions
+		 * in this relation's partition constraint by dummy Vars marked as
+		 * coming from the "OUTER" relation.  Then when actually executing such
+		 * modified partition constraint tree, we feed the actual partition
+		 * expression values via econtext->ecxt_outertuple; see below.
+		 */
+		if (resultRelInfo->ri_partConstrKeyExprs)
+		{
+			List	  *partexprs = resultRelInfo->ri_partConstrKeyExprs;
+			ListCell  *lc;
+			AttrNumber attrno = 1;
+			TupleDesc	partexprs_tupdesc;
+			replace_partexpr_with_dummy_var_context cxt;
+
+			partexprs_tupdesc = CreateTemplateTupleDesc(list_length(partexprs));
+			foreach(lc, partexprs)
+			{
+				Expr   *expr = lfirst(lc);
+
+				cxt.matchexpr = expr;
+				cxt.varattno = attrno;
+				qual = (List *) replace_partexpr_with_dummy_var((Node *) qual,
+																&cxt);
+
+				resultRelInfo->ri_partConstrKeyExprStates =
+					lappend(resultRelInfo->ri_partConstrKeyExprStates,
+							ExecPrepareExpr(expr, estate));
+				TupleDescInitEntry(partexprs_tupdesc, attrno, NULL,
+								   exprType((Node *) expr),
+								   exprTypmod((Node *) expr), 0);
+				attrno++;
+			}
+
+			resultRelInfo->ri_partConstrKeyExprsSlot =
+				ExecInitExtraTupleSlot(estate, partexprs_tupdesc, &TTSOpsVirtual);
+		}
+
 		resultRelInfo->ri_PartitionCheckExpr = ExecPrepareCheck(qual, estate);
 		MemoryContextSwitchTo(oldcxt);
 	}
@@ -1729,6 +1797,33 @@ ExecPartitionCheck(ResultRelInfo *resultRelInfo, TupleTableSlot *slot,
 	/* Arrange for econtext's scan tuple to be the tuple under test */
 	econtext->ecxt_scantuple = slot;
 
+	if (resultRelInfo->ri_partConstrKeyExprStates)
+	{
+		TupleTableSlot *partexprs_slot = resultRelInfo->ri_partConstrKeyExprsSlot;
+		Datum	*values;
+		bool	*isnull;
+		ListCell *lc;
+		AttrNumber attrno = 1;
+
+		Assert(partexprs_slot != NULL);
+		ExecClearTuple(partexprs_slot);
+
+		values = partexprs_slot->tts_values;
+		isnull = partexprs_slot->tts_isnull;
+
+		foreach(lc, resultRelInfo->ri_partConstrKeyExprStates)
+		{
+			ExprState   *partexpr = lfirst(lc);
+
+			values[attrno-1] = ExecEvalExprSwitchContext(partexpr, econtext,
+												  &isnull[attrno-1]);
+			attrno++;
+		}
+		ExecStoreVirtualTuple(partexprs_slot);
+
+		econtext->ecxt_outertuple = partexprs_slot;
+	}
+
 	/*
 	 * As in case of the catalogued constraints, we treat a NULL result as
 	 * success here, not a failure.
diff --git a/src/backend/executor/execPartition.c b/src/backend/executor/execPartition.c
index 3e6c8c58c4..cc1dd04b54 100644
--- a/src/backend/executor/execPartition.c
+++ b/src/backend/executor/execPartition.c
@@ -143,6 +143,13 @@ struct PartitionTupleRouting
  *		If non-NULL, PartititionDispatch for the sub-partitioned partition
  *		that was most recently chosen as the routing target
  *
+ * partconstr_keyexprs
+ *		List of expressions present in the partition keys of all ancestors
+ *		of this table including itself, mapped to have the attribute
+ *		numbers of this table.  The field is so named because all of these
+ *		expressions appear in the partition constraint of each of this
+ *		table's partitions.
+ *
  * indexes
  *		Array of partdesc->nparts elements.  For leaf partitions the index
  *		corresponds to the partition's ResultRelInfo in the encapsulating
@@ -162,6 +169,7 @@ typedef struct PartitionDispatchData
 	AttrMap    *tupmap;
 	ResultRelInfo *savedPartResultInfo;
 	PartitionDispatch savedPartDispatchInfo;
+	List	   *partconstr_keyexprs;
 	int			indexes[FLEXIBLE_ARRAY_MEMBER];
 }			PartitionDispatchData;
 
@@ -995,6 +1003,21 @@ InitRootToPartitionMap(ResultRelInfo *partRelInfo,
 		partRelInfo->ri_PartitionTupleSlot = NULL;
 }
 
+/*
+ * Save parent's partition key expressions in the partition ResultRelInfo
+ * after mapping them to have the partition's attribute numbers.
+ */
+static inline void
+InitPartitionConstraintKeyExprs(PartitionDispatch dispatch,
+								ResultRelInfo *partRelInfo)
+{
+	if (dispatch->partconstr_keyexprs)
+		partRelInfo->ri_partConstrKeyExprs =
+			map_partition_varattnos(dispatch->partconstr_keyexprs, 1,
+									partRelInfo->ri_RelationDesc,
+									dispatch->reldesc);
+}
+
 /*
  * ExecInitRoutingInfo
  *		Set up information needed for translating tuples between root
@@ -1046,6 +1069,8 @@ ExecInitRoutingInfo(ModifyTableState *mtstate,
 
 	partRelInfo->ri_CopyMultiInsertBuffer = NULL;
 
+	InitPartitionConstraintKeyExprs(dispatch, partRelInfo);
+
 	/*
 	 * Keep track of it in the PartitionTupleRouting->partitions array.
 	 */
@@ -1164,6 +1189,26 @@ ExecInitPartitionDispatchInfo(EState *estate,
 	pd->savedPartResultInfo = NULL;
 	pd->savedPartDispatchInfo = NULL;
 
+	if (pd->key->partexprs != NIL)
+	{
+		pd->partconstr_keyexprs = copyObject(pd->key->partexprs);
+		if (parent_pd)
+		{
+			List   *parent_keyexprs = parent_pd->partconstr_keyexprs;
+
+			if (parent_keyexprs && pd->tupmap)
+				parent_keyexprs = map_partition_varattnos(parent_keyexprs, 1,
+														  rel,
+														  parent_pd->reldesc);
+			else if (parent_keyexprs)
+				parent_keyexprs = copyObject(parent_keyexprs);
+			pd->partconstr_keyexprs =
+				list_concat(pd->partconstr_keyexprs, parent_keyexprs);
+		}
+	}
+	else
+		pd->partconstr_keyexprs = NIL;
+
 	/*
 	 * Initialize with -1 to signify that the corresponding partition's
 	 * ResultRelInfo or PartitionDispatch has not been created yet.
@@ -1209,6 +1254,7 @@ ExecInitPartitionDispatchInfo(EState *estate,
 		InitResultRelInfo(rri, rel, 0, rootResultRelInfo, 0);
 		/* The map is needed in CanUseSavedPartitionForTuple(). */
 		InitRootToPartitionMap(rri, rootResultRelInfo, estate);
+		InitPartitionConstraintKeyExprs(pd, rri);
 		proute->nonleaf_partitions[dispatchidx] = rri;
 	}
 	else
diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h
index 7795a69490..7f1ce732ea 100644
--- a/src/include/nodes/execnodes.h
+++ b/src/include/nodes/execnodes.h
@@ -496,6 +496,15 @@ typedef struct ResultRelInfo
 	/* partition check expression state (NULL if not set up yet) */
 	ExprState  *ri_PartitionCheckExpr;
 
+	/*
+	 * Information used by ExecPartitionCheck() to optimize some cases where
+	 * the partition's ancestors' partition keys contain arbitrary
+	 * expressions.
+	 */
+	List	   *ri_partConstrKeyExprs;
+	List	   *ri_partConstrKeyExprStates;
+	TupleTableSlot *ri_partConstrKeyExprsSlot;
+
 	/*
 	 * Information needed by tuple routing target relations
 	 *
-- 
2.24.1

From 5a700674961a808e0f1048cf0300dcca6dc58be1 Mon Sep 17 00:00:00 2001
From: amitlan <amitlangote09@gmail.com>
Date: Tue, 25 May 2021 22:48:47 +0900
Subject: [PATCH 1/2] ExecFindPartition: cache last used partition v4

---
 src/backend/executor/execPartition.c | 253 +++++++++++++++++++--------
 1 file changed, 184 insertions(+), 69 deletions(-)

diff --git a/src/backend/executor/execPartition.c b/src/backend/executor/execPartition.c
index 606c920b06..3e6c8c58c4 100644
--- a/src/backend/executor/execPartition.c
+++ b/src/backend/executor/execPartition.c
@@ -133,6 +133,16 @@ struct PartitionTupleRouting
  *		routing it through this table). A NULL value is stored if no tuple
  *		conversion is required.
  *
+ * savedPartResultInfo
+ *		If non-NULL, ResultRelInfo for the partition that was most recently
+ *		chosen as the routing target; ExecFindPartition() checks if the
+ *		same one can be used for the current row before applying the tuple-
+ *		routing algorithm to it.
+ *
+ * savedPartDispatchInfo
+ *		If non-NULL, PartititionDispatch for the sub-partitioned partition
+ *		that was most recently chosen as the routing target
+ *
  * indexes
  *		Array of partdesc->nparts elements.  For leaf partitions the index
  *		corresponds to the partition's ResultRelInfo in the encapsulating
@@ -150,6 +160,8 @@ typedef struct PartitionDispatchData
 	PartitionDesc partdesc;
 	TupleTableSlot *tupslot;
 	AttrMap    *tupmap;
+	ResultRelInfo *savedPartResultInfo;
+	PartitionDispatch savedPartDispatchInfo;
 	int			indexes[FLEXIBLE_ARRAY_MEMBER];
 }			PartitionDispatchData;
 
@@ -234,6 +246,88 @@ ExecSetupPartitionTupleRouting(EState *estate, Relation rel)
 	return proute;
 }
 
+/*
+ * Remember this partition for the next tuple inserted into this parent; see
+ * CanUseSavedPartitionForTuple() for how it's decided whether a tuple can
+ * indeed reuse this partition.
+ *
+ * Do this only if we have range/list partitions, because only
+ * in that case it's conceivable that consecutively inserted rows
+ * tend to go into the same partition.
+ */
+static inline void
+SavePartitionForNextTuple(PartitionDispatch dispatch,
+						  ResultRelInfo *partInfo,
+						  PartitionDispatch dispatchInfo)
+{
+	if ((dispatch->key->strategy == PARTITION_STRATEGY_RANGE ||
+		 dispatch->key->strategy == PARTITION_STRATEGY_LIST))
+	{
+		dispatch->savedPartResultInfo = partInfo;
+		dispatch->savedPartDispatchInfo = dispatchInfo;
+	}
+}
+
+/*
+ * Check if the saved partition accepts this tuple by evaluating its
+ * partition constraint against the tuple.  If it does, we save a trip
+ * to get_partition_for_tuple(), which can be a slightly more expensive
+ * way to get the same partition, especially if there are many
+ * partitions to search through.
+ */
+static inline bool
+CanUseSavedPartitionForTuple(PartitionDispatch dispatch,
+							 TupleTableSlot *rootslot,
+							 EState *estate)
+{
+	if (dispatch->savedPartResultInfo)
+	{
+		ResultRelInfo *rri;
+		TupleTableSlot *tmpslot;
+		TupleConversionMap *map;
+
+		rri = dispatch->savedPartResultInfo;
+
+		/*
+		 * If needed, convert the root-parent layout tuple into the partition's
+		 * layout, because ExecPartitionCheck() expects to be passed the
+		 * latter.
+		 */
+		map = rri->ri_RootToPartitionMap;
+		if (map)
+			tmpslot = execute_attr_map_slot(map->attrMap, rootslot,
+											rri->ri_PartitionTupleSlot);
+		else
+			tmpslot = rootslot;
+		return ExecPartitionCheck(rri, tmpslot, estate, false);
+	}
+
+	return false;
+}
+
+/*
+ * Convert tuple to a given sub-partitioned partition's layout, if
+ * needed.
+ */
+static inline TupleTableSlot *
+ConvertTupleToPartition(PartitionDispatch dispatch,
+						TupleTableSlot *slot,
+						TupleTableSlot *parent_slot)
+{
+	if (dispatch->tupslot)
+	{
+		AttrMap    *map = dispatch->tupmap;
+
+		Assert(map != NULL);
+		slot = execute_attr_map_slot(map, slot, dispatch->tupslot);
+		/* Don't leak the previous parent's copy of the tuple. */
+		if (parent_slot)
+			ExecClearTuple(parent_slot);
+	}
+
+	return slot;
+}
+
 /*
  * ExecFindPartition -- Return the ResultRelInfo for the leaf partition that
  * the tuple contained in *slot should belong to.
@@ -292,6 +386,35 @@ ExecFindPartition(ModifyTableState *mtstate,
 		CHECK_FOR_INTERRUPTS();
 
 		rel = dispatch->reldesc;
+
+		if (CanUseSavedPartitionForTuple(dispatch, rootslot, estate))
+		{
+			/* If the saved partition is leaf partition, just return it. */
+			if (dispatch->savedPartDispatchInfo == NULL)
+			{
+				/* Restore ecxt's scantuple before returning. */
+				ecxt->ecxt_scantuple = ecxt_scantuple_saved;
+				MemoryContextSwitchTo(oldcxt);
+				return dispatch->savedPartResultInfo;
+			}
+			else
+			{
+				/*
+				 * Saved partition is sub-partitioned, so continue the loop to
+				 * find the next level partition.
+				 */
+				myslot = dispatch->tupslot;
+				dispatch = dispatch->savedPartDispatchInfo;
+				slot = ConvertTupleToPartition(dispatch, slot, myslot);
+				continue;
+			}
+		}
+		else
+		{
+			dispatch->savedPartResultInfo = rri = NULL;
+			dispatch->savedPartDispatchInfo = NULL;
+		}
+
 		partdesc = dispatch->partdesc;
 
 		/*
@@ -331,16 +454,10 @@ ExecFindPartition(ModifyTableState *mtstate,
 		if (is_leaf)
 		{
 			/*
-			 * We've reached the leaf -- hurray, we're done.  Look to see if
-			 * we've already got a ResultRelInfo for this partition.
+			 * We've reached the leaf -- hurray, we're done.  Build the
+			 * ResultRelInfo for this partition if not already done.
 			 */
-			if (likely(dispatch->indexes[partidx] >= 0))
-			{
-				/* ResultRelInfo already built */
-				Assert(dispatch->indexes[partidx] < proute->num_partitions);
-				rri = proute->partitions[dispatch->indexes[partidx]];
-			}
-			else
+			if (unlikely(dispatch->indexes[partidx] < 0))
 			{
 				/*
 				 * If the partition is known in the owning ModifyTableState
@@ -370,65 +487,50 @@ ExecFindPartition(ModifyTableState *mtstate,
 												rootResultRelInfo, partidx);
 				}
 			}
+
+			Assert(dispatch->indexes[partidx] < proute->num_partitions);
+			rri = proute->partitions[dispatch->indexes[partidx]];
 			Assert(rri != NULL);
 
+			SavePartitionForNextTuple(dispatch, rri, NULL);
+
 			/* Signal to terminate the loop */
 			dispatch = NULL;
 		}
 		else
 		{
+			PartitionDispatch subdispatch;
+
 			/*
-			 * Partition is a sub-partitioned table; get the PartitionDispatch
+			 * Partition is a sub-partitioned table; get the PartitionDispatch.
+			 * Build it if not already done, passing the current one in as the
+			 * parent PartitionDspatch.
 			 */
-			if (likely(dispatch->indexes[partidx] >= 0))
-			{
-				/* Already built. */
-				Assert(dispatch->indexes[partidx] < proute->num_dispatch);
-
-				rri = proute->nonleaf_partitions[dispatch->indexes[partidx]];
-
-				/*
-				 * Move down to the next partition level and search again
-				 * until we find a leaf partition that matches this tuple
-				 */
-				dispatch = pd[dispatch->indexes[partidx]];
-			}
-			else
-			{
-				/* Not yet built. Do that now. */
-				PartitionDispatch subdispatch;
-
-				/*
-				 * Create the new PartitionDispatch.  We pass the current one
-				 * in as the parent PartitionDispatch
-				 */
+			if (unlikely(dispatch->indexes[partidx] < 0))
 				subdispatch = ExecInitPartitionDispatchInfo(estate,
 															proute,
 															partdesc->oids[partidx],
 															dispatch, partidx,
 															mtstate->rootResultRelInfo);
-				Assert(dispatch->indexes[partidx] >= 0 &&
-					   dispatch->indexes[partidx] < proute->num_dispatch);
-
-				rri = proute->nonleaf_partitions[dispatch->indexes[partidx]];
-				dispatch = subdispatch;
-			}
+			Assert(dispatch->indexes[partidx] >= 0 &&
+				   dispatch->indexes[partidx] < proute->num_dispatch);
 
 			/*
-			 * Convert the tuple to the new parent's layout, if different from
-			 * the previous parent.
+			 * Move down to the next partition level and search again
+			 * until we find a leaf partition that matches this tuple
 			 */
-			if (dispatch->tupslot)
-			{
-				AttrMap    *map = dispatch->tupmap;
-				TupleTableSlot *tempslot = myslot;
+			subdispatch = pd[dispatch->indexes[partidx]];
+			rri = proute->nonleaf_partitions[dispatch->indexes[partidx]];
 
-				myslot = dispatch->tupslot;
-				slot = execute_attr_map_slot(map, slot, myslot);
+			/*
+			 * Save both the PartitionDispatch and the ResultRelInfo of
+			 * this partition to consider reusing for the next tuple.
+			 */
+			SavePartitionForNextTuple(dispatch, rri, subdispatch);
 
-				if (tempslot != NULL)
-					ExecClearTuple(tempslot);
-			}
+			myslot = dispatch->tupslot;
+			dispatch = subdispatch;
+			slot = ConvertTupleToPartition(dispatch, slot, myslot);
 		}
 
 		/*
@@ -858,27 +960,11 @@ ExecInitPartitionInfo(ModifyTableState *mtstate, EState *estate,
 	return leaf_part_rri;
 }
 
-/*
- * ExecInitRoutingInfo
- *		Set up information needed for translating tuples between root
- *		partitioned table format and partition format, and keep track of it
- *		in PartitionTupleRouting.
- */
-static void
-ExecInitRoutingInfo(ModifyTableState *mtstate,
-					EState *estate,
-					PartitionTupleRouting *proute,
-					PartitionDispatch dispatch,
-					ResultRelInfo *partRelInfo,
-					int partidx,
-					bool is_borrowed_rel)
+static inline void
+InitRootToPartitionMap(ResultRelInfo *partRelInfo,
+					   ResultRelInfo *rootRelInfo,
+					   EState *estate)
 {
-	ResultRelInfo *rootRelInfo = partRelInfo->ri_RootResultRelInfo;
-	MemoryContext oldcxt;
-	int			rri_index;
-
-	oldcxt = MemoryContextSwitchTo(proute->memcxt);
-
 	/*
 	 * Set up a tuple conversion map to convert a tuple routed to the
 	 * partition from the parent's type to the partition's.
@@ -907,6 +993,30 @@ ExecInitRoutingInfo(ModifyTableState *mtstate,
 	}
 	else
 		partRelInfo->ri_PartitionTupleSlot = NULL;
+}
+
+/*
+ * ExecInitRoutingInfo
+ *		Set up information needed for translating tuples between root
+ *		partitioned table format and partition format, and keep track of it
+ *		in PartitionTupleRouting.
+ */
+static void
+ExecInitRoutingInfo(ModifyTableState *mtstate,
+					EState *estate,
+					PartitionTupleRouting *proute,
+					PartitionDispatch dispatch,
+					ResultRelInfo *partRelInfo,
+					int partidx,
+					bool is_borrowed_rel)
+{
+	ResultRelInfo *rootRelInfo = partRelInfo->ri_RootResultRelInfo;
+	MemoryContext oldcxt;
+	int			rri_index;
+
+	oldcxt = MemoryContextSwitchTo(proute->memcxt);
+
+	InitRootToPartitionMap(partRelInfo, rootRelInfo, estate);
 
 	/*
 	 * If the partition is a foreign table, let the FDW init itself for
@@ -1051,6 +1161,9 @@ ExecInitPartitionDispatchInfo(EState *estate,
 		pd->tupslot = NULL;
 	}
 
+	pd->savedPartResultInfo = NULL;
+	pd->savedPartDispatchInfo = NULL;
+
 	/*
 	 * Initialize with -1 to signify that the corresponding partition's
 	 * ResultRelInfo or PartitionDispatch has not been created yet.
@@ -1094,6 +1207,8 @@ ExecInitPartitionDispatchInfo(EState *estate,
 		ResultRelInfo *rri = makeNode(ResultRelInfo);
 
 		InitResultRelInfo(rri, rel, 0, rootResultRelInfo, 0);
+		/* The map is needed in CanUseSavedPartitionForTuple(). */
+		InitRootToPartitionMap(rri, rootResultRelInfo, estate);
 		proute->nonleaf_partitions[dispatchidx] = rri;
 	}
 	else
-- 
2.24.1

From c3c7c9646a5223faae0977c8b5c91e178d3a3c18 Mon Sep 17 00:00:00 2001
From: amitlan <amitlangote09@gmail.com>
Date: Tue, 25 May 2021 22:55:12 +0900
Subject: [PATCH v5 2/2] ExecPartitionCheck: pre-compute partition key
 expression v2

---
 src/backend/executor/execMain.c      | 95 ++++++++++++++++++++++++++++
 src/backend/executor/execPartition.c | 46 ++++++++++++++
 src/include/nodes/execnodes.h        |  9 +++
 3 files changed, 150 insertions(+)

diff --git a/src/backend/executor/execMain.c b/src/backend/executor/execMain.c
index b3ce4bae53..1fc2a9fe82 100644
--- a/src/backend/executor/execMain.c
+++ b/src/backend/executor/execMain.c
@@ -44,6 +44,7 @@
 #include "access/transam.h"
 #include "access/xact.h"
 #include "catalog/namespace.h"
+#include "catalog/partition.h"
 #include "catalog/pg_publication.h"
 #include "commands/matview.h"
 #include "commands/trigger.h"
@@ -52,6 +53,8 @@
 #include "foreign/fdwapi.h"
 #include "jit/jit.h"
 #include "mb/pg_wchar.h"
+#include "nodes/makefuncs.h"
+#include "nodes/nodeFuncs.h"
 #include "miscadmin.h"
 #include "parser/parsetree.h"
 #include "storage/bufmgr.h"
@@ -1686,6 +1689,32 @@ ExecRelCheck(ResultRelInfo *resultRelInfo,
 	return NULL;
 }
 
+/*
+ * Replaces the occurrence of cxt->matchexpr in the expression tree given by
+ * 'node' by an OUTER var with provided attribute number.
+ */
+typedef struct
+{
+	Expr	   *matchexpr;
+	AttrNumber	varattno;
+} replace_partexpr_with_dummy_var_context;
+
+static Node *
+replace_partexpr_with_dummy_var(Node *node,
+								replace_partexpr_with_dummy_var_context *cxt)
+{
+	if (node == NULL)
+		return NULL;
+
+	if (equal(node, cxt->matchexpr))
+		return (Node *) makeVar(OUTER_VAR, cxt->varattno,
+								exprType(node), exprTypmod(node),
+								exprCollation(node), 0);
+
+	return expression_tree_mutator(node, replace_partexpr_with_dummy_var,
+								   (void *) cxt);
+}
+
 /*
  * ExecPartitionCheck --- check that tuple meets the partition constraint.
  *
@@ -1716,6 +1745,45 @@ ExecPartitionCheck(ResultRelInfo *resultRelInfo, TupleTableSlot *slot,
 		MemoryContext oldcxt = MemoryContextSwitchTo(estate->es_query_cxt);
 		List	   *qual = RelationGetPartitionQual(resultRelInfo->ri_RelationDesc);
 
+		/*
+		 * Optimize the evaluation of partition key expressions.  The way we do
+		 * that is by replacing any occurrences of the individual expressions
+		 * in this relation's partition constraint by dummy Vars marked as
+		 * coming from the "OUTER" relation.  Then when actually executing such
+		 * modified partition constraint tree, we feed the actual partition
+		 * expression values via econtext->ecxt_outertuple; see below.
+		 */
+		if (resultRelInfo->ri_partConstrKeyExprs)
+		{
+			List	  *partexprs = resultRelInfo->ri_partConstrKeyExprs;
+			ListCell  *lc;
+			AttrNumber attrno = 1;
+			TupleDesc	partexprs_tupdesc;
+			replace_partexpr_with_dummy_var_context cxt;
+
+			partexprs_tupdesc = CreateTemplateTupleDesc(list_length(partexprs));
+			foreach(lc, partexprs)
+			{
+				Expr   *expr = lfirst(lc);
+
+				cxt.matchexpr = expr;
+				cxt.varattno = attrno;
+				qual = (List *) replace_partexpr_with_dummy_var((Node *) qual,
+																&cxt);
+
+				resultRelInfo->ri_partConstrKeyExprStates =
+					lappend(resultRelInfo->ri_partConstrKeyExprStates,
+							ExecPrepareExpr(expr, estate));
+				TupleDescInitEntry(partexprs_tupdesc, attrno, NULL,
+								   exprType((Node *) expr),
+								   exprTypmod((Node *) expr), 0);
+				attrno++;
+			}
+
+			resultRelInfo->ri_partConstrKeyExprsSlot =
+				ExecInitExtraTupleSlot(estate, partexprs_tupdesc, &TTSOpsVirtual);
+		}
+
 		resultRelInfo->ri_PartitionCheckExpr = ExecPrepareCheck(qual, estate);
 		MemoryContextSwitchTo(oldcxt);
 	}
@@ -1729,6 +1797,33 @@ ExecPartitionCheck(ResultRelInfo *resultRelInfo, TupleTableSlot *slot,
 	/* Arrange for econtext's scan tuple to be the tuple under test */
 	econtext->ecxt_scantuple = slot;
 
+	if (resultRelInfo->ri_partConstrKeyExprStates)
+	{
+		TupleTableSlot *partexprs_slot = resultRelInfo->ri_partConstrKeyExprsSlot;
+		Datum	*values;
+		bool	*isnull;
+		ListCell *lc;
+		AttrNumber attrno = 1;
+
+		Assert(partexprs_slot != NULL);
+		ExecClearTuple(partexprs_slot);
+
+		values = partexprs_slot->tts_values;
+		isnull = partexprs_slot->tts_isnull;
+
+		foreach(lc, resultRelInfo->ri_partConstrKeyExprStates)
+		{
+			ExprState   *partexpr = lfirst(lc);
+
+			values[attrno-1] = ExecEvalExprSwitchContext(partexpr, econtext,
+												  &isnull[attrno-1]);
+			attrno++;
+		}
+		ExecStoreVirtualTuple(partexprs_slot);
+
+		econtext->ecxt_outertuple = partexprs_slot;
+	}
+
 	/*
 	 * As in case of the catalogued constraints, we treat a NULL result as
 	 * success here, not a failure.
diff --git a/src/backend/executor/execPartition.c b/src/backend/executor/execPartition.c
index dd812ae3fc..75dc151535 100644
--- a/src/backend/executor/execPartition.c
+++ b/src/backend/executor/execPartition.c
@@ -143,6 +143,13 @@ struct PartitionTupleRouting
  *		If non-NULL, PartititionDispatch for the sub-partitioned partition
  *		that was most recently chosen as the routing target
  *
+ * partconstr_keyexprs
+ *		List of expressions present in the partition keys of all ancestors
+ *		of this table including itself, mapped to have the attribute
+ *		numbers of this table.  The field is so named because all of these
+ *		expressions appear in the partition constraint of each of this
+ *		table's partitions.
+ *
  * indexes
  *		Array of partdesc->nparts elements.  For leaf partitions the index
  *		corresponds to the partition's ResultRelInfo in the encapsulating
@@ -162,6 +169,7 @@ typedef struct PartitionDispatchData
 	AttrMap    *tupmap;
 	ResultRelInfo *savedPartResultInfo;
 	PartitionDispatch savedPartDispatchInfo;
+	List	   *partconstr_keyexprs;
 	int			indexes[FLEXIBLE_ARRAY_MEMBER];
 }			PartitionDispatchData;
 
@@ -994,6 +1002,21 @@ InitRootToPartitionMap(ResultRelInfo *partRelInfo,
 		partRelInfo->ri_PartitionTupleSlot = NULL;
 }
 
+/*
+ * Save parent's partition key expressions in the partition ResultRelInfo
+ * after mapping them to have the partition's attribute numbers.
+ */
+static inline void
+InitPartitionConstraintKeyExprs(PartitionDispatch dispatch,
+								ResultRelInfo *partRelInfo)
+{
+	if (dispatch->partconstr_keyexprs)
+		partRelInfo->ri_partConstrKeyExprs =
+			map_partition_varattnos(dispatch->partconstr_keyexprs, 1,
+									partRelInfo->ri_RelationDesc,
+									dispatch->reldesc);
+}
+
 /*
  * ExecInitRoutingInfo
  *		Set up information needed for translating tuples between root
@@ -1045,6 +1068,8 @@ ExecInitRoutingInfo(ModifyTableState *mtstate,
 
 	partRelInfo->ri_CopyMultiInsertBuffer = NULL;
 
+	InitPartitionConstraintKeyExprs(dispatch, partRelInfo);
+
 	/*
 	 * Keep track of it in the PartitionTupleRouting->partitions array.
 	 */
@@ -1163,6 +1188,26 @@ ExecInitPartitionDispatchInfo(EState *estate,
 	pd->savedPartResultInfo = NULL;
 	pd->savedPartDispatchInfo = NULL;
 
+	if (pd->key->partexprs != NIL)
+	{
+		pd->partconstr_keyexprs = copyObject(pd->key->partexprs);
+		if (parent_pd)
+		{
+			List   *parent_keyexprs = parent_pd->partconstr_keyexprs;
+
+			if (parent_keyexprs && pd->tupmap)
+				parent_keyexprs = map_partition_varattnos(parent_keyexprs, 1,
+														  rel,
+														  parent_pd->reldesc);
+			else if (parent_keyexprs)
+				parent_keyexprs = copyObject(parent_keyexprs);
+			pd->partconstr_keyexprs =
+				list_concat(pd->partconstr_keyexprs, parent_keyexprs);
+		}
+	}
+	else
+		pd->partconstr_keyexprs = NIL;
+
 	/*
 	 * Initialize with -1 to signify that the corresponding partition's
 	 * ResultRelInfo or PartitionDispatch has not been created yet.
@@ -1208,6 +1253,7 @@ ExecInitPartitionDispatchInfo(EState *estate,
 		InitResultRelInfo(rri, rel, 0, rootResultRelInfo, 0);
 		/* The map is needed in CanUseSavedPartitionForTuple(). */
 		InitRootToPartitionMap(rri, rootResultRelInfo, estate);
+		InitPartitionConstraintKeyExprs(pd, rri);
 		proute->nonleaf_partitions[dispatchidx] = rri;
 	}
 	else
diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h
index 7795a69490..7f1ce732ea 100644
--- a/src/include/nodes/execnodes.h
+++ b/src/include/nodes/execnodes.h
@@ -496,6 +496,15 @@ typedef struct ResultRelInfo
 	/* partition check expression state (NULL if not set up yet) */
 	ExprState  *ri_PartitionCheckExpr;
 
+	/*
+	 * Information used by ExecPartitionCheck() to optimize some cases where
+	 * the partition's ancestors' partition keys contain arbitrary
+	 * expressions.
+	 */
+	List	   *ri_partConstrKeyExprs;
+	List	   *ri_partConstrKeyExprStates;
+	TupleTableSlot *ri_partConstrKeyExprsSlot;
+
 	/*
 	 * Information needed by tuple routing target relations
 	 *
-- 
2.24.1

From 47e87e416dc67b1a22b7189388b897ceda76e1fa Mon Sep 17 00:00:00 2001
From: amitlan <amitlangote09@gmail.com>
Date: Tue, 25 May 2021 22:48:47 +0900
Subject: [PATCH v5 1/2] ExecFindPartition: cache last used partition

---
 src/backend/executor/execPartition.c | 252 +++++++++++++++++++--------
 1 file changed, 183 insertions(+), 69 deletions(-)

diff --git a/src/backend/executor/execPartition.c b/src/backend/executor/execPartition.c
index 606c920b06..dd812ae3fc 100644
--- a/src/backend/executor/execPartition.c
+++ b/src/backend/executor/execPartition.c
@@ -133,6 +133,16 @@ struct PartitionTupleRouting
  *		routing it through this table). A NULL value is stored if no tuple
  *		conversion is required.
  *
+ * savedPartResultInfo
+ *		If non-NULL, ResultRelInfo for the partition that was most recently
+ *		chosen as the routing target; ExecFindPartition() checks if the
+ *		same one can be used for the current row before applying the tuple-
+ *		routing algorithm to it.
+ *
+ * savedPartDispatchInfo
+ *		If non-NULL, PartititionDispatch for the sub-partitioned partition
+ *		that was most recently chosen as the routing target
+ *
  * indexes
  *		Array of partdesc->nparts elements.  For leaf partitions the index
  *		corresponds to the partition's ResultRelInfo in the encapsulating
@@ -150,6 +160,8 @@ typedef struct PartitionDispatchData
 	PartitionDesc partdesc;
 	TupleTableSlot *tupslot;
 	AttrMap    *tupmap;
+	ResultRelInfo *savedPartResultInfo;
+	PartitionDispatch savedPartDispatchInfo;
 	int			indexes[FLEXIBLE_ARRAY_MEMBER];
 }			PartitionDispatchData;
 
@@ -234,6 +246,87 @@ ExecSetupPartitionTupleRouting(EState *estate, Relation rel)
 	return proute;
 }
 
+/*
+ * Remember this partition for the next tuple inserted into this parent; see
+ * CanUseSavedPartitionForTuple() for how it's decided whether a tuple can
+ * indeed reuse this partition.
+ *
+ * Do this only if we have range/list partitions, because only
+ * in that case it's conceivable that consecutively inserted rows
+ * tend to go into the same partition.
+ */
+static inline void
+SavePartitionForNextTuple(PartitionDispatch dispatch,
+						  ResultRelInfo *partInfo,
+						  PartitionDispatch dispatchInfo)
+{
+	if ((dispatch->key->strategy == PARTITION_STRATEGY_RANGE ||
+		 dispatch->key->strategy == PARTITION_STRATEGY_LIST))
+	{
+		dispatch->savedPartResultInfo = partInfo;
+		dispatch->savedPartDispatchInfo = dispatchInfo;
+	}
+}
+
+/*
+ * Check if the saved partition accepts this tuple by evaluating its
+ * partition constraint against the tuple.  If it does, we save a trip
+ * to get_partition_for_tuple(), which can be a slightly more expensive
+ * way to get the same partition, especially if there are many
+ * partitions to search through.
+ */
+static inline bool
+CanUseSavedPartitionForTuple(PartitionDispatch dispatch,
+							 TupleTableSlot *rootslot,
+							 EState *estate)
+{
+	ResultRelInfo *rri;
+	TupleTableSlot *slot;
+	TupleConversionMap *map;
+
+	if (dispatch->savedPartResultInfo == NULL)
+		return false;
+
+	rri = dispatch->savedPartResultInfo;
+
+	/*
+	 * If needed, convert the root-parent layout tuple into the partition's
+	 * layout, because ExecPartitionCheck() expects to be passed the
+	 * latter.
+	 */
+	map = rri->ri_RootToPartitionMap;
+	if (map)
+		slot = execute_attr_map_slot(map->attrMap, rootslot,
+									 rri->ri_PartitionTupleSlot);
+	else
+		slot = rootslot;
+
+	return ExecPartitionCheck(rri, slot, estate, false);
+}
+
+/*
+ * Convert tuple to a given sub-partitioned partition's layout, if
+ * needed.
+ */
+static inline TupleTableSlot *
+ConvertTupleToPartition(PartitionDispatch dispatch,
+						TupleTableSlot *slot,
+						TupleTableSlot *parent_slot)
+{
+	if (dispatch->tupslot)
+	{
+		AttrMap    *map = dispatch->tupmap;
+
+		Assert(map != NULL);
+		slot = execute_attr_map_slot(map, slot, dispatch->tupslot);
+		/* Don't leak the previous parent's copy of the tuple. */
+		if (parent_slot)
+			ExecClearTuple(parent_slot);
+	}
+
+	return slot;
+}
+
 /*
  * ExecFindPartition -- Return the ResultRelInfo for the leaf partition that
  * the tuple contained in *slot should belong to.
@@ -292,6 +385,35 @@ ExecFindPartition(ModifyTableState *mtstate,
 		CHECK_FOR_INTERRUPTS();
 
 		rel = dispatch->reldesc;
+
+		if (CanUseSavedPartitionForTuple(dispatch, rootslot, estate))
+		{
+			/* If the saved partition is leaf partition, just return it. */
+			if (dispatch->savedPartDispatchInfo == NULL)
+			{
+				/* Restore ecxt's scantuple before returning. */
+				ecxt->ecxt_scantuple = ecxt_scantuple_saved;
+				MemoryContextSwitchTo(oldcxt);
+				return dispatch->savedPartResultInfo;
+			}
+			else
+			{
+				/*
+				 * Saved partition is sub-partitioned, so continue the loop to
+				 * find the next level partition.
+				 */
+				myslot = dispatch->tupslot;
+				dispatch = dispatch->savedPartDispatchInfo;
+				slot = ConvertTupleToPartition(dispatch, slot, myslot);
+				continue;
+			}
+		}
+		else
+		{
+			dispatch->savedPartResultInfo = rri = NULL;
+			dispatch->savedPartDispatchInfo = NULL;
+		}
+
 		partdesc = dispatch->partdesc;
 
 		/*
@@ -331,16 +453,10 @@ ExecFindPartition(ModifyTableState *mtstate,
 		if (is_leaf)
 		{
 			/*
-			 * We've reached the leaf -- hurray, we're done.  Look to see if
-			 * we've already got a ResultRelInfo for this partition.
+			 * We've reached the leaf -- hurray, we're done.  Build the
+			 * ResultRelInfo for this partition if not already done.
 			 */
-			if (likely(dispatch->indexes[partidx] >= 0))
-			{
-				/* ResultRelInfo already built */
-				Assert(dispatch->indexes[partidx] < proute->num_partitions);
-				rri = proute->partitions[dispatch->indexes[partidx]];
-			}
-			else
+			if (unlikely(dispatch->indexes[partidx] < 0))
 			{
 				/*
 				 * If the partition is known in the owning ModifyTableState
@@ -370,65 +486,50 @@ ExecFindPartition(ModifyTableState *mtstate,
 												rootResultRelInfo, partidx);
 				}
 			}
+
+			Assert(dispatch->indexes[partidx] < proute->num_partitions);
+			rri = proute->partitions[dispatch->indexes[partidx]];
 			Assert(rri != NULL);
 
+			SavePartitionForNextTuple(dispatch, rri, NULL);
+
 			/* Signal to terminate the loop */
 			dispatch = NULL;
 		}
 		else
 		{
+			PartitionDispatch subdispatch;
+
 			/*
-			 * Partition is a sub-partitioned table; get the PartitionDispatch
+			 * Partition is a sub-partitioned table; get the PartitionDispatch.
+			 * Build it if not already done, passing the current one in as the
+			 * parent PartitionDspatch.
 			 */
-			if (likely(dispatch->indexes[partidx] >= 0))
-			{
-				/* Already built. */
-				Assert(dispatch->indexes[partidx] < proute->num_dispatch);
-
-				rri = proute->nonleaf_partitions[dispatch->indexes[partidx]];
-
-				/*
-				 * Move down to the next partition level and search again
-				 * until we find a leaf partition that matches this tuple
-				 */
-				dispatch = pd[dispatch->indexes[partidx]];
-			}
-			else
-			{
-				/* Not yet built. Do that now. */
-				PartitionDispatch subdispatch;
-
-				/*
-				 * Create the new PartitionDispatch.  We pass the current one
-				 * in as the parent PartitionDispatch
-				 */
+			if (unlikely(dispatch->indexes[partidx] < 0))
 				subdispatch = ExecInitPartitionDispatchInfo(estate,
 															proute,
 															partdesc->oids[partidx],
 															dispatch, partidx,
 															mtstate->rootResultRelInfo);
-				Assert(dispatch->indexes[partidx] >= 0 &&
-					   dispatch->indexes[partidx] < proute->num_dispatch);
-
-				rri = proute->nonleaf_partitions[dispatch->indexes[partidx]];
-				dispatch = subdispatch;
-			}
+			Assert(dispatch->indexes[partidx] >= 0 &&
+				   dispatch->indexes[partidx] < proute->num_dispatch);
 
 			/*
-			 * Convert the tuple to the new parent's layout, if different from
-			 * the previous parent.
+			 * Move down to the next partition level and search again
+			 * until we find a leaf partition that matches this tuple
 			 */
-			if (dispatch->tupslot)
-			{
-				AttrMap    *map = dispatch->tupmap;
-				TupleTableSlot *tempslot = myslot;
+			subdispatch = pd[dispatch->indexes[partidx]];
+			rri = proute->nonleaf_partitions[dispatch->indexes[partidx]];
 
-				myslot = dispatch->tupslot;
-				slot = execute_attr_map_slot(map, slot, myslot);
+			/*
+			 * Save both the PartitionDispatch and the ResultRelInfo of
+			 * this partition to consider reusing for the next tuple.
+			 */
+			SavePartitionForNextTuple(dispatch, rri, subdispatch);
 
-				if (tempslot != NULL)
-					ExecClearTuple(tempslot);
-			}
+			myslot = dispatch->tupslot;
+			dispatch = subdispatch;
+			slot = ConvertTupleToPartition(dispatch, slot, myslot);
 		}
 
 		/*
@@ -858,27 +959,11 @@ ExecInitPartitionInfo(ModifyTableState *mtstate, EState *estate,
 	return leaf_part_rri;
 }
 
-/*
- * ExecInitRoutingInfo
- *		Set up information needed for translating tuples between root
- *		partitioned table format and partition format, and keep track of it
- *		in PartitionTupleRouting.
- */
-static void
-ExecInitRoutingInfo(ModifyTableState *mtstate,
-					EState *estate,
-					PartitionTupleRouting *proute,
-					PartitionDispatch dispatch,
-					ResultRelInfo *partRelInfo,
-					int partidx,
-					bool is_borrowed_rel)
+static inline void
+InitRootToPartitionMap(ResultRelInfo *partRelInfo,
+					   ResultRelInfo *rootRelInfo,
+					   EState *estate)
 {
-	ResultRelInfo *rootRelInfo = partRelInfo->ri_RootResultRelInfo;
-	MemoryContext oldcxt;
-	int			rri_index;
-
-	oldcxt = MemoryContextSwitchTo(proute->memcxt);
-
 	/*
 	 * Set up a tuple conversion map to convert a tuple routed to the
 	 * partition from the parent's type to the partition's.
@@ -907,6 +992,30 @@ ExecInitRoutingInfo(ModifyTableState *mtstate,
 	}
 	else
 		partRelInfo->ri_PartitionTupleSlot = NULL;
+}
+
+/*
+ * ExecInitRoutingInfo
+ *		Set up information needed for translating tuples between root
+ *		partitioned table format and partition format, and keep track of it
+ *		in PartitionTupleRouting.
+ */
+static void
+ExecInitRoutingInfo(ModifyTableState *mtstate,
+					EState *estate,
+					PartitionTupleRouting *proute,
+					PartitionDispatch dispatch,
+					ResultRelInfo *partRelInfo,
+					int partidx,
+					bool is_borrowed_rel)
+{
+	ResultRelInfo *rootRelInfo = partRelInfo->ri_RootResultRelInfo;
+	MemoryContext oldcxt;
+	int			rri_index;
+
+	oldcxt = MemoryContextSwitchTo(proute->memcxt);
+
+	InitRootToPartitionMap(partRelInfo, rootRelInfo, estate);
 
 	/*
 	 * If the partition is a foreign table, let the FDW init itself for
@@ -1051,6 +1160,9 @@ ExecInitPartitionDispatchInfo(EState *estate,
 		pd->tupslot = NULL;
 	}
 
+	pd->savedPartResultInfo = NULL;
+	pd->savedPartDispatchInfo = NULL;
+
 	/*
 	 * Initialize with -1 to signify that the corresponding partition's
 	 * ResultRelInfo or PartitionDispatch has not been created yet.
@@ -1094,6 +1206,8 @@ ExecInitPartitionDispatchInfo(EState *estate,
 		ResultRelInfo *rri = makeNode(ResultRelInfo);
 
 		InitResultRelInfo(rri, rel, 0, rootResultRelInfo, 0);
+		/* The map is needed in CanUseSavedPartitionForTuple(). */
+		InitRootToPartitionMap(rri, rootResultRelInfo, estate);
 		proute->nonleaf_partitions[dispatchidx] = rri;
 	}
 	else
-- 
2.24.1

From b86db0abe56ee6126c3dbf5e3f59da9baaff594f Mon Sep 17 00:00:00 2001
From: houzj <houzj.fnst@fujitsu.com>
Date: Tue, 1 Jun 2021 14:25:21 +0800
Subject: [PATCH] cache-bound-offset

Cached the bound offset in PartitionDescData.

Everytime we try to find a partition, we first use the cached offset to get
the target bound datum(low bound value and low bound value) from
PartitionBoundInfoData and check if the partition key value match the bound datum.
If match, we skip the get_partition_for_tuple.

Currently, only cache the bound offset in LIST and RANGE partition strategy.

---
 src/backend/executor/execPartition.c | 170 +++++++++++++++++++++++++++++------
 src/backend/partitioning/partdesc.c  |   2 +
 src/include/partitioning/partdesc.h  |   2 +
 3 files changed, 147 insertions(+), 27 deletions(-)

diff --git a/src/backend/executor/execPartition.c b/src/backend/executor/execPartition.c
index 606c920..7885f5d 100644
--- a/src/backend/executor/execPartition.c
+++ b/src/backend/executor/execPartition.c
@@ -176,7 +176,9 @@ static void FormPartitionKeyDatum(PartitionDispatch pd,
 								  Datum *values,
 								  bool *isnull);
 static int	get_partition_for_tuple(PartitionDispatch pd, Datum *values,
-									bool *isnull);
+									bool *isnull, int *bound_offset);
+static int check_partition_for_tuple(PartitionDispatch pd, Datum *values,
+									  bool *isnull, int partidx);
 static char *ExecBuildSlotPartitionKeyDescription(Relation rel,
 												  Datum *values,
 												  bool *isnull,
@@ -287,12 +289,14 @@ ExecFindPartition(ModifyTableState *mtstate,
 	while (dispatch != NULL)
 	{
 		int			partidx = -1;
+		int			cached_bound_offset = -1;
 		bool		is_leaf;
 
 		CHECK_FOR_INTERRUPTS();
 
 		rel = dispatch->reldesc;
 		partdesc = dispatch->partdesc;
+		cached_bound_offset = partdesc->bound_offset;
 
 		/*
 		 * Extract partition key from tuple. Expression evaluation machinery
@@ -305,26 +309,39 @@ ExecFindPartition(ModifyTableState *mtstate,
 		ecxt->ecxt_scantuple = slot;
 		FormPartitionKeyDatum(dispatch, slot, estate, values, isnull);
 
-		/*
-		 * If this partitioned table has no partitions or no partition for
-		 * these values, error out.
-		 */
-		if (partdesc->nparts == 0 ||
-			(partidx = get_partition_for_tuple(dispatch, values, isnull)) < 0)
+		/* Check if cache the most recently chosen bound offset */
+		if (partdesc->nparts > 0 &&
+			cached_bound_offset >= 0 &&
+			cached_bound_offset < partdesc->boundinfo->ndatums)
 		{
-			char	   *val_desc;
-
-			val_desc = ExecBuildSlotPartitionKeyDescription(rel,
-															values, isnull, 64);
-			Assert(OidIsValid(RelationGetRelid(rel)));
-			ereport(ERROR,
-					(errcode(ERRCODE_CHECK_VIOLATION),
-					 errmsg("no partition of relation \"%s\" found for row",
-							RelationGetRelationName(rel)),
-					 val_desc ?
-					 errdetail("Partition key of the failing row contains %s.",
-							   val_desc) : 0,
-					 errtable(rel)));
+			partidx = check_partition_for_tuple(dispatch, values, isnull,
+												cached_bound_offset);
+		}
+
+		if (partidx < 0)
+		{
+			/*
+			 * If this partitioned table has no partitions or no partition for
+			 * these values, error out.
+			 */
+			if (partdesc->nparts == 0 ||
+				(partidx = get_partition_for_tuple(dispatch, values, isnull,
+												&partdesc->bound_offset)) < 0)
+			{
+				char	   *val_desc;
+
+				val_desc = ExecBuildSlotPartitionKeyDescription(rel,
+																values, isnull, 64);
+				Assert(OidIsValid(RelationGetRelid(rel)));
+				ereport(ERROR,
+						(errcode(ERRCODE_CHECK_VIOLATION),
+						 errmsg("no partition of relation \"%s\" found for row",
+								RelationGetRelationName(rel)),
+						 val_desc ?
+						 errdetail("Partition key of the failing row contains %s.",
+								   val_desc) : 0,
+						 errtable(rel)));
+			}
 		}
 
 		is_leaf = partdesc->is_leaf[partidx];
@@ -475,6 +492,7 @@ ExecFindPartition(ModifyTableState *mtstate,
 	ecxt->ecxt_scantuple = ecxt_scantuple_saved;
 	MemoryContextSwitchTo(oldcxt);
 
+
 	return rri;
 }
 
@@ -1232,6 +1250,104 @@ FormPartitionKeyDatum(PartitionDispatch pd,
 }
 
 /*
+ * check_partition_for_tuple
+ *		Check if the tuple value match the target partition bounds.
+ *
+ * Return value is index of the partition (>= 0 and < partdesc->nparts) if
+ * match or -1 if not.
+ */
+static int
+check_partition_for_tuple(PartitionDispatch pd, Datum *values, bool *isnull, int bound_offset)
+{
+	PartitionKey	key = pd->key;
+	PartitionDesc	partdesc = pd->partdesc;
+	PartitionBoundInfo boundinfo = partdesc->boundinfo;
+	FmgrInfo	   *partsupfunc = key->partsupfunc;
+	Oid			   *partcollation = key->partcollation;
+	Datum		  **datums = boundinfo->datums;
+	int				part_index = -1;
+	int				offset = bound_offset;
+	int32			cmpval;
+
+	/*
+	 * Compare the tuple value with the target partition bounds based on
+	 * partitioning strategy.
+	 *
+	 * Only check LIST and RANGE STRATEGY.
+	 */
+	switch (key->strategy)
+	{
+		case PARTITION_STRATEGY_LIST:
+			if (!isnull[0])
+			{
+				cmpval = DatumGetInt32(FunctionCall2Coll(&partsupfunc[0],
+														 partcollation[0],
+														 datums[offset][0],
+														 values[0]));
+				if (cmpval == 0)
+					part_index = boundinfo->indexes[offset];
+			}
+			break;
+		case PARTITION_STRATEGY_RANGE:
+			{
+				int			i;
+				bool		is_default = false;
+				int16		partnatts = key->partnatts;
+				PartitionRangeDatumKind **kind = boundinfo->kind;
+
+				/*
+				 * No range includes NULL, so this will be accepted by the
+				 * default partition if there is one, and otherwise rejected.
+				 */
+				for (i = 0; i < partnatts; i++)
+				{
+					if (isnull[i])
+					{
+						is_default = true;
+						break;
+					}
+				}
+
+				if (!is_default)
+				{
+					/* Check if the value is above the low bound */
+					cmpval = partition_rbound_datum_cmp(partsupfunc,
+														partcollation,
+														datums[offset],
+														kind[offset],
+														values,
+														partnatts);
+					if (cmpval == 0)
+						part_index = boundinfo->indexes[offset + 1];
+
+					else if (cmpval < 0 && offset + 1 < boundinfo->ndatums)
+					{
+						/* Check if the value is below the high bound */
+						offset ++;
+						cmpval = partition_rbound_datum_cmp(partsupfunc,
+															partcollation,
+															datums[offset],
+															kind[offset],
+															values,
+															partnatts);
+
+						if (cmpval > 0)
+							part_index = boundinfo->indexes[offset];
+					}
+				}
+				else if (boundinfo->indexes[offset + 1] == boundinfo->default_index)
+					part_index = boundinfo->indexes[offset + 1];
+			}
+			break;
+		default:
+			break;
+	}
+
+	return part_index;
+
+}
+
+/*
  * get_partition_for_tuple
  *		Finds partition of relation which accepts the partition key specified
  *		in values and isnull
@@ -1240,9 +1356,8 @@ FormPartitionKeyDatum(PartitionDispatch pd,
  * found or -1 if none found.
  */
 static int
-get_partition_for_tuple(PartitionDispatch pd, Datum *values, bool *isnull)
+get_partition_for_tuple(PartitionDispatch pd, Datum *values, bool *isnull, int *bound_offset)
 {
-	int			bound_offset;
 	int			part_index = -1;
 	PartitionKey key = pd->key;
 	PartitionDesc partdesc = pd->partdesc;
@@ -1261,6 +1376,7 @@ get_partition_for_tuple(PartitionDispatch pd, Datum *values, bool *isnull)
 													   values, isnull);
 
 				part_index = boundinfo->indexes[rowHash % boundinfo->nindexes];
+				*bound_offset = -1;
 			}
 			break;
 
@@ -1274,12 +1390,12 @@ get_partition_for_tuple(PartitionDispatch pd, Datum *values, bool *isnull)
 			{
 				bool		equal = false;
 
-				bound_offset = partition_list_bsearch(key->partsupfunc,
+				*bound_offset = partition_list_bsearch(key->partsupfunc,
 													  key->partcollation,
 													  boundinfo,
 													  values[0], &equal);
-				if (bound_offset >= 0 && equal)
-					part_index = boundinfo->indexes[bound_offset];
+				if (*bound_offset >= 0 && equal)
+					part_index = boundinfo->indexes[*bound_offset];
 			}
 			break;
 
@@ -1304,7 +1420,7 @@ get_partition_for_tuple(PartitionDispatch pd, Datum *values, bool *isnull)
 
 				if (!range_partkey_has_null)
 				{
-					bound_offset = partition_range_datum_bsearch(key->partsupfunc,
+					*bound_offset = partition_range_datum_bsearch(key->partsupfunc,
 																 key->partcollation,
 																 boundinfo,
 																 key->partnatts,
@@ -1317,7 +1433,7 @@ get_partition_for_tuple(PartitionDispatch pd, Datum *values, bool *isnull)
 					 * bound of the partition we're looking for, if there
 					 * actually exists one.
 					 */
-					part_index = boundinfo->indexes[bound_offset + 1];
+					part_index = boundinfo->indexes[*bound_offset + 1];
 				}
 			}
 			break;
diff --git a/src/backend/partitioning/partdesc.c b/src/backend/partitioning/partdesc.c
index 9a9d6a9..b072da2 100644
--- a/src/backend/partitioning/partdesc.c
+++ b/src/backend/partitioning/partdesc.c
@@ -285,6 +285,8 @@ RelationBuildPartitionDesc(Relation rel, bool omit_detached)
 		MemoryContextAllocZero(new_pdcxt, sizeof(PartitionDescData));
 	partdesc->nparts = nparts;
 	partdesc->detached_exist = detached_exist;
+	partdesc->bound_offset = -1;
+
 	/* If there are no partitions, the rest of the partdesc can stay zero */
 	if (nparts > 0)
 	{
diff --git a/src/include/partitioning/partdesc.h b/src/include/partitioning/partdesc.h
index 0792f48..70ab0a2 100644
--- a/src/include/partitioning/partdesc.h
+++ b/src/include/partitioning/partdesc.h
@@ -36,6 +36,8 @@ typedef struct PartitionDescData
 								 * the corresponding 'oids' element belongs to
 								 * a leaf partition or not */
 	PartitionBoundInfo boundinfo;	/* collection of partition bounds */
+	int			bound_offset;	/* offset of bound info that was most recently
+								 * chosen */
 } PartitionDescData;
 
 
-- 
2.7.2.windows.1

diff --git a/src/backend/executor/execPartition.c b/src/backend/executor/execPartition.c
index 606c920b06..a775bda553 100644
--- a/src/backend/executor/execPartition.c
+++ b/src/backend/executor/execPartition.c
@@ -1246,12 +1246,14 @@ get_partition_for_tuple(PartitionDispatch pd, Datum *values, bool *isnull)
 	int			part_index = -1;
 	PartitionKey key = pd->key;
 	PartitionDesc partdesc = pd->partdesc;
+	int			cached_off = partdesc->cached_bound_offset;
 	PartitionBoundInfo boundinfo = partdesc->boundinfo;
 
 	/* Route as appropriate based on partitioning strategy. */
 	switch (key->strategy)
 	{
 		case PARTITION_STRATEGY_HASH:
+			Assert(cached_off < 0);
 			{
 				uint64		rowHash;
 
@@ -1272,14 +1274,33 @@ get_partition_for_tuple(PartitionDispatch pd, Datum *values, bool *isnull)
 			}
 			else
 			{
-				bool		equal = false;
-
-				bound_offset = partition_list_bsearch(key->partsupfunc,
-													  key->partcollation,
-													  boundinfo,
-													  values[0], &equal);
-				if (bound_offset >= 0 && equal)
-					part_index = boundinfo->indexes[bound_offset];
+				if (cached_off >= 0)
+				{
+					Datum	bound_datum = boundinfo->datums[cached_off][0];
+					int32	cmpval;
+
+					cmpval = DatumGetInt32(FunctionCall2Coll(&key->partsupfunc[0],
+															 key->partcollation[0],
+															 bound_datum,
+															 values[0]));
+					if (cmpval == 0)
+						part_index = boundinfo->indexes[cached_off];
+				}
+
+				if (part_index < 0)
+				{
+					bool		equal = false;
+
+					bound_offset = partition_list_bsearch(key->partsupfunc,
+														  key->partcollation,
+														  boundinfo,
+														  values[0], &equal);
+					if (bound_offset >= 0 && equal)
+					{
+						part_index = boundinfo->indexes[bound_offset];
+						partdesc->cached_bound_offset = bound_offset;
+					}
+				}
 			}
 			break;
 
@@ -1304,20 +1325,56 @@ get_partition_for_tuple(PartitionDispatch pd, Datum *values, bool *isnull)
 
 				if (!range_partkey_has_null)
 				{
-					bound_offset = partition_range_datum_bsearch(key->partsupfunc,
-																 key->partcollation,
-																 boundinfo,
-																 key->partnatts,
-																 values,
-																 &equal);
+					if (cached_off >= 0)
+					{
+						Datum   *bound_datums = boundinfo->datums[cached_off];
+						PartitionRangeDatumKind *bound_kind = boundinfo->kind[cached_off];
+						int32	cmpval;
+
+						/* Check if the value is above the low bound */
+						cmpval = partition_rbound_datum_cmp(key->partsupfunc,
+															key->partcollation,
+															bound_datums,
+															bound_kind,
+															values,
+															key->partnatts);
+						if (cmpval == 0)
+							part_index = boundinfo->indexes[cached_off + 1];
+						else if (cmpval < 0 && cached_off + 1 < boundinfo->ndatums)
+						{
+							/* Check if the value is below the high bound */
+							bound_datums = boundinfo->datums[cached_off + 1];
+							bound_kind = boundinfo->kind[cached_off + 1];
+							cmpval = partition_rbound_datum_cmp(key->partsupfunc,
+																key->partcollation,
+																bound_datums,
+																bound_kind,
+																values,
+																key->partnatts);
+
+							if (cmpval > 0)
+								part_index = boundinfo->indexes[cached_off + 1];
+						}
+					}
 
-					/*
-					 * The bound at bound_offset is less than or equal to the
-					 * tuple value, so the bound at offset+1 is the upper
-					 * bound of the partition we're looking for, if there
-					 * actually exists one.
-					 */
-					part_index = boundinfo->indexes[bound_offset + 1];
+					if (part_index < 0)
+					{
+						bound_offset = partition_range_datum_bsearch(key->partsupfunc,
+																	 key->partcollation,
+																	 boundinfo,
+																	 key->partnatts,
+																	 values,
+																	 &equal);
+
+						/*
+						 * The bound at bound_offset is less than or equal to the
+						 * tuple value, so the bound at offset+1 is the upper
+						 * bound of the partition we're looking for, if there
+						 * actually exists one.
+						 */
+						part_index = boundinfo->indexes[bound_offset + 1];
+						partdesc->cached_bound_offset = bound_offset;
+					}
 				}
 			}
 			break;
diff --git a/src/backend/partitioning/partdesc.c b/src/backend/partitioning/partdesc.c
index 9a9d6a9643..e6ec01de71 100644
--- a/src/backend/partitioning/partdesc.c
+++ b/src/backend/partitioning/partdesc.c
@@ -285,6 +285,8 @@ RelationBuildPartitionDesc(Relation rel, bool omit_detached)
 		MemoryContextAllocZero(new_pdcxt, sizeof(PartitionDescData));
 	partdesc->nparts = nparts;
 	partdesc->detached_exist = detached_exist;
+	partdesc->cached_bound_offset = -1;
+
 	/* If there are no partitions, the rest of the partdesc can stay zero */
 	if (nparts > 0)
 	{
diff --git a/src/include/partitioning/partdesc.h b/src/include/partitioning/partdesc.h
index 0792f48507..9df28ae14f 100644
--- a/src/include/partitioning/partdesc.h
+++ b/src/include/partitioning/partdesc.h
@@ -36,6 +36,9 @@ typedef struct PartitionDescData
 								 * the corresponding 'oids' element belongs to
 								 * a leaf partition or not */
 	PartitionBoundInfo boundinfo;	/* collection of partition bounds */
+	int			cached_bound_offset; /* offset of the bound datum most
+									  * recently chosen by
+									  * get_partition_for_tuple() */
 } PartitionDescData;
 
 

diff --git a/src/backend/executor/execPartition.c b/src/backend/executor/execPartition.c
index 606c920b06..610f98aab1 100644
--- a/src/backend/executor/execPartition.c
+++ b/src/backend/executor/execPartition.c
@@ -176,7 +176,7 @@ static void FormPartitionKeyDatum(PartitionDispatch pd,
 								  Datum *values,
 								  bool *isnull);
 static int	get_partition_for_tuple(PartitionDispatch pd, Datum *values,
-									bool *isnull);
+									bool *isnull, bool check_cached);
 static char *ExecBuildSlotPartitionKeyDescription(Relation rel,
 												  Datum *values,
 												  bool *isnull,
@@ -271,6 +271,7 @@ ExecFindPartition(ModifyTableState *mtstate,
 	TupleTableSlot *myslot = NULL;
 	MemoryContext oldcxt;
 	ResultRelInfo *rri = NULL;
+	bool		check_cached = true;
 
 	/* use per-tuple context here to avoid leaking memory */
 	oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(estate));
@@ -310,7 +311,8 @@ ExecFindPartition(ModifyTableState *mtstate,
 		 * these values, error out.
 		 */
 		if (partdesc->nparts == 0 ||
-			(partidx = get_partition_for_tuple(dispatch, values, isnull)) < 0)
+			(partidx = get_partition_for_tuple(dispatch, values, isnull,
+											   check_cached)) < 0)
 		{
 			char	   *val_desc;
 
@@ -1236,11 +1238,16 @@ FormPartitionKeyDatum(PartitionDispatch pd,
  *		Finds partition of relation which accepts the partition key specified
  *		in values and isnull
  *
+ * If check_cached is true, this short-circuits a full-blown search across all
+ * the bounds, instead checking the tuple against the bound whose offset is
+ * cached in pd->partdesc.
+ *
  * Return value is index of the partition (>= 0 and < partdesc->nparts) if one
  * found or -1 if none found.
  */
 static int
-get_partition_for_tuple(PartitionDispatch pd, Datum *values, bool *isnull)
+get_partition_for_tuple(PartitionDispatch pd, Datum *values, bool *isnull,
+						bool check_cached)
 {
 	int			bound_offset;
 	int			part_index = -1;
@@ -1248,10 +1255,18 @@ get_partition_for_tuple(PartitionDispatch pd, Datum *values, bool *isnull)
 	PartitionDesc partdesc = pd->partdesc;
 	PartitionBoundInfo boundinfo = partdesc->boundinfo;
 
+	/*
+	 * If the cached bound offset is valid, we check below if the that bound
+	 * is satisfied by the new tuple.  If it is, there's no need to perform a
+	 * search across all bounds.
+	 */
+	int			cached_off = partdesc->cached_bound_offset;
+
 	/* Route as appropriate based on partitioning strategy. */
 	switch (key->strategy)
 	{
 		case PARTITION_STRATEGY_HASH:
+			Assert(cached_off < 0);
 			{
 				uint64		rowHash;
 
@@ -1272,14 +1287,33 @@ get_partition_for_tuple(PartitionDispatch pd, Datum *values, bool *isnull)
 			}
 			else
 			{
-				bool		equal = false;
-
-				bound_offset = partition_list_bsearch(key->partsupfunc,
-													  key->partcollation,
-													  boundinfo,
-													  values[0], &equal);
-				if (bound_offset >= 0 && equal)
-					part_index = boundinfo->indexes[bound_offset];
+				if (cached_off >= 0 && check_cached)
+				{
+					Datum	bound_datum = boundinfo->datums[cached_off][0];
+					int32	cmpval;
+
+					cmpval = DatumGetInt32(FunctionCall2Coll(&key->partsupfunc[0],
+															 key->partcollation[0],
+															 bound_datum,
+															 values[0]));
+					if (cmpval == 0)
+						part_index = boundinfo->indexes[cached_off];
+				}
+
+				if (part_index < 0)
+				{
+					bool		equal = false;
+
+					bound_offset = partition_list_bsearch(key->partsupfunc,
+														  key->partcollation,
+														  boundinfo,
+														  values[0], &equal);
+					if (bound_offset >= 0 && equal)
+					{
+						part_index = boundinfo->indexes[bound_offset];
+						partdesc->cached_bound_offset = bound_offset;
+					}
+				}
 			}
 			break;
 
@@ -1304,20 +1338,56 @@ get_partition_for_tuple(PartitionDispatch pd, Datum *values, bool *isnull)
 
 				if (!range_partkey_has_null)
 				{
-					bound_offset = partition_range_datum_bsearch(key->partsupfunc,
-																 key->partcollation,
-																 boundinfo,
-																 key->partnatts,
-																 values,
-																 &equal);
+					if (cached_off >= 0 && check_cached)
+					{
+						Datum   *bound_datums = boundinfo->datums[cached_off];
+						PartitionRangeDatumKind *bound_kind = boundinfo->kind[cached_off];
+						int32	cmpval;
+
+						/* Check if the value is above the low bound */
+						cmpval = partition_rbound_datum_cmp(key->partsupfunc,
+															key->partcollation,
+															bound_datums,
+															bound_kind,
+															values,
+															key->partnatts);
+						if (cmpval == 0)
+							part_index = boundinfo->indexes[cached_off + 1];
+						else if (cmpval < 0 && cached_off + 1 < boundinfo->ndatums)
+						{
+							/* Check if the value is below the high bound */
+							bound_datums = boundinfo->datums[cached_off + 1];
+							bound_kind = boundinfo->kind[cached_off + 1];
+							cmpval = partition_rbound_datum_cmp(key->partsupfunc,
+																key->partcollation,
+																bound_datums,
+																bound_kind,
+																values,
+																key->partnatts);
+
+							if (cmpval > 0)
+								part_index = boundinfo->indexes[cached_off + 1];
+						}
+					}
 
-					/*
-					 * The bound at bound_offset is less than or equal to the
-					 * tuple value, so the bound at offset+1 is the upper
-					 * bound of the partition we're looking for, if there
-					 * actually exists one.
-					 */
-					part_index = boundinfo->indexes[bound_offset + 1];
+					if (part_index < 0)
+					{
+						bound_offset = partition_range_datum_bsearch(key->partsupfunc,
+																	 key->partcollation,
+																	 boundinfo,
+																	 key->partnatts,
+																	 values,
+																	 &equal);
+
+						/*
+						 * The bound at bound_offset is less than or equal to the
+						 * tuple value, so the bound at offset+1 is the upper
+						 * bound of the partition we're looking for, if there
+						 * actually exists one.
+						 */
+						part_index = boundinfo->indexes[bound_offset + 1];
+						partdesc->cached_bound_offset = bound_offset;
+					}
 				}
 			}
 			break;
diff --git a/src/backend/partitioning/partdesc.c b/src/backend/partitioning/partdesc.c
index 9a9d6a9643..e6ec01de71 100644
--- a/src/backend/partitioning/partdesc.c
+++ b/src/backend/partitioning/partdesc.c
@@ -285,6 +285,8 @@ RelationBuildPartitionDesc(Relation rel, bool omit_detached)
 		MemoryContextAllocZero(new_pdcxt, sizeof(PartitionDescData));
 	partdesc->nparts = nparts;
 	partdesc->detached_exist = detached_exist;
+	partdesc->cached_bound_offset = -1;
+
 	/* If there are no partitions, the rest of the partdesc can stay zero */
 	if (nparts > 0)
 	{
diff --git a/src/include/partitioning/partdesc.h b/src/include/partitioning/partdesc.h
index 0792f48507..9df28ae14f 100644
--- a/src/include/partitioning/partdesc.h
+++ b/src/include/partitioning/partdesc.h
@@ -36,6 +36,9 @@ typedef struct PartitionDescData
 								 * the corresponding 'oids' element belongs to
 								 * a leaf partition or not */
 	PartitionBoundInfo boundinfo;	/* collection of partition bounds */
+	int			cached_bound_offset; /* offset of the bound datum most
+									  * recently chosen by
+									  * get_partition_for_tuple() */
 } PartitionDescData;
 
 

From 7d0bd28f75cf2b26706fe5cc8473aa01950286cb Mon Sep 17 00:00:00 2001
From: "houzj.fnst" <houzj.fnst@cn.fujitsu.com>
Date: Mon, 7 Jun 2021 18:57:14 +0800
Subject: [PATCH] cache-bound-offset_v3_modify

---
 src/backend/executor/execPartition.c | 149 ++++++++++++++++++++++-----
 src/backend/partitioning/partdesc.c  |   2 +
 src/include/partitioning/partdesc.h  |   3 +
 3 files changed, 130 insertions(+), 24 deletions(-)

diff --git a/src/backend/executor/execPartition.c b/src/backend/executor/execPartition.c
index 606c920b06..122d330a1d 100644
--- a/src/backend/executor/execPartition.c
+++ b/src/backend/executor/execPartition.c
@@ -150,9 +150,15 @@ typedef struct PartitionDispatchData
 	PartitionDesc partdesc;
 	TupleTableSlot *tupslot;
 	AttrMap    *tupmap;
+
+	short		ntupinserts;
+	short		npartchanges;
+	bool		force;
+	bool		check_cached;
 	int			indexes[FLEXIBLE_ARRAY_MEMBER];
 }			PartitionDispatchData;
 
+#define RECHECK_BOUND_CACHE_THRESHOLD 1000
 
 static ResultRelInfo *ExecInitPartitionInfo(ModifyTableState *mtstate,
 											EState *estate, PartitionTupleRouting *proute,
@@ -176,7 +182,7 @@ static void FormPartitionKeyDatum(PartitionDispatch pd,
 								  Datum *values,
 								  bool *isnull);
 static int	get_partition_for_tuple(PartitionDispatch pd, Datum *values,
-									bool *isnull);
+									bool *isnull, bool check_cached);
 static char *ExecBuildSlotPartitionKeyDescription(Relation rel,
 												  Datum *values,
 												  bool *isnull,
@@ -305,12 +311,23 @@ ExecFindPartition(ModifyTableState *mtstate,
 		ecxt->ecxt_scantuple = slot;
 		FormPartitionKeyDatum(dispatch, slot, estate, values, isnull);
 
+		if (dispatch->ntupinserts > RECHECK_BOUND_CACHE_THRESHOLD &&
+				!dispatch->force)
+		{
+			if (dispatch->npartchanges == 0)
+				dispatch->check_cached = true;
+			else
+				dispatch->check_cached = ((dispatch->ntupinserts/dispatch->npartchanges) > 1);
+			dispatch->ntupinserts = dispatch->npartchanges = 0;
+		}
+
 		/*
 		 * If this partitioned table has no partitions or no partition for
 		 * these values, error out.
 		 */
 		if (partdesc->nparts == 0 ||
-			(partidx = get_partition_for_tuple(dispatch, values, isnull)) < 0)
+			(partidx = get_partition_for_tuple(dispatch, values, isnull,
+							dispatch->check_cached)) < 0)
 		{
 			char	   *val_desc;
 
@@ -1026,6 +1043,12 @@ ExecInitPartitionDispatchInfo(EState *estate,
 	pd->key = RelationGetPartitionKey(rel);
 	pd->keystate = NIL;
 	pd->partdesc = partdesc;
+	pd->ntupinserts = 0;
+	pd->npartchanges = 0;
+	partdesc->cached_bound_offset = -1;
+
+	pd->check_cached = false;
+
 	if (parent_pd != NULL)
 	{
 		TupleDesc	tupdesc = RelationGetDescr(rel);
@@ -1236,11 +1259,16 @@ FormPartitionKeyDatum(PartitionDispatch pd,
  *		Finds partition of relation which accepts the partition key specified
  *		in values and isnull
  *
+ * If check_cached is true, this short-circuits a full-blown search across all
+ * the bounds, instead checking the tuple against the bound whose offset is
+ * cached in pd->partdesc.
+ *
  * Return value is index of the partition (>= 0 and < partdesc->nparts) if one
  * found or -1 if none found.
  */
 static int
-get_partition_for_tuple(PartitionDispatch pd, Datum *values, bool *isnull)
+get_partition_for_tuple(PartitionDispatch pd, Datum *values, bool *isnull,
+						bool check_cached)
 {
 	int			bound_offset;
 	int			part_index = -1;
@@ -1248,10 +1276,18 @@ get_partition_for_tuple(PartitionDispatch pd, Datum *values, bool *isnull)
 	PartitionDesc partdesc = pd->partdesc;
 	PartitionBoundInfo boundinfo = partdesc->boundinfo;
 
+	/*
+	 * If the cached bound offset is valid, we check below if the that bound
+	 * is satisfied by the new tuple.  If it is, there's no need to perform a
+	 * search across all bounds.
+	 */
+	int			cached_off = partdesc->cached_bound_offset;
+
 	/* Route as appropriate based on partitioning strategy. */
 	switch (key->strategy)
 	{
 		case PARTITION_STRATEGY_HASH:
+			Assert(cached_off < 0);
 			{
 				uint64		rowHash;
 
@@ -1265,6 +1301,7 @@ get_partition_for_tuple(PartitionDispatch pd, Datum *values, bool *isnull)
 			break;
 
 		case PARTITION_STRATEGY_LIST:
+			pd->ntupinserts++;
 			if (isnull[0])
 			{
 				if (partition_bound_accepts_nulls(boundinfo))
@@ -1272,14 +1309,37 @@ get_partition_for_tuple(PartitionDispatch pd, Datum *values, bool *isnull)
 			}
 			else
 			{
-				bool		equal = false;
-
-				bound_offset = partition_list_bsearch(key->partsupfunc,
-													  key->partcollation,
-													  boundinfo,
-													  values[0], &equal);
-				if (bound_offset >= 0 && equal)
-					part_index = boundinfo->indexes[bound_offset];
+				if (cached_off >= 0 && check_cached)
+				{
+					Datum	bound_datum = boundinfo->datums[cached_off][0];
+					int32	cmpval;
+
+					cmpval = DatumGetInt32(FunctionCall2Coll(&key->partsupfunc[0],
+															 key->partcollation[0],
+															 bound_datum,
+															 values[0]));
+					if (cmpval == 0)
+						part_index = boundinfo->indexes[cached_off];
+				}
+
+				if (part_index < 0)
+				{
+					bool		equal = false;
+
+					bound_offset = partition_list_bsearch(key->partsupfunc,
+														  key->partcollation,
+														  boundinfo,
+														  values[0], &equal);
+					if (bound_offset >= 0 && equal)
+					{
+						part_index = boundinfo->indexes[bound_offset];
+						if (cached_off != bound_offset)
+						{
+							pd->npartchanges++;
+							partdesc->cached_bound_offset = bound_offset;
+						}
+					}
+				}
 			}
 			break;
 
@@ -1289,6 +1349,7 @@ get_partition_for_tuple(PartitionDispatch pd, Datum *values, bool *isnull)
 							range_partkey_has_null = false;
 				int			i;
 
+				pd->ntupinserts++;
 				/*
 				 * No range includes NULL, so this will be accepted by the
 				 * default partition if there is one, and otherwise rejected.
@@ -1304,20 +1365,60 @@ get_partition_for_tuple(PartitionDispatch pd, Datum *values, bool *isnull)
 
 				if (!range_partkey_has_null)
 				{
-					bound_offset = partition_range_datum_bsearch(key->partsupfunc,
-																 key->partcollation,
-																 boundinfo,
-																 key->partnatts,
-																 values,
-																 &equal);
+					if (cached_off >= 0 && check_cached)
+					{
+						Datum   *bound_datums = boundinfo->datums[cached_off];
+						PartitionRangeDatumKind *bound_kind = boundinfo->kind[cached_off];
+						int32	cmpval;
+
+						/* Check if the value is above the low bound */
+						cmpval = partition_rbound_datum_cmp(key->partsupfunc,
+															key->partcollation,
+															bound_datums,
+															bound_kind,
+															values,
+															key->partnatts);
+						if (cmpval == 0)
+							part_index = boundinfo->indexes[cached_off + 1];
+						else if (cmpval < 0 && cached_off + 1 < boundinfo->ndatums)
+						{
+							/* Check if the value is below the high bound */
+							bound_datums = boundinfo->datums[cached_off + 1];
+							bound_kind = boundinfo->kind[cached_off + 1];
+							cmpval = partition_rbound_datum_cmp(key->partsupfunc,
+																key->partcollation,
+																bound_datums,
+																bound_kind,
+																values,
+																key->partnatts);
+
+							if (cmpval > 0)
+								part_index = boundinfo->indexes[cached_off + 1];
+						}
+					}
 
-					/*
-					 * The bound at bound_offset is less than or equal to the
-					 * tuple value, so the bound at offset+1 is the upper
-					 * bound of the partition we're looking for, if there
-					 * actually exists one.
-					 */
-					part_index = boundinfo->indexes[bound_offset + 1];
+					if (part_index < 0)
+					{
+						bound_offset = partition_range_datum_bsearch(key->partsupfunc,
+																	 key->partcollation,
+																	 boundinfo,
+																	 key->partnatts,
+																	 values,
+																	 &equal);
+
+						/*
+						 * The bound at bound_offset is less than or equal to the
+						 * tuple value, so the bound at offset+1 is the upper
+						 * bound of the partition we're looking for, if there
+						 * actually exists one.
+						 */
+						part_index = boundinfo->indexes[bound_offset + 1];
+						if (cached_off != bound_offset)
+						{
+							pd->npartchanges++;
+							partdesc->cached_bound_offset = bound_offset;
+						}
+					}
 				}
 			}
 			break;
diff --git a/src/backend/partitioning/partdesc.c b/src/backend/partitioning/partdesc.c
index 9a9d6a9643..e6ec01de71 100644
--- a/src/backend/partitioning/partdesc.c
+++ b/src/backend/partitioning/partdesc.c
@@ -285,6 +285,8 @@ RelationBuildPartitionDesc(Relation rel, bool omit_detached)
 		MemoryContextAllocZero(new_pdcxt, sizeof(PartitionDescData));
 	partdesc->nparts = nparts;
 	partdesc->detached_exist = detached_exist;
+	partdesc->cached_bound_offset = -1;
+
 	/* If there are no partitions, the rest of the partdesc can stay zero */
 	if (nparts > 0)
 	{
diff --git a/src/include/partitioning/partdesc.h b/src/include/partitioning/partdesc.h
index 0792f48507..9df28ae14f 100644
--- a/src/include/partitioning/partdesc.h
+++ b/src/include/partitioning/partdesc.h
@@ -36,6 +36,9 @@ typedef struct PartitionDescData
 								 * the corresponding 'oids' element belongs to
 								 * a leaf partition or not */
 	PartitionBoundInfo boundinfo;	/* collection of partition bounds */
+	int			cached_bound_offset; /* offset of the bound datum most
+									  * recently chosen by
+									  * get_partition_for_tuple() */
 } PartitionDescData;
 
 
-- 
2.18.4

From 191abc179b3e4e62d2d2720924678d9c1d7271f9 Mon Sep 17 00:00:00 2001
From: amitlan <amitlangote09@gmail.com>
Date: Tue, 15 Jun 2021 16:21:48 +0900
Subject: [PATCH v5] adpative bound offset caching v5

---
 src/backend/executor/execPartition.c | 210 ++++++++++++++++++++++++---
 1 file changed, 187 insertions(+), 23 deletions(-)

diff --git a/src/backend/executor/execPartition.c b/src/backend/executor/execPartition.c
index 606c920b06..acbf71cb75 100644
--- a/src/backend/executor/execPartition.c
+++ b/src/backend/executor/execPartition.c
@@ -133,6 +133,13 @@ struct PartitionTupleRouting
  *		routing it through this table). A NULL value is stored if no tuple
  *		conversion is required.
  *
+ * cached_bound_offset
+ * last_seen_offset
+ * n_offset_changed
+ * n_tups_inserted
+ *		Fields to manage the state for bound offset caching; see
+ *		maybe_cache_partition_bound_offset()
+ *
  * indexes
  *		Array of partdesc->nparts elements.  For leaf partitions the index
  *		corresponds to the partition's ResultRelInfo in the encapsulating
@@ -150,10 +157,15 @@ typedef struct PartitionDispatchData
 	PartitionDesc partdesc;
 	TupleTableSlot *tupslot;
 	AttrMap    *tupmap;
+
+	int			cached_bound_offset;
+	int			last_seen_offset;
+	int			n_offset_changed;
+	int			n_tups_inserted;
+
 	int			indexes[FLEXIBLE_ARRAY_MEMBER];
 }			PartitionDispatchData;
 
-
 static ResultRelInfo *ExecInitPartitionInfo(ModifyTableState *mtstate,
 											EState *estate, PartitionTupleRouting *proute,
 											PartitionDispatch dispatch,
@@ -1026,6 +1038,10 @@ ExecInitPartitionDispatchInfo(EState *estate,
 	pd->key = RelationGetPartitionKey(rel);
 	pd->keystate = NIL;
 	pd->partdesc = partdesc;
+
+	pd->cached_bound_offset = pd->last_seen_offset = -1;
+	pd->n_tups_inserted = pd->n_offset_changed = 0;
+
 	if (parent_pd != NULL)
 	{
 		TupleDesc	tupdesc = RelationGetDescr(rel);
@@ -1231,6 +1247,134 @@ FormPartitionKeyDatum(PartitionDispatch pd,
 		elog(ERROR, "wrong number of partition key expressions");
 }
 
+/*
+ * Threshold of the number of tuples to have been processed before
+ * maybe_cache_partition_bound_offset() re-assesses whether caching must be
+ * enabled or disabled for subsequent tuples.
+ */
+#define	CACHE_BOUND_OFFSET_THRESHOLD_TUPS	1000
+
+/*
+ * maybe_cache_partition_bound_offset
+ *		Conditionally sets pd->cached_bound_offset so that
+ *		get_cached_{list|range}_partition can be used for subsequent
+ *		tuples
+ *
+ * It is set if it appears that some offsets observed over the last
+ * pd->n_tups_inserted tuples would have been reused, which can be inferred
+ * from seeing that the ratio of tuples inserted and the number of times the
+ * offset needed to be changed during the insertion of those tuples is greater
+ * than 1.  Conversely, we disable the caching if it the ratio is 1, because
+ * it suggests that every consecutive tuple mapped to a different partition.
+ */
+static inline void
+maybe_cache_partition_bound_offset(PartitionDispatch pd, int offset)
+{
+	if (offset != pd->last_seen_offset)
+	{
+		pd->last_seen_offset = offset;
+		pd->n_offset_changed += 1;
+		/* Only set to the new value after calculating the ratio formula. */
+		pd->cached_bound_offset = -1;
+	}
+
+	/*
+	 * Only consider (re-)enabling/disabling caching if we've seen at least
+	 * a threshold number of tuples since the last time we enabled/disabled
+	 * it.
+	 */
+	if (pd->n_tups_inserted < CACHE_BOUND_OFFSET_THRESHOLD_TUPS)
+		return;
+
+	/* Wouldn't get called if the cached bound offset worked. */
+	Assert(offset != pd->cached_bound_offset);
+
+	/* If the offset didn't change at all, caching it might be a good idea. */
+	if (pd->n_offset_changed == 0 ||
+		(double) pd->n_tups_inserted / pd->n_offset_changed > 1)
+		pd->cached_bound_offset = offset;
+	else
+		pd->cached_bound_offset = -1;
+	pd->n_tups_inserted = pd->n_offset_changed = 0;
+}
+
+/*
+ * get_cached_{list|range}_partition
+ *		Computes if the cached bound offset value, if any, is satisfied by
+ *		the tuple specified in 'values' and it is, returns the index of
+ *		the partition corresponding to that bound
+ *
+ * Callers must ensure that none of the elements of 'values' is NULL.
+ */
+static inline int
+get_cached_list_partition(PartitionDispatch pd,
+						  PartitionBoundInfo boundinfo,
+						  PartitionKey key,
+						  Datum *values)
+{
+	int		part_index = -1;
+	int		cached_off = pd->cached_bound_offset;
+
+	if (cached_off >= 0)
+	{
+		Datum	bound_datum = boundinfo->datums[cached_off][0];
+		int32	cmpval;
+
+		cmpval = DatumGetInt32(FunctionCall2Coll(&key->partsupfunc[0],
+												 key->partcollation[0],
+												 bound_datum,
+												 values[0]));
+		if (cmpval == 0)
+			part_index = boundinfo->indexes[cached_off];
+	}
+
+	return part_index;
+}
+
+static inline int
+get_cached_range_partition(PartitionDispatch pd,
+						   PartitionBoundInfo boundinfo,
+						   PartitionKey key,
+						   Datum *values)
+{
+	int		part_index = -1;
+	int		cached_off = pd->cached_bound_offset;
+
+	if (cached_off >= 0)
+	{
+		Datum   *bound_datums = boundinfo->datums[cached_off];
+		PartitionRangeDatumKind *bound_kind = boundinfo->kind[cached_off];
+		int32	cmpval;
+
+		/* Check if the value is above the low bound */
+		cmpval = partition_rbound_datum_cmp(key->partsupfunc,
+											key->partcollation,
+											bound_datums,
+											bound_kind,
+											values,
+											key->partnatts);
+		if (cmpval == 0)
+			part_index = boundinfo->indexes[cached_off + 1];
+		else if (cmpval < 0 && cached_off + 1 < boundinfo->ndatums)
+		{
+			/* Check if the value is below the high bound */
+			bound_datums = boundinfo->datums[cached_off + 1];
+			bound_kind = boundinfo->kind[cached_off + 1];
+			cmpval = partition_rbound_datum_cmp(key->partsupfunc,
+												key->partcollation,
+												bound_datums,
+												bound_kind,
+												values,
+												key->partnatts);
+
+			if (cmpval > 0)
+				part_index = boundinfo->indexes[cached_off + 1];
+		}
+	}
+
+	return part_index;
+}
+
 /*
  * get_partition_for_tuple
  *		Finds partition of relation which accepts the partition key specified
@@ -1248,6 +1392,8 @@ get_partition_for_tuple(PartitionDispatch pd, Datum *values, bool *isnull)
 	PartitionDesc partdesc = pd->partdesc;
 	PartitionBoundInfo boundinfo = partdesc->boundinfo;
 
+	pd->n_tups_inserted += 1;
+
 	/* Route as appropriate based on partitioning strategy. */
 	switch (key->strategy)
 	{
@@ -1272,14 +1418,24 @@ get_partition_for_tuple(PartitionDispatch pd, Datum *values, bool *isnull)
 			}
 			else
 			{
-				bool		equal = false;
-
-				bound_offset = partition_list_bsearch(key->partsupfunc,
-													  key->partcollation,
-													  boundinfo,
-													  values[0], &equal);
-				if (bound_offset >= 0 && equal)
-					part_index = boundinfo->indexes[bound_offset];
+				part_index = get_cached_list_partition(pd, boundinfo, key,
+													   values);
+				if (part_index < 0)
+				{
+					bool		equal = false;
+
+					bound_offset = partition_list_bsearch(key->partsupfunc,
+														  key->partcollation,
+														  boundinfo,
+														  values[0], &equal);
+					if (bound_offset >= 0 && equal)
+					{
+						part_index = boundinfo->indexes[bound_offset];
+						if (part_index >= 0)
+							maybe_cache_partition_bound_offset(pd,
+															   bound_offset);
+					}
+				}
 			}
 			break;
 
@@ -1304,20 +1460,28 @@ get_partition_for_tuple(PartitionDispatch pd, Datum *values, bool *isnull)
 
 				if (!range_partkey_has_null)
 				{
-					bound_offset = partition_range_datum_bsearch(key->partsupfunc,
-																 key->partcollation,
-																 boundinfo,
-																 key->partnatts,
-																 values,
-																 &equal);
-
-					/*
-					 * The bound at bound_offset is less than or equal to the
-					 * tuple value, so the bound at offset+1 is the upper
-					 * bound of the partition we're looking for, if there
-					 * actually exists one.
-					 */
-					part_index = boundinfo->indexes[bound_offset + 1];
+					part_index = get_cached_range_partition(pd, boundinfo,
+															key, values);
+					if (part_index < 0)
+					{
+						bound_offset = partition_range_datum_bsearch(key->partsupfunc,
+																	 key->partcollation,
+																	 boundinfo,
+																	 key->partnatts,
+																	 values,
+																	 &equal);
+
+						/*
+						 * The bound at bound_offset is less than or equal to the
+						 * tuple value, so the bound at offset+1 is the upper
+						 * bound of the partition we're looking for, if there
+						 * actually exists one.
+						 */
+						part_index = boundinfo->indexes[bound_offset + 1];
+						if (part_index >= 0)
+							maybe_cache_partition_bound_offset(pd,
+															   bound_offset);
+					}
 				}
 			}
 			break;
-- 
2.24.1

From e74a22ea5debe9d549864069dfb95bb20cfef30a Mon Sep 17 00:00:00 2001
From: amitlan <amitlangote09@gmail.com>
Date: Tue, 15 Jun 2021 16:21:48 +0900
Subject: [PATCH v6] Teach get_partition_for_tuple to cache bound offset

For bulk loads into list and range partitioned tables, it can be
very likely that long runs of consecutive tuples route to the same
partition.  In such cases, we can avoid the overhead of performing
a binary search for each such tuple by caching the offset of the
bound for that partition and checking that the bound indeed satisfies
any subsequent tuples, which can be implemented with fewer comparisons
than the binary search.

To avoid impacting the cases where such caching can be unproductive,
an adaptive algorithm is used to determine whether to actually
enable caching or to disable it if checking the cached offset seems
to add pure overhead per tuple.

Author: Hou Zhijie
Author: Amit Langote
---
 src/backend/executor/execPartition.c | 209 ++++++++++++++++++++++++---
 1 file changed, 187 insertions(+), 22 deletions(-)

diff --git a/src/backend/executor/execPartition.c b/src/backend/executor/execPartition.c
index 606c920b06..d213ee1a6b 100644
--- a/src/backend/executor/execPartition.c
+++ b/src/backend/executor/execPartition.c
@@ -133,6 +133,13 @@ struct PartitionTupleRouting
  *		routing it through this table). A NULL value is stored if no tuple
  *		conversion is required.
  *
+ * cached_bound_offset
+ * last_seen_offset
+ * n_tups_inserted
+ * n_offset_changed
+ *		Fields to manage the state for bound offset caching; see
+ *		maybe_cache_partition_bound_offset()
+ *
  * indexes
  *		Array of partdesc->nparts elements.  For leaf partitions the index
  *		corresponds to the partition's ResultRelInfo in the encapsulating
@@ -150,6 +157,12 @@ typedef struct PartitionDispatchData
 	PartitionDesc partdesc;
 	TupleTableSlot *tupslot;
 	AttrMap    *tupmap;
+
+	int			cached_bound_offset;
+	int			last_seen_offset;
+	int			n_tups_inserted;
+	int			n_offset_changed;
+
 	int			indexes[FLEXIBLE_ARRAY_MEMBER];
 }			PartitionDispatchData;
 
@@ -1026,6 +1039,10 @@ ExecInitPartitionDispatchInfo(EState *estate,
 	pd->key = RelationGetPartitionKey(rel);
 	pd->keystate = NIL;
 	pd->partdesc = partdesc;
+
+	pd->cached_bound_offset = pd->last_seen_offset = -1;
+	pd->n_tups_inserted = pd->n_offset_changed = 0;
+
 	if (parent_pd != NULL)
 	{
 		TupleDesc	tupdesc = RelationGetDescr(rel);
@@ -1231,6 +1248,134 @@ FormPartitionKeyDatum(PartitionDispatch pd,
 		elog(ERROR, "wrong number of partition key expressions");
 }
 
+/*
+ * Threshold of the number of tuples to need to have been processed before
+ * maybe_cache_partition_bound_offset() (re-)assesses whether caching must be
+ * enabled or disabled for subsequent tuples.
+ */
+#define	CACHE_BOUND_OFFSET_THRESHOLD_TUPS	1000
+
+/*
+ * maybe_cache_partition_bound_offset
+ *		Conditionally sets pd->cached_bound_offset so that
+ *		get_cached_{list|range}_partition can be used for subsequent
+ *		tuples
+ *
+ * It is set if it appears that some offsets observed over the last
+ * pd->n_tups_inserted tuples would have been reused, which can be inferred
+ * from seeing that the ratio of tuples inserted and the number of times the
+ * offset needed to be changed during the insertion of those tuples is greater
+ * than 1.  Conversely, we disable the caching if it the ratio is 1, because
+ * it suggests that every consecutive tuple mapped to a different partition.
+ */
+static inline void
+maybe_cache_partition_bound_offset(PartitionDispatch pd, int offset)
+{
+	if (offset != pd->last_seen_offset)
+	{
+		pd->last_seen_offset = offset;
+		pd->n_offset_changed += 1;
+		/* Only set to the new value after calculating the ratio formula. */
+		pd->cached_bound_offset = -1;
+	}
+
+	/*
+	 * Only consider (re-)enabling/disabling caching if we've seen at least
+	 * a threshold number of tuples since the last time we enabled/disabled
+	 * it.
+	 */
+	if (pd->n_tups_inserted < CACHE_BOUND_OFFSET_THRESHOLD_TUPS)
+		return;
+
+	/* Wouldn't get called if the cached bound offset worked. */
+	Assert(offset != pd->cached_bound_offset);
+
+	/* If the offset didn't change at all, caching it might be a good idea. */
+	if (pd->n_offset_changed == 0 ||
+		(double) pd->n_tups_inserted / pd->n_offset_changed > 1)
+		pd->cached_bound_offset = offset;
+	else
+		pd->cached_bound_offset = -1;
+	pd->n_tups_inserted = pd->n_offset_changed = 0;
+}
+
+/*
+ * get_cached_{list|range}_partition
+ *		Computes if the cached bound offset value, if any, is satisfied by
+ *		the tuple specified in 'values' and it is, returns the index of
+ *		the partition corresponding to that bound
+ *
+ * Callers must ensure that none of the elements of 'values' is NULL.
+ */
+static inline int
+get_cached_list_partition(PartitionDispatch pd,
+						  PartitionBoundInfo boundinfo,
+						  PartitionKey key,
+						  Datum *values)
+{
+	int		part_index = -1;
+	int		cached_off = pd->cached_bound_offset;
+
+	if (cached_off >= 0)
+	{
+		Datum	bound_datum = boundinfo->datums[cached_off][0];
+		int32	cmpval;
+
+		cmpval = DatumGetInt32(FunctionCall2Coll(&key->partsupfunc[0],
+												 key->partcollation[0],
+												 bound_datum,
+												 values[0]));
+		if (cmpval == 0)
+			part_index = boundinfo->indexes[cached_off];
+	}
+
+	return part_index;
+}
+
+static inline int
+get_cached_range_partition(PartitionDispatch pd,
+						   PartitionBoundInfo boundinfo,
+						   PartitionKey key,
+						   Datum *values)
+{
+	int		part_index = -1;
+	int		cached_off = pd->cached_bound_offset;
+
+	if (cached_off >= 0)
+	{
+		Datum   *bound_datums = boundinfo->datums[cached_off];
+		PartitionRangeDatumKind *bound_kind = boundinfo->kind[cached_off];
+		int32	cmpval;
+
+		/* Check if the value is above the low bound */
+		cmpval = partition_rbound_datum_cmp(key->partsupfunc,
+											key->partcollation,
+											bound_datums,
+											bound_kind,
+											values,
+											key->partnatts);
+		if (cmpval == 0)
+			part_index = boundinfo->indexes[cached_off + 1];
+		else if (cmpval < 0 && cached_off + 1 < boundinfo->ndatums)
+		{
+			/* Check if the value is below the high bound */
+			bound_datums = boundinfo->datums[cached_off + 1];
+			bound_kind = boundinfo->kind[cached_off + 1];
+			cmpval = partition_rbound_datum_cmp(key->partsupfunc,
+												key->partcollation,
+												bound_datums,
+												bound_kind,
+												values,
+												key->partnatts);
+
+			if (cmpval > 0)
+				part_index = boundinfo->indexes[cached_off + 1];
+		}
+	}
+
+	return part_index;
+}
+
 /*
  * get_partition_for_tuple
  *		Finds partition of relation which accepts the partition key specified
@@ -1248,6 +1393,8 @@ get_partition_for_tuple(PartitionDispatch pd, Datum *values, bool *isnull)
 	PartitionDesc partdesc = pd->partdesc;
 	PartitionBoundInfo boundinfo = partdesc->boundinfo;
 
+	pd->n_tups_inserted += 1;
+
 	/* Route as appropriate based on partitioning strategy. */
 	switch (key->strategy)
 	{
@@ -1272,14 +1419,24 @@ get_partition_for_tuple(PartitionDispatch pd, Datum *values, bool *isnull)
 			}
 			else
 			{
-				bool		equal = false;
-
-				bound_offset = partition_list_bsearch(key->partsupfunc,
-													  key->partcollation,
-													  boundinfo,
-													  values[0], &equal);
-				if (bound_offset >= 0 && equal)
-					part_index = boundinfo->indexes[bound_offset];
+				part_index = get_cached_list_partition(pd, boundinfo, key,
+													   values);
+				if (part_index < 0)
+				{
+					bool		equal = false;
+
+					bound_offset = partition_list_bsearch(key->partsupfunc,
+														  key->partcollation,
+														  boundinfo,
+														  values[0], &equal);
+					if (bound_offset >= 0 && equal)
+					{
+						part_index = boundinfo->indexes[bound_offset];
+						if (part_index >= 0)
+							maybe_cache_partition_bound_offset(pd,
+															   bound_offset);
+					}
+				}
 			}
 			break;
 
@@ -1304,20 +1461,28 @@ get_partition_for_tuple(PartitionDispatch pd, Datum *values, bool *isnull)
 
 				if (!range_partkey_has_null)
 				{
-					bound_offset = partition_range_datum_bsearch(key->partsupfunc,
-																 key->partcollation,
-																 boundinfo,
-																 key->partnatts,
-																 values,
-																 &equal);
-
-					/*
-					 * The bound at bound_offset is less than or equal to the
-					 * tuple value, so the bound at offset+1 is the upper
-					 * bound of the partition we're looking for, if there
-					 * actually exists one.
-					 */
-					part_index = boundinfo->indexes[bound_offset + 1];
+					part_index = get_cached_range_partition(pd, boundinfo,
+															key, values);
+					if (part_index < 0)
+					{
+						bound_offset = partition_range_datum_bsearch(key->partsupfunc,
+																	 key->partcollation,
+																	 boundinfo,
+																	 key->partnatts,
+																	 values,
+																	 &equal);
+
+						/*
+						 * The bound at bound_offset is less than or equal to the
+						 * tuple value, so the bound at offset+1 is the upper
+						 * bound of the partition we're looking for, if there
+						 * actually exists one.
+						 */
+						part_index = boundinfo->indexes[bound_offset + 1];
+						if (part_index >= 0)
+							maybe_cache_partition_bound_offset(pd,
+															   bound_offset);
+					}
 				}
 			}
 			break;
-- 
2.24.1

From 4631acb275d09de01f8b297ad4d7708ddeed9e8f Mon Sep 17 00:00:00 2001
From: amitlan <amitlangote09@gmail.com>
Date: Tue, 15 Jun 2021 16:21:48 +0900
Subject: [PATCH v7] Teach get_partition_for_tuple to cache bound offset

For bulk loads into list and range partitioned tables, it can be
very likely that long runs of consecutive tuples route to the same
partition.  In such cases, we can avoid the overhead of performing
a binary search for each such tuple by caching the offset of the
bound for that partition and checking that the bound indeed satisfies
any subsequent tuples, which can be implemented with fewer comparisons
than the binary search.

To avoid impacting the cases where such caching can be unproductive,
an adaptive algorithm is used to determine whether to actually
enable caching or to disable it if checking the cached offset seems
to add pure overhead per tuple.

Author: Hou Zhijie
Author: Amit Langote
---
 src/backend/executor/execPartition.c | 214 ++++++++++++++++++++++++---
 1 file changed, 192 insertions(+), 22 deletions(-)

diff --git a/src/backend/executor/execPartition.c b/src/backend/executor/execPartition.c
index 606c920b06..d52f8c4931 100644
--- a/src/backend/executor/execPartition.c
+++ b/src/backend/executor/execPartition.c
@@ -133,6 +133,13 @@ struct PartitionTupleRouting
  *		routing it through this table). A NULL value is stored if no tuple
  *		conversion is required.
  *
+ * cached_bound_offset
+ * last_seen_offset
+ * n_tups_inserted
+ * n_offset_changed
+ *		Fields to manage the state for bound offset caching; see
+ *		maybe_cache_partition_bound_offset()
+ *
  * indexes
  *		Array of partdesc->nparts elements.  For leaf partitions the index
  *		corresponds to the partition's ResultRelInfo in the encapsulating
@@ -150,6 +157,12 @@ typedef struct PartitionDispatchData
 	PartitionDesc partdesc;
 	TupleTableSlot *tupslot;
 	AttrMap    *tupmap;
+
+	int			cached_bound_offset;
+	int			last_seen_offset;
+	int			n_tups_inserted;
+	int			n_offset_changed;
+
 	int			indexes[FLEXIBLE_ARRAY_MEMBER];
 }			PartitionDispatchData;
 
@@ -1026,6 +1039,10 @@ ExecInitPartitionDispatchInfo(EState *estate,
 	pd->key = RelationGetPartitionKey(rel);
 	pd->keystate = NIL;
 	pd->partdesc = partdesc;
+
+	pd->cached_bound_offset = pd->last_seen_offset = -1;
+	pd->n_tups_inserted = pd->n_offset_changed = 0;
+
 	if (parent_pd != NULL)
 	{
 		TupleDesc	tupdesc = RelationGetDescr(rel);
@@ -1231,6 +1248,135 @@ FormPartitionKeyDatum(PartitionDispatch pd,
 		elog(ERROR, "wrong number of partition key expressions");
 }
 
+/*
+ * Threshold of the number of tuples to need to have been processed before
+ * maybe_cache_partition_bound_offset() (re-)assesses whether caching must be
+ * enabled or disabled for subsequent tuples.
+ */
+#define	CACHE_BOUND_OFFSET_THRESHOLD_TUPS	1000
+
+/*
+ * maybe_cache_partition_bound_offset
+ *		Conditionally sets pd->cached_bound_offset so that
+ *		get_cached_{list|range}_partition can be used for subsequent
+ *		tuples
+ *
+ * It is set if it appears that some offsets observed over the last
+ * pd->n_tups_inserted tuples would have been reused, which can be inferred
+ * from seeing that the ratio of tuples inserted and the number of times the
+ * offset needed to be changed during the insertion of those tuples is greater
+ * than 1.  Conversely, we disable the caching if the ratio is 1, because that
+ * suggests that every consecutively inserted tuple mapped to a different
+ * partition.
+ */
+static inline void
+maybe_cache_partition_bound_offset(PartitionDispatch pd, int offset)
+{
+	if (offset != pd->last_seen_offset)
+	{
+		pd->last_seen_offset = offset;
+		pd->n_offset_changed += 1;
+		/* Only set to the new value after calculating the ratio formula. */
+		pd->cached_bound_offset = -1;
+	}
+
+	/*
+	 * Only consider (re-)enabling/disabling caching if we've seen at least
+	 * a threshold number of tuples since the last time we enabled/disabled
+	 * it.
+	 */
+	if (pd->n_tups_inserted < CACHE_BOUND_OFFSET_THRESHOLD_TUPS)
+		return;
+
+	/* Wouldn't get called if the cached bound offset worked. */
+	Assert(offset != pd->cached_bound_offset);
+
+	/* If the offset didn't change at all, caching it might be a good idea. */
+	if (pd->n_offset_changed == 0 ||
+		(double) pd->n_tups_inserted / pd->n_offset_changed > 1)
+		pd->cached_bound_offset = offset;
+	else
+		pd->cached_bound_offset = -1;
+	pd->n_tups_inserted = pd->n_offset_changed = 0;
+}
+
+/*
+ * get_cached_{list|range}_partition
+ *		Computes if the cached bound offset value, if any, is satisfied by
+ *		the tuple specified in 'values' and it is, returns the index of
+ *		the partition corresponding to that bound
+ *
+ * Callers must ensure that none of the elements of 'values' is NULL.
+ */
+static inline int
+get_cached_list_partition(PartitionDispatch pd,
+						  PartitionBoundInfo boundinfo,
+						  PartitionKey key,
+						  Datum *values)
+{
+	int		part_index = -1;
+	int		cached_off = pd->cached_bound_offset;
+
+	if (cached_off >= 0)
+	{
+		Datum	bound_datum = boundinfo->datums[cached_off][0];
+		int32	cmpval;
+
+		cmpval = DatumGetInt32(FunctionCall2Coll(&key->partsupfunc[0],
+												 key->partcollation[0],
+												 bound_datum,
+												 values[0]));
+		if (cmpval == 0)
+			part_index = boundinfo->indexes[cached_off];
+	}
+
+	return part_index;
+}
+
+static inline int
+get_cached_range_partition(PartitionDispatch pd,
+						   PartitionBoundInfo boundinfo,
+						   PartitionKey key,
+						   Datum *values)
+{
+	int		part_index = -1;
+	int		cached_off = pd->cached_bound_offset;
+
+	if (cached_off >= 0)
+	{
+		Datum   *bound_datums = boundinfo->datums[cached_off];
+		PartitionRangeDatumKind *bound_kind = boundinfo->kind[cached_off];
+		int32	cmpval;
+
+		/* Check if the value is above the low bound */
+		cmpval = partition_rbound_datum_cmp(key->partsupfunc,
+											key->partcollation,
+											bound_datums,
+											bound_kind,
+											values,
+											key->partnatts);
+		if (cmpval == 0)
+			part_index = boundinfo->indexes[cached_off + 1];
+		else if (cmpval < 0 && cached_off + 1 < boundinfo->ndatums)
+		{
+			/* Check if the value is below the high bound */
+			bound_datums = boundinfo->datums[cached_off + 1];
+			bound_kind = boundinfo->kind[cached_off + 1];
+			cmpval = partition_rbound_datum_cmp(key->partsupfunc,
+												key->partcollation,
+												bound_datums,
+												bound_kind,
+												values,
+												key->partnatts);
+
+			if (cmpval > 0)
+				part_index = boundinfo->indexes[cached_off + 1];
+		}
+	}
+
+	return part_index;
+}
+
 /*
  * get_partition_for_tuple
  *		Finds partition of relation which accepts the partition key specified
@@ -1248,6 +1394,8 @@ get_partition_for_tuple(PartitionDispatch pd, Datum *values, bool *isnull)
 	PartitionDesc partdesc = pd->partdesc;
 	PartitionBoundInfo boundinfo = partdesc->boundinfo;
 
+	pd->n_tups_inserted += 1;
+
 	/* Route as appropriate based on partitioning strategy. */
 	switch (key->strategy)
 	{
@@ -1272,14 +1420,26 @@ get_partition_for_tuple(PartitionDispatch pd, Datum *values, bool *isnull)
 			}
 			else
 			{
-				bool		equal = false;
-
-				bound_offset = partition_list_bsearch(key->partsupfunc,
-													  key->partcollation,
-													  boundinfo,
-													  values[0], &equal);
-				if (bound_offset >= 0 && equal)
-					part_index = boundinfo->indexes[bound_offset];
+				part_index = get_cached_list_partition(pd,
+													   boundinfo,
+													   key,
+													   values);
+				if (part_index < 0)
+				{
+					bool		equal = false;
+
+					bound_offset = partition_list_bsearch(key->partsupfunc,
+														  key->partcollation,
+														  boundinfo,
+														  values[0], &equal);
+					if (bound_offset >= 0 && equal)
+					{
+						part_index = boundinfo->indexes[bound_offset];
+						if (part_index >= 0)
+							maybe_cache_partition_bound_offset(pd,
+															   bound_offset);
+					}
+				}
 			}
 			break;
 
@@ -1304,20 +1464,30 @@ get_partition_for_tuple(PartitionDispatch pd, Datum *values, bool *isnull)
 
 				if (!range_partkey_has_null)
 				{
-					bound_offset = partition_range_datum_bsearch(key->partsupfunc,
-																 key->partcollation,
-																 boundinfo,
-																 key->partnatts,
-																 values,
-																 &equal);
-
-					/*
-					 * The bound at bound_offset is less than or equal to the
-					 * tuple value, so the bound at offset+1 is the upper
-					 * bound of the partition we're looking for, if there
-					 * actually exists one.
-					 */
-					part_index = boundinfo->indexes[bound_offset + 1];
+					part_index = get_cached_range_partition(pd,
+															boundinfo,
+															key,
+															values);
+					if (part_index < 0)
+					{
+						bound_offset = partition_range_datum_bsearch(key->partsupfunc,
+																	 key->partcollation,
+																	 boundinfo,
+																	 key->partnatts,
+																	 values,
+																	 &equal);
+
+						/*
+						 * The bound at bound_offset is less than or equal to the
+						 * tuple value, so the bound at offset+1 is the upper
+						 * bound of the partition we're looking for, if there
+						 * actually exists one.
+						 */
+						part_index = boundinfo->indexes[bound_offset + 1];
+						if (part_index >= 0)
+							maybe_cache_partition_bound_offset(pd,
+															   bound_offset);
+					}
 				}
 			}
 			break;
-- 
2.24.1

From 1c6c5432dc6821164402d7d3c003f8ff9fc03edb Mon Sep 17 00:00:00 2001
From: amitlan <amitlangote09@gmail.com>
Date: Tue, 15 Jun 2021 16:21:48 +0900
Subject: [PATCH v8] Teach get_partition_for_tuple to cache bound offset

For bulk loads into list and range partitioned tables, it can be
very likely that long runs of consecutive tuples route to the same
partition.  In such cases, we can avoid the overhead of performing
a binary search for each such tuple by caching the offset of the
bound for that partition and checking that the bound indeed satisfies
any subsequent tuples, which can be implemented with fewer comparisons
than the binary search.

To avoid impacting the cases where such caching can be unproductive,
an adaptive algorithm is used to determine whether to actually
enable caching or to disable it if checking the cached offset seems
to add pure overhead per tuple.

Author: Hou Zhijie
Author: Amit Langote
---
 src/backend/executor/execPartition.c | 214 ++++++++++++++++++++++++---
 1 file changed, 192 insertions(+), 22 deletions(-)

diff --git a/src/backend/executor/execPartition.c b/src/backend/executor/execPartition.c
index 5c723bc54e..9047fcbcd5 100644
--- a/src/backend/executor/execPartition.c
+++ b/src/backend/executor/execPartition.c
@@ -133,6 +133,13 @@ struct PartitionTupleRouting
  *		routing it through this table). A NULL value is stored if no tuple
  *		conversion is required.
  *
+ * cached_bound_offset
+ * last_seen_offset
+ * n_tups_inserted
+ * n_offset_changed
+ *		Fields to manage the state for bound offset caching; see
+ *		maybe_cache_partition_bound_offset()
+ *
  * indexes
  *		Array of partdesc->nparts elements.  For leaf partitions the index
  *		corresponds to the partition's ResultRelInfo in the encapsulating
@@ -150,6 +157,12 @@ typedef struct PartitionDispatchData
 	PartitionDesc partdesc;
 	TupleTableSlot *tupslot;
 	AttrMap    *tupmap;
+
+	int			cached_bound_offset;
+	int			last_seen_offset;
+	int			n_tups_inserted;
+	int			n_offset_changed;
+
 	int			indexes[FLEXIBLE_ARRAY_MEMBER];
 }			PartitionDispatchData;
 
@@ -1026,6 +1039,10 @@ ExecInitPartitionDispatchInfo(EState *estate,
 	pd->key = RelationGetPartitionKey(rel);
 	pd->keystate = NIL;
 	pd->partdesc = partdesc;
+
+	pd->cached_bound_offset = pd->last_seen_offset = -1;
+	pd->n_tups_inserted = pd->n_offset_changed = 0;
+
 	if (parent_pd != NULL)
 	{
 		TupleDesc	tupdesc = RelationGetDescr(rel);
@@ -1231,6 +1248,135 @@ FormPartitionKeyDatum(PartitionDispatch pd,
 		elog(ERROR, "wrong number of partition key expressions");
 }
 
+/*
+ * Threshold of the number of tuples to need to have been processed before
+ * maybe_cache_partition_bound_offset() (re-)assesses whether caching must be
+ * enabled or disabled for subsequent tuples.
+ */
+#define	CACHE_BOUND_OFFSET_THRESHOLD_TUPS	1000
+
+/*
+ * maybe_cache_partition_bound_offset
+ *		Conditionally sets pd->cached_bound_offset so that
+ *		get_cached_{list|range}_partition can be used for subsequent
+ *		tuples
+ *
+ * It is set if it appears that some offsets observed over the last
+ * pd->n_tups_inserted tuples would have been reused, which can be inferred
+ * from seeing that the ratio of tuples inserted and the number of times the
+ * offset needed to be changed during the insertion of those tuples is greater
+ * than 1.  Conversely, we disable the caching if the ratio is 1, because that
+ * suggests that every consecutively inserted tuple mapped to a different
+ * partition.
+ */
+static inline void
+maybe_cache_partition_bound_offset(PartitionDispatch pd, int offset)
+{
+	if (offset != pd->last_seen_offset)
+	{
+		pd->last_seen_offset = offset;
+		pd->n_offset_changed += 1;
+		/* Only set to the new value after calculating the ratio formula. */
+		pd->cached_bound_offset = -1;
+	}
+
+	/*
+	 * Only consider (re-)enabling/disabling caching if we've seen at least
+	 * a threshold number of tuples since the last time we enabled/disabled
+	 * it.
+	 */
+	if (pd->n_tups_inserted < CACHE_BOUND_OFFSET_THRESHOLD_TUPS)
+		return;
+
+	/* Wouldn't get called if the cached bound offset worked. */
+	Assert(offset != pd->cached_bound_offset);
+
+	/* If the offset didn't change at all, caching it might be a good idea. */
+	if (pd->n_offset_changed == 0 ||
+		(double) pd->n_tups_inserted / pd->n_offset_changed > 1)
+		pd->cached_bound_offset = offset;
+	else
+		pd->cached_bound_offset = -1;
+	pd->n_tups_inserted = pd->n_offset_changed = 0;
+}
+
+/*
+ * get_cached_{list|range}_partition
+ *		Computes if the cached bound offset value, if any, is satisfied by
+ *		the tuple specified in 'values' and it is, returns the index of
+ *		the partition corresponding to that bound
+ *
+ * Callers must ensure that none of the elements of 'values' is NULL.
+ */
+static inline int
+get_cached_list_partition(PartitionDispatch pd,
+						  PartitionBoundInfo boundinfo,
+						  PartitionKey key,
+						  Datum *values)
+{
+	int		part_index = -1;
+	int		cached_off = pd->cached_bound_offset;
+
+	if (cached_off >= 0)
+	{
+		Datum	bound_datum = boundinfo->datums[cached_off][0];
+		int32	cmpval;
+
+		cmpval = DatumGetInt32(FunctionCall2Coll(&key->partsupfunc[0],
+												 key->partcollation[0],
+												 bound_datum,
+												 values[0]));
+		if (cmpval == 0)
+			part_index = boundinfo->indexes[cached_off];
+	}
+
+	return part_index;
+}
+
+static inline int
+get_cached_range_partition(PartitionDispatch pd,
+						   PartitionBoundInfo boundinfo,
+						   PartitionKey key,
+						   Datum *values)
+{
+	int		part_index = -1;
+	int		cached_off = pd->cached_bound_offset;
+
+	if (cached_off >= 0)
+	{
+		Datum   *bound_datums = boundinfo->datums[cached_off];
+		PartitionRangeDatumKind *bound_kind = boundinfo->kind[cached_off];
+		int32	cmpval;
+
+		/* Check if the value is above the low bound */
+		cmpval = partition_rbound_datum_cmp(key->partsupfunc,
+											key->partcollation,
+											bound_datums,
+											bound_kind,
+											values,
+											key->partnatts);
+		if (cmpval == 0)
+			part_index = boundinfo->indexes[cached_off + 1];
+		else if (cmpval < 0 && cached_off + 1 < boundinfo->ndatums)
+		{
+			/* Check if the value is below the high bound */
+			bound_datums = boundinfo->datums[cached_off + 1];
+			bound_kind = boundinfo->kind[cached_off + 1];
+			cmpval = partition_rbound_datum_cmp(key->partsupfunc,
+												key->partcollation,
+												bound_datums,
+												bound_kind,
+												values,
+												key->partnatts);
+
+			if (cmpval > 0)
+				part_index = boundinfo->indexes[cached_off + 1];
+		}
+	}
+
+	return part_index;
+}
+
 /*
  * get_partition_for_tuple
  *		Finds partition of relation which accepts the partition key specified
@@ -1248,6 +1394,8 @@ get_partition_for_tuple(PartitionDispatch pd, Datum *values, bool *isnull)
 	PartitionDesc partdesc = pd->partdesc;
 	PartitionBoundInfo boundinfo = partdesc->boundinfo;
 
+	pd->n_tups_inserted += 1;
+
 	/* Route as appropriate based on partitioning strategy. */
 	switch (key->strategy)
 	{
@@ -1272,14 +1420,26 @@ get_partition_for_tuple(PartitionDispatch pd, Datum *values, bool *isnull)
 			}
 			else
 			{
-				bool		equal = false;
-
-				bound_offset = partition_list_bsearch(key->partsupfunc,
-													  key->partcollation,
-													  boundinfo,
-													  values[0], &equal);
-				if (bound_offset >= 0 && equal)
-					part_index = boundinfo->indexes[bound_offset];
+				part_index = get_cached_list_partition(pd,
+													   boundinfo,
+													   key,
+													   values);
+				if (part_index < 0)
+				{
+					bool		equal = false;
+
+					bound_offset = partition_list_bsearch(key->partsupfunc,
+														  key->partcollation,
+														  boundinfo,
+														  values[0], &equal);
+					if (bound_offset >= 0 && equal)
+					{
+						part_index = boundinfo->indexes[bound_offset];
+						if (part_index >= 0)
+							maybe_cache_partition_bound_offset(pd,
+															   bound_offset);
+					}
+				}
 			}
 			break;
 
@@ -1304,20 +1464,30 @@ get_partition_for_tuple(PartitionDispatch pd, Datum *values, bool *isnull)
 
 				if (!range_partkey_has_null)
 				{
-					bound_offset = partition_range_datum_bsearch(key->partsupfunc,
-																 key->partcollation,
-																 boundinfo,
-																 key->partnatts,
-																 values,
-																 &equal);
-
-					/*
-					 * The bound at bound_offset is less than or equal to the
-					 * tuple value, so the bound at offset+1 is the upper
-					 * bound of the partition we're looking for, if there
-					 * actually exists one.
-					 */
-					part_index = boundinfo->indexes[bound_offset + 1];
+					part_index = get_cached_range_partition(pd,
+															boundinfo,
+															key,
+															values);
+					if (part_index < 0)
+					{
+						bound_offset = partition_range_datum_bsearch(key->partsupfunc,
+																	 key->partcollation,
+																	 boundinfo,
+																	 key->partnatts,
+																	 values,
+																	 &equal);
+
+						/*
+						 * The bound at bound_offset is less than or equal to the
+						 * tuple value, so the bound at offset+1 is the upper
+						 * bound of the partition we're looking for, if there
+						 * actually exists one.
+						 */
+						part_index = boundinfo->indexes[bound_offset + 1];
+						if (part_index >= 0)
+							maybe_cache_partition_bound_offset(pd,
+															   bound_offset);
+					}
 				}
 			}
 			break;
-- 
2.24.1

From fe28c2a39a709ca5413ca94596776efa5d4e1914 Mon Sep 17 00:00:00 2001
From: amitlan <amitlangote09@gmail.com>
Date: Tue, 15 Jun 2021 16:21:48 +0900
Subject: [PATCH v9] Optimze get_partition_for_tuple by caching bound offset

For bulk loads into list and range partitioned tables, it can be very
likely that long runs of consecutive tuples route to the same
partition.  In such cases, we can perform a binary search only once
to find the partition's bound and cache thus found offset.  And then
for the subsequent tuples, only check if they satisfy the bound at the
cached offset, something that's done with up to 2 comparisons, compared
to O(log num_parts) comparisons needed for the binary search.

To avoid impacting the cases where such caching can be unproductive,
it is disabled on the first tuple that no longer satisfies the cached
bound and only re-enabled if the individual bound offsets are found
to re-occur in succession over the span of a threshold number of
tuples, that is, after that many tuples have been processed.

Author: Hou Zhijie
Author: Amit Langote
---
 src/backend/executor/execPartition.c | 212 ++++++++++++++++++++++++---
 1 file changed, 190 insertions(+), 22 deletions(-)

diff --git a/src/backend/executor/execPartition.c b/src/backend/executor/execPartition.c
index 90ed1485d1..742fd00066 100644
--- a/src/backend/executor/execPartition.c
+++ b/src/backend/executor/execPartition.c
@@ -133,6 +133,13 @@ struct PartitionTupleRouting
  *		routing it through this table). A NULL value is stored if no tuple
  *		conversion is required.
  *
+ * cached_bound_offset
+ * last_seen_offset
+ * n_tups_inserted
+ * n_offset_changed
+ *		Fields to manage the state for bound offset caching; see
+ *		maybe_cache_partition_bound_offset()
+ *
  * indexes
  *		Array of partdesc->nparts elements.  For leaf partitions the index
  *		corresponds to the partition's ResultRelInfo in the encapsulating
@@ -150,6 +157,12 @@ typedef struct PartitionDispatchData
 	PartitionDesc partdesc;
 	TupleTableSlot *tupslot;
 	AttrMap    *tupmap;
+
+	int			cached_bound_offset;
+	int			last_seen_offset;
+	int			n_tups_inserted;
+	int			n_offset_changed;
+
 	int			indexes[FLEXIBLE_ARRAY_MEMBER];
 }			PartitionDispatchData;
 
@@ -1026,6 +1039,10 @@ ExecInitPartitionDispatchInfo(EState *estate,
 	pd->key = RelationGetPartitionKey(rel);
 	pd->keystate = NIL;
 	pd->partdesc = partdesc;
+
+	pd->cached_bound_offset = pd->last_seen_offset = -1;
+	pd->n_tups_inserted = pd->n_offset_changed = 0;
+
 	if (parent_pd != NULL)
 	{
 		TupleDesc	tupdesc = RelationGetDescr(rel);
@@ -1231,6 +1248,133 @@ FormPartitionKeyDatum(PartitionDispatch pd,
 		elog(ERROR, "wrong number of partition key expressions");
 }
 
+/*
+ * Threshold of the number of tuples to need to have been processed before
+ * maybe_cache_partition_bound_offset() (re-)assesses whether caching must be
+ * enabled for subsequent tuples.
+ */
+#define	CACHE_BOUND_OFFSET_THRESHOLD_TUPS	1000
+
+/*
+ * maybe_cache_partition_bound_offset
+ *		Conditionally sets pd->cached_bound_offset so that
+ *		get_cached_{list|range}_partition can be used for subsequent
+ *		tuples
+ *
+ * It is set if it appears that some offsets observed over the last
+ * pd->n_tups_inserted tuples would have been reused, which can be inferred
+ * from seeing that the ratio of tuples inserted and the number of times the
+ * offset needed to be changed during the insertion of those tuples is greater
+ * than 1.
+ */
+static inline void
+maybe_cache_partition_bound_offset(PartitionDispatch pd, int offset)
+{
+	if (offset != pd->last_seen_offset)
+	{
+		pd->last_seen_offset = offset;
+		pd->n_offset_changed += 1;
+		/* Only set to the new value after calculating the ratio formula. */
+		pd->cached_bound_offset = -1;
+	}
+
+	/*
+	 * Only consider (re-)enabling/disabling caching if we've seen at least
+	 * a threshold number of tuples since the last time we enabled/disabled
+	 * it.
+	 */
+	if (pd->n_tups_inserted < CACHE_BOUND_OFFSET_THRESHOLD_TUPS)
+		return;
+
+	/* Wouldn't get called if the cached bound offset worked. */
+	Assert(offset != pd->cached_bound_offset);
+
+	/* If the offset didn't change at all, caching it might be a good idea. */
+	if (pd->n_offset_changed == 0 ||
+		(double) pd->n_tups_inserted / pd->n_offset_changed > 1)
+		pd->cached_bound_offset = offset;
+
+	/* Reset the counters for the next run of tuples. */
+	pd->n_tups_inserted = pd->n_offset_changed = 0;
+}
+
+/*
+ * get_cached_{list|range}_partition
+ *		Computes if the cached bound offset value, if any, is satisfied by
+ *		the tuple specified in 'values' and if it is, returns the index of
+ *		the partition corresponding to that bound
+ *
+ * Callers must ensure that none of the elements of 'values' is NULL.
+ */
+static inline int
+get_cached_list_partition(PartitionDispatch pd,
+						  PartitionBoundInfo boundinfo,
+						  PartitionKey key,
+						  Datum *values)
+{
+	int		part_index = -1;
+	int		cached_off = pd->cached_bound_offset;
+
+	if (cached_off >= 0)
+	{
+		Datum	bound_datum = boundinfo->datums[cached_off][0];
+		int32	cmpval;
+
+		cmpval = DatumGetInt32(FunctionCall2Coll(&key->partsupfunc[0],
+												 key->partcollation[0],
+												 bound_datum,
+												 values[0]));
+		if (cmpval == 0)
+			part_index = boundinfo->indexes[cached_off];
+	}
+
+	return part_index;
+}
+
+static inline int
+get_cached_range_partition(PartitionDispatch pd,
+						   PartitionBoundInfo boundinfo,
+						   PartitionKey key,
+						   Datum *values)
+{
+	int		part_index = -1;
+	int		cached_off = pd->cached_bound_offset;
+
+	if (cached_off >= 0)
+	{
+		Datum   *bound_datums = boundinfo->datums[cached_off];
+		PartitionRangeDatumKind *bound_kind = boundinfo->kind[cached_off];
+		int32	cmpval;
+
+		/* Check if the value is above the low bound */
+		cmpval = partition_rbound_datum_cmp(key->partsupfunc,
+											key->partcollation,
+											bound_datums,
+											bound_kind,
+											values,
+											key->partnatts);
+		if (cmpval == 0)
+			part_index = boundinfo->indexes[cached_off + 1];
+		else if (cmpval < 0 && cached_off + 1 < boundinfo->ndatums)
+		{
+			/* Check if the value is below the high bound */
+			bound_datums = boundinfo->datums[cached_off + 1];
+			bound_kind = boundinfo->kind[cached_off + 1];
+			cmpval = partition_rbound_datum_cmp(key->partsupfunc,
+												key->partcollation,
+												bound_datums,
+												bound_kind,
+												values,
+												key->partnatts);
+
+			if (cmpval > 0)
+				part_index = boundinfo->indexes[cached_off + 1];
+		}
+	}
+
+	return part_index;
+}
+
 /*
  * get_partition_for_tuple
  *		Finds partition of relation which accepts the partition key specified
@@ -1248,6 +1392,8 @@ get_partition_for_tuple(PartitionDispatch pd, Datum *values, bool *isnull)
 	PartitionDesc partdesc = pd->partdesc;
 	PartitionBoundInfo boundinfo = partdesc->boundinfo;
 
+	pd->n_tups_inserted += 1;
+
 	/* Route as appropriate based on partitioning strategy. */
 	switch (key->strategy)
 	{
@@ -1272,14 +1418,26 @@ get_partition_for_tuple(PartitionDispatch pd, Datum *values, bool *isnull)
 			}
 			else
 			{
-				bool		equal = false;
-
-				bound_offset = partition_list_bsearch(key->partsupfunc,
-													  key->partcollation,
-													  boundinfo,
-													  values[0], &equal);
-				if (bound_offset >= 0 && equal)
-					part_index = boundinfo->indexes[bound_offset];
+				part_index = get_cached_list_partition(pd,
+													   boundinfo,
+													   key,
+													   values);
+				if (part_index < 0)
+				{
+					bool		equal = false;
+
+					bound_offset = partition_list_bsearch(key->partsupfunc,
+														  key->partcollation,
+														  boundinfo,
+														  values[0], &equal);
+					if (bound_offset >= 0 && equal)
+					{
+						part_index = boundinfo->indexes[bound_offset];
+						if (part_index >= 0)
+							maybe_cache_partition_bound_offset(pd,
+															   bound_offset);
+					}
+				}
 			}
 			break;
 
@@ -1304,20 +1462,30 @@ get_partition_for_tuple(PartitionDispatch pd, Datum *values, bool *isnull)
 
 				if (!range_partkey_has_null)
 				{
-					bound_offset = partition_range_datum_bsearch(key->partsupfunc,
-																 key->partcollation,
-																 boundinfo,
-																 key->partnatts,
-																 values,
-																 &equal);
-
-					/*
-					 * The bound at bound_offset is less than or equal to the
-					 * tuple value, so the bound at offset+1 is the upper
-					 * bound of the partition we're looking for, if there
-					 * actually exists one.
-					 */
-					part_index = boundinfo->indexes[bound_offset + 1];
+					part_index = get_cached_range_partition(pd,
+															boundinfo,
+															key,
+															values);
+					if (part_index < 0)
+					{
+						bound_offset = partition_range_datum_bsearch(key->partsupfunc,
+																	 key->partcollation,
+																	 boundinfo,
+																	 key->partnatts,
+																	 values,
+																	 &equal);
+
+						/*
+						 * The bound at bound_offset is less than or equal to the
+						 * tuple value, so the bound at offset+1 is the upper
+						 * bound of the partition we're looking for, if there
+						 * actually exists one.
+						 */
+						part_index = boundinfo->indexes[bound_offset + 1];
+						if (part_index >= 0)
+							maybe_cache_partition_bound_offset(pd,
+															   bound_offset);
+					}
 				}
 			}
 			break;
-- 
2.24.1

From c83fd58b09544b2debce1a7960f55cb252c26973 Mon Sep 17 00:00:00 2001
From: amitlan <amitlangote09@gmail.com>
Date: Tue, 15 Jun 2021 16:21:48 +0900
Subject: [PATCH v10] Optimze get_partition_for_tuple by caching bound offset

For bulk loads into list and range partitioned tables, it can be very
likely that long runs of consecutive tuples route to the same
partition.  In such cases, we can perform a binary search only once
to find the partition's bound and cache thus found offset.  And then
for the subsequent tuples, only check if they satisfy the bound at the
cached offset, something that's done with up to 2 comparisons, compared
to O(log num_parts) comparisons needed for the binary search.

To avoid impacting the cases where such caching can be unproductive,
it is disabled on the first tuple that no longer satisfies the cached
bound and only re-enabled if the individual bound offsets are found
to re-occur in succession over the span of a threshold number of
tuples, that is, after that many tuples have been processed.

Author: Hou Zhijie
Author: Amit Langote
---
 src/backend/executor/execPartition.c | 208 ++++++++++++++++++++++++---
 1 file changed, 186 insertions(+), 22 deletions(-)

diff --git a/src/backend/executor/execPartition.c b/src/backend/executor/execPartition.c
index 90ed1485d1..0d9e524026 100644
--- a/src/backend/executor/execPartition.c
+++ b/src/backend/executor/execPartition.c
@@ -133,6 +133,13 @@ struct PartitionTupleRouting
  *		routing it through this table). A NULL value is stored if no tuple
  *		conversion is required.
  *
+ * cached_bound_offset
+ * last_seen_offset
+ * n_tups_inserted
+ * n_offset_changed
+ *		Fields to manage the state for bound offset caching; see
+ *		maybe_cache_partition_bound_offset()
+ *
  * indexes
  *		Array of partdesc->nparts elements.  For leaf partitions the index
  *		corresponds to the partition's ResultRelInfo in the encapsulating
@@ -150,6 +157,12 @@ typedef struct PartitionDispatchData
 	PartitionDesc partdesc;
 	TupleTableSlot *tupslot;
 	AttrMap    *tupmap;
+
+	int			cached_bound_offset;
+	int			last_seen_offset;
+	int			n_tups_inserted;
+	int			n_offset_changed;
+
 	int			indexes[FLEXIBLE_ARRAY_MEMBER];
 }			PartitionDispatchData;
 
@@ -1026,6 +1039,10 @@ ExecInitPartitionDispatchInfo(EState *estate,
 	pd->key = RelationGetPartitionKey(rel);
 	pd->keystate = NIL;
 	pd->partdesc = partdesc;
+
+	pd->cached_bound_offset = pd->last_seen_offset = -1;
+	pd->n_tups_inserted = pd->n_offset_changed = 0;
+
 	if (parent_pd != NULL)
 	{
 		TupleDesc	tupdesc = RelationGetDescr(rel);
@@ -1231,6 +1248,129 @@ FormPartitionKeyDatum(PartitionDispatch pd,
 		elog(ERROR, "wrong number of partition key expressions");
 }
 
+/*
+ * Threshold of the number of tuples to need to have been processed before
+ * maybe_cache_partition_bound_offset() (re-)assesses whether caching must be
+ * enabled for subsequent tuples.
+ */
+#define	CACHE_BOUND_OFFSET_THRESHOLD_TUPS	10
+
+/*
+ * maybe_cache_partition_bound_offset
+ *		Conditionally sets pd->cached_bound_offset so that
+ *		get_cached_{list|range}_partition can be used for subsequent
+ *		tuples
+ *
+ * It is set if it appears that some offsets observed over the last
+ * pd->n_tups_inserted tuples would have been reused, which can be inferred
+ * from seeing that the number of tuples inserted is greater than the number
+ * of times the bound offsets to which they were routed changed.
+ */
+static inline void
+maybe_cache_partition_bound_offset(PartitionDispatch pd, int offset)
+{
+	/* If the offset has changed, reset the cached value. */
+	if (offset != pd->last_seen_offset)
+	{
+		pd->last_seen_offset = offset;
+		pd->n_offset_changed += 1;
+		pd->cached_bound_offset = -1;
+	}
+
+	/*
+	 * Only consider (re-) enabling caching if we've seen at least a threshold
+	 * number of tuples.
+	 */
+	if (pd->n_tups_inserted < CACHE_BOUND_OFFSET_THRESHOLD_TUPS)
+		return;
+
+	/* Wouldn't get called if the cached bound offset worked. */
+	Assert(offset != pd->cached_bound_offset);
+
+	if (pd->n_tups_inserted > pd->n_offset_changed)
+		pd->cached_bound_offset = offset;
+
+	/* Reset the counters for the next run of tuples. */
+	pd->n_tups_inserted = pd->n_offset_changed = 0;
+}
+
+/*
+ * get_cached_{list|range}_partition
+ *		Computes if the cached bound offset value, if any, is satisfied by
+ *		the tuple specified in 'values' and if it is, returns the index of
+ *		the partition corresponding to that bound
+ *
+ * Callers must ensure that none of the elements of 'values' is NULL.
+ */
+static inline int
+get_cached_list_partition(PartitionDispatch pd,
+						  PartitionBoundInfo boundinfo,
+						  PartitionKey key,
+						  Datum *values)
+{
+	int		part_index = -1;
+	int		cached_off = pd->cached_bound_offset;
+
+	if (cached_off >= 0)
+	{
+		Datum	bound_datum = boundinfo->datums[cached_off][0];
+		int32	cmpval;
+
+		cmpval = DatumGetInt32(FunctionCall2Coll(&key->partsupfunc[0],
+												 key->partcollation[0],
+												 bound_datum,
+												 values[0]));
+		if (cmpval == 0)
+			part_index = boundinfo->indexes[cached_off];
+	}
+
+	return part_index;
+}
+
+static inline int
+get_cached_range_partition(PartitionDispatch pd,
+						   PartitionBoundInfo boundinfo,
+						   PartitionKey key,
+						   Datum *values)
+{
+	int		part_index = -1;
+	int		cached_off = pd->cached_bound_offset;
+
+	if (cached_off >= 0)
+	{
+		Datum   *bound_datums = boundinfo->datums[cached_off];
+		PartitionRangeDatumKind *bound_kind = boundinfo->kind[cached_off];
+		int32	cmpval;
+
+		/* Check if the value is above the lower bound */
+		cmpval = partition_rbound_datum_cmp(key->partsupfunc,
+											key->partcollation,
+											bound_datums,
+											bound_kind,
+											values,
+											key->partnatts);
+		if (cmpval == 0)
+			part_index = boundinfo->indexes[cached_off + 1];
+		else if (cmpval < 0 && cached_off + 1 < boundinfo->ndatums)
+		{
+			/* Check if the value is below the upper bound */
+			bound_datums = boundinfo->datums[cached_off + 1];
+			bound_kind = boundinfo->kind[cached_off + 1];
+			cmpval = partition_rbound_datum_cmp(key->partsupfunc,
+												key->partcollation,
+												bound_datums,
+												bound_kind,
+												values,
+												key->partnatts);
+
+			if (cmpval > 0)
+				part_index = boundinfo->indexes[cached_off + 1];
+		}
+	}
+
+	return part_index;
+}
+
 /*
  * get_partition_for_tuple
  *		Finds partition of relation which accepts the partition key specified
@@ -1248,6 +1388,8 @@ get_partition_for_tuple(PartitionDispatch pd, Datum *values, bool *isnull)
 	PartitionDesc partdesc = pd->partdesc;
 	PartitionBoundInfo boundinfo = partdesc->boundinfo;
 
+	pd->n_tups_inserted += 1;
+
 	/* Route as appropriate based on partitioning strategy. */
 	switch (key->strategy)
 	{
@@ -1272,14 +1414,26 @@ get_partition_for_tuple(PartitionDispatch pd, Datum *values, bool *isnull)
 			}
 			else
 			{
-				bool		equal = false;
-
-				bound_offset = partition_list_bsearch(key->partsupfunc,
-													  key->partcollation,
-													  boundinfo,
-													  values[0], &equal);
-				if (bound_offset >= 0 && equal)
-					part_index = boundinfo->indexes[bound_offset];
+				part_index = get_cached_list_partition(pd,
+													   boundinfo,
+													   key,
+													   values);
+				if (part_index < 0)
+				{
+					bool		equal = false;
+
+					bound_offset = partition_list_bsearch(key->partsupfunc,
+														  key->partcollation,
+														  boundinfo,
+														  values[0], &equal);
+					if (bound_offset >= 0 && equal)
+					{
+						part_index = boundinfo->indexes[bound_offset];
+						if (part_index >= 0)
+							maybe_cache_partition_bound_offset(pd,
+															   bound_offset);
+					}
+				}
 			}
 			break;
 
@@ -1304,20 +1458,30 @@ get_partition_for_tuple(PartitionDispatch pd, Datum *values, bool *isnull)
 
 				if (!range_partkey_has_null)
 				{
-					bound_offset = partition_range_datum_bsearch(key->partsupfunc,
-																 key->partcollation,
-																 boundinfo,
-																 key->partnatts,
-																 values,
-																 &equal);
-
-					/*
-					 * The bound at bound_offset is less than or equal to the
-					 * tuple value, so the bound at offset+1 is the upper
-					 * bound of the partition we're looking for, if there
-					 * actually exists one.
-					 */
-					part_index = boundinfo->indexes[bound_offset + 1];
+					part_index = get_cached_range_partition(pd,
+															boundinfo,
+															key,
+															values);
+					if (part_index < 0)
+					{
+						bound_offset = partition_range_datum_bsearch(key->partsupfunc,
+																	 key->partcollation,
+																	 boundinfo,
+																	 key->partnatts,
+																	 values,
+																	 &equal);
+
+						/*
+						 * The bound at bound_offset is less than or equal to the
+						 * tuple value, so the bound at offset+1 is the upper
+						 * bound of the partition we're looking for, if there
+						 * actually exists one.
+						 */
+						part_index = boundinfo->indexes[bound_offset + 1];
+						if (part_index >= 0)
+							maybe_cache_partition_bound_offset(pd,
+															   bound_offset);
+					}
 				}
 			}
 			break;
-- 
2.24.1

From c482323feabae476f92accb696dc1efc5628d589 Mon Sep 17 00:00:00 2001
From: David Rowley <dgrowley@gmail.com>
Date: Wed, 14 Jul 2021 00:34:18 +1200
Subject: [PATCH v11 1/3] WIP: Cache last used partition in PartitionDesc

---
 src/backend/executor/execPartition.c | 195 ++++++++++++++++++++++++++-
 src/backend/partitioning/partdesc.c  |   6 +
 src/include/partitioning/partdesc.h  |  11 ++
 3 files changed, 211 insertions(+), 1 deletion(-)

diff --git a/src/backend/executor/execPartition.c b/src/backend/executor/execPartition.c
index e03ea27299..aca08791e9 100644
--- a/src/backend/executor/execPartition.c
+++ b/src/backend/executor/execPartition.c
@@ -176,6 +176,8 @@ static void FormPartitionKeyDatum(PartitionDispatch pd,
 								  EState *estate,
 								  Datum *values,
 								  bool *isnull);
+static int	get_partition_for_tuple_using_cache(PartitionDispatch pd,
+												Datum *values, bool *isnull);
 static int	get_partition_for_tuple(PartitionDispatch pd, Datum *values,
 									bool *isnull);
 static char *ExecBuildSlotPartitionKeyDescription(Relation rel,
@@ -318,7 +320,7 @@ ExecFindPartition(ModifyTableState *mtstate,
 		 * these values, error out.
 		 */
 		if (partdesc->nparts == 0 ||
-			(partidx = get_partition_for_tuple(dispatch, values, isnull)) < 0)
+			(partidx = get_partition_for_tuple_using_cache(dispatch, values, isnull)) < 0)
 		{
 			char	   *val_desc;
 
@@ -1332,6 +1334,191 @@ FormPartitionKeyDatum(PartitionDispatch pd,
 		elog(ERROR, "wrong number of partition key expressions");
 }
 
+/*
+ * find_last_partition_for_tuple
+ *		Checks if 'values' and 'isnull' matches the last found partition and
+ *		returns the partition index of that partition or -1 if the given
+ *		values don't belong to the last found partition.
+ *
+ * Note: If calculating the correct partition is just as cheap as checking if
+ * these values belong to the last partition, here we just calculate the
+ * correct partition for the given values.  This is the case for HASH
+ * partitioning and for LIST partitioning with a NULL value.
+ */
+static inline int
+find_last_partition_for_tuple(PartitionDispatch pd, PartitionDesc partdesc,
+							  Datum *values, bool *isnull)
+{
+	PartitionKey key;
+	PartitionBoundInfo boundinfo;
+
+	/* No last partition? No match then. */
+	if (partdesc->last_found_part_index == -1)
+		return -1;
+
+	key = pd->key;
+	boundinfo = partdesc->boundinfo;
+
+	switch (key->strategy)
+	{
+		case PARTITION_STRATEGY_HASH:
+			{
+				uint64		rowHash;
+
+				rowHash = compute_partition_hash_value(key->partnatts,
+													   key->partsupfunc,
+													   key->partcollation,
+													   values, isnull);
+
+				/* Just calculate the correct partition and return it */
+				return boundinfo->indexes[rowHash % boundinfo->nindexes];
+			}
+
+		case PARTITION_STRATEGY_LIST:
+			if (isnull[0])
+			{
+				/* Just return the NULL partition, if there is one */
+				return boundinfo->null_index;
+			}
+			else
+			{
+				int			last_datum_offset = partdesc->last_found_datum_index;
+				Datum		lastDatum = boundinfo->datums[last_datum_offset][0];
+				int32		cmpval;
+
+				cmpval = DatumGetInt32(FunctionCall2Coll(&key->partsupfunc[0],
+														 key->partcollation[0],
+														 lastDatum,
+														 values[0]));
+
+				if (cmpval == 0)
+					return boundinfo->indexes[last_datum_offset];
+				break;
+			}
+
+		case PARTITION_STRATEGY_RANGE:
+			{
+				int			last_datum_offset = partdesc->last_found_datum_index;
+				Datum	   *lastDatums = boundinfo->datums[last_datum_offset];
+				PartitionRangeDatumKind *kind = boundinfo->kind[last_datum_offset];
+				int32		cmpval;
+
+				/* Check for NULLs and abort the cache check if we find any */
+				for (int i = 0; i < key->partnatts; i++)
+				{
+					if (isnull[i])
+						return -1;
+				}
+
+				/* Check if the value is equal to the lower bound */
+				cmpval = partition_rbound_datum_cmp(key->partsupfunc,
+													key->partcollation,
+													lastDatums,
+													kind,
+													values,
+													key->partnatts);
+
+				if (cmpval == 0)
+					return boundinfo->indexes[last_datum_offset + 1];
+
+				else if (cmpval < 0 && last_datum_offset + 1 < boundinfo->ndatums)
+				{
+					/* Check if the value is below the upper bound */
+					lastDatums = boundinfo->datums[last_datum_offset + 1];
+					kind = boundinfo->kind[last_datum_offset + 1];
+					cmpval = partition_rbound_datum_cmp(key->partsupfunc,
+														key->partcollation,
+														lastDatums,
+														kind,
+														values,
+														key->partnatts);
+
+					if (cmpval > 0)
+						return boundinfo->indexes[last_datum_offset + 1];
+				}
+				break;
+			}
+
+		default:
+			elog(ERROR, "unexpected partition strategy: %d",
+				 (int) key->strategy);
+	}
+
+	return -1;
+}
+
+/*
+ * The number of times the same partition must be found in a row before we
+ * switch from a search for the given values to just checking if the values
+ * belong to the last found partition.
+ */
+#define PARTITION_CACHED_FIND_THRESHOLD		16
+
+/*
+ * get_partition_for_tuple_using_cache
+ *		As get_partition_for_tuple, but use caching logic and check if the
+ *		given 'values' and 'isnull' array also belong to the last found
+ *		partition.  If it does then this can save an expensive binary search
+ *		for LIST and RANGE partitioning.
+ */
+static int
+get_partition_for_tuple_using_cache(PartitionDispatch pd, Datum *values,
+									bool *isnull)
+{
+	PartitionDesc partdesc = pd->partdesc;
+	int			lastpart;
+
+	/*
+	 * When we've found that the same partition matches
+	 * PARTITION_CACHED_FIND_THRESHOLD times in a row, instead of doing a
+	 * partition search, we just check if the last partition found will also
+	 * accept these values.  If it does then that'll save us from searching
+	 * for the correct partition.
+	 */
+
+	/* Have we found the same partition enough times to use the cache? */
+	if (partdesc->last_found_count >= PARTITION_CACHED_FIND_THRESHOLD)
+	{
+		/* check if these values also belong to the last found partition */
+		lastpart = find_last_partition_for_tuple(pd, partdesc, values, isnull);
+
+		if (lastpart == -1)
+		{
+			/*
+			 * The last partition did not match.  We must fall back on a
+			 * search for the correct partition without the cache.
+			 */
+			lastpart = get_partition_for_tuple(pd, values, isnull);
+			partdesc->last_found_count = 1;
+			return lastpart;
+		}
+		else
+		{
+			/* no point in advancing last_found_count any further */
+			return lastpart;
+		}
+	}
+	else
+	{
+		int			thispart;
+
+		/*
+		 * We've not met the threshold for caching yet. Just perform a search.
+		 * get_partition_for_tuple will stash the last_found_part_index.
+		 */
+		lastpart = partdesc->last_found_part_index;
+		thispart = get_partition_for_tuple(pd, values, isnull);
+
+		/* adjust the count accordingly if the partition matched or not */
+		if (thispart == lastpart)
+			partdesc->last_found_count++;
+		else
+			partdesc->last_found_count = 1;
+
+		return thispart;
+	}
+}
+
 /*
  * get_partition_for_tuple
  *		Finds partition of relation which accepts the partition key specified
@@ -1380,7 +1567,10 @@ get_partition_for_tuple(PartitionDispatch pd, Datum *values, bool *isnull)
 													  boundinfo,
 													  values[0], &equal);
 				if (bound_offset >= 0 && equal)
+				{
 					part_index = boundinfo->indexes[bound_offset];
+					partdesc->last_found_datum_index = bound_offset;
+				}
 			}
 			break;
 
@@ -1419,6 +1609,7 @@ get_partition_for_tuple(PartitionDispatch pd, Datum *values, bool *isnull)
 					 * actually exists one.
 					 */
 					part_index = boundinfo->indexes[bound_offset + 1];
+					partdesc->last_found_datum_index = bound_offset;
 				}
 			}
 			break;
@@ -1435,6 +1626,8 @@ get_partition_for_tuple(PartitionDispatch pd, Datum *values, bool *isnull)
 	if (part_index < 0)
 		part_index = boundinfo->default_index;
 
+	partdesc->last_found_part_index = part_index;
+
 	return part_index;
 }
 
diff --git a/src/backend/partitioning/partdesc.c b/src/backend/partitioning/partdesc.c
index 8b6e0bd595..737f0edd89 100644
--- a/src/backend/partitioning/partdesc.c
+++ b/src/backend/partitioning/partdesc.c
@@ -290,6 +290,12 @@ RelationBuildPartitionDesc(Relation rel, bool omit_detached)
 	{
 		oldcxt = MemoryContextSwitchTo(new_pdcxt);
 		partdesc->boundinfo = partition_bounds_copy(boundinfo, key);
+
+		/* Initialize caching fields for speeding up ExecFindPartition */
+		partdesc->last_found_datum_index = -1;
+		partdesc->last_found_part_index = -1;
+		partdesc->last_found_count = 0;
+
 		partdesc->oids = (Oid *) palloc(nparts * sizeof(Oid));
 		partdesc->is_leaf = (bool *) palloc(nparts * sizeof(bool));
 
diff --git a/src/include/partitioning/partdesc.h b/src/include/partitioning/partdesc.h
index ae1afe3d78..7121ac7f7a 100644
--- a/src/include/partitioning/partdesc.h
+++ b/src/include/partitioning/partdesc.h
@@ -36,6 +36,17 @@ typedef struct PartitionDescData
 								 * the corresponding 'oids' element belongs to
 								 * a leaf partition or not */
 	PartitionBoundInfo boundinfo;	/* collection of partition bounds */
+	int			last_found_datum_index; /* Index into the owning
+										 * PartitionBoundInfo's datum array
+										 * for the last found partition */
+	int			last_found_part_index;	/* Partition index of the last found
+										 * partition or -1 if none have been
+										 * found yet or if we've failed to
+										 * find one */
+	int			last_found_count;	/* Number of times in a row have we found
+									 * values to match the partition
+									 * referenced in the last_found_part_index
+									 * field */
 } PartitionDescData;
 
 
-- 
2.35.1.windows.2

From f2c2a04a34ffde2942cc5b75d66eaa6b524c12bc Mon Sep 17 00:00:00 2001
From: David Rowley <dgrowley@gmail.com>
Date: Thu, 14 Jul 2022 16:56:10 +1200
Subject: [PATCH v11 2/3] Do partition caching another way

---
 src/backend/executor/execPartition.c | 357 +++++++++++----------------
 1 file changed, 151 insertions(+), 206 deletions(-)

diff --git a/src/backend/executor/execPartition.c b/src/backend/executor/execPartition.c
index aca08791e9..7bdf78af99 100644
--- a/src/backend/executor/execPartition.c
+++ b/src/backend/executor/execPartition.c
@@ -176,8 +176,6 @@ static void FormPartitionKeyDatum(PartitionDispatch pd,
 								  EState *estate,
 								  Datum *values,
 								  bool *isnull);
-static int	get_partition_for_tuple_using_cache(PartitionDispatch pd,
-												Datum *values, bool *isnull);
 static int	get_partition_for_tuple(PartitionDispatch pd, Datum *values,
 									bool *isnull);
 static char *ExecBuildSlotPartitionKeyDescription(Relation rel,
@@ -320,7 +318,7 @@ ExecFindPartition(ModifyTableState *mtstate,
 		 * these values, error out.
 		 */
 		if (partdesc->nparts == 0 ||
-			(partidx = get_partition_for_tuple_using_cache(dispatch, values, isnull)) < 0)
+			(partidx = get_partition_for_tuple(dispatch, values, isnull)) < 0)
 		{
 			char	   *val_desc;
 
@@ -1334,195 +1332,42 @@ FormPartitionKeyDatum(PartitionDispatch pd,
 		elog(ERROR, "wrong number of partition key expressions");
 }
 
-/*
- * find_last_partition_for_tuple
- *		Checks if 'values' and 'isnull' matches the last found partition and
- *		returns the partition index of that partition or -1 if the given
- *		values don't belong to the last found partition.
- *
- * Note: If calculating the correct partition is just as cheap as checking if
- * these values belong to the last partition, here we just calculate the
- * correct partition for the given values.  This is the case for HASH
- * partitioning and for LIST partitioning with a NULL value.
- */
-static inline int
-find_last_partition_for_tuple(PartitionDispatch pd, PartitionDesc partdesc,
-							  Datum *values, bool *isnull)
-{
-	PartitionKey key;
-	PartitionBoundInfo boundinfo;
-
-	/* No last partition? No match then. */
-	if (partdesc->last_found_part_index == -1)
-		return -1;
-
-	key = pd->key;
-	boundinfo = partdesc->boundinfo;
-
-	switch (key->strategy)
-	{
-		case PARTITION_STRATEGY_HASH:
-			{
-				uint64		rowHash;
-
-				rowHash = compute_partition_hash_value(key->partnatts,
-													   key->partsupfunc,
-													   key->partcollation,
-													   values, isnull);
-
-				/* Just calculate the correct partition and return it */
-				return boundinfo->indexes[rowHash % boundinfo->nindexes];
-			}
-
-		case PARTITION_STRATEGY_LIST:
-			if (isnull[0])
-			{
-				/* Just return the NULL partition, if there is one */
-				return boundinfo->null_index;
-			}
-			else
-			{
-				int			last_datum_offset = partdesc->last_found_datum_index;
-				Datum		lastDatum = boundinfo->datums[last_datum_offset][0];
-				int32		cmpval;
-
-				cmpval = DatumGetInt32(FunctionCall2Coll(&key->partsupfunc[0],
-														 key->partcollation[0],
-														 lastDatum,
-														 values[0]));
-
-				if (cmpval == 0)
-					return boundinfo->indexes[last_datum_offset];
-				break;
-			}
-
-		case PARTITION_STRATEGY_RANGE:
-			{
-				int			last_datum_offset = partdesc->last_found_datum_index;
-				Datum	   *lastDatums = boundinfo->datums[last_datum_offset];
-				PartitionRangeDatumKind *kind = boundinfo->kind[last_datum_offset];
-				int32		cmpval;
-
-				/* Check for NULLs and abort the cache check if we find any */
-				for (int i = 0; i < key->partnatts; i++)
-				{
-					if (isnull[i])
-						return -1;
-				}
-
-				/* Check if the value is equal to the lower bound */
-				cmpval = partition_rbound_datum_cmp(key->partsupfunc,
-													key->partcollation,
-													lastDatums,
-													kind,
-													values,
-													key->partnatts);
-
-				if (cmpval == 0)
-					return boundinfo->indexes[last_datum_offset + 1];
-
-				else if (cmpval < 0 && last_datum_offset + 1 < boundinfo->ndatums)
-				{
-					/* Check if the value is below the upper bound */
-					lastDatums = boundinfo->datums[last_datum_offset + 1];
-					kind = boundinfo->kind[last_datum_offset + 1];
-					cmpval = partition_rbound_datum_cmp(key->partsupfunc,
-														key->partcollation,
-														lastDatums,
-														kind,
-														values,
-														key->partnatts);
-
-					if (cmpval > 0)
-						return boundinfo->indexes[last_datum_offset + 1];
-				}
-				break;
-			}
-
-		default:
-			elog(ERROR, "unexpected partition strategy: %d",
-				 (int) key->strategy);
-	}
-
-	return -1;
-}
-
 /*
  * The number of times the same partition must be found in a row before we
  * switch from a search for the given values to just checking if the values
- * belong to the last found partition.
- */
-#define PARTITION_CACHED_FIND_THRESHOLD		16
-
-/*
- * get_partition_for_tuple_using_cache
- *		As get_partition_for_tuple, but use caching logic and check if the
- *		given 'values' and 'isnull' array also belong to the last found
- *		partition.  If it does then this can save an expensive binary search
- *		for LIST and RANGE partitioning.
+ * belong to the last found partition.  This must be above 0.
  */
-static int
-get_partition_for_tuple_using_cache(PartitionDispatch pd, Datum *values,
-									bool *isnull)
-{
-	PartitionDesc partdesc = pd->partdesc;
-	int			lastpart;
-
-	/*
-	 * When we've found that the same partition matches
-	 * PARTITION_CACHED_FIND_THRESHOLD times in a row, instead of doing a
-	 * partition search, we just check if the last partition found will also
-	 * accept these values.  If it does then that'll save us from searching
-	 * for the correct partition.
-	 */
+#define PARTITION_CACHED_FIND_THRESHOLD			16
 
-	/* Have we found the same partition enough times to use the cache? */
-	if (partdesc->last_found_count >= PARTITION_CACHED_FIND_THRESHOLD)
-	{
-		/* check if these values also belong to the last found partition */
-		lastpart = find_last_partition_for_tuple(pd, partdesc, values, isnull);
-
-		if (lastpart == -1)
-		{
-			/*
-			 * The last partition did not match.  We must fall back on a
-			 * search for the correct partition without the cache.
-			 */
-			lastpart = get_partition_for_tuple(pd, values, isnull);
-			partdesc->last_found_count = 1;
-			return lastpart;
-		}
-		else
-		{
-			/* no point in advancing last_found_count any further */
-			return lastpart;
-		}
-	}
-	else
-	{
-		int			thispart;
-
-		/*
-		 * We've not met the threshold for caching yet. Just perform a search.
-		 * get_partition_for_tuple will stash the last_found_part_index.
-		 */
-		lastpart = partdesc->last_found_part_index;
-		thispart = get_partition_for_tuple(pd, values, isnull);
-
-		/* adjust the count accordingly if the partition matched or not */
-		if (thispart == lastpart)
-			partdesc->last_found_count++;
-		else
-			partdesc->last_found_count = 1;
-
-		return thispart;
-	}
-}
-
-/*
+ /*
  * get_partition_for_tuple
  *		Finds partition of relation which accepts the partition key specified
- *		in values and isnull
+ *		in values and isnull.
+ *
+ * Calling this function can be quite expensive for LIST and RANGE partitioned
+ * tables have many partitions.  This is due to the binary search that's done
+ * to find the correct partition.  Many of the use cases for LIST and RANGE
+ * partitioned tables mean that the same partition is likely to be found in
+ * subsequent ExecFindPartition() calls.  This is especially true for cases
+ * such as RANGE partitioned tables on a TIMESTAMP column where the partition
+ * key is the current time.  When asked to find a partition for a RANGE or
+ * LIST partitioned table, we record the partition index we've found in the
+ * PartitionDesc (which is stored in the relcache), and if we keep finding the
+ * same partition PARTITION_CACHED_FIND_THRESHOLD times, then we'll enable
+ * caching logic and instead of performing a binary search, we'll double check
+ * that the values still belong to the last found partition, and if so, we'll
+ * return that partition index without performing the binary search.  If we
+ * fail to match the last partition when double checking, then we fall back on
+ * doing a normal search.  In this case, we'll set the number of times we've
+ * hit the partition back to 1 again so that we don't attempt to use the cache
+ * again.   For cases where the partition changes on each lookup, the amount
+ * of additional work required just amounts to recording the last found
+ * partition and setting the found counter back to 1 again.
+ *
+ * No caching of partitions is done when the last found partition is th
+ * DEFAULT partition.  In this case, we don't have sufficient information about
+ * the last found partition to confirm the Datum being looked up belongs to
+ * the DEFAULT partition.
  *
  * Return value is index of the partition (>= 0 and < partdesc->nparts) if one
  * found or -1 if none found.
@@ -1536,6 +1381,18 @@ get_partition_for_tuple(PartitionDispatch pd, Datum *values, bool *isnull)
 	PartitionDesc partdesc = pd->partdesc;
 	PartitionBoundInfo boundinfo = partdesc->boundinfo;
 
+	/*
+	 * In the switch statement below, when we perform a cached lookup for
+	 * RANGE and LIST partitioned tables, if we find that the last found
+	 * partition matches the 'values', we return the partition index right
+	 * away.  We do this instead of breaking out of the switch as we don't
+	 * want to execute the code about the default partition or do any updates
+	 * for any of the cache-related fields.  That would be a waste of effort
+	 * as we already know it's not the DEFAULT partition and have no need
+	 * to increment the number of times we found the same partition any
+	 * higher than PARTITION_CACHED_FIND_THRESHOLD.
+	 */
+
 	/* Route as appropriate based on partitioning strategy. */
 	switch (key->strategy)
 	{
@@ -1543,24 +1400,56 @@ get_partition_for_tuple(PartitionDispatch pd, Datum *values, bool *isnull)
 			{
 				uint64		rowHash;
 
+				/* hash partitioning is too cheap to bother caching */
 				rowHash = compute_partition_hash_value(key->partnatts,
 													   key->partsupfunc,
 													   key->partcollation,
 													   values, isnull);
 
-				part_index = boundinfo->indexes[rowHash % boundinfo->nindexes];
+				/*
+				 * HASH partitions can't have a DEFAULT partition and we don't
+				 * do any caching work for them, so just return the part index
+				 */
+				return boundinfo->indexes[rowHash % boundinfo->nindexes];
 			}
-			break;
 
 		case PARTITION_STRATEGY_LIST:
 			if (isnull[0])
 			{
+				/* this is far too cheap to bother doing any caching */
 				if (partition_bound_accepts_nulls(boundinfo))
 					part_index = boundinfo->null_index;
 			}
 			else
 			{
-				bool		equal = false;
+				bool	equal;
+
+				if (partdesc->last_found_count >= PARTITION_CACHED_FIND_THRESHOLD)
+				{
+					int			last_datum_offset = partdesc->last_found_datum_index;
+					Datum		lastDatum = boundinfo->datums[last_datum_offset][0];
+					int32		cmpval;
+
+					/*
+					 * Check if the last found datum index is the same as this
+					 * Datum.
+					 */
+					cmpval = DatumGetInt32(FunctionCall2Coll(&key->partsupfunc[0],
+															 key->partcollation[0],
+															 lastDatum,
+															 values[0]));
+
+					if (cmpval == 0)
+						return boundinfo->indexes[last_datum_offset];
+
+					/*
+					 * The Datum has changed.  Zero the number of times we've
+					 * found last_found_datum_index in a row.
+					 */
+					partdesc->last_found_count = 0;
+
+					/* fall-through and do a manual lookup */
+				}
 
 				bound_offset = partition_list_bsearch(key->partsupfunc,
 													  key->partcollation,
@@ -1593,24 +1482,65 @@ get_partition_for_tuple(PartitionDispatch pd, Datum *values, bool *isnull)
 					}
 				}
 
-				if (!range_partkey_has_null)
+				if (range_partkey_has_null)
 				{
-					bound_offset = partition_range_datum_bsearch(key->partsupfunc,
-																 key->partcollation,
-																 boundinfo,
-																 key->partnatts,
-																 values,
-																 &equal);
+					/* Zero the "winning streak" on the cache hit count */
+					partdesc->last_found_count = 0;
+					break;
+				}
 
-					/*
-					 * The bound at bound_offset is less than or equal to the
-					 * tuple value, so the bound at offset+1 is the upper
-					 * bound of the partition we're looking for, if there
-					 * actually exists one.
-					 */
-					part_index = boundinfo->indexes[bound_offset + 1];
-					partdesc->last_found_datum_index = bound_offset;
+				if (partdesc->last_found_count >= PARTITION_CACHED_FIND_THRESHOLD)
+				{
+					int			last_datum_offset = partdesc->last_found_datum_index;
+					Datum	   *lastDatums = boundinfo->datums[last_datum_offset];
+					PartitionRangeDatumKind *kind = boundinfo->kind[last_datum_offset];
+					int32		cmpval;
+
+					/* Check if the value is equal to the lower bound */
+					cmpval = partition_rbound_datum_cmp(key->partsupfunc,
+														key->partcollation,
+														lastDatums,
+														kind,
+														values,
+														key->partnatts);
+
+					if (cmpval == 0)
+						return boundinfo->indexes[last_datum_offset + 1];
+
+					else if (cmpval < 0 && last_datum_offset + 1 < boundinfo->ndatums)
+					{
+						/* Check if the value is below the upper bound */
+						lastDatums = boundinfo->datums[last_datum_offset + 1];
+						kind = boundinfo->kind[last_datum_offset + 1];
+						cmpval = partition_rbound_datum_cmp(key->partsupfunc,
+															key->partcollation,
+															lastDatums,
+															kind,
+															values,
+															key->partnatts);
+
+						if (cmpval > 0)
+							return boundinfo->indexes[last_datum_offset + 1];
+					}
+
+					/* fall-through and do a manual lookup */
 				}
+
+				bound_offset = partition_range_datum_bsearch(key->partsupfunc,
+															 key->partcollation,
+															 boundinfo,
+															 key->partnatts,
+															 values,
+															 &equal);
+
+				/*
+				 * The bound at bound_offset is less than or equal to the
+				 * tuple value, so the bound at offset+1 is the upper
+				 * bound of the partition we're looking for, if there
+				 * actually exists one.
+				 */
+				part_index = boundinfo->indexes[bound_offset + 1];
+				partdesc->last_found_datum_index = bound_offset;
 			}
 			break;
 
@@ -1625,9 +1555,24 @@ get_partition_for_tuple(PartitionDispatch pd, Datum *values, bool *isnull)
 	 */
 	if (part_index < 0)
 		part_index = boundinfo->default_index;
-
-	partdesc->last_found_part_index = part_index;
-
+	else
+	{
+		/*
+		 * Attend to the cache fields.  If this partition is the same as the
+		 * last partition found, then bump the count by one.  If all goes well
+		 * we'll eventually reach PARTITION_CACHED_FIND_THRESHOLD and we'll
+		 * try the cache path next time around.  If the part_index is not the
+		 * same as last time then we'll reset the cache count back to 1 and
+		 * record this partition to say we've found this one once.
+		 */
+		if (part_index == partdesc->last_found_part_index)
+			partdesc->last_found_count++;
+		else
+		{
+			partdesc->last_found_count = 1;
+			partdesc->last_found_part_index = part_index;
+		}
+	}
 	return part_index;
 }
 
-- 
2.35.1.windows.2

From c6acc6db6be20e72acd1a28669ea4566c8deb44d Mon Sep 17 00:00:00 2001
From: David Rowley <dgrowley@gmail.com>
Date: Thu, 14 Jul 2022 16:57:51 +1200
Subject: [PATCH v11 3/3] likely

---
 src/backend/executor/execPartition.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/backend/executor/execPartition.c b/src/backend/executor/execPartition.c
index 7bdf78af99..edacf28524 100644
--- a/src/backend/executor/execPartition.c
+++ b/src/backend/executor/execPartition.c
@@ -1424,7 +1424,7 @@ get_partition_for_tuple(PartitionDispatch pd, Datum *values, bool *isnull)
 			{
 				bool	equal;
 
-				if (partdesc->last_found_count >= PARTITION_CACHED_FIND_THRESHOLD)
+				if (likely(partdesc->last_found_count >= PARTITION_CACHED_FIND_THRESHOLD))
 				{
 					int			last_datum_offset = partdesc->last_found_datum_index;
 					Datum		lastDatum = boundinfo->datums[last_datum_offset][0];
@@ -1489,7 +1489,7 @@ get_partition_for_tuple(PartitionDispatch pd, Datum *values, bool *isnull)
 					break;
 				}
 
-				if (partdesc->last_found_count >= PARTITION_CACHED_FIND_THRESHOLD)
+				if (likely(partdesc->last_found_count >= PARTITION_CACHED_FIND_THRESHOLD))
 				{
 					int			last_datum_offset = partdesc->last_found_datum_index;
 					Datum	   *lastDatums = boundinfo->datums[last_datum_offset];
-- 
2.35.1.windows.2

diff --git a/src/backend/executor/execPartition.c b/src/backend/executor/execPartition.c
index e03ea27299..6a323436d5 100644
--- a/src/backend/executor/execPartition.c
+++ b/src/backend/executor/execPartition.c
@@ -1332,10 +1332,48 @@ FormPartitionKeyDatum(PartitionDispatch pd,
 		elog(ERROR, "wrong number of partition key expressions");
 }
 
+/*
+ * The number of times the same partition must be found in a row before we
+ * switch from a search for the given values to just checking if the values
+ * belong to the last found partition.  This must be above 0.
+ */
+#define PARTITION_CACHED_FIND_THRESHOLD			16
+
 /*
  * get_partition_for_tuple
  *		Finds partition of relation which accepts the partition key specified
- *		in values and isnull
+ *		in values and isnull.
+ *
+ * Calling this function can be quite expensive when LIST and RANGE
+ * partitioned tables have many partitions.  This is due to the binary search
+ * that's done to find the correct partition.  Many of the use cases for LIST
+ * and RANGE partitioned tables make it likely that the same partition is
+ * found in subsequent ExecFindPartition() calls.  This is especially true for
+ * cases such as RANGE partitioned tables on a TIMESTAMP column where the
+ * partition key is the current time.  When asked to find a partition for a
+ * RANGE or LIST partitioned table, we record the partition index and datum
+ * offset we've found for the given 'values' in the PartitionDesc (which is
+ * stored in relcache), and if we keep finding the same partition
+ * PARTITION_CACHED_FIND_THRESHOLD times in a row, then we'll enable caching
+ * logic and instead of performing a binary search to find the correct
+ * partition, we'll just double-check that 'values' still belong to the last
+ * found partition, and if so, we'll return that partition index, thus
+ * skipping the need for the binary search.  If we fail to match the last
+ * partition when double checking, then we fall back on doing a binary search.
+ * In this case, we'll reset the number of times we've hit the same partition
+ * so that we don't attempt to use the cache again until we've found that
+ * partition at least PARTITION_CACHED_FIND_THRESHOLD times in a row.
+ *
+ * For cases where the partition changes on each lookup, the amount of
+ * additional work required just amounts to recording the last found partition
+ * and bound offset then resetting the found counter.  This is cheap and does
+ * not appear to cause any meaningful slowdowns for such cases.
+ *
+ * No caching of partitions is done when the last found partition is the
+ * DEFAULT or NULL partition.  For the case of the DEFAULT partition, there
+ * is no bound offset storing the matching datum, so we cannot confirm the
+ * indexes match.  For the NULL partition, this is just so cheap, there's no
+ * sense in caching.
  *
  * Return value is index of the partition (>= 0 and < partdesc->nparts) if one
  * found or -1 if none found.
@@ -1343,12 +1381,24 @@ FormPartitionKeyDatum(PartitionDispatch pd,
 static int
 get_partition_for_tuple(PartitionDispatch pd, Datum *values, bool *isnull)
 {
-	int			bound_offset;
+	int			bound_offset = -1;
 	int			part_index = -1;
 	PartitionKey key = pd->key;
 	PartitionDesc partdesc = pd->partdesc;
 	PartitionBoundInfo boundinfo = partdesc->boundinfo;
 
+	/*
+	 * In the switch statement below, when we perform a cached lookup for
+	 * RANGE and LIST partitioned tables, if we find that the last found
+	 * partition matches the 'values', we return the partition index right
+	 * away.  We do this instead of breaking out of the switch as we don't
+	 * want to execute the code about the default partition or do any updates
+	 * for any of the cache-related fields.  That would be a waste of effort
+	 * as we already know it's not the DEFAULT partition and have no need to
+	 * increment the number of times we found the same partition any higher
+	 * than PARTITION_CACHED_FIND_THRESHOLD.
+	 */
+
 	/* Route as appropriate based on partitioning strategy. */
 	switch (key->strategy)
 	{
@@ -1356,24 +1406,62 @@ get_partition_for_tuple(PartitionDispatch pd, Datum *values, bool *isnull)
 			{
 				uint64		rowHash;
 
+				/* hash partitioning is too cheap to bother caching */
 				rowHash = compute_partition_hash_value(key->partnatts,
 													   key->partsupfunc,
 													   key->partcollation,
 													   values, isnull);
 
-				part_index = boundinfo->indexes[rowHash % boundinfo->nindexes];
+				/*
+				 * HASH partitions can't have a DEFAULT partition and we don't
+				 * do any caching work for them, so just return the part index
+				 */
+				return boundinfo->indexes[rowHash % boundinfo->nindexes];
 			}
-			break;
 
 		case PARTITION_STRATEGY_LIST:
 			if (isnull[0])
 			{
+				/* this is far too cheap to bother doing any caching */
 				if (partition_bound_accepts_nulls(boundinfo))
-					part_index = boundinfo->null_index;
+				{
+					/*
+					 * When there is a NULL partition we just return that
+					 * directly.  We don't have a bound_offset so it's not
+					 * valid to drop into the code after the switch which
+					 * checks and updates the cache fields.  We perhaps should
+					 * be invalidating the details of the last cached
+					 * partition but there's no real need to.  Keeping those
+					 * fields set gives a chance at a matching to the cached
+					 * partition on the next lookup.
+					 */
+					return boundinfo->null_index;
+				}
 			}
 			else
 			{
-				bool		equal = false;
+				bool		equal;
+
+				if (partdesc->last_found_count >= PARTITION_CACHED_FIND_THRESHOLD)
+				{
+					int			last_datum_offset = partdesc->last_found_datum_index;
+					Datum		lastDatum = boundinfo->datums[last_datum_offset][0];
+					int32		cmpval;
+
+					/*
+					 * Check if the last found datum index is the same as this
+					 * Datum.
+					 */
+					cmpval = DatumGetInt32(FunctionCall2Coll(&key->partsupfunc[0],
+															 key->partcollation[0],
+															 lastDatum,
+															 values[0]));
+
+					if (cmpval == 0)
+						return boundinfo->indexes[last_datum_offset];
+
+					/* fall-through and do a manual lookup */
+				}
 
 				bound_offset = partition_list_bsearch(key->partsupfunc,
 													  key->partcollation,
@@ -1403,23 +1491,63 @@ get_partition_for_tuple(PartitionDispatch pd, Datum *values, bool *isnull)
 					}
 				}
 
-				if (!range_partkey_has_null)
+				if (range_partkey_has_null)
+					break;
+
+				if (partdesc->last_found_count >= PARTITION_CACHED_FIND_THRESHOLD)
 				{
-					bound_offset = partition_range_datum_bsearch(key->partsupfunc,
-																 key->partcollation,
-																 boundinfo,
-																 key->partnatts,
-																 values,
-																 &equal);
+					int			last_datum_offset = partdesc->last_found_datum_index;
+					Datum	   *lastDatums = boundinfo->datums[last_datum_offset];
+					PartitionRangeDatumKind *kind = boundinfo->kind[last_datum_offset];
+					int32		cmpval;
+
+					/* Check if the value is >= to the lower bound */
+					cmpval = partition_rbound_datum_cmp(key->partsupfunc,
+														key->partcollation,
+														lastDatums,
+														kind,
+														values,
+														key->partnatts);
 
 					/*
-					 * The bound at bound_offset is less than or equal to the
-					 * tuple value, so the bound at offset+1 is the upper
-					 * bound of the partition we're looking for, if there
-					 * actually exists one.
+					 * If it's equal to the lower bound then no need to check
+					 * the upper bound.
 					 */
-					part_index = boundinfo->indexes[bound_offset + 1];
+					if (cmpval == 0)
+						return boundinfo->indexes[last_datum_offset + 1];
+
+					else if (cmpval < 0 && last_datum_offset + 1 < boundinfo->ndatums)
+					{
+						/* Check if the value is below the upper bound */
+						lastDatums = boundinfo->datums[last_datum_offset + 1];
+						kind = boundinfo->kind[last_datum_offset + 1];
+						cmpval = partition_rbound_datum_cmp(key->partsupfunc,
+															key->partcollation,
+															lastDatums,
+															kind,
+															values,
+															key->partnatts);
+
+						if (cmpval > 0)
+							return boundinfo->indexes[last_datum_offset + 1];
+					}
+					/* fall-through and do a manual lookup */
 				}
+
+				bound_offset = partition_range_datum_bsearch(key->partsupfunc,
+															 key->partcollation,
+															 boundinfo,
+															 key->partnatts,
+															 values,
+															 &equal);
+
+				/*
+				 * The bound at bound_offset is less than or equal to the
+				 * tuple value, so the bound at offset+1 is the upper bound of
+				 * the partition we're looking for, if there actually exists
+				 * one.
+				 */
+				part_index = boundinfo->indexes[bound_offset + 1];
 			}
 			break;
 
@@ -1433,7 +1561,39 @@ get_partition_for_tuple(PartitionDispatch pd, Datum *values, bool *isnull)
 	 * the default partition, if there is one.
 	 */
 	if (part_index < 0)
-		part_index = boundinfo->default_index;
+	{
+		/*
+		 * Since we don't do caching for the default partition or failed
+		 * lookups, we'll just wipe the cache fields back to their initial
+		 * values.  The count becomes 0 rather than 1 as 1 means it's the
+		 * first time we've found a partition we're recording for the cache.
+		 */
+		partdesc->last_found_datum_index = -1;
+		partdesc->last_found_part_index = -1;
+		partdesc->last_found_count = 0;
+
+		return boundinfo->default_index;
+	}
+
+	/* We should only make it here when the code above set bound_offset */
+	Assert(bound_offset >= 0);
+
+	/*
+	 * Attend to the cache fields.  If the bound_offset matches the last
+	 * cached bound offset then we've found the same partition as last time,
+	 * so bump the count by one.  If all goes well we'll eventually reach
+	 * PARTITION_CACHED_FIND_THRESHOLD and we'll try the cache path next time
+	 * around.  Otherwise, we'll reset the cache count back to 1 to mark that
+	 * we've found this partition for the first time.
+	 */
+	if (bound_offset == partdesc->last_found_datum_index)
+		partdesc->last_found_count++;
+	else
+	{
+		partdesc->last_found_count = 1;
+		partdesc->last_found_part_index = part_index;
+		partdesc->last_found_datum_index = bound_offset;
+	}
 
 	return part_index;
 }
diff --git a/src/backend/partitioning/partdesc.c b/src/backend/partitioning/partdesc.c
index 8b6e0bd595..737f0edd89 100644
--- a/src/backend/partitioning/partdesc.c
+++ b/src/backend/partitioning/partdesc.c
@@ -290,6 +290,12 @@ RelationBuildPartitionDesc(Relation rel, bool omit_detached)
 	{
 		oldcxt = MemoryContextSwitchTo(new_pdcxt);
 		partdesc->boundinfo = partition_bounds_copy(boundinfo, key);
+
+		/* Initialize caching fields for speeding up ExecFindPartition */
+		partdesc->last_found_datum_index = -1;
+		partdesc->last_found_part_index = -1;
+		partdesc->last_found_count = 0;
+
 		partdesc->oids = (Oid *) palloc(nparts * sizeof(Oid));
 		partdesc->is_leaf = (bool *) palloc(nparts * sizeof(bool));
 
diff --git a/src/include/partitioning/partdesc.h b/src/include/partitioning/partdesc.h
index ae1afe3d78..4659fe0e64 100644
--- a/src/include/partitioning/partdesc.h
+++ b/src/include/partitioning/partdesc.h
@@ -36,6 +36,32 @@ typedef struct PartitionDescData
 								 * the corresponding 'oids' element belongs to
 								 * a leaf partition or not */
 	PartitionBoundInfo boundinfo;	/* collection of partition bounds */
+
+	/* Caching fields to cache lookups in get_partition_for_tuple() */
+
+	/*
+	 * Index into the PartitionBoundInfo's datum array for the last found
+	 * partition or -1 if none.
+	 */
+	int			last_found_datum_index;
+
+	/*
+	 * Partition index of the last found partition or -1 if none has been
+	 * found yet, the last found was the DEFAULT partition, or there was no
+	 * valid partition for the last looked up values.
+	 */
+	int			last_found_part_index;
+
+	/*
+	 * For LIST partitioning, this is the number of times in a row that the
+	 * the datum we're looking for a partition for matches the datum in the
+	 * last_found_datum_index index of the boundinfo->datums array.  For RANGE
+	 * partitioning, this is the number of times in a row we've found that the
+	 * datum we're looking for a partition for falls into the range of the
+	 * partition corresponding to the last_found_datum_index index of the
+	 * boundinfo->datums array.
+	 */
+	int			last_found_count;
 } PartitionDescData;
 
 

diff --git a/src/backend/executor/execPartition.c b/src/backend/executor/execPartition.c
index e03ea27299..7ae7496737 100644
--- a/src/backend/executor/execPartition.c
+++ b/src/backend/executor/execPartition.c
@@ -1332,10 +1332,49 @@ FormPartitionKeyDatum(PartitionDispatch pd,
 		elog(ERROR, "wrong number of partition key expressions");
 }
 
+/*
+ * The number of times the same partition must be found in a row before we
+ * switch from a binary search for the given values to just checking if the
+ * values belong to the last found partition.  This must be above 0.
+ */
+#define PARTITION_CACHED_FIND_THRESHOLD			16
+
 /*
  * get_partition_for_tuple
  *		Finds partition of relation which accepts the partition key specified
- *		in values and isnull
+ *		in values and isnull.
+ *
+ * Calling this function can be quite expensive when LIST and RANGE
+ * partitioned tables have many partitions.  This is due to the binary search
+ * that's done to find the correct partition.  Many of the use cases for LIST
+ * and RANGE partitioned tables make it likely that the same partition is
+ * found in subsequent ExecFindPartition() calls.  This is especially true for
+ * cases such as RANGE partitioned tables on a TIMESTAMP column where the
+ * partition key is the current time.  When asked to find a partition for a
+ * RANGE or LIST partitioned table, we record the partition index and datum
+ * offset we've found for the given 'values' in the PartitionDesc (which is
+ * stored in relcache), and if we keep finding the same partition
+ * PARTITION_CACHED_FIND_THRESHOLD times in a row, then we'll enable caching
+ * logic and instead of performing a binary search to find the correct
+ * partition, we'll just double-check that 'values' still belong to the last
+ * found partition, and if so, we'll return that partition index, thus
+ * skipping the need for the binary search.  If we fail to match the last
+ * partition when double checking, then we fall back on doing a binary search.
+ * In this case, unless we find 'values' belong to the DEFAULT partition,
+ * we'll reset the number of times we've hit the same partition so that we
+ * don't attempt to use the cache again until we've found that partition at
+ * least PARTITION_CACHED_FIND_THRESHOLD times in a row.
+ *
+ * For cases where the partition changes on each lookup, the amount of
+ * additional work required just amounts to recording the last found partition
+ * and bound offset then resetting the found counter.  This is cheap and does
+ * not appear to cause any meaningful slowdowns for such cases.
+ *
+ * No caching of partitions is done when the last found partition is the
+ * DEFAULT or NULL partition.  For the case of the DEFAULT partition, there
+ * is no bound offset storing the matching datum, so we cannot confirm the
+ * indexes match.  For the NULL partition, this is just so cheap, there's no
+ * sense in caching.
  *
  * Return value is index of the partition (>= 0 and < partdesc->nparts) if one
  * found or -1 if none found.
@@ -1343,12 +1382,24 @@ FormPartitionKeyDatum(PartitionDispatch pd,
 static int
 get_partition_for_tuple(PartitionDispatch pd, Datum *values, bool *isnull)
 {
-	int			bound_offset;
+	int			bound_offset = -1;
 	int			part_index = -1;
 	PartitionKey key = pd->key;
 	PartitionDesc partdesc = pd->partdesc;
 	PartitionBoundInfo boundinfo = partdesc->boundinfo;
 
+	/*
+	 * In the switch statement below, when we perform a cached lookup for
+	 * RANGE and LIST partitioned tables, if we find that the last found
+	 * partition matches the 'values', we return the partition index right
+	 * away.  We do this instead of breaking out of the switch as we don't
+	 * want to execute the code about the DEFAULT partition or do any updates
+	 * for any of the cache-related fields.  That would be a waste of effort
+	 * as we already know it's not the DEFAULT partition and have no need to
+	 * increment the number of times we found the same partition any higher
+	 * than PARTITION_CACHED_FIND_THRESHOLD.
+	 */
+
 	/* Route as appropriate based on partitioning strategy. */
 	switch (key->strategy)
 	{
@@ -1356,24 +1407,62 @@ get_partition_for_tuple(PartitionDispatch pd, Datum *values, bool *isnull)
 			{
 				uint64		rowHash;
 
+				/* hash partitioning is too cheap to bother caching */
 				rowHash = compute_partition_hash_value(key->partnatts,
 													   key->partsupfunc,
 													   key->partcollation,
 													   values, isnull);
 
-				part_index = boundinfo->indexes[rowHash % boundinfo->nindexes];
+				/*
+				 * HASH partitions can't have a DEFAULT partition and we don't
+				 * do any caching work for them, so just return the part index
+				 */
+				return boundinfo->indexes[rowHash % boundinfo->nindexes];
 			}
-			break;
 
 		case PARTITION_STRATEGY_LIST:
 			if (isnull[0])
 			{
+				/* this is far too cheap to bother doing any caching */
 				if (partition_bound_accepts_nulls(boundinfo))
-					part_index = boundinfo->null_index;
+				{
+					/*
+					 * When there is a NULL partition we just return that
+					 * directly.  We don't have a bound_offset so it's not
+					 * valid to drop into the code after the switch which
+					 * checks and updates the cache fields.  We perhaps should
+					 * be invalidating the details of the last cached
+					 * partition but there's no real need to.  Keeping those
+					 * fields set gives a chance at matching to the cached
+					 * partition on the next lookup.
+					 */
+					return boundinfo->null_index;
+				}
 			}
 			else
 			{
-				bool		equal = false;
+				bool		equal;
+
+				if (partdesc->last_found_count >= PARTITION_CACHED_FIND_THRESHOLD)
+				{
+					int			last_datum_offset = partdesc->last_found_datum_index;
+					Datum		lastDatum = boundinfo->datums[last_datum_offset][0];
+					int32		cmpval;
+
+					/*
+					 * Check if the last found datum index is the same as this
+					 * Datum.
+					 */
+					cmpval = DatumGetInt32(FunctionCall2Coll(&key->partsupfunc[0],
+															 key->partcollation[0],
+															 lastDatum,
+															 values[0]));
+
+					if (cmpval == 0)
+						return boundinfo->indexes[last_datum_offset];
+
+					/* fall-through and do a manual lookup */
+				}
 
 				bound_offset = partition_list_bsearch(key->partsupfunc,
 													  key->partcollation,
@@ -1403,23 +1492,63 @@ get_partition_for_tuple(PartitionDispatch pd, Datum *values, bool *isnull)
 					}
 				}
 
-				if (!range_partkey_has_null)
+				if (range_partkey_has_null)
+					break;
+
+				if (partdesc->last_found_count >= PARTITION_CACHED_FIND_THRESHOLD)
 				{
-					bound_offset = partition_range_datum_bsearch(key->partsupfunc,
-																 key->partcollation,
-																 boundinfo,
-																 key->partnatts,
-																 values,
-																 &equal);
+					int			last_datum_offset = partdesc->last_found_datum_index;
+					Datum	   *lastDatums = boundinfo->datums[last_datum_offset];
+					PartitionRangeDatumKind *kind = boundinfo->kind[last_datum_offset];
+					int32		cmpval;
+
+					/* Check if the value is >= to the lower bound */
+					cmpval = partition_rbound_datum_cmp(key->partsupfunc,
+														key->partcollation,
+														lastDatums,
+														kind,
+														values,
+														key->partnatts);
 
 					/*
-					 * The bound at bound_offset is less than or equal to the
-					 * tuple value, so the bound at offset+1 is the upper
-					 * bound of the partition we're looking for, if there
-					 * actually exists one.
+					 * If it's equal to the lower bound then no need to check
+					 * the upper bound.
 					 */
-					part_index = boundinfo->indexes[bound_offset + 1];
+					if (cmpval == 0)
+						return boundinfo->indexes[last_datum_offset + 1];
+
+					if (cmpval < 0 && last_datum_offset + 1 < boundinfo->ndatums)
+					{
+						/* Check if the value is below the upper bound */
+						lastDatums = boundinfo->datums[last_datum_offset + 1];
+						kind = boundinfo->kind[last_datum_offset + 1];
+						cmpval = partition_rbound_datum_cmp(key->partsupfunc,
+															key->partcollation,
+															lastDatums,
+															kind,
+															values,
+															key->partnatts);
+
+						if (cmpval > 0)
+							return boundinfo->indexes[last_datum_offset + 1];
+					}
+					/* fall-through and do a manual lookup */
 				}
+
+				bound_offset = partition_range_datum_bsearch(key->partsupfunc,
+															 key->partcollation,
+															 boundinfo,
+															 key->partnatts,
+															 values,
+															 &equal);
+
+				/*
+				 * The bound at bound_offset is less than or equal to the
+				 * tuple value, so the bound at offset+1 is the upper bound of
+				 * the partition we're looking for, if there actually exists
+				 * one.
+				 */
+				part_index = boundinfo->indexes[bound_offset + 1];
 			}
 			break;
 
@@ -1433,7 +1562,34 @@ get_partition_for_tuple(PartitionDispatch pd, Datum *values, bool *isnull)
 	 * the default partition, if there is one.
 	 */
 	if (part_index < 0)
-		part_index = boundinfo->default_index;
+	{
+		/*
+		 * No need to reset the cache fields here.  The next set of values
+		 * might end up belonging to the cached partition, so leaving the
+		 * cache alone improves the chances of a cache hit on the next lookup.
+		 */
+		return boundinfo->default_index;
+	}
+
+	/* We should only make it here when the code above set bound_offset */
+	Assert(bound_offset >= 0);
+
+	/*
+	 * Attend to the cache fields.  If the bound_offset matches the last
+	 * cached bound offset then we've found the same partition as last time,
+	 * so bump the count by one.  If all goes well, we'll eventually reach
+	 * PARTITION_CACHED_FIND_THRESHOLD and try the cache path next time
+	 * around.  Otherwise, we'll reset the cache count back to 1 to mark that
+	 * we've found this partition for the first time.
+	 */
+	if (bound_offset == partdesc->last_found_datum_index)
+		partdesc->last_found_count++;
+	else
+	{
+		partdesc->last_found_count = 1;
+		partdesc->last_found_part_index = part_index;
+		partdesc->last_found_datum_index = bound_offset;
+	}
 
 	return part_index;
 }
diff --git a/src/backend/partitioning/partdesc.c b/src/backend/partitioning/partdesc.c
index 8b6e0bd595..737f0edd89 100644
--- a/src/backend/partitioning/partdesc.c
+++ b/src/backend/partitioning/partdesc.c
@@ -290,6 +290,12 @@ RelationBuildPartitionDesc(Relation rel, bool omit_detached)
 	{
 		oldcxt = MemoryContextSwitchTo(new_pdcxt);
 		partdesc->boundinfo = partition_bounds_copy(boundinfo, key);
+
+		/* Initialize caching fields for speeding up ExecFindPartition */
+		partdesc->last_found_datum_index = -1;
+		partdesc->last_found_part_index = -1;
+		partdesc->last_found_count = 0;
+
 		partdesc->oids = (Oid *) palloc(nparts * sizeof(Oid));
 		partdesc->is_leaf = (bool *) palloc(nparts * sizeof(bool));
 
diff --git a/src/include/partitioning/partdesc.h b/src/include/partitioning/partdesc.h
index ae1afe3d78..1de9a658c7 100644
--- a/src/include/partitioning/partdesc.h
+++ b/src/include/partitioning/partdesc.h
@@ -36,6 +36,32 @@ typedef struct PartitionDescData
 								 * the corresponding 'oids' element belongs to
 								 * a leaf partition or not */
 	PartitionBoundInfo boundinfo;	/* collection of partition bounds */
+
+	/* Caching fields to cache lookups in get_partition_for_tuple() */
+
+	/*
+	 * Index into the PartitionBoundInfo's datum array for the last found
+	 * partition or -1 if none.
+	 */
+	int			last_found_datum_index;
+
+	/*
+	 * Partition index of the last found partition or -1 if none has been
+	 * found yet, if the last found was the DEFAULT partition, or if there was
+	 * no valid partition for the last looked up values.
+	 */
+	int			last_found_part_index;
+
+	/*
+	 * For LIST partitioning, this is the number of times in a row that the
+	 * the datum we're looking for a partition for matches the datum in the
+	 * last_found_datum_index index of the boundinfo->datums array.  For RANGE
+	 * partitioning, this is the number of times in a row we've found that the
+	 * datum we're looking for a partition for falls into the range of the
+	 * partition corresponding to the last_found_datum_index index of the
+	 * boundinfo->datums array.
+	 */
+	int			last_found_count;
 } PartitionDescData;