Partial sort

Author: knizhnik

src/backend/optimizer/path/pathkeys.c

@@ -430,6 +430,40 @@ get_cheapest_fractional_path_for_pathkeys(List *paths,
 	return matched_path;
 }
 
+Path *
+get_cheapest_partial_path_for_pathkeys(List *paths,
+									   List *pathkeys,
+									   Relids required_outer,
+									   double fraction)
+{
+	Path	   *matched_path = NULL;
+	ListCell   *l;
+	int best_prefix_len = 0;
+	foreach(l, paths)
+	{
+		Path	   *path = (Path *) lfirst(l);
+		int prefix_len = pathkeys_get_prefix(pathkeys, path->pathkeys);
+		if (prefix_len < best_prefix_len || path->pathtype != T_IndexOnlyScan) { 
+			continue;
+		}
+		/*
+		 * Since cost comparison is a lot cheaper than pathkey comparison, do
+		 * that first.  (XXX is that still true?)
+		 */
+		if (matched_path != NULL &&
+			compare_fractional_path_costs(matched_path, path, fraction) <= 0)
+			continue;
+
+		if (prefix_len != 0 
+			&& bms_is_subset(PATH_REQ_OUTER(path), required_outer))
+		{
+			matched_path = path;
+			best_prefix_len = prefix_len;
+		}
+	}
+	return matched_path;
+}
+
 /****************************************************************************
  *		NEW PATHKEY FORMATION
  ****************************************************************************/
@@ -1483,13 +1517,17 @@ pathkeys_useful_for_ordering(PlannerInfo *root, List *pathkeys)
 	if (pathkeys == NIL)
 		return 0;				/* unordered path */
 
+#if 0
 	if (pathkeys_contained_in(root->query_pathkeys, pathkeys))
 	{
 		/* It's useful ... or at least the first N keys are */
 		return list_length(root->query_pathkeys);
 	}
 
 	return 0;					/* path ordering not useful */
+#else
+	return pathkeys_get_prefix(root->query_pathkeys, pathkeys);
+#endif
 }
 
 /*

src/backend/optimizer/plan/createplan.c

@@ -4049,17 +4049,6 @@ make_sort(PlannerInfo *root, Plan *lefttree, int numCols,
 			  0.0,
 			  work_mem,
 			  limit_tuples);
-	if (lefttree->type == T_IndexOnlyScan && root->simple_rel_array_size == 2)
-	{
-		RelOptInfo* relinfo = root->simple_rel_array[1];
-		IndexOptInfo* indexinfo = linitial(root->simple_rel_array[1]->indexlist);
-		IndexOnlyScan* indexscan = (IndexOnlyScan*)lefttree;
-		List *index_pathkeys = build_index_pathkeys(root, indexinfo, indexscan->indexorderdir);
-		int prefix_len = pathkeys_get_prefix(root->query_pathkeys, index_pathkeys);
-		sort_path.total_cost -= sort_path.startup_cost;
-		sort_path.startup_cost /= (prefix_len+1);
-		sort_path.total_cost += sort_path.startup_cost;
-	}
 	plan->startup_cost = sort_path.startup_cost;
 	plan->total_cost = sort_path.total_cost;
 	plan->targetlist = lefttree->targetlist;

src/backend/optimizer/plan/planner.c

@@ -1334,6 +1334,10 @@ grouping_planner(PlannerInfo *root, double tuple_fraction)
 	double		dNumGroups = 0;
 	bool		use_hashed_distinct = false;
 	bool		tested_hashed_distinct = false;
+	Path	   *cheapest_path;
+	Path	   *sorted_path = NULL;
+	Path	   *partial_sorted_path = NULL;
+	Path	   *best_path  = NULL;
 
 	/* Tweak caller-supplied tuple_fraction if have LIMIT/OFFSET */
 	if (parse->limitCount || parse->limitOffset)
@@ -1434,9 +1438,6 @@ grouping_planner(PlannerInfo *root, double tuple_fraction)
 		List	   *rollup_groupclauses = NIL;
 		standard_qp_extra qp_extra;
 		RelOptInfo *final_rel;
-		Path	   *cheapest_path;
-		Path	   *sorted_path;
-		Path	   *best_path;
 
 		MemSet(&agg_costs, 0, sizeof(AggClauseCosts));
 
@@ -1764,7 +1765,14 @@ grouping_planner(PlannerInfo *root, double tuple_fraction)
 													  root->query_pathkeys,
 													  NULL,
 													  tuple_fraction);
-
+		if (sorted_path == NULL)
+		{
+			partial_sorted_path =
+				get_cheapest_partial_path_for_pathkeys(final_rel->pathlist,
+													   root->query_pathkeys,
+													   NULL,
+													   tuple_fraction);
+		}
 		/* Don't consider same path in both guises; just wastes effort */
 		if (sorted_path == cheapest_path)
 			sorted_path = NULL;
@@ -1803,7 +1811,32 @@ grouping_planner(PlannerInfo *root, double tuple_fraction)
 				/* Presorted path is a loser */
 				sorted_path = NULL;
 			}
+		} else if (partial_sorted_path != NULL) {
+			Path	sort_path;
+			Path	partial_sort_path;
+			
+			cost_sort(&sort_path, root, root->query_pathkeys,
+					  cheapest_path->total_cost,
+					  path_rows, path_width,
+					  0.0, work_mem, root->limit_tuples);
+			
+			cost_sort(&partial_sort_path, root, root->query_pathkeys,
+					  partial_sorted_path->total_cost,
+					  path_rows, path_width,
+					  0.0, work_mem, root->limit_tuples);
+			
+			partial_sort_path.total_cost -= partial_sort_path.startup_cost;
+			partial_sort_path.startup_cost /= partial_sorted_path->pathkeys->length+1;
+			partial_sort_path.total_cost += partial_sort_path.startup_cost;
+
+
+			if (compare_fractional_path_costs(&sort_path, &partial_sort_path,
+											  tuple_fraction) > 0)
+			{
+				cheapest_path = partial_sorted_path;
+			}
 		}
+			
 
 		/*
 		 * Consider whether we want to use hashing instead of sorting.
@@ -2370,6 +2403,12 @@ grouping_planner(PlannerInfo *root, double tuple_fraction)
 														   result_plan,
 														 root->sort_pathkeys,
 														   limit_tuples);
+			if (partial_sorted_path && best_path == partial_sorted_path)
+			{
+				result_plan->total_cost -= result_plan->startup_cost;
+				result_plan->startup_cost /= partial_sorted_path->pathkeys->length+1;
+				result_plan->total_cost += result_plan->startup_cost;				
+			}
 			current_pathkeys = root->sort_pathkeys;
 		}
 	}

src/include/optimizer/paths.h

@@ -175,6 +175,10 @@ extern Path *get_cheapest_fractional_path_for_pathkeys(List *paths,
 										  List *pathkeys,
 										  Relids required_outer,
 										  double fraction);
+extern Path *get_cheapest_partial_path_for_pathkeys(List *paths,
+										  List *pathkeys,
+										  Relids required_outer,
+										  double fraction);
 extern List *build_index_pathkeys(PlannerInfo *root, IndexOptInfo *index,
 					 ScanDirection scandir);
 extern List *build_expression_pathkey(PlannerInfo *root, Expr *expr,