Employ EquivalenceClass to adjust ndistinct estimation.

Operations like grouping, incremental sort, hash join, memoize, etc., estimate
the number of groups in a source using the statistics of this column
or expression.
Equivalence clauses like 'x=y' obviously reduce the maximum number of distinct
values above the clause evaluation node to the fewest distincts in the 'x'
or 'y' source. Therefore, in estimating the groups number, the planner may
involve this data from the EC.
Identification of proper EC for arbitrary expression seems too expensive
operation. However, having a pathkey gives the planner immediate access to
the EC. Here, a routine to identify proper expression is provided. ndistinct
estimation is cached inside the EM.

Author: danolivo

contrib/postgres_fdw/postgres_fdw.c

@@ -3388,7 +3388,7 @@ estimate_path_cost_size(PlannerInfo *root,
 			numGroups = estimate_num_groups(root,
 											get_sortgrouplist_exprs(root->processed_groupClause,
 																	fpinfo->grouped_tlist),
-											input_rows, NULL, NULL);
+											input_rows, NULL, NULL, NULL);
 
 			/*
 			 * Get the retrieved_rows and rows estimates.  If there are HAVING

src/backend/optimizer/path/costsize.c

@@ -1999,7 +1999,7 @@ cost_tuplesort(Cost *startup_cost, Cost *run_cost,
 void
 cost_incremental_sort(Path *path,
 					  PlannerInfo *root, List *pathkeys, int presorted_keys,
-					  int input_disabled_nodes,
+					  int input_disabled_nodes, Relids relids,
 					  Cost input_startup_cost, Cost input_total_cost,
 					  double input_tuples, int width, Cost comparison_cost, int sort_mem,
 					  double limit_tuples)
@@ -2012,9 +2012,6 @@ cost_incremental_sort(Path *path,
 	Cost		group_startup_cost,
 				group_run_cost,
 				group_input_run_cost;
-	List	   *presortedExprs = NIL;
-	ListCell   *l;
-	bool		unknown_varno = false;
 
 	Assert(presorted_keys > 0 && presorted_keys < list_length(pathkeys));
 
@@ -2025,58 +2022,10 @@ cost_incremental_sort(Path *path,
 	if (input_tuples < 2.0)
 		input_tuples = 2.0;
 
-	/* Default estimate of number of groups, capped to one group per row. */
-	input_groups = Min(input_tuples, DEFAULT_NUM_DISTINCT);
-
-	/*
-	 * Extract presorted keys as list of expressions.
-	 *
-	 * We need to be careful about Vars containing "varno 0" which might have
-	 * been introduced by generate_append_tlist, which would confuse
-	 * estimate_num_groups (in fact it'd fail for such expressions). See
-	 * recurse_set_operations which has to deal with the same issue.
-	 *
-	 * Unlike recurse_set_operations we can't access the original target list
-	 * here, and even if we could it's not very clear how useful would that be
-	 * for a set operation combining multiple tables. So we simply detect if
-	 * there are any expressions with "varno 0" and use the default
-	 * DEFAULT_NUM_DISTINCT in that case.
-	 *
-	 * We might also use either 1.0 (a single group) or input_tuples (each row
-	 * being a separate group), pretty much the worst and best case for
-	 * incremental sort. But those are extreme cases and using something in
-	 * between seems reasonable. Furthermore, generate_append_tlist is used
-	 * for set operations, which are likely to produce mostly unique output
-	 * anyway - from that standpoint the DEFAULT_NUM_DISTINCT is defensive
-	 * while maintaining lower startup cost.
-	 */
-	foreach(l, pathkeys)
-	{
-		PathKey    *key = (PathKey *) lfirst(l);
-		EquivalenceMember *member = (EquivalenceMember *)
-			linitial(key->pk_eclass->ec_members);
-
-		/*
-		 * Check if the expression contains Var with "varno 0" so that we
-		 * don't call estimate_num_groups in that case.
-		 */
-		if (bms_is_member(0, pull_varnos(root, (Node *) member->em_expr)))
-		{
-			unknown_varno = true;
-			break;
-		}
-
-		/* expression not containing any Vars with "varno 0" */
-		presortedExprs = lappend(presortedExprs, member->em_expr);
-
-		if (foreach_current_index(l) + 1 >= presorted_keys)
-			break;
-	}
-
 	/* Estimate the number of groups with equal presorted keys. */
-	if (!unknown_varno)
-		input_groups = estimate_num_groups(root, presortedExprs, input_tuples,
-										   NULL, NULL);
+	input_groups = estimate_num_groups(root,
+									   list_copy_head(pathkeys, presorted_keys),
+									   input_tuples, NULL, NULL, relids);
 
 	group_tuples = input_tuples / input_groups;
 	group_input_run_cost = input_run_cost / input_groups;
@@ -2579,7 +2528,7 @@ cost_memoize_rescan(PlannerInfo *root, MemoizePath *mpath,
 
 	/* estimate on the distinct number of parameter values */
 	ndistinct = estimate_num_groups(root, mpath->param_exprs, calls, NULL,
-									&estinfo);
+									&estinfo, NULL);
 
 	/*
 	 * When the estimation fell back on using a default value, it's a bit too
@@ -2900,7 +2849,7 @@ get_windowclause_startup_tuples(PlannerInfo *root, WindowClause *wc,
 														root->parse->targetList);
 
 		num_partitions = estimate_num_groups(root, partexprs, input_tuples,
-											 NULL, NULL);
+											 NULL, NULL, NULL);
 		list_free(partexprs);
 
 		partition_tuples = input_tuples / num_partitions;
@@ -2923,7 +2872,7 @@ get_windowclause_startup_tuples(PlannerInfo *root, WindowClause *wc,
 		/* estimate out how many peer groups there are in the partition */
 		num_groups = estimate_num_groups(root, orderexprs,
 										 partition_tuples, NULL,
-										 NULL);
+										 NULL, NULL);
 		list_free(orderexprs);
 		peer_tuples = partition_tuples / num_groups;
 	}
@@ -3703,6 +3652,7 @@ initial_cost_mergejoin(PlannerInfo *root, JoinCostWorkspace *workspace,
 								  outersortkeys,
 								  outer_presorted_keys,
 								  outer_path->disabled_nodes,
+								  outer_path->parent->relids,
 								  outer_path->startup_cost,
 								  outer_path->total_cost,
 								  outer_path_rows,
@@ -6614,3 +6564,67 @@ compute_gather_rows(Path *path)
 
 	return clamp_row_est(path->rows * get_parallel_divisor(path));
 }
+
+/*
+ * Find suitable member of the equivalence class.
+ * Passing through the list of EC members find the member with minimum of
+ * distinct values. Cache estimated number of distincts in the em_ndistinct
+ * field of each member.
+ *
+ * Return NULL if no one proper member found (each member contains 0 relid).
+ */
+EquivalenceMember *
+identify_proper_ecmember(PlannerInfo *root, EquivalenceClass *ec, Relids relids)
+{
+	EquivalenceMember		   *candidate = NULL;
+	EquivalenceMember		   *em;
+	EquivalenceMemberIterator	it;
+
+	setup_eclass_member_iterator(&it, ec, relids);
+	while ((em = eclass_member_iterator_next(&it)) != NULL)
+	{
+		VariableStatData	vardata;
+
+		if (bms_is_member(0, em->em_relids))
+			continue;
+
+		if (em->em_is_const || bms_is_empty(em->em_relids))
+		{
+			/* Trivial case. Set up cache values and go further */
+			em->em_default_nd = false;
+			em->em_ndistinct = 1.0;
+		}
+		else if (relids && !bms_is_subset(em->em_relids, relids))
+			continue;
+
+		if (em->em_ndistinct < 0.)
+		{
+			/* Let's check candidate's ndistinct value */
+			examine_variable(root, (Node *) em->em_expr, 0, &vardata);
+			if (HeapTupleIsValid(vardata.statsTuple))
+				em->em_ndistinct =
+						get_variable_numdistinct(&vardata, &em->em_default_nd);
+			else
+			{
+				em->em_ndistinct = 0.0;
+				em->em_default_nd = true;
+			}
+			ReleaseVariableStats(vardata);
+		}
+
+		if (candidate == NULL)
+			candidate = em;
+
+		if (em->em_default_nd)
+			/* Nothing helpful */
+			continue;
+
+		Assert(em->em_ndistinct > 0.);
+
+		if (candidate->em_ndistinct == 0. ||
+			em->em_ndistinct < candidate->em_ndistinct)
+			candidate = em;
+	}
+
+	return candidate;
+}

src/backend/optimizer/path/equivclass.c

@@ -601,6 +601,7 @@ make_eq_member(EquivalenceClass *ec, Expr *expr, Relids relids,
 	em->em_datatype = datatype;
 	em->em_jdomain = jdomain;
 	em->em_parent = parent;
+	em->em_ndistinct = -1.0;
 
 	if (bms_is_empty(relids))
 	{

src/backend/optimizer/path/indxpath.c

@@ -2400,6 +2400,7 @@ adjust_rowcount_for_semijoins(PlannerInfo *root,
 										  sjinfo->semi_rhs_exprs,
 										  nraw,
 										  NULL,
+										  NULL,
 										  NULL);
 			if (rowcount > nunique)
 				rowcount = nunique;

src/backend/optimizer/plan/createplan.c

@@ -5523,6 +5523,7 @@ label_incrementalsort_with_costsize(PlannerInfo *root, IncrementalSort *plan,
 	cost_incremental_sort(&sort_path, root, pathkeys,
 						  plan->nPresortedCols,
 						  plan->sort.plan.disabled_nodes,
+						  NULL,
 						  lefttree->startup_cost,
 						  lefttree->total_cost,
 						  lefttree->plan_rows,

src/backend/optimizer/plan/planner.c

@@ -144,6 +144,7 @@ static List *extract_rollup_sets(List *groupingSets);
 static List *reorder_grouping_sets(List *groupingSets, List *sortclause);
 static void standard_qp_callback(PlannerInfo *root, void *extra);
 static double get_number_of_groups(PlannerInfo *root,
+								   Relids relids,
 								   double path_rows,
 								   grouping_sets_data *gd,
 								   List *target_list);
@@ -3602,7 +3603,7 @@ standard_qp_callback(PlannerInfo *root, void *extra)
  * determining whether some combination of them could be hashed instead.
  */
 static double
-get_number_of_groups(PlannerInfo *root,
+get_number_of_groups(PlannerInfo *root, Relids relids,
 					 double path_rows,
 					 grouping_sets_data *gd,
 					 List *target_list)
@@ -3642,7 +3643,8 @@ get_number_of_groups(PlannerInfo *root,
 																groupExprs,
 																path_rows,
 																&gset,
-																NULL);
+																NULL,
+																relids);
 
 					gs->numGroups = numGroups;
 					rollup->numGroups += numGroups;
@@ -3668,7 +3670,8 @@ get_number_of_groups(PlannerInfo *root,
 																groupExprs,
 																path_rows,
 																&gset,
-																NULL);
+																NULL,
+																relids);
 
 					gs->numGroups = numGroups;
 					gd->dNumHashGroups += numGroups;
@@ -3679,12 +3682,12 @@ get_number_of_groups(PlannerInfo *root,
 		}
 		else
 		{
-			/* Plain GROUP BY -- estimate based on optimized groupClause */
-			groupExprs = get_sortgrouplist_exprs(root->processed_groupClause,
-												 target_list);
+			List *pathkeys = list_copy_head(root->group_pathkeys,
+											root->num_groupby_pathkeys);
 
-			dNumGroups = estimate_num_groups(root, groupExprs, path_rows,
-											 NULL, NULL);
+			/* Plain GROUP BY -- estimate based on grouping pathkeys */
+			dNumGroups = estimate_num_groups(root, pathkeys, path_rows,
+											 NULL, NULL, relids);
 		}
 	}
 	else if (parse->groupingSets)
@@ -4074,7 +4077,7 @@ create_ordinary_grouping_paths(PlannerInfo *root, RelOptInfo *input_rel,
 	/*
 	 * Estimate number of groups.
 	 */
-	dNumGroups = get_number_of_groups(root,
+	dNumGroups = get_number_of_groups(root, cheapest_path->parent->relids,
 									  cheapest_path->rows,
 									  gd,
 									  extra->targetList);
@@ -4846,7 +4849,7 @@ create_partial_distinct_paths(PlannerInfo *root, RelOptInfo *input_rel,
 	/* estimate how many distinct rows we'll get from each worker */
 	numDistinctRows = estimate_num_groups(root, distinctExprs,
 										  cheapest_partial_path->rows,
-										  NULL, NULL);
+										  NULL, NULL, NULL);
 
 	/*
 	 * Try sorting the cheapest path and incrementally sorting any paths with
@@ -5017,7 +5020,7 @@ create_final_distinct_paths(PlannerInfo *root, RelOptInfo *input_rel,
 												parse->targetList);
 		numDistinctRows = estimate_num_groups(root, distinctExprs,
 											  cheapest_input_path->rows,
-											  NULL, NULL);
+											  NULL, NULL, NULL);
 	}
 
 	/*
@@ -7358,13 +7361,13 @@ create_partial_grouping_paths(PlannerInfo *root,
 	/* Estimate number of partial groups. */
 	if (cheapest_total_path != NULL)
 		dNumPartialGroups =
-			get_number_of_groups(root,
+			get_number_of_groups(root, input_rel->relids,
 								 cheapest_total_path->rows,
 								 gd,
 								 extra->targetList);
 	if (cheapest_partial_path != NULL)
 		dNumPartialPartialGroups =
-			get_number_of_groups(root,
+			get_number_of_groups(root, input_rel->relids,
 								 cheapest_partial_path->rows,
 								 gd,
 								 extra->targetList);

src/backend/optimizer/prep/prepunion.c

@@ -665,6 +665,7 @@ build_setop_child_paths(PlannerInfo *root, RelOptInfo *rel,
 											  get_tlist_exprs(subroot->parse->targetList, false),
 											  rel->cheapest_total_path->rows,
 											  NULL,
+											  NULL,
 											  NULL);
 	}
 }

src/backend/optimizer/util/pathnode.c

@@ -1858,6 +1858,7 @@ create_unique_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath,
 											  sjinfo->semi_rhs_exprs,
 											  rel->rows,
 											  NULL,
+											  NULL,
 											  NULL);
 	numCols = list_length(sjinfo->semi_rhs_exprs);
 
@@ -3059,6 +3060,7 @@ create_incremental_sort_path(PlannerInfo *root,
 	cost_incremental_sort(&pathnode->path,
 						  root, pathkeys, presorted_keys,
 						  subpath->disabled_nodes,
+						  subpath->parent->relids,
 						  subpath->startup_cost,
 						  subpath->total_cost,
 						  subpath->rows,