why partition pruning doesn't work?

diff --git a/src/backend/partitioning/partprune.c b/src/backend/partitioning/partprune.c
index 58ec2a6..61c6c0c 100644
--- a/src/backend/partitioning/partprune.c
+++ b/src/backend/partitioning/partprune.c
@@ -2705,6 +2705,15 @@ pull_partkey_params(PartitionPruneInfo *pinfo, List *steps)
 		{
 			Expr	   *expr = lfirst(lc2);
 
+			if (IsA(expr, SQLValueFunction))
+			{
+				Param	   *param = (Param *) expr;
+
+				pinfo->execparams = bms_add_member(pinfo->execparams,
+												   param->paramid);
+				gotone = true;
+			}
+
 			if (IsA(expr, Param))
 			{
 				Param	   *param = (Param *) expr;
@@ -3038,6 +3047,7 @@ partkey_datum_from_expr(PartitionPruneContext *context,
 			return true;
 
 		case T_Param:
+		case T_SQLValueFunction:
 
 			/*
 			 * When being called from the executor we may be able to evaluate

diff --git a/src/backend/partitioning/partprune.c b/src/backend/partitioning/partprune.c
index 58ec2a684d..b9e801e1d0 100644
--- a/src/backend/partitioning/partprune.c
+++ b/src/backend/partitioning/partprune.c
@@ -43,6 +43,7 @@
 #include "access/nbtree.h"
 #include "catalog/pg_operator.h"
 #include "catalog/pg_opfamily.h"
+#include "catalog/pg_proc.h"
 #include "catalog/pg_type.h"
 #include "executor/executor.h"
 #include "miscadmin.h"
@@ -2704,28 +2705,80 @@ pull_partkey_params(PartitionPruneInfo *pinfo, List *steps)
 		foreach(lc2, stepop->exprs)
 		{
 			Expr	   *expr = lfirst(lc2);
+			char		provolatile;
+			Param	   *param;
 
-			if (IsA(expr, Param))
+			switch (nodeTag(expr))
 			{
-				Param	   *param = (Param *) expr;
+				case T_OpExpr:
+				case T_DistinctExpr:
+				case T_NullIfExpr:
+				{
+					OpExpr	   *op = (OpExpr *) expr;
+					provolatile =  func_volatile(op->opfuncid);
+
+					if (provolatile == PROVOLATILE_STABLE ||
+						provolatile == PROVOLATILE_IMMUTABLE)
+					{
+						param = (Param *) expr;
+						pinfo->execparams = bms_add_member(pinfo->execparams,
+														   param->paramid);
 
-				switch (param->paramkind)
+					}
+					gotone = true;
+					break;
+				}
+				case T_FuncExpr:
 				{
-					case PARAM_EXTERN:
-						pinfo->extparams = bms_add_member(pinfo->extparams,
-														  param->paramid);
-						break;
-					case PARAM_EXEC:
+					FuncExpr	   *func = (FuncExpr *) expr;
+					provolatile =  func_volatile(func->funcid);
+
+					if (provolatile == PROVOLATILE_STABLE ||
+						provolatile == PROVOLATILE_IMMUTABLE)
+					{
+						param = (Param *) expr;
 						pinfo->execparams = bms_add_member(pinfo->execparams,
 														   param->paramid);
-						break;
 
-					default:
-						elog(ERROR, "unrecognized paramkind: %d",
-							 (int) param->paramkind);
-						break;
+					}
+					gotone = true;
+					break;
 				}
-				gotone = true;
+				case T_SQLValueFunction:
+				{
+					param = (Param *) expr;
+
+					pinfo->execparams = bms_add_member(pinfo->execparams,
+													   param->paramid);
+					gotone = true;
+					break;
+				}
+				case T_Param:
+				{
+					param = (Param *) expr;
+
+					switch (param->paramkind)
+					{
+						case PARAM_EXTERN:
+							pinfo->extparams = bms_add_member(pinfo->extparams,
+															  param->paramid);
+							break;
+						case PARAM_EXEC:
+							pinfo->execparams = bms_add_member(pinfo->execparams,
+															   param->paramid);
+							break;
+
+						default:
+							elog(ERROR, "unrecognized paramkind: %d",
+								 (int) param->paramkind);
+							break;
+					}
+					gotone = true;
+					break;
+				}
+				default:
+					gotone = false;
+					break;
 			}
 		}
 	}
@@ -3038,6 +3091,8 @@ partkey_datum_from_expr(PartitionPruneContext *context,
 			return true;
 
 		case T_Param:
+		case T_SQLValueFunction:
+		case T_FuncExpr:
 
 			/*
 			 * When being called from the executor we may be able to evaluate

diff --git a/src/backend/partitioning/partprune.c b/src/backend/partitioning/partprune.c
index 58ec2a6..f02bd30 100644
--- a/src/backend/partitioning/partprune.c
+++ b/src/backend/partitioning/partprune.c
@@ -2705,6 +2705,9 @@ pull_partkey_params(PartitionPruneInfo *pinfo, List *steps)
 		{
 			Expr	   *expr = lfirst(lc2);
 
+			if (contain_volatile_functions((Node *) expr))
+				continue;
+
 			if (IsA(expr, Param))
 			{
 				Param	   *param = (Param *) expr;
@@ -2727,6 +2730,13 @@ pull_partkey_params(PartitionPruneInfo *pinfo, List *steps)
 				}
 				gotone = true;
 			}
+			else if (!IsA(expr, Const))
+			{
+				Param	*param = (Param *) expr;
+				pinfo->execparams = bms_add_member(pinfo->execparams,
+												   param->paramid);
+				gotone = true;
+			}
 		}
 	}
 
@@ -3031,37 +3041,35 @@ static bool
 partkey_datum_from_expr(PartitionPruneContext *context,
 						Expr *expr, int stateidx, Datum *value)
 {
-	switch (nodeTag(expr))
-	{
-		case T_Const:
-			*value = ((Const *) expr)->constvalue;
-			return true;
-
-		case T_Param:
-
-			/*
-			 * When being called from the executor we may be able to evaluate
-			 * the Param's value.
-			 */
-			if (context->planstate &&
-				bms_is_member(((Param *) expr)->paramid, context->safeparams))
-			{
-				ExprState  *exprstate;
-				ExprContext *ectx;
-				bool		isNull;
+	if (contain_volatile_functions((Node *) expr))
+		return false;
 
-				exprstate = context->exprstates[stateidx];
-				ectx = context->planstate->ps_ExprContext;
-				*value = ExecEvalExprSwitchContext(exprstate, ectx, &isNull);
-				if (isNull)
-					return false;
+	if (IsA(expr, Const))
+	{
+		*value = ((Const *) expr)->constvalue;
+		return true;
+	}
+	else
+	{
+		/*
+		 * When being called from the executor we may be able to evaluate
+		 * the Param's value.
+		 */
+		if (context->planstate &&
+			bms_is_member(((Param *) expr)->paramid, context->safeparams))
+		{
+			ExprState  *exprstate;
+			ExprContext *ectx;
+			bool		isNull;
 
-				return true;
-			}
-			break;
+			exprstate = context->exprstates[stateidx];
+			ectx = context->planstate->ps_ExprContext;
+			*value = ExecEvalExprSwitchContext(exprstate, ectx, &isNull);
+			if (isNull)
+				return false;
 
-		default:
-			break;
+			return true;
+		}
 	}
 
 	return false;

diff --git a/src/backend/executor/execPartition.c b/src/backend/executor/execPartition.c
index c83991c93c..f9a812480d 100644
--- a/src/backend/executor/execPartition.c
+++ b/src/backend/executor/execPartition.c
@@ -1349,7 +1349,11 @@ adjust_partition_tlist(List *tlist, TupleConversionMap *map)
  * difference between these that we need to concern ourselves with is the
  * time when the values of the Params are known.  External Param values are
  * known at any time of execution, including executor startup, but exec Param
- * values are only known when the executor is running.
+ * values are only known when the executor is running.  We also support
+ * pruning using any stable expression which does not contain any Vars.
+ * Immutable expressions would have been evaluated to a Const during planning,
+ * so plan-time pruning would have taken care of any pruning.  It's not
+ * possible for pruning to take place using volatile expressions.
  *
  * For external Params we may be able to prune away unneeded partitions
  * during executor startup.  This has the added benefit of not having to
@@ -1418,6 +1422,7 @@ ExecSetupPartitionPruneState(PlanState *planstate, List *partitionpruneinfo)
 	prunestate->num_partprunedata = list_length(partitionpruneinfo);
 	prunestate->extparams = NULL;
 	prunestate->execparams = NULL;
+	prunestate->hasparamlessexprs = false;
 
 	/*
 	 * Create a sub memory context which we'll use when making calls to the
@@ -1513,6 +1518,7 @@ ExecSetupPartitionPruneState(PlanState *planstate, List *partitionpruneinfo)
 		pprune->pruning_steps = pinfo->pruning_steps;
 		pprune->extparams = bms_copy(pinfo->extparams);
 		pprune->allparams = bms_union(pinfo->extparams, pinfo->execparams);
+		pprune->hasparamlessexprs = pinfo->hasparamlessexprs;
 
 		/*
 		 * Accumulate the paramids which match the partitioned keys of all
@@ -1524,6 +1530,8 @@ ExecSetupPartitionPruneState(PlanState *planstate, List *partitionpruneinfo)
 		prunestate->execparams = bms_add_members(prunestate->execparams,
 												 pinfo->execparams);
 
+		prunestate->hasparamlessexprs |= pinfo->hasparamlessexprs;
+
 		relation_close(rel, NoLock);
 
 		i++;
@@ -1566,10 +1574,11 @@ ExecFindInitialMatchingSubPlans(PartitionPruneState *prunestate, int nsubnodes)
 	Bitmapset  *result = NULL;
 
 	/*
-	 * Ensure there's actually external params, or we've not been called
-	 * already.
+	 * If there are no parameter-less Exprs then ensure there's actually
+	 * external params, or we've not been called already.
 	 */
-	Assert(!bms_is_empty(prunestate->extparams));
+	Assert(prunestate->hasparamlessexprs ||
+		   !bms_is_empty(prunestate->extparams));
 
 	pprune = prunestate->partprunedata;
 
@@ -1739,14 +1748,14 @@ find_subplans_for_params_recurse(PartitionPruneState *prunestate,
 
 	/*
 	 * We only need to determine the matching partitions if there are any
-	 * params matching the partition key at this level.  If there are no
-	 * matching params, then we can simply return all subnodes which belong to
-	 * this parent partition.  The planner should have already determined
-	 * these to be the minimum possible set.  We must still recursively visit
-	 * any subpartitioned tables as we may find their partition keys match
-	 * some Params at their level.
+	 * params matching the partition key at this level, or if there are any
+	 * parameter-less expressions matching the partition key.  However, if
+	 * it's just parameter-less expressions then we only prune during
+	 * ExecFindInitialMatchingSubPlans, there's no point in doing this from
+	 * ExecFindMatchingSubPlans too, once is enough.
 	 */
-	if (!bms_is_empty(pruneparams))
+	if ((!allparams && pprune->hasparamlessexprs) ||
+		!bms_is_empty(pruneparams))
 	{
 		context->safeparams = pruneparams;
 		partset = get_matching_partitions(context,
diff --git a/src/backend/executor/nodeAppend.c b/src/backend/executor/nodeAppend.c
index 6bc3e470bf..275254aa65 100644
--- a/src/backend/executor/nodeAppend.c
+++ b/src/backend/executor/nodeAppend.c
@@ -139,10 +139,11 @@ ExecInitAppend(Append *node, EState *estate, int eflags)
 												  node->part_prune_infos);
 
 		/*
-		 * When there are external params matching the partition key we may be
-		 * able to prune away Append subplans now.
+		 * When there are parameter-less exprs or any external params matching
+		 * the partition key we may be able to prune away Append subplans now.
 		 */
-		if (!bms_is_empty(prunestate->extparams))
+		if (prunestate->hasparamlessexprs ||
+			!bms_is_empty(prunestate->extparams))
 		{
 			/* Determine which subplans match the external params */
 			validsubplans = ExecFindInitialMatchingSubPlans(prunestate,
diff --git a/src/backend/nodes/copyfuncs.c b/src/backend/nodes/copyfuncs.c
index 7c045a7afe..78b737b2b9 100644
--- a/src/backend/nodes/copyfuncs.c
+++ b/src/backend/nodes/copyfuncs.c
@@ -2174,6 +2174,7 @@ _copyPartitionPruneInfo(const PartitionPruneInfo *from)
 	COPY_SCALAR_FIELD(reloid);
 	COPY_NODE_FIELD(pruning_steps);
 	COPY_BITMAPSET_FIELD(present_parts);
+	COPY_SCALAR_FIELD(hasparamlessexprs);
 	COPY_SCALAR_FIELD(nparts);
 	COPY_POINTER_FIELD(subnode_map, from->nparts * sizeof(int));
 	COPY_POINTER_FIELD(subpart_map, from->nparts * sizeof(int));
diff --git a/src/backend/nodes/outfuncs.c b/src/backend/nodes/outfuncs.c
index 610f9edaf5..846055d68d 100644
--- a/src/backend/nodes/outfuncs.c
+++ b/src/backend/nodes/outfuncs.c
@@ -1741,6 +1741,7 @@ _outPartitionPruneInfo(StringInfo str, const PartitionPruneInfo *node)
 	WRITE_OID_FIELD(reloid);
 	WRITE_NODE_FIELD(pruning_steps);
 	WRITE_BITMAPSET_FIELD(present_parts);
+	WRITE_BOOL_FIELD(hasparamlessexprs);
 	WRITE_INT_FIELD(nparts);
 
 	appendStringInfoString(str, " :subnode_map");
diff --git a/src/backend/nodes/readfuncs.c b/src/backend/nodes/readfuncs.c
index 2826cec2f8..67f30f431e 100644
--- a/src/backend/nodes/readfuncs.c
+++ b/src/backend/nodes/readfuncs.c
@@ -1362,6 +1362,7 @@ _readPartitionPruneInfo(void)
 	READ_OID_FIELD(reloid);
 	READ_NODE_FIELD(pruning_steps);
 	READ_BITMAPSET_FIELD(present_parts);
+	READ_BOOL_FIELD(hasparamlessexprs);
 	READ_INT_FIELD(nparts);
 	READ_INT_ARRAY(subnode_map, local_node->nparts);
 	READ_INT_ARRAY(subpart_map, local_node->nparts);
diff --git a/src/backend/partitioning/partprune.c b/src/backend/partitioning/partprune.c
index 58ec2a684d..cb2969403d 100644
--- a/src/backend/partitioning/partprune.c
+++ b/src/backend/partitioning/partprune.c
@@ -53,6 +53,7 @@
 #include "optimizer/planner.h"
 #include "optimizer/predtest.h"
 #include "optimizer/prep.h"
+#include "optimizer/var.h"
 #include "partitioning/partprune.h"
 #include "partitioning/partbounds.h"
 #include "rewrite/rewriteManip.h"
@@ -115,6 +116,24 @@ typedef struct PruneStepResult
 	bool		scan_null;		/* Scan the partition for NULL values? */
 } PruneStepResult;
 
+/*
+ * expression_tree_walker context struct for gathering paramids of params
+ * matching the partition key.
+ */
+typedef struct PullParamContext
+{
+	Bitmapset *extparams;
+	Bitmapset *execparams;
+} PullParamContext;
+
+/*
+ * expression_tree_walker context struct for checking if an Expr contains any
+ * Params not listed in 'safeparams'.
+ */
+typedef struct SafeParamContext
+{
+	Bitmapset *safeparams;
+} SafeParamContext;
 
 static List *gen_partprune_steps(RelOptInfo *rel, List *clauses,
 					bool *contradictory);
@@ -162,6 +181,8 @@ static PruneStepResult *get_matching_list_bounds(PartitionPruneContext *context,
 static PruneStepResult *get_matching_range_bounds(PartitionPruneContext *context,
 						  StrategyNumber opstrategy, Datum *values, int nvalues,
 						  FmgrInfo *partsupfunc, Bitmapset *nullkeys);
+static void pull_params(Expr *expr, PartitionPruneInfo *pinfo);
+static bool pull_params_walker(Node *node, PullParamContext *context);
 static bool pull_partkey_params(PartitionPruneInfo *pinfo, List *steps);
 static PruneStepResult *perform_pruning_base_step(PartitionPruneContext *context,
 						  PartitionPruneStepOp *opstep);
@@ -172,6 +193,9 @@ static bool match_boolean_partition_clause(Oid partopfamily, Expr *clause,
 							   Expr *partkey, Expr **outconst);
 static bool partkey_datum_from_expr(PartitionPruneContext *context,
 						Expr *expr, int stateidx, Datum *value);
+static bool contains_only_safeparams_walker(Node *node,
+								SafeParamContext *context);
+static bool contains_only_safeparams(Expr *expr, Bitmapset *safeparams);
 
 /*
  * make_partition_pruneinfo
@@ -197,7 +221,7 @@ make_partition_pruneinfo(PlannerInfo *root, List *partition_rels,
 	int		   *relid_subnode_map;
 	int		   *relid_subpart_map;
 	int			i;
-	bool		gotparam = false;
+	bool		gotnonconst = false;
 
 	/*
 	 * Allocate two arrays to store the 1-based indexes of the 'subpaths' and
@@ -326,11 +350,12 @@ make_partition_pruneinfo(PlannerInfo *root, List *partition_rels,
 		pinfo->subpart_map = subpart_map;
 
 		/*
-		 * Extract Params matching partition key and record if we got any.
-		 * We'll not bother enabling run-time pruning if no params matched the
-		 * partition key at any level of partitioning.
+		 * Extract Params matching partition key and record if any steps
+		 * compare a non-Const value to the partition key.  If everything
+		 * is Const then we've no need to perform run-time pruning as the
+		 * planner will have already selected the minimum set of partitions.
 		 */
-		gotparam |= pull_partkey_params(pinfo, pruning_steps);
+		gotnonconst |= pull_partkey_params(pinfo, pruning_steps);
 
 		pinfolist = lappend(pinfolist, pinfo);
 	}
@@ -338,14 +363,11 @@ make_partition_pruneinfo(PlannerInfo *root, List *partition_rels,
 	pfree(relid_subnode_map);
 	pfree(relid_subpart_map);
 
-	if (gotparam)
+	/* Enable pruning if we got any non-Consts */
+	if (gotnonconst)
 		return pinfolist;
 
-	/*
-	 * If no Params were found to match the partition key on any of the
-	 * partitioned relations then there's no point doing any run-time
-	 * partition pruning.
-	 */
+	/* Run-time pruning would be useless */
 	return NIL;
 }
 
@@ -1478,6 +1500,11 @@ match_clause_to_partition_key(RelOptInfo *rel,
 		if (contain_volatile_functions((Node *) expr))
 			return PARTCLAUSE_UNSUPPORTED;
 
+		/* We can't prune using an expression with Vars */
+		/* XXX this only checks for vars at level 0, We need to disable any Var */
+		if (contain_var_clause((Node *) expr))
+			return PARTCLAUSE_UNSUPPORTED;
+
 		/*
 		 * Determine the input types of the operator we're considering.
 		 *
@@ -2682,16 +2709,74 @@ get_matching_range_bounds(PartitionPruneContext *context,
 	return result;
 }
 
+/*
+ * pull_params
+ *		Determine all external and exec params in 'expr' and add the found
+ *		paramids to the appropriate 'pinfo' field.  pinfo's hasparamlessexprs
+ *		field is set if any non-Const expression is found which have no
+ *		parameters.
+ */
+static void
+pull_params(Expr *expr, PartitionPruneInfo *pinfo)
+{
+	PullParamContext context;
+
+	context.extparams = NULL;
+	context.execparams = NULL;
+
+	pull_params_walker((Node *) expr, &context);
+
+	pinfo->extparams = bms_add_members(pinfo->extparams, context.extparams);
+	pinfo->execparams = bms_add_members(pinfo->execparams,
+										context.execparams);
+
+	/* Mark that an Expr has been seen which contains no Params */
+	if (!context.extparams && !context.execparams)
+		pinfo->hasparamlessexprs = true;
+}
+
+static bool
+pull_params_walker(Node *node, PullParamContext *context)
+{
+	if (node == NULL)
+		return false;
+	if (IsA(node, Param))
+	{
+		Param	   *param = (Param *) node;
+
+		switch (param->paramkind)
+		{
+			case PARAM_EXTERN:
+				context->extparams = bms_add_member(context->extparams,
+													param->paramid);
+				break;
+			case PARAM_EXEC:
+				context->execparams = bms_add_member(context->execparams,
+													 param->paramid);
+				break;
+
+			default:
+				elog(ERROR, "unrecognized paramkind: %d",
+					 (int) param->paramkind);
+				break;
+		}
+	}
+	return expression_tree_walker(node, pull_params_walker,
+								  (void *) context);
+}
+
 /*
  * pull_partkey_params
  *		Loop through each pruning step and record each external and exec
  *		Params being compared to the partition keys.
+ *
+ * Returns true if any non-const value is being compared to the partition key.
  */
 static bool
 pull_partkey_params(PartitionPruneInfo *pinfo, List *steps)
 {
 	ListCell   *lc;
-	bool		gotone = false;
+	bool		gotnonconst = false;
 
 	foreach(lc, steps)
 	{
@@ -2705,32 +2790,15 @@ pull_partkey_params(PartitionPruneInfo *pinfo, List *steps)
 		{
 			Expr	   *expr = lfirst(lc2);
 
-			if (IsA(expr, Param))
-			{
-				Param	   *param = (Param *) expr;
-
-				switch (param->paramkind)
-				{
-					case PARAM_EXTERN:
-						pinfo->extparams = bms_add_member(pinfo->extparams,
-														  param->paramid);
-						break;
-					case PARAM_EXEC:
-						pinfo->execparams = bms_add_member(pinfo->execparams,
-														   param->paramid);
-						break;
+			if (IsA(expr, Const))
+				continue;
 
-					default:
-						elog(ERROR, "unrecognized paramkind: %d",
-							 (int) param->paramkind);
-						break;
-				}
-				gotone = true;
-			}
+			gotnonconst = true;
+			pull_params(expr, pinfo);
 		}
 	}
 
-	return gotone;
+	return gotnonconst;
 }
 
 /*
@@ -3031,38 +3099,62 @@ static bool
 partkey_datum_from_expr(PartitionPruneContext *context,
 						Expr *expr, int stateidx, Datum *value)
 {
-	switch (nodeTag(expr))
+	if (IsA(expr, Const))
+	{
+		*value = ((Const *) expr)->constvalue;
+		return true;
+	}
+	else
 	{
-		case T_Const:
-			*value = ((Const *) expr)->constvalue;
+		/*
+		 * When being called during planning constant folding the Param's
+		 * value.
+		 */
+		if (context->planstate &&
+			contains_only_safeparams(expr, context->safeparams))
+		{
+			ExprState  *exprstate;
+			ExprContext *ectx;
+			bool		isNull;
+
+			/* Exprs with volatile functions shouldn't make it here */
+			Assert(!contain_volatile_functions((Node *) expr));
+
+			exprstate = context->exprstates[stateidx];
+			ectx = context->planstate->ps_ExprContext;
+			*value = ExecEvalExprSwitchContext(exprstate, ectx, &isNull);
+			if (isNull)
+				return false;
+
 			return true;
+		}
+	}
 
-		case T_Param:
+	return false;
+}
 
-			/*
-			 * When being called from the executor we may be able to evaluate
-			 * the Param's value.
-			 */
-			if (context->planstate &&
-				bms_is_member(((Param *) expr)->paramid, context->safeparams))
-			{
-				ExprState  *exprstate;
-				ExprContext *ectx;
-				bool		isNull;
+static bool
+contains_only_safeparams(Expr *expr, Bitmapset *safeparams)
+{
+	SafeParamContext context;
 
-				exprstate = context->exprstates[stateidx];
-				ectx = context->planstate->ps_ExprContext;
-				*value = ExecEvalExprSwitchContext(exprstate, ectx, &isNull);
-				if (isNull)
-					return false;
+	context.safeparams = safeparams;
 
-				return true;
-			}
-			break;
+	return contains_only_safeparams_walker((Node *) expr, &context);
+}
 
-		default:
-			break;
+static bool
+contains_only_safeparams_walker(Node *node, SafeParamContext *context)
+{
+	if (node == NULL)
+		return false;
+	if (IsA(node, Param))
+	{
+		Param *param = (Param *) node;
+		return bms_is_member(param->paramid, context->safeparams);
 	}
+	(void) expression_tree_walker(node, contains_only_safeparams_walker,
+								  (void *) context);
 
-	return false;
+	return true;
 }
diff --git a/src/include/executor/execPartition.h b/src/include/executor/execPartition.h
index fc6e9574e3..a48cf72d8c 100644
--- a/src/include/executor/execPartition.h
+++ b/src/include/executor/execPartition.h
@@ -136,6 +136,8 @@ typedef struct PartitionTupleRouting
  * extparams					Contains paramids of external params found
  *								matching partition keys in 'pruning_steps'.
  * allparams					As 'extparams' but also including exec params.
+ * hasparamlessexprs			Some pruning steps contain Exprs without any
+ *								Params.
  *-----------------------
  */
 typedef struct PartitionPruningData
@@ -147,6 +149,7 @@ typedef struct PartitionPruningData
 	List	   *pruning_steps;
 	Bitmapset  *extparams;
 	Bitmapset  *allparams;
+	bool		hasparamlessexprs;
 } PartitionPruningData;
 
 /*-----------------------
@@ -163,6 +166,7 @@ typedef struct PartitionPruningData
  *						partitioned relation. First element contains the
  *						details for the target partitioned table.
  * num_partprunedata	Number of items in 'partprunedata' array.
+ * hasparamlessexprs	Some pruning steps contain Exprs without any Params.
  * prune_context		A memory context which can be used to call the query
  *						planner's partition prune functions.
  * extparams			All PARAM_EXTERN paramids which were found to match a
@@ -177,6 +181,7 @@ typedef struct PartitionPruneState
 {
 	PartitionPruningData *partprunedata;
 	int			num_partprunedata;
+	bool		hasparamlessexprs;
 	MemoryContext prune_context;
 	Bitmapset  *extparams;
 	Bitmapset  *execparams;
diff --git a/src/include/nodes/primnodes.h b/src/include/nodes/primnodes.h
index f90aa7b2a1..aae102126f 100644
--- a/src/include/nodes/primnodes.h
+++ b/src/include/nodes/primnodes.h
@@ -1597,6 +1597,8 @@ typedef struct PartitionPruneInfo
 	List	   *pruning_steps;	/* List of PartitionPruneStep */
 	Bitmapset  *present_parts;	/* Indexes of all partitions which subnodes
 								 * are present for. */
+	bool		hasparamlessexprs;	/* True if Exprs exist which don't contain
+									 * any Params */
 	int			nparts;			/* The length of the following two arrays */
 	int		   *subnode_map;	/* subnode index by partition id, or -1 */
 	int		   *subpart_map;	/* subpart index by partition id, or -1 */
diff --git a/src/test/regress/expected/partition_prune.out b/src/test/regress/expected/partition_prune.out
index cf331e79c1..64b4e933d6 100644
--- a/src/test/regress/expected/partition_prune.out
+++ b/src/test/regress/expected/partition_prune.out
@@ -1835,6 +1835,54 @@ fetch backward all from cur;
 (2 rows)
 
 commit;
+begin;
+-- Test run-time pruning using stable functions
+create function list_part_fn(int) returns int as $$ begin return $1; end;$$ language plpgsql stable;
+-- Ensure pruning works using a stable function containing no Vars
+explain (analyze, costs off, summary off, timing off) select * from list_part where a = list_part_fn(1);
+                      QUERY PLAN                      
+------------------------------------------------------
+ Append (actual rows=1 loops=1)
+   Subplans Removed: 3
+   ->  Seq Scan on list_part1 (actual rows=1 loops=1)
+         Filter: (a = list_part_fn(1))
+(4 rows)
+
+-- Ensure pruning does not take place when the function contains a Var parameter
+explain (analyze, costs off, summary off, timing off) select * from list_part where a = list_part_fn(a);
+                      QUERY PLAN                      
+------------------------------------------------------
+ Append (actual rows=4 loops=1)
+   ->  Seq Scan on list_part1 (actual rows=1 loops=1)
+         Filter: (a = list_part_fn(a))
+   ->  Seq Scan on list_part2 (actual rows=1 loops=1)
+         Filter: (a = list_part_fn(a))
+   ->  Seq Scan on list_part3 (actual rows=1 loops=1)
+         Filter: (a = list_part_fn(a))
+   ->  Seq Scan on list_part4 (actual rows=1 loops=1)
+         Filter: (a = list_part_fn(a))
+(9 rows)
+
+-- Ensure pruning does not take place when the expression contains a Var.
+explain (analyze, costs off, summary off, timing off) select * from list_part where a = list_part_fn(1) + a;
+                      QUERY PLAN                      
+------------------------------------------------------
+ Append (actual rows=0 loops=1)
+   ->  Seq Scan on list_part1 (actual rows=0 loops=1)
+         Filter: (a = (list_part_fn(1) + a))
+         Rows Removed by Filter: 1
+   ->  Seq Scan on list_part2 (actual rows=0 loops=1)
+         Filter: (a = (list_part_fn(1) + a))
+         Rows Removed by Filter: 1
+   ->  Seq Scan on list_part3 (actual rows=0 loops=1)
+         Filter: (a = (list_part_fn(1) + a))
+         Rows Removed by Filter: 1
+   ->  Seq Scan on list_part4 (actual rows=0 loops=1)
+         Filter: (a = (list_part_fn(1) + a))
+         Rows Removed by Filter: 1
+(13 rows)
+
+rollback;
 drop table list_part;
 -- Parallel append
 -- Suppress the number of loops each parallel node runs for.  This is because
@@ -2079,6 +2127,40 @@ select explain_parallel_append('select avg(ab.a) from ab inner join lprt_a a on
                                  Index Cond: (a = a.a)
 (27 rows)
 
+-- Ensure the same partitions are pruned when we make the nested loop
+-- parameter an Expr rather than a plain Param.
+select explain_parallel_append('select avg(ab.a) from ab inner join lprt_a a on ab.a = a.a + 0 where a.a in(0, 0, 1)');
+                                      explain_parallel_append                                      
+---------------------------------------------------------------------------------------------------
+ Finalize Aggregate (actual rows=1 loops=1)
+   ->  Gather (actual rows=2 loops=1)
+         Workers Planned: 1
+         Workers Launched: 1
+         ->  Partial Aggregate (actual rows=1 loops=2)
+               ->  Nested Loop (actual rows=0 loops=2)
+                     ->  Parallel Seq Scan on lprt_a a (actual rows=51 loops=N)
+                           Filter: (a = ANY ('{0,0,1}'::integer[]))
+                     ->  Append (actual rows=0 loops=102)
+                           ->  Index Scan using ab_a1_b1_a_idx on ab_a1_b1 (actual rows=0 loops=2)
+                                 Index Cond: (a = (a.a + 0))
+                           ->  Index Scan using ab_a1_b2_a_idx on ab_a1_b2 (actual rows=0 loops=2)
+                                 Index Cond: (a = (a.a + 0))
+                           ->  Index Scan using ab_a1_b3_a_idx on ab_a1_b3 (actual rows=0 loops=2)
+                                 Index Cond: (a = (a.a + 0))
+                           ->  Index Scan using ab_a2_b1_a_idx on ab_a2_b1 (never executed)
+                                 Index Cond: (a = (a.a + 0))
+                           ->  Index Scan using ab_a2_b2_a_idx on ab_a2_b2 (never executed)
+                                 Index Cond: (a = (a.a + 0))
+                           ->  Index Scan using ab_a2_b3_a_idx on ab_a2_b3 (never executed)
+                                 Index Cond: (a = (a.a + 0))
+                           ->  Index Scan using ab_a3_b1_a_idx on ab_a3_b1 (never executed)
+                                 Index Cond: (a = (a.a + 0))
+                           ->  Index Scan using ab_a3_b2_a_idx on ab_a3_b2 (never executed)
+                                 Index Cond: (a = (a.a + 0))
+                           ->  Index Scan using ab_a3_b3_a_idx on ab_a3_b3 (never executed)
+                                 Index Cond: (a = (a.a + 0))
+(27 rows)
+
 insert into lprt_a values(3),(3);
 select explain_parallel_append('select avg(ab.a) from ab inner join lprt_a a on ab.a = a.a where a.a in(1, 0, 3)');
                                       explain_parallel_append                                      
diff --git a/src/test/regress/sql/partition_prune.sql b/src/test/regress/sql/partition_prune.sql
index 1464f4dcd9..b6681fa44c 100644
--- a/src/test/regress/sql/partition_prune.sql
+++ b/src/test/regress/sql/partition_prune.sql
@@ -396,6 +396,22 @@ fetch backward all from cur;
 
 commit;
 
+begin;
+
+-- Test run-time pruning using stable functions
+create function list_part_fn(int) returns int as $$ begin return $1; end;$$ language plpgsql stable;
+
+-- Ensure pruning works using a stable function containing no Vars
+explain (analyze, costs off, summary off, timing off) select * from list_part where a = list_part_fn(1);
+
+-- Ensure pruning does not take place when the function contains a Var parameter
+explain (analyze, costs off, summary off, timing off) select * from list_part where a = list_part_fn(a);
+
+-- Ensure pruning does not take place when the expression contains a Var.
+explain (analyze, costs off, summary off, timing off) select * from list_part where a = list_part_fn(1) + a;
+
+rollback;
+
 drop table list_part;
 
 -- Parallel append
@@ -486,6 +502,10 @@ set enable_mergejoin = 0;
 
 select explain_parallel_append('select avg(ab.a) from ab inner join lprt_a a on ab.a = a.a where a.a in(0, 0, 1)');
 
+-- Ensure the same partitions are pruned when we make the nested loop
+-- parameter an Expr rather than a plain Param.
+select explain_parallel_append('select avg(ab.a) from ab inner join lprt_a a on ab.a = a.a + 0 where a.a in(0, 0, 1)');
+
 insert into lprt_a values(3),(3);
 
 select explain_parallel_append('select avg(ab.a) from ab inner join lprt_a a on ab.a = a.a where a.a in(1, 0, 3)');

diff --git a/src/backend/executor/execPartition.c b/src/backend/executor/execPartition.c
index c83991c93c..f9a812480d 100644
--- a/src/backend/executor/execPartition.c
+++ b/src/backend/executor/execPartition.c
@@ -1349,7 +1349,11 @@ adjust_partition_tlist(List *tlist, TupleConversionMap *map)
  * difference between these that we need to concern ourselves with is the
  * time when the values of the Params are known.  External Param values are
  * known at any time of execution, including executor startup, but exec Param
- * values are only known when the executor is running.
+ * values are only known when the executor is running.  We also support
+ * pruning using any stable expression which does not contain any Vars.
+ * Immutable expressions would have been evaluated to a Const during planning,
+ * so plan-time pruning would have taken care of any pruning.  It's not
+ * possible for pruning to take place using volatile expressions.
  *
  * For external Params we may be able to prune away unneeded partitions
  * during executor startup.  This has the added benefit of not having to
@@ -1418,6 +1422,7 @@ ExecSetupPartitionPruneState(PlanState *planstate, List *partitionpruneinfo)
 	prunestate->num_partprunedata = list_length(partitionpruneinfo);
 	prunestate->extparams = NULL;
 	prunestate->execparams = NULL;
+	prunestate->hasparamlessexprs = false;
 
 	/*
 	 * Create a sub memory context which we'll use when making calls to the
@@ -1513,6 +1518,7 @@ ExecSetupPartitionPruneState(PlanState *planstate, List *partitionpruneinfo)
 		pprune->pruning_steps = pinfo->pruning_steps;
 		pprune->extparams = bms_copy(pinfo->extparams);
 		pprune->allparams = bms_union(pinfo->extparams, pinfo->execparams);
+		pprune->hasparamlessexprs = pinfo->hasparamlessexprs;
 
 		/*
 		 * Accumulate the paramids which match the partitioned keys of all
@@ -1524,6 +1530,8 @@ ExecSetupPartitionPruneState(PlanState *planstate, List *partitionpruneinfo)
 		prunestate->execparams = bms_add_members(prunestate->execparams,
 												 pinfo->execparams);
 
+		prunestate->hasparamlessexprs |= pinfo->hasparamlessexprs;
+
 		relation_close(rel, NoLock);
 
 		i++;
@@ -1566,10 +1574,11 @@ ExecFindInitialMatchingSubPlans(PartitionPruneState *prunestate, int nsubnodes)
 	Bitmapset  *result = NULL;
 
 	/*
-	 * Ensure there's actually external params, or we've not been called
-	 * already.
+	 * If there are no parameter-less Exprs then ensure there's actually
+	 * external params, or we've not been called already.
 	 */
-	Assert(!bms_is_empty(prunestate->extparams));
+	Assert(prunestate->hasparamlessexprs ||
+		   !bms_is_empty(prunestate->extparams));
 
 	pprune = prunestate->partprunedata;
 
@@ -1739,14 +1748,14 @@ find_subplans_for_params_recurse(PartitionPruneState *prunestate,
 
 	/*
 	 * We only need to determine the matching partitions if there are any
-	 * params matching the partition key at this level.  If there are no
-	 * matching params, then we can simply return all subnodes which belong to
-	 * this parent partition.  The planner should have already determined
-	 * these to be the minimum possible set.  We must still recursively visit
-	 * any subpartitioned tables as we may find their partition keys match
-	 * some Params at their level.
+	 * params matching the partition key at this level, or if there are any
+	 * parameter-less expressions matching the partition key.  However, if
+	 * it's just parameter-less expressions then we only prune during
+	 * ExecFindInitialMatchingSubPlans, there's no point in doing this from
+	 * ExecFindMatchingSubPlans too, once is enough.
 	 */
-	if (!bms_is_empty(pruneparams))
+	if ((!allparams && pprune->hasparamlessexprs) ||
+		!bms_is_empty(pruneparams))
 	{
 		context->safeparams = pruneparams;
 		partset = get_matching_partitions(context,
diff --git a/src/backend/executor/nodeAppend.c b/src/backend/executor/nodeAppend.c
index 6bc3e470bf..275254aa65 100644
--- a/src/backend/executor/nodeAppend.c
+++ b/src/backend/executor/nodeAppend.c
@@ -139,10 +139,11 @@ ExecInitAppend(Append *node, EState *estate, int eflags)
 												  node->part_prune_infos);
 
 		/*
-		 * When there are external params matching the partition key we may be
-		 * able to prune away Append subplans now.
+		 * When there are parameter-less exprs or any external params matching
+		 * the partition key we may be able to prune away Append subplans now.
 		 */
-		if (!bms_is_empty(prunestate->extparams))
+		if (prunestate->hasparamlessexprs ||
+			!bms_is_empty(prunestate->extparams))
 		{
 			/* Determine which subplans match the external params */
 			validsubplans = ExecFindInitialMatchingSubPlans(prunestate,
diff --git a/src/backend/nodes/copyfuncs.c b/src/backend/nodes/copyfuncs.c
index 7c045a7afe..78b737b2b9 100644
--- a/src/backend/nodes/copyfuncs.c
+++ b/src/backend/nodes/copyfuncs.c
@@ -2174,6 +2174,7 @@ _copyPartitionPruneInfo(const PartitionPruneInfo *from)
 	COPY_SCALAR_FIELD(reloid);
 	COPY_NODE_FIELD(pruning_steps);
 	COPY_BITMAPSET_FIELD(present_parts);
+	COPY_SCALAR_FIELD(hasparamlessexprs);
 	COPY_SCALAR_FIELD(nparts);
 	COPY_POINTER_FIELD(subnode_map, from->nparts * sizeof(int));
 	COPY_POINTER_FIELD(subpart_map, from->nparts * sizeof(int));
diff --git a/src/backend/nodes/outfuncs.c b/src/backend/nodes/outfuncs.c
index 610f9edaf5..846055d68d 100644
--- a/src/backend/nodes/outfuncs.c
+++ b/src/backend/nodes/outfuncs.c
@@ -1741,6 +1741,7 @@ _outPartitionPruneInfo(StringInfo str, const PartitionPruneInfo *node)
 	WRITE_OID_FIELD(reloid);
 	WRITE_NODE_FIELD(pruning_steps);
 	WRITE_BITMAPSET_FIELD(present_parts);
+	WRITE_BOOL_FIELD(hasparamlessexprs);
 	WRITE_INT_FIELD(nparts);
 
 	appendStringInfoString(str, " :subnode_map");
diff --git a/src/backend/nodes/readfuncs.c b/src/backend/nodes/readfuncs.c
index 2826cec2f8..67f30f431e 100644
--- a/src/backend/nodes/readfuncs.c
+++ b/src/backend/nodes/readfuncs.c
@@ -1362,6 +1362,7 @@ _readPartitionPruneInfo(void)
 	READ_OID_FIELD(reloid);
 	READ_NODE_FIELD(pruning_steps);
 	READ_BITMAPSET_FIELD(present_parts);
+	READ_BOOL_FIELD(hasparamlessexprs);
 	READ_INT_FIELD(nparts);
 	READ_INT_ARRAY(subnode_map, local_node->nparts);
 	READ_INT_ARRAY(subpart_map, local_node->nparts);
diff --git a/src/backend/partitioning/partprune.c b/src/backend/partitioning/partprune.c
index 58ec2a684d..ebc9e90ed8 100644
--- a/src/backend/partitioning/partprune.c
+++ b/src/backend/partitioning/partprune.c
@@ -53,6 +53,7 @@
 #include "optimizer/planner.h"
 #include "optimizer/predtest.h"
 #include "optimizer/prep.h"
+#include "optimizer/var.h"
 #include "partitioning/partprune.h"
 #include "partitioning/partbounds.h"
 #include "rewrite/rewriteManip.h"
@@ -115,6 +116,24 @@ typedef struct PruneStepResult
 	bool		scan_null;		/* Scan the partition for NULL values? */
 } PruneStepResult;
 
+/*
+ * expression_tree_walker context struct for gathering paramids of params
+ * matching the partition key.
+ */
+typedef struct PullParamContext
+{
+	Bitmapset *extparams;
+	Bitmapset *execparams;
+} PullParamContext;
+
+/*
+ * expression_tree_walker context struct for checking if an Expr contains any
+ * Params not listed in 'safeparams'.
+ */
+typedef struct SafeParamContext
+{
+	Bitmapset *safeparams;
+} SafeParamContext;
 
 static List *gen_partprune_steps(RelOptInfo *rel, List *clauses,
 					bool *contradictory);
@@ -162,6 +181,8 @@ static PruneStepResult *get_matching_list_bounds(PartitionPruneContext *context,
 static PruneStepResult *get_matching_range_bounds(PartitionPruneContext *context,
 						  StrategyNumber opstrategy, Datum *values, int nvalues,
 						  FmgrInfo *partsupfunc, Bitmapset *nullkeys);
+static void pull_params(Expr *expr, PartitionPruneInfo *pinfo);
+static bool pull_params_walker(Node *node, PullParamContext *context);
 static bool pull_partkey_params(PartitionPruneInfo *pinfo, List *steps);
 static PruneStepResult *perform_pruning_base_step(PartitionPruneContext *context,
 						  PartitionPruneStepOp *opstep);
@@ -172,6 +193,9 @@ static bool match_boolean_partition_clause(Oid partopfamily, Expr *clause,
 							   Expr *partkey, Expr **outconst);
 static bool partkey_datum_from_expr(PartitionPruneContext *context,
 						Expr *expr, int stateidx, Datum *value);
+static bool contains_unsafeparams(Expr *expr, Bitmapset *safeparams);
+static bool contains_unsafeparams_walker(Node *node,
+							 SafeParamContext *context);
 
 /*
  * make_partition_pruneinfo
@@ -197,7 +221,7 @@ make_partition_pruneinfo(PlannerInfo *root, List *partition_rels,
 	int		   *relid_subnode_map;
 	int		   *relid_subpart_map;
 	int			i;
-	bool		gotparam = false;
+	bool		gotnonconst = false;
 
 	/*
 	 * Allocate two arrays to store the 1-based indexes of the 'subpaths' and
@@ -326,11 +350,12 @@ make_partition_pruneinfo(PlannerInfo *root, List *partition_rels,
 		pinfo->subpart_map = subpart_map;
 
 		/*
-		 * Extract Params matching partition key and record if we got any.
-		 * We'll not bother enabling run-time pruning if no params matched the
-		 * partition key at any level of partitioning.
+		 * Extract Params matching partition key and record if any steps
+		 * compare a non-Const value to the partition key.  If everything
+		 * is Const then we've no need to perform run-time pruning as the
+		 * planner will have already selected the minimum set of partitions.
 		 */
-		gotparam |= pull_partkey_params(pinfo, pruning_steps);
+		gotnonconst |= pull_partkey_params(pinfo, pruning_steps);
 
 		pinfolist = lappend(pinfolist, pinfo);
 	}
@@ -338,14 +363,11 @@ make_partition_pruneinfo(PlannerInfo *root, List *partition_rels,
 	pfree(relid_subnode_map);
 	pfree(relid_subpart_map);
 
-	if (gotparam)
+	/* Enable pruning if we got any non-Consts */
+	if (gotnonconst)
 		return pinfolist;
 
-	/*
-	 * If no Params were found to match the partition key on any of the
-	 * partitioned relations then there's no point doing any run-time
-	 * partition pruning.
-	 */
+	/* Run-time pruning would be useless */
 	return NIL;
 }
 
@@ -1478,6 +1500,10 @@ match_clause_to_partition_key(RelOptInfo *rel,
 		if (contain_volatile_functions((Node *) expr))
 			return PARTCLAUSE_UNSUPPORTED;
 
+		/* We can't prune using an expression with Vars. */
+		if (contain_var_clause((Node *) expr))
+			return PARTCLAUSE_UNSUPPORTED;
+
 		/*
 		 * Determine the input types of the operator we're considering.
 		 *
@@ -2682,16 +2708,74 @@ get_matching_range_bounds(PartitionPruneContext *context,
 	return result;
 }
 
+/*
+ * pull_params
+ *		Determine all external and exec params in 'expr' and add the found
+ *		paramids to the appropriate 'pinfo' field.  pinfo's hasparamlessexprs
+ *		field is set if any non-Const expression is found which have no
+ *		parameters.
+ */
+static void
+pull_params(Expr *expr, PartitionPruneInfo *pinfo)
+{
+	PullParamContext context;
+
+	context.extparams = NULL;
+	context.execparams = NULL;
+
+	pull_params_walker((Node *) expr, &context);
+
+	pinfo->extparams = bms_add_members(pinfo->extparams, context.extparams);
+	pinfo->execparams = bms_add_members(pinfo->execparams,
+										context.execparams);
+
+	/* Mark that an Expr has been seen which contains no Params */
+	if (!context.extparams && !context.execparams)
+		pinfo->hasparamlessexprs = true;
+}
+
+static bool
+pull_params_walker(Node *node, PullParamContext *context)
+{
+	if (node == NULL)
+		return false;
+	if (IsA(node, Param))
+	{
+		Param	   *param = (Param *) node;
+
+		switch (param->paramkind)
+		{
+			case PARAM_EXTERN:
+				context->extparams = bms_add_member(context->extparams,
+													param->paramid);
+				break;
+			case PARAM_EXEC:
+				context->execparams = bms_add_member(context->execparams,
+													 param->paramid);
+				break;
+
+			default:
+				elog(ERROR, "unrecognized paramkind: %d",
+					 (int) param->paramkind);
+				break;
+		}
+	}
+	return expression_tree_walker(node, pull_params_walker,
+								  (void *) context);
+}
+
 /*
  * pull_partkey_params
  *		Loop through each pruning step and record each external and exec
  *		Params being compared to the partition keys.
+ *
+ * Returns true if any non-const value is being compared to the partition key.
  */
 static bool
 pull_partkey_params(PartitionPruneInfo *pinfo, List *steps)
 {
 	ListCell   *lc;
-	bool		gotone = false;
+	bool		gotnonconst = false;
 
 	foreach(lc, steps)
 	{
@@ -2705,32 +2789,15 @@ pull_partkey_params(PartitionPruneInfo *pinfo, List *steps)
 		{
 			Expr	   *expr = lfirst(lc2);
 
-			if (IsA(expr, Param))
-			{
-				Param	   *param = (Param *) expr;
-
-				switch (param->paramkind)
-				{
-					case PARAM_EXTERN:
-						pinfo->extparams = bms_add_member(pinfo->extparams,
-														  param->paramid);
-						break;
-					case PARAM_EXEC:
-						pinfo->execparams = bms_add_member(pinfo->execparams,
-														   param->paramid);
-						break;
+			if (IsA(expr, Const))
+				continue;
 
-					default:
-						elog(ERROR, "unrecognized paramkind: %d",
-							 (int) param->paramkind);
-						break;
-				}
-				gotone = true;
-			}
+			gotnonconst = true;
+			pull_params(expr, pinfo);
 		}
 	}
 
-	return gotone;
+	return gotnonconst;
 }
 
 /*
@@ -3031,38 +3098,64 @@ static bool
 partkey_datum_from_expr(PartitionPruneContext *context,
 						Expr *expr, int stateidx, Datum *value)
 {
-	switch (nodeTag(expr))
+	if (IsA(expr, Const))
+	{
+		*value = ((Const *) expr)->constvalue;
+		return true;
+	}
+	else
 	{
-		case T_Const:
-			*value = ((Const *) expr)->constvalue;
+		/*
+		 * When being called during planning constant folding the Param's
+		 * value.
+		 */
+		if (context->planstate &&
+			!contains_unsafeparams(expr, context->safeparams))
+		{
+			ExprState  *exprstate;
+			ExprContext *ectx;
+			bool		isNull;
+
+			/* Exprs with volatile functions shouldn't make it here */
+			Assert(!contain_volatile_functions((Node *) expr));
+
+			exprstate = context->exprstates[stateidx];
+			ectx = context->planstate->ps_ExprContext;
+			*value = ExecEvalExprSwitchContext(exprstate, ectx, &isNull);
+			if (isNull)
+				return false;
+
 			return true;
+		}
+	}
+
+	return false;
+}
 
-		case T_Param:
+static bool
+contains_unsafeparams(Expr *expr, Bitmapset *safeparams)
+{
+	SafeParamContext context;
 
-			/*
-			 * When being called from the executor we may be able to evaluate
-			 * the Param's value.
-			 */
-			if (context->planstate &&
-				bms_is_member(((Param *) expr)->paramid, context->safeparams))
-			{
-				ExprState  *exprstate;
-				ExprContext *ectx;
-				bool		isNull;
+	context.safeparams = safeparams;
 
-				exprstate = context->exprstates[stateidx];
-				ectx = context->planstate->ps_ExprContext;
-				*value = ExecEvalExprSwitchContext(exprstate, ectx, &isNull);
-				if (isNull)
-					return false;
+	return contains_unsafeparams_walker((Node *) expr, &context);
+}
 
-				return true;
-			}
-			break;
+static bool
+contains_unsafeparams_walker(Node *node, SafeParamContext *context)
+{
+	if (node == NULL)
+		return false;
+	if (IsA(node, Param))
+	{
+		Param *param = (Param *) node;
 
-		default:
-			break;
+		/* if param is not on the safe list then return true */
+		if (!bms_is_member(param->paramid, context->safeparams))
+			return true;
+		return false;		/* keep looking */
 	}
-
-	return false;
+	return expression_tree_walker(node, contains_unsafeparams_walker,
+								  (void *) context);
 }
diff --git a/src/include/executor/execPartition.h b/src/include/executor/execPartition.h
index fc6e9574e3..a48cf72d8c 100644
--- a/src/include/executor/execPartition.h
+++ b/src/include/executor/execPartition.h
@@ -136,6 +136,8 @@ typedef struct PartitionTupleRouting
  * extparams					Contains paramids of external params found
  *								matching partition keys in 'pruning_steps'.
  * allparams					As 'extparams' but also including exec params.
+ * hasparamlessexprs			Some pruning steps contain Exprs without any
+ *								Params.
  *-----------------------
  */
 typedef struct PartitionPruningData
@@ -147,6 +149,7 @@ typedef struct PartitionPruningData
 	List	   *pruning_steps;
 	Bitmapset  *extparams;
 	Bitmapset  *allparams;
+	bool		hasparamlessexprs;
 } PartitionPruningData;
 
 /*-----------------------
@@ -163,6 +166,7 @@ typedef struct PartitionPruningData
  *						partitioned relation. First element contains the
  *						details for the target partitioned table.
  * num_partprunedata	Number of items in 'partprunedata' array.
+ * hasparamlessexprs	Some pruning steps contain Exprs without any Params.
  * prune_context		A memory context which can be used to call the query
  *						planner's partition prune functions.
  * extparams			All PARAM_EXTERN paramids which were found to match a
@@ -177,6 +181,7 @@ typedef struct PartitionPruneState
 {
 	PartitionPruningData *partprunedata;
 	int			num_partprunedata;
+	bool		hasparamlessexprs;
 	MemoryContext prune_context;
 	Bitmapset  *extparams;
 	Bitmapset  *execparams;
diff --git a/src/include/nodes/primnodes.h b/src/include/nodes/primnodes.h
index f90aa7b2a1..aae102126f 100644
--- a/src/include/nodes/primnodes.h
+++ b/src/include/nodes/primnodes.h
@@ -1597,6 +1597,8 @@ typedef struct PartitionPruneInfo
 	List	   *pruning_steps;	/* List of PartitionPruneStep */
 	Bitmapset  *present_parts;	/* Indexes of all partitions which subnodes
 								 * are present for. */
+	bool		hasparamlessexprs;	/* True if Exprs exist which don't contain
+									 * any Params */
 	int			nparts;			/* The length of the following two arrays */
 	int		   *subnode_map;	/* subnode index by partition id, or -1 */
 	int		   *subpart_map;	/* subpart index by partition id, or -1 */
diff --git a/src/test/regress/expected/partition_prune.out b/src/test/regress/expected/partition_prune.out
index cf331e79c1..64b4e933d6 100644
--- a/src/test/regress/expected/partition_prune.out
+++ b/src/test/regress/expected/partition_prune.out
@@ -1835,6 +1835,54 @@ fetch backward all from cur;
 (2 rows)
 
 commit;
+begin;
+-- Test run-time pruning using stable functions
+create function list_part_fn(int) returns int as $$ begin return $1; end;$$ language plpgsql stable;
+-- Ensure pruning works using a stable function containing no Vars
+explain (analyze, costs off, summary off, timing off) select * from list_part where a = list_part_fn(1);
+                      QUERY PLAN                      
+------------------------------------------------------
+ Append (actual rows=1 loops=1)
+   Subplans Removed: 3
+   ->  Seq Scan on list_part1 (actual rows=1 loops=1)
+         Filter: (a = list_part_fn(1))
+(4 rows)
+
+-- Ensure pruning does not take place when the function contains a Var parameter
+explain (analyze, costs off, summary off, timing off) select * from list_part where a = list_part_fn(a);
+                      QUERY PLAN                      
+------------------------------------------------------
+ Append (actual rows=4 loops=1)
+   ->  Seq Scan on list_part1 (actual rows=1 loops=1)
+         Filter: (a = list_part_fn(a))
+   ->  Seq Scan on list_part2 (actual rows=1 loops=1)
+         Filter: (a = list_part_fn(a))
+   ->  Seq Scan on list_part3 (actual rows=1 loops=1)
+         Filter: (a = list_part_fn(a))
+   ->  Seq Scan on list_part4 (actual rows=1 loops=1)
+         Filter: (a = list_part_fn(a))
+(9 rows)
+
+-- Ensure pruning does not take place when the expression contains a Var.
+explain (analyze, costs off, summary off, timing off) select * from list_part where a = list_part_fn(1) + a;
+                      QUERY PLAN                      
+------------------------------------------------------
+ Append (actual rows=0 loops=1)
+   ->  Seq Scan on list_part1 (actual rows=0 loops=1)
+         Filter: (a = (list_part_fn(1) + a))
+         Rows Removed by Filter: 1
+   ->  Seq Scan on list_part2 (actual rows=0 loops=1)
+         Filter: (a = (list_part_fn(1) + a))
+         Rows Removed by Filter: 1
+   ->  Seq Scan on list_part3 (actual rows=0 loops=1)
+         Filter: (a = (list_part_fn(1) + a))
+         Rows Removed by Filter: 1
+   ->  Seq Scan on list_part4 (actual rows=0 loops=1)
+         Filter: (a = (list_part_fn(1) + a))
+         Rows Removed by Filter: 1
+(13 rows)
+
+rollback;
 drop table list_part;
 -- Parallel append
 -- Suppress the number of loops each parallel node runs for.  This is because
@@ -2079,6 +2127,40 @@ select explain_parallel_append('select avg(ab.a) from ab inner join lprt_a a on
                                  Index Cond: (a = a.a)
 (27 rows)
 
+-- Ensure the same partitions are pruned when we make the nested loop
+-- parameter an Expr rather than a plain Param.
+select explain_parallel_append('select avg(ab.a) from ab inner join lprt_a a on ab.a = a.a + 0 where a.a in(0, 0, 1)');
+                                      explain_parallel_append                                      
+---------------------------------------------------------------------------------------------------
+ Finalize Aggregate (actual rows=1 loops=1)
+   ->  Gather (actual rows=2 loops=1)
+         Workers Planned: 1
+         Workers Launched: 1
+         ->  Partial Aggregate (actual rows=1 loops=2)
+               ->  Nested Loop (actual rows=0 loops=2)
+                     ->  Parallel Seq Scan on lprt_a a (actual rows=51 loops=N)
+                           Filter: (a = ANY ('{0,0,1}'::integer[]))
+                     ->  Append (actual rows=0 loops=102)
+                           ->  Index Scan using ab_a1_b1_a_idx on ab_a1_b1 (actual rows=0 loops=2)
+                                 Index Cond: (a = (a.a + 0))
+                           ->  Index Scan using ab_a1_b2_a_idx on ab_a1_b2 (actual rows=0 loops=2)
+                                 Index Cond: (a = (a.a + 0))
+                           ->  Index Scan using ab_a1_b3_a_idx on ab_a1_b3 (actual rows=0 loops=2)
+                                 Index Cond: (a = (a.a + 0))
+                           ->  Index Scan using ab_a2_b1_a_idx on ab_a2_b1 (never executed)
+                                 Index Cond: (a = (a.a + 0))
+                           ->  Index Scan using ab_a2_b2_a_idx on ab_a2_b2 (never executed)
+                                 Index Cond: (a = (a.a + 0))
+                           ->  Index Scan using ab_a2_b3_a_idx on ab_a2_b3 (never executed)
+                                 Index Cond: (a = (a.a + 0))
+                           ->  Index Scan using ab_a3_b1_a_idx on ab_a3_b1 (never executed)
+                                 Index Cond: (a = (a.a + 0))
+                           ->  Index Scan using ab_a3_b2_a_idx on ab_a3_b2 (never executed)
+                                 Index Cond: (a = (a.a + 0))
+                           ->  Index Scan using ab_a3_b3_a_idx on ab_a3_b3 (never executed)
+                                 Index Cond: (a = (a.a + 0))
+(27 rows)
+
 insert into lprt_a values(3),(3);
 select explain_parallel_append('select avg(ab.a) from ab inner join lprt_a a on ab.a = a.a where a.a in(1, 0, 3)');
                                       explain_parallel_append                                      
diff --git a/src/test/regress/sql/partition_prune.sql b/src/test/regress/sql/partition_prune.sql
index 1464f4dcd9..b6681fa44c 100644
--- a/src/test/regress/sql/partition_prune.sql
+++ b/src/test/regress/sql/partition_prune.sql
@@ -396,6 +396,22 @@ fetch backward all from cur;
 
 commit;
 
+begin;
+
+-- Test run-time pruning using stable functions
+create function list_part_fn(int) returns int as $$ begin return $1; end;$$ language plpgsql stable;
+
+-- Ensure pruning works using a stable function containing no Vars
+explain (analyze, costs off, summary off, timing off) select * from list_part where a = list_part_fn(1);
+
+-- Ensure pruning does not take place when the function contains a Var parameter
+explain (analyze, costs off, summary off, timing off) select * from list_part where a = list_part_fn(a);
+
+-- Ensure pruning does not take place when the expression contains a Var.
+explain (analyze, costs off, summary off, timing off) select * from list_part where a = list_part_fn(1) + a;
+
+rollback;
+
 drop table list_part;
 
 -- Parallel append
@@ -486,6 +502,10 @@ set enable_mergejoin = 0;
 
 select explain_parallel_append('select avg(ab.a) from ab inner join lprt_a a on ab.a = a.a where a.a in(0, 0, 1)');
 
+-- Ensure the same partitions are pruned when we make the nested loop
+-- parameter an Expr rather than a plain Param.
+select explain_parallel_append('select avg(ab.a) from ab inner join lprt_a a on ab.a = a.a + 0 where a.a in(0, 0, 1)');
+
 insert into lprt_a values(3),(3);
 
 select explain_parallel_append('select avg(ab.a) from ab inner join lprt_a a on ab.a = a.a where a.a in(1, 0, 3)');

diff --git a/src/backend/executor/execPartition.c b/src/backend/executor/execPartition.c
index c83991c93c..2055b81d4f 100644
--- a/src/backend/executor/execPartition.c
+++ b/src/backend/executor/execPartition.c
@@ -1349,7 +1349,11 @@ adjust_partition_tlist(List *tlist, TupleConversionMap *map)
  * difference between these that we need to concern ourselves with is the
  * time when the values of the Params are known.  External Param values are
  * known at any time of execution, including executor startup, but exec Param
- * values are only known when the executor is running.
+ * values are only known when the executor is running.  We also support
+ * pruning using any stable expression which does not contain any Vars.
+ * Immutable expressions would have been evaluated to a Const during planning,
+ * so plan-time pruning would have taken care of any pruning.  It's not
+ * possible for pruning to take place using volatile expressions.
  *
  * For external Params we may be able to prune away unneeded partitions
  * during executor startup.  This has the added benefit of not having to
@@ -1418,6 +1422,7 @@ ExecSetupPartitionPruneState(PlanState *planstate, List *partitionpruneinfo)
 	prunestate->num_partprunedata = list_length(partitionpruneinfo);
 	prunestate->extparams = NULL;
 	prunestate->execparams = NULL;
+	prunestate->hasparamlessexprs = false;
 
 	/*
 	 * Create a sub memory context which we'll use when making calls to the
@@ -1456,6 +1461,7 @@ ExecSetupPartitionPruneState(PlanState *planstate, List *partitionpruneinfo)
 
 		/* We can use the subpart_map verbatim, since we never modify it */
 		pprune->subpart_map = pinfo->subpart_map;
+		pprune->hasparamlessexprs = false;
 
 		/*
 		 * Grab some info from the table's relcache; lock was already obtained
@@ -1478,6 +1484,7 @@ ExecSetupPartitionPruneState(PlanState *planstate, List *partitionpruneinfo)
 		context->planstate = planstate;
 		context->safeparams = NULL; /* empty for now */
 		context->exprstates = palloc0(sizeof(ExprState *) * n_steps * partnatts);
+		context->exprparamids = palloc0(sizeof(Bitmapset *) * n_steps * partnatts);
 
 		/* Initialize expression states for each expression */
 		foreach(lc2, pinfo->pruning_steps)
@@ -1505,6 +1512,11 @@ ExecSetupPartitionPruneState(PlanState *planstate, List *partitionpruneinfo)
 												step->step.step_id, keyno);
 					context->exprstates[stateidx] =
 						ExecInitExpr(expr, context->planstate);
+					context->exprparamids[stateidx] = pull_paramids(expr);
+
+					if (!pprune->hasparamlessexprs &&
+						bms_is_empty(context->exprparamids[stateidx]))
+						pprune->hasparamlessexprs = true;
 				}
 				keyno++;
 			}
@@ -1524,6 +1536,8 @@ ExecSetupPartitionPruneState(PlanState *planstate, List *partitionpruneinfo)
 		prunestate->execparams = bms_add_members(prunestate->execparams,
 												 pinfo->execparams);
 
+		prunestate->hasparamlessexprs |= pprune->hasparamlessexprs;
+
 		relation_close(rel, NoLock);
 
 		i++;
@@ -1566,10 +1580,11 @@ ExecFindInitialMatchingSubPlans(PartitionPruneState *prunestate, int nsubnodes)
 	Bitmapset  *result = NULL;
 
 	/*
-	 * Ensure there's actually external params, or we've not been called
-	 * already.
+	 * If there are no parameter-less Exprs then ensure there's actually
+	 * external params, or we've not been called already.
 	 */
-	Assert(!bms_is_empty(prunestate->extparams));
+	Assert(prunestate->hasparamlessexprs ||
+		   !bms_is_empty(prunestate->extparams));
 
 	pprune = prunestate->partprunedata;
 
@@ -1739,14 +1754,14 @@ find_subplans_for_params_recurse(PartitionPruneState *prunestate,
 
 	/*
 	 * We only need to determine the matching partitions if there are any
-	 * params matching the partition key at this level.  If there are no
-	 * matching params, then we can simply return all subnodes which belong to
-	 * this parent partition.  The planner should have already determined
-	 * these to be the minimum possible set.  We must still recursively visit
-	 * any subpartitioned tables as we may find their partition keys match
-	 * some Params at their level.
+	 * params matching the partition key at this level, or if there are any
+	 * parameter-less expressions matching the partition key.  However, if
+	 * it's just parameter-less expressions then we only prune during
+	 * ExecFindInitialMatchingSubPlans, there's no point in doing this from
+	 * ExecFindMatchingSubPlans too, once is enough.
 	 */
-	if (!bms_is_empty(pruneparams))
+	if ((!allparams && pprune->hasparamlessexprs) ||
+		!bms_is_empty(pruneparams))
 	{
 		context->safeparams = pruneparams;
 		partset = get_matching_partitions(context,
diff --git a/src/backend/executor/nodeAppend.c b/src/backend/executor/nodeAppend.c
index 6bc3e470bf..275254aa65 100644
--- a/src/backend/executor/nodeAppend.c
+++ b/src/backend/executor/nodeAppend.c
@@ -139,10 +139,11 @@ ExecInitAppend(Append *node, EState *estate, int eflags)
 												  node->part_prune_infos);
 
 		/*
-		 * When there are external params matching the partition key we may be
-		 * able to prune away Append subplans now.
+		 * When there are parameter-less exprs or any external params matching
+		 * the partition key we may be able to prune away Append subplans now.
 		 */
-		if (!bms_is_empty(prunestate->extparams))
+		if (prunestate->hasparamlessexprs ||
+			!bms_is_empty(prunestate->extparams))
 		{
 			/* Determine which subplans match the external params */
 			validsubplans = ExecFindInitialMatchingSubPlans(prunestate,
diff --git a/src/backend/partitioning/partprune.c b/src/backend/partitioning/partprune.c
index 58ec2a684d..a78013bf86 100644
--- a/src/backend/partitioning/partprune.c
+++ b/src/backend/partitioning/partprune.c
@@ -53,6 +53,7 @@
 #include "optimizer/planner.h"
 #include "optimizer/predtest.h"
 #include "optimizer/prep.h"
+#include "optimizer/var.h"
 #include "partitioning/partprune.h"
 #include "partitioning/partbounds.h"
 #include "rewrite/rewriteManip.h"
@@ -115,6 +116,15 @@ typedef struct PruneStepResult
 	bool		scan_null;		/* Scan the partition for NULL values? */
 } PruneStepResult;
 
+/*
+ * expression_tree_walker context struct for gathering paramids of params
+ * matching the partition key.
+ */
+typedef struct PullParamContext
+{
+	Bitmapset *extparams;
+	Bitmapset *execparams;
+} PullParamContext;
 
 static List *gen_partprune_steps(RelOptInfo *rel, List *clauses,
 					bool *contradictory);
@@ -162,6 +172,8 @@ static PruneStepResult *get_matching_list_bounds(PartitionPruneContext *context,
 static PruneStepResult *get_matching_range_bounds(PartitionPruneContext *context,
 						  StrategyNumber opstrategy, Datum *values, int nvalues,
 						  FmgrInfo *partsupfunc, Bitmapset *nullkeys);
+static void pull_params(Expr *expr, PartitionPruneInfo *pinfo);
+static bool pull_params_walker(Node *node, PullParamContext *context);
 static bool pull_partkey_params(PartitionPruneInfo *pinfo, List *steps);
 static PruneStepResult *perform_pruning_base_step(PartitionPruneContext *context,
 						  PartitionPruneStepOp *opstep);
@@ -197,7 +209,7 @@ make_partition_pruneinfo(PlannerInfo *root, List *partition_rels,
 	int		   *relid_subnode_map;
 	int		   *relid_subpart_map;
 	int			i;
-	bool		gotparam = false;
+	bool		gotnonconst = false;
 
 	/*
 	 * Allocate two arrays to store the 1-based indexes of the 'subpaths' and
@@ -326,11 +338,12 @@ make_partition_pruneinfo(PlannerInfo *root, List *partition_rels,
 		pinfo->subpart_map = subpart_map;
 
 		/*
-		 * Extract Params matching partition key and record if we got any.
-		 * We'll not bother enabling run-time pruning if no params matched the
-		 * partition key at any level of partitioning.
+		 * Extract Params matching partition key and record if any steps
+		 * compare a non-Const value to the partition key.  If everything
+		 * is Const then we've no need to perform run-time pruning as the
+		 * planner will have already selected the minimum set of partitions.
 		 */
-		gotparam |= pull_partkey_params(pinfo, pruning_steps);
+		gotnonconst |= pull_partkey_params(pinfo, pruning_steps);
 
 		pinfolist = lappend(pinfolist, pinfo);
 	}
@@ -338,14 +351,11 @@ make_partition_pruneinfo(PlannerInfo *root, List *partition_rels,
 	pfree(relid_subnode_map);
 	pfree(relid_subpart_map);
 
-	if (gotparam)
+	/* Enable pruning if we got any non-Consts */
+	if (gotnonconst)
 		return pinfolist;
 
-	/*
-	 * If no Params were found to match the partition key on any of the
-	 * partitioned relations then there's no point doing any run-time
-	 * partition pruning.
-	 */
+	/* Run-time pruning would be useless */
 	return NIL;
 }
 
@@ -447,6 +457,7 @@ prune_append_rel_partitions(RelOptInfo *rel)
 	context.planstate = NULL;
 	context.safeparams = NULL;
 	context.exprstates = NULL;
+	context.exprparamids = NULL;
 
 	/* Actual pruning happens here. */
 	partindexes = get_matching_partitions(&context, pruning_steps);
@@ -1478,6 +1489,10 @@ match_clause_to_partition_key(RelOptInfo *rel,
 		if (contain_volatile_functions((Node *) expr))
 			return PARTCLAUSE_UNSUPPORTED;
 
+		/* We can't prune using an expression with Vars. */
+		if (contain_var_clause((Node *) expr))
+			return PARTCLAUSE_UNSUPPORTED;
+
 		/*
 		 * Determine the input types of the operator we're considering.
 		 *
@@ -2682,16 +2697,85 @@ get_matching_range_bounds(PartitionPruneContext *context,
 	return result;
 }
 
+/*
+ * pull_paramids
+ *		Returns a Bitmapset containing the paramids of each Param in 'expr'.
+ */
+Bitmapset *
+pull_paramids(Expr *expr)
+{
+	PullParamContext context;
+
+	context.extparams = NULL;
+	context.execparams = NULL;
+
+	pull_params_walker((Node *) expr, &context);
+
+	return bms_union(context.extparams, context.execparams);
+}
+
+/*
+ * pull_params
+ *		Determine all external and exec params in 'expr' and add the found
+ *		paramids to the appropriate 'pinfo' field.
+ */
+static void
+pull_params(Expr *expr, PartitionPruneInfo *pinfo)
+{
+	PullParamContext context;
+
+	context.extparams = NULL;
+	context.execparams = NULL;
+
+	pull_params_walker((Node *) expr, &context);
+
+	pinfo->extparams = bms_add_members(pinfo->extparams, context.extparams);
+	pinfo->execparams = bms_add_members(pinfo->execparams,
+										context.execparams);
+}
+
+static bool
+pull_params_walker(Node *node, PullParamContext *context)
+{
+	if (node == NULL)
+		return false;
+	if (IsA(node, Param))
+	{
+		Param	   *param = (Param *) node;
+
+		switch (param->paramkind)
+		{
+			case PARAM_EXTERN:
+				context->extparams = bms_add_member(context->extparams,
+													param->paramid);
+				break;
+			case PARAM_EXEC:
+				context->execparams = bms_add_member(context->execparams,
+													 param->paramid);
+				break;
+
+			default:
+				elog(ERROR, "unrecognized paramkind: %d",
+					 (int) param->paramkind);
+				break;
+		}
+	}
+	return expression_tree_walker(node, pull_params_walker,
+								  (void *) context);
+}
+
 /*
  * pull_partkey_params
  *		Loop through each pruning step and record each external and exec
  *		Params being compared to the partition keys.
+ *
+ * Returns true if any non-const value is being compared to the partition key.
  */
 static bool
 pull_partkey_params(PartitionPruneInfo *pinfo, List *steps)
 {
 	ListCell   *lc;
-	bool		gotone = false;
+	bool		gotnonconst = false;
 
 	foreach(lc, steps)
 	{
@@ -2705,32 +2789,15 @@ pull_partkey_params(PartitionPruneInfo *pinfo, List *steps)
 		{
 			Expr	   *expr = lfirst(lc2);
 
-			if (IsA(expr, Param))
-			{
-				Param	   *param = (Param *) expr;
-
-				switch (param->paramkind)
-				{
-					case PARAM_EXTERN:
-						pinfo->extparams = bms_add_member(pinfo->extparams,
-														  param->paramid);
-						break;
-					case PARAM_EXEC:
-						pinfo->execparams = bms_add_member(pinfo->execparams,
-														   param->paramid);
-						break;
+			if (IsA(expr, Const))
+				continue;
 
-					default:
-						elog(ERROR, "unrecognized paramkind: %d",
-							 (int) param->paramkind);
-						break;
-				}
-				gotone = true;
-			}
+			gotnonconst = true;
+			pull_params(expr, pinfo);
 		}
 	}
 
-	return gotone;
+	return gotnonconst;
 }
 
 /*
@@ -3031,37 +3098,38 @@ static bool
 partkey_datum_from_expr(PartitionPruneContext *context,
 						Expr *expr, int stateidx, Datum *value)
 {
-	switch (nodeTag(expr))
+	if (IsA(expr, Const))
 	{
-		case T_Const:
-			*value = ((Const *) expr)->constvalue;
-			return true;
-
-		case T_Param:
-
-			/*
-			 * When being called from the executor we may be able to evaluate
-			 * the Param's value.
-			 */
-			if (context->planstate &&
-				bms_is_member(((Param *) expr)->paramid, context->safeparams))
-			{
-				ExprState  *exprstate;
-				ExprContext *ectx;
-				bool		isNull;
+		*value = ((Const *) expr)->constvalue;
+		return true;
+	}
+	else
+	{
+		/*
+		 * When called from the executor we'll have a valid planstate so we
+		 * may be able to evaluate the expression.  However, we must ensure
+		 * we don't try to do this if the expression contains parameters which
+		 * we're unable to evaluate at this time.
+		 */
+		if (context->planstate &&
+			!bms_nonempty_difference(context->exprparamids[stateidx],
+									 context->safeparams))
+		{
+			ExprState  *exprstate;
+			ExprContext *ectx;
+			bool		isNull;
 
-				exprstate = context->exprstates[stateidx];
-				ectx = context->planstate->ps_ExprContext;
-				*value = ExecEvalExprSwitchContext(exprstate, ectx, &isNull);
-				if (isNull)
-					return false;
+			/* Exprs with volatile functions shouldn't make it here */
+			Assert(!contain_volatile_functions((Node *) expr));
 
-				return true;
-			}
-			break;
+			exprstate = context->exprstates[stateidx];
+			ectx = context->planstate->ps_ExprContext;
+			*value = ExecEvalExprSwitchContext(exprstate, ectx, &isNull);
+			if (isNull)
+				return false;
 
-		default:
-			break;
+			return true;
+		}
 	}
 
 	return false;
diff --git a/src/include/executor/execPartition.h b/src/include/executor/execPartition.h
index fc6e9574e3..a48cf72d8c 100644
--- a/src/include/executor/execPartition.h
+++ b/src/include/executor/execPartition.h
@@ -136,6 +136,8 @@ typedef struct PartitionTupleRouting
  * extparams					Contains paramids of external params found
  *								matching partition keys in 'pruning_steps'.
  * allparams					As 'extparams' but also including exec params.
+ * hasparamlessexprs			Some pruning steps contain Exprs without any
+ *								Params.
  *-----------------------
  */
 typedef struct PartitionPruningData
@@ -147,6 +149,7 @@ typedef struct PartitionPruningData
 	List	   *pruning_steps;
 	Bitmapset  *extparams;
 	Bitmapset  *allparams;
+	bool		hasparamlessexprs;
 } PartitionPruningData;
 
 /*-----------------------
@@ -163,6 +166,7 @@ typedef struct PartitionPruningData
  *						partitioned relation. First element contains the
  *						details for the target partitioned table.
  * num_partprunedata	Number of items in 'partprunedata' array.
+ * hasparamlessexprs	Some pruning steps contain Exprs without any Params.
  * prune_context		A memory context which can be used to call the query
  *						planner's partition prune functions.
  * extparams			All PARAM_EXTERN paramids which were found to match a
@@ -177,6 +181,7 @@ typedef struct PartitionPruneState
 {
 	PartitionPruningData *partprunedata;
 	int			num_partprunedata;
+	bool		hasparamlessexprs;
 	MemoryContext prune_context;
 	Bitmapset  *extparams;
 	Bitmapset  *execparams;
diff --git a/src/include/partitioning/partprune.h b/src/include/partitioning/partprune.h
index 3d114b4c71..14fc9aea9c 100644
--- a/src/include/partitioning/partprune.h
+++ b/src/include/partitioning/partprune.h
@@ -57,6 +57,9 @@ typedef struct PartitionPruneContext
 	 * otherwise NULL.
 	 */
 	ExprState **exprstates;
+
+	/* Array of Bitmapsets, one for each exprstates */
+	Bitmapset **exprparamids;
 } PartitionPruneContext;
 
 #define PruneCxtStateIdx(partnatts, step_id, keyno) \
@@ -67,5 +70,6 @@ extern List *make_partition_pruneinfo(PlannerInfo *root, List *partition_rels,
 extern Relids prune_append_rel_partitions(RelOptInfo *rel);
 extern Bitmapset *get_matching_partitions(PartitionPruneContext *context,
 						List *pruning_steps);
+extern Bitmapset *pull_paramids(Expr *expr);
 
 #endif							/* PARTPRUNE_H */
diff --git a/src/test/regress/expected/partition_prune.out b/src/test/regress/expected/partition_prune.out
index cf331e79c1..64b4e933d6 100644
--- a/src/test/regress/expected/partition_prune.out
+++ b/src/test/regress/expected/partition_prune.out
@@ -1835,6 +1835,54 @@ fetch backward all from cur;
 (2 rows)
 
 commit;
+begin;
+-- Test run-time pruning using stable functions
+create function list_part_fn(int) returns int as $$ begin return $1; end;$$ language plpgsql stable;
+-- Ensure pruning works using a stable function containing no Vars
+explain (analyze, costs off, summary off, timing off) select * from list_part where a = list_part_fn(1);
+                      QUERY PLAN                      
+------------------------------------------------------
+ Append (actual rows=1 loops=1)
+   Subplans Removed: 3
+   ->  Seq Scan on list_part1 (actual rows=1 loops=1)
+         Filter: (a = list_part_fn(1))
+(4 rows)
+
+-- Ensure pruning does not take place when the function contains a Var parameter
+explain (analyze, costs off, summary off, timing off) select * from list_part where a = list_part_fn(a);
+                      QUERY PLAN                      
+------------------------------------------------------
+ Append (actual rows=4 loops=1)
+   ->  Seq Scan on list_part1 (actual rows=1 loops=1)
+         Filter: (a = list_part_fn(a))
+   ->  Seq Scan on list_part2 (actual rows=1 loops=1)
+         Filter: (a = list_part_fn(a))
+   ->  Seq Scan on list_part3 (actual rows=1 loops=1)
+         Filter: (a = list_part_fn(a))
+   ->  Seq Scan on list_part4 (actual rows=1 loops=1)
+         Filter: (a = list_part_fn(a))
+(9 rows)
+
+-- Ensure pruning does not take place when the expression contains a Var.
+explain (analyze, costs off, summary off, timing off) select * from list_part where a = list_part_fn(1) + a;
+                      QUERY PLAN                      
+------------------------------------------------------
+ Append (actual rows=0 loops=1)
+   ->  Seq Scan on list_part1 (actual rows=0 loops=1)
+         Filter: (a = (list_part_fn(1) + a))
+         Rows Removed by Filter: 1
+   ->  Seq Scan on list_part2 (actual rows=0 loops=1)
+         Filter: (a = (list_part_fn(1) + a))
+         Rows Removed by Filter: 1
+   ->  Seq Scan on list_part3 (actual rows=0 loops=1)
+         Filter: (a = (list_part_fn(1) + a))
+         Rows Removed by Filter: 1
+   ->  Seq Scan on list_part4 (actual rows=0 loops=1)
+         Filter: (a = (list_part_fn(1) + a))
+         Rows Removed by Filter: 1
+(13 rows)
+
+rollback;
 drop table list_part;
 -- Parallel append
 -- Suppress the number of loops each parallel node runs for.  This is because
@@ -2079,6 +2127,40 @@ select explain_parallel_append('select avg(ab.a) from ab inner join lprt_a a on
                                  Index Cond: (a = a.a)
 (27 rows)
 
+-- Ensure the same partitions are pruned when we make the nested loop
+-- parameter an Expr rather than a plain Param.
+select explain_parallel_append('select avg(ab.a) from ab inner join lprt_a a on ab.a = a.a + 0 where a.a in(0, 0, 1)');
+                                      explain_parallel_append                                      
+---------------------------------------------------------------------------------------------------
+ Finalize Aggregate (actual rows=1 loops=1)
+   ->  Gather (actual rows=2 loops=1)
+         Workers Planned: 1
+         Workers Launched: 1
+         ->  Partial Aggregate (actual rows=1 loops=2)
+               ->  Nested Loop (actual rows=0 loops=2)
+                     ->  Parallel Seq Scan on lprt_a a (actual rows=51 loops=N)
+                           Filter: (a = ANY ('{0,0,1}'::integer[]))
+                     ->  Append (actual rows=0 loops=102)
+                           ->  Index Scan using ab_a1_b1_a_idx on ab_a1_b1 (actual rows=0 loops=2)
+                                 Index Cond: (a = (a.a + 0))
+                           ->  Index Scan using ab_a1_b2_a_idx on ab_a1_b2 (actual rows=0 loops=2)
+                                 Index Cond: (a = (a.a + 0))
+                           ->  Index Scan using ab_a1_b3_a_idx on ab_a1_b3 (actual rows=0 loops=2)
+                                 Index Cond: (a = (a.a + 0))
+                           ->  Index Scan using ab_a2_b1_a_idx on ab_a2_b1 (never executed)
+                                 Index Cond: (a = (a.a + 0))
+                           ->  Index Scan using ab_a2_b2_a_idx on ab_a2_b2 (never executed)
+                                 Index Cond: (a = (a.a + 0))
+                           ->  Index Scan using ab_a2_b3_a_idx on ab_a2_b3 (never executed)
+                                 Index Cond: (a = (a.a + 0))
+                           ->  Index Scan using ab_a3_b1_a_idx on ab_a3_b1 (never executed)
+                                 Index Cond: (a = (a.a + 0))
+                           ->  Index Scan using ab_a3_b2_a_idx on ab_a3_b2 (never executed)
+                                 Index Cond: (a = (a.a + 0))
+                           ->  Index Scan using ab_a3_b3_a_idx on ab_a3_b3 (never executed)
+                                 Index Cond: (a = (a.a + 0))
+(27 rows)
+
 insert into lprt_a values(3),(3);
 select explain_parallel_append('select avg(ab.a) from ab inner join lprt_a a on ab.a = a.a where a.a in(1, 0, 3)');
                                       explain_parallel_append                                      
diff --git a/src/test/regress/sql/partition_prune.sql b/src/test/regress/sql/partition_prune.sql
index 1464f4dcd9..b6681fa44c 100644
--- a/src/test/regress/sql/partition_prune.sql
+++ b/src/test/regress/sql/partition_prune.sql
@@ -396,6 +396,22 @@ fetch backward all from cur;
 
 commit;
 
+begin;
+
+-- Test run-time pruning using stable functions
+create function list_part_fn(int) returns int as $$ begin return $1; end;$$ language plpgsql stable;
+
+-- Ensure pruning works using a stable function containing no Vars
+explain (analyze, costs off, summary off, timing off) select * from list_part where a = list_part_fn(1);
+
+-- Ensure pruning does not take place when the function contains a Var parameter
+explain (analyze, costs off, summary off, timing off) select * from list_part where a = list_part_fn(a);
+
+-- Ensure pruning does not take place when the expression contains a Var.
+explain (analyze, costs off, summary off, timing off) select * from list_part where a = list_part_fn(1) + a;
+
+rollback;
+
 drop table list_part;
 
 -- Parallel append
@@ -486,6 +502,10 @@ set enable_mergejoin = 0;
 
 select explain_parallel_append('select avg(ab.a) from ab inner join lprt_a a on ab.a = a.a where a.a in(0, 0, 1)');
 
+-- Ensure the same partitions are pruned when we make the nested loop
+-- parameter an Expr rather than a plain Param.
+select explain_parallel_append('select avg(ab.a) from ab inner join lprt_a a on ab.a = a.a + 0 where a.a in(0, 0, 1)');
+
 insert into lprt_a values(3),(3);
 
 select explain_parallel_append('select avg(ab.a) from ab inner join lprt_a a on ab.a = a.a where a.a in(1, 0, 3)');

diff --git a/src/backend/executor/execPartition.c b/src/backend/executor/execPartition.c
index c83991c93c..92b74077e9 100644
--- a/src/backend/executor/execPartition.c
+++ b/src/backend/executor/execPartition.c
@@ -50,7 +50,7 @@ static char *ExecBuildSlotPartitionKeyDescription(Relation rel,
 static List *adjust_partition_tlist(List *tlist, TupleConversionMap *map);
 static void find_subplans_for_params_recurse(PartitionPruneState *prunestate,
 								 PartitionPruningData *pprune,
-								 bool allparams,
+								 bool initial_prune,
 								 Bitmapset **validsubplans);
 
 
@@ -1345,18 +1345,16 @@ adjust_partition_tlist(List *tlist, TupleConversionMap *map)
  * pruning to be performed for values which are only determined during
  * execution, we must make an additional pruning attempt during execution.
  *
- * Here we support pruning using both external and exec Params.  The main
- * difference between these that we need to concern ourselves with is the
- * time when the values of the Params are known.  External Param values are
- * known at any time of execution, including executor startup, but exec Param
- * values are only known when the executor is running.
+ * Here we support pruning using any non-volatile expression. This allows
+ * pruning to be performed using both external and exec Params, along with
+ * stable functions calls and expressions.  Any expression containing an exec
+ * Param must not be evaluated until during execution. For everything else, we
+ * can perform pruning during executor startup.
  *
- * For external Params we may be able to prune away unneeded partitions
- * during executor startup.  This has the added benefit of not having to
- * initialize the unneeded subnodes at all.  This is useful as it can save
- * quite a bit of effort during executor startup.
+ * Having the ability to prune away unneeded subnodes during executor startup
+ * has the added benefit of not having to initialize the unneeded subnodes at
+ * all.
  *
- * For exec Params, we must delay pruning until the executor is running.
  *
  * Functions:
  *
@@ -1369,19 +1367,20 @@ adjust_partition_tlist(List *tlist, TupleConversionMap *map)
  *		planner's partition prune function into subnode indexes.
  *
  * ExecFindInitialMatchingSubPlans:
- *		Returns indexes of matching subnodes utilizing only external Params
- *		to eliminate subnodes.  The function must only be called during
- *		executor startup for the given node before the subnodes themselves
- *		are initialized.  Subnodes which are found not to match by this
- *		function must not be included in the node's list of subnodes as this
- *		function performs a remap of the partition index to subplan index map
- *		and the newly created map provides indexes only for subnodes which
- *		remain after calling this function.
+ *		Returns indexes of matching subnodes.  Partition pruning is attempted
+ *		without any evaluation of expressions containing exec Params.  This
+ *		function must only be called during executor startup for the given
+ *		node before the subnodes themselves are initialized.  Subnodes which
+ *		are found not to match by this function must not be included in the
+ *		node's list of subnodes as this function performs a remap of the
+ *		partition index to subplan index map and the newly created map
+ *		provides indexes only for subnodes which remain after calling this
+ *		function.
  *
  * ExecFindMatchingSubPlans:
- *		Returns indexes of matching subnodes utilizing all Params to eliminate
- *		subnodes which can't possibly contain matching tuples.  This function
- *		can only be called while the executor is running.
+ *		Returns indexes of matching subnodes evaluating all possible
+ *		expressions.  This function can only be called while the executor is
+ *		running.
  *-------------------------------------------------------------------------
  */
 
@@ -1416,8 +1415,8 @@ ExecSetupPartitionPruneState(PlanState *planstate, List *partitionpruneinfo)
 	 */
 	prunestate->partprunedata = prunedata;
 	prunestate->num_partprunedata = list_length(partitionpruneinfo);
-	prunestate->extparams = NULL;
 	prunestate->execparams = NULL;
+	prunestate->do_initial_prune = false;	/* may be set below */
 
 	/*
 	 * Create a sub memory context which we'll use when making calls to the
@@ -1444,7 +1443,7 @@ ExecSetupPartitionPruneState(PlanState *planstate, List *partitionpruneinfo)
 		int			partnatts;
 		int			n_steps;
 
-		pprune->present_parts = bms_copy(pinfo->present_parts);
+		pprune->present_parts = pinfo->present_parts;
 		pprune->subnode_map = palloc(sizeof(int) * pinfo->nparts);
 
 		/*
@@ -1476,9 +1475,14 @@ ExecSetupPartitionPruneState(PlanState *planstate, List *partitionpruneinfo)
 		context->nparts = pinfo->nparts;
 		context->boundinfo = partition_bounds_copy(partdesc->boundinfo, partkey);
 		context->planstate = planstate;
-		context->safeparams = NULL; /* empty for now */
 		context->exprstates = palloc0(sizeof(ExprState *) * n_steps * partnatts);
 
+		/*
+		 * Use the hasexecparam. This is not modified anywhere, so we just
+		 * borrow the planner's copy.
+		 */
+		context->exprhasexecparam = pinfo->hasexecparam;
+
 		/* Initialize expression states for each expression */
 		foreach(lc2, pinfo->pruning_steps)
 		{
@@ -1511,31 +1515,25 @@ ExecSetupPartitionPruneState(PlanState *planstate, List *partitionpruneinfo)
 		}
 
 		pprune->pruning_steps = pinfo->pruning_steps;
-		pprune->extparams = bms_copy(pinfo->extparams);
-		pprune->allparams = bms_union(pinfo->extparams, pinfo->execparams);
+		pprune->execparams = bms_copy(pinfo->execparams);
+		pprune->do_initial_prune = pinfo->do_initial_prune;
+		pprune->do_exec_prune = pinfo->do_exec_prune;
 
 		/*
-		 * Accumulate the paramids which match the partitioned keys of all
-		 * partitioned tables.
+		 * Accumulate the exec paramids which match the partitioned keys of
+		 * all partitioned tables.
 		 */
-		prunestate->extparams = bms_add_members(prunestate->extparams,
-												pinfo->extparams);
-
 		prunestate->execparams = bms_add_members(prunestate->execparams,
 												 pinfo->execparams);
 
+		/* Record if an initial prune would be useful at any level */
+		prunestate->do_initial_prune |= pinfo->do_initial_prune;
+
 		relation_close(rel, NoLock);
 
 		i++;
 	}
 
-	/*
-	 * Cache the union of the paramids of both types.  This saves having to
-	 * recalculate it everytime we need to know what they are.
-	 */
-	prunestate->allparams = bms_union(prunestate->extparams,
-									  prunestate->execparams);
-
 	return prunestate;
 }
 
@@ -1543,9 +1541,9 @@ ExecSetupPartitionPruneState(PlanState *planstate, List *partitionpruneinfo)
  * ExecFindInitialMatchingSubPlans
  *		Determine which subset of subplan nodes we need to initialize based
  *		on the details stored in 'prunestate'.  Here we only determine the
- *		matching partitions using values known during plan startup, which is
- *		only external Params.  Exec Params will be unknown at this time.  We
- *		must delay pruning using exec Params until the actual executor run.
+ *		matching partitions using values known during plan startup, which
+ *		excludes attempting to evaulate any expressions containing exec
+ *		Params.
  *
  * It is expected that callers of this function do so only once during their
  * init plan.  The caller must only initialize the subnodes which are returned
@@ -1554,8 +1552,6 @@ ExecSetupPartitionPruneState(PlanState *planstate, List *partitionpruneinfo)
  * return its matching subnode indexes assuming that the caller discarded
  * the original non-matching subnodes.
  *
- * This function must only be called if 'prunestate' has any extparams.
- *
  * 'nsubnodes' must be passed as the total number of unpruned subnodes.
  */
 Bitmapset *
@@ -1565,11 +1561,7 @@ ExecFindInitialMatchingSubPlans(PartitionPruneState *prunestate, int nsubnodes)
 	MemoryContext oldcontext;
 	Bitmapset  *result = NULL;
 
-	/*
-	 * Ensure there's actually external params, or we've not been called
-	 * already.
-	 */
-	Assert(!bms_is_empty(prunestate->extparams));
+	Assert(prunestate->do_initial_prune);
 
 	pprune = prunestate->partprunedata;
 
@@ -1579,8 +1571,8 @@ ExecFindInitialMatchingSubPlans(PartitionPruneState *prunestate, int nsubnodes)
 	 */
 	oldcontext = MemoryContextSwitchTo(prunestate->prune_context);
 
-	/* Determine which subnodes match the external params */
-	find_subplans_for_params_recurse(prunestate, pprune, false, &result);
+	/* Perform pruning without using exec params */
+	find_subplans_for_params_recurse(prunestate, pprune, true, &result);
 
 	MemoryContextSwitchTo(oldcontext);
 
@@ -1589,18 +1581,6 @@ ExecFindInitialMatchingSubPlans(PartitionPruneState *prunestate, int nsubnodes)
 
 	MemoryContextReset(prunestate->prune_context);
 
-	/*
-	 * Record that partition pruning has been performed for external params.
-	 * These are not required again afterwards, and nullifying them helps
-	 * ensure nothing accidentally calls this function twice on the same
-	 * PartitionPruneState.
-	 *
-	 * (Note we keep prunestate->allparams, because we do use that one
-	 * repeatedly in ExecFindMatchingSubPlans).
-	 */
-	bms_free(prunestate->extparams);
-	prunestate->extparams = NULL;
-
 	/*
 	 * If any subnodes were pruned, we must re-sequence the subnode indexes so
 	 * that ExecFindMatchingSubPlans properly returns the indexes from the
@@ -1644,7 +1624,6 @@ ExecFindInitialMatchingSubPlans(PartitionPruneState *prunestate, int nsubnodes)
 			 * for.  It seems easier to build a fresh one, rather than trying
 			 * to update the existing one.
 			 */
-			bms_free(pprune->present_parts);
 			pprune->present_parts = NULL;
 
 			for (j = 0; j < nparts; j++)
@@ -1669,6 +1648,41 @@ ExecFindInitialMatchingSubPlans(PartitionPruneState *prunestate, int nsubnodes)
 			}
 		}
 
+		/*
+		 * Now we must determine which sub-partitioned tables still have
+		 * unpruned partitions.  The easiest way to do this is to simply loop
+		 * over each PartitionPruningData again checking if there are any
+		 * 'present_parts' in the sub-partitioned table.  We needn't bother
+		 * doing this if there are no sub-partitioned tables.
+		 */
+		if (prunestate->num_partprunedata > 1)
+		{
+			for (i = 0; i < prunestate->num_partprunedata; i++)
+			{
+				int			nparts;
+				int			j;
+
+				pprune = &prunestate->partprunedata[i];
+				nparts = pprune->context.nparts;
+
+				for (j = 0; j < nparts; j++)
+				{
+					int			subidx = pprune->subpart_map[j];
+
+					if (subidx >= 0)
+					{
+						PartitionPruningData *subprune;
+
+						subprune = &prunestate->partprunedata[subidx];
+
+						if (!bms_is_empty(subprune->present_parts))
+							pprune->present_parts =
+								bms_add_member(pprune->present_parts, j);
+					}
+				}
+			}
+		}
+
 		pfree(new_subnode_indexes);
 	}
 
@@ -1697,7 +1711,7 @@ ExecFindMatchingSubPlans(PartitionPruneState *prunestate)
 	 */
 	oldcontext = MemoryContextSwitchTo(prunestate->prune_context);
 
-	find_subplans_for_params_recurse(prunestate, pprune, true, &result);
+	find_subplans_for_params_recurse(prunestate, pprune, false, &result);
 
 	MemoryContextSwitchTo(oldcontext);
 
@@ -1717,43 +1731,34 @@ ExecFindMatchingSubPlans(PartitionPruneState *prunestate)
 static void
 find_subplans_for_params_recurse(PartitionPruneState *prunestate,
 								 PartitionPruningData *pprune,
-								 bool allparams,
+								 bool initial_prune,
 								 Bitmapset **validsubplans)
 {
 	PartitionPruneContext *context = &pprune->context;
 	Bitmapset  *partset;
-	Bitmapset  *pruneparams;
 	int			i;
 
 	/* Guard against stack overflow due to overly deep partition hierarchy. */
 	check_stack_depth();
 
-	/*
-	 * Use only external params unless we've been asked to also use exec
-	 * params too.
-	 */
-	if (allparams)
-		pruneparams = pprune->allparams;
-	else
-		pruneparams = pprune->extparams;
-
-	/*
-	 * We only need to determine the matching partitions if there are any
-	 * params matching the partition key at this level.  If there are no
-	 * matching params, then we can simply return all subnodes which belong to
-	 * this parent partition.  The planner should have already determined
-	 * these to be the minimum possible set.  We must still recursively visit
-	 * any subpartitioned tables as we may find their partition keys match
-	 * some Params at their level.
-	 */
-	if (!bms_is_empty(pruneparams))
+	/* Only prune if pruning would be useful at this level. */
+	if ((initial_prune && pprune->do_initial_prune) ||
+		(!initial_prune && pprune->do_exec_prune))
 	{
-		context->safeparams = pruneparams;
+		/* Set whether we can evaluate exec params or not */
+		context->evalexecparams = !initial_prune;
+
 		partset = get_matching_partitions(context,
 										  pprune->pruning_steps);
 	}
 	else
+	{
+		/*
+		 * If no pruning is to be done, just include all partitions at this
+		 * level.
+		 */
 		partset = pprune->present_parts;
+	}
 
 	/* Translate partset into subnode indexes */
 	i = -1;
@@ -1769,7 +1774,7 @@ find_subplans_for_params_recurse(PartitionPruneState *prunestate,
 			if (partidx != -1)
 				find_subplans_for_params_recurse(prunestate,
 												 &prunestate->partprunedata[partidx],
-												 allparams, validsubplans);
+												 initial_prune, validsubplans);
 			else
 			{
 				/*
diff --git a/src/backend/executor/nodeAppend.c b/src/backend/executor/nodeAppend.c
index 6bc3e470bf..707a3e0e4b 100644
--- a/src/backend/executor/nodeAppend.c
+++ b/src/backend/executor/nodeAppend.c
@@ -138,11 +138,8 @@ ExecInitAppend(Append *node, EState *estate, int eflags)
 		prunestate = ExecSetupPartitionPruneState(&appendstate->ps,
 												  node->part_prune_infos);
 
-		/*
-		 * When there are external params matching the partition key we may be
-		 * able to prune away Append subplans now.
-		 */
-		if (!bms_is_empty(prunestate->extparams))
+		/* Perform an initial partition prune, if required. */
+		if (prunestate->do_initial_prune)
 		{
 			/* Determine which subplans match the external params */
 			validsubplans = ExecFindInitialMatchingSubPlans(prunestate,
diff --git a/src/backend/nodes/copyfuncs.c b/src/backend/nodes/copyfuncs.c
index 7c045a7afe..90c8d4a028 100644
--- a/src/backend/nodes/copyfuncs.c
+++ b/src/backend/nodes/copyfuncs.c
@@ -2175,9 +2175,12 @@ _copyPartitionPruneInfo(const PartitionPruneInfo *from)
 	COPY_NODE_FIELD(pruning_steps);
 	COPY_BITMAPSET_FIELD(present_parts);
 	COPY_SCALAR_FIELD(nparts);
+	COPY_SCALAR_FIELD(nexprs);
 	COPY_POINTER_FIELD(subnode_map, from->nparts * sizeof(int));
 	COPY_POINTER_FIELD(subpart_map, from->nparts * sizeof(int));
-	COPY_BITMAPSET_FIELD(extparams);
+	COPY_POINTER_FIELD(hasexecparam, from->nexprs * sizeof(bool));
+	COPY_SCALAR_FIELD(do_initial_prune);
+	COPY_SCALAR_FIELD(do_exec_prune);
 	COPY_BITMAPSET_FIELD(execparams);
 
 	return newnode;
diff --git a/src/backend/nodes/outfuncs.c b/src/backend/nodes/outfuncs.c
index 610f9edaf5..9f6fb7c55f 100644
--- a/src/backend/nodes/outfuncs.c
+++ b/src/backend/nodes/outfuncs.c
@@ -1742,6 +1742,7 @@ _outPartitionPruneInfo(StringInfo str, const PartitionPruneInfo *node)
 	WRITE_NODE_FIELD(pruning_steps);
 	WRITE_BITMAPSET_FIELD(present_parts);
 	WRITE_INT_FIELD(nparts);
+	WRITE_INT_FIELD(nexprs);
 
 	appendStringInfoString(str, " :subnode_map");
 	for (i = 0; i < node->nparts; i++)
@@ -1751,7 +1752,12 @@ _outPartitionPruneInfo(StringInfo str, const PartitionPruneInfo *node)
 	for (i = 0; i < node->nparts; i++)
 		appendStringInfo(str, " %d", node->subpart_map[i]);
 
-	WRITE_BITMAPSET_FIELD(extparams);
+	appendStringInfoString(str, " :hasexecparam");
+	for (i = 0; i < node->nexprs; i++)
+		appendStringInfo(str, " %s", booltostr(node->hasexecparam[i]));
+
+	WRITE_BOOL_FIELD(do_initial_prune);
+	WRITE_BOOL_FIELD(do_exec_prune);
 	WRITE_BITMAPSET_FIELD(execparams);
 }
 
diff --git a/src/backend/nodes/readfuncs.c b/src/backend/nodes/readfuncs.c
index 2826cec2f8..a0335ccd76 100644
--- a/src/backend/nodes/readfuncs.c
+++ b/src/backend/nodes/readfuncs.c
@@ -1363,9 +1363,12 @@ _readPartitionPruneInfo(void)
 	READ_NODE_FIELD(pruning_steps);
 	READ_BITMAPSET_FIELD(present_parts);
 	READ_INT_FIELD(nparts);
+	READ_INT_FIELD(nexprs);
 	READ_INT_ARRAY(subnode_map, local_node->nparts);
 	READ_INT_ARRAY(subpart_map, local_node->nparts);
-	READ_BITMAPSET_FIELD(extparams);
+	READ_BOOL_ARRAY(hasexecparam, local_node->nexprs);
+	READ_BOOL_FIELD(do_initial_prune);
+	READ_BOOL_FIELD(do_exec_prune);
 	READ_BITMAPSET_FIELD(execparams);
 
 	READ_DONE();
diff --git a/src/backend/partitioning/partprune.c b/src/backend/partitioning/partprune.c
index 58ec2a684d..2561c6b835 100644
--- a/src/backend/partitioning/partprune.c
+++ b/src/backend/partitioning/partprune.c
@@ -53,10 +53,12 @@
 #include "optimizer/planner.h"
 #include "optimizer/predtest.h"
 #include "optimizer/prep.h"
+#include "optimizer/var.h"
 #include "partitioning/partprune.h"
 #include "partitioning/partbounds.h"
 #include "rewrite/rewriteManip.h"
 #include "utils/lsyscache.h"
+#include "utils/rel.h"
 
 
 /*
@@ -115,6 +117,14 @@ typedef struct PruneStepResult
 	bool		scan_null;		/* Scan the partition for NULL values? */
 } PruneStepResult;
 
+/*
+ * expression_tree_walker context struct for gathering paramids of params
+ * matching the partition key.
+ */
+typedef struct PullParamContext
+{
+	Bitmapset  *params;
+} PullParamContext;
 
 static List *gen_partprune_steps(RelOptInfo *rel, List *clauses,
 					bool *contradictory);
@@ -162,7 +172,10 @@ static PruneStepResult *get_matching_list_bounds(PartitionPruneContext *context,
 static PruneStepResult *get_matching_range_bounds(PartitionPruneContext *context,
 						  StrategyNumber opstrategy, Datum *values, int nvalues,
 						  FmgrInfo *partsupfunc, Bitmapset *nullkeys);
-static bool pull_partkey_params(PartitionPruneInfo *pinfo, List *steps);
+static Bitmapset *pull_exec_paramids(Expr *expr);
+static bool pull_exec_paramids_walker(Node *node, PullParamContext * context);
+static bool analyze_partkey_exprs(PartitionPruneInfo *pinfo, List *steps,
+					  int partnatts);
 static PruneStepResult *perform_pruning_base_step(PartitionPruneContext *context,
 						  PartitionPruneStepOp *opstep);
 static PruneStepResult *perform_pruning_combine_step(PartitionPruneContext *context,
@@ -197,7 +210,7 @@ make_partition_pruneinfo(PlannerInfo *root, List *partition_rels,
 	int		   *relid_subnode_map;
 	int		   *relid_subpart_map;
 	int			i;
-	bool		gotparam = false;
+	bool		doruntimeprune = false;
 
 	/*
 	 * Allocate two arrays to store the 1-based indexes of the 'subpaths' and
@@ -238,6 +251,7 @@ make_partition_pruneinfo(PlannerInfo *root, List *partition_rels,
 		RangeTblEntry *rte;
 		Bitmapset  *present_parts;
 		int			nparts = subpart->nparts;
+		int			partnatts = subpart->part_scheme->partnatts;
 		int		   *subnode_map;
 		int		   *subpart_map;
 		List	   *partprunequal;
@@ -320,17 +334,13 @@ make_partition_pruneinfo(PlannerInfo *root, List *partition_rels,
 		pinfo->pruning_steps = pruning_steps;
 		pinfo->present_parts = present_parts;
 		pinfo->nparts = nparts;
-		pinfo->extparams = NULL;
+		pinfo->nexprs = list_length(pruning_steps) * partnatts;
 		pinfo->execparams = NULL;
 		pinfo->subnode_map = subnode_map;
 		pinfo->subpart_map = subpart_map;
 
-		/*
-		 * Extract Params matching partition key and record if we got any.
-		 * We'll not bother enabling run-time pruning if no params matched the
-		 * partition key at any level of partitioning.
-		 */
-		gotparam |= pull_partkey_params(pinfo, pruning_steps);
+		/* Determine which pruning types should be enabled at this level */
+		doruntimeprune |= analyze_partkey_exprs(pinfo, pruning_steps, partnatts);
 
 		pinfolist = lappend(pinfolist, pinfo);
 	}
@@ -338,14 +348,10 @@ make_partition_pruneinfo(PlannerInfo *root, List *partition_rels,
 	pfree(relid_subnode_map);
 	pfree(relid_subpart_map);
 
-	if (gotparam)
+	if (doruntimeprune)
 		return pinfolist;
 
-	/*
-	 * If no Params were found to match the partition key on any of the
-	 * partitioned relations then there's no point doing any run-time
-	 * partition pruning.
-	 */
+	/* No run-time pruning required. */
 	return NIL;
 }
 
@@ -444,9 +450,10 @@ prune_append_rel_partitions(RelOptInfo *rel)
 	context.boundinfo = rel->boundinfo;
 
 	/* Not valid when being called from the planner */
+	context.evalexecparams = false;
 	context.planstate = NULL;
-	context.safeparams = NULL;
 	context.exprstates = NULL;
+	context.exprhasexecparam = NULL;
 
 	/* Actual pruning happens here. */
 	partindexes = get_matching_partitions(&context, pruning_steps);
@@ -1478,6 +1485,10 @@ match_clause_to_partition_key(RelOptInfo *rel,
 		if (contain_volatile_functions((Node *) expr))
 			return PARTCLAUSE_UNSUPPORTED;
 
+		/* We can't prune using an expression with Vars. */
+		if (contain_var_clause((Node *) expr))
+			return PARTCLAUSE_UNSUPPORTED;
+
 		/*
 		 * Determine the input types of the operator we're considering.
 		 *
@@ -1655,7 +1666,7 @@ match_clause_to_partition_key(RelOptInfo *rel,
 					return PARTCLAUSE_UNSUPPORTED;
 			}
 			else
-				return PARTCLAUSE_UNSUPPORTED; /* no useful negator */
+				return PARTCLAUSE_UNSUPPORTED;	/* no useful negator */
 		}
 
 		/*
@@ -2683,54 +2694,96 @@ get_matching_range_bounds(PartitionPruneContext *context,
 }
 
 /*
- * pull_partkey_params
- *		Loop through each pruning step and record each external and exec
- *		Params being compared to the partition keys.
+ * pull_exec_paramids
+ *		Returns a Bitmapset containing the paramids of each Param with
+ *		paramkind = PARAM_EXEC in 'expr'.
+ */
+static Bitmapset *
+pull_exec_paramids(Expr *expr)
+{
+	PullParamContext context;
+
+	context.params = NULL;
+
+	pull_exec_paramids_walker((Node *) expr, &context);
+
+	return context.params;
+}
+
+static bool
+pull_exec_paramids_walker(Node *node, PullParamContext * context)
+{
+	if (node == NULL)
+		return false;
+	if (IsA(node, Param))
+	{
+		Param	   *param = (Param *) node;
+
+		if (param->paramkind == PARAM_EXEC)
+			context->params = bms_add_member(context->params, param->paramid);
+		return false;
+	}
+	return expression_tree_walker(node, pull_exec_paramids_walker,
+								  (void *) context);
+}
+
+/*
+ * analyze_partkey_exprs
+ *		Loop through each pruning steps recording which one are comparing exec
+ *		params to the partition key.
+ *
+ * Returns true if run-time partition pruning should be attempted at this
+ * level.
  */
 static bool
-pull_partkey_params(PartitionPruneInfo *pinfo, List *steps)
+analyze_partkey_exprs(PartitionPruneInfo *pinfo, List *steps, int partnatts)
 {
 	ListCell   *lc;
-	bool		gotone = false;
+	bool		doruntimeprune = false;
+
+	pinfo->hasexecparam = palloc0(sizeof(bool) * pinfo->nexprs);
+	pinfo->do_initial_prune = false;
+	pinfo->do_exec_prune = false;
 
 	foreach(lc, steps)
 	{
-		PartitionPruneStepOp *stepop = lfirst(lc);
+		PartitionPruneStepOp *step = lfirst(lc);
 		ListCell   *lc2;
+		int			keyno;
 
-		if (!IsA(stepop, PartitionPruneStepOp))
+		if (!IsA(step, PartitionPruneStepOp))
 			continue;
 
-		foreach(lc2, stepop->exprs)
+		keyno = 0;
+		foreach(lc2, step->exprs)
 		{
 			Expr	   *expr = lfirst(lc2);
 
-			if (IsA(expr, Param))
+			if (!IsA(expr, Const))
 			{
-				Param	   *param = (Param *) expr;
-
-				switch (param->paramkind)
-				{
-					case PARAM_EXTERN:
-						pinfo->extparams = bms_add_member(pinfo->extparams,
-														  param->paramid);
-						break;
-					case PARAM_EXEC:
-						pinfo->execparams = bms_add_member(pinfo->execparams,
-														   param->paramid);
-						break;
+				Bitmapset  *execparams = pull_exec_paramids(expr);
+				bool		hasexecparams;
+				int			stateidx = PruneCxtStateIdx(partnatts,
+														step->step.step_id,
+														keyno);
+
+				hasexecparams = !bms_is_empty(execparams);
+				pinfo->hasexecparam[stateidx] = hasexecparams;
+				pinfo->execparams = bms_add_members(pinfo->execparams,
+													execparams);
+
+				if (!hasexecparams)
+					pinfo->do_initial_prune = true;
+				else
+					pinfo->do_exec_prune = true;
 
-					default:
-						elog(ERROR, "unrecognized paramkind: %d",
-							 (int) param->paramkind);
-						break;
-				}
-				gotone = true;
+				doruntimeprune = true;
 			}
+			keyno++;
 		}
 	}
 
-	return gotone;
+	return doruntimeprune;
 }
 
 /*
@@ -3031,37 +3084,40 @@ static bool
 partkey_datum_from_expr(PartitionPruneContext *context,
 						Expr *expr, int stateidx, Datum *value)
 {
-	switch (nodeTag(expr))
+	if (IsA(expr, Const))
 	{
-		case T_Const:
-			*value = ((Const *) expr)->constvalue;
-			return true;
-
-		case T_Param:
-
-			/*
-			 * When being called from the executor we may be able to evaluate
-			 * the Param's value.
-			 */
-			if (context->planstate &&
-				bms_is_member(((Param *) expr)->paramid, context->safeparams))
-			{
-				ExprState  *exprstate;
-				ExprContext *ectx;
-				bool		isNull;
+		*value = ((Const *) expr)->constvalue;
+		return true;
+	}
+	else
+	{
+		/*
+		 * When called from the executor we'll have a valid planstate so we
+		 * may be able to evaluate the expression which could not be folded to
+		 * a Const during planning.  Since run-time pruning can occur both
+		 * during initialization of the executor or while it's running, we
+		 * must be careful here only to attempt to evaluate expressions
+		 * containing exec params when the executor is running.
+		 */
+		if (context->planstate &&
+			(context->evalexecparams ||
+			 !context->exprhasexecparam[stateidx]))
+		{
+			ExprState  *exprstate;
+			ExprContext *ectx;
+			bool		isNull;
 
-				exprstate = context->exprstates[stateidx];
-				ectx = context->planstate->ps_ExprContext;
-				*value = ExecEvalExprSwitchContext(exprstate, ectx, &isNull);
-				if (isNull)
-					return false;
+			/* Exprs with volatile functions shouldn't make it here */
+			Assert(!contain_volatile_functions((Node *) expr));
 
-				return true;
-			}
-			break;
+			exprstate = context->exprstates[stateidx];
+			ectx = context->planstate->ps_ExprContext;
+			*value = ExecEvalExprSwitchContext(exprstate, ectx, &isNull);
+			if (isNull)
+				return false;
 
-		default:
-			break;
+			return true;
+		}
 	}
 
 	return false;
diff --git a/src/include/executor/execPartition.h b/src/include/executor/execPartition.h
index fc6e9574e3..ed940a8a36 100644
--- a/src/include/executor/execPartition.h
+++ b/src/include/executor/execPartition.h
@@ -133,9 +133,12 @@ typedef struct PartitionTupleRouting
  *								the partition pruning code.
  * pruning_steps				Contains a list of PartitionPruneStep used to
  *								perform the actual pruning.
- * extparams					Contains paramids of external params found
+ * execparams					Contains paramids of exec params found
  *								matching partition keys in 'pruning_steps'.
- * allparams					As 'extparams' but also including exec params.
+ * do_initial_prune				true if pruning should be performed during
+ *								executor startup.
+ * do_exec_prune				true if pruning should be performed during
+ *								executor run.
  *-----------------------
  */
 typedef struct PartitionPruningData
@@ -145,8 +148,9 @@ typedef struct PartitionPruningData
 	Bitmapset  *present_parts;
 	PartitionPruneContext context;
 	List	   *pruning_steps;
-	Bitmapset  *extparams;
-	Bitmapset  *allparams;
+	Bitmapset  *execparams;
+	bool		do_initial_prune;
+	bool		do_exec_prune;
 } PartitionPruningData;
 
 /*-----------------------
@@ -163,24 +167,22 @@ typedef struct PartitionPruningData
  *						partitioned relation. First element contains the
  *						details for the target partitioned table.
  * num_partprunedata	Number of items in 'partprunedata' array.
+ * do_initial_prune		true if pruning should be performed during executor
+ *						startup.
  * prune_context		A memory context which can be used to call the query
  *						planner's partition prune functions.
- * extparams			All PARAM_EXTERN paramids which were found to match a
+ * execparams			All PARAM_EXEC paramids which were found to match a
  *						partition key in each of the contained
  *						PartitionPruningData structs.
- * execparams			As above but for PARAM_EXEC.
- * allparams			Union of 'extparams' and 'execparams', saved to avoid
- *						recalculation.
  *-----------------------
  */
 typedef struct PartitionPruneState
 {
 	PartitionPruningData *partprunedata;
 	int			num_partprunedata;
+	bool		do_initial_prune;
 	MemoryContext prune_context;
-	Bitmapset  *extparams;
 	Bitmapset  *execparams;
-	Bitmapset  *allparams;
 } PartitionPruneState;
 
 extern PartitionTupleRouting *ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
diff --git a/src/include/nodes/primnodes.h b/src/include/nodes/primnodes.h
index f90aa7b2a1..e4c366b58f 100644
--- a/src/include/nodes/primnodes.h
+++ b/src/include/nodes/primnodes.h
@@ -1598,9 +1598,16 @@ typedef struct PartitionPruneInfo
 	Bitmapset  *present_parts;	/* Indexes of all partitions which subnodes
 								 * are present for. */
 	int			nparts;			/* The length of the following two arrays */
+	int			nexprs;			/* Size of hasexecparam array */
 	int		   *subnode_map;	/* subnode index by partition id, or -1 */
 	int		   *subpart_map;	/* subpart index by partition id, or -1 */
-	Bitmapset  *extparams;		/* All external paramids seen in prunesteps */
+	bool	   *hasexecparam;	/* true if corresponding pruning_step has an
+								 * exec Param in the Expr being compared to
+								 * the partition key. */
+	bool		do_initial_prune;	/* true if pruning should be performed
+									 * during executor startup. */
+	bool		do_exec_prune;	/* true if pruning should be performed during
+								 * executor run. */
 	Bitmapset  *execparams;		/* All exec paramids seen in prunesteps */
 } PartitionPruneInfo;
 
diff --git a/src/include/partitioning/partprune.h b/src/include/partitioning/partprune.h
index 3d114b4c71..028d4cecb6 100644
--- a/src/include/partitioning/partprune.h
+++ b/src/include/partitioning/partprune.h
@@ -36,6 +36,9 @@ typedef struct PartitionPruneContext
 	/* Number of partitions */
 	int			nparts;
 
+	/* true if it's safe to evaulate exec params */
+	bool		evalexecparams;
+
 	/* Partition boundary info */
 	PartitionBoundInfo boundinfo;
 
@@ -45,18 +48,15 @@ typedef struct PartitionPruneContext
 	 */
 	PlanState  *planstate;
 
-	/*
-	 * Parameters that are safe to be used for partition pruning. execparams
-	 * are not safe to use until the executor is running.
-	 */
-	Bitmapset  *safeparams;
-
 	/*
 	 * Array of ExprStates, indexed as per PruneCtxStateIdx; one for each
 	 * partkey in each pruning step.  Allocated if planstate is non-NULL,
 	 * otherwise NULL.
 	 */
 	ExprState **exprstates;
+
+	/* true if corresponding 'exprstate' expression contains an exec param */
+	bool	   *exprhasexecparam;
 } PartitionPruneContext;
 
 #define PruneCxtStateIdx(partnatts, step_id, keyno) \
diff --git a/src/test/regress/expected/partition_prune.out b/src/test/regress/expected/partition_prune.out
index cf331e79c1..64b4e933d6 100644
--- a/src/test/regress/expected/partition_prune.out
+++ b/src/test/regress/expected/partition_prune.out
@@ -1835,6 +1835,54 @@ fetch backward all from cur;
 (2 rows)
 
 commit;
+begin;
+-- Test run-time pruning using stable functions
+create function list_part_fn(int) returns int as $$ begin return $1; end;$$ language plpgsql stable;
+-- Ensure pruning works using a stable function containing no Vars
+explain (analyze, costs off, summary off, timing off) select * from list_part where a = list_part_fn(1);
+                      QUERY PLAN                      
+------------------------------------------------------
+ Append (actual rows=1 loops=1)
+   Subplans Removed: 3
+   ->  Seq Scan on list_part1 (actual rows=1 loops=1)
+         Filter: (a = list_part_fn(1))
+(4 rows)
+
+-- Ensure pruning does not take place when the function contains a Var parameter
+explain (analyze, costs off, summary off, timing off) select * from list_part where a = list_part_fn(a);
+                      QUERY PLAN                      
+------------------------------------------------------
+ Append (actual rows=4 loops=1)
+   ->  Seq Scan on list_part1 (actual rows=1 loops=1)
+         Filter: (a = list_part_fn(a))
+   ->  Seq Scan on list_part2 (actual rows=1 loops=1)
+         Filter: (a = list_part_fn(a))
+   ->  Seq Scan on list_part3 (actual rows=1 loops=1)
+         Filter: (a = list_part_fn(a))
+   ->  Seq Scan on list_part4 (actual rows=1 loops=1)
+         Filter: (a = list_part_fn(a))
+(9 rows)
+
+-- Ensure pruning does not take place when the expression contains a Var.
+explain (analyze, costs off, summary off, timing off) select * from list_part where a = list_part_fn(1) + a;
+                      QUERY PLAN                      
+------------------------------------------------------
+ Append (actual rows=0 loops=1)
+   ->  Seq Scan on list_part1 (actual rows=0 loops=1)
+         Filter: (a = (list_part_fn(1) + a))
+         Rows Removed by Filter: 1
+   ->  Seq Scan on list_part2 (actual rows=0 loops=1)
+         Filter: (a = (list_part_fn(1) + a))
+         Rows Removed by Filter: 1
+   ->  Seq Scan on list_part3 (actual rows=0 loops=1)
+         Filter: (a = (list_part_fn(1) + a))
+         Rows Removed by Filter: 1
+   ->  Seq Scan on list_part4 (actual rows=0 loops=1)
+         Filter: (a = (list_part_fn(1) + a))
+         Rows Removed by Filter: 1
+(13 rows)
+
+rollback;
 drop table list_part;
 -- Parallel append
 -- Suppress the number of loops each parallel node runs for.  This is because
@@ -2079,6 +2127,40 @@ select explain_parallel_append('select avg(ab.a) from ab inner join lprt_a a on
                                  Index Cond: (a = a.a)
 (27 rows)
 
+-- Ensure the same partitions are pruned when we make the nested loop
+-- parameter an Expr rather than a plain Param.
+select explain_parallel_append('select avg(ab.a) from ab inner join lprt_a a on ab.a = a.a + 0 where a.a in(0, 0, 1)');
+                                      explain_parallel_append                                      
+---------------------------------------------------------------------------------------------------
+ Finalize Aggregate (actual rows=1 loops=1)
+   ->  Gather (actual rows=2 loops=1)
+         Workers Planned: 1
+         Workers Launched: 1
+         ->  Partial Aggregate (actual rows=1 loops=2)
+               ->  Nested Loop (actual rows=0 loops=2)
+                     ->  Parallel Seq Scan on lprt_a a (actual rows=51 loops=N)
+                           Filter: (a = ANY ('{0,0,1}'::integer[]))
+                     ->  Append (actual rows=0 loops=102)
+                           ->  Index Scan using ab_a1_b1_a_idx on ab_a1_b1 (actual rows=0 loops=2)
+                                 Index Cond: (a = (a.a + 0))
+                           ->  Index Scan using ab_a1_b2_a_idx on ab_a1_b2 (actual rows=0 loops=2)
+                                 Index Cond: (a = (a.a + 0))
+                           ->  Index Scan using ab_a1_b3_a_idx on ab_a1_b3 (actual rows=0 loops=2)
+                                 Index Cond: (a = (a.a + 0))
+                           ->  Index Scan using ab_a2_b1_a_idx on ab_a2_b1 (never executed)
+                                 Index Cond: (a = (a.a + 0))
+                           ->  Index Scan using ab_a2_b2_a_idx on ab_a2_b2 (never executed)
+                                 Index Cond: (a = (a.a + 0))
+                           ->  Index Scan using ab_a2_b3_a_idx on ab_a2_b3 (never executed)
+                                 Index Cond: (a = (a.a + 0))
+                           ->  Index Scan using ab_a3_b1_a_idx on ab_a3_b1 (never executed)
+                                 Index Cond: (a = (a.a + 0))
+                           ->  Index Scan using ab_a3_b2_a_idx on ab_a3_b2 (never executed)
+                                 Index Cond: (a = (a.a + 0))
+                           ->  Index Scan using ab_a3_b3_a_idx on ab_a3_b3 (never executed)
+                                 Index Cond: (a = (a.a + 0))
+(27 rows)
+
 insert into lprt_a values(3),(3);
 select explain_parallel_append('select avg(ab.a) from ab inner join lprt_a a on ab.a = a.a where a.a in(1, 0, 3)');
                                       explain_parallel_append                                      
diff --git a/src/test/regress/sql/partition_prune.sql b/src/test/regress/sql/partition_prune.sql
index 1464f4dcd9..b6681fa44c 100644
--- a/src/test/regress/sql/partition_prune.sql
+++ b/src/test/regress/sql/partition_prune.sql
@@ -396,6 +396,22 @@ fetch backward all from cur;
 
 commit;
 
+begin;
+
+-- Test run-time pruning using stable functions
+create function list_part_fn(int) returns int as $$ begin return $1; end;$$ language plpgsql stable;
+
+-- Ensure pruning works using a stable function containing no Vars
+explain (analyze, costs off, summary off, timing off) select * from list_part where a = list_part_fn(1);
+
+-- Ensure pruning does not take place when the function contains a Var parameter
+explain (analyze, costs off, summary off, timing off) select * from list_part where a = list_part_fn(a);
+
+-- Ensure pruning does not take place when the expression contains a Var.
+explain (analyze, costs off, summary off, timing off) select * from list_part where a = list_part_fn(1) + a;
+
+rollback;
+
 drop table list_part;
 
 -- Parallel append
@@ -486,6 +502,10 @@ set enable_mergejoin = 0;
 
 select explain_parallel_append('select avg(ab.a) from ab inner join lprt_a a on ab.a = a.a where a.a in(0, 0, 1)');
 
+-- Ensure the same partitions are pruned when we make the nested loop
+-- parameter an Expr rather than a plain Param.
+select explain_parallel_append('select avg(ab.a) from ab inner join lprt_a a on ab.a = a.a + 0 where a.a in(0, 0, 1)');
+
 insert into lprt_a values(3),(3);
 
 select explain_parallel_append('select avg(ab.a) from ab inner join lprt_a a on ab.a = a.a where a.a in(1, 0, 3)');

diff --git a/src/backend/executor/execPartition.c b/src/backend/executor/execPartition.c
index c83991c93c..f185e47889 100644
--- a/src/backend/executor/execPartition.c
+++ b/src/backend/executor/execPartition.c
@@ -48,9 +48,9 @@ static char *ExecBuildSlotPartitionKeyDescription(Relation rel,
 									 bool *isnull,
 									 int maxfieldlen);
 static List *adjust_partition_tlist(List *tlist, TupleConversionMap *map);
-static void find_subplans_for_params_recurse(PartitionPruneState *prunestate,
+static int find_subplans_for_params_recurse(PartitionPruneState *prunestate,
 								 PartitionPruningData *pprune,
-								 bool allparams,
+								 bool initial_prune,
 								 Bitmapset **validsubplans);
 
 
@@ -1334,54 +1334,53 @@ adjust_partition_tlist(List *tlist, TupleConversionMap *map)
  * Run-Time Partition Pruning Support.
  *
  * The following series of functions exist to support the removal of unneeded
- * subnodes for queries against partitioned tables.  The supporting functions
+ * subplans for queries against partitioned tables.  The supporting functions
  * here are designed to work with any node type which supports an arbitrary
- * number of subnodes, e.g. Append, MergeAppend.
+ * number of subplans, e.g. Append, MergeAppend.
  *
- * Normally this pruning work is performed by the query planner's partition
- * pruning code, however, the planner is limited to only being able to prune
- * away unneeded partitions using quals which compare the partition key to a
- * value which is known to be Const during planning.  To allow the same
- * pruning to be performed for values which are only determined during
- * execution, we must make an additional pruning attempt during execution.
+ * Run-time pruning works in addition to plan-time pruning, however, during
+ * query planning, pruning is limited to only being able to use expressions
+ * which are known Consts.  To allow pruning to be performed using values which
+ * aren't known during planning, we must make an additional pruning attempt
+ * during execution.
  *
- * Here we support pruning using both external and exec Params.  The main
- * difference between these that we need to concern ourselves with is the
- * time when the values of the Params are known.  External Param values are
- * known at any time of execution, including executor startup, but exec Param
- * values are only known when the executor is running.
+ * Here we support pruning using any non-volatile expression, thus allowing
+ * pruning to be performed using both external and exec params, in fact, any
+ * stable expression approved by gen_partprune_steps can be evaluated and
+ * used here.  However, if an expression contains an exec param it cannot be
+ * evaluated until during execution. For everything else, we can perform
+ * pruning during executor startup.
  *
- * For external Params we may be able to prune away unneeded partitions
- * during executor startup.  This has the added benefit of not having to
- * initialize the unneeded subnodes at all.  This is useful as it can save
- * quite a bit of effort during executor startup.
+ * When performing pruning using expressions containing exec params, we must
+ * perform partition pruning again each time one of these params changes.  It
+ * is the calling code's responsibility to ensure that this happens.
  *
- * For exec Params, we must delay pruning until the executor is running.
+ * Having the ability to prune away unneeded subplans during executor startup
+ * has the added benefit of not having to initialize the unneeded subplans.
  *
  * Functions:
  *
  * ExecSetupPartitionPruneState:
- *		This must be called by nodes before any partition pruning is
- *		attempted.  Normally executor startup is a good time. This function
- *		creates the PartitionPruneState details which are required by each
- *		of the two pruning functions, details include information about
- *		how to map the partition index details which are returned by the
- *		planner's partition prune function into subnode indexes.
+ *		Creates the PartitionPruneState as required by each of the two pruning
+ *		functions.  Details stored include how to map the partition index
+ *		returned by the partition pruning code into subplans indexes.
  *
  * ExecFindInitialMatchingSubPlans:
- *		Returns indexes of matching subnodes utilizing only external Params
- *		to eliminate subnodes.  The function must only be called during
- *		executor startup for the given node before the subnodes themselves
- *		are initialized.  Subnodes which are found not to match by this
- *		function must not be included in the node's list of subnodes as this
- *		function performs a remap of the partition index to subplan index map
- *		and the newly created map provides indexes only for subnodes which
- *		remain after calling this function.
+ *		Returns indexes of matching subplans.  Here partition pruning is
+ *		performed using all expressions found in the partition pruning steps
+ *		apart from expressions containing exec params.  This function must
+ *		only be called once and must only ne called during initialization of
+ *		the node which it applies to.  Subplans which are found not to match
+ *		by this function must not be included in the node's list of subplans
+ *		as this function performs a remap of the partition index to subplan
+ *		index map and the newly created map provides indexes only for subplans
+ *		which remain after calling this function.
  *
  * ExecFindMatchingSubPlans:
- *		Returns indexes of matching subnodes utilizing all Params to eliminate
- *		subnodes which can't possibly contain matching tuples.  This function
- *		can only be called while the executor is running.
+ *		Returns indexes of matching subplans evaluating all expressions in the
+ *		pruning steps, including exec params.  This function can only be
+ *		called during execution and must be called again each time the value
+ *		of a param listed in PartitionPruneState's 'execparams' changes.
  *-------------------------------------------------------------------------
  */
 
@@ -1392,32 +1391,29 @@ adjust_partition_tlist(List *tlist, TupleConversionMap *map)
  *
  * 'partitionpruneinfo' is a List of PartitionPruneInfos as generated by
  * make_partition_pruneinfo.  Here we build a PartitionPruneContext for each
- * item in the List.  These contexts can be re-used each time we re-evaulate
+ * item in that List.  These contexts can be re-used each time we reevaluate
  * which partitions match the pruning steps provided in each
  * PartitionPruneInfo.
  */
 PartitionPruneState *
 ExecSetupPartitionPruneState(PlanState *planstate, List *partitionpruneinfo)
 {
-	PartitionPruningData *prunedata;
 	PartitionPruneState *prunestate;
 	ListCell   *lc;
 	int			i;
+	int			num_partprunedata;
+	Size		size;
 
 	Assert(partitionpruneinfo != NIL);
 
-	prunestate = (PartitionPruneState *) palloc(sizeof(PartitionPruneState));
-	prunedata = (PartitionPruningData *)
-		palloc(sizeof(PartitionPruningData) * list_length(partitionpruneinfo));
+	num_partprunedata = list_length(partitionpruneinfo);
+	size = offsetof(PartitionPruneState, partprunedata);
+	size += sizeof(PartitionPruningData) * num_partprunedata;
 
-	/*
-	 * The first item in the array contains the details for the query's target
-	 * partition, so record that as the root of the partition hierarchy.
-	 */
-	prunestate->partprunedata = prunedata;
-	prunestate->num_partprunedata = list_length(partitionpruneinfo);
-	prunestate->extparams = NULL;
+	prunestate = (PartitionPruneState *) palloc(size);
+	prunestate->num_partprunedata = num_partprunedata;
 	prunestate->execparams = NULL;
+	prunestate->do_initial_prune = false;	/* may be set below */
 
 	/*
 	 * Create a sub memory context which we'll use when making calls to the
@@ -1435,7 +1431,7 @@ ExecSetupPartitionPruneState(PlanState *planstate, List *partitionpruneinfo)
 	foreach(lc, partitionpruneinfo)
 	{
 		PartitionPruneInfo *pinfo = (PartitionPruneInfo *) lfirst(lc);
-		PartitionPruningData *pprune = &prunedata[i];
+		PartitionPruningData *pprune = &prunestate->partprunedata[i];
 		PartitionPruneContext *context = &pprune->context;
 		PartitionDesc partdesc;
 		Relation	rel;
@@ -1444,24 +1440,24 @@ ExecSetupPartitionPruneState(PlanState *planstate, List *partitionpruneinfo)
 		int			partnatts;
 		int			n_steps;
 
-		pprune->present_parts = bms_copy(pinfo->present_parts);
-		pprune->subnode_map = palloc(sizeof(int) * pinfo->nparts);
+		pprune->present_parts = pinfo->present_parts;
+		pprune->subplan_map = palloc(sizeof(int) * pinfo->nparts);
 
 		/*
 		 * We must make a copy of this rather than pointing directly to the
 		 * plan's version as we may end up making modifications to it later.
 		 */
-		memcpy(pprune->subnode_map, pinfo->subnode_map,
+		memcpy(pprune->subplan_map, pinfo->subplan_map,
 			   sizeof(int) * pinfo->nparts);
 
-		/* We can use the subpart_map verbatim, since we never modify it */
+		/* We can use the subpart_map verbatim since we never modify it */
 		pprune->subpart_map = pinfo->subpart_map;
 
 		/*
 		 * Grab some info from the table's relcache; lock was already obtained
 		 * by ExecLockNonLeafAppendTables.
 		 */
-		rel = relation_open(pinfo->reloid, NoLock);
+		rel = heap_open(pinfo->reloid, NoLock);
 
 		partkey = RelationGetPartitionKey(rel);
 		partdesc = RelationGetPartitionDesc(rel);
@@ -1476,9 +1472,14 @@ ExecSetupPartitionPruneState(PlanState *planstate, List *partitionpruneinfo)
 		context->nparts = pinfo->nparts;
 		context->boundinfo = partition_bounds_copy(partdesc->boundinfo, partkey);
 		context->planstate = planstate;
-		context->safeparams = NULL; /* empty for now */
 		context->exprstates = palloc0(sizeof(ExprState *) * n_steps * partnatts);
 
+		/*
+		 * Use the hasexecparam. This is not modified anywhere, so we just
+		 * borrow the plan's copy.
+		 */
+		context->exprhasexecparam = pinfo->hasexecparam;
+
 		/* Initialize expression states for each expression */
 		foreach(lc2, pinfo->pruning_steps)
 		{
@@ -1511,65 +1512,51 @@ ExecSetupPartitionPruneState(PlanState *planstate, List *partitionpruneinfo)
 		}
 
 		pprune->pruning_steps = pinfo->pruning_steps;
-		pprune->extparams = bms_copy(pinfo->extparams);
-		pprune->allparams = bms_union(pinfo->extparams, pinfo->execparams);
+		pprune->execparams = pinfo->execparams;
+		pprune->do_initial_prune = pinfo->do_initial_prune;
+		pprune->do_exec_prune = pinfo->do_exec_prune;
 
 		/*
-		 * Accumulate the paramids which match the partitioned keys of all
-		 * partitioned tables.
+		 * Accumulate the exec paramids which match the partitioned keys of
+		 * all partitioned tables.
 		 */
-		prunestate->extparams = bms_add_members(prunestate->extparams,
-												pinfo->extparams);
-
 		prunestate->execparams = bms_add_members(prunestate->execparams,
 												 pinfo->execparams);
 
-		relation_close(rel, NoLock);
+		/*
+		 * Record if an initial prune would be useful at any level of the
+		 * partition hierarchy.
+		 */
+		prunestate->do_initial_prune |= pinfo->do_initial_prune;
+
+		heap_close(rel, NoLock);
 
 		i++;
 	}
 
-	/*
-	 * Cache the union of the paramids of both types.  This saves having to
-	 * recalculate it everytime we need to know what they are.
-	 */
-	prunestate->allparams = bms_union(prunestate->extparams,
-									  prunestate->execparams);
-
 	return prunestate;
 }
 
 /*
  * ExecFindInitialMatchingSubPlans
- *		Determine which subset of subplan nodes we need to initialize based
- *		on the details stored in 'prunestate'.  Here we only determine the
- *		matching partitions using values known during plan startup, which is
- *		only external Params.  Exec Params will be unknown at this time.  We
- *		must delay pruning using exec Params until the actual executor run.
- *
- * It is expected that callers of this function do so only once during their
- * init plan.  The caller must only initialize the subnodes which are returned
- * by this function. The remaining subnodes should be discarded.  Once this
- * function has been called, future calls to ExecFindMatchingSubPlans will
- * return its matching subnode indexes assuming that the caller discarded
- * the original non-matching subnodes.
+ *		Determine the minimum set of subplans matching these pruning steps
+ *		without evaluation of exec Params.  We also re-map the translation
+ *		matrix which allows conversion of partition indexes into subplan index
+ *		to account for the unneeded subplans having been removed.
  *
- * This function must only be called if 'prunestate' has any extparams.
+ * Must only be called once per 'prunestate'.
  *
- * 'nsubnodes' must be passed as the total number of unpruned subnodes.
+ * 'nsubplans' must be passed as the total number of unpruned subplans.
  */
 Bitmapset *
-ExecFindInitialMatchingSubPlans(PartitionPruneState *prunestate, int nsubnodes)
+ExecFindInitialMatchingSubPlans(PartitionPruneState *prunestate, int nsubplans)
 {
 	PartitionPruningData *pprune;
 	MemoryContext oldcontext;
 	Bitmapset  *result = NULL;
+	int			matches;
 
-	/*
-	 * Ensure there's actually external params, or we've not been called
-	 * already.
-	 */
-	Assert(!bms_is_empty(prunestate->extparams));
+	Assert(prunestate->do_initial_prune);
 
 	pprune = prunestate->partprunedata;
 
@@ -1579,8 +1566,9 @@ ExecFindInitialMatchingSubPlans(PartitionPruneState *prunestate, int nsubnodes)
 	 */
 	oldcontext = MemoryContextSwitchTo(prunestate->prune_context);
 
-	/* Determine which subnodes match the external params */
-	find_subplans_for_params_recurse(prunestate, pprune, false, &result);
+	/* Perform pruning without using exec params */
+	matches = find_subplans_for_params_recurse(prunestate, pprune, true,
+											   &result);
 
 	MemoryContextSwitchTo(oldcontext);
 
@@ -1590,86 +1578,113 @@ ExecFindInitialMatchingSubPlans(PartitionPruneState *prunestate, int nsubnodes)
 	MemoryContextReset(prunestate->prune_context);
 
 	/*
-	 * Record that partition pruning has been performed for external params.
-	 * These are not required again afterwards, and nullifying them helps
-	 * ensure nothing accidentally calls this function twice on the same
-	 * PartitionPruneState.
-	 *
-	 * (Note we keep prunestate->allparams, because we do use that one
-	 * repeatedly in ExecFindMatchingSubPlans).
-	 */
-	bms_free(prunestate->extparams);
-	prunestate->extparams = NULL;
-
-	/*
-	 * If any subnodes were pruned, we must re-sequence the subnode indexes so
+	 * If any subplans were pruned, we must re-sequence the subplan indexes so
 	 * that ExecFindMatchingSubPlans properly returns the indexes from the
-	 * subnodes which will remain after execution of this function.
+	 * subplans which will remain after execution of this function.
 	 */
-	if (bms_num_members(result) < nsubnodes)
+	if (matches < nsubplans)
 	{
-		int		   *new_subnode_indexes;
+		int		   *new_subplan_indexes;
 		int			i;
 		int			newidx;
+		int			num_partprunedata;
 
 		/*
-		 * First we must build an array which we can use to adjust the
-		 * existing subnode_map so that it contains the new subnode indexes.
+		 * First we must build an array which to stores the new 1-based index
+		 * of the subplan node.  Elements which are set to 0 after this are
+		 * newly pruned partitions.
 		 */
-		new_subnode_indexes = (int *) palloc(sizeof(int) * nsubnodes);
-		newidx = 0;
-		for (i = 0; i < nsubnodes; i++)
-		{
-			if (bms_is_member(i, result))
-				new_subnode_indexes[i] = newidx++;
-			else
-				new_subnode_indexes[i] = -1;	/* Newly pruned */
-		}
+		new_subplan_indexes = (int *) palloc0(sizeof(int) * nsubplans);
+		newidx = 1;
+		i = -1;
+		while ((i = bms_next_member(result, i)) >= 0)
+			new_subplan_indexes[i] = newidx++;
+
+		num_partprunedata = prunestate->num_partprunedata;
 
 		/*
-		 * Now we can re-sequence each PartitionPruneInfo's subnode_map so
-		 * that they point to the new index of the subnode.
+		 * Now we can re-sequence each PartitionPruneInfo's subplan_map so
+		 * that they point to the new index of the subplan.
 		 */
-		for (i = 0; i < prunestate->num_partprunedata; i++)
+		for (i = 0; i < num_partprunedata; i++)
 		{
-			int			nparts;
+			Bitmapset  *new_parts = NULL;
 			int			j;
 
 			pprune = &prunestate->partprunedata[i];
-			nparts = pprune->context.nparts;
 
-			/*
-			 * We also need to reset the present_parts field so that it only
-			 * contains partition indexes that we actually still have subnodes
-			 * for.  It seems easier to build a fresh one, rather than trying
-			 * to update the existing one.
-			 */
-			bms_free(pprune->present_parts);
-			pprune->present_parts = NULL;
-
-			for (j = 0; j < nparts; j++)
+			/* Redetermine which partitions are now present. */
+			j = -1;
+			while ((j = bms_next_member(pprune->present_parts, j)) >= 0)
 			{
-				int			oldidx = pprune->subnode_map[j];
+				int			oldidx = pprune->subplan_map[j];
 
 				/*
-				 * If this partition existed as a subnode then change the old
-				 * subnode index to the new subnode index.  The new index may
+				 * If this partition existed as a subplan then change the old
+				 * subplan index to the new subplan index.  The new index may
 				 * become -1 if the partition was pruned above, or it may just
-				 * come earlier in the subnode list due to some subnodes being
+				 * come earlier in the subplan list due to some subplans being
 				 * removed earlier in the list.
 				 */
 				if (oldidx >= 0)
 				{
-					pprune->subnode_map[j] = new_subnode_indexes[oldidx];
+					int			newidx = new_subplan_indexes[oldidx] - 1;
+
+					pprune->subplan_map[j] = newidx;
 
-					if (new_subnode_indexes[oldidx] >= 0)
-						pprune->present_parts =
-							bms_add_member(pprune->present_parts, j);
+					if (newidx >= 0)
+						new_parts = bms_add_member(new_parts, j);
 				}
 			}
+
+			/*
+			 * Replace without pfreeing the original, since that memory
+			 * belongs to the plan.
+			 */
+			pprune->present_parts = new_parts;
 		}
 
-		pfree(new_subnode_indexes);
+		/*
+		 * Now we must determine which sub-partitioned tables still have
+		 * unpruned partitions.  The easiest way to do this is to simply loop
+		 * over each PartitionPruningData again checking if there are any
+		 * 'present_parts' for the sub-partitioned table.  We needn't bother
+		 * doing this if there are no sub-partitioned tables.
+		 */
+		if (num_partprunedata > 1)
+		{
+			for (i = 0; i < num_partprunedata; i++)
+			{
+				int			nparts;
+				int			j;
+
+				pprune = &prunestate->partprunedata[i];
+				nparts = pprune->context.nparts;
+
+				/*
+				 * XXX if we still had the old present_parts available then we
+				 * could do a bms_next_member() loop here.  Is it worth
+				 * stashing it somewhere to allow that?
+				 */
+				for (j = 0; j < nparts; j++)
+				{
+					int			subidx = pprune->subpart_map[j];
+
+					if (subidx >= 0)
+					{
+						PartitionPruningData *subprune;
+
+						subprune = &prunestate->partprunedata[subidx];
+
+						if (!bms_is_empty(subprune->present_parts))
+							pprune->present_parts =
+								bms_add_member(pprune->present_parts, j);
+					}
+				}
+			}
+		}
+
+		pfree(new_subplan_indexes);
 	}
 
 	return result;
@@ -1677,10 +1692,8 @@ ExecFindInitialMatchingSubPlans(PartitionPruneState *prunestate, int nsubnodes)
 
 /*
  * ExecFindMatchingSubPlans
- *		Determine which subplans match the pruning steps detailed in
- *		'pprune' for the current Param values.
- *
- * Here we utilize both external and exec Params for pruning.
+ *		Determine which subplan are required based on the sets of pruning
+ *		steps stored in 'prunestate'.
  */
 Bitmapset *
 ExecFindMatchingSubPlans(PartitionPruneState *prunestate)
@@ -1697,7 +1710,7 @@ ExecFindMatchingSubPlans(PartitionPruneState *prunestate)
 	 */
 	oldcontext = MemoryContextSwitchTo(prunestate->prune_context);
 
-	find_subplans_for_params_recurse(prunestate, pprune, true, &result);
+	find_subplans_for_params_recurse(prunestate, pprune, false, &result);
 
 	MemoryContextSwitchTo(oldcontext);
 
@@ -1712,73 +1725,68 @@ ExecFindMatchingSubPlans(PartitionPruneState *prunestate)
 /*
  * find_subplans_for_params_recurse
  *		Recursive worker function for ExecFindMatchingSubPlans and
- *		ExecFindInitialMatchingSubPlans
+ *		ExecFindInitialMatchingSubPlans.
+ *
+ * Returns the number of matching subplans found.
  */
-static void
+static int
 find_subplans_for_params_recurse(PartitionPruneState *prunestate,
 								 PartitionPruningData *pprune,
-								 bool allparams,
+								 bool initial_prune,
 								 Bitmapset **validsubplans)
 {
 	PartitionPruneContext *context = &pprune->context;
 	Bitmapset  *partset;
-	Bitmapset  *pruneparams;
+	int			matches = 0;
+	int			partidx;
 	int			i;
 
 	/* Guard against stack overflow due to overly deep partition hierarchy. */
 	check_stack_depth();
 
 	/*
-	 * Use only external params unless we've been asked to also use exec
-	 * params too.
-	 */
-	if (allparams)
-		pruneparams = pprune->allparams;
-	else
-		pruneparams = pprune->extparams;
-
-	/*
-	 * We only need to determine the matching partitions if there are any
-	 * params matching the partition key at this level.  If there are no
-	 * matching params, then we can simply return all subnodes which belong to
-	 * this parent partition.  The planner should have already determined
-	 * these to be the minimum possible set.  We must still recursively visit
-	 * any subpartitioned tables as we may find their partition keys match
-	 * some Params at their level.
+	 * Only prune if pruning would be useful at this level.  Pruning is free
+	 * to evaluate exec params when initial_prune is false.
 	 */
-	if (!bms_is_empty(pruneparams))
+	if (!initial_prune && pprune->do_exec_prune)
 	{
-		context->safeparams = pruneparams;
+		context->evalexecparams = true;
+		partset = get_matching_partitions(context,
+										  pprune->pruning_steps);
+	}
+	else if (initial_prune && pprune->do_initial_prune)
+	{
+		context->evalexecparams = false;
 		partset = get_matching_partitions(context,
 										  pprune->pruning_steps);
 	}
 	else
+	{
+		/* No pruning required?  Just include all partitions. */
 		partset = pprune->present_parts;
+	}
 
-	/* Translate partset into subnode indexes */
+	/* Translate partset into subplan indexes */
 	i = -1;
 	while ((i = bms_next_member(partset, i)) >= 0)
 	{
-		if (pprune->subnode_map[i] >= 0)
+		if (pprune->subplan_map[i] >= 0)
+		{
 			*validsubplans = bms_add_member(*validsubplans,
-											pprune->subnode_map[i]);
+											pprune->subplan_map[i]);
+			matches++;
+		}
+
+		/* Recurse if the partition is a partitioned table */
+		else if ((partidx = pprune->subpart_map[i]) >= 0)
+			matches += find_subplans_for_params_recurse(prunestate,
+														&prunestate->partprunedata[partidx],
+														initial_prune, validsubplans);
 		else
 		{
-			int			partidx = pprune->subpart_map[i];
-
-			if (partidx != -1)
-				find_subplans_for_params_recurse(prunestate,
-												 &prunestate->partprunedata[partidx],
-												 allparams, validsubplans);
-			else
-			{
-				/*
-				 * This could only happen if clauses used in planning where
-				 * more restrictive than those used here, or if the maps are
-				 * somehow corrupt.
-				 */
-				elog(ERROR, "partition missing from subplans");
-			}
+			/* Shouldn't happen */
+			elog(ERROR, "partition missing from subplans");
 		}
 	}
+	return matches;
 }
diff --git a/src/backend/executor/nodeAppend.c b/src/backend/executor/nodeAppend.c
index 6bc3e470bf..707a3e0e4b 100644
--- a/src/backend/executor/nodeAppend.c
+++ b/src/backend/executor/nodeAppend.c
@@ -138,11 +138,8 @@ ExecInitAppend(Append *node, EState *estate, int eflags)
 		prunestate = ExecSetupPartitionPruneState(&appendstate->ps,
 												  node->part_prune_infos);
 
-		/*
-		 * When there are external params matching the partition key we may be
-		 * able to prune away Append subplans now.
-		 */
-		if (!bms_is_empty(prunestate->extparams))
+		/* Perform an initial partition prune, if required. */
+		if (prunestate->do_initial_prune)
 		{
 			/* Determine which subplans match the external params */
 			validsubplans = ExecFindInitialMatchingSubPlans(prunestate,
diff --git a/src/backend/nodes/copyfuncs.c b/src/backend/nodes/copyfuncs.c
index 7c045a7afe..4c6bddaa35 100644
--- a/src/backend/nodes/copyfuncs.c
+++ b/src/backend/nodes/copyfuncs.c
@@ -1190,6 +1190,29 @@ _copyPlanInvalItem(const PlanInvalItem *from)
 	return newnode;
 }
 
+/*
+ * _copyPartitionPruneInfo
+ */
+static PartitionPruneInfo *
+_copyPartitionPruneInfo(const PartitionPruneInfo *from)
+{
+	PartitionPruneInfo *newnode = makeNode(PartitionPruneInfo);
+
+	COPY_SCALAR_FIELD(reloid);
+	COPY_NODE_FIELD(pruning_steps);
+	COPY_BITMAPSET_FIELD(present_parts);
+	COPY_SCALAR_FIELD(nparts);
+	COPY_SCALAR_FIELD(nexprs);
+	COPY_POINTER_FIELD(subplan_map, from->nparts * sizeof(int));
+	COPY_POINTER_FIELD(subpart_map, from->nparts * sizeof(int));
+	COPY_POINTER_FIELD(hasexecparam, from->nexprs * sizeof(bool));
+	COPY_SCALAR_FIELD(do_initial_prune);
+	COPY_SCALAR_FIELD(do_exec_prune);
+	COPY_BITMAPSET_FIELD(execparams);
+
+	return newnode;
+}
+
 /* ****************************************************************
  *					   primnodes.h copy functions
  * ****************************************************************
@@ -2166,23 +2189,6 @@ _copyPartitionPruneStepCombine(const PartitionPruneStepCombine *from)
 	return newnode;
 }
 
-static PartitionPruneInfo *
-_copyPartitionPruneInfo(const PartitionPruneInfo *from)
-{
-	PartitionPruneInfo *newnode = makeNode(PartitionPruneInfo);
-
-	COPY_SCALAR_FIELD(reloid);
-	COPY_NODE_FIELD(pruning_steps);
-	COPY_BITMAPSET_FIELD(present_parts);
-	COPY_SCALAR_FIELD(nparts);
-	COPY_POINTER_FIELD(subnode_map, from->nparts * sizeof(int));
-	COPY_POINTER_FIELD(subpart_map, from->nparts * sizeof(int));
-	COPY_BITMAPSET_FIELD(extparams);
-	COPY_BITMAPSET_FIELD(execparams);
-
-	return newnode;
-}
-
 /* ****************************************************************
  *						relation.h copy functions
  *
@@ -4904,6 +4910,9 @@ copyObjectImpl(const void *from)
 		case T_PlanInvalItem:
 			retval = _copyPlanInvalItem(from);
 			break;
+		case T_PartitionPruneInfo:
+			retval = _copyPartitionPruneInfo(from);
+			break;
 
 			/*
 			 * PRIMITIVE NODES
@@ -5089,9 +5098,6 @@ copyObjectImpl(const void *from)
 		case T_PlaceHolderInfo:
 			retval = _copyPlaceHolderInfo(from);
 			break;
-		case T_PartitionPruneInfo:
-			retval = _copyPartitionPruneInfo(from);
-			break;
 
 			/*
 			 * VALUE NODES
diff --git a/src/backend/nodes/outfuncs.c b/src/backend/nodes/outfuncs.c
index 610f9edaf5..b6b53a2de3 100644
--- a/src/backend/nodes/outfuncs.c
+++ b/src/backend/nodes/outfuncs.c
@@ -1019,6 +1019,36 @@ _outPlanInvalItem(StringInfo str, const PlanInvalItem *node)
 	WRITE_UINT_FIELD(hashValue);
 }
 
+static void
+_outPartitionPruneInfo(StringInfo str, const PartitionPruneInfo *node)
+{
+	int			i;
+
+	WRITE_NODE_TYPE("PARTITIONPRUNEINFO");
+
+	WRITE_OID_FIELD(reloid);
+	WRITE_NODE_FIELD(pruning_steps);
+	WRITE_BITMAPSET_FIELD(present_parts);
+	WRITE_INT_FIELD(nparts);
+	WRITE_INT_FIELD(nexprs);
+
+	appendStringInfoString(str, " :subplan_map");
+	for (i = 0; i < node->nparts; i++)
+		appendStringInfo(str, " %d", node->subplan_map[i]);
+
+	appendStringInfoString(str, " :subpart_map");
+	for (i = 0; i < node->nparts; i++)
+		appendStringInfo(str, " %d", node->subpart_map[i]);
+
+	appendStringInfoString(str, " :hasexecparam");
+	for (i = 0; i < node->nexprs; i++)
+		appendStringInfo(str, " %s", booltostr(node->hasexecparam[i]));
+
+	WRITE_BOOL_FIELD(do_initial_prune);
+	WRITE_BOOL_FIELD(do_exec_prune);
+	WRITE_BITMAPSET_FIELD(execparams);
+}
+
 /*****************************************************************************
  *
  *	Stuff from primnodes.h.
@@ -1731,30 +1761,6 @@ _outOnConflictExpr(StringInfo str, const OnConflictExpr *node)
 	WRITE_NODE_FIELD(exclRelTlist);
 }
 
-static void
-_outPartitionPruneInfo(StringInfo str, const PartitionPruneInfo *node)
-{
-	int			i;
-
-	WRITE_NODE_TYPE("PARTITIONPRUNEINFO");
-
-	WRITE_OID_FIELD(reloid);
-	WRITE_NODE_FIELD(pruning_steps);
-	WRITE_BITMAPSET_FIELD(present_parts);
-	WRITE_INT_FIELD(nparts);
-
-	appendStringInfoString(str, " :subnode_map");
-	for (i = 0; i < node->nparts; i++)
-		appendStringInfo(str, " %d", node->subnode_map[i]);
-
-	appendStringInfoString(str, " :subpart_map");
-	for (i = 0; i < node->nparts; i++)
-		appendStringInfo(str, " %d", node->subpart_map[i]);
-
-	WRITE_BITMAPSET_FIELD(extparams);
-	WRITE_BITMAPSET_FIELD(execparams);
-}
-
 /*****************************************************************************
  *
  *	Stuff from relation.h.
@@ -3824,6 +3830,9 @@ outNode(StringInfo str, const void *obj)
 			case T_PlanInvalItem:
 				_outPlanInvalItem(str, obj);
 				break;
+			case T_PartitionPruneInfo:
+				_outPartitionPruneInfo(str, obj);
+				break;
 			case T_Alias:
 				_outAlias(str, obj);
 				break;
@@ -3983,9 +3992,6 @@ outNode(StringInfo str, const void *obj)
 			case T_PartitionPruneStepCombine:
 				_outPartitionPruneStepCombine(str, obj);
 				break;
-			case T_PartitionPruneInfo:
-				_outPartitionPruneInfo(str, obj);
-				break;
 			case T_Path:
 				_outPath(str, obj);
 				break;
diff --git a/src/backend/nodes/readfuncs.c b/src/backend/nodes/readfuncs.c
index 2826cec2f8..18bbf37e14 100644
--- a/src/backend/nodes/readfuncs.c
+++ b/src/backend/nodes/readfuncs.c
@@ -1354,23 +1354,6 @@ _readPartitionPruneStepCombine(void)
 	READ_DONE();
 }
 
-static PartitionPruneInfo *
-_readPartitionPruneInfo(void)
-{
-	READ_LOCALS(PartitionPruneInfo);
-
-	READ_OID_FIELD(reloid);
-	READ_NODE_FIELD(pruning_steps);
-	READ_BITMAPSET_FIELD(present_parts);
-	READ_INT_FIELD(nparts);
-	READ_INT_ARRAY(subnode_map, local_node->nparts);
-	READ_INT_ARRAY(subpart_map, local_node->nparts);
-	READ_BITMAPSET_FIELD(extparams);
-	READ_BITMAPSET_FIELD(execparams);
-
-	READ_DONE();
-}
-
 /*
  *	Stuff from parsenodes.h.
  */
@@ -2376,6 +2359,29 @@ _readPlanInvalItem(void)
 	READ_DONE();
 }
 
+/*
+ * _readPartitionPruneInfo
+ */
+static PartitionPruneInfo *
+_readPartitionPruneInfo(void)
+{
+	READ_LOCALS(PartitionPruneInfo);
+
+	READ_OID_FIELD(reloid);
+	READ_NODE_FIELD(pruning_steps);
+	READ_BITMAPSET_FIELD(present_parts);
+	READ_INT_FIELD(nparts);
+	READ_INT_FIELD(nexprs);
+	READ_INT_ARRAY(subplan_map, local_node->nparts);
+	READ_INT_ARRAY(subpart_map, local_node->nparts);
+	READ_BOOL_ARRAY(hasexecparam, local_node->nexprs);
+	READ_BOOL_FIELD(do_initial_prune);
+	READ_BOOL_FIELD(do_exec_prune);
+	READ_BITMAPSET_FIELD(execparams);
+
+	READ_DONE();
+}
+
 /*
  * _readSubPlan
  */
@@ -2620,8 +2626,6 @@ parseNodeString(void)
 		return_value = _readPartitionPruneStepOp();
 	else if (MATCH("PARTITIONPRUNESTEPCOMBINE", 25))
 		return_value = _readPartitionPruneStepCombine();
-	else if (MATCH("PARTITIONPRUNEINFO", 18))
-		return_value = _readPartitionPruneInfo();
 	else if (MATCH("RTE", 3))
 		return_value = _readRangeTblEntry();
 	else if (MATCH("RANGETBLFUNCTION", 16))
@@ -2724,6 +2728,8 @@ parseNodeString(void)
 		return_value = _readPlanRowMark();
 	else if (MATCH("PLANINVALITEM", 13))
 		return_value = _readPlanInvalItem();
+	else if (MATCH("PARTITIONPRUNEINFO", 18))
+		return_value = _readPartitionPruneInfo();
 	else if (MATCH("SUBPLAN", 7))
 		return_value = _readSubPlan();
 	else if (MATCH("ALTERNATIVESUBPLAN", 18))
diff --git a/src/backend/partitioning/partprune.c b/src/backend/partitioning/partprune.c
index 58ec2a684d..640105ddf2 100644
--- a/src/backend/partitioning/partprune.c
+++ b/src/backend/partitioning/partprune.c
@@ -25,7 +25,7 @@
  * the outputs of some other steps using the appropriate combination method.
  * All steps that are constructed are executed in succession such that for any
  * "combine" step, all of the steps whose output it depends on are executed
- * first and their ouput preserved.
+ * first and their output preserved.
  *
  * See gen_partprune_steps_internal() for more details on step generation.
  *
@@ -53,6 +53,7 @@
 #include "optimizer/planner.h"
 #include "optimizer/predtest.h"
 #include "optimizer/prep.h"
+#include "optimizer/var.h"
 #include "partitioning/partprune.h"
 #include "partitioning/partbounds.h"
 #include "rewrite/rewriteManip.h"
@@ -115,6 +116,14 @@ typedef struct PruneStepResult
 	bool		scan_null;		/* Scan the partition for NULL values? */
 } PruneStepResult;
 
+/*
+ * expression_tree_walker context struct for gathering the paramids in an
+ * expression.
+ */
+typedef struct PullParamContext
+{
+	Bitmapset  *params;
+} PullParamContext;
 
 static List *gen_partprune_steps(RelOptInfo *rel, List *clauses,
 					bool *contradictory);
@@ -162,7 +171,10 @@ static PruneStepResult *get_matching_list_bounds(PartitionPruneContext *context,
 static PruneStepResult *get_matching_range_bounds(PartitionPruneContext *context,
 						  StrategyNumber opstrategy, Datum *values, int nvalues,
 						  FmgrInfo *partsupfunc, Bitmapset *nullkeys);
-static bool pull_partkey_params(PartitionPruneInfo *pinfo, List *steps);
+static Bitmapset *pull_exec_paramids(Expr *expr);
+static bool pull_exec_paramids_walker(Node *node, PullParamContext *context);
+static bool analyze_partkey_exprs(PartitionPruneInfo *pinfo, List *steps,
+					  int partnatts);
 static PruneStepResult *perform_pruning_base_step(PartitionPruneContext *context,
 						  PartitionPruneStepOp *opstep);
 static PruneStepResult *perform_pruning_combine_step(PartitionPruneContext *context,
@@ -180,7 +192,7 @@ static bool partkey_datum_from_expr(PartitionPruneContext *context,
  *		pruning to take place.
  *
  * Here we generate partition pruning steps for 'prunequal' and also build a
- * data stucture which allows mapping of partition indexes into 'subpaths'
+ * data structure which allows mapping of partition indexes into 'subpaths'
  * indexes.
  *
  * If no Params were found to match the partition key in any of the
@@ -194,16 +206,16 @@ make_partition_pruneinfo(PlannerInfo *root, List *partition_rels,
 	RelOptInfo *targetpart = NULL;
 	ListCell   *lc;
 	List	   *pinfolist = NIL;
-	int		   *relid_subnode_map;
+	int		   *relid_subplan_map;
 	int		   *relid_subpart_map;
 	int			i;
-	bool		gotparam = false;
+	bool		doruntimeprune = false;
 
 	/*
 	 * Allocate two arrays to store the 1-based indexes of the 'subpaths' and
 	 * 'partitioned_rels' by relid.
 	 */
-	relid_subnode_map = palloc0(sizeof(int) * root->simple_rel_array_size);
+	relid_subplan_map = palloc0(sizeof(int) * root->simple_rel_array_size);
 	relid_subpart_map = palloc0(sizeof(int) * root->simple_rel_array_size);
 
 	i = 1;
@@ -215,7 +227,7 @@ make_partition_pruneinfo(PlannerInfo *root, List *partition_rels,
 		Assert(IS_SIMPLE_REL(pathrel));
 		Assert(pathrel->relid < root->simple_rel_array_size);
 
-		relid_subnode_map[pathrel->relid] = i++;
+		relid_subplan_map[pathrel->relid] = i++;
 	}
 
 	/* Likewise for the partition_rels */
@@ -238,7 +250,8 @@ make_partition_pruneinfo(PlannerInfo *root, List *partition_rels,
 		RangeTblEntry *rte;
 		Bitmapset  *present_parts;
 		int			nparts = subpart->nparts;
-		int		   *subnode_map;
+		int			partnatts = subpart->part_scheme->partnatts;
+		int		   *subplan_map;
 		int		   *subpart_map;
 		List	   *partprunequal;
 		List	   *pruning_steps;
@@ -284,7 +297,7 @@ make_partition_pruneinfo(PlannerInfo *root, List *partition_rels,
 			return NIL;
 		}
 
-		subnode_map = (int *) palloc(nparts * sizeof(int));
+		subplan_map = (int *) palloc(nparts * sizeof(int));
 		subpart_map = (int *) palloc(nparts * sizeof(int));
 		present_parts = NULL;
 
@@ -297,10 +310,10 @@ make_partition_pruneinfo(PlannerInfo *root, List *partition_rels,
 		for (i = 0; i < nparts; i++)
 		{
 			RelOptInfo *partrel = subpart->part_rels[i];
-			int			subnodeidx = relid_subnode_map[partrel->relid] - 1;
+			int			subnodeidx = relid_subplan_map[partrel->relid] - 1;
 			int			subpartidx = relid_subpart_map[partrel->relid] - 1;
 
-			subnode_map[i] = subnodeidx;
+			subplan_map[i] = subnodeidx;
 			subpart_map[i] = subpartidx;
 
 			/*
@@ -320,32 +333,27 @@ make_partition_pruneinfo(PlannerInfo *root, List *partition_rels,
 		pinfo->pruning_steps = pruning_steps;
 		pinfo->present_parts = present_parts;
 		pinfo->nparts = nparts;
-		pinfo->extparams = NULL;
-		pinfo->execparams = NULL;
-		pinfo->subnode_map = subnode_map;
+		pinfo->nexprs = list_length(pruning_steps) * partnatts;
+		pinfo->subplan_map = subplan_map;
 		pinfo->subpart_map = subpart_map;
 
 		/*
-		 * Extract Params matching partition key and record if we got any.
-		 * We'll not bother enabling run-time pruning if no params matched the
-		 * partition key at any level of partitioning.
+		 * Determine when run-time pruning needs to be performed for this
+		 * partitioned table.
 		 */
-		gotparam |= pull_partkey_params(pinfo, pruning_steps);
+		doruntimeprune |= analyze_partkey_exprs(pinfo, pruning_steps,
+												partnatts);
 
 		pinfolist = lappend(pinfolist, pinfo);
 	}
 
-	pfree(relid_subnode_map);
+	pfree(relid_subplan_map);
 	pfree(relid_subpart_map);
 
-	if (gotparam)
+	if (doruntimeprune)
 		return pinfolist;
 
-	/*
-	 * If no Params were found to match the partition key on any of the
-	 * partitioned relations then there's no point doing any run-time
-	 * partition pruning.
-	 */
+	/* No run-time pruning required. */
 	return NIL;
 }
 
@@ -444,9 +452,10 @@ prune_append_rel_partitions(RelOptInfo *rel)
 	context.boundinfo = rel->boundinfo;
 
 	/* Not valid when being called from the planner */
+	context.evalexecparams = false;
 	context.planstate = NULL;
-	context.safeparams = NULL;
 	context.exprstates = NULL;
+	context.exprhasexecparam = NULL;
 
 	/* Actual pruning happens here. */
 	partindexes = get_matching_partitions(&context, pruning_steps);
@@ -1478,6 +1487,10 @@ match_clause_to_partition_key(RelOptInfo *rel,
 		if (contain_volatile_functions((Node *) expr))
 			return PARTCLAUSE_UNSUPPORTED;
 
+		/* We can't prune using an expression with Vars. */
+		if (contain_var_clause((Node *) expr))
+			return PARTCLAUSE_UNSUPPORTED;
+
 		/*
 		 * Determine the input types of the operator we're considering.
 		 *
@@ -1655,7 +1668,7 @@ match_clause_to_partition_key(RelOptInfo *rel,
 					return PARTCLAUSE_UNSUPPORTED;
 			}
 			else
-				return PARTCLAUSE_UNSUPPORTED; /* no useful negator */
+				return PARTCLAUSE_UNSUPPORTED;	/* no useful negator */
 		}
 
 		/*
@@ -2683,54 +2696,97 @@ get_matching_range_bounds(PartitionPruneContext *context,
 }
 
 /*
- * pull_partkey_params
- *		Loop through each pruning step and record each external and exec
- *		Params being compared to the partition keys.
+ * pull_exec_paramids
+ *		Returns a Bitmapset containing the paramids of each Param with
+ *		paramkind = PARAM_EXEC in 'expr'.
+ */
+static Bitmapset *
+pull_exec_paramids(Expr *expr)
+{
+	PullParamContext context;
+
+	context.params = NULL;
+
+	pull_exec_paramids_walker((Node *) expr, &context);
+
+	return context.params;
+}
+
+static bool
+pull_exec_paramids_walker(Node *node, PullParamContext *context)
+{
+	if (node == NULL)
+		return false;
+	if (IsA(node, Param))
+	{
+		Param	   *param = (Param *) node;
+
+		if (param->paramkind == PARAM_EXEC)
+			context->params = bms_add_member(context->params, param->paramid);
+		return false;
+	}
+	return expression_tree_walker(node, pull_exec_paramids_walker,
+								  (void *) context);
+}
+
+/*
+ * analyze_partkey_exprs
+ *		Loop through each pruning steps recording which one are comparing exec
+ *		params to the partition key.
+ *
+ * Returns true if run-time partition pruning should be attempted for this
+ * partitioned table.
  */
 static bool
-pull_partkey_params(PartitionPruneInfo *pinfo, List *steps)
+analyze_partkey_exprs(PartitionPruneInfo *pinfo, List *steps, int partnatts)
 {
 	ListCell   *lc;
-	bool		gotone = false;
+	bool		doruntimeprune = false;
+
+	pinfo->hasexecparam = palloc0(sizeof(bool) * pinfo->nexprs);
+	pinfo->execparams = NULL;
+	pinfo->do_initial_prune = false;
+	pinfo->do_exec_prune = false;
 
 	foreach(lc, steps)
 	{
-		PartitionPruneStepOp *stepop = lfirst(lc);
+		PartitionPruneStepOp *step = lfirst(lc);
 		ListCell   *lc2;
+		int			keyno;
 
-		if (!IsA(stepop, PartitionPruneStepOp))
+		if (!IsA(step, PartitionPruneStepOp))
 			continue;
 
-		foreach(lc2, stepop->exprs)
+		keyno = 0;
+		foreach(lc2, step->exprs)
 		{
 			Expr	   *expr = lfirst(lc2);
 
-			if (IsA(expr, Param))
+			if (!IsA(expr, Const))
 			{
-				Param	   *param = (Param *) expr;
-
-				switch (param->paramkind)
-				{
-					case PARAM_EXTERN:
-						pinfo->extparams = bms_add_member(pinfo->extparams,
-														  param->paramid);
-						break;
-					case PARAM_EXEC:
-						pinfo->execparams = bms_add_member(pinfo->execparams,
-														   param->paramid);
-						break;
+				Bitmapset  *execparams = pull_exec_paramids(expr);
+				bool		hasexecparams;
+				int			stateidx = PruneCxtStateIdx(partnatts,
+														step->step.step_id,
+														keyno);
+
+				hasexecparams = !bms_is_empty(execparams);
+				pinfo->hasexecparam[stateidx] = hasexecparams;
+				pinfo->execparams = bms_add_members(pinfo->execparams,
+													execparams);
+
+				if (!hasexecparams)
+					pinfo->do_initial_prune = true;
+				else
+					pinfo->do_exec_prune = true;
 
-					default:
-						elog(ERROR, "unrecognized paramkind: %d",
-							 (int) param->paramkind);
-						break;
-				}
-				gotone = true;
+				doruntimeprune = true;
 			}
+			keyno++;
 		}
 	}
 
-	return gotone;
+	return doruntimeprune;
 }
 
 /*
@@ -3031,37 +3087,43 @@ static bool
 partkey_datum_from_expr(PartitionPruneContext *context,
 						Expr *expr, int stateidx, Datum *value)
 {
-	switch (nodeTag(expr))
+	if (IsA(expr, Const))
 	{
-		case T_Const:
-			*value = ((Const *) expr)->constvalue;
-			return true;
-
-		case T_Param:
+		*value = ((Const *) expr)->constvalue;
+		return true;
+	}
+	else
+	{
+		/*
+		 * When called from the executor we'll have a valid planstate so we
+		 * may be able to evaluate expressions which could not be folded to
+		 * constants during planning.  Since run-time pruning can occur both
+		 * during initialization of the executor and while it's running, we
+		 * must be careful not to attempt to evaluate expressions containing
+		 * exec params during initialization of the executor.
+		 */
+		if (context->planstate &&
+			(context->evalexecparams ||
+			 !context->exprhasexecparam[stateidx]))
+		{
+			ExprState  *exprstate;
+			ExprContext *ectx;
+			bool		isNull;
 
-			/*
-			 * When being called from the executor we may be able to evaluate
-			 * the Param's value.
-			 */
-			if (context->planstate &&
-				bms_is_member(((Param *) expr)->paramid, context->safeparams))
-			{
-				ExprState  *exprstate;
-				ExprContext *ectx;
-				bool		isNull;
+			/* Exprs with volatile functions shouldn't make it here */
+			Assert(!contain_volatile_functions((Node *) expr));
 
-				exprstate = context->exprstates[stateidx];
-				ectx = context->planstate->ps_ExprContext;
-				*value = ExecEvalExprSwitchContext(exprstate, ectx, &isNull);
-				if (isNull)
-					return false;
+			/* Exprs with Vars shouldn't make it here either */
+			Assert(!contain_var_clause((Node *) expr));
 
-				return true;
-			}
-			break;
+			exprstate = context->exprstates[stateidx];
+			ectx = context->planstate->ps_ExprContext;
+			*value = ExecEvalExprSwitchContext(exprstate, ectx, &isNull);
+			if (isNull)
+				return false;
 
-		default:
-			break;
+			return true;
+		}
 	}
 
 	return false;
diff --git a/src/include/executor/execPartition.h b/src/include/executor/execPartition.h
index fc6e9574e3..ae850f4d6e 100644
--- a/src/include/executor/execPartition.h
+++ b/src/include/executor/execPartition.h
@@ -121,9 +121,9 @@ typedef struct PartitionTupleRouting
  * bypass certain subnodes when we have proofs that indicate that no tuple
  * matching the 'pruning_steps' will be found within.
  *
- * subnode_map					An array containing the subnode index which
+ * subplan_map					An array containing the subplan index which
  *								matches this partition index, or -1 if the
- *								subnode has been pruned already.
+ *								subplan has been pruned already.
  * subpart_map					An array containing the offset into the
  *								'partprunedata' array in PartitionPruning, or
  *								-1 if there is no such element in that array.
@@ -133,20 +133,24 @@ typedef struct PartitionTupleRouting
  *								the partition pruning code.
  * pruning_steps				Contains a list of PartitionPruneStep used to
  *								perform the actual pruning.
- * extparams					Contains paramids of external params found
+ * execparams					Contains paramids of exec params found
  *								matching partition keys in 'pruning_steps'.
- * allparams					As 'extparams' but also including exec params.
+ * do_initial_prune				true if pruning should be performed during
+ *								executor startup.
+ * do_exec_prune				true if pruning should be performed during
+ *								executor run.
  *-----------------------
  */
 typedef struct PartitionPruningData
 {
-	int		   *subnode_map;
+	int		   *subplan_map;
 	int		   *subpart_map;
 	Bitmapset  *present_parts;
 	PartitionPruneContext context;
 	List	   *pruning_steps;
-	Bitmapset  *extparams;
-	Bitmapset  *allparams;
+	Bitmapset  *execparams;
+	bool		do_initial_prune;
+	bool		do_exec_prune;
 } PartitionPruningData;
 
 /*-----------------------
@@ -159,28 +163,28 @@ typedef struct PartitionPruningData
  * the clauses being unable to match to any tuple that the subnode could
  * possibly produce.
  *
- * partprunedata		Array of PartitionPruningData for the node's target
- *						partitioned relation. First element contains the
- *						details for the target partitioned table.
  * num_partprunedata	Number of items in 'partprunedata' array.
+ * do_initial_prune		true if pruning should be performed during executor
+ *						startup.
  * prune_context		A memory context which can be used to call the query
  *						planner's partition prune functions.
- * extparams			All PARAM_EXTERN paramids which were found to match a
+ * execparams			All PARAM_EXEC paramids which were found to match a
  *						partition key in each of the contained
- *						PartitionPruningData structs.
- * execparams			As above but for PARAM_EXEC.
- * allparams			Union of 'extparams' and 'execparams', saved to avoid
- *						recalculation.
+ *						PartitionPruningData structs.  Pruning must be done
+ *						again each time the value of one of these parameters
+ *						changes.
+ * partprunedata		Array of PartitionPruningData for the node's target
+ *						partitioned relation. First element contains the
+ *						details for the target partitioned table.
  *-----------------------
  */
 typedef struct PartitionPruneState
 {
-	PartitionPruningData *partprunedata;
 	int			num_partprunedata;
+	bool		do_initial_prune;
 	MemoryContext prune_context;
-	Bitmapset  *extparams;
 	Bitmapset  *execparams;
-	Bitmapset  *allparams;
+	PartitionPruningData partprunedata[FLEXIBLE_ARRAY_MEMBER];
 } PartitionPruneState;
 
 extern PartitionTupleRouting *ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
diff --git a/src/include/nodes/nodes.h b/src/include/nodes/nodes.h
index adb159a6da..120b1c7a7b 100644
--- a/src/include/nodes/nodes.h
+++ b/src/include/nodes/nodes.h
@@ -88,6 +88,7 @@ typedef enum NodeTag
 	T_NestLoopParam,
 	T_PlanRowMark,
 	T_PlanInvalItem,
+	T_PartitionPruneInfo,
 
 	/*
 	 * TAGS FOR PLAN STATE NODES (execnodes.h)
@@ -195,7 +196,6 @@ typedef enum NodeTag
 	T_PartitionPruneStep,
 	T_PartitionPruneStepOp,
 	T_PartitionPruneStepCombine,
-	T_PartitionPruneInfo,
 
 	/*
 	 * TAGS FOR EXPRESSION STATE NODES (execnodes.h)
diff --git a/src/include/nodes/plannodes.h b/src/include/nodes/plannodes.h
index f2dda82e66..0ff14c96f3 100644
--- a/src/include/nodes/plannodes.h
+++ b/src/include/nodes/plannodes.h
@@ -1062,4 +1062,35 @@ typedef struct PlanInvalItem
 	uint32		hashValue;		/* hash value of object's cache lookup key */
 } PlanInvalItem;
 
+/*
+ * PartitionPruneInfo - Details required to allow the executor to prune
+ * partitions.
+ *
+ * Here we store mapping details to allow translation of a partitioned table's
+ * index as returned by the partition pruning code into subplan indexes for
+ * node types which support arbitrary numbers of subplans, such as Append.
+ * We also store various details to give indication to the executor when it
+ * should be performing partition pruning.
+ */
+typedef struct PartitionPruneInfo
+{
+	NodeTag		type;
+	Oid			reloid;			/* Oid of partition rel */
+	List	   *pruning_steps;	/* List of PartitionPruneStep */
+	Bitmapset  *present_parts;	/* Indexes of all partitions which subnodes
+								 * are present for. */
+	int			nparts;			/* The length of the following two arrays */
+	int			nexprs;			/* Size of hasexecparam array */
+	int		   *subplan_map;	/* subplan index by partition id, or -1 */
+	int		   *subpart_map;	/* subpart index by partition id, or -1 */
+	bool	   *hasexecparam;	/* true if corresponding pruning_step has an
+								 * exec Param in the Expr being compared to
+								 * the partition key. */
+	bool		do_initial_prune;	/* true if pruning should be performed
+									 * during executor startup. */
+	bool		do_exec_prune;	/* true if pruning should be performed during
+								 * executor run. */
+	Bitmapset  *execparams;		/* All exec paramids seen in prunesteps */
+} PartitionPruneInfo;
+
 #endif							/* PLANNODES_H */
diff --git a/src/include/nodes/primnodes.h b/src/include/nodes/primnodes.h
index f90aa7b2a1..ff5c4ff8e4 100644
--- a/src/include/nodes/primnodes.h
+++ b/src/include/nodes/primnodes.h
@@ -1581,27 +1581,4 @@ typedef struct PartitionPruneStepCombine
 	List	   *source_stepids;
 } PartitionPruneStepCombine;
 
-/*----------
- * PartitionPruneInfo - Details required to allow the executor to prune
- * partitions.
- *
- * Here we store mapping details to allow translation of a partitioned table's
- * index into subnode indexes for node types which support arbitrary numbers
- * of sub nodes, such as Append.
- *----------
- */
-typedef struct PartitionPruneInfo
-{
-	NodeTag		type;
-	Oid			reloid;			/* Oid of partition rel */
-	List	   *pruning_steps;	/* List of PartitionPruneStep */
-	Bitmapset  *present_parts;	/* Indexes of all partitions which subnodes
-								 * are present for. */
-	int			nparts;			/* The length of the following two arrays */
-	int		   *subnode_map;	/* subnode index by partition id, or -1 */
-	int		   *subpart_map;	/* subpart index by partition id, or -1 */
-	Bitmapset  *extparams;		/* All external paramids seen in prunesteps */
-	Bitmapset  *execparams;		/* All exec paramids seen in prunesteps */
-} PartitionPruneInfo;
-
 #endif							/* PRIMNODES_H */
diff --git a/src/include/partitioning/partprune.h b/src/include/partitioning/partprune.h
index 3d114b4c71..4ac8cf5552 100644
--- a/src/include/partitioning/partprune.h
+++ b/src/include/partitioning/partprune.h
@@ -36,6 +36,9 @@ typedef struct PartitionPruneContext
 	/* Number of partitions */
 	int			nparts;
 
+	/* true if it's safe to evaluate exec params */
+	bool		evalexecparams;
+
 	/* Partition boundary info */
 	PartitionBoundInfo boundinfo;
 
@@ -45,18 +48,15 @@ typedef struct PartitionPruneContext
 	 */
 	PlanState  *planstate;
 
-	/*
-	 * Parameters that are safe to be used for partition pruning. execparams
-	 * are not safe to use until the executor is running.
-	 */
-	Bitmapset  *safeparams;
-
 	/*
 	 * Array of ExprStates, indexed as per PruneCtxStateIdx; one for each
 	 * partkey in each pruning step.  Allocated if planstate is non-NULL,
 	 * otherwise NULL.
 	 */
 	ExprState **exprstates;
+
+	/* true if corresponding 'exprstate' expression contains an exec param */
+	bool	   *exprhasexecparam;
 } PartitionPruneContext;
 
 #define PruneCxtStateIdx(partnatts, step_id, keyno) \
diff --git a/src/test/regress/expected/partition_prune.out b/src/test/regress/expected/partition_prune.out
index cf331e79c1..64b4e933d6 100644
--- a/src/test/regress/expected/partition_prune.out
+++ b/src/test/regress/expected/partition_prune.out
@@ -1835,6 +1835,54 @@ fetch backward all from cur;
 (2 rows)
 
 commit;
+begin;
+-- Test run-time pruning using stable functions
+create function list_part_fn(int) returns int as $$ begin return $1; end;$$ language plpgsql stable;
+-- Ensure pruning works using a stable function containing no Vars
+explain (analyze, costs off, summary off, timing off) select * from list_part where a = list_part_fn(1);
+                      QUERY PLAN                      
+------------------------------------------------------
+ Append (actual rows=1 loops=1)
+   Subplans Removed: 3
+   ->  Seq Scan on list_part1 (actual rows=1 loops=1)
+         Filter: (a = list_part_fn(1))
+(4 rows)
+
+-- Ensure pruning does not take place when the function contains a Var parameter
+explain (analyze, costs off, summary off, timing off) select * from list_part where a = list_part_fn(a);
+                      QUERY PLAN                      
+------------------------------------------------------
+ Append (actual rows=4 loops=1)
+   ->  Seq Scan on list_part1 (actual rows=1 loops=1)
+         Filter: (a = list_part_fn(a))
+   ->  Seq Scan on list_part2 (actual rows=1 loops=1)
+         Filter: (a = list_part_fn(a))
+   ->  Seq Scan on list_part3 (actual rows=1 loops=1)
+         Filter: (a = list_part_fn(a))
+   ->  Seq Scan on list_part4 (actual rows=1 loops=1)
+         Filter: (a = list_part_fn(a))
+(9 rows)
+
+-- Ensure pruning does not take place when the expression contains a Var.
+explain (analyze, costs off, summary off, timing off) select * from list_part where a = list_part_fn(1) + a;
+                      QUERY PLAN                      
+------------------------------------------------------
+ Append (actual rows=0 loops=1)
+   ->  Seq Scan on list_part1 (actual rows=0 loops=1)
+         Filter: (a = (list_part_fn(1) + a))
+         Rows Removed by Filter: 1
+   ->  Seq Scan on list_part2 (actual rows=0 loops=1)
+         Filter: (a = (list_part_fn(1) + a))
+         Rows Removed by Filter: 1
+   ->  Seq Scan on list_part3 (actual rows=0 loops=1)
+         Filter: (a = (list_part_fn(1) + a))
+         Rows Removed by Filter: 1
+   ->  Seq Scan on list_part4 (actual rows=0 loops=1)
+         Filter: (a = (list_part_fn(1) + a))
+         Rows Removed by Filter: 1
+(13 rows)
+
+rollback;
 drop table list_part;
 -- Parallel append
 -- Suppress the number of loops each parallel node runs for.  This is because
@@ -2079,6 +2127,40 @@ select explain_parallel_append('select avg(ab.a) from ab inner join lprt_a a on
                                  Index Cond: (a = a.a)
 (27 rows)
 
+-- Ensure the same partitions are pruned when we make the nested loop
+-- parameter an Expr rather than a plain Param.
+select explain_parallel_append('select avg(ab.a) from ab inner join lprt_a a on ab.a = a.a + 0 where a.a in(0, 0, 1)');
+                                      explain_parallel_append                                      
+---------------------------------------------------------------------------------------------------
+ Finalize Aggregate (actual rows=1 loops=1)
+   ->  Gather (actual rows=2 loops=1)
+         Workers Planned: 1
+         Workers Launched: 1
+         ->  Partial Aggregate (actual rows=1 loops=2)
+               ->  Nested Loop (actual rows=0 loops=2)
+                     ->  Parallel Seq Scan on lprt_a a (actual rows=51 loops=N)
+                           Filter: (a = ANY ('{0,0,1}'::integer[]))
+                     ->  Append (actual rows=0 loops=102)
+                           ->  Index Scan using ab_a1_b1_a_idx on ab_a1_b1 (actual rows=0 loops=2)
+                                 Index Cond: (a = (a.a + 0))
+                           ->  Index Scan using ab_a1_b2_a_idx on ab_a1_b2 (actual rows=0 loops=2)
+                                 Index Cond: (a = (a.a + 0))
+                           ->  Index Scan using ab_a1_b3_a_idx on ab_a1_b3 (actual rows=0 loops=2)
+                                 Index Cond: (a = (a.a + 0))
+                           ->  Index Scan using ab_a2_b1_a_idx on ab_a2_b1 (never executed)
+                                 Index Cond: (a = (a.a + 0))
+                           ->  Index Scan using ab_a2_b2_a_idx on ab_a2_b2 (never executed)
+                                 Index Cond: (a = (a.a + 0))
+                           ->  Index Scan using ab_a2_b3_a_idx on ab_a2_b3 (never executed)
+                                 Index Cond: (a = (a.a + 0))
+                           ->  Index Scan using ab_a3_b1_a_idx on ab_a3_b1 (never executed)
+                                 Index Cond: (a = (a.a + 0))
+                           ->  Index Scan using ab_a3_b2_a_idx on ab_a3_b2 (never executed)
+                                 Index Cond: (a = (a.a + 0))
+                           ->  Index Scan using ab_a3_b3_a_idx on ab_a3_b3 (never executed)
+                                 Index Cond: (a = (a.a + 0))
+(27 rows)
+
 insert into lprt_a values(3),(3);
 select explain_parallel_append('select avg(ab.a) from ab inner join lprt_a a on ab.a = a.a where a.a in(1, 0, 3)');
                                       explain_parallel_append                                      
diff --git a/src/test/regress/sql/partition_prune.sql b/src/test/regress/sql/partition_prune.sql
index 1464f4dcd9..b6681fa44c 100644
--- a/src/test/regress/sql/partition_prune.sql
+++ b/src/test/regress/sql/partition_prune.sql
@@ -396,6 +396,22 @@ fetch backward all from cur;
 
 commit;
 
+begin;
+
+-- Test run-time pruning using stable functions
+create function list_part_fn(int) returns int as $$ begin return $1; end;$$ language plpgsql stable;
+
+-- Ensure pruning works using a stable function containing no Vars
+explain (analyze, costs off, summary off, timing off) select * from list_part where a = list_part_fn(1);
+
+-- Ensure pruning does not take place when the function contains a Var parameter
+explain (analyze, costs off, summary off, timing off) select * from list_part where a = list_part_fn(a);
+
+-- Ensure pruning does not take place when the expression contains a Var.
+explain (analyze, costs off, summary off, timing off) select * from list_part where a = list_part_fn(1) + a;
+
+rollback;
+
 drop table list_part;
 
 -- Parallel append
@@ -486,6 +502,10 @@ set enable_mergejoin = 0;
 
 select explain_parallel_append('select avg(ab.a) from ab inner join lprt_a a on ab.a = a.a where a.a in(0, 0, 1)');
 
+-- Ensure the same partitions are pruned when we make the nested loop
+-- parameter an Expr rather than a plain Param.
+select explain_parallel_append('select avg(ab.a) from ab inner join lprt_a a on ab.a = a.a + 0 where a.a in(0, 0, 1)');
+
 insert into lprt_a values(3),(3);
 
 select explain_parallel_append('select avg(ab.a) from ab inner join lprt_a a on ab.a = a.a where a.a in(1, 0, 3)');

diff --git a/src/backend/executor/execPartition.c b/src/backend/executor/execPartition.c
index 0a003d9935..cbce6fda8e 100644
--- a/src/backend/executor/execPartition.c
+++ b/src/backend/executor/execPartition.c
@@ -1605,9 +1605,13 @@ ExecFindInitialMatchingSubPlans(PartitionPruneState *prunestate, int nsubplans)
 
 		/*
 		 * Now we can re-sequence each PartitionPruneInfo's subplan_map so
-		 * that they point to the new index of the subplan.
+		 * that they point to the new index of the subplan.  We perform this
+		 * loop in a back-to-front order so that we determine present_parts
+		 * for the lowest-level partitioned tables first.  This way we can
+		 * determine if a sub-partitioned table's partitions were entirely
+		 * pruned so we can exclude that from 'present_parts'.
 		 */
-		for (i = 0; i < prunestate->num_partprunedata; i++)
+		for (i = prunestate->num_partprunedata - 1; i >= 0 ; i--)
 		{
 			int			nparts;
 			int			j;
@@ -1627,7 +1631,7 @@ ExecFindInitialMatchingSubPlans(PartitionPruneState *prunestate, int nsubplans)
 			for (j = 0; j < nparts; j++)
 			{
 				int			oldidx = pprune->subplan_map[j];
-
+				int			subidx;
 				/*
 				 * If this partition existed as a subplan then change the old
 				 * subplan index to the new subplan index.  The new index may
@@ -1643,41 +1647,17 @@ ExecFindInitialMatchingSubPlans(PartitionPruneState *prunestate, int nsubplans)
 						pprune->present_parts =
 							bms_add_member(pprune->present_parts, j);
 				}
-			}
-		}
-
-		/*
-		 * Now we must determine which sub-partitioned tables still have
-		 * unpruned partitions.  The easiest way to do this is to simply loop
-		 * over each PartitionPruningData again checking if there are any
-		 * 'present_parts' in the sub-partitioned table.  We needn't bother
-		 * doing this if there are no sub-partitioned tables.
-		 */
-		if (prunestate->num_partprunedata > 1)
-		{
-			for (i = 0; i < prunestate->num_partprunedata; i++)
-			{
-				int			nparts;
-				int			j;
-
-				pprune = &prunestate->partprunedata[i];
-				nparts = pprune->context.nparts;
-
-				for (j = 0; j < nparts; j++)
+				else if ((subidx = pprune->subpart_map[j]) >= 0)
 				{
-					int			subidx = pprune->subpart_map[j];
-
-					if (subidx >= 0)
-					{
-						PartitionPruningData *subprune;
+					PartitionPruningData *subprune;
 
-						subprune = &prunestate->partprunedata[subidx];
+					subprune = &prunestate->partprunedata[subidx];
 
-						if (!bms_is_empty(subprune->present_parts))
-							pprune->present_parts =
-								bms_add_member(pprune->present_parts, j);
-					}
+					if (!bms_is_empty(subprune->present_parts))
+						pprune->present_parts =
+							bms_add_member(pprune->present_parts, j);
 				}
+
 			}
 		}
 
diff --git a/src/backend/optimizer/path/allpaths.c b/src/backend/optimizer/path/allpaths.c
index 477b9f7fb8..146298828d 100644
--- a/src/backend/optimizer/path/allpaths.c
+++ b/src/backend/optimizer/path/allpaths.c
@@ -1451,7 +1451,8 @@ add_paths_to_append_rel(PlannerInfo *root, RelOptInfo *rel,
 
 		/*
 		 * If we need to build partitioned_rels, accumulate the partitioned
-		 * rels for this child.
+		 * rels for this child.  We must ensure that parents are always listed
+		 * before their child partitioned tables.
 		 */
 		if (build_partitioned_rels)
 		{
diff --git a/src/backend/partitioning/partprune.c b/src/backend/partitioning/partprune.c
index fc0388e621..a09464dede 100644
--- a/src/backend/partitioning/partprune.c
+++ b/src/backend/partitioning/partprune.c
@@ -170,7 +170,7 @@ static PruneStepResult *perform_pruning_combine_step(PartitionPruneContext *cont
 static bool match_boolean_partition_clause(Oid partopfamily, Expr *clause,
 							   Expr *partkey, Expr **outconst);
 static bool partkey_datum_from_expr(PartitionPruneContext *context,
-						Expr *expr, int stateidx, Datum *value);
+						Expr *expr, int stateidx, Datum *value, bool *isnull);
 
 
 /*
@@ -183,9 +183,15 @@ static bool partkey_datum_from_expr(PartitionPruneContext *context,
  * data structure which allows mapping of partition indexes into 'subpaths'
  * indexes.
  *
+ * 'partition_rels' must list all RT index of all parent partitioned tables
+ * for all partitions seen in 'subpaths'.  Heigher level parent partitioned
+ * tables must come before their child partitioned table, meaning the top-most
+ * parent must be first in the list.
+ *
  * If no non-Const expressions are being compared to the partition key in any
- * of the 'partitioned_rels', then we return NIL.  In such a case run-time
- * partition pruning would be useless, since the planner did it already.
+ * of the 'partitioned_rels', then we return NIL to indicate no run-time
+ * pruning should be performed.  Run-time pruning would be useless, since the
+ * pruning done during planning will have pruned everything that can be.
  */
 List *
 make_partition_pruneinfo(PlannerInfo *root, List *partition_rels,
@@ -2835,21 +2841,40 @@ perform_pruning_base_step(PartitionPruneContext *context,
 			Expr	   *expr;
 			int			stateidx;
 			Datum		datum;
+			bool		isnull;
 
 			expr = lfirst(lc1);
 			stateidx = PruneCxtStateIdx(context->partnatts,
 										opstep->step.step_id, keyno);
-			if (partkey_datum_from_expr(context, expr, stateidx, &datum))
+			if (partkey_datum_from_expr(context, expr, stateidx, &datum,
+										&isnull))
 			{
 				Oid			cmpfn;
 
+				/*
+				 * Since we only allow strict operators in pruning steps, any
+				 * NULL valued datum cannot possibily match any partitions.
+				 */
+				if (isnull)
+				{
+					PruneStepResult *result;
+
+					result = (PruneStepResult *) palloc(sizeof(PruneStepResult));
+					result->bound_offsets = NULL;
+					result->scan_default = false;
+					result->scan_null = false;
+
+					return result;
+				}
+
+				cmpfn = lfirst_oid(lc2);
+				Assert(OidIsValid(cmpfn));
+
 				/*
 				 * If we're going to need a different comparison function than
 				 * the one cached in the PartitionKey, we'll need to look up
 				 * the FmgrInfo.
 				 */
-				cmpfn = lfirst_oid(lc2);
-				Assert(OidIsValid(cmpfn));
 				if (cmpfn != context->partsupfunc[keyno].fn_oid)
 					fmgr_info(cmpfn, &partsupfunc[keyno]);
 				else
@@ -3073,7 +3098,8 @@ match_boolean_partition_clause(Oid partopfamily, Expr *clause, Expr *partkey,
  *
  * Evaluate 'expr', whose ExprState is stateidx of the context exprstate
  * array; set *value to the resulting Datum.  Return true if evaluation was
- * possible, otherwise false.
+ * possible, otherwise false. 'isnull' is set to indicate if the 'value' datum
+ * is SQL NULL or not.
  *
  * Note that the evaluated result may be in the per-tuple memory context of
  * context->planstate->ps_ExprContext, and we may have leaked other memory
@@ -3082,11 +3108,14 @@ match_boolean_partition_clause(Oid partopfamily, Expr *clause, Expr *partkey,
  */
 static bool
 partkey_datum_from_expr(PartitionPruneContext *context,
-						Expr *expr, int stateidx, Datum *value)
+						Expr *expr, int stateidx, Datum *value, bool *isnull)
 {
 	if (IsA(expr, Const))
 	{
-		*value = ((Const *) expr)->constvalue;
+		Const *con = (Const *) expr;
+
+		*value = con->constvalue;
+		*isnull = con->constisnull;
 		return true;
 	}
 	else
@@ -3105,14 +3134,10 @@ partkey_datum_from_expr(PartitionPruneContext *context,
 		{
 			ExprState  *exprstate;
 			ExprContext *ectx;
-			bool		isNull;
 
 			exprstate = context->exprstates[stateidx];
 			ectx = context->planstate->ps_ExprContext;
-			*value = ExecEvalExprSwitchContext(exprstate, ectx, &isNull);
-			if (isNull)
-				return false;
-
+			*value = ExecEvalExprSwitchContext(exprstate, ectx, isnull);
 			return true;
 		}
 	}
diff --git a/src/include/executor/execPartition.h b/src/include/executor/execPartition.h
index 9f0b817c54..59176139e7 100644
--- a/src/include/executor/execPartition.h
+++ b/src/include/executor/execPartition.h
@@ -121,12 +121,21 @@ typedef struct PartitionTupleRouting
  * subplan when we can prove that no tuple matching the 'pruning_steps' will
  * be found within.
  *
- * subplan_map					An array containing the subplan index which
- *								matches this partition index, or -1 if the
- *								subplan has been pruned already.
- * subpart_map					An array containing the index into the
- *								partprunedata array in PartitionPruneState, or
- *								-1 if there is no such element in that array.
+ * subplan_map					An array indexed by the partitioned table's
+ *								partition index as returned by the pruning
+ *								code.  Contains the index of the subplan for
+ *								that partition, or -1 if that subplan does not
+ *								exists due to having been pruned away already
+ *								or the index belongs to a subpartitioned
+ *								table.
+ * subpart_map					An array indexed by the partitioned table's
+ *								partition index as returned by the pruning
+ *								code.  Contains the index of the
+ *								PartitionPruneState 'partprunedata' element
+ *								which stores the details for this
+ *								subpartitioned table, or -1 if that table was
+ *								pruned away already, or if the index belongs
+ *								to a leaf partition.
  * present_parts				A Bitmapset of the partition indexes that we
  *								have subplans mapped for.
  * context						Contains the context details required to call
@@ -161,7 +170,9 @@ typedef struct PartitionPruningData
  *
  * partprunedata		Array of PartitionPruningData for the plan's target
  *						partitioned relation. First element contains the
- *						details for the target partitioned table.
+ *						details for the target partitioned table the remaining
+ *						elements are in flattened hierarchical order with the
+ *						parents coming before their children.
  * num_partprunedata	Number of items in 'partprunedata' array.
  * do_initial_prune		true if pruning should be performed during executor
  *						startup (at any hierarchy level).
diff --git a/src/include/nodes/plannodes.h b/src/include/nodes/plannodes.h
index dacc50edc2..42343de210 100644
--- a/src/include/nodes/plannodes.h
+++ b/src/include/nodes/plannodes.h
@@ -220,7 +220,10 @@ typedef struct ModifyTable
 	CmdType		operation;		/* INSERT, UPDATE, or DELETE */
 	bool		canSetTag;		/* do we set the command tag/es_processed? */
 	Index		nominalRelation;	/* Parent RT index for use of EXPLAIN */
-	/* RT indexes of non-leaf tables in a partition tree */
+	/*
+	 * A flattened hierarchical list of RT indexes of partitioned tables in
+	 * parent to child order having the top-most parent first.
+	 */
 	List	   *partitioned_rels;
 	bool		partColsUpdated;	/* some part key in hierarchy updated */
 	List	   *resultRelations;	/* integer list of RT indexes */
@@ -257,7 +260,10 @@ typedef struct Append
 	 */
 	int			first_partial_plan;
 
-	/* RT indexes of non-leaf tables in a partition tree */
+	/*
+	 * A flattened hierarchical list of RT indexes of partitioned tables in
+	 * parent to child order having the top-most parent first.
+	 */
 	List	   *partitioned_rels;
 
 	/* Info for run-time subplan pruning, one entry per partitioned_rels */
@@ -272,7 +278,10 @@ typedef struct Append
 typedef struct MergeAppend
 {
 	Plan		plan;
-	/* RT indexes of non-leaf tables in a partition tree */
+	/*
+	 * A flattened hierarchical list of RT indexes of partitioned tables in
+	 * parent to child order having the top-most parent first.
+	 */
 	List	   *partitioned_rels;
 	List	   *mergeplans;
 	/* remaining fields are just like the sort-key info in struct Sort */
diff --git a/src/include/nodes/relation.h b/src/include/nodes/relation.h
index 3b28d1994f..78177aa687 100644
--- a/src/include/nodes/relation.h
+++ b/src/include/nodes/relation.h
@@ -689,7 +689,9 @@ typedef struct RelOptInfo
 									 * stored in the same order of bounds */
 	List	  **partexprs;		/* Non-nullable partition key expressions. */
 	List	  **nullable_partexprs; /* Nullable partition key expressions. */
-	List	   *partitioned_child_rels; /* List of RT indexes. */
+	List	   *partitioned_child_rels; /* Flattened hierarchical list of
+										 * partitioned table of RT indexes
+										 * in parent to child order. */
 } RelOptInfo;
 
 /*
diff --git a/src/test/regress/expected/partition_prune.out b/src/test/regress/expected/partition_prune.out
index ab32c7d67e..47c6aa4817 100644
--- a/src/test/regress/expected/partition_prune.out
+++ b/src/test/regress/expected/partition_prune.out
@@ -2731,6 +2731,52 @@ explain (analyze, costs off, summary off, timing off)  execute q1 (1,2,2,1);
          Filter: ((b = ANY (ARRAY[$1, $2])) AND ($3 <> b) AND ($4 <> b))
 (4 rows)
 
+drop table listp_2;
+-- Ensure Params that evaulate to NULL properly prune away all partitions
+explain (analyze, costs off, summary off, timing off) select * from listp where a = (select null::int);
+                  QUERY PLAN                  
+----------------------------------------------
+ Append (actual rows=0 loops=1)
+   InitPlan 1 (returns $0)
+     ->  Result (actual rows=1 loops=1)
+   ->  Seq Scan on listp_1_1 (never executed)
+         Filter: (a = $0)
+(5 rows)
+
+prepare q2 (int) as select * from listp where a = $1;
+execute q2 (1);
+ a | b 
+---+---
+(0 rows)
+
+execute q2 (1);
+ a | b 
+---+---
+(0 rows)
+
+execute q2 (1);
+ a | b 
+---+---
+(0 rows)
+
+execute q2 (1);
+ a | b 
+---+---
+(0 rows)
+
+execute q2 (1);
+ a | b 
+---+---
+(0 rows)
+
+explain (analyze, costs off, summary off, timing off)  execute q2 (null);
+                  QUERY PLAN                  
+----------------------------------------------
+ Append (actual rows=0 loops=1)
+   ->  Seq Scan on listp_1_1 (never executed)
+         Filter: (a = $1)
+(3 rows)
+
 drop table listp;
 -- Ensure runtime pruning works with initplans params with boolean types
 create table boolvalues (value bool not null);
diff --git a/src/test/regress/sql/partition_prune.sql b/src/test/regress/sql/partition_prune.sql
index 609fe09aeb..8d62b19a3d 100644
--- a/src/test/regress/sql/partition_prune.sql
+++ b/src/test/regress/sql/partition_prune.sql
@@ -685,6 +685,21 @@ explain (analyze, costs off, summary off, timing off)  execute q1 (1,2,2,0);
 -- One subplan will remain in this case, but it should not be executed.
 explain (analyze, costs off, summary off, timing off)  execute q1 (1,2,2,1);
 
+drop table listp_2;
+
+-- Ensure Params that evaulate to NULL properly prune away all partitions
+explain (analyze, costs off, summary off, timing off) select * from listp where a = (select null::int);
+
+prepare q2 (int) as select * from listp where a = $1;
+
+execute q2 (1);
+execute q2 (1);
+execute q2 (1);
+execute q2 (1);
+execute q2 (1);
+
+explain (analyze, costs off, summary off, timing off)  execute q2 (null);
+
 drop table listp;
 
 -- Ensure runtime pruning works with initplans params with boolean types

diff --git a/src/backend/executor/execPartition.c b/src/backend/executor/execPartition.c
index 33513ff1d1..5b74733804 100644
--- a/src/backend/executor/execPartition.c
+++ b/src/backend/executor/execPartition.c
@@ -1463,19 +1463,29 @@ ExecSetupPartitionPruneState(PlanState *planstate, List *partitionpruneinfo)
 
 		partkey = RelationGetPartitionKey(rel);
 		partdesc = RelationGetPartitionDesc(rel);
+		n_steps = list_length(pinfo->pruning_steps);
 
 		context->strategy = partkey->strategy;
 		context->partnatts = partnatts = partkey->partnatts;
-		context->partopfamily = partkey->partopfamily;
-		context->partopcintype = partkey->partopcintype;
-		context->partcollation = partkey->partcollation;
-		context->partsupfunc = partkey->partsupfunc;
+
+		context->partopfamily = (Oid *) palloc(sizeof(Oid) * partnatts);
+		memcpy(context->partopfamily, partkey->partopfamily, sizeof(Oid) * partnatts);
+
+		context->partopcintype = (Oid *) palloc(sizeof(Oid) * partnatts);
+		memcpy(context->partopcintype, partkey->partopcintype, sizeof(Oid) * partnatts);
+
+		context->partcollation = (Oid *) palloc(sizeof(Oid) * partnatts);
+		memcpy(context->partcollation, partkey->partcollation, sizeof(Oid) * partnatts);
+
+		context->stepcmpfuncs = (FmgrInfo *) palloc0(sizeof(FmgrInfo) *
+													 n_steps *
+													 partnatts);
+
 		context->nparts = pinfo->nparts;
 		context->boundinfo = partition_bounds_copy(partdesc->boundinfo, partkey);
 		context->planstate = planstate;
 
 		/* Initialize expression state for each expression we need */
-		n_steps = list_length(pinfo->pruning_steps);
 		context->exprstates = (ExprState **)
 			palloc0(sizeof(ExprState *) * n_steps * partnatts);
 		foreach(lc2, pinfo->pruning_steps)
diff --git a/src/backend/partitioning/partprune.c b/src/backend/partitioning/partprune.c
index 856bdd3a14..44be58f7ec 100644
--- a/src/backend/partitioning/partprune.c
+++ b/src/backend/partitioning/partprune.c
@@ -441,7 +441,9 @@ prune_append_rel_partitions(RelOptInfo *rel)
 	context.partopfamily = rel->part_scheme->partopfamily;
 	context.partopcintype = rel->part_scheme->partopcintype;
 	context.partcollation = rel->part_scheme->partcollation;
-	context.partsupfunc = rel->part_scheme->partsupfunc;
+	context.stepcmpfuncs = (FmgrInfo *) palloc0(sizeof(FmgrInfo) *
+												context.partnatts *
+												list_length(pruning_steps));
 	context.nparts = rel->nparts;
 	context.boundinfo = rel->boundinfo;
 
@@ -2809,7 +2811,8 @@ perform_pruning_base_step(PartitionPruneContext *context,
 	int			keyno,
 				nvalues;
 	Datum		values[PARTITION_MAX_KEYS];
-	FmgrInfo	partsupfunc[PARTITION_MAX_KEYS];
+	FmgrInfo	*partsupfunc;
+	int			stateidx;
 
 	/*
 	 * There better be the same number of expressions and compare functions.
@@ -2844,7 +2847,6 @@ perform_pruning_base_step(PartitionPruneContext *context,
 		if (lc1 != NULL)
 		{
 			Expr	   *expr;
-			int			stateidx;
 			Datum		datum;
 			bool		isnull;
 
@@ -2873,19 +2875,12 @@ perform_pruning_base_step(PartitionPruneContext *context,
 					return result;
 				}
 
-				/*
-				 * If we're going to need a different comparison function than
-				 * the one cached in the PartitionKey, we'll need to look up
-				 * the FmgrInfo.
-				 */
 				cmpfn = lfirst_oid(lc2);
 				Assert(OidIsValid(cmpfn));
-				if (cmpfn != context->partsupfunc[keyno].fn_oid)
-					fmgr_info(cmpfn, &partsupfunc[keyno]);
-				else
-					fmgr_info_copy(&partsupfunc[keyno],
-								   &context->partsupfunc[keyno],
-								   CurrentMemoryContext);
+
+				/* Check if we've cached the FmgrInfo yet */
+				if (!OidIsValid(context->stepcmpfuncs[stateidx].fn_oid))
+					fmgr_info(cmpfn, &context->stepcmpfuncs[stateidx]);
 
 				values[keyno] = datum;
 				nvalues++;
@@ -2896,6 +2891,14 @@ perform_pruning_base_step(PartitionPruneContext *context,
 		}
 	}
 
+	/*
+	 * Determine the stateidx for the 0th key and point the partsupfunc to
+	 * that element. This provides the correct array segment for the
+	 * strategy matching function below.
+	 */
+	stateidx = PruneCxtStateIdx(context->partnatts, opstep->step.step_id, 0);
+	partsupfunc = &context->stepcmpfuncs[stateidx];
+
 	switch (context->strategy)
 	{
 		case PARTITION_STRATEGY_HASH:
diff --git a/src/include/partitioning/partprune.h b/src/include/partitioning/partprune.h
index e3b3bfb7c1..b275c9375e 100644
--- a/src/include/partitioning/partprune.h
+++ b/src/include/partitioning/partprune.h
@@ -18,51 +18,56 @@
 #include "nodes/relation.h"
 
 
-/*
+/*-----------------------
  * PartitionPruneContext
+ *		Stores information to allow partition pruning on a single partitioned
+ *		table.
  *
- * Information about a partitioned table needed to perform partition pruning.
+ * strategy			Partition strategy, e.g. LIST, RANGE, HASH.
+ * partnatts		Number of attributes and exprs that make up the partition
+ *					key.
+ * partopfamily		Array of partnatts elements storing the opfamily of the
+ *					corresponding partition key element.
+ * partopcintype	Array of partnatts elements storing the Oid of opclass
+ *					if the corresponding partition key element.
+ * partcollation	Array of partnatts elements storing the collation of the
+ *					corresponding partition key element.
+ * stepcmpfuncs		An array to store FmrgInfo for each pruning step partition
+ *					key pair. The array should be indexed by PruneCtxStateIdx.
+ * nparts			Number of partitions belonging to this partitioned table.
+ * boundinfo		PartitionBoundInfo for the partitioned table.
+ * planstate		Holds the executor's planstate when being called during
+ *					execution, or NULL when being called from the planner.
+ * exprstates		Array of ExprStates, indexed as per PruneCtxStateIdx; one
+ *					for each partkey in each pruning step.  Allocated if
+ *					planstate is non-NULL, otherwise NULL.
+ * exprhasexecparam	Array of bools, each true if corresponding 'exprstate'
+ *					expression contains any PARAM_EXEC Params.  (Can be NULL
+ *					if planstate is NULL.)
+ * evalexecparams	True if it's safe to evaluate PARAM_EXEC Params.
+ *-----------------------
  */
 typedef struct PartitionPruneContext
 {
-	/* Partition key information */
 	char		strategy;
 	int			partnatts;
 	Oid		   *partopfamily;
 	Oid		   *partopcintype;
 	Oid		   *partcollation;
-	FmgrInfo   *partsupfunc;
-
-	/* Number of partitions */
+	FmgrInfo   *stepcmpfuncs;
 	int			nparts;
-
-	/* Partition boundary info */
 	PartitionBoundInfo boundinfo;
-
-	/*
-	 * This will be set when the context is used from the executor, to allow
-	 * Params to be evaluated.
-	 */
 	PlanState  *planstate;
-
-	/*
-	 * Array of ExprStates, indexed as per PruneCtxStateIdx; one for each
-	 * partkey in each pruning step.  Allocated if planstate is non-NULL,
-	 * otherwise NULL.
-	 */
 	ExprState **exprstates;
-
-	/*
-	 * Similar array of flags, each true if corresponding 'exprstate'
-	 * expression contains any PARAM_EXEC Params.  (Can be NULL if planstate
-	 * is NULL.)
-	 */
 	bool	   *exprhasexecparam;
-
-	/* true if it's safe to evaluate PARAM_EXEC Params */
 	bool		evalexecparams;
 } PartitionPruneContext;
 
+/*
+ * Determine a unique index into a 2-dimentional array based on the 3 inputs,
+ * where partnatts is the maximum possible value for keyno.  Consecutive
+ * keynos are consecutive array elements.
+ */
 #define PruneCxtStateIdx(partnatts, step_id, keyno) \
 	((partnatts) * (step_id) + (keyno))
 

diff --git a/src/backend/executor/execPartition.c b/src/backend/executor/execPartition.c
index 33513ff..4eeee7c 100644
*** a/src/backend/executor/execPartition.c
--- b/src/backend/executor/execPartition.c
*************** adjust_partition_tlist(List *tlist, Tupl
*** 1357,1367 ****
   *
   * Functions:
   *
!  * ExecSetupPartitionPruneState:
   *		Creates the PartitionPruneState required by each of the two pruning
   *		functions.  Details stored include how to map the partition index
   *		returned by the partition pruning code into subplan indexes.
   *
   * ExecFindInitialMatchingSubPlans:
   *		Returns indexes of matching subplans.  Partition pruning is attempted
   *		without any evaluation of expressions containing PARAM_EXEC Params.
--- 1357,1370 ----
   *
   * Functions:
   *
!  * ExecCreatePartitionPruneState:
   *		Creates the PartitionPruneState required by each of the two pruning
   *		functions.  Details stored include how to map the partition index
   *		returned by the partition pruning code into subplan indexes.
   *
+  * ExecDestroyPartitionPruneState:
+  *		Deletes a PartitionPruneState. Must be called during executor shutdown.
+  *
   * ExecFindInitialMatchingSubPlans:
   *		Returns indexes of matching subplans.  Partition pruning is attempted
   *		without any evaluation of expressions containing PARAM_EXEC Params.
*************** adjust_partition_tlist(List *tlist, Tupl
*** 1382,1389 ****
   */
  
  /*
!  * ExecSetupPartitionPruneState
!  *		Set up the data structure required for calling
   *		ExecFindInitialMatchingSubPlans and ExecFindMatchingSubPlans.
   *
   * 'planstate' is the parent plan node's execution state.
--- 1385,1392 ----
   */
  
  /*
!  * ExecCreatePartitionPruneState
!  *		Build the data structure required for calling
   *		ExecFindInitialMatchingSubPlans and ExecFindMatchingSubPlans.
   *
   * 'planstate' is the parent plan node's execution state.
*************** adjust_partition_tlist(List *tlist, Tupl
*** 1395,1401 ****
   * in each PartitionPruneInfo.
   */
  PartitionPruneState *
! ExecSetupPartitionPruneState(PlanState *planstate, List *partitionpruneinfo)
  {
  	PartitionPruneState *prunestate;
  	PartitionPruningData *prunedata;
--- 1398,1404 ----
   * in each PartitionPruneInfo.
   */
  PartitionPruneState *
! ExecCreatePartitionPruneState(PlanState *planstate, List *partitionpruneinfo)
  {
  	PartitionPruneState *prunestate;
  	PartitionPruningData *prunedata;
*************** ExecSetupPartitionPruneState(PlanState *
*** 1435,1445 ****
  		PartitionPruningData *pprune = &prunedata[i];
  		PartitionPruneContext *context = &pprune->context;
  		PartitionDesc partdesc;
- 		Relation	rel;
  		PartitionKey partkey;
- 		ListCell   *lc2;
  		int			partnatts;
  		int			n_steps;
  
  		/*
  		 * We must copy the subplan_map rather than pointing directly to the
--- 1438,1447 ----
  		PartitionPruningData *pprune = &prunedata[i];
  		PartitionPruneContext *context = &pprune->context;
  		PartitionDesc partdesc;
  		PartitionKey partkey;
  		int			partnatts;
  		int			n_steps;
+ 		ListCell   *lc2;
  
  		/*
  		 * We must copy the subplan_map rather than pointing directly to the
*************** ExecSetupPartitionPruneState(PlanState *
*** 1456,1481 ****
  		pprune->present_parts = bms_copy(pinfo->present_parts);
  
  		/*
! 		 * Grab some info from the table's relcache; lock was already obtained
! 		 * by ExecLockNonLeafAppendTables.
  		 */
! 		rel = relation_open(pinfo->reloid, NoLock);
  
! 		partkey = RelationGetPartitionKey(rel);
! 		partdesc = RelationGetPartitionDesc(rel);
  
  		context->strategy = partkey->strategy;
  		context->partnatts = partnatts = partkey->partnatts;
! 		context->partopfamily = partkey->partopfamily;
! 		context->partopcintype = partkey->partopcintype;
  		context->partcollation = partkey->partcollation;
  		context->partsupfunc = partkey->partsupfunc;
! 		context->nparts = pinfo->nparts;
! 		context->boundinfo = partition_bounds_copy(partdesc->boundinfo, partkey);
  		context->planstate = planstate;
  
  		/* Initialize expression state for each expression we need */
- 		n_steps = list_length(pinfo->pruning_steps);
  		context->exprstates = (ExprState **)
  			palloc0(sizeof(ExprState *) * n_steps * partnatts);
  		foreach(lc2, pinfo->pruning_steps)
--- 1458,1490 ----
  		pprune->present_parts = bms_copy(pinfo->present_parts);
  
  		/*
! 		 * We need to hold a pin on the partitioned table's relcache entry so
! 		 * that we can rely on its copies of the table's partition key and
! 		 * partition descriptor.  We need not get a lock though; one should
! 		 * have been acquired already by InitPlan or
! 		 * ExecLockNonLeafAppendTables.
  		 */
! 		context->partrel = relation_open(pinfo->reloid, NoLock);
  
! 		partkey = RelationGetPartitionKey(context->partrel);
! 		partdesc = RelationGetPartitionDesc(context->partrel);
! 		n_steps = list_length(pinfo->pruning_steps);
  
  		context->strategy = partkey->strategy;
  		context->partnatts = partnatts = partkey->partnatts;
! 		context->nparts = pinfo->nparts;
! 		context->boundinfo = partdesc->boundinfo;
  		context->partcollation = partkey->partcollation;
  		context->partsupfunc = partkey->partsupfunc;
! 
! 		/* We'll look up type-specific support functions as needed */
! 		context->stepcmpfuncs = (FmgrInfo *)
! 			palloc0(sizeof(FmgrInfo) * n_steps * partnatts);
! 
! 		context->ppccontext = CurrentMemoryContext;
  		context->planstate = planstate;
  
  		/* Initialize expression state for each expression we need */
  		context->exprstates = (ExprState **)
  			palloc0(sizeof(ExprState *) * n_steps * partnatts);
  		foreach(lc2, pinfo->pruning_steps)
*************** ExecSetupPartitionPruneState(PlanState *
*** 1527,1534 ****
  		prunestate->execparamids = bms_add_members(prunestate->execparamids,
  												   pinfo->execparamids);
  
- 		relation_close(rel, NoLock);
- 
  		i++;
  	}
  
--- 1536,1541 ----
*************** ExecSetupPartitionPruneState(PlanState *
*** 1536,1541 ****
--- 1543,1568 ----
  }
  
  /*
+  * ExecDestroyPartitionPruneState
+  *		Release resources at plan shutdown.
+  *
+  * We don't bother to free any memory here, since the whole executor context
+  * will be going away shortly.  We do need to release our relcache pins.
+  */
+ void
+ ExecDestroyPartitionPruneState(PartitionPruneState *prunestate)
+ {
+ 	int			i;
+ 
+ 	for (i = 0; i < prunestate->num_partprunedata; i++)
+ 	{
+ 		PartitionPruningData *pprune = &prunestate->partprunedata[i];
+ 
+ 		relation_close(pprune->context.partrel, NoLock);
+ 	}
+ }
+ 
+ /*
   * ExecFindInitialMatchingSubPlans
   *		Identify the set of subplans that cannot be eliminated by initial
   *		pruning (disregarding any pruning constraints involving PARAM_EXEC
diff --git a/src/backend/executor/nodeAppend.c b/src/backend/executor/nodeAppend.c
index 6dd53e9..5ce4fb4 100644
*** a/src/backend/executor/nodeAppend.c
--- b/src/backend/executor/nodeAppend.c
*************** ExecInitAppend(Append *node, EState *est
*** 136,143 ****
  		/* We may need an expression context to evaluate partition exprs */
  		ExecAssignExprContext(estate, &appendstate->ps);
  
! 		prunestate = ExecSetupPartitionPruneState(&appendstate->ps,
! 												  node->part_prune_infos);
  
  		/* Perform an initial partition prune, if required. */
  		if (prunestate->do_initial_prune)
--- 136,145 ----
  		/* We may need an expression context to evaluate partition exprs */
  		ExecAssignExprContext(estate, &appendstate->ps);
  
! 		/* Create the working data structure for pruning. */
! 		prunestate = ExecCreatePartitionPruneState(&appendstate->ps,
! 												   node->part_prune_infos);
! 		appendstate->as_prune_state = prunestate;
  
  		/* Perform an initial partition prune, if required. */
  		if (prunestate->do_initial_prune)
*************** ExecInitAppend(Append *node, EState *est
*** 178,185 ****
  		 */
  		if (!prunestate->do_exec_prune)
  			appendstate->as_valid_subplans = bms_add_range(NULL, 0, nplans - 1);
- 
- 		appendstate->as_prune_state = prunestate;
  	}
  	else
  	{
--- 180,185 ----
*************** ExecEndAppend(AppendState *node)
*** 330,335 ****
--- 330,341 ----
  	 */
  	for (i = 0; i < nplans; i++)
  		ExecEndNode(appendplans[i]);
+ 
+ 	/*
+ 	 * release any resources associated with run-time pruning
+ 	 */
+ 	if (node->as_prune_state)
+ 		ExecDestroyPartitionPruneState(node->as_prune_state);
  }
  
  void
diff --git a/src/backend/partitioning/partprune.c b/src/backend/partitioning/partprune.c
index 856bdd3..ee5826e 100644
*** a/src/backend/partitioning/partprune.c
--- b/src/backend/partitioning/partprune.c
*************** prune_append_rel_partitions(RelOptInfo *
*** 436,449 ****
  	if (contradictory)
  		return NULL;
  
  	context.strategy = rel->part_scheme->strategy;
  	context.partnatts = rel->part_scheme->partnatts;
- 	context.partopfamily = rel->part_scheme->partopfamily;
- 	context.partopcintype = rel->part_scheme->partopcintype;
- 	context.partcollation = rel->part_scheme->partcollation;
- 	context.partsupfunc = rel->part_scheme->partsupfunc;
  	context.nparts = rel->nparts;
  	context.boundinfo = rel->boundinfo;
  
  	/* These are not valid when being called from the planner */
  	context.planstate = NULL;
--- 436,453 ----
  	if (contradictory)
  		return NULL;
  
+ 	/* Set up PartitionPruneContext */
+ 	context.partrel = NULL;
  	context.strategy = rel->part_scheme->strategy;
  	context.partnatts = rel->part_scheme->partnatts;
  	context.nparts = rel->nparts;
  	context.boundinfo = rel->boundinfo;
+ 	context.partcollation = rel->part_scheme->partcollation;
+ 	context.partsupfunc = rel->part_scheme->partsupfunc;
+ 	context.stepcmpfuncs = (FmgrInfo *) palloc0(sizeof(FmgrInfo) *
+ 												context.partnatts *
+ 												list_length(pruning_steps));
+ 	context.ppccontext = CurrentMemoryContext;
  
  	/* These are not valid when being called from the planner */
  	context.planstate = NULL;
*************** perform_pruning_base_step(PartitionPrune
*** 2809,2815 ****
  	int			keyno,
  				nvalues;
  	Datum		values[PARTITION_MAX_KEYS];
! 	FmgrInfo	partsupfunc[PARTITION_MAX_KEYS];
  
  	/*
  	 * There better be the same number of expressions and compare functions.
--- 2813,2820 ----
  	int			keyno,
  				nvalues;
  	Datum		values[PARTITION_MAX_KEYS];
! 	FmgrInfo   *partsupfunc;
! 	int			stateidx;
  
  	/*
  	 * There better be the same number of expressions and compare functions.
*************** perform_pruning_base_step(PartitionPrune
*** 2844,2850 ****
  		if (lc1 != NULL)
  		{
  			Expr	   *expr;
- 			int			stateidx;
  			Datum		datum;
  			bool		isnull;
  
--- 2849,2854 ----
*************** perform_pruning_base_step(PartitionPrune
*** 2873,2891 ****
  					return result;
  				}
  
! 				/*
! 				 * If we're going to need a different comparison function than
! 				 * the one cached in the PartitionKey, we'll need to look up
! 				 * the FmgrInfo.
! 				 */
  				cmpfn = lfirst_oid(lc2);
  				Assert(OidIsValid(cmpfn));
! 				if (cmpfn != context->partsupfunc[keyno].fn_oid)
! 					fmgr_info(cmpfn, &partsupfunc[keyno]);
! 				else
! 					fmgr_info_copy(&partsupfunc[keyno],
! 								   &context->partsupfunc[keyno],
! 								   CurrentMemoryContext);
  
  				values[keyno] = datum;
  				nvalues++;
--- 2877,2901 ----
  					return result;
  				}
  
! 				/* Set up the stepcmpfuncs entry, unless we already did */
  				cmpfn = lfirst_oid(lc2);
  				Assert(OidIsValid(cmpfn));
! 				if (cmpfn != context->stepcmpfuncs[stateidx].fn_oid)
! 				{
! 					/*
! 					 * If the needed support function is the same one cached
! 					 * in the relation's partition key, copy the cached
! 					 * FmgrInfo.  Otherwise (i.e., when we have a cross-type
! 					 * comparison), an actual lookup is required.
! 					 */
! 					if (cmpfn == context->partsupfunc[keyno].fn_oid)
! 						fmgr_info_copy(&context->stepcmpfuncs[stateidx],
! 									   &context->partsupfunc[keyno],
! 									   context->ppccontext);
! 					else
! 						fmgr_info_cxt(cmpfn, &context->stepcmpfuncs[stateidx],
! 									  context->ppccontext);
! 				}
  
  				values[keyno] = datum;
  				nvalues++;
*************** perform_pruning_base_step(PartitionPrune
*** 2896,2901 ****
--- 2906,2918 ----
  		}
  	}
  
+ 	/*
+ 	 * Point partsupfunc to the entry for the 0th key of this step; the
+ 	 * additional support functions, if any, follow consecutively.
+ 	 */
+ 	stateidx = PruneCxtStateIdx(context->partnatts, opstep->step.step_id, 0);
+ 	partsupfunc = &context->stepcmpfuncs[stateidx];
+ 
  	switch (context->strategy)
  	{
  		case PARTITION_STRATEGY_HASH:
diff --git a/src/backend/utils/cache/relcache.c b/src/backend/utils/cache/relcache.c
index 3dfb1b8..dc69280 100644
*** a/src/backend/utils/cache/relcache.c
--- b/src/backend/utils/cache/relcache.c
*************** RelationClearRelation(Relation relation,
*** 2401,2406 ****
--- 2401,2407 ----
  		keep_tupdesc = equalTupleDescs(relation->rd_att, newrel->rd_att);
  		keep_rules = equalRuleLocks(relation->rd_rules, newrel->rd_rules);
  		keep_policies = equalRSDesc(relation->rd_rsdesc, newrel->rd_rsdesc);
+ 		/* partkey is immutable once set up, so we can always keep it */
  		keep_partkey = (relation->rd_partkey != NULL);
  		keep_partdesc = equalPartitionDescs(relation->rd_partkey,
  											relation->rd_partdesc,
*************** RelationClearRelation(Relation relation,
*** 2445,2451 ****
  		SWAPFIELD(Form_pg_class, rd_rel);
  		/* ... but actually, we don't have to update newrel->rd_rel */
  		memcpy(relation->rd_rel, newrel->rd_rel, CLASS_TUPLE_SIZE);
! 		/* preserve old tupledesc and rules if no logical change */
  		if (keep_tupdesc)
  			SWAPFIELD(TupleDesc, rd_att);
  		if (keep_rules)
--- 2446,2452 ----
  		SWAPFIELD(Form_pg_class, rd_rel);
  		/* ... but actually, we don't have to update newrel->rd_rel */
  		memcpy(relation->rd_rel, newrel->rd_rel, CLASS_TUPLE_SIZE);
! 		/* preserve old tupledesc, rules, policies if no logical change */
  		if (keep_tupdesc)
  			SWAPFIELD(TupleDesc, rd_att);
  		if (keep_rules)
*************** RelationClearRelation(Relation relation,
*** 2459,2471 ****
  		SWAPFIELD(Oid, rd_toastoid);
  		/* pgstat_info must be preserved */
  		SWAPFIELD(struct PgStat_TableStatus *, pgstat_info);
! 		/* partition key must be preserved, if we have one */
  		if (keep_partkey)
  		{
  			SWAPFIELD(PartitionKey, rd_partkey);
  			SWAPFIELD(MemoryContext, rd_partkeycxt);
  		}
- 		/* preserve old partdesc if no logical change */
  		if (keep_partdesc)
  		{
  			SWAPFIELD(PartitionDesc, rd_partdesc);
--- 2460,2471 ----
  		SWAPFIELD(Oid, rd_toastoid);
  		/* pgstat_info must be preserved */
  		SWAPFIELD(struct PgStat_TableStatus *, pgstat_info);
! 		/* preserve old partitioning info if no logical change */
  		if (keep_partkey)
  		{
  			SWAPFIELD(PartitionKey, rd_partkey);
  			SWAPFIELD(MemoryContext, rd_partkeycxt);
  		}
  		if (keep_partdesc)
  		{
  			SWAPFIELD(PartitionDesc, rd_partdesc);
diff --git a/src/include/executor/execPartition.h b/src/include/executor/execPartition.h
index 71d639f..862bf65 100644
*** a/src/include/executor/execPartition.h
--- b/src/include/executor/execPartition.h
*************** extern HeapTuple ConvertPartitionTupleSl
*** 208,215 ****
  						  TupleTableSlot **p_my_slot);
  extern void ExecCleanupTupleRouting(ModifyTableState *mtstate,
  						PartitionTupleRouting *proute);
! extern PartitionPruneState *ExecSetupPartitionPruneState(PlanState *planstate,
! 							 List *partitionpruneinfo);
  extern Bitmapset *ExecFindMatchingSubPlans(PartitionPruneState *prunestate);
  extern Bitmapset *ExecFindInitialMatchingSubPlans(PartitionPruneState *prunestate,
  								int nsubplans);
--- 208,216 ----
  						  TupleTableSlot **p_my_slot);
  extern void ExecCleanupTupleRouting(ModifyTableState *mtstate,
  						PartitionTupleRouting *proute);
! extern PartitionPruneState *ExecCreatePartitionPruneState(PlanState *planstate,
! 							  List *partitionpruneinfo);
! extern void ExecDestroyPartitionPruneState(PartitionPruneState *prunestate);
  extern Bitmapset *ExecFindMatchingSubPlans(PartitionPruneState *prunestate);
  extern Bitmapset *ExecFindInitialMatchingSubPlans(PartitionPruneState *prunestate,
  								int nsubplans);
diff --git a/src/include/partitioning/partprune.h b/src/include/partitioning/partprune.h
index e3b3bfb..09147b5 100644
*** a/src/include/partitioning/partprune.h
--- b/src/include/partitioning/partprune.h
***************
*** 20,68 ****
  
  /*
   * PartitionPruneContext
   *
!  * Information about a partitioned table needed to perform partition pruning.
   */
  typedef struct PartitionPruneContext
  {
! 	/* Partition key information */
  	char		strategy;
  	int			partnatts;
- 	Oid		   *partopfamily;
- 	Oid		   *partopcintype;
- 	Oid		   *partcollation;
- 	FmgrInfo   *partsupfunc;
- 
- 	/* Number of partitions */
  	int			nparts;
- 
- 	/* Partition boundary info */
  	PartitionBoundInfo boundinfo;
! 
! 	/*
! 	 * This will be set when the context is used from the executor, to allow
! 	 * Params to be evaluated.
! 	 */
  	PlanState  *planstate;
- 
- 	/*
- 	 * Array of ExprStates, indexed as per PruneCtxStateIdx; one for each
- 	 * partkey in each pruning step.  Allocated if planstate is non-NULL,
- 	 * otherwise NULL.
- 	 */
  	ExprState **exprstates;
- 
- 	/*
- 	 * Similar array of flags, each true if corresponding 'exprstate'
- 	 * expression contains any PARAM_EXEC Params.  (Can be NULL if planstate
- 	 * is NULL.)
- 	 */
  	bool	   *exprhasexecparam;
- 
- 	/* true if it's safe to evaluate PARAM_EXEC Params */
  	bool		evalexecparams;
  } PartitionPruneContext;
  
  #define PruneCxtStateIdx(partnatts, step_id, keyno) \
  	((partnatts) * (step_id) + (keyno))
  
--- 20,76 ----
  
  /*
   * PartitionPruneContext
+  *		Stores information needed at runtime for pruning computations
+  *		related to a single partitioned table.
   *
!  * partrel			Relcache pointer for the partitioned table,
!  *					if we have it open (else NULL).
!  * strategy			Partition strategy, e.g. LIST, RANGE, HASH.
!  * partnatts		Number of columns in the partition key.
!  * nparts			Number of partitions in this partitioned table.
!  * boundinfo		Partition boundary info for the partitioned table.
!  * partcollation	Array of partnatts elements, storing the collations of the
!  *					partition key columns.
!  * partsupfunc		Array of FmgrInfos for the comparison or hashing functions
!  *					associated with the partition keys (partnatts elements).
!  *					(This points into the partrel's partition key, typically.)
!  * stepcmpfuncs		Array of FmgrInfos for the comparison or hashing function
!  *					for each pruning step and partition key.
!  * ppccontext		Memory context holding this PartitionPruneContext's
!  *					subsidiary data, such as the FmgrInfos.
!  * planstate		Points to the parent plan node's PlanState when called
!  *					during execution; NULL when called from the planner.
!  * exprstates		Array of ExprStates, indexed as per PruneCtxStateIdx; one
!  *					for each partition key in each pruning step.  Allocated if
!  *					planstate is non-NULL, otherwise NULL.
!  * exprhasexecparam	Array of bools, each true if corresponding 'exprstate'
!  *					expression contains any PARAM_EXEC Params.  (Can be NULL
!  *					if planstate is NULL.)
!  * evalexecparams	True if it's safe to evaluate PARAM_EXEC Params.
   */
  typedef struct PartitionPruneContext
  {
! 	Relation	partrel;
  	char		strategy;
  	int			partnatts;
  	int			nparts;
  	PartitionBoundInfo boundinfo;
! 	Oid		   *partcollation;
! 	FmgrInfo   *partsupfunc;
! 	FmgrInfo   *stepcmpfuncs;
! 	MemoryContext ppccontext;
  	PlanState  *planstate;
  	ExprState **exprstates;
  	bool	   *exprhasexecparam;
  	bool		evalexecparams;
  } PartitionPruneContext;
  
+ /*
+  * PruneCxtStateIdx() computes the correct index into the stepcmpfuncs[],
+  * exprstates[] and exprhasexecparam[] arrays for step step_id and
+  * partition key column keyno.  (Note: there is code that assumes the
+  * entries for a given step are sequential, so this is not chosen freely.)
+  */
  #define PruneCxtStateIdx(partnatts, step_id, keyno) \
  	((partnatts) * (step_id) + (keyno))
  

diff --git a/src/backend/executor/execPartition.c b/src/backend/executor/execPartition.c
index 7a4665cc4e..ea6b05934b 100644
--- a/src/backend/executor/execPartition.c
+++ b/src/backend/executor/execPartition.c
@@ -1401,7 +1401,8 @@ adjust_partition_tlist(List *tlist, TupleConversionMap *map)
  * in each PartitionPruneInfo.
  */
 PartitionPruneState *
-ExecCreatePartitionPruneState(PlanState *planstate, List *partitionpruneinfo)
+ExecCreatePartitionPruneState(PlanState *planstate, List *partitionpruneinfo,
+							  Relation *partitioned_rels)
 {
 	PartitionPruneState *prunestate;
 	PartitionPruningData *prunedata;
@@ -1440,6 +1441,7 @@ ExecCreatePartitionPruneState(PlanState *planstate, List *partitionpruneinfo)
 		PartitionPruneInfo *pinfo = castNode(PartitionPruneInfo, lfirst(lc));
 		PartitionPruningData *pprune = &prunedata[i];
 		PartitionPruneContext *context = &pprune->context;
+		Relation	rel;
 		PartitionDesc partdesc;
 		PartitionKey partkey;
 		int			partnatts;
@@ -1460,17 +1462,11 @@ ExecCreatePartitionPruneState(PlanState *planstate, List *partitionpruneinfo)
 		/* present_parts is also subject to later modification */
 		pprune->present_parts = bms_copy(pinfo->present_parts);
 
-		/*
-		 * We need to hold a pin on the partitioned table's relcache entry so
-		 * that we can rely on its copies of the table's partition key and
-		 * partition descriptor.  We need not get a lock though; one should
-		 * have been acquired already by InitPlan or
-		 * ExecLockNonLeafAppendTables.
-		 */
-		context->partrel = relation_open(pinfo->reloid, NoLock);
-
-		partkey = RelationGetPartitionKey(context->partrel);
-		partdesc = RelationGetPartitionDesc(context->partrel);
+		Assert(partitioned_rels[i] != NULL);
+		rel = partitioned_rels[i];
+		Assert(RelationGetRelid(rel) == pinfo->reloid);
+		partkey = RelationGetPartitionKey(rel);
+		partdesc = RelationGetPartitionDesc(rel);
 		n_steps = list_length(pinfo->pruning_steps);
 
 		context->strategy = partkey->strategy;
@@ -1546,26 +1542,6 @@ ExecCreatePartitionPruneState(PlanState *planstate, List *partitionpruneinfo)
 }
 
 /*
- * ExecDestroyPartitionPruneState
- *		Release resources at plan shutdown.
- *
- * We don't bother to free any memory here, since the whole executor context
- * will be going away shortly.  We do need to release our relcache pins.
- */
-void
-ExecDestroyPartitionPruneState(PartitionPruneState *prunestate)
-{
-	int			i;
-
-	for (i = 0; i < prunestate->num_partprunedata; i++)
-	{
-		PartitionPruningData *pprune = &prunestate->partprunedata[i];
-
-		relation_close(pprune->context.partrel, NoLock);
-	}
-}
-
-/*
  * ExecFindInitialMatchingSubPlans
  *		Identify the set of subplans that cannot be eliminated by initial
  *		pruning (disregarding any pruning constraints involving PARAM_EXEC
diff --git a/src/backend/executor/execUtils.c b/src/backend/executor/execUtils.c
index b963cae730..87809054ed 100644
--- a/src/backend/executor/execUtils.c
+++ b/src/backend/executor/execUtils.c
@@ -858,22 +858,52 @@ ShutdownExprContext(ExprContext *econtext, bool isCommit)
 /*
  * ExecLockNonLeafAppendTables
  *
- * Locks, if necessary, the tables indicated by the RT indexes contained in
- * the partitioned_rels list.  These are the non-leaf tables in the partition
- * tree controlled by a given Append or MergeAppend node.
+ * Opens and/or locks, if necessary, the tables indicated by the RT indexes
+ * contained in the partitioned_rels list.  These are the non-leaf tables in
+ * the partition tree controlled by a given Append or MergeAppend node.
  */
 void
-ExecLockNonLeafAppendTables(List *partitioned_rels, EState *estate)
+ExecLockNonLeafAppendTables(PlanState *planstate,
+							EState *estate,
+							List *partitioned_rels)
 {
 	PlannedStmt *stmt = estate->es_plannedstmt;
 	ListCell   *lc;
+	int			i;
 
+	if (partitioned_rels == NIL)
+		return;
+
+	/*
+	 * If we're going to be performing pruning, allocate space for Relation
+	 * pointers to be used later when setting up partition pruning state in
+	 * ExecCreatePartitionPruneState.
+	 */
+	if (IsA(planstate, AppendState))
+	{
+		AppendState *appendstate = (AppendState *) planstate;
+		Append *node = (Append *) planstate->plan;
+
+		if (node->part_prune_infos != NIL)
+		{
+			Assert(list_length(node->part_prune_infos) ==
+				   list_length(partitioned_rels));
+			appendstate->partitioned_rels = (Relation *)
+								palloc(sizeof(Relation) *
+									   list_length(node->part_prune_infos));
+			appendstate->num_partitioned_rels =
+									   list_length(node->part_prune_infos);
+		}
+	}
+
+	i = 0;
 	foreach(lc, partitioned_rels)
 	{
 		ListCell   *l;
 		Index		rti = lfirst_int(lc);
 		bool		is_result_rel = false;
 		Oid			relid = getrelid(rti, estate->es_range_table);
+		int			lockmode;
 
 		/* If this is a result relation, already locked in InitPlan */
 		foreach(l, stmt->nonleafResultRelations)
@@ -903,9 +933,39 @@ ExecLockNonLeafAppendTables(List *partitioned_rels, EState *estate)
 			}
 
 			if (rc && RowMarkRequiresRowShareLock(rc->markType))
-				LockRelationOid(relid, RowShareLock);
+				lockmode = RowShareLock;
 			else
-				LockRelationOid(relid, AccessShareLock);
+				lockmode = AccessShareLock;
+			switch (nodeTag(planstate))
+			{
+				/*
+				 * We need to also hold a pin on the partitioned table's
+				 * relcache entry so that we can rely on its copies of the
+				 * table's partition key and partition descriptor, which
+				 * are used when setting up partition pruning state.
+				 */
+				case T_AppendState:
+					{
+						AppendState *appendstate = (AppendState *) planstate;
+
+						if (appendstate->partitioned_rels)
+							appendstate->partitioned_rels[i] =
+												heap_open(relid, lockmode);
+						else
+							LockRelationOid(relid, lockmode);
+						i++;
+					}
+
+				/* Just lock here; there is no pruning support. */
+				case T_MergeAppendState:
+					LockRelationOid(relid, lockmode);
+					break;
+
+				default:
+					elog(ERROR, "invalid PlanState node: %d",
+						 nodeTag(planstate));
+					break;
+			}
 		}
 	}
 }
diff --git a/src/backend/executor/nodeAppend.c b/src/backend/executor/nodeAppend.c
index 5ce4fb43e1..5ce4601a35 100644
--- a/src/backend/executor/nodeAppend.c
+++ b/src/backend/executor/nodeAppend.c
@@ -113,18 +113,19 @@ ExecInitAppend(Append *node, EState *estate, int eflags)
 	Assert(!(eflags & EXEC_FLAG_MARK));
 
 	/*
-	 * Lock the non-leaf tables in the partition tree controlled by this node.
-	 * It's a no-op for non-partitioned parent tables.
-	 */
-	ExecLockNonLeafAppendTables(node->partitioned_rels, estate);
-
-	/*
 	 * create new AppendState for our append node
 	 */
 	appendstate->ps.plan = (Plan *) node;
 	appendstate->ps.state = estate;
 	appendstate->ps.ExecProcNode = ExecAppend;
 
+	/*
+	 * Lock the non-leaf tables in the partition tree controlled by this node.
+	 * It's a no-op for non-partitioned parent tables.
+	 */
+	ExecLockNonLeafAppendTables((PlanState *) appendstate, estate,
+								node->partitioned_rels);
+
 	/* Let choose_next_subplan_* function handle setting the first subplan */
 	appendstate->as_whichplan = INVALID_SUBPLAN_INDEX;
 
@@ -137,8 +138,12 @@ ExecInitAppend(Append *node, EState *estate, int eflags)
 		ExecAssignExprContext(estate, &appendstate->ps);
 
 		/* Create the working data structure for pruning. */
+
+		/* ExecLockNonLeafAppendTables must have set this up. */
+		Assert(appendstate->partitioned_rels != NULL);
 		prunestate = ExecCreatePartitionPruneState(&appendstate->ps,
-												   node->part_prune_infos);
+												   node->part_prune_infos,
+												   appendstate->partitioned_rels);
 		appendstate->as_prune_state = prunestate;
 
 		/* Perform an initial partition prune, if required. */
@@ -318,6 +323,7 @@ ExecEndAppend(AppendState *node)
 	PlanState **appendplans;
 	int			nplans;
 	int			i;
+	int			num_partitioned_rels;
 
 	/*
 	 * get information from the node
@@ -326,16 +332,19 @@ ExecEndAppend(AppendState *node)
 	nplans = node->as_nplans;
 
 	/*
+	 * Close partitioned rels that we may have opened for partition
+	 * pruning.
+	 */
+	num_partitioned_rels = node->num_partitioned_rels;
+	Assert(node->partitioned_rels != NULL || num_partitioned_rels == 0);
+	for (i = 0; i < num_partitioned_rels; i++)
+		heap_close(node->partitioned_rels[i], NoLock);
+
+	/*
 	 * shut down each of the subscans
 	 */
 	for (i = 0; i < nplans; i++)
 		ExecEndNode(appendplans[i]);
-
-	/*
-	 * release any resources associated with run-time pruning
-	 */
-	if (node->as_prune_state)
-		ExecDestroyPartitionPruneState(node->as_prune_state);
 }
 
 void
diff --git a/src/backend/executor/nodeMergeAppend.c b/src/backend/executor/nodeMergeAppend.c
index 118f4ef07d..6f28002ce2 100644
--- a/src/backend/executor/nodeMergeAppend.c
+++ b/src/backend/executor/nodeMergeAppend.c
@@ -76,7 +76,8 @@ ExecInitMergeAppend(MergeAppend *node, EState *estate, int eflags)
 	 * Lock the non-leaf tables in the partition tree controlled by this node.
 	 * It's a no-op for non-partitioned parent tables.
 	 */
-	ExecLockNonLeafAppendTables(node->partitioned_rels, estate);
+	ExecLockNonLeafAppendTables((PlanState *) mergestate, estate,
+								node->partitioned_rels);
 
 	/*
 	 * Set up empty vector of subplan states
diff --git a/src/include/executor/execPartition.h b/src/include/executor/execPartition.h
index 862bf65060..33c3f73e78 100644
--- a/src/include/executor/execPartition.h
+++ b/src/include/executor/execPartition.h
@@ -209,8 +209,8 @@ extern HeapTuple ConvertPartitionTupleSlot(TupleConversionMap *map,
 extern void ExecCleanupTupleRouting(ModifyTableState *mtstate,
 						PartitionTupleRouting *proute);
 extern PartitionPruneState *ExecCreatePartitionPruneState(PlanState *planstate,
-							  List *partitionpruneinfo);
-extern void ExecDestroyPartitionPruneState(PartitionPruneState *prunestate);
+							  List *partitionpruneinfo,
+							  Relation *partitioned_rels);
 extern Bitmapset *ExecFindMatchingSubPlans(PartitionPruneState *prunestate);
 extern Bitmapset *ExecFindInitialMatchingSubPlans(PartitionPruneState *prunestate,
 								int nsubplans);
diff --git a/src/include/executor/executor.h b/src/include/executor/executor.h
index f82b51667f..2b5eec9896 100644
--- a/src/include/executor/executor.h
+++ b/src/include/executor/executor.h
@@ -524,7 +524,9 @@ extern void UnregisterExprContextCallback(ExprContext *econtext,
 							  ExprContextCallbackFunction function,
 							  Datum arg);
 
-extern void ExecLockNonLeafAppendTables(List *partitioned_rels, EState *estate);
+extern void ExecLockNonLeafAppendTables(PlanState *planstate,
+							EState *estate,
+							List *partitioned_rels);
 
 extern Datum GetAttributeByName(HeapTupleHeader tuple, const char *attname,
 				   bool *isNull);
diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h
index da7f52cab0..a20d94fd9f 100644
--- a/src/include/nodes/execnodes.h
+++ b/src/include/nodes/execnodes.h
@@ -1092,6 +1092,8 @@ struct AppendState
 										 * the first partial plan */
 	ParallelAppendState *as_pstate; /* parallel coordination info */
 	Size		pstate_len;		/* size of parallel coordination info */
+	Relation   *partitioned_rels;
+	int			num_partitioned_rels;	/* number of entries in above array */
 	struct PartitionPruneState *as_prune_state;
 	Bitmapset  *as_valid_subplans;
 	bool		(*choose_next_subplan) (AppendState *);

From d55c30f8330081bc7c2eadea61d236a3b5de0f87 Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Thu, 14 Jun 2018 14:50:22 +0900
Subject: [PATCH] Open partitioned tables during Append initialization

---
 src/backend/executor/execPartition.c   |  40 ++------
 src/backend/executor/execUtils.c       | 173 ++++++++++++++++++++++-----------
 src/backend/executor/nodeAppend.c      |  33 ++++---
 src/backend/executor/nodeMergeAppend.c |   9 +-
 src/include/executor/execPartition.h   |   4 +-
 src/include/executor/executor.h        |   4 +-
 src/include/nodes/execnodes.h          |   2 +
 7 files changed, 157 insertions(+), 108 deletions(-)

diff --git a/src/backend/executor/execPartition.c b/src/backend/executor/execPartition.c
index 7a4665cc4e..ea6b05934b 100644
--- a/src/backend/executor/execPartition.c
+++ b/src/backend/executor/execPartition.c
@@ -1401,7 +1401,8 @@ adjust_partition_tlist(List *tlist, TupleConversionMap *map)
  * in each PartitionPruneInfo.
  */
 PartitionPruneState *
-ExecCreatePartitionPruneState(PlanState *planstate, List *partitionpruneinfo)
+ExecCreatePartitionPruneState(PlanState *planstate, List *partitionpruneinfo,
+							  Relation *partitioned_rels)
 {
 	PartitionPruneState *prunestate;
 	PartitionPruningData *prunedata;
@@ -1440,6 +1441,7 @@ ExecCreatePartitionPruneState(PlanState *planstate, List *partitionpruneinfo)
 		PartitionPruneInfo *pinfo = castNode(PartitionPruneInfo, lfirst(lc));
 		PartitionPruningData *pprune = &prunedata[i];
 		PartitionPruneContext *context = &pprune->context;
+		Relation	rel;
 		PartitionDesc partdesc;
 		PartitionKey partkey;
 		int			partnatts;
@@ -1460,17 +1462,11 @@ ExecCreatePartitionPruneState(PlanState *planstate, List *partitionpruneinfo)
 		/* present_parts is also subject to later modification */
 		pprune->present_parts = bms_copy(pinfo->present_parts);
 
-		/*
-		 * We need to hold a pin on the partitioned table's relcache entry so
-		 * that we can rely on its copies of the table's partition key and
-		 * partition descriptor.  We need not get a lock though; one should
-		 * have been acquired already by InitPlan or
-		 * ExecLockNonLeafAppendTables.
-		 */
-		context->partrel = relation_open(pinfo->reloid, NoLock);
-
-		partkey = RelationGetPartitionKey(context->partrel);
-		partdesc = RelationGetPartitionDesc(context->partrel);
+		Assert(partitioned_rels[i] != NULL);
+		rel = partitioned_rels[i];
+		Assert(RelationGetRelid(rel) == pinfo->reloid);
+		partkey = RelationGetPartitionKey(rel);
+		partdesc = RelationGetPartitionDesc(rel);
 		n_steps = list_length(pinfo->pruning_steps);
 
 		context->strategy = partkey->strategy;
@@ -1546,26 +1542,6 @@ ExecCreatePartitionPruneState(PlanState *planstate, List *partitionpruneinfo)
 }
 
 /*
- * ExecDestroyPartitionPruneState
- *		Release resources at plan shutdown.
- *
- * We don't bother to free any memory here, since the whole executor context
- * will be going away shortly.  We do need to release our relcache pins.
- */
-void
-ExecDestroyPartitionPruneState(PartitionPruneState *prunestate)
-{
-	int			i;
-
-	for (i = 0; i < prunestate->num_partprunedata; i++)
-	{
-		PartitionPruningData *pprune = &prunestate->partprunedata[i];
-
-		relation_close(pprune->context.partrel, NoLock);
-	}
-}
-
-/*
  * ExecFindInitialMatchingSubPlans
  *		Identify the set of subplans that cannot be eliminated by initial
  *		pruning (disregarding any pruning constraints involving PARAM_EXEC
diff --git a/src/backend/executor/execUtils.c b/src/backend/executor/execUtils.c
index b963cae730..540b885c55 100644
--- a/src/backend/executor/execUtils.c
+++ b/src/backend/executor/execUtils.c
@@ -704,6 +704,124 @@ ExecCloseScanRelation(Relation scanrel)
 }
 
 /*
+ * ExecOpenAppendPartitionedTables
+ *
+ * Opens and/or locks, if necessary, the tables indicated by the RT indexes
+ * contained in the partitioned_rels list of a given Append or MergeAppend
+ * node.  These are the non-leaf tables in the partition tree controlled by
+ * the node.
+ */
+void
+ExecOpenAppendPartitionedTables(PlanState *planstate,
+								EState *estate,
+								List *partitioned_rels)
+{
+	PlannedStmt *stmt = estate->es_plannedstmt;
+	ListCell   *lc;
+	int			i;
+
+	Assert(partitioned_rels != NIL);
+
+	/*
+	 * If we're going to be performing pruning, allocate space for Relation
+	 * pointers to be used later when setting up partition pruning state in
+	 * ExecCreatePartitionPruneState.
+	 */
+	if (IsA(planstate, AppendState))
+	{
+		AppendState *appendstate = (AppendState *) planstate;
+		Append *node = (Append *) planstate->plan;
+
+		if (node->part_prune_infos != NIL)
+		{
+			Assert(list_length(node->part_prune_infos) ==
+				   list_length(partitioned_rels));
+			appendstate->partitioned_rels = (Relation *)
+								palloc(sizeof(Relation) *
+									   list_length(node->part_prune_infos));
+			appendstate->num_partitioned_rels =
+									   list_length(node->part_prune_infos);
+		}
+	}
+
+	i = 0;
+	foreach(lc, partitioned_rels)
+	{
+		ListCell   *l;
+		Index		rti = lfirst_int(lc);
+		bool		is_result_rel = false;
+		Oid			relid = getrelid(rti, estate->es_range_table);
+		int			lockmode;
+
+		/*
+		 * We need not bother about partitioned result relations here, they're
+		 * taken care of in InitPlan.
+		 */
+		foreach(l, stmt->nonleafResultRelations)
+		{
+			if (rti == lfirst_int(l))
+			{
+				is_result_rel = true;
+				break;
+			}
+		}
+
+		/*
+		 * Not a result relation; check if there is a RowMark that requires
+		 * taking a RowShareLock on this rel.
+		 */
+		if (!is_result_rel)
+		{
+			PlanRowMark *rc = NULL;
+
+			foreach(l, stmt->rowMarks)
+			{
+				if (((PlanRowMark *) lfirst(l))->rti == rti)
+				{
+					rc = lfirst(l);
+					break;
+				}
+			}
+
+			if (rc && RowMarkRequiresRowShareLock(rc->markType))
+				lockmode = RowShareLock;
+			else
+				lockmode = AccessShareLock;
+			switch (nodeTag(planstate))
+			{
+				/*
+				 * We need to also hold a pin on the partitioned table's
+				 * relcache entry so that we can rely on its copies of the
+				 * table's partition key and partition descriptor, which
+				 * are used when setting up partition pruning state.
+				 */
+				case T_AppendState:
+					{
+						AppendState *appendstate = (AppendState *) planstate;
+
+						if (appendstate->partitioned_rels)
+							appendstate->partitioned_rels[i] =
+												heap_open(relid, lockmode);
+						else
+							LockRelationOid(relid, lockmode);
+						i++;
+					}
+
+				/* Just lock here; there is no pruning support. */
+				case T_MergeAppendState:
+					LockRelationOid(relid, lockmode);
+					break;
+
+				default:
+					elog(ERROR, "invalid PlanState node: %d",
+						 nodeTag(planstate));
+					break;
+			}
+		}
+	}
+}
+
+/*
  * UpdateChangedParamSet
  *		Add changed parameters to a plan node's chgParam set
  */
@@ -856,61 +974,6 @@ ShutdownExprContext(ExprContext *econtext, bool isCommit)
 }
 
 /*
- * ExecLockNonLeafAppendTables
- *
- * Locks, if necessary, the tables indicated by the RT indexes contained in
- * the partitioned_rels list.  These are the non-leaf tables in the partition
- * tree controlled by a given Append or MergeAppend node.
- */
-void
-ExecLockNonLeafAppendTables(List *partitioned_rels, EState *estate)
-{
-	PlannedStmt *stmt = estate->es_plannedstmt;
-	ListCell   *lc;
-
-	foreach(lc, partitioned_rels)
-	{
-		ListCell   *l;
-		Index		rti = lfirst_int(lc);
-		bool		is_result_rel = false;
-		Oid			relid = getrelid(rti, estate->es_range_table);
-
-		/* If this is a result relation, already locked in InitPlan */
-		foreach(l, stmt->nonleafResultRelations)
-		{
-			if (rti == lfirst_int(l))
-			{
-				is_result_rel = true;
-				break;
-			}
-		}
-
-		/*
-		 * Not a result relation; check if there is a RowMark that requires
-		 * taking a RowShareLock on this rel.
-		 */
-		if (!is_result_rel)
-		{
-			PlanRowMark *rc = NULL;
-
-			foreach(l, stmt->rowMarks)
-			{
-				if (((PlanRowMark *) lfirst(l))->rti == rti)
-				{
-					rc = lfirst(l);
-					break;
-				}
-			}
-
-			if (rc && RowMarkRequiresRowShareLock(rc->markType))
-				LockRelationOid(relid, RowShareLock);
-			else
-				LockRelationOid(relid, AccessShareLock);
-		}
-	}
-}
-
-/*
  *		GetAttributeByName
  *		GetAttributeByNum
  *
diff --git a/src/backend/executor/nodeAppend.c b/src/backend/executor/nodeAppend.c
index 5ce4fb43e1..24604aa311 100644
--- a/src/backend/executor/nodeAppend.c
+++ b/src/backend/executor/nodeAppend.c
@@ -113,18 +113,17 @@ ExecInitAppend(Append *node, EState *estate, int eflags)
 	Assert(!(eflags & EXEC_FLAG_MARK));
 
 	/*
-	 * Lock the non-leaf tables in the partition tree controlled by this node.
-	 * It's a no-op for non-partitioned parent tables.
-	 */
-	ExecLockNonLeafAppendTables(node->partitioned_rels, estate);
-
-	/*
 	 * create new AppendState for our append node
 	 */
 	appendstate->ps.plan = (Plan *) node;
 	appendstate->ps.state = estate;
 	appendstate->ps.ExecProcNode = ExecAppend;
 
+	/* Lock and open (if needed) the partitioned tables. */
+	if (node->partitioned_rels != NIL)
+		ExecOpenAppendPartitionedTables((PlanState *) appendstate, estate,
+										node->partitioned_rels);
+
 	/* Let choose_next_subplan_* function handle setting the first subplan */
 	appendstate->as_whichplan = INVALID_SUBPLAN_INDEX;
 
@@ -137,8 +136,12 @@ ExecInitAppend(Append *node, EState *estate, int eflags)
 		ExecAssignExprContext(estate, &appendstate->ps);
 
 		/* Create the working data structure for pruning. */
+
+		/* ExecLockNonLeafAppendTables must have set this up. */
+		Assert(appendstate->partitioned_rels != NULL);
 		prunestate = ExecCreatePartitionPruneState(&appendstate->ps,
-												   node->part_prune_infos);
+												   node->part_prune_infos,
+												   appendstate->partitioned_rels);
 		appendstate->as_prune_state = prunestate;
 
 		/* Perform an initial partition prune, if required. */
@@ -318,6 +321,7 @@ ExecEndAppend(AppendState *node)
 	PlanState **appendplans;
 	int			nplans;
 	int			i;
+	int			num_partitioned_rels;
 
 	/*
 	 * get information from the node
@@ -326,16 +330,19 @@ ExecEndAppend(AppendState *node)
 	nplans = node->as_nplans;
 
 	/*
+	 * Close partitioned rels that we may have opened for partition
+	 * pruning.
+	 */
+	num_partitioned_rels = node->num_partitioned_rels;
+	Assert(node->partitioned_rels != NULL || num_partitioned_rels == 0);
+	for (i = 0; i < num_partitioned_rels; i++)
+		heap_close(node->partitioned_rels[i], NoLock);
+
+	/*
 	 * shut down each of the subscans
 	 */
 	for (i = 0; i < nplans; i++)
 		ExecEndNode(appendplans[i]);
-
-	/*
-	 * release any resources associated with run-time pruning
-	 */
-	if (node->as_prune_state)
-		ExecDestroyPartitionPruneState(node->as_prune_state);
 }
 
 void
diff --git a/src/backend/executor/nodeMergeAppend.c b/src/backend/executor/nodeMergeAppend.c
index 118f4ef07d..60ce18ea95 100644
--- a/src/backend/executor/nodeMergeAppend.c
+++ b/src/backend/executor/nodeMergeAppend.c
@@ -72,11 +72,10 @@ ExecInitMergeAppend(MergeAppend *node, EState *estate, int eflags)
 	/* check for unsupported flags */
 	Assert(!(eflags & (EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK)));
 
-	/*
-	 * Lock the non-leaf tables in the partition tree controlled by this node.
-	 * It's a no-op for non-partitioned parent tables.
-	 */
-	ExecLockNonLeafAppendTables(node->partitioned_rels, estate);
+	/* Lock and open (if needed) the partitioned tables. */
+	if (node->partitioned_rels != NIL)
+		ExecOpenAppendPartitionedTables((PlanState *) mergestate, estate,
+										node->partitioned_rels);
 
 	/*
 	 * Set up empty vector of subplan states
diff --git a/src/include/executor/execPartition.h b/src/include/executor/execPartition.h
index 862bf65060..33c3f73e78 100644
--- a/src/include/executor/execPartition.h
+++ b/src/include/executor/execPartition.h
@@ -209,8 +209,8 @@ extern HeapTuple ConvertPartitionTupleSlot(TupleConversionMap *map,
 extern void ExecCleanupTupleRouting(ModifyTableState *mtstate,
 						PartitionTupleRouting *proute);
 extern PartitionPruneState *ExecCreatePartitionPruneState(PlanState *planstate,
-							  List *partitionpruneinfo);
-extern void ExecDestroyPartitionPruneState(PartitionPruneState *prunestate);
+							  List *partitionpruneinfo,
+							  Relation *partitioned_rels);
 extern Bitmapset *ExecFindMatchingSubPlans(PartitionPruneState *prunestate);
 extern Bitmapset *ExecFindInitialMatchingSubPlans(PartitionPruneState *prunestate,
 								int nsubplans);
diff --git a/src/include/executor/executor.h b/src/include/executor/executor.h
index f82b51667f..eb6bc9d14f 100644
--- a/src/include/executor/executor.h
+++ b/src/include/executor/executor.h
@@ -524,7 +524,9 @@ extern void UnregisterExprContextCallback(ExprContext *econtext,
 							  ExprContextCallbackFunction function,
 							  Datum arg);
 
-extern void ExecLockNonLeafAppendTables(List *partitioned_rels, EState *estate);
+extern void ExecOpenAppendPartitionedTables(PlanState *planstate,
+								EState *estate,
+								List *partitioned_rels);
 
 extern Datum GetAttributeByName(HeapTupleHeader tuple, const char *attname,
 				   bool *isNull);
diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h
index da7f52cab0..a20d94fd9f 100644
--- a/src/include/nodes/execnodes.h
+++ b/src/include/nodes/execnodes.h
@@ -1092,6 +1092,8 @@ struct AppendState
 										 * the first partial plan */
 	ParallelAppendState *as_pstate; /* parallel coordination info */
 	Size		pstate_len;		/* size of parallel coordination info */
+	Relation   *partitioned_rels;
+	int			num_partitioned_rels;	/* number of entries in above array */
 	struct PartitionPruneState *as_prune_state;
 	Bitmapset  *as_valid_subplans;
 	bool		(*choose_next_subplan) (AppendState *);
-- 
2.11.0

From 0fd93b0b2108d4d12f483b96aab2c25c120173cb Mon Sep 17 00:00:00 2001
From: amit <amitlangote09@gmail.com>
Date: Thu, 14 Jun 2018 14:50:22 +0900
Subject: [PATCH v2] Fix opening/closing of partitioned tables in Append plans

---
 src/backend/executor/execPartition.c   |  49 ++++----------
 src/backend/executor/execUtils.c       | 114 +++++++++++++++++----------------
 src/backend/executor/nodeAppend.c      |  26 ++++----
 src/backend/executor/nodeMergeAppend.c |  11 ++--
 src/include/executor/execPartition.h   |   4 +-
 src/include/executor/executor.h        |   4 +-
 src/include/nodes/execnodes.h          |   4 ++
 7 files changed, 100 insertions(+), 112 deletions(-)

diff --git a/src/backend/executor/execPartition.c b/src/backend/executor/execPartition.c
index 7a4665cc4e..b9bc157bfa 100644
--- a/src/backend/executor/execPartition.c
+++ b/src/backend/executor/execPartition.c
@@ -1399,13 +1399,19 @@ adjust_partition_tlist(List *tlist, TupleConversionMap *map)
  * PartitionPruningData for each item in that List.  This data can be re-used
  * each time we re-evaluate which partitions match the pruning steps provided
  * in each PartitionPruneInfo.
+ *
+ * 'partitioned_rels' is a List of same number of elements as there are in
+ * 'partitionpruneinfo' containing the Relation pointers of corresponding
+ * partitioned tables.
  */
 PartitionPruneState *
-ExecCreatePartitionPruneState(PlanState *planstate, List *partitionpruneinfo)
+ExecCreatePartitionPruneState(PlanState *planstate, List *partitionpruneinfo,
+							  List *partitioned_rels)
 {
 	PartitionPruneState *prunestate;
 	PartitionPruningData *prunedata;
-	ListCell   *lc;
+	ListCell   *lc1,
+			   *lc2;
 	int			i;
 
 	Assert(partitionpruneinfo != NIL);
@@ -1435,9 +1441,10 @@ ExecCreatePartitionPruneState(PlanState *planstate, List *partitionpruneinfo)
 							  ALLOCSET_DEFAULT_SIZES);
 
 	i = 0;
-	foreach(lc, partitionpruneinfo)
+	forboth(lc1, partitionpruneinfo, lc2, partitioned_rels)
 	{
-		PartitionPruneInfo *pinfo = castNode(PartitionPruneInfo, lfirst(lc));
+		PartitionPruneInfo *pinfo = castNode(PartitionPruneInfo, lfirst(lc1));
+		Relation	rel = lfirst(lc2);
 		PartitionPruningData *pprune = &prunedata[i];
 		PartitionPruneContext *context = &pprune->context;
 		PartitionDesc partdesc;
@@ -1460,17 +1467,9 @@ ExecCreatePartitionPruneState(PlanState *planstate, List *partitionpruneinfo)
 		/* present_parts is also subject to later modification */
 		pprune->present_parts = bms_copy(pinfo->present_parts);
 
-		/*
-		 * We need to hold a pin on the partitioned table's relcache entry so
-		 * that we can rely on its copies of the table's partition key and
-		 * partition descriptor.  We need not get a lock though; one should
-		 * have been acquired already by InitPlan or
-		 * ExecLockNonLeafAppendTables.
-		 */
-		context->partrel = relation_open(pinfo->reloid, NoLock);
-
-		partkey = RelationGetPartitionKey(context->partrel);
-		partdesc = RelationGetPartitionDesc(context->partrel);
+		Assert(RelationGetRelid(rel) == pinfo->reloid);
+		partkey = RelationGetPartitionKey(rel);
+		partdesc = RelationGetPartitionDesc(rel);
 		n_steps = list_length(pinfo->pruning_steps);
 
 		context->strategy = partkey->strategy;
@@ -1546,26 +1545,6 @@ ExecCreatePartitionPruneState(PlanState *planstate, List *partitionpruneinfo)
 }
 
 /*
- * ExecDestroyPartitionPruneState
- *		Release resources at plan shutdown.
- *
- * We don't bother to free any memory here, since the whole executor context
- * will be going away shortly.  We do need to release our relcache pins.
- */
-void
-ExecDestroyPartitionPruneState(PartitionPruneState *prunestate)
-{
-	int			i;
-
-	for (i = 0; i < prunestate->num_partprunedata; i++)
-	{
-		PartitionPruningData *pprune = &prunestate->partprunedata[i];
-
-		relation_close(pprune->context.partrel, NoLock);
-	}
-}
-
-/*
  * ExecFindInitialMatchingSubPlans
  *		Identify the set of subplans that cannot be eliminated by initial
  *		pruning (disregarding any pruning constraints involving PARAM_EXEC
diff --git a/src/backend/executor/execUtils.c b/src/backend/executor/execUtils.c
index b963cae730..f936f8c3da 100644
--- a/src/backend/executor/execUtils.c
+++ b/src/backend/executor/execUtils.c
@@ -704,6 +704,65 @@ ExecCloseScanRelation(Relation scanrel)
 }
 
 /*
+ * ExecOpenAppendPartitionedTables
+ *
+ * Opens and/or locks, if necessary, the tables indicated by the RT indexes
+ * contained in the partitioned_rels list of a given Append or MergeAppend
+ * node.  These are the non-leaf tables in the partition tree controlled by
+ * the node.
+ */
+List *
+ExecOpenAppendPartitionedTables(List *partitioned_rels, EState *estate)
+{
+	PlannedStmt *stmt = estate->es_plannedstmt;
+	ListCell   *lc;
+	List	   *result = NIL;
+
+	Assert(partitioned_rels != NIL);
+
+	foreach(lc, partitioned_rels)
+	{
+		ListCell   *l;
+		Index		rti = lfirst_int(lc);
+		Oid			relid = getrelid(rti, estate->es_range_table);
+		int			lockmode = AccessShareLock;
+		PlanRowMark *rc = NULL;
+
+		/* Check if there is a RowMark that requires taking a RowShareLock. */
+
+		foreach(l, stmt->rowMarks)
+		{
+			if (((PlanRowMark *) lfirst(l))->rti == rti)
+			{
+				rc = lfirst(l);
+				break;
+			}
+		}
+
+		if (rc && RowMarkRequiresRowShareLock(rc->markType))
+			lockmode = RowShareLock;
+
+		result = lappend(result, heap_open(relid, lockmode));
+	}
+
+	return result;
+}
+
+/* Close each Relation in the input list. */
+void
+ExecCloseAppendPartitionedTables(List *partitioned_rels)
+{
+	ListCell *lc;
+
+	/*
+	 * Close partitioned rels that we may have opened for partition
+	 * pruning.
+	 */
+	foreach(lc, partitioned_rels)
+		heap_close(lfirst(lc), NoLock);
+}
+
+/*
  * UpdateChangedParamSet
  *		Add changed parameters to a plan node's chgParam set
  */
@@ -856,61 +915,6 @@ ShutdownExprContext(ExprContext *econtext, bool isCommit)
 }
 
 /*
- * ExecLockNonLeafAppendTables
- *
- * Locks, if necessary, the tables indicated by the RT indexes contained in
- * the partitioned_rels list.  These are the non-leaf tables in the partition
- * tree controlled by a given Append or MergeAppend node.
- */
-void
-ExecLockNonLeafAppendTables(List *partitioned_rels, EState *estate)
-{
-	PlannedStmt *stmt = estate->es_plannedstmt;
-	ListCell   *lc;
-
-	foreach(lc, partitioned_rels)
-	{
-		ListCell   *l;
-		Index		rti = lfirst_int(lc);
-		bool		is_result_rel = false;
-		Oid			relid = getrelid(rti, estate->es_range_table);
-
-		/* If this is a result relation, already locked in InitPlan */
-		foreach(l, stmt->nonleafResultRelations)
-		{
-			if (rti == lfirst_int(l))
-			{
-				is_result_rel = true;
-				break;
-			}
-		}
-
-		/*
-		 * Not a result relation; check if there is a RowMark that requires
-		 * taking a RowShareLock on this rel.
-		 */
-		if (!is_result_rel)
-		{
-			PlanRowMark *rc = NULL;
-
-			foreach(l, stmt->rowMarks)
-			{
-				if (((PlanRowMark *) lfirst(l))->rti == rti)
-				{
-					rc = lfirst(l);
-					break;
-				}
-			}
-
-			if (rc && RowMarkRequiresRowShareLock(rc->markType))
-				LockRelationOid(relid, RowShareLock);
-			else
-				LockRelationOid(relid, AccessShareLock);
-		}
-	}
-}
-
-/*
  *		GetAttributeByName
  *		GetAttributeByNum
  *
diff --git a/src/backend/executor/nodeAppend.c b/src/backend/executor/nodeAppend.c
index 5ce4fb43e1..77285af194 100644
--- a/src/backend/executor/nodeAppend.c
+++ b/src/backend/executor/nodeAppend.c
@@ -113,18 +113,17 @@ ExecInitAppend(Append *node, EState *estate, int eflags)
 	Assert(!(eflags & EXEC_FLAG_MARK));
 
 	/*
-	 * Lock the non-leaf tables in the partition tree controlled by this node.
-	 * It's a no-op for non-partitioned parent tables.
-	 */
-	ExecLockNonLeafAppendTables(node->partitioned_rels, estate);
-
-	/*
 	 * create new AppendState for our append node
 	 */
 	appendstate->ps.plan = (Plan *) node;
 	appendstate->ps.state = estate;
 	appendstate->ps.ExecProcNode = ExecAppend;
 
+	/* Lock and open (if needed) the partitioned tables. */
+	if (node->partitioned_rels != NIL)
+		appendstate->as_partitioned_rels =
+			ExecOpenAppendPartitionedTables(node->partitioned_rels, estate);
+
 	/* Let choose_next_subplan_* function handle setting the first subplan */
 	appendstate->as_whichplan = INVALID_SUBPLAN_INDEX;
 
@@ -137,8 +136,11 @@ ExecInitAppend(Append *node, EState *estate, int eflags)
 		ExecAssignExprContext(estate, &appendstate->ps);
 
 		/* Create the working data structure for pruning. */
-		prunestate = ExecCreatePartitionPruneState(&appendstate->ps,
-												   node->part_prune_infos);
+
+		prunestate =
+				ExecCreatePartitionPruneState(&appendstate->ps,
+											  node->part_prune_infos,
+											  appendstate->as_partitioned_rels);
 		appendstate->as_prune_state = prunestate;
 
 		/* Perform an initial partition prune, if required. */
@@ -325,17 +327,13 @@ ExecEndAppend(AppendState *node)
 	appendplans = node->appendplans;
 	nplans = node->as_nplans;
 
+	ExecCloseAppendPartitionedTables(node->as_partitioned_rels);
+
 	/*
 	 * shut down each of the subscans
 	 */
 	for (i = 0; i < nplans; i++)
 		ExecEndNode(appendplans[i]);
-
-	/*
-	 * release any resources associated with run-time pruning
-	 */
-	if (node->as_prune_state)
-		ExecDestroyPartitionPruneState(node->as_prune_state);
 }
 
 void
diff --git a/src/backend/executor/nodeMergeAppend.c b/src/backend/executor/nodeMergeAppend.c
index 118f4ef07d..8de956b129 100644
--- a/src/backend/executor/nodeMergeAppend.c
+++ b/src/backend/executor/nodeMergeAppend.c
@@ -72,11 +72,10 @@ ExecInitMergeAppend(MergeAppend *node, EState *estate, int eflags)
 	/* check for unsupported flags */
 	Assert(!(eflags & (EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK)));
 
-	/*
-	 * Lock the non-leaf tables in the partition tree controlled by this node.
-	 * It's a no-op for non-partitioned parent tables.
-	 */
-	ExecLockNonLeafAppendTables(node->partitioned_rels, estate);
+	/* Lock and open (if needed) the partitioned tables. */
+	if (node->partitioned_rels != NIL)
+		mergestate->ms_partitioned_rels =
+			ExecOpenAppendPartitionedTables(node->partitioned_rels, estate);
 
 	/*
 	 * Set up empty vector of subplan states
@@ -283,6 +282,8 @@ ExecEndMergeAppend(MergeAppendState *node)
 	mergeplans = node->mergeplans;
 	nplans = node->ms_nplans;
 
+	ExecCloseAppendPartitionedTables(node->ms_partitioned_rels);
+
 	/*
 	 * shut down each of the subscans
 	 */
diff --git a/src/include/executor/execPartition.h b/src/include/executor/execPartition.h
index 862bf65060..7b0744a2c9 100644
--- a/src/include/executor/execPartition.h
+++ b/src/include/executor/execPartition.h
@@ -209,8 +209,8 @@ extern HeapTuple ConvertPartitionTupleSlot(TupleConversionMap *map,
 extern void ExecCleanupTupleRouting(ModifyTableState *mtstate,
 						PartitionTupleRouting *proute);
 extern PartitionPruneState *ExecCreatePartitionPruneState(PlanState *planstate,
-							  List *partitionpruneinfo);
-extern void ExecDestroyPartitionPruneState(PartitionPruneState *prunestate);
+							  List *partitionpruneinfo,
+							  List *partitioned_rels);
 extern Bitmapset *ExecFindMatchingSubPlans(PartitionPruneState *prunestate);
 extern Bitmapset *ExecFindInitialMatchingSubPlans(PartitionPruneState *prunestate,
 								int nsubplans);
diff --git a/src/include/executor/executor.h b/src/include/executor/executor.h
index f82b51667f..301e4b4059 100644
--- a/src/include/executor/executor.h
+++ b/src/include/executor/executor.h
@@ -524,7 +524,9 @@ extern void UnregisterExprContextCallback(ExprContext *econtext,
 							  ExprContextCallbackFunction function,
 							  Datum arg);
 
-extern void ExecLockNonLeafAppendTables(List *partitioned_rels, EState *estate);
+extern List *ExecOpenAppendPartitionedTables(List *partitioned_rels,
+								EState *estate);
+extern void ExecCloseAppendPartitionedTables(List *partitioned_rels);
 
 extern Datum GetAttributeByName(HeapTupleHeader tuple, const char *attname,
 				   bool *isNull);
diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h
index da7f52cab0..55996b80d3 100644
--- a/src/include/nodes/execnodes.h
+++ b/src/include/nodes/execnodes.h
@@ -1073,6 +1073,7 @@ typedef struct ModifyTableState
  *							eliminated from the scan, or NULL if not possible.
  *		valid_subplans		for runtime pruning, valid appendplans indexes to
  *							scan.
+ *		partitioned_rels	Relation pointers of partitioned tables
  * ----------------
  */
 
@@ -1095,6 +1096,7 @@ struct AppendState
 	struct PartitionPruneState *as_prune_state;
 	Bitmapset  *as_valid_subplans;
 	bool		(*choose_next_subplan) (AppendState *);
+	List	   *as_partitioned_rels;	/* List of Relation pointers */
 };
 
 /* ----------------
@@ -1106,6 +1108,7 @@ struct AppendState
  *		slots			current output tuple of each subplan
  *		heap			heap of active tuples
  *		initialized		true if we have fetched first tuple from each subplan
+ *		partitioned_rels	Relation pointers of partitioned tables
  * ----------------
  */
 typedef struct MergeAppendState
@@ -1118,6 +1121,7 @@ typedef struct MergeAppendState
 	TupleTableSlot **ms_slots;	/* array of length ms_nplans */
 	struct binaryheap *ms_heap; /* binary heap of slot indices */
 	bool		ms_initialized; /* are subplans started? */
+	List	   *ms_partitioned_rels;	/* List of Relation pointers */
 } MergeAppendState;
 
 /* ----------------
-- 
2.11.0

diff --git a/src/backend/executor/execMain.c b/src/backend/executor/execMain.c
index 8026fe2..58c62f3 100644
--- a/src/backend/executor/execMain.c
+++ b/src/backend/executor/execMain.c
@@ -817,6 +817,7 @@ InitPlan(QueryDesc *queryDesc, int eflags)
 	TupleDesc	tupType;
 	ListCell   *l;
 	int			i;
+	bool		gotlock;
 
 	/*
 	 * Do permissions checks
@@ -852,7 +853,9 @@ InitPlan(QueryDesc *queryDesc, int eflags)
 			Relation	resultRelation;
 
 			resultRelationOid = getrelid(resultRelationIndex, rangeTable);
-			resultRelation = heap_open(resultRelationOid, RowExclusiveLock);
+			gotlock = LockRelationOid(resultRelationOid, RowExclusiveLock);
+			Assert(!gotlock || IsParallelWorker());
+			resultRelation = heap_open(resultRelationOid, NoLock);
 
 			InitResultRelInfo(resultRelInfo,
 							  resultRelation,
@@ -892,7 +895,9 @@ InitPlan(QueryDesc *queryDesc, int eflags)
 				Relation	resultRelDesc;
 
 				resultRelOid = getrelid(resultRelIndex, rangeTable);
-				resultRelDesc = heap_open(resultRelOid, RowExclusiveLock);
+				gotlock = LockRelationOid(resultRelOid, RowExclusiveLock);
+				Assert(!gotlock || IsParallelWorker());
+				resultRelDesc = heap_open(resultRelOid, NoLock);
 				InitResultRelInfo(resultRelInfo,
 								  resultRelDesc,
 								  lfirst_int(l),
@@ -912,8 +917,11 @@ InitPlan(QueryDesc *queryDesc, int eflags)
 				/* We locked the roots above. */
 				if (!list_member_int(plannedstmt->rootResultRelations,
 									 resultRelIndex))
-					LockRelationOid(getrelid(resultRelIndex, rangeTable),
-									RowExclusiveLock);
+				{
+					gotlock = LockRelationOid(getrelid(resultRelIndex, rangeTable),
+											  RowExclusiveLock);
+					Assert(!gotlock || IsParallelWorker());
+				}
 			}
 		}
 	}
@@ -963,10 +971,14 @@ InitPlan(QueryDesc *queryDesc, int eflags)
 			case ROW_MARK_NOKEYEXCLUSIVE:
 			case ROW_MARK_SHARE:
 			case ROW_MARK_KEYSHARE:
-				relation = heap_open(relid, RowShareLock);
+				gotlock = LockRelationOid(relid, RowShareLock);
+				Assert(!gotlock || IsParallelWorker());
+				relation = heap_open(relid, NoLock);
 				break;
 			case ROW_MARK_REFERENCE:
-				relation = heap_open(relid, AccessShareLock);
+				gotlock = LockRelationOid(relid, AccessShareLock);
+				Assert(!gotlock || IsParallelWorker());
+				relation = heap_open(relid, NoLock);
 				break;
 			case ROW_MARK_COPY:
 				/* no physical table access is required */
diff --git a/src/backend/executor/execUtils.c b/src/backend/executor/execUtils.c
index b963cae..cf08b50 100644
--- a/src/backend/executor/execUtils.c
+++ b/src/backend/executor/execUtils.c
@@ -42,6 +42,7 @@
 
 #include "postgres.h"
 
+#include "access/parallel.h"
 #include "access/relscan.h"
 #include "access/transam.h"
 #include "executor/executor.h"
@@ -645,6 +646,7 @@ ExecOpenScanRelation(EState *estate, Index scanrelid, int eflags)
 	Relation	rel;
 	Oid			reloid;
 	LOCKMODE	lockmode;
+	bool		gotlock;
 
 	/*
 	 * Determine the lock type we need.  First, scan to see if target relation
@@ -659,13 +661,19 @@ ExecOpenScanRelation(EState *estate, Index scanrelid, int eflags)
 		/* Keep this check in sync with InitPlan! */
 		ExecRowMark *erm = ExecFindRowMark(estate, scanrelid, true);
 
-		if (erm != NULL && erm->relation != NULL)
+		/* HACK: assume things are OK for ROW_MARK_COPY case */
+		if (erm != NULL)
 			lockmode = NoLock;
 	}
 
 	/* Open the relation and acquire lock as needed */
 	reloid = getrelid(scanrelid, estate->es_range_table);
-	rel = heap_open(reloid, lockmode);
+	if (lockmode != NoLock)
+	{
+		gotlock = LockRelationOid(reloid, lockmode);
+		Assert(!gotlock || IsParallelWorker());
+	}
+	rel = heap_open(reloid, NoLock);
 
 	/*
 	 * Complain if we're attempting a scan of an unscannable relation, except
@@ -874,6 +882,7 @@ ExecLockNonLeafAppendTables(List *partitioned_rels, EState *estate)
 		Index		rti = lfirst_int(lc);
 		bool		is_result_rel = false;
 		Oid			relid = getrelid(rti, estate->es_range_table);
+		bool		gotlock;
 
 		/* If this is a result relation, already locked in InitPlan */
 		foreach(l, stmt->nonleafResultRelations)
@@ -903,9 +912,10 @@ ExecLockNonLeafAppendTables(List *partitioned_rels, EState *estate)
 			}
 
 			if (rc && RowMarkRequiresRowShareLock(rc->markType))
-				LockRelationOid(relid, RowShareLock);
+				gotlock = LockRelationOid(relid, RowShareLock);
 			else
-				LockRelationOid(relid, AccessShareLock);
+				gotlock = LockRelationOid(relid, AccessShareLock);
+			Assert(!gotlock || IsParallelWorker());
 		}
 	}
 }
diff --git a/src/backend/storage/lmgr/lmgr.c b/src/backend/storage/lmgr/lmgr.c
index 7b2dcb6..a1ebf64 100644
--- a/src/backend/storage/lmgr/lmgr.c
+++ b/src/backend/storage/lmgr/lmgr.c
@@ -100,8 +100,9 @@ SetLocktagRelationOid(LOCKTAG *tag, Oid relid)
  *
  * Lock a relation given only its OID.  This should generally be used
  * before attempting to open the relation's relcache entry.
+ * Return TRUE if we acquired a new lock, FALSE if already held.
  */
-void
+bool
 LockRelationOid(Oid relid, LOCKMODE lockmode)
 {
 	LOCKTAG		tag;
@@ -122,7 +123,11 @@ LockRelationOid(Oid relid, LOCKMODE lockmode)
 	 * CommandCounterIncrement, not here.)
 	 */
 	if (res != LOCKACQUIRE_ALREADY_HELD)
+	{
 		AcceptInvalidationMessages();
+		return true;
+	}
+	return false;
 }
 
 /*
diff --git a/src/include/storage/lmgr.h b/src/include/storage/lmgr.h
index a217de9..69e6f7f 100644
--- a/src/include/storage/lmgr.h
+++ b/src/include/storage/lmgr.h
@@ -37,7 +37,7 @@ typedef enum XLTW_Oper
 extern void RelationInitLockInfo(Relation relation);
 
 /* Lock a relation */
-extern void LockRelationOid(Oid relid, LOCKMODE lockmode);
+extern bool LockRelationOid(Oid relid, LOCKMODE lockmode);
 extern bool ConditionalLockRelationOid(Oid relid, LOCKMODE lockmode);
 extern void UnlockRelationId(LockRelId *relid, LOCKMODE lockmode);
 extern void UnlockRelationOid(Oid relid, LOCKMODE lockmode);