mirror/postgresql
2
0
Fork 0
mirror of https://git.postgresql.org/git/postgresql.git synced 2025-01-30 19:00:29 +08:00
Code Issues Packages Projects Releases Wiki Activity

Revert the logic for expanding AND/OR conditions in pred_test() to what

Browse Source 
it was in 7.4, and add some comments explaining why it has to be this way.
I broke it for OR'd index predicates in a fit of code cleanup last summer.
Per example from Sergey Koshcheyev.
This commit is contained in:
Tom Lane 2005-03-01 00:24:52 +00:00
parent 5c4a91c295
commit 4e89bae704
1 changed files with 69 additions and 54 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

123
src/backend/optimizer/path/indxpath.c
View File

@ -9,7 +9,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/optimizer/path/indxpath.c,v 1.167 2004/12/31 22:00:04 pgsql Exp $
* $PostgreSQL: pgsql/src/backend/optimizer/path/indxpath.c,v 1.168 2005/03/01 00:24:52 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@ -64,9 +64,9 @@ static bool match_join_clause_to_indexcol(RelOptInfo *rel, IndexOptInfo *index,
RestrictInfo *rinfo);
static Oid indexable_operator(Expr *clause, Oid opclass,
bool indexkey_on_left);
static bool pred_test_recurse_pred(Expr *predicate, List *restrictinfo_list);
static bool pred_test_restrict_list(Expr *predicate, List *restrictinfo_list);
static bool pred_test_recurse_restrict(Expr *predicate, Node *clause);
static bool pred_test_recurse_pred(Expr *predicate, Node *clause);
static bool pred_test_simple_clause(Expr *predicate, Node *clause);
static Relids indexable_outerrelids(RelOptInfo *rel, IndexOptInfo *index);
static Path *make_innerjoin_index_path(Query *root,
@ -749,11 +749,25 @@ check_partial_indexes(Query *root, RelOptInfo *rel)
* Recursively checks whether the clauses in restrictinfo_list imply
* that the given predicate is true.
*
* This routine (together with the routines it calls) first breaks down
* the predicate to its constituent AND/OR elements, then similarly
* breaks down the restriction clauses to AND/OR elements in an effort
* to prove that each predicate element is implied. The top-level
* List structure of each list corresponds to an AND list.
* This routine (together with the routines it calls) iterates over
* ANDs in the predicate first, then breaks down the restriction list
* to its constituent AND/OR elements, and iterates over ORs
* in the predicate last. This order is important to make the test
* succeed whenever possible. --Nels, Jan '93
*
* For example, a restriction (a OR b) certainly implies a predicate
* (a OR b OR c), but no one element of the predicate is individually
* implied by the restriction. By expanding the predicate ORs last
* we are able to prove that the whole predicate is implied by each arm
* of the restriction. Conversely consider predicate (a AND b) with
* restriction (a AND b AND c). This should be implied but we will
* fail to prove it if we dissect the restriction first.
*
* The top-level List structure of each list corresponds to an AND list.
* We assume that canonicalize_qual() has been applied and so there
* are no explicit ANDs immediately below the top-level List structure.
* (If this is not true we might fail to prove an implication that is
* valid, but no worse consequences will ensue.)
*/
bool
pred_test(List *predicate_list, List *restrictinfo_list)
@ -779,65 +793,23 @@ pred_test(List *predicate_list, List *restrictinfo_list)
return false; /* no restriction clauses: the test must
* fail */
/* Take care of the AND semantics of the top-level predicate list */
foreach(pred, predicate_list)
{
/*
* if any clause is not implied, the whole predicate is not
* implied.
*/
if (!pred_test_recurse_pred(lfirst(pred), restrictinfo_list))
if (!pred_test_restrict_list(lfirst(pred), restrictinfo_list))
return false;
}
return true;
}
/*
* pred_test_recurse_pred
* Does the "predicate inclusion test" for one conjunct of a predicate
* expression. Here we recursively deal with the possibility that the
* predicate conjunct is itself an AND or OR structure.
*/
static bool
pred_test_recurse_pred(Expr *predicate, List *restrictinfo_list)
{
List *items;
ListCell *item;
Assert(predicate != NULL);
if (or_clause((Node *) predicate))
{
items = ((BoolExpr *) predicate)->args;
foreach(item, items)
{
/* if any item is implied, the whole predicate is implied */
if (pred_test_recurse_pred(lfirst(item), restrictinfo_list))
return true;
}
return false;
}
else if (and_clause((Node *) predicate))
{
items = ((BoolExpr *) predicate)->args;
foreach(item, items)
{
/*
* if any item is not implied, the whole predicate is not
* implied
*/
if (!pred_test_recurse_pred(lfirst(item), restrictinfo_list))
return false;
}
return true;
}
else
return pred_test_restrict_list(predicate, restrictinfo_list);
}
/*
* pred_test_restrict_list
* Does the "predicate inclusion test" for one element of a predicate
* Does the "predicate inclusion test" for one AND clause of a predicate
* expression. Here we take care of the AND semantics of the top-level
* restrictinfo list.
*/
@ -859,10 +831,10 @@ pred_test_restrict_list(Expr *predicate, List *restrictinfo_list)
/*
* pred_test_recurse_restrict
* Does the "predicate inclusion test" for one element of a predicate
* Does the "predicate inclusion test" for one AND clause of a predicate
* expression. Here we recursively deal with the possibility that the
* restriction-list element is itself an AND or OR structure; also,
* we strip off RestrictInfo nodes to find bare predicate expressions.
* we strip off RestrictInfo nodes to find bare qualifier expressions.
*/
static bool
pred_test_recurse_restrict(Expr *predicate, Node *clause)
@ -903,6 +875,49 @@ pred_test_recurse_restrict(Expr *predicate, Node *clause)
}
return false;
}
else
return pred_test_recurse_pred(predicate, clause);
}
/*
* pred_test_recurse_pred
* Does the "predicate inclusion test" for one conjunct of a predicate
* expression. Here we recursively deal with the possibility that the
* predicate conjunct is itself an AND or OR structure.
*/
static bool
pred_test_recurse_pred(Expr *predicate, Node *clause)
{
List *items;
ListCell *item;
Assert(predicate != NULL);
if (or_clause((Node *) predicate))
{
items = ((BoolExpr *) predicate)->args;
foreach(item, items)
{
/* if any item is implied, the whole predicate is implied */
if (pred_test_recurse_pred(lfirst(item), clause))
return true;
}
return false;
}
else if (and_clause((Node *) predicate))
{
items = ((BoolExpr *) predicate)->args;
foreach(item, items)
{
/*
* if any item is not implied, the whole predicate is not
* implied
*/
if (!pred_test_recurse_pred(lfirst(item), clause))
return false;
}
return true;
}
else
return pred_test_simple_clause(predicate, clause);
}