fixed projections in custom nodes (broken IndexOnlyScan), extract exec_append_common(), remove useless functions

funbringer · funbringer · commit e841962d7b26 · 2016-05-12T21:17:39.000+03:00
diff --git a/hooks.c b/hooks.c
@@ -250,9 +250,6 @@ pathman_rel_pathlist_hook(PlannerInfo *root, RelOptInfo *rel, Index rti, RangeTb
 			root->simple_rte_array = new_rte_array;
 		}
 
-		/* Target list should be sorted in physical order for custom nodes to work */
-		rel->reltargetlist = sort_rel_tlist(rel->reltargetlist);
-
 		/*
 		 * Iterate all indexes in rangeset and append corresponding child
 		 * relations.
diff --git a/nodes_common.c b/nodes_common.c
@@ -12,7 +12,9 @@
 #include "nodes_common.h"
 #include "runtimeappend.h"
 #include "optimizer/restrictinfo.h"
-
+#include "optimizer/plancat.h"
+#include "utils/memutils.h"
+#include "utils.h"
 
 
 /* Compare plans by 'original_order' */
@@ -275,6 +277,21 @@ create_append_plan_common(PlannerInfo *root, RelOptInfo *rel,
 	RuntimeAppendPath  *gpath = (RuntimeAppendPath *) best_path;
 	CustomScan		   *cscan;
 
+	/* HACK: kill me plz, it severely breaks IndexOnlyScan */
+	if (custom_plans)
+	{
+		ListCell   *lc1,
+				   *lc2;
+
+		forboth (lc1, gpath->cpath.custom_paths, lc2, custom_plans)
+		{
+			Plan	   *child_plan = (Plan *) lfirst(lc2);
+			RelOptInfo *child_rel = ((Path *) lfirst(lc1))->parent;
+
+			child_plan->targetlist = build_physical_tlist(root, child_rel);
+		}
+	}
+
 	cscan = makeNode(CustomScan);
 	cscan->scan.plan.qual = NIL;
 	cscan->scan.plan.targetlist = tlist;
@@ -324,6 +341,51 @@ begin_append_common(CustomScanState *node, EState *estate, int eflags)
 	scan_state->custom_expr_states =
 		(List *) ExecInitExpr((Expr *) scan_state->custom_exprs,
 							  (PlanState *) scan_state);
+
+	node->ss.ps.ps_TupFromTlist = false;
+}
+
+TupleTableSlot *
+exec_append_common(CustomScanState *node,
+				   void (*fetch_next_tuple) (CustomScanState *node))
+{
+	RuntimeAppendState	   *scan_state = (RuntimeAppendState *) node;
+
+	if (scan_state->ncur_plans == 0)
+		ExecReScan(&node->ss.ps);
+
+	for (;;)
+	{
+		if (!node->ss.ps.ps_TupFromTlist)
+		{
+			fetch_next_tuple(node);
+
+			if (TupIsNull(scan_state->slot))
+				return NULL;
+		}
+
+		if (node->ss.ps.ps_ProjInfo)
+		{
+			ExprDoneCond	isDone;
+			TupleTableSlot *result;
+
+			ResetExprContext(node->ss.ps.ps_ExprContext);
+
+			node->ss.ps.ps_ProjInfo->pi_exprContext->ecxt_scantuple = scan_state->slot;
+			result = ExecProject(node->ss.ps.ps_ProjInfo, &isDone);
+
+			if (isDone != ExprEndResult)
+			{
+				node->ss.ps.ps_TupFromTlist = (isDone == ExprMultipleResult);
+
+				return result;
+			}
+			else
+				node->ss.ps.ps_TupFromTlist = false;
+		}
+		else
+			return scan_state->slot;
+	}
 }
 
 void
diff --git a/nodes_common.h b/nodes_common.h
@@ -78,6 +78,9 @@ Node * create_append_scan_state_common(CustomScan *node,
 
 void begin_append_common(CustomScanState *node, EState *estate, int eflags);
 
+TupleTableSlot * exec_append_common(CustomScanState *node,
+									void (*fetch_next_tuple) (CustomScanState *node));
+
 void end_append_common(CustomScanState *node);
 
 void rescan_append_common(CustomScanState *node);
diff --git a/runtime_merge_append.c b/runtime_merge_append.c
@@ -306,17 +306,14 @@ runtimemergeappend_begin(CustomScanState *node, EState *estate, int eflags)
 	begin_append_common(node, estate, eflags);
 }
 
-TupleTableSlot *
-runtimemergeappend_exec(CustomScanState *node)
+static void
+fetch_next_tuple(CustomScanState *node)
 {
 	RuntimeMergeAppendState	   *scan_state = (RuntimeMergeAppendState *) node;
 	RuntimeAppendState		   *rstate = &scan_state->rstate;
 	PlanState				   *ps;
 	int							i;
 
-	if (scan_state->rstate.ncur_plans == 0)
-		ExecReScan(&node->ss.ps);
-
 	if (!scan_state->ms_initialized)
 	{
 		for (i = 0; i < scan_state->rstate.ncur_plans; i++)
@@ -367,15 +364,23 @@ runtimemergeappend_exec(CustomScanState *node)
 	if (binaryheap_empty(scan_state->ms_heap))
 	{
 		/* All the subplans are exhausted, and so is the heap */
-		return NULL;
+		rstate->slot = NULL;
+		return;
 	}
 	else
 	{
 		i = DatumGetInt32(binaryheap_first(scan_state->ms_heap));
-		return scan_state->ms_slots[i];
+		rstate->slot = scan_state->ms_slots[i];
+		return;
 	}
 }
 
+TupleTableSlot *
+runtimemergeappend_exec(CustomScanState *node)
+{
+	return exec_append_common(node, fetch_next_tuple);
+}
+
 void
 runtimemergeappend_end(CustomScanState *node)
 {
diff --git a/runtimeappend.c b/runtimeappend.c
@@ -58,19 +58,16 @@ runtimeappend_begin(CustomScanState *node, EState *estate, int eflags)
 	begin_append_common(node, estate, eflags);
 }
 
-TupleTableSlot *
-runtimeappend_exec(CustomScanState *node)
+static void
+fetch_next_tuple(CustomScanState *node)
 {
 	RuntimeAppendState	   *scan_state = (RuntimeAppendState *) node;
-
-	if (scan_state->ncur_plans == 0)
-		ExecReScan(&node->ss.ps);
+	TupleTableSlot		   *slot = NULL;
 
 	while (scan_state->running_idx < scan_state->ncur_plans)
 	{
 		ChildScanCommon		child = scan_state->cur_plans[scan_state->running_idx];
 		PlanState		   *state = child->content.plan_state;
-		TupleTableSlot	   *slot = NULL;
 		bool				quals;
 
 		for (;;)
@@ -87,15 +84,23 @@ runtimeappend_exec(CustomScanState *node)
 			ResetExprContext(node->ss.ps.ps_ExprContext);
 
 			if (quals)
-				return slot;
+			{
+				scan_state->slot = slot;
+				return;
+			}
 		}
 
 		scan_state->running_idx++;
 	}
 
-	/* Force ReScan */
-	scan_state->ncur_plans = 0;
-	return NULL;
+	scan_state->slot = slot;
+	return;
+}
+
+TupleTableSlot *
+runtimeappend_exec(CustomScanState *node)
+{
+	return exec_append_common(node, fetch_next_tuple);
 }
 
 void
diff --git a/runtimeappend.h b/runtimeappend.h
@@ -48,6 +48,9 @@ typedef struct
 
 	/* Index of the selected plan state */
 	int					running_idx;
+
+	/* Last saved tuple (for SRF projections) */
+	TupleTableSlot	   *slot;
 } RuntimeAppendState;
 
 extern bool					pg_pathman_enable_runtimeappend;
diff --git a/utils.c b/utils.c
@@ -36,77 +36,16 @@ clause_contains_params_walker(Node *node, void *context)
 								  context);
 }
 
-static Node *
-replace_child_var(Var *var, replace_rte_variables_context *context)
+static char *
+bms_print(Bitmapset *bms)
 {
-	ReplaceVarsContext *cxt = (ReplaceVarsContext *) context->callback_arg;
-	Var				   *new_var;
+  StringInfoData str;
+  int x;
 
-	new_var = makeNode(Var);
-	memcpy(new_var, var, sizeof(Var));
+  initStringInfo(&str);
+  x = -1;
+  while ((x = bms_next_member(bms, x)) >= 0)
+    appendStringInfo(&str, " %d", x);
 
-	/*
-	 * Replace a partition's Var with a Var
-	 * pointing to the RuntimeAppend's results
-	 */
-	new_var->varno = cxt->parent->relid;
-	new_var->location = -1;
-	new_var->varnoold = 0;
-
-	return (Node *) new_var;
-}
-
-Node *
-replace_child_vars_with_parent_var(Node *node, ReplaceVarsContext *context)
-{
-	return replace_rte_variables(node, context->child->relid, context->sublevels_up,
-								 replace_child_var, (void *) context, NULL);
-}
-
-/*
- * Sorts reltargetlist by Var's varattno (physical order) since
- * we can't use static build_path_tlist() for our custom nodes.
- *
- * See create_scan_plan & use_physical_tlist for more details.
- */
-List *
-sort_rel_tlist(List *tlist)
-{
-	int			i;
-	int			plain_tlist_size = list_length(tlist);
-	Var		  **plain_tlist = palloc(plain_tlist_size * sizeof(Var *));
-	ListCell   *tlist_cell;
-	List	   *result = NIL;
-
-	i = 0;
-	foreach (tlist_cell, tlist)
-		plain_tlist[i++] = lfirst(tlist_cell);
-
-	qsort(plain_tlist, plain_tlist_size, sizeof(Var *), cmp_tlist_vars);
-
-	for (i = 0; i < plain_tlist_size; i++)
-		result = lappend(result, plain_tlist[i]);
-
-	return result;
-}
-
-/* Compare Vars by varattno */
-int
-cmp_tlist_vars(const void *a, const void *b)
-{
-	Var *v1 = *(Var **) a;
-	Var *v2 = *(Var **) b;
-
-	Assert(IsA(v1, Var) && IsA(v2, Var));
-
-	if (v1->varattno > v2->varattno)
-		return 1;
-	else if (v1->varattno < v2->varattno)
-		return -1;
-	else
-	{
-		/* XXX: I really doubt this case is ok */
-		Assert(v1->varattno != v2->varattno);
-		return 0;
-	}
+  return str.data;
 }
diff --git a/utils.h b/utils.h
@@ -23,9 +23,6 @@ typedef struct
 
 bool clause_contains_params(Node *clause);
 
-Node * replace_child_vars_with_parent_var(Node *node,
-										  ReplaceVarsContext *context);
-
 int cmp_tlist_vars(const void *a, const void *b);
 List * sort_rel_tlist(List *tlist);
 

Original file line number	Diff line number	Diff line change
`@@ -250,9 +250,6 @@ pathman_rel_pathlist_hook(PlannerInfo root, RelOptInfo rel, Index rti, RangeTb`
`250`	`250`	`root->simple_rte_array = new_rte_array;`
`251`	`251`	`}`
`252`	`252`
`253`		`- /* Target list should be sorted in physical order for custom nodes to work */`
`254`		`- rel->reltargetlist = sort_rel_tlist(rel->reltargetlist);`
`255`		`-`
`256`	`253`	`/*`
`257`	`254`	`* Iterate all indexes in rangeset and append corresponding child`
`258`	`255`	`* relations.`
Original file line number	Diff line number	Diff line change
`@@ -306,17 +306,14 @@ runtimemergeappend_begin(CustomScanState node, EState estate, int eflags)`
`306`	`306`	`begin_append_common(node, estate, eflags);`
`307`	`307`	`}`
`308`	`308`
`309`		`-TupleTableSlot *`
`310`		`-runtimemergeappend_exec(CustomScanState *node)`
	`309`	`+static void`
	`310`	`+fetch_next_tuple(CustomScanState *node)`
`311`	`311`	`{`
`312`	`312`	`RuntimeMergeAppendState scan_state = (RuntimeMergeAppendState ) node;`
`313`	`313`	`RuntimeAppendState *rstate = &scan_state->rstate;`
`314`	`314`	`PlanState *ps;`
`315`	`315`	`int i;`
`316`	`316`
`317`		`- if (scan_state->rstate.ncur_plans == 0)`
`318`		`- ExecReScan(&node->ss.ps);`
`319`		`-`
`320`	`317`	`if (!scan_state->ms_initialized)`
`321`	`318`	`{`
`322`	`319`	`for (i = 0; i < scan_state->rstate.ncur_plans; i++)`
`@@ -367,15 +364,23 @@ runtimemergeappend_exec(CustomScanState *node)`
`367`	`364`	`if (binaryheap_empty(scan_state->ms_heap))`
`368`	`365`	`{`
`369`	`366`	`/* All the subplans are exhausted, and so is the heap */`
`370`		`- return NULL;`
	`367`	`+ rstate->slot = NULL;`
	`368`	`+ return;`
`371`	`369`	`}`
`372`	`370`	`else`
`373`	`371`	`{`
`374`	`372`	`i = DatumGetInt32(binaryheap_first(scan_state->ms_heap));`
`375`		`- return scan_state->ms_slots[i];`
	`373`	`+ rstate->slot = scan_state->ms_slots[i];`
	`374`	`+ return;`
`376`	`375`	`}`
`377`	`376`	`}`
`378`	`377`
	`378`	`+TupleTableSlot *`
	`379`	`+runtimemergeappend_exec(CustomScanState *node)`
	`380`	`+{`
	`381`	`+ return exec_append_common(node, fetch_next_tuple);`
	`382`	`+}`
	`383`	`+`
`379`	`384`	`void`
`380`	`385`	`runtimemergeappend_end(CustomScanState *node)`
`381`	`386`	`{`