rdelaage
/
postgresql
mirror of https://git.postgresql.org/git/postgresql.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Improve outer-join-deduction logic to be able to propagate equalities 

through multiple join clauses.
This commit is contained in:
Tom Lane 2005-07-03 18:26:32 +00:00
parent 76eca0ec98
commit cc9bcbc8a4
1 changed files with 209 additions and 164 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

251
src/backend/optimizer/path/pathkeys.c
View File

@ -11,7 +11,7 @@
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/optimizer/path/pathkeys.c,v 1.69 2005/07/02 23:00:40 tgl Exp $
* $PostgreSQL: pgsql/src/backend/optimizer/path/pathkeys.c,v 1.70 2005/07/03 18:26:32 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@ -35,6 +35,10 @@ static PathKeyItem *makePathKeyItem(Node *key, Oid sortop, bool checkType);
static void generate_outer_join_implications(PlannerInfo *root,
List *equi_key_set,
Relids *relids);
static void sub_generate_join_implications(PlannerInfo *root,
List *equi_key_set, Relids *relids,
Node *item1, Oid sortop1,
Relids item1_relids);
static void process_implied_const_eq(PlannerInfo *root,
List *equi_key_set, Relids *relids,
Node *item1, Oid sortop1,
@ -250,24 +254,16 @@ generate_implied_equalities(PlannerInfo *root)
i1++;
}
/*
* If we have constant(s) and outer joins, try to propagate the
* constants through outer-join quals.
*/
if (have_consts && root->hasOuterJoins)
generate_outer_join_implications(root, curset, relids);
/*
* A set containing only two items cannot imply any equalities
* beyond the one that created the set, so we can skip it.
*/
if (nitems < 3)
continue;
/*
* Match each item in the set with all that appear after it (it's
* sufficient to generate A=B, need not process B=A too).
*
* A set containing only two items cannot imply any equalities
* beyond the one that created the set, so we can skip this
* processing in that case.
*/
if (nitems >= 3)
{
i1 = 0;
foreach(ptr1, curset)
{
@ -310,6 +306,14 @@ generate_implied_equalities(PlannerInfo *root)
i1++;
}
}
/*
* If we have constant(s) and outer joins, try to propagate the
* constants through outer-join quals.
*/
if (have_consts && root->hasOuterJoins)
generate_outer_join_implications(root, curset, relids);
}
}
/*
@ -362,118 +366,154 @@ generate_outer_join_implications(PlannerInfo *root,
List *equi_key_set,
Relids *relids)
{
ListCell *l1;
ListCell *l;
int i = 0;
/* Examine each mergejoinable outer-join clause with OUTERVAR on left */
foreach(l1, root->left_join_clauses)
/* Process each non-constant element of equi_key_set */
foreach(l, equi_key_set)
{
RestrictInfo *rinfo = (RestrictInfo *) lfirst(l1);
PathKeyItem *item1 = (PathKeyItem *) lfirst(l);
if (!bms_is_empty(relids[i]))
{
sub_generate_join_implications(root, equi_key_set, relids,
item1->key,
item1->sortop,
relids[i]);
}
i++;
}
}
/*
* sub_generate_join_implications
* Propagate a constant equality through outer join clauses.
*
* The item described by item1/sortop1/item1_relids has been determined
* to be equal to the constant(s) listed in equi_key_set. Recursively
* trace out the implications of this.
*
* equi_key_set and relids are as for generate_outer_join_implications.
*/
static void
sub_generate_join_implications(PlannerInfo *root,
List *equi_key_set, Relids *relids,
Node *item1, Oid sortop1, Relids item1_relids)
{
ListCell *l;
/*
* Examine each mergejoinable outer-join clause with OUTERVAR on left,
* looking for an OUTERVAR identical to item1
*/
foreach(l, root->left_join_clauses)
{
RestrictInfo *rinfo = (RestrictInfo *) lfirst(l);
Node *leftop = get_leftop(rinfo->clause);
Node *rightop = get_rightop(rinfo->clause);
ListCell *l2;
/* Scan to see if it matches any element of equi_key_set */
foreach(l2, equi_key_set)
{
PathKeyItem *item1 = (PathKeyItem *) lfirst(l2);
if (equal(leftop, item1->key) &&
rinfo->left_sortop == item1->sortop)
if (equal(leftop, item1) && rinfo->left_sortop == sortop1)
{
/*
* Yes, so find constant member(s) of set and generate
* Match, so find constant member(s) of set and generate
* implied INNERVAR = CONSTANT
*/
Node *rightop = get_rightop(rinfo->clause);
process_implied_const_eq(root, equi_key_set, relids,
rightop,
rinfo->right_sortop,
rinfo->right_relids,
false);
/*
* We can remove the explicit outer join qual, too,
* We can remove explicit tests of this outer-join qual, too,
* since we now have tests forcing each of its sides
* to the same value.
*/
process_implied_equality(root,
leftop,
rightop,
rinfo->left_sortop,
rinfo->right_sortop,
rinfo->left_relids,
rinfo->right_relids,
leftop, rightop,
rinfo->left_sortop, rinfo->right_sortop,
rinfo->left_relids, rinfo->right_relids,
true);
/* No need to match against remaining set members */
break;
}
/*
* And recurse to see if we can deduce anything from
* INNERVAR = CONSTANT
*/
sub_generate_join_implications(root, equi_key_set, relids,
rightop,
rinfo->right_sortop,
rinfo->right_relids);
}
}
/* Examine each mergejoinable outer-join clause with OUTERVAR on right */
foreach(l1, root->right_join_clauses)
/* The same, looking at clauses with OUTERVAR on right */
foreach(l, root->right_join_clauses)
{
RestrictInfo *rinfo = (RestrictInfo *) lfirst(l1);
Node *leftop = get_leftop(rinfo->clause);
RestrictInfo *rinfo = (RestrictInfo *) lfirst(l);
Node *rightop = get_rightop(rinfo->clause);
ListCell *l2;
/* Scan to see if it matches any element of equi_key_set */
foreach(l2, equi_key_set)
{
PathKeyItem *item1 = (PathKeyItem *) lfirst(l2);
if (equal(rightop, item1->key) &&
rinfo->right_sortop == item1->sortop)
if (equal(rightop, item1) && rinfo->right_sortop == sortop1)
{
/*
* Yes, so find constant member(s) of set and generate
* Match, so find constant member(s) of set and generate
* implied INNERVAR = CONSTANT
*/
Node *leftop = get_leftop(rinfo->clause);
process_implied_const_eq(root, equi_key_set, relids,
leftop,
rinfo->left_sortop,
rinfo->left_relids,
false);
/*
* We can remove the explicit outer join qual, too,
* We can remove explicit tests of this outer-join qual, too,
* since we now have tests forcing each of its sides
* to the same value.
*/
process_implied_equality(root,
leftop,
rightop,
rinfo->left_sortop,
rinfo->right_sortop,
rinfo->left_relids,
rinfo->right_relids,
leftop, rightop,
rinfo->left_sortop, rinfo->right_sortop,
rinfo->left_relids, rinfo->right_relids,
true);
/* No need to match against remaining set members */
break;
/*
* And recurse to see if we can deduce anything from
* INNERVAR = CONSTANT
*/
sub_generate_join_implications(root, equi_key_set, relids,
leftop,
rinfo->left_sortop,
rinfo->left_relids);
}
}
}
/* Examine each mergejoinable full-join clause */
foreach(l1, root->full_join_clauses)
{
RestrictInfo *rinfo = (RestrictInfo *) lfirst(l1);
Node *leftop = get_leftop(rinfo->clause);
Node *rightop = get_rightop(rinfo->clause);
int i1 = 0;
ListCell *l2;
/* Scan to see if it matches any element of equi_key_set */
foreach(l2, equi_key_set)
{
PathKeyItem *item1 = (PathKeyItem *) lfirst(l2);
CoalesceExpr *cexpr = (CoalesceExpr *) item1->key;
/*
* Try to match a pathkey containing a COALESCE() expression
* to the join clause. We can assume the COALESCE() inputs
* are in the same order as the join clause, since both were
* automatically generated in the cases we care about.
* Only COALESCE(x,y) items can possibly match full joins
*/
if (IsA(item1, CoalesceExpr))
{
CoalesceExpr *cexpr = (CoalesceExpr *) item1;
Node *cfirst;
Node *csecond;
if (list_length(cexpr->args) != 2)
return;
cfirst = (Node *) linitial(cexpr->args);
csecond = (Node *) lsecond(cexpr->args);
/*
* Examine each mergejoinable full-join clause, looking for a
* clause of the form "x = y" matching the COALESCE(x,y) expression
*/
foreach(l, root->full_join_clauses)
{
RestrictInfo *rinfo = (RestrictInfo *) lfirst(l);
Node *leftop = get_leftop(rinfo->clause);
Node *rightop = get_rightop(rinfo->clause);
/*
* We can assume the COALESCE() inputs are in the same order
* as the join clause, since both were automatically generated
* in the cases we care about.
*
* XXX currently this may fail to match in cross-type cases
* because the COALESCE will contain typecast operations while
@ -482,15 +522,13 @@ generate_outer_join_implications(PlannerInfo *root,
* Is it OK to strip implicit coercions from the COALESCE
* arguments? What of the sortops in such cases?
*/
if (IsA(cexpr, CoalesceExpr) &&
list_length(cexpr->args) == 2 &&
equal(leftop, (Node *) linitial(cexpr->args)) &&
equal(rightop, (Node *) lsecond(cexpr->args)) &&
rinfo->left_sortop == item1->sortop &&
rinfo->right_sortop == item1->sortop)
if (equal(leftop, cfirst) &&
equal(rightop, csecond) &&
rinfo->left_sortop == sortop1 &&
rinfo->right_sortop == sortop1)
{
/*
* Yes, so find constant member(s) of set and generate
* Match, so find constant member(s) of set and generate
* implied LEFTVAR = CONSTANT
*/
process_implied_const_eq(root, equi_key_set, relids,
@ -506,28 +544,37 @@ generate_outer_join_implications(PlannerInfo *root,
false);
/* ... and remove COALESCE() = CONSTANT */
process_implied_const_eq(root, equi_key_set, relids,
item1->key,
item1->sortop,
relids[i1],
item1,
sortop1,
item1_relids,
true);
/*
* We can remove the explicit outer join qual, too,
* We can remove explicit tests of this outer-join qual, too,
* since we now have tests forcing each of its sides
* to the same value.
*/
process_implied_equality(root,
leftop,
rightop,
leftop, rightop,
rinfo->left_sortop,
rinfo->right_sortop,
rinfo->left_relids,
rinfo->right_relids,
true);
/*
* And recurse to see if we can deduce anything from
* LEFTVAR = CONSTANT
*/
sub_generate_join_implications(root, equi_key_set, relids,
leftop,
rinfo->left_sortop,
rinfo->left_relids);
/* ... and RIGHTVAR = CONSTANT */
sub_generate_join_implications(root, equi_key_set, relids,
rightop,
rinfo->right_sortop,
rinfo->right_relids);
/* No need to match against remaining set members */
break;
}
i1++;
}
}
}
@ -537,10 +584,8 @@ generate_outer_join_implications(PlannerInfo *root,
* Apply process_implied_equality with the given item and each
* pseudoconstant member of equi_key_set.
*
* This is just a subroutine to save some cruft in
* generate_outer_join_implications. equi_key_set and relids are as in
* generate_outer_join_implications, the other parameters as for
* process_implied_equality.
* equi_key_set and relids are as for generate_outer_join_implications,
* the other parameters as for process_implied_equality.
*/
static void
process_implied_const_eq(PlannerInfo *root, List *equi_key_set, Relids *relids,