indexscan-params-1.patch

Index: src/backend/executor/nodeBitmapIndexscan.c
===================================================================
RCS file: /cvsroot/pgsql/src/backend/executor/nodeBitmapIndexscan.c,v
retrieving revision 1.33
diff -c -r1.33 nodeBitmapIndexscan.c
*** src/backend/executor/nodeBitmapIndexscan.c	2 Jan 2010 16:57:41 -0000	1.33
--- src/backend/executor/nodeBitmapIndexscan.c	12 Jul 2010 04:26:44 -0000
***************
*** 108,144 ****
  /* ----------------------------------------------------------------
   *		ExecBitmapIndexReScan(node)
   *
!  *		Recalculates the value of the scan keys whose value depends on
!  *		information known at runtime and rescans the indexed relation.
   * ----------------------------------------------------------------
   */
  void
  ExecBitmapIndexReScan(BitmapIndexScanState *node, ExprContext *exprCtxt)
  {
! 	ExprContext *econtext;
! 
! 	econtext = node->biss_RuntimeContext;		/* context for runtime keys */
  
  	if (econtext)
- 	{
- 		/*
- 		 * If we are being passed an outer tuple, save it for runtime key
- 		 * calc.
- 		 */
- 		if (exprCtxt != NULL)
- 			econtext->ecxt_outertuple = exprCtxt->ecxt_outertuple;
- 
- 		/*
- 		 * Reset the runtime-key context so we don't leak memory as each outer
- 		 * tuple is scanned.  Note this assumes that we will recalculate *all*
- 		 * runtime keys on each call.
- 		 */
  		ResetExprContext(econtext);
- 	}
  
  	/*
! 	 * If we are doing runtime key calculations (ie, the index keys depend on
! 	 * data from an outer scan), compute the new key values.
  	 *
  	 * Array keys are also treated as runtime keys; note that if we return
  	 * with biss_RuntimeKeysReady still false, then there is an empty array
--- 108,133 ----
  /* ----------------------------------------------------------------
   *		ExecBitmapIndexReScan(node)
   *
!  *		Recalculates the values of any scan keys whose value depends on
!  *		information known at runtime, then rescans the indexed relation.
   * ----------------------------------------------------------------
   */
  void
  ExecBitmapIndexReScan(BitmapIndexScanState *node, ExprContext *exprCtxt)
  {
! 	ExprContext *econtext = node->biss_RuntimeContext;
  
+ 	/*
+ 	 * Reset the runtime-key context so we don't leak memory as each outer
+ 	 * tuple is scanned.  Note this assumes that we will recalculate *all*
+ 	 * runtime keys on each call.
+ 	 */
  	if (econtext)
  		ResetExprContext(econtext);
  
  	/*
! 	 * If we are doing runtime key calculations (ie, any of the index key
! 	 * values weren't simple Consts), compute the new key values.
  	 *
  	 * Array keys are also treated as runtime keys; note that if we return
  	 * with biss_RuntimeKeysReady still false, then there is an empty array
Index: src/backend/executor/nodeIndexscan.c
===================================================================
RCS file: /cvsroot/pgsql/src/backend/executor/nodeIndexscan.c,v
retrieving revision 1.139
diff -c -r1.139 nodeIndexscan.c
*** src/backend/executor/nodeIndexscan.c	26 Feb 2010 02:00:42 -0000	1.139
--- src/backend/executor/nodeIndexscan.c	12 Jul 2010 04:26:44 -0000
***************
*** 151,158 ****
  /* ----------------------------------------------------------------
   *		ExecIndexReScan(node)
   *
!  *		Recalculates the value of the scan keys whose value depends on
!  *		information known at runtime and rescans the indexed relation.
   *		Updating the scan key was formerly done separately in
   *		ExecUpdateIndexScanKeys. Integrating it into ReScan makes
   *		rescans of indices and relations/general streams more uniform.
--- 151,159 ----
  /* ----------------------------------------------------------------
   *		ExecIndexReScan(node)
   *
!  *		Recalculates the values of any scan keys whose value depends on
!  *		information known at runtime, then rescans the indexed relation.
!  *
   *		Updating the scan key was formerly done separately in
   *		ExecUpdateIndexScanKeys. Integrating it into ReScan makes
   *		rescans of indices and relations/general streams more uniform.
***************
*** 161,202 ****
  void
  ExecIndexReScan(IndexScanState *node, ExprContext *exprCtxt)
  {
- 	ExprContext *econtext;
- 
- 	econtext = node->iss_RuntimeContext;		/* context for runtime keys */
- 
- 	if (econtext)
- 	{
- 		/*
- 		 * If we are being passed an outer tuple, save it for runtime key
- 		 * calc.  We also need to link it into the "regular" per-tuple
- 		 * econtext, so it can be used during indexqualorig evaluations.
- 		 */
- 		if (exprCtxt != NULL)
- 		{
- 			ExprContext *stdecontext;
- 
- 			econtext->ecxt_outertuple = exprCtxt->ecxt_outertuple;
- 			stdecontext = node->ss.ps.ps_ExprContext;
- 			stdecontext->ecxt_outertuple = exprCtxt->ecxt_outertuple;
- 		}
- 
- 		/*
- 		 * Reset the runtime-key context so we don't leak memory as each outer
- 		 * tuple is scanned.  Note this assumes that we will recalculate *all*
- 		 * runtime keys on each call.
- 		 */
- 		ResetExprContext(econtext);
- 	}
- 
  	/*
! 	 * If we are doing runtime key calculations (ie, the index keys depend on
! 	 * data from an outer scan), compute the new key values
  	 */
  	if (node->iss_NumRuntimeKeys != 0)
  		ExecIndexEvalRuntimeKeys(econtext,
  								 node->iss_RuntimeKeys,
  								 node->iss_NumRuntimeKeys);
  	node->iss_RuntimeKeysReady = true;
  
  	/* reset index scan */
--- 162,183 ----
  void
  ExecIndexReScan(IndexScanState *node, ExprContext *exprCtxt)
  {
  	/*
! 	 * If we are doing runtime key calculations (ie, any of the index key
! 	 * values weren't simple Consts), compute the new key values.  But first,
! 	 * reset the context so we don't leak memory as each outer tuple is
! 	 * scanned.  Note this assumes that we will recalculate *all* runtime keys
! 	 * on each call.
  	 */
  	if (node->iss_NumRuntimeKeys != 0)
+ 	{
+ 		ExprContext *econtext = node->iss_RuntimeContext;
+ 
+ 		ResetExprContext(econtext);
  		ExecIndexEvalRuntimeKeys(econtext,
  								 node->iss_RuntimeKeys,
  								 node->iss_NumRuntimeKeys);
+ 	}
  	node->iss_RuntimeKeysReady = true;
  
  	/* reset index scan */
***************
*** 229,239 ****
  
  		/*
  		 * For each run-time key, extract the run-time expression and evaluate
! 		 * it with respect to the current outer tuple.	We then stick the
! 		 * result into the proper scan key.
  		 *
  		 * Note: the result of the eval could be a pass-by-ref value that's
! 		 * stored in the outer scan's tuple, not in
  		 * econtext->ecxt_per_tuple_memory.  We assume that the outer tuple
  		 * will stay put throughout our scan.  If this is wrong, we could copy
  		 * the result into our context explicitly, but I think that's not
--- 210,220 ----
  
  		/*
  		 * For each run-time key, extract the run-time expression and evaluate
! 		 * it with respect to the current context.  We then stick the result
! 		 * into the proper scan key.
  		 *
  		 * Note: the result of the eval could be a pass-by-ref value that's
! 		 * stored in some outer scan's tuple, not in
  		 * econtext->ecxt_per_tuple_memory.  We assume that the outer tuple
  		 * will stay put throughout our scan.  If this is wrong, we could copy
  		 * the result into our context explicitly, but I think that's not
Index: src/backend/executor/nodeNestloop.c
===================================================================
RCS file: /cvsroot/pgsql/src/backend/executor/nodeNestloop.c,v
retrieving revision 1.55
diff -c -r1.55 nodeNestloop.c
*** src/backend/executor/nodeNestloop.c	2 Jan 2010 16:57:44 -0000	1.55
--- src/backend/executor/nodeNestloop.c	12 Jul 2010 04:26:44 -0000
***************
*** 59,64 ****
--- 59,65 ----
  TupleTableSlot *
  ExecNestLoop(NestLoopState *node)
  {
+ 	NestLoop   *nl;
  	PlanState  *innerPlan;
  	PlanState  *outerPlan;
  	TupleTableSlot *outerTupleSlot;
***************
*** 66,77 ****
--- 67,80 ----
  	List	   *joinqual;
  	List	   *otherqual;
  	ExprContext *econtext;
+ 	ListCell   *lc;
  
  	/*
  	 * get information from the node
  	 */
  	ENL1_printf("getting info from node");
  
+ 	nl = (NestLoop *) node->js.ps.plan;
  	joinqual = node->js.joinqual;
  	otherqual = node->js.ps.qual;
  	outerPlan = outerPlanState(node);
***************
*** 134,149 ****
  			node->nl_MatchedOuter = false;
  
  			/*
! 			 * now rescan the inner plan
  			 */
! 			ENL1_printf("rescanning inner plan");
  
  			/*
! 			 * The scan key of the inner plan might depend on the current
! 			 * outer tuple (e.g. in index scans), that's why we pass our expr
! 			 * context.
  			 */
! 			ExecReScan(innerPlan, econtext);
  		}
  
  		/*
--- 137,169 ----
  			node->nl_MatchedOuter = false;
  
  			/*
! 			 * fetch the values of any outer Vars that must be passed to
! 			 * the inner scan, and store them in the appropriate PARAM_EXEC
! 			 * slots.
  			 */
! 			foreach(lc, nl->nestParams)
! 			{
! 				NestLoopParam *nlp = (NestLoopParam *) lfirst(lc);
! 				int			paramno = nlp->paramno;
! 				ParamExecData *prm;
! 
! 				prm = &(econtext->ecxt_param_exec_vals[paramno]);
! 				/* Param value should be an OUTER var */
! 				Assert(nlp->paramval->varno == OUTER);
! 				Assert(nlp->paramval->varattno > 0);
! 				prm->value = slot_getattr(outerTupleSlot,
! 										  nlp->paramval->varattno,
! 										  &(prm->isnull));
! 				/* Flag parameter value as changed */
! 				innerPlan->chgParam = bms_add_member(innerPlan->chgParam,
! 													 paramno);
! 			}
  
  			/*
! 			 * now rescan the inner plan
  			 */
! 			ENL1_printf("rescanning inner plan");
! 			ExecReScan(innerPlan, NULL);
  		}
  
  		/*
Index: src/backend/nodes/copyfuncs.c
===================================================================
RCS file: /cvsroot/pgsql/src/backend/nodes/copyfuncs.c,v
retrieving revision 1.464
diff -c -r1.464 copyfuncs.c
*** src/backend/nodes/copyfuncs.c	26 Feb 2010 02:00:43 -0000	1.464
--- src/backend/nodes/copyfuncs.c	12 Jul 2010 04:26:44 -0000
***************
*** 564,569 ****
--- 564,574 ----
  	 */
  	CopyJoinFields((Join *) from, (Join *) newnode);
  
+ 	/*
+ 	 * copy remainder of node
+ 	 */
+ 	COPY_NODE_FIELD(nestParams);
+ 
  	return newnode;
  }
  
***************
*** 845,850 ****
--- 850,869 ----
  }
  
  /*
+  * _copyNestLoopParam
+  */
+ static NestLoopParam *
+ _copyNestLoopParam(NestLoopParam *from)
+ {
+ 	NestLoopParam *newnode = makeNode(NestLoopParam);
+ 
+ 	COPY_SCALAR_FIELD(paramno);
+ 	COPY_NODE_FIELD(paramval);
+ 
+ 	return newnode;
+ }
+ 
+ /*
   * _copyPlanRowMark
   */
  static PlanRowMark *
***************
*** 3671,3676 ****
--- 3690,3698 ----
  		case T_Limit:
  			retval = _copyLimit(from);
  			break;
+ 		case T_NestLoopParam:
+ 			retval = _copyNestLoopParam(from);
+ 			break;
  		case T_PlanRowMark:
  			retval = _copyPlanRowMark(from);
  			break;
Index: src/backend/nodes/outfuncs.c
===================================================================
RCS file: /cvsroot/pgsql/src/backend/nodes/outfuncs.c,v
retrieving revision 1.385
diff -c -r1.385 outfuncs.c
*** src/backend/nodes/outfuncs.c	30 Mar 2010 21:58:10 -0000	1.385
--- src/backend/nodes/outfuncs.c	12 Jul 2010 04:26:44 -0000
***************
*** 517,522 ****
--- 517,524 ----
  	WRITE_NODE_TYPE("NESTLOOP");
  
  	_outJoinPlanInfo(str, (Join *) node);
+ 
+ 	WRITE_NODE_FIELD(nestParams);
  }
  
  static void
***************
*** 749,754 ****
--- 751,765 ----
  }
  
  static void
+ _outNestLoopParam(StringInfo str, NestLoopParam *node)
+ {
+ 	WRITE_NODE_TYPE("NESTLOOPPARAM");
+ 
+ 	WRITE_INT_FIELD(paramno);
+ 	WRITE_NODE_FIELD(paramval);
+ }
+ 
+ static void
  _outPlanRowMark(StringInfo str, PlanRowMark *node)
  {
  	WRITE_NODE_TYPE("PLANROWMARK");
***************
*** 1565,1570 ****
--- 1576,1583 ----
  	WRITE_BOOL_FIELD(hasPseudoConstantQuals);
  	WRITE_BOOL_FIELD(hasRecursion);
  	WRITE_INT_FIELD(wt_param_id);
+ 	WRITE_BITMAPSET_FIELD(curOuterRels);
+ 	WRITE_NODE_FIELD(curOuterParams);
  }
  
  static void
***************
*** 2562,2567 ****
--- 2575,2583 ----
  			case T_Limit:
  				_outLimit(str, obj);
  				break;
+ 			case T_NestLoopParam:
+ 				_outNestLoopParam(str, obj);
+ 				break;
  			case T_PlanRowMark:
  				_outPlanRowMark(str, obj);
  				break;
Index: src/backend/optimizer/plan/createplan.c
===================================================================
RCS file: /cvsroot/pgsql/src/backend/optimizer/plan/createplan.c,v
retrieving revision 1.275
diff -c -r1.275 createplan.c
*** src/backend/optimizer/plan/createplan.c	25 May 2010 17:44:41 -0000	1.275
--- src/backend/optimizer/plan/createplan.c	12 Jul 2010 04:26:44 -0000
***************
*** 28,33 ****
--- 28,34 ----
  #include "optimizer/planmain.h"
  #include "optimizer/predtest.h"
  #include "optimizer/restrictinfo.h"
+ #include "optimizer/subselect.h"
  #include "optimizer/tlist.h"
  #include "optimizer/var.h"
  #include "parser/parse_clause.h"
***************
*** 35,40 ****
--- 36,42 ----
  #include "utils/lsyscache.h"
  
  
+ static Plan *create_plan_recurse(PlannerInfo *root, Path *best_path);
  static Plan *create_scan_plan(PlannerInfo *root, Path *best_path);
  static List *build_relation_tlist(RelOptInfo *rel);
  static bool use_physical_tlist(PlannerInfo *root, RelOptInfo *rel);
***************
*** 72,78 ****
  					  Plan *outer_plan, Plan *inner_plan);
  static HashJoin *create_hashjoin_plan(PlannerInfo *root, HashPath *best_path,
  					 Plan *outer_plan, Plan *inner_plan);
! static List *fix_indexqual_references(List *indexquals, IndexPath *index_path);
  static List *get_switched_clauses(List *clauses, Relids outerrelids);
  static List *order_qual_clauses(PlannerInfo *root, List *clauses);
  static void copy_path_costsize(Plan *dest, Path *src);
--- 74,83 ----
  					  Plan *outer_plan, Plan *inner_plan);
  static HashJoin *create_hashjoin_plan(PlannerInfo *root, HashPath *best_path,
  					 Plan *outer_plan, Plan *inner_plan);
! static Node *replace_nestloop_params(PlannerInfo *root, Node *expr);
! static Node *replace_nestloop_params_mutator(Node *node, PlannerInfo *root);
! static List *fix_indexqual_references(PlannerInfo *root, IndexPath *index_path,
! 						 List *indexquals);
  static List *get_switched_clauses(List *clauses, Relids outerrelids);
  static List *order_qual_clauses(PlannerInfo *root, List *clauses);
  static void copy_path_costsize(Plan *dest, Path *src);
***************
*** 103,109 ****
  static BitmapAnd *make_bitmap_and(List *bitmapplans);
  static BitmapOr *make_bitmap_or(List *bitmapplans);
  static NestLoop *make_nestloop(List *tlist,
! 			  List *joinclauses, List *otherclauses,
  			  Plan *lefttree, Plan *righttree,
  			  JoinType jointype);
  static HashJoin *make_hashjoin(List *tlist,
--- 108,114 ----
  static BitmapAnd *make_bitmap_and(List *bitmapplans);
  static BitmapOr *make_bitmap_or(List *bitmapplans);
  static NestLoop *make_nestloop(List *tlist,
! 			  List *joinclauses, List *otherclauses, List *nestParams,
  			  Plan *lefttree, Plan *righttree,
  			  JoinType jointype);
  static HashJoin *make_hashjoin(List *tlist,
***************
*** 133,140 ****
  
  /*
   * create_plan
!  *	  Creates the access plan for a query by tracing backwards through the
!  *	  desired chain of pathnodes, starting at the node 'best_path'.  For
   *	  every pathnode found, we create a corresponding plan node containing
   *	  appropriate id, target list, and qualification information.
   *
--- 138,145 ----
  
  /*
   * create_plan
!  *	  Creates the access plan for a query by recursively processing the
!  *	  desired tree of pathnodes, starting at the node 'best_path'.  For
   *	  every pathnode found, we create a corresponding plan node containing
   *	  appropriate id, target list, and qualification information.
   *
***************
*** 151,156 ****
--- 156,184 ----
  {
  	Plan	   *plan;
  
+ 	/* Initialize this module's private workspace in PlannerInfo */
+ 	root->curOuterRels = NULL;
+ 	root->curOuterParams = NIL;
+ 
+ 	/* Recursively process the path tree */
+ 	plan = create_plan_recurse(root, best_path);
+ 
+ 	/* Check we successfully assigned all NestLoopParams to plan nodes */
+ 	if (root->curOuterParams != NIL)
+ 		elog(ERROR, "failed to assign all NestLoopParams to plan nodes");
+ 
+ 	return plan;
+ }
+ 
+ /*
+  * create_plan_recurse
+  *	  Recursive guts of create_plan().
+  */
+ static Plan *
+ create_plan_recurse(PlannerInfo *root, Path *best_path)
+ {
+ 	Plan	   *plan;
+ 
  	switch (best_path->pathtype)
  	{
  		case T_SeqScan:
***************
*** 477,485 ****
  	Plan	   *outer_plan;
  	Plan	   *inner_plan;
  	Plan	   *plan;
  
! 	outer_plan = create_plan(root, best_path->outerjoinpath);
! 	inner_plan = create_plan(root, best_path->innerjoinpath);
  
  	switch (best_path->path.pathtype)
  	{
--- 505,520 ----
  	Plan	   *outer_plan;
  	Plan	   *inner_plan;
  	Plan	   *plan;
+ 	Relids		saveOuterRels = root->curOuterRels;
  
! 	outer_plan = create_plan_recurse(root, best_path->outerjoinpath);
! 
! 	/* For a nestloop, include outer relids in curOuterRels for inner side */
! 	if (best_path->path.pathtype == T_NestLoop)
! 		root->curOuterRels = bms_union(root->curOuterRels,
! 								   best_path->outerjoinpath->parent->relids);
! 
! 	inner_plan = create_plan_recurse(root, best_path->innerjoinpath);
  
  	switch (best_path->path.pathtype)
  	{
***************
*** 496,501 ****
--- 531,540 ----
  												 inner_plan);
  			break;
  		case T_NestLoop:
+ 			/* Restore curOuterRels */
+ 			bms_free(root->curOuterRels);
+ 			root->curOuterRels = saveOuterRels;
+ 
  			plan = (Plan *) create_nestloop_plan(root,
  												 (NestPath *) best_path,
  												 outer_plan,
***************
*** 571,577 ****
  	{
  		Path	   *subpath = (Path *) lfirst(subpaths);
  
! 		subplans = lappend(subplans, create_plan(root, subpath));
  	}
  
  	plan = make_append(subplans, tlist);
--- 610,616 ----
  	{
  		Path	   *subpath = (Path *) lfirst(subpaths);
  
! 		subplans = lappend(subplans, create_plan_recurse(root, subpath));
  	}
  
  	plan = make_append(subplans, tlist);
***************
*** 616,622 ****
  	Material   *plan;
  	Plan	   *subplan;
  
! 	subplan = create_plan(root, best_path->subpath);
  
  	/* We don't want any excess columns in the materialized tuples */
  	disuse_physical_tlist(subplan, best_path->subpath);
--- 655,661 ----
  	Material   *plan;
  	Plan	   *subplan;
  
! 	subplan = create_plan_recurse(root, best_path->subpath);
  
  	/* We don't want any excess columns in the materialized tuples */
  	disuse_physical_tlist(subplan, best_path->subpath);
***************
*** 650,656 ****
  	int			groupColPos;
  	ListCell   *l;
  
! 	subplan = create_plan(root, best_path->subpath);
  
  	/* Done if we don't need to do any actual unique-ifying */
  	if (best_path->umethod == UNIQUE_PATH_NOOP)
--- 689,695 ----
  	int			groupColPos;
  	ListCell   *l;
  
! 	subplan = create_plan_recurse(root, best_path->subpath);
  
  	/* Done if we don't need to do any actual unique-ifying */
  	if (best_path->umethod == UNIQUE_PATH_NOOP)
***************
*** 904,910 ****
  	 * The executor needs a copy with the indexkey on the left of each clause
  	 * and with index attr numbers substituted for table ones.
  	 */
! 	fixed_indexquals = fix_indexqual_references(indexquals, best_path);
  
  	/*
  	 * If this is an innerjoin scan, the indexclauses will contain join
--- 943,949 ----
  	 * The executor needs a copy with the indexkey on the left of each clause
  	 * and with index attr numbers substituted for table ones.
  	 */
! 	fixed_indexquals = fix_indexqual_references(root, best_path, indexquals);
  
  	/*
  	 * If this is an innerjoin scan, the indexclauses will contain join
***************
*** 975,980 ****
--- 1014,1035 ----
  	/* Reduce RestrictInfo list to bare expressions; ignore pseudoconstants */
  	qpqual = extract_actual_clauses(qpqual, false);
  
+ 	/*
+ 	 * We have to replace any outer-relation variables with nestloop params
+ 	 * in the indexqualorig and qpqual expressions.  A bit annoying to have to
+ 	 * do this separately from the processing in fix_indexqual_references ---
+ 	 * rethink this when generalizing the inner indexscan support.  But note
+ 	 * we can't really do this earlier because it'd break the comparisons to
+ 	 * predicates above ... (or would it?  Those wouldn't have outer refs)
+ 	 */
+ 	if (best_path->isjoininner)
+ 	{
+ 		stripped_indexquals = (List *)
+ 			replace_nestloop_params(root, (Node *) stripped_indexquals);
+ 		qpqual = (List *)
+ 			replace_nestloop_params(root, (Node *) qpqual);
+ 	}
+ 
  	/* Finally ready to build the plan node */
  	scan_plan = make_indexscan(tlist,
  							   qpqual,
***************
*** 1267,1272 ****
--- 1322,1338 ----
  				*indexqual = lappend(*indexqual, pred);
  			}
  		}
+ 		/*
+ 		 * Replace outer-relation variables with nestloop params, but only
+ 		 * after doing the above comparisons to index predicates.
+ 		 */
+ 		if (ipath->isjoininner)
+ 		{
+ 			*qual = (List *)
+ 				replace_nestloop_params(root, (Node *) *qual);
+ 			*indexqual = (List *)
+ 				replace_nestloop_params(root, (Node *) *indexqual);
+ 		}
  	}
  	else
  	{
***************
*** 1572,1582 ****
  					 Plan *outer_plan,
  					 Plan *inner_plan)
  {
  	List	   *tlist = build_relation_tlist(best_path->path.parent);
  	List	   *joinrestrictclauses = best_path->joinrestrictinfo;
  	List	   *joinclauses;
  	List	   *otherclauses;
! 	NestLoop   *join_plan;
  
  	/*
  	 * If the inner path is a nestloop inner indexscan, it might be using some
--- 1638,1653 ----
  					 Plan *outer_plan,
  					 Plan *inner_plan)
  {
+ 	NestLoop   *join_plan;
  	List	   *tlist = build_relation_tlist(best_path->path.parent);
  	List	   *joinrestrictclauses = best_path->joinrestrictinfo;
  	List	   *joinclauses;
  	List	   *otherclauses;
! 	Relids		outerrelids;
! 	List	   *nestParams;
! 	ListCell   *cell;
! 	ListCell   *prev;
! 	ListCell   *next;
  
  	/*
  	 * If the inner path is a nestloop inner indexscan, it might be using some
***************
*** 1605,1613 ****
--- 1676,1707 ----
  		otherclauses = NIL;
  	}
  
+ 	/*
+ 	 * Identify any nestloop parameters that should be supplied by this join
+ 	 * node, and move them from root->curOuterParams to the nestParams list.
+ 	 */
+ 	outerrelids = best_path->outerjoinpath->parent->relids;
+ 	nestParams = NIL;
+ 	prev = NULL;
+ 	for (cell = list_head(root->curOuterParams); cell; cell = next)
+ 	{
+ 		NestLoopParam *nlp = (NestLoopParam *) lfirst(cell);
+ 
+ 		next = lnext(cell);
+ 		if (bms_is_member(nlp->paramval->varno, outerrelids))
+ 		{
+ 			root->curOuterParams = list_delete_cell(root->curOuterParams,
+ 													cell, prev);
+ 			nestParams = lappend(nestParams, nlp);
+ 		}
+ 		else
+ 			prev = cell;
+ 	}
+ 
  	join_plan = make_nestloop(tlist,
  							  joinclauses,
  							  otherclauses,
+ 							  nestParams,
  							  outer_plan,
  							  inner_plan,
  							  best_path->jointype);
***************
*** 2016,2027 ****
   *****************************************************************************/
  
  /*
   * fix_indexqual_references
   *	  Adjust indexqual clauses to the form the executor's indexqual
   *	  machinery needs.
   *
!  * We have three tasks here:
   *	* Remove RestrictInfo nodes from the input clauses.
   *	* Index keys must be represented by Var nodes with varattno set to the
   *	  index's attribute number, not the attribute number in the original rel.
   *	* If the index key is on the right, commute the clause to put it on the
--- 2110,2181 ----
   *****************************************************************************/
  
  /*
+  * replace_nestloop_params
+  *	  Replace outer-relation Vars in the given expression with nestloop Params
+  *
+  * All Vars belonging to the relation(s) identified by root->curOuterRels
+  * are replaced by Params, and entries are added to root->curOuterParams if
+  * not already present.
+  */
+ static Node *
+ replace_nestloop_params(PlannerInfo *root, Node *expr)
+ {
+ 	/* No setup needed for tree walk, so away we go */
+ 	return replace_nestloop_params_mutator(expr, root);
+ }
+ 
+ static Node *
+ replace_nestloop_params_mutator(Node *node, PlannerInfo *root)
+ {
+ 	if (node == NULL)
+ 		return NULL;
+ 	if (IsA(node, Var))
+ 	{
+ 		Var	   *var = (Var *) node;
+ 		Param  *param;
+ 		NestLoopParam *nlp;
+ 		ListCell *lc;
+ 
+ 		/* Upper-level Vars should be long gone at this point */
+ 		Assert(var->varlevelsup == 0);
+ 		/* If not to be replaced, we can just return the Var unmodified */
+ 		if (!bms_is_member(var->varno, root->curOuterRels))
+ 			return node;
+ 		/* Create a Param representing the Var */
+ 		param = assign_nestloop_param(root, var);
+ 		/* Is this param already listed in root->curOuterParams? */
+ 		foreach(lc, root->curOuterParams)
+ 		{
+ 			nlp = (NestLoopParam *) lfirst(lc);
+ 			if (nlp->paramno == param->paramid)
+ 			{
+ 				Assert(equal(var, nlp->paramval));
+ 				/* Present, so we can just return the Param */
+ 				return (Node *) param;
+ 			}
+ 		}
+ 		/* No, so add it */
+ 		nlp = makeNode(NestLoopParam);
+ 		nlp->paramno = param->paramid;
+ 		nlp->paramval = var;
+ 		root->curOuterParams = lappend(root->curOuterParams, nlp);
+ 		/* And return the replacement Param */
+ 		return (Node *) param;
+ 	}
+ 	return expression_tree_mutator(node,
+ 								   replace_nestloop_params_mutator,
+ 								   (void *) root);
+ }
+ 
+ /*
   * fix_indexqual_references
   *	  Adjust indexqual clauses to the form the executor's indexqual
   *	  machinery needs.
   *
!  * We have four tasks here:
   *	* Remove RestrictInfo nodes from the input clauses.
+  *	* Replace any outer-relation Var nodes with nestloop Params.
+  *	  (XXX eventually, that responsibility should go elsewhere?)
   *	* Index keys must be represented by Var nodes with varattno set to the
   *	  index's attribute number, not the attribute number in the original rel.
   *	* If the index key is on the right, commute the clause to put it on the
***************
*** 2033,2039 ****
   * two separate copies of the subplan tree, or things will go awry).
   */
  static List *
! fix_indexqual_references(List *indexquals, IndexPath *index_path)
  {
  	IndexOptInfo *index = index_path->indexinfo;
  	List	   *fixed_indexquals;
--- 2187,2194 ----
   * two separate copies of the subplan tree, or things will go awry).
   */
  static List *
! fix_indexqual_references(PlannerInfo *root, IndexPath *index_path,
! 						 List *indexquals)
  {
  	IndexOptInfo *index = index_path->indexinfo;
  	List	   *fixed_indexquals;
***************
*** 2041,2066 ****
  
  	fixed_indexquals = NIL;
  
- 	/*
- 	 * For each qual clause, commute if needed to put the indexkey operand on
- 	 * the left, and then fix its varattno.  (We do not need to change the
- 	 * other side of the clause.)
- 	 */
  	foreach(l, indexquals)
  	{
  		RestrictInfo *rinfo = (RestrictInfo *) lfirst(l);
! 		Expr	   *clause;
  
  		Assert(IsA(rinfo, RestrictInfo));
  
  		/*
! 		 * Make a copy that will become the fixed clause.
  		 *
! 		 * We used to try to do a shallow copy here, but that fails if there
! 		 * is a subplan in the arguments of the opclause.  So just do a full
! 		 * copy.
  		 */
! 		clause = (Expr *) copyObject((Node *) rinfo->clause);
  
  		if (IsA(clause, OpExpr))
  		{
--- 2196,2215 ----
  
  	fixed_indexquals = NIL;
  
  	foreach(l, indexquals)
  	{
  		RestrictInfo *rinfo = (RestrictInfo *) lfirst(l);
! 		Node	   *clause;
  
  		Assert(IsA(rinfo, RestrictInfo));
  
  		/*
! 		 * Replace any outer-relation variables with nestloop params.
  		 *
! 		 * This also makes a copy of the clause, so it's safe to modify it
! 		 * in-place below.
  		 */
! 		clause = replace_nestloop_params(root, (Node *) rinfo->clause);
  
  		if (IsA(clause, OpExpr))
  		{
***************
*** 2765,2770 ****
--- 2914,2920 ----
  make_nestloop(List *tlist,
  			  List *joinclauses,
  			  List *otherclauses,
+ 			  List *nestParams,
  			  Plan *lefttree,
  			  Plan *righttree,
  			  JoinType jointype)
***************
*** 2779,2784 ****
--- 2929,2935 ----
  	plan->righttree = righttree;
  	node->join.jointype = jointype;
  	node->join.joinqual = joinclauses;
+ 	node->nestParams = nestParams;
  
  	return node;
  }
Index: src/backend/optimizer/plan/setrefs.c
===================================================================
RCS file: /cvsroot/pgsql/src/backend/optimizer/plan/setrefs.c,v
retrieving revision 1.160
diff -c -r1.160 setrefs.c
*** src/backend/optimizer/plan/setrefs.c	26 Feb 2010 02:00:45 -0000	1.160
--- src/backend/optimizer/plan/setrefs.c	12 Jul 2010 04:26:44 -0000
***************
*** 89,96 ****
  static Node *fix_scan_expr_mutator(Node *node, fix_scan_expr_context *context);
  static bool fix_scan_expr_walker(Node *node, fix_scan_expr_context *context);
  static void set_join_references(PlannerGlobal *glob, Join *join, int rtoffset);
- static void set_inner_join_references(PlannerGlobal *glob, Plan *inner_plan,
- 						  indexed_tlist *outer_itlist);
  static void set_upper_references(PlannerGlobal *glob, Plan *plan, int rtoffset);
  static void set_dummy_tlist_references(Plan *plan, int rtoffset);
  static indexed_tlist *build_tlist_index(List *tlist);
--- 89,94 ----
***************
*** 878,889 ****
  		Assert(var->varlevelsup == 0);
  
  		/*
! 		 * We should not see any Vars marked INNER, but in a nestloop inner
! 		 * scan there could be OUTER Vars.	Leave them alone.
  		 */
  		Assert(var->varno != INNER);
! 		if (var->varno > 0 && var->varno != OUTER)
! 			var->varno += context->rtoffset;
  		if (var->varnoold > 0)
  			var->varnoold += context->rtoffset;
  		return (Node *) var;
--- 876,886 ----
  		Assert(var->varlevelsup == 0);
  
  		/*
! 		 * We should not see any Vars marked INNER or OUTER.
  		 */
  		Assert(var->varno != INNER);
! 		Assert(var->varno != OUTER);
! 		var->varno += context->rtoffset;
  		if (var->varnoold > 0)
  			var->varnoold += context->rtoffset;
  		return (Node *) var;
***************
*** 927,936 ****
   *	  values to the result domain number of either the corresponding outer
   *	  or inner join tuple item.  Also perform opcode lookup for these
   *	  expressions. and add regclass OIDs to glob->relationOids.
-  *
-  * In the case of a nestloop with inner indexscan, we will also need to
-  * apply the same transformation to any outer vars appearing in the
-  * quals of the child indexscan.  set_inner_join_references does that.
   */
  static void
  set_join_references(PlannerGlobal *glob, Join *join, int rtoffset)
--- 924,929 ----
***************
*** 966,973 ****
  	/* Now do join-type-specific stuff */
  	if (IsA(join, NestLoop))
  	{
! 		/* This processing is split out to handle possible recursion */
! 		set_inner_join_references(glob, inner_plan, outer_itlist);
  	}
  	else if (IsA(join, MergeJoin))
  	{
--- 959,976 ----
  	/* Now do join-type-specific stuff */
  	if (IsA(join, NestLoop))
  	{
! 		NestLoop   *nl = (NestLoop *) join;
! 		ListCell   *lc;
! 
! 		foreach(lc, nl->nestParams)
! 		{
! 			NestLoopParam *nlp = (NestLoopParam *) lfirst(lc);
! 
! 			nlp->paramval = (Var *) fix_upper_expr(glob,
! 												   (Node *) nlp->paramval,
! 												   outer_itlist,
! 												   rtoffset);
! 		}
  	}
  	else if (IsA(join, MergeJoin))
  	{
***************
*** 997,1189 ****
  }
  
  /*
-  * set_inner_join_references
-  *		Handle join references appearing in an inner indexscan's quals
-  *
-  * To handle bitmap-scan plan trees, we have to be able to recurse down
-  * to the bottom BitmapIndexScan nodes; likewise, appendrel indexscans
-  * require recursing through Append nodes.	This is split out as a separate
-  * function so that it can recurse.
-  *
-  * Note we do *not* apply any rtoffset for non-join Vars; this is because
-  * the quals will be processed again by fix_scan_expr when the set_plan_refs
-  * recursion reaches the inner indexscan, and so we'd have done it twice.
-  */
- static void
- set_inner_join_references(PlannerGlobal *glob, Plan *inner_plan,
- 						  indexed_tlist *outer_itlist)
- {
- 	if (IsA(inner_plan, IndexScan))
- 	{
- 		/*
- 		 * An index is being used to reduce the number of tuples scanned in
- 		 * the inner relation.	If there are join clauses being used with the
- 		 * index, we must update their outer-rel var nodes to refer to the
- 		 * outer side of the join.
- 		 */
- 		IndexScan  *innerscan = (IndexScan *) inner_plan;
- 		List	   *indexqualorig = innerscan->indexqualorig;
- 
- 		/* No work needed if indexqual refers only to its own rel... */
- 		if (NumRelids((Node *) indexqualorig) > 1)
- 		{
- 			Index		innerrel = innerscan->scan.scanrelid;
- 
- 			/* only refs to outer vars get changed in the inner qual */
- 			innerscan->indexqualorig = fix_join_expr(glob,
- 													 indexqualorig,
- 													 outer_itlist,
- 													 NULL,
- 													 innerrel,
- 													 0);
- 			innerscan->indexqual = fix_join_expr(glob,
- 												 innerscan->indexqual,
- 												 outer_itlist,
- 												 NULL,
- 												 innerrel,
- 												 0);
- 
- 			/*
- 			 * We must fix the inner qpqual too, if it has join clauses (this
- 			 * could happen if special operators are involved: some indexquals
- 			 * may get rechecked as qpquals).
- 			 */
- 			if (NumRelids((Node *) inner_plan->qual) > 1)
- 				inner_plan->qual = fix_join_expr(glob,
- 												 inner_plan->qual,
- 												 outer_itlist,
- 												 NULL,
- 												 innerrel,
- 												 0);
- 		}
- 	}
- 	else if (IsA(inner_plan, BitmapIndexScan))
- 	{
- 		/*
- 		 * Same, but index is being used within a bitmap plan.
- 		 */
- 		BitmapIndexScan *innerscan = (BitmapIndexScan *) inner_plan;
- 		List	   *indexqualorig = innerscan->indexqualorig;
- 
- 		/* No work needed if indexqual refers only to its own rel... */
- 		if (NumRelids((Node *) indexqualorig) > 1)
- 		{
- 			Index		innerrel = innerscan->scan.scanrelid;
- 
- 			/* only refs to outer vars get changed in the inner qual */
- 			innerscan->indexqualorig = fix_join_expr(glob,
- 													 indexqualorig,
- 													 outer_itlist,
- 													 NULL,
- 													 innerrel,
- 													 0);
- 			innerscan->indexqual = fix_join_expr(glob,
- 												 innerscan->indexqual,
- 												 outer_itlist,
- 												 NULL,
- 												 innerrel,
- 												 0);
- 			/* no need to fix inner qpqual */
- 			Assert(inner_plan->qual == NIL);
- 		}
- 	}
- 	else if (IsA(inner_plan, BitmapHeapScan))
- 	{
- 		/*
- 		 * The inner side is a bitmap scan plan.  Fix the top node, and
- 		 * recurse to get the lower nodes.
- 		 *
- 		 * Note: create_bitmap_scan_plan removes clauses from bitmapqualorig
- 		 * if they are duplicated in qpqual, so must test these independently.
- 		 */
- 		BitmapHeapScan *innerscan = (BitmapHeapScan *) inner_plan;
- 		Index		innerrel = innerscan->scan.scanrelid;
- 		List	   *bitmapqualorig = innerscan->bitmapqualorig;
- 
- 		/* only refs to outer vars get changed in the inner qual */
- 		if (NumRelids((Node *) bitmapqualorig) > 1)
- 			innerscan->bitmapqualorig = fix_join_expr(glob,
- 													  bitmapqualorig,
- 													  outer_itlist,
- 													  NULL,
- 													  innerrel,
- 													  0);
- 
- 		/*
- 		 * We must fix the inner qpqual too, if it has join clauses (this
- 		 * could happen if special operators are involved: some indexquals may
- 		 * get rechecked as qpquals).
- 		 */
- 		if (NumRelids((Node *) inner_plan->qual) > 1)
- 			inner_plan->qual = fix_join_expr(glob,
- 											 inner_plan->qual,
- 											 outer_itlist,
- 											 NULL,
- 											 innerrel,
- 											 0);
- 
- 		/* Now recurse */
- 		set_inner_join_references(glob, inner_plan->lefttree, outer_itlist);
- 	}
- 	else if (IsA(inner_plan, BitmapAnd))
- 	{
- 		/* All we need do here is recurse */
- 		BitmapAnd  *innerscan = (BitmapAnd *) inner_plan;
- 		ListCell   *l;
- 
- 		foreach(l, innerscan->bitmapplans)
- 		{
- 			set_inner_join_references(glob, (Plan *) lfirst(l), outer_itlist);
- 		}
- 	}
- 	else if (IsA(inner_plan, BitmapOr))
- 	{
- 		/* All we need do here is recurse */
- 		BitmapOr   *innerscan = (BitmapOr *) inner_plan;
- 		ListCell   *l;
- 
- 		foreach(l, innerscan->bitmapplans)
- 		{
- 			set_inner_join_references(glob, (Plan *) lfirst(l), outer_itlist);
- 		}
- 	}
- 	else if (IsA(inner_plan, TidScan))
- 	{
- 		TidScan    *innerscan = (TidScan *) inner_plan;
- 		Index		innerrel = innerscan->scan.scanrelid;
- 
- 		innerscan->tidquals = fix_join_expr(glob,
- 											innerscan->tidquals,
- 											outer_itlist,
- 											NULL,
- 											innerrel,
- 											0);
- 	}
- 	else if (IsA(inner_plan, Append))
- 	{
- 		/*
- 		 * The inner side is an append plan.  Recurse to see if it contains
- 		 * indexscans that need to be fixed.
- 		 */
- 		Append	   *appendplan = (Append *) inner_plan;
- 		ListCell   *l;
- 
- 		foreach(l, appendplan->appendplans)
- 		{
- 			set_inner_join_references(glob, (Plan *) lfirst(l), outer_itlist);
- 		}
- 	}
- 	else if (IsA(inner_plan, Result))
- 	{
- 		/* Recurse through a gating Result node (similar to Append case) */
- 		Result	   *result = (Result *) inner_plan;
- 
- 		if (result->plan.lefttree)
- 			set_inner_join_references(glob, result->plan.lefttree, outer_itlist);
- 	}
- }
- 
- /*
   * set_upper_references
   *	  Update the targetlist and quals of an upper-level plan node
   *	  to refer to the tuples returned by its lefttree subplan.
--- 1000,1005 ----
***************
*** 1532,1554 ****
   *
   * This is used in two different scenarios: a normal join clause, where
   * all the Vars in the clause *must* be replaced by OUTER or INNER references;
!  * and an indexscan being used on the inner side of a nestloop join.
!  * In the latter case we want to replace the outer-relation Vars by OUTER
!  * references, while Vars of the inner relation should be adjusted by rtoffset.
!  * (We also implement RETURNING clause fixup using this second scenario.)
   *
   * For a normal join, acceptable_rel should be zero so that any failure to
!  * match a Var will be reported as an error.  For the indexscan case,
!  * pass inner_itlist = NULL and acceptable_rel = the (not-offseted-yet) ID
!  * of the inner relation.
   *
   * 'clauses' is the targetlist or list of join clauses
   * 'outer_itlist' is the indexed target list of the outer join relation
   * 'inner_itlist' is the indexed target list of the inner join relation,
   *		or NULL
   * 'acceptable_rel' is either zero or the rangetable index of a relation
!  *		whose Vars may appear in the clause without provoking an error.
!  * 'rtoffset' is what to add to varno for Vars of acceptable_rel.
   *
   * Returns the new expression tree.  The original clause structure is
   * not modified.
--- 1348,1368 ----
   *
   * This is used in two different scenarios: a normal join clause, where
   * all the Vars in the clause *must* be replaced by OUTER or INNER references;
!  * and a RETURNING clause, which may contain both Vars of the target relation
!  * and Vars of other relations.  In the latter case we want to replace the
!  * other-relation Vars by OUTER references, while leaving target Vars alone.
   *
   * For a normal join, acceptable_rel should be zero so that any failure to
!  * match a Var will be reported as an error.  For the RETURNING case, pass
!  * inner_itlist = NULL and acceptable_rel = the ID of the target relation.
   *
   * 'clauses' is the targetlist or list of join clauses
   * 'outer_itlist' is the indexed target list of the outer join relation
   * 'inner_itlist' is the indexed target list of the inner join relation,
   *		or NULL
   * 'acceptable_rel' is either zero or the rangetable index of a relation
!  *		whose Vars may appear in the clause without provoking an error
!  * 'rtoffset': how much to increment varnoold by
   *
   * Returns the new expression tree.  The original clause structure is
   * not modified.
***************
*** 1603,1610 ****
  		if (var->varno == context->acceptable_rel)
  		{
  			var = copyVar(var);
! 			var->varno += context->rtoffset;
! 			var->varnoold += context->rtoffset;
  			return (Node *) var;
  		}
  
--- 1417,1424 ----
  		if (var->varno == context->acceptable_rel)
  		{
  			var = copyVar(var);
! 			if (var->varnoold > 0)
! 				var->varnoold += context->rtoffset;
  			return (Node *) var;
  		}
  
***************
*** 1783,1789 ****
  
  	/*
  	 * We can perform the desired Var fixup by abusing the fix_join_expr
! 	 * machinery that normally handles inner indexscan fixup.  We search the
  	 * top plan's targetlist for Vars of non-result relations, and use
  	 * fix_join_expr to convert RETURNING Vars into references to those tlist
  	 * entries, while leaving result-rel Vars as-is.
--- 1597,1603 ----
  
  	/*
  	 * We can perform the desired Var fixup by abusing the fix_join_expr
! 	 * machinery that formerly handled inner indexscan fixup.  We search the
  	 * top plan's targetlist for Vars of non-result relations, and use
  	 * fix_join_expr to convert RETURNING Vars into references to those tlist
  	 * entries, while leaving result-rel Vars as-is.
Index: src/backend/optimizer/plan/subselect.c
===================================================================
RCS file: /cvsroot/pgsql/src/backend/optimizer/plan/subselect.c,v
retrieving revision 1.162
diff -c -r1.162 subselect.c
*** src/backend/optimizer/plan/subselect.c	19 Apr 2010 00:55:25 -0000	1.162
--- src/backend/optimizer/plan/subselect.c	12 Jul 2010 04:26:44 -0000
***************
*** 83,112 ****
  
  
  /*
!  * Generate a Param node to replace the given Var,
!  * which is expected to have varlevelsup > 0 (ie, it is not local).
   */
! static Param *
! replace_outer_var(PlannerInfo *root, Var *var)
  {
- 	Param	   *retval;
  	ListCell   *ppl;
  	PlannerParamItem *pitem;
  	Index		abslevel;
  	int			i;
  
- 	Assert(var->varlevelsup > 0 && var->varlevelsup < root->query_level);
  	abslevel = root->query_level - var->varlevelsup;
  
! 	/*
! 	 * If there's already a paramlist entry for this same Var, just use it.
! 	 * NOTE: in sufficiently complex querytrees, it is possible for the same
! 	 * varno/abslevel to refer to different RTEs in different parts of the
! 	 * parsetree, so that different fields might end up sharing the same Param
! 	 * number.	As long as we check the vartype/typmod as well, I believe that
! 	 * this sort of aliasing will cause no trouble.  The correct field should
! 	 * get stored into the Param slot at execution in each part of the tree.
! 	 */
  	i = 0;
  	foreach(ppl, root->glob->paramlist)
  	{
--- 83,102 ----
  
  
  /*
!  * Select a PARAM_EXEC number to identify the given Var.
!  * If the Var already has a param slot, return that one.
   */
! static int
! assign_param_for_var(PlannerInfo *root, Var *var)
  {
  	ListCell   *ppl;
  	PlannerParamItem *pitem;
  	Index		abslevel;
  	int			i;
  
  	abslevel = root->query_level - var->varlevelsup;
  
! 	/* If there's already a paramlist entry for this same Var, just use it */
  	i = 0;
  	foreach(ppl, root->glob->paramlist)
  	{
***************
*** 119,142 ****
  				pvar->varattno == var->varattno &&
  				pvar->vartype == var->vartype &&
  				pvar->vartypmod == var->vartypmod)
! 				break;
  		}
  		i++;
  	}
  
! 	if (!ppl)
! 	{
! 		/* Nope, so make a new one */
! 		var = (Var *) copyObject(var);
! 		var->varlevelsup = 0;
! 
! 		pitem = makeNode(PlannerParamItem);
! 		pitem->item = (Node *) var;
! 		pitem->abslevel = abslevel;
  
! 		root->glob->paramlist = lappend(root->glob->paramlist, pitem);
! 		/* i is already the correct index for the new item */
! 	}
  
  	retval = makeNode(Param);
  	retval->paramkind = PARAM_EXEC;
--- 109,184 ----
  				pvar->varattno == var->varattno &&
  				pvar->vartype == var->vartype &&
  				pvar->vartypmod == var->vartypmod)
! 				return i;
  		}
  		i++;
  	}
  
! 	/* Nope, so make a new one */
! 	var = (Var *) copyObject(var);
! 	var->varlevelsup = 0;
  
! 	pitem = makeNode(PlannerParamItem);
! 	pitem->item = (Node *) var;
! 	pitem->abslevel = abslevel;
! 
! 	root->glob->paramlist = lappend(root->glob->paramlist, pitem);
! 
! 	/* i is already the correct list index for the new item */
! 	return i;
! }
! 
! /*
!  * Generate a Param node to replace the given Var,
!  * which is expected to have varlevelsup > 0 (ie, it is not local).
!  */
! static Param *
! replace_outer_var(PlannerInfo *root, Var *var)
! {
! 	Param	   *retval;
! 	int			i;
! 
! 	Assert(var->varlevelsup > 0 && var->varlevelsup < root->query_level);
! 
! 	/*
! 	 * Find the Var in root->glob->paramlist, or add it if not present.
! 	 *
! 	 * NOTE: in sufficiently complex querytrees, it is possible for the same
! 	 * varno/abslevel to refer to different RTEs in different parts of the
! 	 * parsetree, so that different fields might end up sharing the same Param
! 	 * number.	As long as we check the vartype/typmod as well, I believe that
! 	 * this sort of aliasing will cause no trouble.  The correct field should
! 	 * get stored into the Param slot at execution in each part of the tree.
! 	 */
! 	i = assign_param_for_var(root, var);
! 
! 	retval = makeNode(Param);
! 	retval->paramkind = PARAM_EXEC;
! 	retval->paramid = i;
! 	retval->paramtype = var->vartype;
! 	retval->paramtypmod = var->vartypmod;
! 	retval->location = -1;
! 
! 	return retval;
! }
! 
! /*
!  * Generate a Param node to replace the given Var, which will be supplied
!  * from an upper NestLoop join node.
!  *
!  * Because we allow nestloop and subquery Params to alias each other,
!  * this is effectively the same as replace_outer_var, except that we expect
!  * the Var to be local to the current query level.
!  */
! Param *
! assign_nestloop_param(PlannerInfo *root, Var *var)
! {
! 	Param	   *retval;
! 	int			i;
! 
! 	Assert(var->varlevelsup == 0);
! 
! 	i = assign_param_for_var(root, var);
  
  	retval = makeNode(Param);
  	retval->paramkind = PARAM_EXEC;
***************
*** 1773,1780 ****
  	 *
  	 * Note: this is a bit overly generous since some parameters of upper
  	 * query levels might belong to query subtrees that don't include this
! 	 * query.  However, valid_params is only a debugging crosscheck, so it
! 	 * doesn't seem worth expending lots of cycles to try to be exact.
  	 */
  	valid_params = bms_copy(initSetParam);
  	paramid = 0;
--- 1815,1823 ----
  	 *
  	 * Note: this is a bit overly generous since some parameters of upper
  	 * query levels might belong to query subtrees that don't include this
! 	 * query, or might be nestloop params that won't be passed down at all.
! 	 * However, valid_params is only a debugging crosscheck, so it doesn't
! 	 * seem worth expending lots of cycles to try to be exact.
  	 */
  	valid_params = bms_copy(initSetParam);
  	paramid = 0;
***************
*** 1849,1854 ****
--- 1892,1899 ----
  {
  	finalize_primnode_context context;
  	int			locally_added_param;
+ 	Bitmapset  *nestloop_params;
+ 	Bitmapset  *child_params;
  
  	if (plan == NULL)
  		return NULL;
***************
*** 1856,1861 ****
--- 1901,1907 ----
  	context.root = root;
  	context.paramids = NULL;	/* initialize set to empty */
  	locally_added_param = -1;	/* there isn't one */
+ 	nestloop_params = NULL;		/* there aren't any */
  
  	/*
  	 * When we call finalize_primnode, context.paramids sets are automatically
***************
*** 2056,2063 ****
  			break;
  
  		case T_NestLoop:
! 			finalize_primnode((Node *) ((Join *) plan)->joinqual,
! 							  &context);
  			break;
  
  		case T_MergeJoin:
--- 2102,2121 ----
  			break;
  
  		case T_NestLoop:
! 			{
! 				ListCell   *l;
! 
! 				finalize_primnode((Node *) ((Join *) plan)->joinqual,
! 								  &context);
! 				/* collect set of params that will be passed to right child */
! 				foreach(l, ((NestLoop *) plan)->nestParams)
! 				{
! 					NestLoopParam *nlp = (NestLoopParam *) lfirst(l);
! 
! 					nestloop_params = bms_add_member(nestloop_params,
! 													 nlp->paramno);
! 				}
! 			}
  			break;
  
  		case T_MergeJoin:
***************
*** 2120,2136 ****
  	}
  
  	/* Process left and right child plans, if any */
! 	context.paramids = bms_add_members(context.paramids,
! 									   finalize_plan(root,
! 													 plan->lefttree,
! 													 valid_params,
! 													 scan_params));
! 
! 	context.paramids = bms_add_members(context.paramids,
! 									   finalize_plan(root,
! 													 plan->righttree,
! 													 valid_params,
! 													 scan_params));
  
  	/*
  	 * Any locally generated parameter doesn't count towards its generating
--- 2178,2209 ----
  	}
  
  	/* Process left and right child plans, if any */
! 	child_params = finalize_plan(root,
! 								 plan->lefttree,
! 								 valid_params,
! 								 scan_params);
! 	context.paramids = bms_add_members(context.paramids, child_params);
! 
! 	if (nestloop_params)
! 	{
! 		/* right child can reference nestloop_params as well as valid_params */
! 		child_params = finalize_plan(root,
! 									 plan->righttree,
! 									 bms_union(nestloop_params, valid_params),
! 									 scan_params);
! 		/* ... and they don't count as parameters used at my level */
! 		child_params = bms_difference(child_params, nestloop_params);
! 		bms_free(nestloop_params);
! 	}
! 	else
! 	{
! 		/* easy case */
! 		child_params = finalize_plan(root,
! 									 plan->righttree,
! 									 valid_params,
! 									 scan_params);
! 	}
! 	context.paramids = bms_add_members(context.paramids, child_params);
  
  	/*
  	 * Any locally generated parameter doesn't count towards its generating
Index: src/include/nodes/nodes.h
===================================================================
RCS file: /cvsroot/pgsql/src/include/nodes/nodes.h,v
retrieving revision 1.234
diff -c -r1.234 nodes.h
*** src/include/nodes/nodes.h	28 Mar 2010 22:59:33 -0000	1.234
--- src/include/nodes/nodes.h	12 Jul 2010 04:26:44 -0000
***************
*** 74,79 ****
--- 74,80 ----
  	T_LockRows,
  	T_Limit,
  	/* these aren't subclasses of Plan: */
+ 	T_NestLoopParam,
  	T_PlanRowMark,
  	T_PlanInvalItem,
  
Index: src/include/nodes/plannodes.h
===================================================================
RCS file: /cvsroot/pgsql/src/include/nodes/plannodes.h,v
retrieving revision 1.117
diff -c -r1.117 plannodes.h
*** src/include/nodes/plannodes.h	26 Feb 2010 02:01:25 -0000	1.117
--- src/include/nodes/plannodes.h	12 Jul 2010 04:26:44 -0000
***************
*** 432,444 ****
--- 432,457 ----
  
  /* ----------------
   *		nest loop join node
+  *
+  * The nestParams list identifies any executor Params that must be passed
+  * into execution of the inner subplan carrying values from the current row
+  * of the outer subplan.  Currently we restrict these values to be simple
+  * Vars, but perhaps someday that'd be worth relaxing.
   * ----------------
   */
  typedef struct NestLoop
  {
  	Join		join;
+ 	List	   *nestParams;		/* list of NestLoopParam nodes */
  } NestLoop;
  
+ typedef struct NestLoopParam
+ {
+ 	NodeTag		type;
+ 	int			paramno;		/* number of the PARAM_EXEC Param to set */
+ 	Var		   *paramval;		/* outer-relation Var to assign to Param */
+ } NestLoopParam;
+ 
  /* ----------------
   *		merge join node
   *
Index: src/include/nodes/primnodes.h
===================================================================
RCS file: /cvsroot/pgsql/src/include/nodes/primnodes.h,v
retrieving revision 1.156
diff -c -r1.156 primnodes.h
*** src/include/nodes/primnodes.h	26 Feb 2010 02:01:25 -0000	1.156
--- src/include/nodes/primnodes.h	12 Jul 2010 04:26:44 -0000
***************
*** 175,181 ****
   *				Such parameters are numbered from 1 to n.
   *
   *		PARAM_EXEC:  The parameter is an internal executor parameter, used
!  *				for passing values into and out of sub-queries.
   *				For historical reasons, such parameters are numbered from 0.
   *				These numbers are independent of PARAM_EXTERN numbers.
   *
--- 175,182 ----
   *				Such parameters are numbered from 1 to n.
   *
   *		PARAM_EXEC:  The parameter is an internal executor parameter, used
!  *				for passing values into and out of sub-queries or from
!  *				nestloop joins to their inner scans.
   *				For historical reasons, such parameters are numbered from 0.
   *				These numbers are independent of PARAM_EXTERN numbers.
   *
Index: src/include/nodes/relation.h
===================================================================
RCS file: /cvsroot/pgsql/src/include/nodes/relation.h,v
retrieving revision 1.187
diff -c -r1.187 relation.h
*** src/include/nodes/relation.h	6 Jul 2010 19:19:00 -0000	1.187
--- src/include/nodes/relation.h	12 Jul 2010 04:26:45 -0000
***************
*** 209,214 ****
--- 209,218 ----
  	int			wt_param_id;	/* PARAM_EXEC ID for the work table */
  	struct Plan *non_recursive_plan;	/* plan for non-recursive term */
  
+ 	/* These fields are workspace for createplan.c */
+ 	Relids		curOuterRels;			/* outer rels above current node */
+ 	List	   *curOuterParams;			/* not-yet-assigned NestLoopParams */
+ 
  	/* optional private data for join_search_hook, e.g., GEQO */
  	void	   *join_search_private;
  } PlannerInfo;
***************
*** 1330,1345 ****
  /*
   * glob->paramlist keeps track of the PARAM_EXEC slots that we have decided
   * we need for the query.  At runtime these slots are used to pass values
!  * either down into subqueries (for outer references in subqueries) or up out
!  * of subqueries (for the results of a subplan).  The n'th entry in the list
!  * (n counts from 0) corresponds to Param->paramid = n.
   *
   * Each paramlist item shows the absolute query level it is associated with,
   * where the outermost query is level 1 and nested subqueries have higher
   * numbers.  The item the parameter slot represents can be one of three kinds:
   *
   * A Var: the slot represents a variable of that level that must be passed
!  * down because subqueries have outer references to it.  The varlevelsup
   * value in the Var will always be zero.
   *
   * An Aggref (with an expression tree representing its argument): the slot
--- 1334,1353 ----
  /*
   * glob->paramlist keeps track of the PARAM_EXEC slots that we have decided
   * we need for the query.  At runtime these slots are used to pass values
!  * around from one plan node to another.  They can be used to pass values
!  * down into subqueries (for outer references in subqueries), or up out of
!  * subqueries (for the results of a subplan), or from a NestLoop plan node
!  * into its inner relation (when the inner scan is parameterized with values
!  * from the outer relation).  The n'th entry in the list (n counts from 0)
!  * corresponds to Param->paramid = n.
   *
   * Each paramlist item shows the absolute query level it is associated with,
   * where the outermost query is level 1 and nested subqueries have higher
   * numbers.  The item the parameter slot represents can be one of three kinds:
   *
   * A Var: the slot represents a variable of that level that must be passed
!  * down because subqueries have outer references to it, or must be passed
!  * from a NestLoop node of that level to its inner scan.  The varlevelsup
   * value in the Var will always be zero.
   *
   * An Aggref (with an expression tree representing its argument): the slot
***************
*** 1352,1358 ****
   * to the parent query of the subplan.
   *
   * Note: we detect duplicate Var parameters and coalesce them into one slot,
!  * but we do not do this for Aggref or Param slots.
   */
  typedef struct PlannerParamItem
  {
--- 1360,1372 ----
   * to the parent query of the subplan.
   *
   * Note: we detect duplicate Var parameters and coalesce them into one slot,
!  * but we do not bother to do this for Aggrefs, and it would be incorrect
!  * to do so for Param slots.  Duplicate detection is actually *necessary*
!  * in the case of NestLoop parameters since it serves to match up the usage
!  * of a Param (in the inner scan) with the assignment of the value (in the
!  * NestLoop node).  This might result in the same PARAM_EXEC slot being used
!  * by multiple NestLoop nodes or SubPlan nodes, but no harm is done since
!  * the same value would be assigned anyway.
   */
  typedef struct PlannerParamItem
  {
Index: src/include/optimizer/subselect.h
===================================================================
RCS file: /cvsroot/pgsql/src/include/optimizer/subselect.h,v
retrieving revision 1.39
diff -c -r1.39 subselect.h
*** src/include/optimizer/subselect.h	2 Jan 2010 16:58:07 -0000	1.39
--- src/include/optimizer/subselect.h	12 Jul 2010 04:26:45 -0000
***************
*** 29,34 ****
--- 29,35 ----
  				 bool attach_initplans);
  extern Param *SS_make_initplan_from_plan(PlannerInfo *root, Plan *plan,
  						   Oid resulttype, int32 resulttypmod);
+ extern Param *assign_nestloop_param(PlannerInfo *root, Var *var);
  extern int	SS_assign_special_param(PlannerInfo *root);
  
  #endif   /* SUBSELECT_H */