replace-casetestexpr-with-expressionparams-2.patch

*** a/src/backend/executor/execQual.c
--- b/src/backend/executor/execQual.c
***************
*** 61,67 ****
  static Datum ExecEvalArrayRef(ArrayRefExprState *astate,
  				 ExprContext *econtext,
  				 bool *isNull, ExprDoneCond *isDone);
- static bool isAssignmentIndirectionExpr(ExprState *exprstate);
  static Datum ExecEvalAggref(AggrefExprState *aggref,
  			   ExprContext *econtext,
  			   bool *isNull, ExprDoneCond *isDone);
--- 61,66 ----
***************
*** 82,87 **** static Datum ExecEvalParamExec(ExprState *exprstate, ExprContext *econtext,
--- 81,88 ----
  				  bool *isNull, ExprDoneCond *isDone);
  static Datum ExecEvalParamExtern(ExprState *exprstate, ExprContext *econtext,
  					bool *isNull, ExprDoneCond *isDone);
+ static Datum ExecEvalExpressionParam(ExprState *exprstate, ExprContext *econtext,
+ 				  bool *isNull, ExprDoneCond *isDone);
  static void init_fcache(Oid foid, Oid input_collation, FuncExprState *fcache,
  			MemoryContext fcacheCxt, bool needDescForSets);
  static void ShutdownFuncExpr(Datum arg);
***************
*** 122,130 **** static Datum ExecEvalConvertRowtype(ConvertRowtypeExprState *cstate,
  					   bool *isNull, ExprDoneCond *isDone);
  static Datum ExecEvalCase(CaseExprState *caseExpr, ExprContext *econtext,
  			 bool *isNull, ExprDoneCond *isDone);
- static Datum ExecEvalCaseTestExpr(ExprState *exprstate,
- 					 ExprContext *econtext,
- 					 bool *isNull, ExprDoneCond *isDone);
  static Datum ExecEvalArray(ArrayExprState *astate,
  			  ExprContext *econtext,
  			  bool *isNull, ExprDoneCond *isDone);
--- 123,128 ----
***************
*** 352,394 **** ExecEvalArrayRef(ArrayRefExprState *astate,
  	if (isAssignment)
  	{
  		Datum		sourceData;
! 		Datum		save_datum;
! 		bool		save_isNull;
  
  		/*
  		 * We might have a nested-assignment situation, in which the
  		 * refassgnexpr is itself a FieldStore or ArrayRef that needs to
  		 * obtain and modify the previous value of the array element or slice
  		 * being replaced.	If so, we have to extract that value from the
! 		 * array and pass it down via the econtext's caseValue.  It's safe to
! 		 * reuse the CASE mechanism because there cannot be a CASE between
! 		 * here and where the value would be needed, and an array assignment
! 		 * can't be within a CASE either.  (So saving and restoring the
! 		 * caseValue is just paranoia, but let's do it anyway.)
! 		 *
! 		 * Since fetching the old element might be a nontrivial expense, do it
! 		 * only if the argument appears to actually need it.
  		 */
! 		save_datum = econtext->caseValue_datum;
! 		save_isNull = econtext->caseValue_isNull;
! 
! 		if (isAssignmentIndirectionExpr(astate->refassgnexpr))
  		{
  			if (*isNull)
  			{
  				/* whole array is null, so any element or slice is too */
! 				econtext->caseValue_datum = (Datum) 0;
! 				econtext->caseValue_isNull = true;
  			}
  			else if (lIndex == NULL)
  			{
! 				econtext->caseValue_datum = array_ref(array_source, i,
! 													  upper.indx,
! 													  astate->refattrlength,
! 													  astate->refelemlength,
! 													  astate->refelembyval,
! 													  astate->refelemalign,
! 												&econtext->caseValue_isNull);
  			}
  			else
  			{
--- 350,382 ----
  	if (isAssignment)
  	{
  		Datum		sourceData;
! 		ParamExecData prm;
  
  		/*
  		 * We might have a nested-assignment situation, in which the
  		 * refassgnexpr is itself a FieldStore or ArrayRef that needs to
  		 * obtain and modify the previous value of the array element or slice
  		 * being replaced.	If so, we have to extract that value from the
! 		 * array and pass it down via an expression param.
  		 */
! 		if (arrayRef->refuseparam)
  		{
+ 			prm.execPlan = NULL; /* not used */
  			if (*isNull)
  			{
  				/* whole array is null, so any element or slice is too */
! 				prm.value = (Datum) 0;
! 				prm.isnull = true;
  			}
  			else if (lIndex == NULL)
  			{
! 				prm.value = array_ref(array_source, i,
! 									  upper.indx,
! 									  astate->refattrlength,
! 									  astate->refelemlength,
! 									  astate->refelembyval,
! 									  astate->refelemalign,
! 									  &prm.isnull);
  			}
  			else
  			{
***************
*** 398,412 **** ExecEvalArrayRef(ArrayRefExprState *astate,
  											  astate->refelemlength,
  											  astate->refelembyval,
  											  astate->refelemalign);
! 				econtext->caseValue_datum = PointerGetDatum(resultArray);
! 				econtext->caseValue_isNull = false;
  			}
! 		}
! 		else
! 		{
! 			/* argument shouldn't need caseValue, but for safety set it null */
! 			econtext->caseValue_datum = (Datum) 0;
! 			econtext->caseValue_isNull = true;
  		}
  
  		/*
--- 386,395 ----
  											  astate->refelemlength,
  											  astate->refelembyval,
  											  astate->refelemalign);
! 				prm.value = PointerGetDatum(resultArray);
! 				prm.isnull = false;
  			}
! 			econtext->expr_params = lcons(&prm, econtext->expr_params);
  		}
  
  		/*
***************
*** 417,424 **** ExecEvalArrayRef(ArrayRefExprState *astate,
  								  &eisnull,
  								  NULL);
  
! 		econtext->caseValue_datum = save_datum;
! 		econtext->caseValue_isNull = save_isNull;
  
  		/*
  		 * For an assignment to a fixed-length array type, both the original
--- 400,408 ----
  								  &eisnull,
  								  NULL);
  
! 		/* pop the expression param stack if we pushed */
! 		if (arrayRef->refuseparam)
! 			econtext->expr_params = list_delete_first(econtext->expr_params);
  
  		/*
  		 * For an assignment to a fixed-length array type, both the original
***************
*** 481,515 **** ExecEvalArrayRef(ArrayRefExprState *astate,
  	}
  }
  
- /*
-  * Helper for ExecEvalArrayRef: is expr a nested FieldStore or ArrayRef
-  * that might need the old element value passed down?
-  *
-  * (We could use this in ExecEvalFieldStore too, but in that case passing
-  * the old value is so cheap there's no need.)
-  */
- static bool
- isAssignmentIndirectionExpr(ExprState *exprstate)
- {
- 	if (exprstate == NULL)
- 		return false;			/* just paranoia */
- 	if (IsA(exprstate, FieldStoreState))
- 	{
- 		FieldStore *fstore = (FieldStore *) exprstate->expr;
- 
- 		if (fstore->arg && IsA(fstore->arg, CaseTestExpr))
- 			return true;
- 	}
- 	else if (IsA(exprstate, ArrayRefExprState))
- 	{
- 		ArrayRef   *arrayRef = (ArrayRef *) exprstate->expr;
- 
- 		if (arrayRef->refexpr && IsA(arrayRef->refexpr, CaseTestExpr))
- 			return true;
- 	}
- 	return false;
- }
- 
  /* ----------------------------------------------------------------
   *		ExecEvalAggref
   *
--- 465,470 ----
***************
*** 1046,1051 **** ExecEvalParamExtern(ExprState *exprstate, ExprContext *econtext,
--- 1001,1032 ----
  	return (Datum) 0;			/* keep compiler quiet */
  }
  
+ /* ----------------------------------------------------------------
+  *		ExecEvalExpressionParam
+  *
+  *		Returns the value of an expression parameter.
+  * ----------------------------------------------------------------
+  */
+ static Datum
+ ExecEvalExpressionParam(ExprState *exprstate, ExprContext *econtext,
+ 						bool *isNull, ExprDoneCond *isDone)
+ {
+ 	ExpressionParam *eparam = (ExpressionParam *) exprstate->expr;
+ 	ParamExecData *prm;
+ 
+ 	if (isDone)
+ 		*isDone = ExprSingleResult;
+ 
+ 	/* Expression params are stored in a stack, in econtext->expr_params */
+ 	if (eparam->levelsup >= list_length(econtext->expr_params))
+ 		elog(ERROR, "invalid expression parameter reference (%d levels up, while stack is only %d elements deep)",
+ 			 eparam->levelsup, list_length(econtext->expr_params));
+ 	prm = list_nth(econtext->expr_params, eparam->levelsup);
+ 
+ 	*isNull = prm->isnull;
+ 	return prm->value;
+ }
+ 
  
  /* ----------------------------------------------------------------
   *		ExecEvalOper / ExecEvalFunc support routines
***************
*** 2769,2795 **** ExecEvalCase(CaseExprState *caseExpr, ExprContext *econtext,
  {
  	List	   *clauses = caseExpr->args;
  	ListCell   *clause;
! 	Datum		save_datum;
! 	bool		save_isNull;
  
  	if (isDone)
  		*isDone = ExprSingleResult;
  
  	/*
  	 * If there's a test expression, we have to evaluate it and save the value
! 	 * where the CaseTestExpr placeholders can find it. We must save and
! 	 * restore prior setting of econtext's caseValue fields, in case this node
! 	 * is itself within a larger CASE.
  	 */
- 	save_datum = econtext->caseValue_datum;
- 	save_isNull = econtext->caseValue_isNull;
- 
  	if (caseExpr->arg)
  	{
! 		econtext->caseValue_datum = ExecEvalExpr(caseExpr->arg,
! 												 econtext,
! 												 &econtext->caseValue_isNull,
! 												 NULL);
  	}
  
  	/*
--- 2750,2772 ----
  {
  	List	   *clauses = caseExpr->args;
  	ListCell   *clause;
! 	ParamExecData prm;
  
  	if (isDone)
  		*isDone = ExprSingleResult;
  
  	/*
  	 * If there's a test expression, we have to evaluate it and save the value
! 	 * in the right Param slot.
  	 */
  	if (caseExpr->arg)
  	{
! 		prm.execPlan = NULL; /* not used */
! 		prm.value = ExecEvalExpr(caseExpr->arg,
! 								 econtext,
! 								 &prm.isnull,
! 								 NULL);
! 		econtext->expr_params = lcons(&prm, econtext->expr_params);
  	}
  
  	/*
***************
*** 2814,2821 **** ExecEvalCase(CaseExprState *caseExpr, ExprContext *econtext,
  		 */
  		if (DatumGetBool(clause_value) && !*isNull)
  		{
! 			econtext->caseValue_datum = save_datum;
! 			econtext->caseValue_isNull = save_isNull;
  			return ExecEvalExpr(wclause->result,
  								econtext,
  								isNull,
--- 2791,2798 ----
  		 */
  		if (DatumGetBool(clause_value) && !*isNull)
  		{
! 			if (caseExpr->arg)
! 				econtext->expr_params = list_delete_first(econtext->expr_params);
  			return ExecEvalExpr(wclause->result,
  								econtext,
  								isNull,
***************
*** 2823,2830 **** ExecEvalCase(CaseExprState *caseExpr, ExprContext *econtext,
  		}
  	}
  
! 	econtext->caseValue_datum = save_datum;
! 	econtext->caseValue_isNull = save_isNull;
  
  	if (caseExpr->defresult)
  	{
--- 2800,2808 ----
  		}
  	}
  
! 	/* pop the expression param stack if we pushed a value */
! 	if (caseExpr->arg)
! 		econtext->expr_params = list_delete_first(econtext->expr_params);
  
  	if (caseExpr->defresult)
  	{
***************
*** 2838,2859 **** ExecEvalCase(CaseExprState *caseExpr, ExprContext *econtext,
  	return (Datum) 0;
  }
  
- /*
-  * ExecEvalCaseTestExpr
-  *
-  * Return the value stored by CASE.
-  */
- static Datum
- ExecEvalCaseTestExpr(ExprState *exprstate,
- 					 ExprContext *econtext,
- 					 bool *isNull, ExprDoneCond *isDone)
- {
- 	if (isDone)
- 		*isDone = ExprSingleResult;
- 	*isNull = econtext->caseValue_isNull;
- 	return econtext->caseValue_datum;
- }
- 
  /* ----------------------------------------------------------------
   *		ExecEvalArray - ARRAY[] expressions
   * ----------------------------------------------------------------
--- 2816,2821 ----
***************
*** 3936,3945 **** ExecEvalFieldStore(FieldStoreState *fstate,
  	TupleDesc	tupDesc;
  	Datum	   *values;
  	bool	   *isnull;
- 	Datum		save_datum;
- 	bool		save_isNull;
  	ListCell   *l1,
  			   *l2;
  
  	tupDatum = ExecEvalExpr(fstate->arg, econtext, isNull, isDone);
  
--- 3898,3906 ----
  	TupleDesc	tupDesc;
  	Datum	   *values;
  	bool	   *isnull;
  	ListCell   *l1,
  			   *l2;
+ 	ParamExecData prm;
  
  	tupDatum = ExecEvalExpr(fstate->arg, econtext, isNull, isDone);
  
***************
*** 3980,3987 **** ExecEvalFieldStore(FieldStoreState *fstate,
  	/* Result is never null */
  	*isNull = false;
  
! 	save_datum = econtext->caseValue_datum;
! 	save_isNull = econtext->caseValue_isNull;
  
  	forboth(l1, fstate->newvals, l2, fstore->fieldnums)
  	{
--- 3941,3947 ----
  	/* Result is never null */
  	*isNull = false;
  
! 	econtext->expr_params = lcons(&prm, econtext->expr_params);
  
  	forboth(l1, fstate->newvals, l2, fstore->fieldnums)
  	{
***************
*** 3991,4006 **** ExecEvalFieldStore(FieldStoreState *fstate,
  		Assert(fieldnum > 0 && fieldnum <= tupDesc->natts);
  
  		/*
! 		 * Use the CaseTestExpr mechanism to pass down the old value of the
  		 * field being replaced; this is needed in case the newval is itself a
  		 * FieldStore or ArrayRef that has to obtain and modify the old value.
- 		 * It's safe to reuse the CASE mechanism because there cannot be a
- 		 * CASE between here and where the value would be needed, and a field
- 		 * assignment can't be within a CASE either.  (So saving and restoring
- 		 * the caseValue is just paranoia, but let's do it anyway.)
  		 */
! 		econtext->caseValue_datum = values[fieldnum - 1];
! 		econtext->caseValue_isNull = isnull[fieldnum - 1];
  
  		values[fieldnum - 1] = ExecEvalExpr(newval,
  											econtext,
--- 3951,3963 ----
  		Assert(fieldnum > 0 && fieldnum <= tupDesc->natts);
  
  		/*
! 		 * Use an exec Param to pass down the old value of the
  		 * field being replaced; this is needed in case the newval is itself a
  		 * FieldStore or ArrayRef that has to obtain and modify the old value.
  		 */
! 		prm.execPlan = NULL; /* not used */
! 		prm.value = values[fieldnum - 1];
! 		prm.isnull = isnull[fieldnum - 1];
  
  		values[fieldnum - 1] = ExecEvalExpr(newval,
  											econtext,
***************
*** 4008,4015 **** ExecEvalFieldStore(FieldStoreState *fstate,
  											NULL);
  	}
  
! 	econtext->caseValue_datum = save_datum;
! 	econtext->caseValue_isNull = save_isNull;
  
  	tuple = heap_form_tuple(tupDesc, values, isnull);
  
--- 3965,3971 ----
  											NULL);
  	}
  
! 	econtext->expr_params = list_delete_first(econtext->expr_params);
  
  	tuple = heap_form_tuple(tupDesc, values, isnull);
  
***************
*** 4251,4263 **** ExecInitExpr(Expr *node, PlanState *parent)
  					break;
  			}
  			break;
! 		case T_CoerceToDomainValue:
  			state = (ExprState *) makeNode(ExprState);
! 			state->evalfunc = ExecEvalCoerceToDomainValue;
  			break;
! 		case T_CaseTestExpr:
  			state = (ExprState *) makeNode(ExprState);
! 			state->evalfunc = ExecEvalCaseTestExpr;
  			break;
  		case T_Aggref:
  			{
--- 4207,4219 ----
  					break;
  			}
  			break;
! 		case T_ExpressionParam:
  			state = (ExprState *) makeNode(ExprState);
! 			state->evalfunc = ExecEvalExpressionParam;
  			break;
! 		case T_CoerceToDomainValue:
  			state = (ExprState *) makeNode(ExprState);
! 			state->evalfunc = ExecEvalCoerceToDomainValue;
  			break;
  		case T_Aggref:
  			{
*** a/src/backend/executor/execUtils.c
--- b/src/backend/executor/execUtils.c
***************
*** 252,260 **** CreateExprContext(EState *estate)
  	econtext->ecxt_aggvalues = NULL;
  	econtext->ecxt_aggnulls = NULL;
  
- 	econtext->caseValue_datum = (Datum) 0;
- 	econtext->caseValue_isNull = true;
- 
  	econtext->domainValue_datum = (Datum) 0;
  	econtext->domainValue_isNull = true;
  
--- 252,257 ----
***************
*** 323,331 **** CreateStandaloneExprContext(void)
  	econtext->ecxt_aggvalues = NULL;
  	econtext->ecxt_aggnulls = NULL;
  
- 	econtext->caseValue_datum = (Datum) 0;
- 	econtext->caseValue_isNull = true;
- 
  	econtext->domainValue_datum = (Datum) 0;
  	econtext->domainValue_isNull = true;
  
--- 320,325 ----
*** a/src/backend/nodes/copyfuncs.c
--- b/src/backend/nodes/copyfuncs.c
***************
*** 1168,1173 **** _copyArrayRef(ArrayRef *from)
--- 1168,1174 ----
  	COPY_NODE_FIELD(reflowerindexpr);
  	COPY_NODE_FIELD(refexpr);
  	COPY_NODE_FIELD(refassgnexpr);
+ 	COPY_SCALAR_FIELD(refuseparam);
  
  	return newnode;
  }
***************
*** 1386,1391 **** _copyFieldStore(FieldStore *from)
--- 1387,1393 ----
  	COPY_NODE_FIELD(arg);
  	COPY_NODE_FIELD(newvals);
  	COPY_NODE_FIELD(fieldnums);
+ 	COPY_SCALAR_FIELD(useparam);
  	COPY_SCALAR_FIELD(resulttype);
  
  	return newnode;
***************
*** 1511,1526 **** _copyCaseWhen(CaseWhen *from)
  }
  
  /*
!  * _copyCaseTestExpr
   */
! static CaseTestExpr *
! _copyCaseTestExpr(CaseTestExpr *from)
  {
! 	CaseTestExpr *newnode = makeNode(CaseTestExpr);
  
  	COPY_SCALAR_FIELD(typeId);
  	COPY_SCALAR_FIELD(typeMod);
  	COPY_SCALAR_FIELD(collation);
  
  	return newnode;
  }
--- 1513,1530 ----
  }
  
  /*
!  * _copyExpressionParam
   */
! static ExpressionParam *
! _copyExpressionParam(ExpressionParam *from)
  {
! 	ExpressionParam *newnode = makeNode(ExpressionParam);
  
+ 	COPY_SCALAR_FIELD(levelsup);
  	COPY_SCALAR_FIELD(typeId);
  	COPY_SCALAR_FIELD(typeMod);
  	COPY_SCALAR_FIELD(collation);
+ 	COPY_LOCATION_FIELD(location);
  
  	return newnode;
  }
***************
*** 4042,4049 **** copyObject(void *from)
  		case T_CaseWhen:
  			retval = _copyCaseWhen(from);
  			break;
! 		case T_CaseTestExpr:
! 			retval = _copyCaseTestExpr(from);
  			break;
  		case T_ArrayExpr:
  			retval = _copyArrayExpr(from);
--- 4046,4053 ----
  		case T_CaseWhen:
  			retval = _copyCaseWhen(from);
  			break;
! 		case T_ExpressionParam:
! 			retval = _copyExpressionParam(from);
  			break;
  		case T_ArrayExpr:
  			retval = _copyArrayExpr(from);
*** a/src/backend/nodes/equalfuncs.c
--- b/src/backend/nodes/equalfuncs.c
***************
*** 224,229 **** _equalArrayRef(ArrayRef *a, ArrayRef *b)
--- 224,230 ----
  	COMPARE_NODE_FIELD(reflowerindexpr);
  	COMPARE_NODE_FIELD(refexpr);
  	COMPARE_NODE_FIELD(refassgnexpr);
+ 	COMPARE_SCALAR_FIELD(refuseparam);
  
  	return true;
  }
***************
*** 435,440 **** _equalFieldStore(FieldStore *a, FieldStore *b)
--- 436,442 ----
  	COMPARE_NODE_FIELD(arg);
  	COMPARE_NODE_FIELD(newvals);
  	COMPARE_NODE_FIELD(fieldnums);
+ 	COMPARE_SCALAR_FIELD(useparam);
  	COMPARE_SCALAR_FIELD(resulttype);
  
  	return true;
***************
*** 561,571 **** _equalCaseWhen(CaseWhen *a, CaseWhen *b)
  }
  
  static bool
! _equalCaseTestExpr(CaseTestExpr *a, CaseTestExpr *b)
  {
  	COMPARE_SCALAR_FIELD(typeId);
  	COMPARE_SCALAR_FIELD(typeMod);
  	COMPARE_SCALAR_FIELD(collation);
  
  	return true;
  }
--- 563,575 ----
  }
  
  static bool
! _equalExpressionParam(ExpressionParam *a, ExpressionParam *b)
  {
+ 	COMPARE_SCALAR_FIELD(levelsup);
  	COMPARE_SCALAR_FIELD(typeId);
  	COMPARE_SCALAR_FIELD(typeMod);
  	COMPARE_SCALAR_FIELD(collation);
+ 	COMPARE_LOCATION_FIELD(location);
  
  	return true;
  }
***************
*** 2608,2615 **** equal(void *a, void *b)
  		case T_CaseWhen:
  			retval = _equalCaseWhen(a, b);
  			break;
! 		case T_CaseTestExpr:
! 			retval = _equalCaseTestExpr(a, b);
  			break;
  		case T_ArrayExpr:
  			retval = _equalArrayExpr(a, b);
--- 2612,2619 ----
  		case T_CaseWhen:
  			retval = _equalCaseWhen(a, b);
  			break;
! 		case T_ExpressionParam:
! 			retval = _equalExpressionParam(a, b);
  			break;
  		case T_ArrayExpr:
  			retval = _equalArrayExpr(a, b);
*** a/src/backend/nodes/nodeFuncs.c
--- b/src/backend/nodes/nodeFuncs.c
***************
*** 180,187 **** exprType(Node *expr)
  		case T_CaseExpr:
  			type = ((CaseExpr *) expr)->casetype;
  			break;
! 		case T_CaseTestExpr:
! 			type = ((CaseTestExpr *) expr)->typeId;
  			break;
  		case T_ArrayExpr:
  			type = ((ArrayExpr *) expr)->array_typeid;
--- 180,187 ----
  		case T_CaseExpr:
  			type = ((CaseExpr *) expr)->casetype;
  			break;
! 		case T_ExpressionParam:
! 			type = ((ExpressionParam *) expr)->typeId;
  			break;
  		case T_ArrayExpr:
  			type = ((ArrayExpr *) expr)->array_typeid;
***************
*** 365,372 **** exprTypmod(Node *expr)
  				return typmod;
  			}
  			break;
! 		case T_CaseTestExpr:
! 			return ((CaseTestExpr *) expr)->typeMod;
  		case T_ArrayExpr:
  			{
  				/*
--- 365,372 ----
  				return typmod;
  			}
  			break;
! 		case T_ExpressionParam:
! 			return ((ExpressionParam *) expr)->typeMod;
  		case T_ArrayExpr:
  			{
  				/*
***************
*** 756,763 **** exprCollation(Node *expr)
  		case T_CaseExpr:
  			coll = ((CaseExpr *) expr)->casecollid;
  			break;
! 		case T_CaseTestExpr:
! 			coll = ((CaseTestExpr *) expr)->collation;
  			break;
  		case T_ArrayExpr:
  			coll = ((ArrayExpr *) expr)->array_collid;
--- 756,763 ----
  		case T_CaseExpr:
  			coll = ((CaseExpr *) expr)->casecollid;
  			break;
! 		case T_ExpressionParam:
! 			coll = ((ExpressionParam *) expr)->collation;
  			break;
  		case T_ArrayExpr:
  			coll = ((ArrayExpr *) expr)->array_collid;
***************
*** 1525,1531 **** expression_tree_walker(Node *node,
  		case T_Const:
  		case T_Param:
  		case T_CoerceToDomainValue:
! 		case T_CaseTestExpr:
  		case T_SetToDefault:
  		case T_CurrentOfExpr:
  		case T_RangeTblRef:
--- 1525,1531 ----
  		case T_Const:
  		case T_Param:
  		case T_CoerceToDomainValue:
! 		case T_ExpressionParam:
  		case T_SetToDefault:
  		case T_CurrentOfExpr:
  		case T_RangeTblRef:
***************
*** 2040,2046 **** expression_tree_mutator(Node *node,
  			break;
  		case T_Param:
  		case T_CoerceToDomainValue:
! 		case T_CaseTestExpr:
  		case T_SetToDefault:
  		case T_CurrentOfExpr:
  		case T_RangeTblRef:
--- 2040,2046 ----
  			break;
  		case T_Param:
  		case T_CoerceToDomainValue:
! 		case T_ExpressionParam:
  		case T_SetToDefault:
  		case T_CurrentOfExpr:
  		case T_RangeTblRef:
*** a/src/backend/nodes/outfuncs.c
--- b/src/backend/nodes/outfuncs.c
***************
*** 989,994 **** _outArrayRef(StringInfo str, ArrayRef *node)
--- 989,995 ----
  	WRITE_NODE_FIELD(reflowerindexpr);
  	WRITE_NODE_FIELD(refexpr);
  	WRITE_NODE_FIELD(refassgnexpr);
+ 	WRITE_BOOL_FIELD(refuseparam);
  }
  
  static void
***************
*** 1164,1169 **** _outFieldStore(StringInfo str, FieldStore *node)
--- 1165,1171 ----
  	WRITE_NODE_FIELD(arg);
  	WRITE_NODE_FIELD(newvals);
  	WRITE_NODE_FIELD(fieldnums);
+ 	WRITE_BOOL_FIELD(useparam);
  	WRITE_OID_FIELD(resulttype);
  }
  
***************
*** 1252,1264 **** _outCaseWhen(StringInfo str, CaseWhen *node)
  }
  
  static void
! _outCaseTestExpr(StringInfo str, CaseTestExpr *node)
  {
! 	WRITE_NODE_TYPE("CASETESTEXPR");
  
  	WRITE_OID_FIELD(typeId);
  	WRITE_INT_FIELD(typeMod);
  	WRITE_OID_FIELD(collation);
  }
  
  static void
--- 1254,1268 ----
  }
  
  static void
! _outExpressionParam(StringInfo str, ExpressionParam *node)
  {
! 	WRITE_NODE_TYPE("EXPRESSIONPARAM");
  
+ 	WRITE_INT_FIELD(levelsup);
  	WRITE_OID_FIELD(typeId);
  	WRITE_INT_FIELD(typeMod);
  	WRITE_OID_FIELD(collation);
+ 	WRITE_LOCATION_FIELD(location);
  }
  
  static void
***************
*** 2878,2885 **** _outNode(StringInfo str, void *obj)
  			case T_CaseWhen:
  				_outCaseWhen(str, obj);
  				break;
! 			case T_CaseTestExpr:
! 				_outCaseTestExpr(str, obj);
  				break;
  			case T_ArrayExpr:
  				_outArrayExpr(str, obj);
--- 2882,2889 ----
  			case T_CaseWhen:
  				_outCaseWhen(str, obj);
  				break;
! 			case T_ExpressionParam:
! 				_outExpressionParam(str, obj);
  				break;
  			case T_ArrayExpr:
  				_outArrayExpr(str, obj);
*** a/src/backend/nodes/readfuncs.c
--- b/src/backend/nodes/readfuncs.c
***************
*** 520,525 **** _readArrayRef(void)
--- 520,526 ----
  	READ_NODE_FIELD(reflowerindexpr);
  	READ_NODE_FIELD(refexpr);
  	READ_NODE_FIELD(refassgnexpr);
+ 	READ_BOOL_FIELD(refuseparam);
  
  	READ_DONE();
  }
***************
*** 757,762 **** _readFieldStore(void)
--- 758,764 ----
  	READ_NODE_FIELD(arg);
  	READ_NODE_FIELD(newvals);
  	READ_NODE_FIELD(fieldnums);
+ 	READ_BOOL_FIELD(useparam);
  	READ_OID_FIELD(resulttype);
  
  	READ_DONE();
***************
*** 882,897 **** _readCaseWhen(void)
  }
  
  /*
!  * _readCaseTestExpr
   */
! static CaseTestExpr *
! _readCaseTestExpr(void)
  {
! 	READ_LOCALS(CaseTestExpr);
  
  	READ_OID_FIELD(typeId);
  	READ_INT_FIELD(typeMod);
  	READ_OID_FIELD(collation);
  
  	READ_DONE();
  }
--- 884,901 ----
  }
  
  /*
!  * _readExpressionParam
   */
! static ExpressionParam *
! _readExpressionParam(void)
  {
! 	READ_LOCALS(ExpressionParam);
  
+ 	READ_INT_FIELD(levelsup);
  	READ_OID_FIELD(typeId);
  	READ_INT_FIELD(typeMod);
  	READ_OID_FIELD(collation);
+ 	READ_LOCATION_FIELD(location);
  
  	READ_DONE();
  }
***************
*** 1314,1321 **** parseNodeString(void)
  		return_value = _readCaseExpr();
  	else if (MATCH("WHEN", 4))
  		return_value = _readCaseWhen();
! 	else if (MATCH("CASETESTEXPR", 12))
! 		return_value = _readCaseTestExpr();
  	else if (MATCH("ARRAY", 5))
  		return_value = _readArrayExpr();
  	else if (MATCH("ROW", 3))
--- 1318,1325 ----
  		return_value = _readCaseExpr();
  	else if (MATCH("WHEN", 4))
  		return_value = _readCaseWhen();
! 	else if (MATCH("EXPRESSIONPARAM", 15))
! 		return_value = _readExpressionParam();
  	else if (MATCH("ARRAY", 5))
  		return_value = _readArrayExpr();
  	else if (MATCH("ROW", 3))
*** a/src/backend/optimizer/util/clauses.c
--- b/src/backend/optimizer/util/clauses.c
***************
*** 59,73 **** typedef struct
  	ParamListInfo boundParams;
  	PlannerGlobal *glob;
  	List	   *active_fns;
- 	Node	   *case_val;
  	bool		estimate;
  } eval_const_expressions_context;
  
  typedef struct
  {
  	int			nargs;
  	List	   *args;
  	int		   *usecounts;
  } substitute_actual_parameters_context;
  
  typedef struct
--- 59,79 ----
  	ParamListInfo boundParams;
  	PlannerGlobal *glob;
  	List	   *active_fns;
  	bool		estimate;
  } eval_const_expressions_context;
  
  typedef struct
  {
+ 	Node *replacement;
+ 	int replacement_level;
+ } replace_expression_param_context;
+ 
+ typedef struct
+ {
  	int			nargs;
  	List	   *args;
  	int		   *usecounts;
+ 	int			expr_param_depth;
  } substitute_actual_parameters_context;
  
  typedef struct
***************
*** 129,138 **** static Expr *inline_function(Oid funcid, Oid result_type, Oid result_collid,
--- 135,150 ----
  				Oid input_collid, List *args,
  				HeapTuple func_tuple,
  				eval_const_expressions_context *context);
+ static int	expression_params_used(Node *node);
  static Node *substitute_actual_parameters(Node *expr, int nargs, List *args,
  							 int *usecounts);
  static Node *substitute_actual_parameters_mutator(Node *node,
  							  substitute_actual_parameters_context *context);
+ static Node *adjust_expression_params(Node *expr, int offset);
+ static Node *adjust_expression_params_mutator(Node *node, int *offset);
+ static Node *replace_expression_param(Node *expr, Node *replacement);
+ static Node *replace_expression_param_mutator(Node *node,
+ 								 replace_expression_param_context *context);
  static void sql_inline_error_callback(void *arg);
  static Expr *evaluate_expr(Expr *expr, Oid result_type, int32 result_typmod,
  			  Oid result_collation);
***************
*** 2104,2110 **** eval_const_expressions(PlannerInfo *root, Node *node)
  		context.glob = NULL;
  	}
  	context.active_fns = NIL;	/* nothing being recursively simplified */
- 	context.case_val = NULL;	/* no CASE being examined */
  	context.estimate = false;	/* safe transformations only */
  	return eval_const_expressions_mutator(node, &context);
  }
--- 2116,2121 ----
***************
*** 2135,2141 **** estimate_expression_value(PlannerInfo *root, Node *node)
  	/* we do not need to mark the plan as depending on inlined functions */
  	context.glob = NULL;
  	context.active_fns = NIL;	/* nothing being recursively simplified */
- 	context.case_val = NULL;	/* no CASE being examined */
  	context.estimate = true;	/* unsafe transformations OK */
  	return eval_const_expressions_mutator(node, &context);
  }
--- 2146,2151 ----
***************
*** 2700,2706 **** eval_const_expressions_mutator(Node *node,
  		 * CASE to the default result (ELSE result).
  		 *
  		 * If we have a simple-form CASE with constant test expression,
! 		 * we substitute the constant value for contained CaseTestExpr
  		 * placeholder nodes, so that we have the opportunity to reduce
  		 * constant test conditions.  For example this allows
  		 *		CASE 0 WHEN 0 THEN 1 ELSE 1/0 END
--- 2710,2716 ----
  		 * CASE to the default result (ELSE result).
  		 *
  		 * If we have a simple-form CASE with constant test expression,
! 		 * we substitute the constant value for contained ExpressionParam
  		 * placeholder nodes, so that we have the opportunity to reduce
  		 * constant test conditions.  For example this allows
  		 *		CASE 0 WHEN 0 THEN 1 ELSE 1/0 END
***************
*** 2709,2750 **** eval_const_expressions_mutator(Node *node,
  		 * include it in the resulting CASE; for example
  		 *		CASE 0 WHEN x THEN y ELSE z END
  		 * is transformed by the parser to
! 		 *		CASE 0 WHEN CaseTestExpr = x THEN y ELSE z END
  		 * which we can simplify to
  		 *		CASE WHEN 0 = x THEN y ELSE z END
  		 * It is not necessary for the executor to evaluate the "arg"
  		 * expression when executing the CASE, since any contained
! 		 * CaseTestExprs that might have referred to it will have been
  		 * replaced by the constant.
  		 *----------
  		 */
  		CaseExpr   *caseexpr = (CaseExpr *) node;
  		CaseExpr   *newcase;
- 		Node	   *save_case_val;
  		Node	   *newarg;
  		List	   *newargs;
  		bool		const_true_cond;
  		Node	   *defresult = NULL;
  		ListCell   *arg;
  
  		/* Simplify the test expression, if any */
  		newarg = eval_const_expressions_mutator((Node *) caseexpr->arg,
  												context);
  
! 		/* Set up for contained CaseTestExpr nodes */
! 		save_case_val = context->case_val;
! 		if (newarg && IsA(newarg, Const))
  		{
! 			context->case_val = newarg;
! 			newarg = NULL;		/* not needed anymore, see comment above */
  		}
- 		else
- 			context->case_val = NULL;
  
  		/* Simplify the WHEN clauses */
  		newargs = NIL;
  		const_true_cond = false;
! 		foreach(arg, caseexpr->args)
  		{
  			CaseWhen   *oldcasewhen = (CaseWhen *) lfirst(arg);
  			Node	   *casecond;
--- 2719,2776 ----
  		 * include it in the resulting CASE; for example
  		 *		CASE 0 WHEN x THEN y ELSE z END
  		 * is transformed by the parser to
! 		 *		CASE 0 WHEN ExpressionParam = x THEN y ELSE z END
  		 * which we can simplify to
  		 *		CASE WHEN 0 = x THEN y ELSE z END
  		 * It is not necessary for the executor to evaluate the "arg"
  		 * expression when executing the CASE, since any contained
! 		 * ExpressionParams that might have referred to it will have been
  		 * replaced by the constant.
  		 *----------
  		 */
  		CaseExpr   *caseexpr = (CaseExpr *) node;
  		CaseExpr   *newcase;
  		Node	   *newarg;
  		List	   *newargs;
  		bool		const_true_cond;
  		Node	   *defresult = NULL;
  		ListCell   *arg;
+ 		List	   *args;
  
  		/* Simplify the test expression, if any */
  		newarg = eval_const_expressions_mutator((Node *) caseexpr->arg,
  												context);
  
! 		/*
! 		 * Set up for contained ExpressionParam nodes. If the case value is
! 		 * a constant, we can simply replace the ExpressionParam nodes with the
! 		 * constant. Otherwise, create an expression param to pass down the
! 		 * value at runtime from the CaseExpr. It would be legal to do the
! 		 * simple replacement for any non-volatile expression, but that's
! 		 * unlikely to be a win if the expression is any more complicated than
! 		 * a simple Const.
! 		 *
! 		 * Note: These conditions must match those in expression_params_used()!
! 		 */
! 		args = caseexpr->args;
! 		if (newarg)
  		{
! 			if (IsA(newarg, Const))
! 			{
! 				/*
! 				 * Replace any ExpressionParams referring to this with the
! 				 * constant. This also adjusts the levelsup fields of any
! 				 * ExpressionParams referring to values above this level.
! 				 */
! 				args = (List *) replace_expression_param((Node *) args, newarg);
! 				newarg = NULL;		/* not needed anymore */
! 			}
  		}
  
  		/* Simplify the WHEN clauses */
  		newargs = NIL;
  		const_true_cond = false;
! 		foreach(arg, args)
  		{
  			CaseWhen   *oldcasewhen = (CaseWhen *) lfirst(arg);
  			Node	   *casecond;
***************
*** 2803,2810 **** eval_const_expressions_mutator(Node *node,
  				eval_const_expressions_mutator((Node *) caseexpr->defresult,
  											   context);
  
- 		context->case_val = save_case_val;
- 
  		/* If no non-FALSE alternatives, CASE reduces to the default result */
  		if (newargs == NIL)
  			return defresult;
--- 2829,2834 ----
***************
*** 2818,2835 **** eval_const_expressions_mutator(Node *node,
  		newcase->location = caseexpr->location;
  		return (Node *) newcase;
  	}
- 	if (IsA(node, CaseTestExpr))
- 	{
- 		/*
- 		 * If we know a constant test value for the current CASE construct,
- 		 * substitute it for the placeholder.  Else just return the
- 		 * placeholder as-is.
- 		 */
- 		if (context->case_val)
- 			return copyObject(context->case_val);
- 		else
- 			return copyObject(node);
- 	}
  	if (IsA(node, ArrayExpr))
  	{
  		ArrayExpr  *arrayexpr = (ArrayExpr *) node;
--- 2842,2847 ----
***************
*** 4139,4144 **** fail:
--- 4151,4287 ----
  }
  
  /*
+  * Returns the number of expression params pushed to the stack by this node.
+  */
+ static int
+ expression_params_used(Node *node)
+ {
+ 	/*
+ 	 * "CASE x WHEN ..." constructs push the CASE-value x to an expression
+ 	 * param.
+ 	 */
+ 	if (IsA(node, CaseExpr))
+ 	{
+ 		CaseExpr   *caseexpr = (CaseExpr *) node;
+ 		/*
+ 		 * Note: these conditions must match those in
+ 		 * eval_const_expressions_mutator()!
+ 		 */
+ 		if (caseexpr->arg && !IsA(caseexpr->arg, Const))
+ 			return 1;
+ 	}
+ 	if (IsA(node, FieldStore))
+ 	{
+ 		FieldStore   *fstore = (FieldStore *) node;
+ 		if (fstore->useparam)
+ 			return 1;
+ 	}
+ 	if (IsA(node, ArrayRef))
+ 	{
+ 		ArrayRef   *aref = (ArrayRef *) node;
+ 		if (aref->refexpr)
+ 			return 1;
+ 	}
+ 	/*
+ 	 * XXX
+ 	 *
+ 	 * IN will push one param, the left-hand value. BETWEEN will also push one,
+ 	 * BETWEEN SYMMETRIC will push three values in the worst case.
+ 	 */
+ 	return 0;
+ }
+ 
+ /*
+  *
+  */
+ static Node *
+ adjust_expression_params(Node *node, int offset)
+ {
+ 	if (offset == 0)
+ 		return node;
+ 
+ 	return adjust_expression_params_mutator(node, &offset);
+ }
+ 
+ static Node *
+ adjust_expression_params_mutator(Node *node, int *offset)
+ {
+ 	if (node == NULL)
+ 		return NULL;
+ 	if (IsA(node, ExpressionParam))
+ 	{
+ 		ExpressionParam *eparam = (ExpressionParam *) copyObject(node);
+ 		eparam->levelsup += (*offset);
+ 		return (Node *) eparam;
+ 	}
+ 	return expression_tree_mutator(node, adjust_expression_params_mutator,
+ 								   (void *) offset);
+ }
+ 
+ /*
+  * Replaces any ExpressionParams (with eparamid == 0) in 'node' with the
+  * given replacement node.
+  *
+  * The difficulty is in tracking which ExpressionParams point to the value
+  * we're trying to replace. As we drill into a CaseExpr, for example, the
+  * "current" depth we're at increases. Within one such a node the
+  * ExpressionParams we need to replace will have levelsup == 1.
+  */
+ static Node *
+ replace_expression_param(Node *node, Node *replacement)
+ {
+ 	replace_expression_param_context context;
+ 
+ 	/* we are replacing ExpressionParams with levelsup 0 initially */
+ 	context.replacement_level = 0;
+ 	context.replacement = replacement;
+ 	return replace_expression_param_mutator(node, &context);
+ }
+ 
+ static Node *
+ replace_expression_param_mutator(Node *node, replace_expression_param_context *context)
+ {
+ 	int			num_expr_params;
+ 
+ 	if (node == NULL)
+ 		return NULL;
+ 	if (IsA(node, ExpressionParam))
+ 	{
+ 		ExpressionParam *eparam = (ExpressionParam *) copyObject(node);
+ 
+ 		/*
+ 		 * If this param points to the param that we're replacing, return
+ 		 * the replacement. If it points to something above it, shift the
+ 		 * reference down as we're removing the layer from the middle. If
+ 		 * it points to something below it, leave it alone.
+ 		 */
+ 		if (eparam->levelsup == context->replacement_level)
+ 			return context->replacement; /* XXX copy? */
+ 		else if (eparam->levelsup > context->replacement_level)
+ 		{
+ 			ExpressionParam *neweparam = (ExpressionParam *) copyObject(eparam);
+ 			neweparam->levelsup--;
+ 			return (Node *) neweparam;
+ 		}
+ 		else
+ 			return (Node *) eparam;
+ 	}
+ 
+ 	num_expr_params = expression_params_used(node);
+ 	if (num_expr_params > 0)
+ 	{
+ 		context->replacement_level += num_expr_params;
+ 		return expression_tree_mutator(node, replace_expression_param_mutator,
+ 									   (void *) context);
+ 		context->replacement_level -= num_expr_params;
+ 	}
+ 	else
+ 		return expression_tree_mutator(node, replace_expression_param_mutator,
+ 									   (void *) context);
+ }
+ 
+ 
+ /*
   * Replace Param nodes by appropriate actual parameters
   */
  static Node *
***************
*** 4150,4155 **** substitute_actual_parameters(Node *expr, int nargs, List *args,
--- 4293,4299 ----
  	context.nargs = nargs;
  	context.args = args;
  	context.usecounts = usecounts;
+ 	context.expr_param_depth = 0;
  
  	return substitute_actual_parameters_mutator(expr, &context);
  }
***************
*** 4158,4168 **** static Node *
--- 4302,4316 ----
  substitute_actual_parameters_mutator(Node *node,
  							   substitute_actual_parameters_context *context)
  {
+ 	int			num_expr_params;
+ 
  	if (node == NULL)
  		return NULL;
+ 
  	if (IsA(node, Param))
  	{
  		Param	   *param = (Param *) node;
+ 		Node	   *arg;
  
  		if (param->paramkind != PARAM_EXTERN)
  			elog(ERROR, "unexpected paramkind: %d", (int) param->paramkind);
***************
*** 4172,4183 **** substitute_actual_parameters_mutator(Node *node,
  		/* Count usage of parameter */
  		context->usecounts[param->paramid - 1]++;
  
! 		/* Select the appropriate actual arg and replace the Param with it */
! 		/* We don't need to copy at this time (it'll get done later) */
! 		return list_nth(context->args, param->paramid - 1);
  	}
! 	return expression_tree_mutator(node, substitute_actual_parameters_mutator,
! 								   (void *) context);
  }
  
  /*
--- 4320,4349 ----
  		/* Count usage of parameter */
  		context->usecounts[param->paramid - 1]++;
  
! 		/*
! 		 * Select the appropriate actual arg and replace the Param with it.
! 		 * We don't need to copy at this time (it'll get done later).
! 		 * However, if we're within a node that sets an ExpressionParam, we
! 		 * need to adjust any ExpressionParam references to outer expressions
! 		 * accordingly.
! 		 */
! 		arg = list_nth(context->args, param->paramid - 1);
! 		if (context->expr_param_depth > 0)
! 			arg = adjust_expression_params(arg, context->expr_param_depth);
! 		return arg;
! 	}
! 
! 	num_expr_params = expression_params_used(node);
! 	if (num_expr_params > 0)
! 	{
! 		context->expr_param_depth += num_expr_params;
! 		return expression_tree_mutator(node, substitute_actual_parameters_mutator,
! 									   (void *) context);
! 		context->expr_param_depth -= num_expr_params;
  	}
! 	else
! 		return expression_tree_mutator(node, substitute_actual_parameters_mutator,
! 									   (void *) context);
  }
  
  /*
*** a/src/backend/parser/parse_collate.c
--- b/src/backend/parser/parse_collate.c
***************
*** 598,604 **** assign_collations_walker(Node *node, assign_collations_context *context)
  		case T_Const:
  		case T_Param:
  		case T_CoerceToDomainValue:
! 		case T_CaseTestExpr:
  		case T_SetToDefault:
  		case T_CurrentOfExpr:
  
--- 598,604 ----
  		case T_Const:
  		case T_Param:
  		case T_CoerceToDomainValue:
! 		case T_ExpressionParam:
  		case T_SetToDefault:
  		case T_CurrentOfExpr:
  
*** a/src/backend/parser/parse_expr.c
--- b/src/backend/parser/parse_expr.c
***************
*** 321,327 **** transformExpr(ParseState *pstate, Node *expr)
  		case T_ArrayCoerceExpr:
  		case T_ConvertRowtypeExpr:
  		case T_CollateExpr:
! 		case T_CaseTestExpr:
  		case T_ArrayExpr:
  		case T_CoerceToDomain:
  		case T_CoerceToDomainValue:
--- 321,327 ----
  		case T_ArrayCoerceExpr:
  		case T_ConvertRowtypeExpr:
  		case T_CollateExpr:
! 		case T_ExpressionParam:
  		case T_ArrayExpr:
  		case T_CoerceToDomain:
  		case T_CoerceToDomainValue:
***************
*** 1253,1259 **** transformCaseExpr(ParseState *pstate, CaseExpr *c)
  {
  	CaseExpr   *newc;
  	Node	   *arg;
! 	CaseTestExpr *placeholder;
  	List	   *newargs;
  	List	   *resultexprs;
  	ListCell   *l;
--- 1253,1259 ----
  {
  	CaseExpr   *newc;
  	Node	   *arg;
! 	ExpressionParam *placeholder;
  	List	   *newargs;
  	List	   *resultexprs;
  	ListCell   *l;
***************
*** 1286,1296 **** transformCaseExpr(ParseState *pstate, CaseExpr *c)
  		 * Run collation assignment on the test expression so that we know
  		 * what collation to mark the placeholder with.  In principle we could
  		 * leave it to parse_collate.c to do that later, but propagating the
! 		 * result to the CaseTestExpr would be unnecessarily complicated.
  		 */
  		assign_expr_collations(pstate, arg);
  
! 		placeholder = makeNode(CaseTestExpr);
  		placeholder->typeId = exprType(arg);
  		placeholder->typeMod = exprTypmod(arg);
  		placeholder->collation = exprCollation(arg);
--- 1286,1297 ----
  		 * Run collation assignment on the test expression so that we know
  		 * what collation to mark the placeholder with.  In principle we could
  		 * leave it to parse_collate.c to do that later, but propagating the
! 		 * result to the ExpressionParam would be unnecessarily complicated.
  		 */
  		assign_expr_collations(pstate, arg);
  
! 		placeholder = makeNode(ExpressionParam);
! 		placeholder->levelsup = 0;
  		placeholder->typeId = exprType(arg);
  		placeholder->typeMod = exprTypmod(arg);
  		placeholder->collation = exprCollation(arg);
*** a/src/backend/parser/parse_target.c
--- b/src/backend/parser/parse_target.c
***************
*** 583,598 **** transformAssignmentIndirection(ParseState *pstate,
  	List	   *subscripts = NIL;
  	bool		isSlice = false;
  	ListCell   *i;
  
  	if (indirection && !basenode)
  	{
! 		/* Set up a substitution.  We reuse CaseTestExpr for this. */
! 		CaseTestExpr *ctest = makeNode(CaseTestExpr);
! 
! 		ctest->typeId = targetTypeId;
! 		ctest->typeMod = targetTypMod;
! 		ctest->collation = targetCollation;
! 		basenode = (Node *) ctest;
  	}
  
  	/*
--- 583,601 ----
  	List	   *subscripts = NIL;
  	bool		isSlice = false;
  	ListCell   *i;
+ 	bool		useparam = false;
  
  	if (indirection && !basenode)
  	{
! 		/* Set up a substitution. */
! 		ExpressionParam *eparam = makeNode(ExpressionParam);
! 
! 		eparam->levelsup = 0;
! 		eparam->typeId = targetTypeId;
! 		eparam->typeMod = targetTypMod;
! 		eparam->collation = targetCollation;
! 		basenode = (Node *) eparam;
! 		useparam = true;
  	}
  
  	/*
***************
*** 691,696 **** transformAssignmentIndirection(ParseState *pstate,
--- 694,704 ----
  			fstore->arg = (Expr *) basenode;
  			fstore->newvals = list_make1(rhs);
  			fstore->fieldnums = list_make1_int(attnum);
+ 			/*
+ 			 * if there's any more recursion, need to store the old value
+ 			 * of the field in an expression param at execution time
+ 			 */
+ 			fstore->useparam = (lnext(i) != NULL);
  			fstore->resulttype = targetTypeId;
  
  			return (Node *) fstore;
***************
*** 765,770 **** transformAssignmentSubscripts(ParseState *pstate,
--- 773,779 ----
  							  Node *rhs,
  							  int location)
  {
+ 	ArrayRef   *aref;
  	Node	   *result;
  	Oid			arrayType;
  	int32		arrayTypMod;
***************
*** 805,817 **** transformAssignmentSubscripts(ParseState *pstate,
  										 location);
  
  	/* process subscripts */
! 	result = (Node *) transformArraySubscripts(pstate,
! 											   basenode,
! 											   arrayType,
! 											   elementTypeId,
! 											   arrayTypMod,
! 											   subscripts,
! 											   rhs);
  
  	/* If target was a domain over array, need to coerce up to the domain */
  	if (arrayType != targetTypeId)
--- 814,854 ----
  										 location);
  
  	/* process subscripts */
! 	aref = transformArraySubscripts(pstate,
! 									  basenode,
! 									  arrayType,
! 									  elementTypeId,
! 									  arrayTypMod,
! 									  subscripts,
! 									  rhs);
! 	/*
! 	 * We might have a nested-assignment situation, in which the rhs is
! 	 * itself a FieldStore or ArrayRef that needs to obtain and modify the
! 	 * previous value of the array element or slice being replaced. If so, we
! 	 * have to extract that value from the array at runtime and pass it down
! 	 * via an expression param.
! 	 *
! 	 * Since fetching the old element might be a nontrivial expense, do it
! 	 * only if the argument appears to actually need it. We set refuseparam
! 	 * if that is needed.
! 	 */
! 	if (IsA(rhs, FieldStore))
! 	{
! 		FieldStore *fstore = (FieldStore *) rhs;
! 
! 		if (fstore->arg && IsA(fstore->arg, ExpressionParam) &&
! 			((ExpressionParam *) fstore->arg)->levelsup == 0)
! 			aref->refuseparam = true;
! 	}
! 	else if (IsA(rhs, ArrayRef))
! 	{
! 		ArrayRef   *arrayRef = (ArrayRef *) rhs;
! 
! 		if (arrayRef->refexpr && IsA(arrayRef->refexpr, ExpressionParam) &&
! 			((ExpressionParam *) arrayRef->refexpr)->levelsup == 0)
! 			aref->refuseparam = true;
! 	}
! 	result = (Node *) aref;
  
  	/* If target was a domain over array, need to coerce up to the domain */
  	if (arrayType != targetTypeId)
*** a/src/backend/utils/adt/ruleutils.c
--- b/src/backend/utils/adt/ruleutils.c
***************
*** 4783,4796 **** get_rule_expr(Node *node, deparse_context *context,
  				bool		need_parens;
  
  				/*
! 				 * If the argument is a CaseTestExpr, we must be inside a
  				 * FieldStore, ie, we are assigning to an element of an array
  				 * within a composite column.  Since we already punted on
  				 * displaying the FieldStore's target information, just punt
  				 * here too, and display only the assignment source
  				 * expression.
  				 */
! 				if (IsA(aref->refexpr, CaseTestExpr))
  				{
  					Assert(aref->refassgnexpr);
  					get_rule_expr((Node *) aref->refassgnexpr,
--- 4783,4797 ----
  				bool		need_parens;
  
  				/*
! 				 * If the argument is an ExpressionParam, we must be inside a
  				 * FieldStore, ie, we are assigning to an element of an array
  				 * within a composite column.  Since we already punted on
  				 * displaying the FieldStore's target information, just punt
  				 * here too, and display only the assignment source
  				 * expression.
  				 */
! 				if (IsA(aref->refexpr, ExpressionParam) &&
! 					((ExpressionParam *) aref->refexpr)->levelsup == 0)
  				{
  					Assert(aref->refassgnexpr);
  					get_rule_expr((Node *) aref->refassgnexpr,
***************
*** 5191,5198 **** get_rule_expr(Node *node, deparse_context *context,
  					{
  						/*
  						 * The parser should have produced WHEN clauses of
! 						 * the form "CaseTestExpr = RHS", possibly with an
! 						 * implicit coercion inserted above the CaseTestExpr.
  						 * For accurate decompilation of rules it's essential
  						 * that we show just the RHS.  However in an
  						 * expression that's been through the optimizer, the
--- 5192,5199 ----
  					{
  						/*
  						 * The parser should have produced WHEN clauses of
! 						 * the form "ExpressionParam[0] = RHS", possibly with an
! 						 * implicit coercion inserted above the ExpressionParam.
  						 * For accurate decompilation of rules it's essential
  						 * that we show just the RHS.  However in an
  						 * expression that's been through the optimizer, the
***************
*** 5204,5214 **** get_rule_expr(Node *node, deparse_context *context,
  						if (IsA(w, OpExpr))
  						{
  							List	   *args = ((OpExpr *) w)->args;
  
! 							if (list_length(args) == 2 &&
! 								IsA(strip_implicit_coercions(linitial(args)),
! 									CaseTestExpr))
! 								w = (Node *) lsecond(args);
  						}
  					}
  
--- 5205,5218 ----
  						if (IsA(w, OpExpr))
  						{
  							List	   *args = ((OpExpr *) w)->args;
+ 							if (list_length(args) == 2)
+ 							{
+ 								Node *leftarg = strip_implicit_coercions(linitial(args));
  
! 								if (IsA(leftarg, ExpressionParam) &&
! 									((ExpressionParam *) leftarg)->levelsup == 0)
! 									w = (Node *) lsecond(args);
! 							}
  						}
  					}
  
***************
*** 5232,5238 **** get_rule_expr(Node *node, deparse_context *context,
  			}
  			break;
  
! 		case T_CaseTestExpr:
  			{
  				/*
  				 * Normally we should never get here, since for expressions
--- 5236,5242 ----
  			}
  			break;
  
! 		case T_ExpressionParam:
  			{
  				/*
  				 * Normally we should never get here, since for expressions
***************
*** 5241,5247 **** get_rule_expr(Node *node, deparse_context *context,
  				 * be unable to avoid that (see comments for CaseExpr).  If we
  				 * do see one, print it as CASE_TEST_EXPR.
  				 */
! 				appendStringInfo(buf, "CASE_TEST_EXPR");
  			}
  			break;
  
--- 5245,5252 ----
  				 * be unable to avoid that (see comments for CaseExpr).  If we
  				 * do see one, print it as CASE_TEST_EXPR.
  				 */
! 				appendStringInfo(buf, "EXPR_PARAM[%d]",
! 								 ((ExpressionParam *) node)->levelsup);
  			}
  			break;
  
*** a/src/backend/utils/adt/selfuncs.c
--- b/src/backend/utils/adt/selfuncs.c
***************
*** 1836,1842 **** scalararraysel(PlannerInfo *root,
  	}
  	else
  	{
! 		CaseTestExpr *dummyexpr;
  		List	   *args;
  		Selectivity s2;
  		int			i;
--- 1836,1842 ----
  	}
  	else
  	{
! 		ExpressionParam *dummyexpr;
  		List	   *args;
  		Selectivity s2;
  		int			i;
***************
*** 1844,1852 **** scalararraysel(PlannerInfo *root,
  		/*
  		 * We need a dummy rightop to pass to the operator selectivity
  		 * routine.  It can be pretty much anything that doesn't look like a
! 		 * constant; CaseTestExpr is a convenient choice.
  		 */
! 		dummyexpr = makeNode(CaseTestExpr);
  		dummyexpr->typeId = nominal_element_type;
  		dummyexpr->typeMod = -1;
  		dummyexpr->collation = clause->inputcollid;
--- 1844,1853 ----
  		/*
  		 * We need a dummy rightop to pass to the operator selectivity
  		 * routine.  It can be pretty much anything that doesn't look like a
! 		 * constant; ExpressionParam is a convenient choice.
  		 */
! 		dummyexpr = makeNode(ExpressionParam);
! 		dummyexpr->levelsup = 0;
  		dummyexpr->typeId = nominal_element_type;
  		dummyexpr->typeMod = -1;
  		dummyexpr->collation = clause->inputcollid;
*** a/src/include/nodes/execnodes.h
--- b/src/include/nodes/execnodes.h
***************
*** 125,130 **** typedef struct ExprContext
--- 125,132 ----
  	ParamExecData *ecxt_param_exec_vals;		/* for PARAM_EXEC params */
  	ParamListInfo ecxt_param_list_info; /* for other param types */
  
+ 	List	   *expr_params;	/* stack of ParamExecDatas */
+ 
  	/*
  	 * Values to substitute for Aggref nodes in the expressions of an Agg
  	 * node, or for WindowFunc nodes within a WindowAgg node.
***************
*** 132,141 **** typedef struct ExprContext
  	Datum	   *ecxt_aggvalues; /* precomputed values for aggs/windowfuncs */
  	bool	   *ecxt_aggnulls;	/* null flags for aggs/windowfuncs */
  
- 	/* Value to substitute for CaseTestExpr nodes in expression */
- 	Datum		caseValue_datum;
- 	bool		caseValue_isNull;
- 
  	/* Value to substitute for CoerceToDomainValue nodes in expression */
  	Datum		domainValue_datum;
  	bool		domainValue_isNull;
--- 134,139 ----
*** a/src/include/nodes/nodes.h
--- b/src/include/nodes/nodes.h
***************
*** 152,158 **** typedef enum NodeTag
  	T_CollateExpr,
  	T_CaseExpr,
  	T_CaseWhen,
! 	T_CaseTestExpr,
  	T_ArrayExpr,
  	T_RowExpr,
  	T_RowCompareExpr,
--- 152,158 ----
  	T_CollateExpr,
  	T_CaseExpr,
  	T_CaseWhen,
! 	T_ExpressionParam,
  	T_ArrayExpr,
  	T_RowExpr,
  	T_RowCompareExpr,
*** a/src/include/nodes/primnodes.h
--- b/src/include/nodes/primnodes.h
***************
*** 212,217 **** typedef struct Param
--- 212,239 ----
  } Param;
  
  /*
+  * ExpressionParam
+  *
+  * Expression params are similar to Params, but are only used within a single
+  * expression. An enclosing Expr node can set a param, and an inner Expr
+  * can reference it using an ExpressionParam node. Unlike normal Params,
+  * expression param ids are not globally unique. Instead, they form a stack.
+  * An ExpressionParam with eparamid == 0 references the param value at the
+  * top of the stack, eparamid == 1 the one below it, and so forth. The syntax
+  * of the expressions that use this only allow referencing the topmost param,
+  * but SQL function inlining can rearrange things.
+  */
+ typedef struct ExpressionParam
+ {
+ 	Expr		xpr;
+ 	int			levelsup;		/* stack level this refers to */
+ 	Oid			typeId;			/* pg_type OID of parameter's datatype */
+ 	int32		typeMod;		/* typmod value, if known */
+ 	Oid			collation;		/* OID of collation, or InvalidOid if none */
+ 	int			location;		/* token location, or -1 if unknown */
+ } ExpressionParam;
+ 
+ /*
   * Aggref
   *
   * The aggregate's args list is a targetlist, ie, a list of TargetEntry nodes
***************
*** 295,300 **** typedef struct ArrayRef
--- 317,324 ----
  								 * value */
  	Expr	   *refassgnexpr;	/* expression for the source value, or NULL if
  								 * fetch */
+ 	bool		refuseparam;	/* need an exec param to hold old value during
+ 								 * refassgnexpr execution? */
  } ArrayRef;
  
  /*
***************
*** 639,644 **** typedef struct FieldStore
--- 663,669 ----
  	Expr	   *arg;			/* input tuple value */
  	List	   *newvals;		/* new value(s) for field(s) */
  	List	   *fieldnums;		/* integer list of field attnums */
+ 	bool		useparam;		/* need an expr param to hold old values? */
  	Oid			resulttype;		/* type of result (same as type of arg) */
  	/* Like RowExpr, we deliberately omit a typmod and collation here */
  } FieldStore;
***************
*** 761,768 **** typedef struct CollateExpr
   * In the raw grammar output for the second form, the condition expressions
   * of the WHEN clauses are just the comparison values.	Parse analysis
   * converts these to valid boolean expressions of the form
!  *		CaseTestExpr '=' compexpr
!  * where the CaseTestExpr node is a placeholder that emits the correct
   * value at runtime.  This structure is used so that the testexpr need be
   * evaluated only once.  Note that after parse analysis, the condition
   * expressions always yield boolean.
--- 786,793 ----
   * In the raw grammar output for the second form, the condition expressions
   * of the WHEN clauses are just the comparison values.	Parse analysis
   * converts these to valid boolean expressions of the form
!  *		ExpressionParam[0] '=' compexpr
!  * where the ExpressionParam node is a placeholder that emits the correct
   * value at runtime.  This structure is used so that the testexpr need be
   * evaluated only once.  Note that after parse analysis, the condition
   * expressions always yield boolean.
***************
*** 794,815 **** typedef struct CaseWhen
  } CaseWhen;
  
  /*
-  * Placeholder node for the test value to be processed by a CASE expression.
-  * This is effectively like a Param, but can be implemented more simply
-  * since we need only one replacement value at a time.
-  *
-  * We also use this in nested UPDATE expressions.
-  * See transformAssignmentIndirection().
-  */
- typedef struct CaseTestExpr
- {
- 	Expr		xpr;
- 	Oid			typeId;			/* type for substituted value */
- 	int32		typeMod;		/* typemod for substituted value */
- 	Oid			collation;		/* collation for the substituted value */
- } CaseTestExpr;
- 
- /*
   * ArrayExpr - an ARRAY[] expression
   *
   * Note: if multidims is false, the constituent expressions all yield the
--- 819,824 ----
*** a/src/pl/plpgsql/src/pl_exec.c
--- b/src/pl/plpgsql/src/pl_exec.c
***************
*** 5459,5465 **** exec_simple_check_node(Node *node)
  				return TRUE;
  			}
  
! 		case T_CaseTestExpr:
  			return TRUE;
  
  		case T_ArrayExpr:
--- 5459,5465 ----
  				return TRUE;
  			}
  
! 		case T_ExpressionParam:
  			return TRUE;
  
  		case T_ArrayExpr: