Remember pathkey's source expression.

To consistently estimate the number of groups using the pathkeys list in the
sorting operation, we need to identify the expression used as a sort key.
Pathkey refers to the equivalence class, which can contain a wide variety of
expressions. To somehow stabilise the expression's choice, save the link to the
origin expression, triggering the PathKey creation. While this approach doesn't
always guarantee the right choice, it makes dependence on the SQL string less
obvious.

Author: danolivo

contrib/postgres_fdw/postgres_fdw.c

@@ -976,6 +976,7 @@ get_useful_pathkeys_for_relation(PlannerInfo *root, RelOptInfo *rel)
 	foreach(lc, useful_eclass_list)
 	{
 		EquivalenceClass *cur_ec = lfirst(lc);
+		EquivalenceMember *em;
 		PathKey    *pathkey;
 
 		/* If redundant with what we did above, skip it. */
@@ -988,14 +989,15 @@ get_useful_pathkeys_for_relation(PlannerInfo *root, RelOptInfo *rel)
 			continue;
 
 		/* If no pushable expression for this rel, skip it. */
-		if (find_em_for_rel(root, cur_ec, rel) == NULL)
+		if ((em = find_em_for_rel(root, cur_ec, rel)) == NULL)
 			continue;
 
 		/* Looks like we can generate a pathkey, so let's do it. */
 		pathkey = make_canonical_pathkey(root, cur_ec,
 										 linitial_oid(cur_ec->ec_opfamilies),
 										 BTLessStrategyNumber,
-										 false);
+										 false,
+										 em->em_expr); /* TODO */
 		useful_pathkeys_list = lappend(useful_pathkeys_list,
 									   list_make1(pathkey));
 	}

src/backend/optimizer/path/costsize.c

@@ -2019,21 +2019,41 @@ cost_incremental_sort(Path *path,
 	foreach(l, pathkeys)
 	{
 		PathKey    *key = (PathKey *) lfirst(l);
-		EquivalenceMember *member = (EquivalenceMember *)
-			linitial(key->pk_eclass->ec_members);
+
+#ifdef USE_ASSERT_CHECKING
+		ListCell *lc;
+
+		/* Be paranoid, but caring about performace don't check on prod */
+		foreach(lc, key->pk_eclass->ec_members)
+		{
+			if (find_ec_member_matching_expr(
+								key->pk_eclass, key->source_expr,
+								pull_varnos(root, (Node *) key->source_expr)))
+				break;
+		}
+		if (!lc)
+			/*
+			 * XXX: Can we build PathKey over derived expression and does it
+			 * trigger this error?
+			 */
+			elog(ERROR, "PathKey source expression must be a part of EQ class");
+#endif
+
+		/* Reassure ourselves no one created pathkeys alternative way */
+		Assert(key->source_expr != NULL);
 
 		/*
 		 * 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)))
+		if (bms_is_member(0, pull_varnos(root, (Node *) key->source_expr)))
 		{
 			unknown_varno = true;
 			break;
 		}
 
 		/* expression not containing any Vars with "varno 0" */
-		presortedExprs = lappend(presortedExprs, member->em_expr);
+		presortedExprs = lappend(presortedExprs, key->source_expr);
 
 		if (foreach_current_index(l) + 1 >= presorted_keys)
 			break;

src/backend/optimizer/path/pathkeys.c

@@ -54,7 +54,7 @@ static bool right_merge_direction(PlannerInfo *root, PathKey *pathkey);
 PathKey *
 make_canonical_pathkey(PlannerInfo *root,
 					   EquivalenceClass *eclass, Oid opfamily,
-					   int strategy, bool nulls_first)
+					   int strategy, bool nulls_first, Expr *src_expr)
 {
 	PathKey    *pk;
 	ListCell   *lc;
@@ -89,6 +89,7 @@ make_canonical_pathkey(PlannerInfo *root,
 	pk->pk_opfamily = opfamily;
 	pk->pk_strategy = strategy;
 	pk->pk_nulls_first = nulls_first;
+	pk->source_expr = src_expr;
 
 	root->canon_pathkeys = lappend(root->canon_pathkeys, pk);
 
@@ -241,7 +242,7 @@ make_pathkey_from_sortinfo(PlannerInfo *root,
 
 	/* And finally we can find or create a PathKey node */
 	return make_canonical_pathkey(root, eclass, opfamily,
-								  strategy, nulls_first);
+								  strategy, nulls_first, expr);
 }
 
 /*
@@ -1117,7 +1118,8 @@ convert_subquery_pathkeys(PlannerInfo *root, RelOptInfo *rel,
 											   outer_ec,
 											   sub_pathkey->pk_opfamily,
 											   sub_pathkey->pk_strategy,
-											   sub_pathkey->pk_nulls_first);
+											   sub_pathkey->pk_nulls_first,
+											   (Expr *) outer_var);
 			}
 		}
 		else
@@ -1199,7 +1201,8 @@ convert_subquery_pathkeys(PlannerInfo *root, RelOptInfo *rel,
 													  outer_ec,
 													  sub_pathkey->pk_opfamily,
 													  sub_pathkey->pk_strategy,
-													  sub_pathkey->pk_nulls_first);
+													  sub_pathkey->pk_nulls_first,
+													  (Expr *) outer_var);
 					/* score = # of equivalence peers */
 					score = list_length(outer_ec->ec_members) - 1;
 					/* +1 if it matches the proper query_pathkeys item */
@@ -1646,6 +1649,7 @@ select_outer_pathkeys_for_merge(PlannerInfo *root,
 	List	   *pathkeys = NIL;
 	int			nClauses = list_length(mergeclauses);
 	EquivalenceClass **ecs;
+	Expr			 **exprs;
 	int		   *scores;
 	int			necs;
 	ListCell   *lc;
@@ -1660,6 +1664,7 @@ select_outer_pathkeys_for_merge(PlannerInfo *root,
 	 * duplicates) and their "popularity" scores.
 	 */
 	ecs = (EquivalenceClass **) palloc(nClauses * sizeof(EquivalenceClass *));
+	exprs = (Expr **) palloc(nClauses * sizeof(Expr *));
 	scores = (int *) palloc(nClauses * sizeof(int));
 	necs = 0;
 
@@ -1669,14 +1674,21 @@ select_outer_pathkeys_for_merge(PlannerInfo *root,
 		EquivalenceClass *oeclass;
 		int			score;
 		ListCell   *lc2;
+		Expr	   *expr;
 
 		/* get the outer eclass */
 		update_mergeclause_eclasses(root, rinfo);
 
 		if (rinfo->outer_is_left)
+		{
 			oeclass = rinfo->left_ec;
+			expr = (Expr *) linitial(((OpExpr *) rinfo->clause)->args);
+		}
 		else
+		{
 			oeclass = rinfo->right_ec;
+			expr = (Expr *) lsecond(((OpExpr *) rinfo->clause)->args);
+		}
 
 		/* reject duplicates */
 		for (j = 0; j < necs; j++)
@@ -1700,6 +1712,8 @@ select_outer_pathkeys_for_merge(PlannerInfo *root,
 		}
 
 		ecs[necs] = oeclass;
+		exprs[necs] = expr;
+
 		scores[necs] = score;
 		necs++;
 	}
@@ -1801,7 +1815,8 @@ select_outer_pathkeys_for_merge(PlannerInfo *root,
 										 ec,
 										 linitial_oid(ec->ec_opfamilies),
 										 BTLessStrategyNumber,
-										 false);
+										 false,
+										 exprs[best_j]);
 		/* can't be redundant because no duplicate ECs */
 		Assert(!pathkey_is_redundant(pathkey, pathkeys));
 		pathkeys = lappend(pathkeys, pathkey);
@@ -1855,18 +1870,23 @@ make_inner_pathkeys_for_merge(PlannerInfo *root,
 		EquivalenceClass *oeclass;
 		EquivalenceClass *ieclass;
 		PathKey    *pathkey;
+		Expr	   *src_expr;
 
 		update_mergeclause_eclasses(root, rinfo);
 
+		Assert(IsA(rinfo->clause, OpExpr) && rinfo->orclause == NULL);
+
 		if (rinfo->outer_is_left)
 		{
 			oeclass = rinfo->left_ec;
 			ieclass = rinfo->right_ec;
+			src_expr = (Expr *) lsecond(((OpExpr *) rinfo->clause)->args);
 		}
 		else
 		{
 			oeclass = rinfo->right_ec;
 			ieclass = rinfo->left_ec;
+			src_expr = (Expr *) linitial(((OpExpr *) rinfo->clause)->args);
 		}
 
 		/* outer eclass should match current or next pathkeys */
@@ -1894,7 +1914,8 @@ make_inner_pathkeys_for_merge(PlannerInfo *root,
 											 ieclass,
 											 opathkey->pk_opfamily,
 											 opathkey->pk_strategy,
-											 opathkey->pk_nulls_first);
+											 opathkey->pk_nulls_first,
+											 src_expr);
 
 		/*
 		 * Don't generate redundant pathkeys (which can happen if multiple

src/include/nodes/pathnodes.h

@@ -1469,6 +1469,8 @@ typedef struct PathKey
 	Oid			pk_opfamily;	/* btree opfamily defining the ordering */
 	int			pk_strategy;	/* sort direction (ASC or DESC) */
 	bool		pk_nulls_first; /* do NULLs come before normal values? */
+
+	Expr	   *source_expr;	/* Expression, which triggered this creation */
 } PathKey;
 
 /*

src/include/optimizer/paths.h

@@ -264,7 +264,8 @@ extern bool has_useful_pathkeys(PlannerInfo *root, RelOptInfo *rel);
 extern List *append_pathkeys(List *target, List *source);
 extern PathKey *make_canonical_pathkey(PlannerInfo *root,
 									   EquivalenceClass *eclass, Oid opfamily,
-									   int strategy, bool nulls_first);
+									   int strategy, bool nulls_first,
+									   Expr *src_expr);
 extern void add_paths_to_append_rel(PlannerInfo *root, RelOptInfo *rel,
 									List *live_childrels);