database/postgres
database/postgres
1
0
Fork 0
mirror of https://github.com/postgres/postgres.git synced 2025-05-17 06:41:24 +03:00
Code

Fix longstanding bug that would sometimes let the planner generate a bad plan

Browse Source 
for an outer join; symptom is bogus error "RIGHT JOIN is only supported with
merge-joinable join conditions".  Problem was that select_mergejoin_clauses
did its tests in the wrong order.  We need to force left join not right join
for a merge join when there are non-mergeable join clauses; but the test for
this only accounted for mergejoinability of the clause operator, and not
whether the left and right Vars were of the proper relations.  Per report
from Jean-Pierre Pelletier.
This commit is contained in:
Tom Lane 2005-10-25 20:30:45 +00:00
parent 01145f963f
commit fcd978c57d
1 changed files with 34 additions and 31 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

65
src/backend/optimizer/path/joinpath.c
View File

@ -8,7 +8,7 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/joinpath.c,v 1.82.2.3 2005/05/24 18:03:24 tgl Exp $ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/joinpath.c,v 1.82.2.4 2005/10/25 20:30:45 tgl Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -799,6 +799,7 @@ select_mergejoin_clauses(RelOptInfo *joinrel,
{ {
List *result_list = NIL; List *result_list = NIL;
bool isouterjoin = IS_OUTER_JOIN(jointype); bool isouterjoin = IS_OUTER_JOIN(jointype);
bool have_nonmergeable_joinclause = false;
List *i; List *i;
foreach(i, restrictlist) foreach(i, restrictlist)
@ -808,41 +809,16 @@ select_mergejoin_clauses(RelOptInfo *joinrel,
/* /*
* If processing an outer join, only use its own join clauses in * If processing an outer join, only use its own join clauses in
* the merge. For inner joins we need not be so picky. * the merge. For inner joins we need not be so picky.
*
* Furthermore, if it is a right/full join then *all* the explicit
* join clauses must be mergejoinable, else the executor will
* fail. If we are asked for a right join then just return NIL to
* indicate no mergejoin is possible (we can handle it as a left
* join instead). If we are asked for a full join then emit an
* error, because there is no fallback.
*/ */
if (isouterjoin) if (isouterjoin && restrictinfo->ispusheddown)
{ continue;
if (restrictinfo->ispusheddown)
continue;
switch (jointype)
{
case JOIN_RIGHT:
if (restrictinfo->left_relids == NULL ||
restrictinfo->mergejoinoperator == InvalidOid)
return NIL; /* not mergejoinable */
break;
case JOIN_FULL:
if (restrictinfo->left_relids == NULL ||
restrictinfo->mergejoinoperator == InvalidOid)
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("FULL JOIN is only supported with merge-joinable join conditions")));
break;
default:
/* otherwise, it's OK to have nonmergeable join quals */
break;
}
}
if (restrictinfo->left_relids == NULL || if (restrictinfo->left_relids == NULL ||
restrictinfo->mergejoinoperator == InvalidOid) restrictinfo->mergejoinoperator == InvalidOid)
{
have_nonmergeable_joinclause = true;
continue; /* not mergejoinable */ continue; /* not mergejoinable */
}
/* /*
* Check if clause is usable with these input rels. All the vars * Check if clause is usable with these input rels. All the vars
@ -860,10 +836,37 @@ select_mergejoin_clauses(RelOptInfo *joinrel,
/* lefthand side is inner */ /* lefthand side is inner */
} }
else else
{
have_nonmergeable_joinclause = true;
continue; /* no good for these input relations */ continue; /* no good for these input relations */
}
result_list = lcons(restrictinfo, result_list); result_list = lcons(restrictinfo, result_list);
} }
/*
* If it is a right/full join then *all* the explicit join clauses must be
* mergejoinable, else the executor will fail. If we are asked for a right
* join then just return NIL to indicate no mergejoin is possible (we can
* handle it as a left join instead). If we are asked for a full join then
* emit an error, because there is no fallback.
*/
if (have_nonmergeable_joinclause)
{
switch (jointype)
{
case JOIN_RIGHT:
return NIL; /* not mergejoinable */
case JOIN_FULL:
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("FULL JOIN is only supported with merge-joinable join conditions")));
break;
default:
/* otherwise, it's OK to have nonmergeable join quals */
break;
}
}
return result_list; return result_list;
} }