improve child path generation for Runtime[Merge]Append (using get_cheapest_parameterized_child_path())

funbringer · funbringer · commit d57501d0db23 · 2017-04-15T01:09:48.000+03:00
diff --git a/expected/pathman_only.out b/expected/pathman_only.out
@@ -179,16 +179,26 @@ SELECT * FROM test_only.from_only_test JOIN q1 USING(val);
    ->  CTE Scan on q1
    ->  Custom Scan (RuntimeAppend)
          ->  Seq Scan on from_only_test_1 from_only_test
+               Filter: (q1.val = val)
          ->  Seq Scan on from_only_test_2 from_only_test
+               Filter: (q1.val = val)
          ->  Seq Scan on from_only_test_3 from_only_test
+               Filter: (q1.val = val)
          ->  Seq Scan on from_only_test_4 from_only_test
+               Filter: (q1.val = val)
          ->  Seq Scan on from_only_test_5 from_only_test
+               Filter: (q1.val = val)
          ->  Seq Scan on from_only_test_6 from_only_test
+               Filter: (q1.val = val)
          ->  Seq Scan on from_only_test_7 from_only_test
+               Filter: (q1.val = val)
          ->  Seq Scan on from_only_test_8 from_only_test
+               Filter: (q1.val = val)
          ->  Seq Scan on from_only_test_9 from_only_test
+               Filter: (q1.val = val)
          ->  Seq Scan on from_only_test_10 from_only_test
-(15 rows)
+               Filter: (q1.val = val)
+(25 rows)
 
 /* should be OK */
 EXPLAIN (COSTS OFF)
diff --git a/src/hooks.c b/src/hooks.c
@@ -120,27 +120,39 @@ pathman_join_pathlist_hook(PlannerInfo *root,
 		NestPath	   *nest_path;		/* NestLoop we're creating */
 		ParamPathInfo  *ppi;			/* parameterization info */
 		Relids			inner_required;	/* required paremeterization relids */
-		List		   *filtered_joinclauses = NIL;
+		List		   *filtered_joinclauses = NIL,
+					   *saved_ppi_list;
 		ListCell	   *rinfo_lc;
 
 		if (!IsA(cur_inner_path, AppendPath))
 			continue;
 
 		/* Select cheapest path for outerrel */
 		outer = outerrel->cheapest_total_path;
+
+		/* Wrap outer path with Unique if needed */
 		if (saved_jointype == JOIN_UNIQUE_OUTER)
 		{
 			outer = (Path *) create_unique_path(root, outerrel,
 												outer, extra->sjinfo);
 			Assert(outer);
 		}
 
+		 /* No way to do this in a parameterized inner path */
+		if (saved_jointype == JOIN_UNIQUE_INNER)
+			return;
+
 		/* Make innerrel path depend on outerrel's column */
 		inner_required = bms_union(PATH_REQ_OUTER((Path *) cur_inner_path),
 								   bms_make_singleton(outerrel->relid));
 
+		/* Preserve existing ppis built by get_appendrel_parampathinfo() */
+		saved_ppi_list = innerrel->ppilist;
+
 		/* Get the ParamPathInfo for a parameterized path */
+		innerrel->ppilist = NIL;
 		ppi = get_baserel_parampathinfo(root, innerrel, inner_required);
+		innerrel->ppilist = saved_ppi_list;
 
 		/* Skip ppi->ppi_clauses don't reference partition attribute */
 		if (!(ppi && get_partitioned_attr_clauses(ppi->ppi_clauses,
@@ -149,8 +161,8 @@ pathman_join_pathlist_hook(PlannerInfo *root,
 			continue;
 
 		inner = create_runtimeappend_path(root, cur_inner_path, ppi, paramsel);
-		if (saved_jointype == JOIN_UNIQUE_INNER)
-			return; /* No way to do this with a parameterized inner path */
+		if (!inner)
+			return; /* could not build it, retreat! */
 
 		initial_cost_nestloop(root, &workspace, jointype,
 							  outer, inner, /* built paths */
@@ -388,13 +400,6 @@ pathman_rel_pathlist_hook(PlannerInfo *root,
 			Relids			inner_required = PATH_REQ_OUTER((Path *) cur_path);
 			Path		   *inner_path = NULL;
 			ParamPathInfo  *ppi;
-			List		   *ppi_part_clauses = NIL;
-
-			/* Fetch ParamPathInfo & try to extract part-related clauses */
-			ppi = get_baserel_parampathinfo(root, rel, inner_required);
-			if (ppi && ppi->ppi_clauses)
-				ppi_part_clauses = get_partitioned_attr_clauses(ppi->ppi_clauses,
-																prel, rel->relid);
 
 			/* Skip if rel contains some join-related stuff or path type mismatched */
 			if (!(IsA(cur_path, AppendPath) || IsA(cur_path, MergeAppendPath)) ||
@@ -403,13 +408,13 @@ pathman_rel_pathlist_hook(PlannerInfo *root,
 				continue;
 			}
 
-			/*
-			 * Skip if neither rel->baserestrictinfo nor
-			 * ppi->ppi_clauses reference partition attribute
-			 */
-			if (!(rel_part_clauses || ppi_part_clauses))
+			/* Skip if rel->baserestrictinfo doesn't reference partition attribute */
+			if (!rel_part_clauses)
 				continue;
 
+			/* Get existing parameterization */
+			ppi = get_appendrel_parampathinfo(rel, inner_required);
+
 			if (IsA(cur_path, AppendPath) && pg_pathman_enable_runtimeappend)
 				inner_path = create_runtimeappend_path(root, cur_path,
 													   ppi, paramsel);
diff --git a/src/include/pathman.h b/src/include/pathman.h
@@ -123,6 +123,9 @@ Bitmapset *translate_col_privs(const Bitmapset *parent_privs,
 void set_append_rel_pathlist(PlannerInfo *root, RelOptInfo *rel, Index rti,
 							 PathKey *pathkeyAsc, PathKey *pathkeyDesc);
 
+Path *get_cheapest_parameterized_child_path(PlannerInfo *root, RelOptInfo *rel,
+											Relids required_outer);
+
 
 typedef struct
 {
diff --git a/src/include/runtimeappend.h b/src/include/runtimeappend.h
@@ -37,7 +37,6 @@ typedef struct
 
 	/* Restrictions to be checked during ReScan and Exec */
 	List			   *custom_exprs;
-	List			   *custom_expr_states;
 
 	/* All available plans \ plan states */
 	HTAB			   *children_table;
diff --git a/src/nodes_common.c b/src/nodes_common.c
@@ -350,22 +350,53 @@ create_append_path_common(PlannerInfo *root,
 
 	result->nchildren = list_length(inner_append->subpaths);
 	result->children = (ChildScanCommon *)
-			palloc(result->nchildren * sizeof(ChildScanCommon));
+							palloc(result->nchildren * sizeof(ChildScanCommon));
+
 	i = 0;
 	foreach (lc, inner_append->subpaths)
 	{
-		Path			   *path = lfirst(lc);
-		Index				relindex = path->parent->relid;
+		Path			   *path = (Path *) lfirst(lc);
+		RelOptInfo		   *childrel = path->parent;
 		ChildScanCommon		child;
 
+		/* Do we have parameterization? */
+		if (param_info)
+		{
+			Relids required_outer = param_info->ppi_req_outer;
+
+			/* Rebuild path using new 'required_outer' */
+			path = get_cheapest_parameterized_child_path(root, childrel,
+														 required_outer);
+		}
+
+		/*
+		 * We were unable to re-parameterize child path,
+		 * which means that we can't use Runtime[Merge]Append,
+		 * since its children can't evaluate join quals.
+		 */
+		if (!path)
+		{
+			int j;
+
+			for (j = 0; j < i; j++)
+				pfree(result->children[j]);
+			pfree(result->children);
+
+			list_free_deep(result->cpath.custom_paths);
+
+			pfree(result);
+
+			return NULL; /* notify caller */
+		}
+
 		child = (ChildScanCommon) palloc(sizeof(ChildScanCommonData));
 
 		result->cpath.path.startup_cost += path->startup_cost;
 		result->cpath.path.total_cost += path->total_cost;
 
 		child->content_type = CHILD_PATH;
 		child->content.path = path;
-		child->relid = root->simple_rte_array[relindex]->relid;
+		child->relid = root->simple_rte_array[childrel->relid]->relid;
 		Assert(child->relid != InvalidOid);
 
 		result->cpath.custom_paths = lappend(result->cpath.custom_paths,
@@ -476,12 +507,6 @@ create_append_scan_state_common(CustomScan *node,
 void
 begin_append_common(CustomScanState *node, EState *estate, int eflags)
 {
-	RuntimeAppendState *scan_state = (RuntimeAppendState *) node;
-
-	scan_state->custom_expr_states =
-		(List *) ExecInitExpr((Expr *) scan_state->custom_exprs,
-							  (PlanState *) scan_state);
-
 	node->ss.ps.ps_TupFromTlist = false;
 }
 
diff --git a/src/pg_pathman.c b/src/pg_pathman.c
@@ -92,10 +92,6 @@ static void generate_mergeappend_paths(PlannerInfo *root,
 									   PathKey *pathkeyAsc,
 									   PathKey *pathkeyDesc);
 
-static Path *get_cheapest_parameterized_child_path(PlannerInfo *root,
-												   RelOptInfo *rel,
-												   Relids required_outer);
-
 
 /* We can transform Param into Const provided that 'econtext' is available */
 #define IsConstValue(wcxt, node) \
@@ -293,7 +289,7 @@ append_child_relation(PlannerInfo *root, Relation parent_relation,
 	{
 		childquals = NIL;
 
-		forboth(lc1, wrappers, lc2, parent_rel->baserestrictinfo)
+		forboth (lc1, wrappers, lc2, parent_rel->baserestrictinfo)
 		{
 			WrapperNode	   *wrap = (WrapperNode *) lfirst(lc1);
 			Node		   *new_clause;
@@ -1333,78 +1329,6 @@ accumulate_append_subpath(List *subpaths, Path *path)
 	return lappend(subpaths, path);
 }
 
-/*
- * get_cheapest_parameterized_child_path
- *		Get cheapest path for this relation that has exactly the requested
- *		parameterization.
- *
- * Returns NULL if unable to create such a path.
- */
-static Path *
-get_cheapest_parameterized_child_path(PlannerInfo *root, RelOptInfo *rel,
-									  Relids required_outer)
-{
-	Path	   *cheapest;
-	ListCell   *lc;
-
-	/*
-	 * Look up the cheapest existing path with no more than the needed
-	 * parameterization.  If it has exactly the needed parameterization, we're
-	 * done.
-	 */
-	cheapest = get_cheapest_path_for_pathkeys(rel->pathlist,
-											  NIL,
-											  required_outer,
-											  TOTAL_COST);
-	Assert(cheapest != NULL);
-	if (bms_equal(PATH_REQ_OUTER(cheapest), required_outer))
-		return cheapest;
-
-	/*
-	 * Otherwise, we can "reparameterize" an existing path to match the given
-	 * parameterization, which effectively means pushing down additional
-	 * joinquals to be checked within the path's scan.  However, some existing
-	 * paths might check the available joinquals already while others don't;
-	 * therefore, it's not clear which existing path will be cheapest after
-	 * reparameterization.  We have to go through them all and find out.
-	 */
-	cheapest = NULL;
-	foreach(lc, rel->pathlist)
-	{
-		Path	   *path = (Path *) lfirst(lc);
-
-		/* Can't use it if it needs more than requested parameterization */
-		if (!bms_is_subset(PATH_REQ_OUTER(path), required_outer))
-			continue;
-
-		/*
-		 * Reparameterization can only increase the path's cost, so if it's
-		 * already more expensive than the current cheapest, forget it.
-		 */
-		if (cheapest != NULL &&
-			compare_path_costs(cheapest, path, TOTAL_COST) <= 0)
-			continue;
-
-		/* Reparameterize if needed, then recheck cost */
-		if (!bms_equal(PATH_REQ_OUTER(path), required_outer))
-		{
-			path = reparameterize_path(root, path, required_outer, 1.0);
-			if (path == NULL)
-				continue;		/* failed to reparameterize this one */
-			Assert(bms_equal(PATH_REQ_OUTER(path), required_outer));
-
-			if (cheapest != NULL &&
-				compare_path_costs(cheapest, path, TOTAL_COST) <= 0)
-				continue;
-		}
-
-		/* We have a new best path */
-		cheapest = path;
-	}
-
-	/* Return the best path, or NULL if we found no suitable candidate */
-	return cheapest;
-}
 
 /*
  * generate_mergeappend_paths
@@ -1945,7 +1869,6 @@ set_append_rel_pathlist(PlannerInfo *root, RelOptInfo *rel, Index rti,
 
 		if (parallel_workers > 0)
 		{
-
 			/* Generate a partial append path. */
 			appendpath = create_append_path_compat(rel, partial_subpaths, NULL,
 					parallel_workers);
@@ -2006,3 +1929,76 @@ set_append_rel_pathlist(PlannerInfo *root, RelOptInfo *rel, Index rti,
 					 create_append_path_compat(rel, subpaths, required_outer, 0));
 	}
 }
+
+/*
+ * get_cheapest_parameterized_child_path
+ *		Get cheapest path for this relation that has exactly the requested
+ *		parameterization.
+ *
+ * Returns NULL if unable to create such a path.
+ */
+Path *
+get_cheapest_parameterized_child_path(PlannerInfo *root, RelOptInfo *rel,
+									  Relids required_outer)
+{
+	Path	   *cheapest;
+	ListCell   *lc;
+
+	/*
+	 * Look up the cheapest existing path with no more than the needed
+	 * parameterization.  If it has exactly the needed parameterization, we're
+	 * done.
+	 */
+	cheapest = get_cheapest_path_for_pathkeys(rel->pathlist,
+											  NIL,
+											  required_outer,
+											  TOTAL_COST);
+	Assert(cheapest != NULL);
+	if (bms_equal(PATH_REQ_OUTER(cheapest), required_outer))
+		return cheapest;
+
+	/*
+	 * Otherwise, we can "reparameterize" an existing path to match the given
+	 * parameterization, which effectively means pushing down additional
+	 * joinquals to be checked within the path's scan.  However, some existing
+	 * paths might check the available joinquals already while others don't;
+	 * therefore, it's not clear which existing path will be cheapest after
+	 * reparameterization.  We have to go through them all and find out.
+	 */
+	cheapest = NULL;
+	foreach(lc, rel->pathlist)
+	{
+		Path	   *path = (Path *) lfirst(lc);
+
+		/* Can't use it if it needs more than requested parameterization */
+		if (!bms_is_subset(PATH_REQ_OUTER(path), required_outer))
+			continue;
+
+		/*
+		 * Reparameterization can only increase the path's cost, so if it's
+		 * already more expensive than the current cheapest, forget it.
+		 */
+		if (cheapest != NULL &&
+			compare_path_costs(cheapest, path, TOTAL_COST) <= 0)
+			continue;
+
+		/* Reparameterize if needed, then recheck cost */
+		if (!bms_equal(PATH_REQ_OUTER(path), required_outer))
+		{
+			path = reparameterize_path(root, path, required_outer, 1.0);
+			if (path == NULL)
+				continue;		/* failed to reparameterize this one */
+			Assert(bms_equal(PATH_REQ_OUTER(path), required_outer));
+
+			if (cheapest != NULL &&
+				compare_path_costs(cheapest, path, TOTAL_COST) <= 0)
+				continue;
+		}
+
+		/* We have a new best path */
+		cheapest = path;
+	}
+
+	/* Return the best path, or NULL if we found no suitable candidate */
+	return cheapest;
+}
diff --git a/src/runtime_merge_append.c b/src/runtime_merge_append.c
diff --git a/src/runtimeappend.c b/src/runtimeappend.c

Original file line number	Diff line number	Diff line change
`@@ -123,6 +123,9 @@ Bitmapset translate_col_privs(const Bitmapset parent_privs,`
`123`	`123`	`void set_append_rel_pathlist(PlannerInfo root, RelOptInfo rel, Index rti,`
`124`	`124`	`PathKey pathkeyAsc, PathKey pathkeyDesc);`
`125`	`125`
	`126`	`+Path get_cheapest_parameterized_child_path(PlannerInfo root, RelOptInfo *rel,`
	`127`	`+ Relids required_outer);`
	`128`	`+`
`126`	`129`
`127`	`130`	`typedef struct`
`128`	`131`	`{`