parameterized append paths

zilder · zilder · commit 655d2d7d1f82 · 2016-04-15T17:58:01.000+03:00
diff --git a/pg_pathman.c b/pg_pathman.c
@@ -99,6 +99,7 @@ static void generate_mergeappend_paths(PlannerInfo *root, RelOptInfo *rel,
 						   List *all_child_pathkeys,
 						   PathKey *pathkeyAsc,
 						   PathKey *pathkeyDesc);
+static Path *get_cheapest_parameterized_child_path(PlannerInfo *root, RelOptInfo *rel, Relids required_outer);
 
 
 /*
@@ -1616,6 +1617,49 @@ set_append_rel_pathlist(PlannerInfo *root, RelOptInfo *rel,
 		generate_mergeappend_paths(root, rel, live_childrels,
 								   all_child_pathkeys, pathkeyAsc,
 								   pathkeyDesc);
+
+	/*
+	 * Build Append paths for each parameterization seen among the child rels.
+	 * (This may look pretty expensive, but in most cases of practical
+	 * interest, the child rels will expose mostly the same parameterizations,
+	 * so that not that many cases actually get considered here.)
+	 *
+	 * The Append node itself cannot enforce quals, so all qual checking must
+	 * be done in the child paths.  This means that to have a parameterized
+	 * Append path, we must have the exact same parameterization for each
+	 * child path; otherwise some children might be failing to check the
+	 * moved-down quals.  To make them match up, we can try to increase the
+	 * parameterization of lesser-parameterized paths.
+	 */
+	foreach(l, all_child_outers)
+	{
+		Relids		required_outer = (Relids) lfirst(l);
+		ListCell   *lcr;
+
+		/* Select the child paths for an Append with this parameterization */
+		subpaths = NIL;
+		subpaths_valid = true;
+		foreach(lcr, live_childrels)
+		{
+			RelOptInfo *childrel = (RelOptInfo *) lfirst(lcr);
+			Path	   *subpath;
+
+			subpath = get_cheapest_parameterized_child_path(root,
+															childrel,
+															required_outer);
+			if (subpath == NULL)
+			{
+				/* failed to make a suitable path for this child */
+				subpaths_valid = false;
+				break;
+			}
+			subpaths = accumulate_append_subpath(subpaths, subpath);
+		}
+
+		if (subpaths_valid)
+			add_path(rel, (Path *)
+					 create_append_path(rel, subpaths, required_outer));
+	}
 }
 
 static List *
@@ -1624,7 +1668,78 @@ 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;
+}
 
 
 //---------------------------------------------------------------
