From cde35cf4ae968d3366ea5358d2a754641e4c06c8 Mon Sep 17 00:00:00 2001
From: Tom Lane <tgl@sss.pgh.pa.us>
Date: Thu, 6 Aug 2015 20:14:37 -0400
Subject: [PATCH] Fix eclass_useful_for_merging to give valid results for
appendrel children.
Formerly, this function would always return "true" for an appendrel child
relation, because it would think that the appendrel parent was a potential
join target for the child. In principle that should only lead to some
inefficiency in planning, but fuzz testing by Andreas Seltenreich disclosed
that it could lead to "could not find pathkey item to sort" planner errors
in odd corner cases. Specifically, we would think that all columns of a
child table's multicolumn index were interesting pathkeys, causing us to
generate a MergeAppend path that sorts by all the columns. However, if any
of those columns weren't actually used above the level of the appendrel,
they would not get added to that rel's targetlist, which would result in
being unable to resolve the MergeAppend's sort keys against its targetlist
during createplan.c.
Backpatch to 9.3. In older versions, columns of an appendrel get added
to its targetlist even if they're not mentioned above the scan level,
so that the failure doesn't occur. It might be worth back-patching this
fix to older versions anyway, but I'll refrain for the moment.
---
src/backend/optimizer/path/equivclass.c | 14 +++++++---
src/backend/optimizer/path/pathkeys.c | 2 +-
src/include/optimizer/paths.h | 3 ++-
src/test/regress/expected/inherit.out | 34 +++++++++++++++++++++++++
src/test/regress/sql/inherit.sql | 21 +++++++++++++++
5 files changed, 69 insertions(+), 5 deletions(-)
diff --git a/src/backend/optimizer/path/equivclass.c b/src/backend/optimizer/path/equivclass.c
index 80021d57bdc..48be45dffc9 100644
--- a/src/backend/optimizer/path/equivclass.c
+++ b/src/backend/optimizer/path/equivclass.c
@@ -2285,9 +2285,11 @@ has_relevant_eclass_joinclause(PlannerInfo *root, RelOptInfo *rel1)
* from actually being generated.
*/
bool
-eclass_useful_for_merging(EquivalenceClass *eclass,
+eclass_useful_for_merging(PlannerInfo *root,
+ EquivalenceClass *eclass,
RelOptInfo *rel)
{
+ Relids relids;
ListCell *lc;
Assert(!eclass->ec_merged);
@@ -2305,8 +2307,14 @@ eclass_useful_for_merging(EquivalenceClass *eclass,
* possibly-overoptimistic heuristic.
*/
+ /* If specified rel is a child, we must consider the topmost parent rel */
+ if (rel->reloptkind == RELOPT_OTHER_MEMBER_REL)
+ relids = find_childrel_top_parent(root, rel)->relids;
+ else
+ relids = rel->relids;
+
/* If rel already includes all members of eclass, no point in searching */
- if (bms_is_subset(eclass->ec_relids, rel->relids))
+ if (bms_is_subset(eclass->ec_relids, relids))
return false;
/* To join, we need a member not in the given rel */
@@ -2317,7 +2325,7 @@ eclass_useful_for_merging(EquivalenceClass *eclass,
if (cur_em->em_is_child)
continue; /* ignore children here */
- if (!bms_overlap(cur_em->em_relids, rel->relids))
+ if (!bms_overlap(cur_em->em_relids, relids))
return true;
}
diff --git a/src/backend/optimizer/path/pathkeys.c b/src/backend/optimizer/path/pathkeys.c
index 8b25222b93a..c6b5d78724b 100644
--- a/src/backend/optimizer/path/pathkeys.c
+++ b/src/backend/optimizer/path/pathkeys.c
@@ -1373,7 +1373,7 @@ pathkeys_useful_for_merging(PlannerInfo *root, RelOptInfo *rel, List *pathkeys)
* surely possible to generate a mergejoin clause using them.
*/
if (rel->has_eclass_joins &&
- eclass_useful_for_merging(pathkey->pk_eclass, rel))
+ eclass_useful_for_merging(root, pathkey->pk_eclass, rel))
matched = true;
else
{
diff --git a/src/include/optimizer/paths.h b/src/include/optimizer/paths.h
index 3e2378aeb7d..87123a57295 100644
--- a/src/include/optimizer/paths.h
+++ b/src/include/optimizer/paths.h
@@ -146,7 +146,8 @@ extern bool have_relevant_eclass_joinclause(PlannerInfo *root,
RelOptInfo *rel1, RelOptInfo *rel2);
extern bool has_relevant_eclass_joinclause(PlannerInfo *root,
RelOptInfo *rel1);
-extern bool eclass_useful_for_merging(EquivalenceClass *eclass,
+extern bool eclass_useful_for_merging(PlannerInfo *root,
+ EquivalenceClass *eclass,
RelOptInfo *rel);
extern bool is_redundant_derived_clause(RestrictInfo *rinfo, List *clauselist);
diff --git a/src/test/regress/expected/inherit.out b/src/test/regress/expected/inherit.out
index 56e2c995150..89b6c1caf47 100644
--- a/src/test/regress/expected/inherit.out
+++ b/src/test/regress/expected/inherit.out
@@ -1307,6 +1307,40 @@ DETAIL: drop cascades to table matest1
drop cascades to table matest2
drop cascades to table matest3
--
+-- Check that use of an index with an extraneous column doesn't produce
+-- a plan with extraneous sorting
+--
+create table matest0 (a int, b int, c int, d int);
+create table matest1 () inherits(matest0);
+create index matest0i on matest0 (b, c);
+create index matest1i on matest1 (b, c);
+set enable_nestloop = off; -- we want a plan with two MergeAppends
+explain (costs off)
+select t1.* from matest0 t1, matest0 t2
+where t1.b = t2.b and t2.c = t2.d
+order by t1.b limit 10;
+ QUERY PLAN
+-------------------------------------------------------------------
+ Limit
+ -> Merge Join
+ Merge Cond: (t1.b = t2.b)
+ -> Merge Append
+ Sort Key: t1.b
+ -> Index Scan using matest0i on matest0 t1
+ -> Index Scan using matest1i on matest1 t1_1
+ -> Materialize
+ -> Merge Append
+ Sort Key: t2.b
+ -> Index Scan using matest0i on matest0 t2
+ Filter: (c = d)
+ -> Index Scan using matest1i on matest1 t2_1
+ Filter: (c = d)
+(14 rows)
+
+reset enable_nestloop;
+drop table matest0 cascade;
+NOTICE: drop cascades to table matest1
+--
-- Test merge-append for UNION ALL append relations
--
set enable_seqscan = off;
diff --git a/src/test/regress/sql/inherit.sql b/src/test/regress/sql/inherit.sql
index 09bb7507ad9..793c2163768 100644
--- a/src/test/regress/sql/inherit.sql
+++ b/src/test/regress/sql/inherit.sql
@@ -402,6 +402,27 @@ reset enable_seqscan;
drop table matest0 cascade;
+--
+-- Check that use of an index with an extraneous column doesn't produce
+-- a plan with extraneous sorting
+--
+
+create table matest0 (a int, b int, c int, d int);
+create table matest1 () inherits(matest0);
+create index matest0i on matest0 (b, c);
+create index matest1i on matest1 (b, c);
+
+set enable_nestloop = off; -- we want a plan with two MergeAppends
+
+explain (costs off)
+select t1.* from matest0 t1, matest0 t2
+where t1.b = t2.b and t2.c = t2.d
+order by t1.b limit 10;
+
+reset enable_nestloop;
+
+drop table matest0 cascade;
+
--
-- Test merge-append for UNION ALL append relations
--
--
GitLab