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

Make a marginal performance improvement in predicate_implied_by and 

predicate_refuted_by: if either top-level input is a single-element list,
reduce it to its lone member before proceeding.  This avoids
a useless level of AND-recursion within the recursive proof routines.
It's worth doing because, for example, if the clause is a 100-element
list and the predicate is a 1-element list then we'd otherwise strip
the predicate's list structure 100 times as we iterate through the clause.
It's only needed at top level because there won't be any trivial ANDs below
that --- this situation is an artifact of the decision to represent even
single-item conditions as Lists in the "implicit AND" format, and that format
is only used at the top level of any predicate or restriction condition.
This commit is contained in:
Tom Lane 2009-05-10 22:45:28 +00:00
parent 4db44b433b
commit 723476c72e
1 changed files with 41 additions and 7 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

48
src/backend/optimizer/util/predtest.c
View File

@ -9,7 +9,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/optimizer/util/predtest.c,v 1.24 2009/01/09 15:46:10 tgl Exp $
* $PostgreSQL: pgsql/src/backend/optimizer/util/predtest.c,v 1.25 2009/05/10 22:45:28 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@ -124,14 +124,31 @@ static void InvalidateOprProofCacheCallBack(Datum arg, int cacheid, ItemPointer
bool
predicate_implied_by(List *predicate_list, List *restrictinfo_list)
{
Node *p,
*r;
if (predicate_list == NIL)
return true; /* no predicate: implication is vacuous */
if (restrictinfo_list == NIL)
return false; /* no restriction: implication must fail */
/* Otherwise, away we go ... */
return predicate_implied_by_recurse((Node *) restrictinfo_list,
(Node *) predicate_list);
/*
* If either input is a single-element list, replace it with its lone
* member; this avoids one useless level of AND-recursion. We only need
* to worry about this at top level, since eval_const_expressions should
* have gotten rid of any trivial ANDs or ORs below that.
*/
if (list_length(predicate_list) == 1)
p = (Node *) linitial(predicate_list);
else
p = (Node *) predicate_list;
if (list_length(restrictinfo_list) == 1)
r = (Node *) linitial(restrictinfo_list);
else
r = (Node *) restrictinfo_list;
/* And away we go ... */
return predicate_implied_by_recurse(r, p);
}
/*
@ -165,14 +182,31 @@ predicate_implied_by(List *predicate_list, List *restrictinfo_list)
bool
predicate_refuted_by(List *predicate_list, List *restrictinfo_list)
{
Node *p,
*r;
if (predicate_list == NIL)
return false; /* no predicate: no refutation is possible */
if (restrictinfo_list == NIL)
return false; /* no restriction: refutation must fail */
/* Otherwise, away we go ... */
return predicate_refuted_by_recurse((Node *) restrictinfo_list,
(Node *) predicate_list);
/*
* If either input is a single-element list, replace it with its lone
* member; this avoids one useless level of AND-recursion. We only need
* to worry about this at top level, since eval_const_expressions should
* have gotten rid of any trivial ANDs or ORs below that.
*/
if (list_length(predicate_list) == 1)
p = (Node *) linitial(predicate_list);
else
p = (Node *) predicate_list;
if (list_length(restrictinfo_list) == 1)
r = (Node *) linitial(restrictinfo_list);
else
r = (Node *) restrictinfo_list;
/* And away we go ... */
return predicate_refuted_by_recurse(r, p);
}
/*----------