mirror of
https://github.com/postgres/postgres.git
synced 2025-07-09 22:41:56 +03:00
Fix some planner performance problems with large WHERE clauses, by
introducing new 'FastList' list-construction subroutines to use in hot spots. This avoids the O(N^2) behavior of repeated lappend's by keeping a tail pointer, while not changing behavior by reversing list order as the lcons() method would do.
This commit is contained in:
@ -9,7 +9,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/indxpath.c,v 1.142 2003/05/28 16:03:56 tgl Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/indxpath.c,v 1.143 2003/05/28 22:32:49 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -417,10 +417,11 @@ extract_or_indexqual_conditions(RelOptInfo *rel,
|
||||
IndexOptInfo *index,
|
||||
Expr *orsubclause)
|
||||
{
|
||||
List *quals = NIL;
|
||||
FastList quals;
|
||||
int indexcol = 0;
|
||||
Oid *classes = index->classlist;
|
||||
|
||||
FastListInit(&quals);
|
||||
/*
|
||||
* Extract relevant indexclauses in indexkey order. This is
|
||||
* essentially just like group_clauses_by_indexkey() except that the
|
||||
@ -430,9 +431,10 @@ extract_or_indexqual_conditions(RelOptInfo *rel,
|
||||
do
|
||||
{
|
||||
Oid curClass = classes[0];
|
||||
List *clausegroup = NIL;
|
||||
FastList clausegroup;
|
||||
List *item;
|
||||
|
||||
FastListInit(&clausegroup);
|
||||
if (and_clause((Node *) orsubclause))
|
||||
{
|
||||
foreach(item, ((BoolExpr *) orsubclause)->args)
|
||||
@ -442,21 +444,23 @@ extract_or_indexqual_conditions(RelOptInfo *rel,
|
||||
if (match_clause_to_indexcol(rel, index,
|
||||
indexcol, curClass,
|
||||
subsubclause))
|
||||
clausegroup = nconc(clausegroup,
|
||||
expand_indexqual_condition(subsubclause,
|
||||
curClass));
|
||||
FastConc(&clausegroup,
|
||||
expand_indexqual_condition(subsubclause,
|
||||
curClass));
|
||||
}
|
||||
}
|
||||
else if (match_clause_to_indexcol(rel, index,
|
||||
indexcol, curClass,
|
||||
orsubclause))
|
||||
clausegroup = expand_indexqual_condition(orsubclause, curClass);
|
||||
FastConc(&clausegroup,
|
||||
expand_indexqual_condition(orsubclause,
|
||||
curClass));
|
||||
|
||||
/*
|
||||
* If we found no clauses for this indexkey in the OR subclause
|
||||
* itself, try looking in the rel's top-level restriction list.
|
||||
*/
|
||||
if (clausegroup == NIL)
|
||||
if (FastListValue(&clausegroup) == NIL)
|
||||
{
|
||||
foreach(item, rel->baserestrictinfo)
|
||||
{
|
||||
@ -465,9 +469,9 @@ extract_or_indexqual_conditions(RelOptInfo *rel,
|
||||
if (match_clause_to_indexcol(rel, index,
|
||||
indexcol, curClass,
|
||||
rinfo->clause))
|
||||
clausegroup = nconc(clausegroup,
|
||||
expand_indexqual_condition(rinfo->clause,
|
||||
curClass));
|
||||
FastConc(&clausegroup,
|
||||
expand_indexqual_condition(rinfo->clause,
|
||||
curClass));
|
||||
}
|
||||
}
|
||||
|
||||
@ -475,20 +479,20 @@ extract_or_indexqual_conditions(RelOptInfo *rel,
|
||||
* If still no clauses match this key, we're done; we don't want
|
||||
* to look at keys to its right.
|
||||
*/
|
||||
if (clausegroup == NIL)
|
||||
if (FastListValue(&clausegroup) == NIL)
|
||||
break;
|
||||
|
||||
quals = nconc(quals, clausegroup);
|
||||
FastConcFast(&quals, &clausegroup);
|
||||
|
||||
indexcol++;
|
||||
classes++;
|
||||
|
||||
} while (!DoneMatchingIndexKeys(classes));
|
||||
|
||||
if (quals == NIL)
|
||||
if (FastListValue(&quals) == NIL)
|
||||
elog(ERROR, "extract_or_indexqual_conditions: no matching clause");
|
||||
|
||||
return quals;
|
||||
return FastListValue(&quals);
|
||||
}
|
||||
|
||||
|
||||
@ -520,7 +524,7 @@ extract_or_indexqual_conditions(RelOptInfo *rel,
|
||||
static List *
|
||||
group_clauses_by_indexkey(RelOptInfo *rel, IndexOptInfo *index)
|
||||
{
|
||||
List *clausegroup_list = NIL;
|
||||
FastList clausegroup_list;
|
||||
List *restrictinfo_list = rel->baserestrictinfo;
|
||||
int indexcol = 0;
|
||||
Oid *classes = index->classlist;
|
||||
@ -528,12 +532,14 @@ group_clauses_by_indexkey(RelOptInfo *rel, IndexOptInfo *index)
|
||||
if (restrictinfo_list == NIL)
|
||||
return NIL;
|
||||
|
||||
FastListInit(&clausegroup_list);
|
||||
do
|
||||
{
|
||||
Oid curClass = classes[0];
|
||||
List *clausegroup = NIL;
|
||||
FastList clausegroup;
|
||||
List *i;
|
||||
|
||||
FastListInit(&clausegroup);
|
||||
foreach(i, restrictinfo_list)
|
||||
{
|
||||
RestrictInfo *rinfo = (RestrictInfo *) lfirst(i);
|
||||
@ -543,24 +549,24 @@ group_clauses_by_indexkey(RelOptInfo *rel, IndexOptInfo *index)
|
||||
indexcol,
|
||||
curClass,
|
||||
rinfo->clause))
|
||||
clausegroup = lappend(clausegroup, rinfo);
|
||||
FastAppend(&clausegroup, rinfo);
|
||||
}
|
||||
|
||||
/*
|
||||
* If no clauses match this key, we're done; we don't want to look
|
||||
* at keys to its right.
|
||||
*/
|
||||
if (clausegroup == NIL)
|
||||
if (FastListValue(&clausegroup) == NIL)
|
||||
break;
|
||||
|
||||
clausegroup_list = lappend(clausegroup_list, clausegroup);
|
||||
FastAppend(&clausegroup_list, FastListValue(&clausegroup));
|
||||
|
||||
indexcol++;
|
||||
classes++;
|
||||
|
||||
} while (!DoneMatchingIndexKeys(classes));
|
||||
|
||||
return clausegroup_list;
|
||||
return FastListValue(&clausegroup_list);
|
||||
}
|
||||
|
||||
/*
|
||||
@ -580,17 +586,20 @@ static List *
|
||||
group_clauses_by_indexkey_for_join(RelOptInfo *rel, IndexOptInfo *index,
|
||||
Relids outer_relids, bool isouterjoin)
|
||||
{
|
||||
List *clausegroup_list = NIL;
|
||||
FastList clausegroup_list;
|
||||
bool jfound = false;
|
||||
int indexcol = 0;
|
||||
Oid *classes = index->classlist;
|
||||
|
||||
FastListInit(&clausegroup_list);
|
||||
do
|
||||
{
|
||||
Oid curClass = classes[0];
|
||||
List *clausegroup = NIL;
|
||||
FastList clausegroup;
|
||||
List *i;
|
||||
|
||||
FastListInit(&clausegroup);
|
||||
|
||||
/* Look for joinclauses that are usable with given outer_relids */
|
||||
foreach(i, rel->joininfo)
|
||||
{
|
||||
@ -614,7 +623,7 @@ group_clauses_by_indexkey_for_join(RelOptInfo *rel, IndexOptInfo *index,
|
||||
curClass,
|
||||
rinfo->clause))
|
||||
{
|
||||
clausegroup = lappend(clausegroup, rinfo);
|
||||
FastAppend(&clausegroup, rinfo);
|
||||
jfound = true;
|
||||
}
|
||||
}
|
||||
@ -634,17 +643,17 @@ group_clauses_by_indexkey_for_join(RelOptInfo *rel, IndexOptInfo *index,
|
||||
indexcol,
|
||||
curClass,
|
||||
rinfo->clause))
|
||||
clausegroup = lappend(clausegroup, rinfo);
|
||||
FastAppend(&clausegroup, rinfo);
|
||||
}
|
||||
|
||||
/*
|
||||
* If no clauses match this key, we're done; we don't want to look
|
||||
* at keys to its right.
|
||||
*/
|
||||
if (clausegroup == NIL)
|
||||
if (FastListValue(&clausegroup) == NIL)
|
||||
break;
|
||||
|
||||
clausegroup_list = lappend(clausegroup_list, clausegroup);
|
||||
FastAppend(&clausegroup_list, FastListValue(&clausegroup));
|
||||
|
||||
indexcol++;
|
||||
classes++;
|
||||
@ -653,12 +662,9 @@ group_clauses_by_indexkey_for_join(RelOptInfo *rel, IndexOptInfo *index,
|
||||
|
||||
/* if no join clause was matched then forget it, per comments above */
|
||||
if (!jfound)
|
||||
{
|
||||
freeList(clausegroup_list);
|
||||
return NIL;
|
||||
}
|
||||
|
||||
return clausegroup_list;
|
||||
return FastListValue(&clausegroup_list);
|
||||
}
|
||||
|
||||
|
||||
@ -1870,12 +1876,13 @@ match_special_index_operator(Expr *clause, Oid opclass,
|
||||
List *
|
||||
expand_indexqual_conditions(IndexOptInfo *index, List *clausegroups)
|
||||
{
|
||||
List *resultquals = NIL;
|
||||
FastList resultquals;
|
||||
Oid *classes = index->classlist;
|
||||
|
||||
if (clausegroups == NIL)
|
||||
return NIL;
|
||||
|
||||
FastListInit(&resultquals);
|
||||
do
|
||||
{
|
||||
Oid curClass = classes[0];
|
||||
@ -1885,9 +1892,9 @@ expand_indexqual_conditions(IndexOptInfo *index, List *clausegroups)
|
||||
{
|
||||
RestrictInfo *rinfo = (RestrictInfo *) lfirst(i);
|
||||
|
||||
resultquals = nconc(resultquals,
|
||||
expand_indexqual_condition(rinfo->clause,
|
||||
curClass));
|
||||
FastConc(&resultquals,
|
||||
expand_indexqual_condition(rinfo->clause,
|
||||
curClass));
|
||||
}
|
||||
|
||||
clausegroups = lnext(clausegroups);
|
||||
@ -1898,7 +1905,7 @@ expand_indexqual_conditions(IndexOptInfo *index, List *clausegroups)
|
||||
|
||||
Assert(clausegroups == NIL); /* else more groups than indexkeys... */
|
||||
|
||||
return resultquals;
|
||||
return FastListValue(&resultquals);
|
||||
}
|
||||
|
||||
/*
|
||||
|
@ -8,7 +8,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/orindxpath.c,v 1.49 2002/12/12 15:49:31 tgl Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/orindxpath.c,v 1.50 2003/05/28 22:32:49 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -149,10 +149,12 @@ best_or_subclause_indices(Query *root,
|
||||
List *indices,
|
||||
IndexPath *pathnode)
|
||||
{
|
||||
FastList infos;
|
||||
FastList quals;
|
||||
List *slist;
|
||||
|
||||
pathnode->indexinfo = NIL;
|
||||
pathnode->indexqual = NIL;
|
||||
FastListInit(&infos);
|
||||
FastListInit(&quals);
|
||||
pathnode->path.startup_cost = 0;
|
||||
pathnode->path.total_cost = 0;
|
||||
|
||||
@ -170,14 +172,17 @@ best_or_subclause_indices(Query *root,
|
||||
|
||||
Assert(best_indexinfo != NULL);
|
||||
|
||||
pathnode->indexinfo = lappend(pathnode->indexinfo, best_indexinfo);
|
||||
pathnode->indexqual = lappend(pathnode->indexqual, best_indexqual);
|
||||
FastAppend(&infos, best_indexinfo);
|
||||
FastAppend(&quals, best_indexqual);
|
||||
if (slist == subclauses) /* first scan? */
|
||||
pathnode->path.startup_cost = best_startup_cost;
|
||||
pathnode->path.total_cost += best_total_cost;
|
||||
|
||||
indices = lnext(indices);
|
||||
}
|
||||
|
||||
pathnode->indexinfo = FastListValue(&infos);
|
||||
pathnode->indexqual = FastListValue(&quals);
|
||||
}
|
||||
|
||||
/*
|
||||
|
@ -8,7 +8,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/prep/prepqual.c,v 1.34 2002/12/12 15:49:32 tgl Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/prep/prepqual.c,v 1.35 2003/05/28 22:32:49 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -21,8 +21,12 @@
|
||||
#include "utils/lsyscache.h"
|
||||
|
||||
static Expr *flatten_andors(Expr *qual);
|
||||
static List *pull_ors(List *orlist);
|
||||
static void flatten_andors_and_walker(FastList *out_list, List *andlist);
|
||||
static void flatten_andors_or_walker(FastList *out_list, List *orlist);
|
||||
static List *pull_ands(List *andlist);
|
||||
static void pull_ands_walker(FastList *out_list, List *andlist);
|
||||
static List *pull_ors(List *orlist);
|
||||
static void pull_ors_walker(FastList *out_list, List *orlist);
|
||||
static Expr *find_nots(Expr *qual);
|
||||
static Expr *push_nots(Expr *qual);
|
||||
static Expr *find_ors(Expr *qual);
|
||||
@ -291,47 +295,19 @@ flatten_andors(Expr *qual)
|
||||
|
||||
if (and_clause((Node *) qual))
|
||||
{
|
||||
List *out_list = NIL;
|
||||
List *arg;
|
||||
FastList out_list;
|
||||
|
||||
foreach(arg, ((BoolExpr *) qual)->args)
|
||||
{
|
||||
Expr *subexpr = flatten_andors((Expr *) lfirst(arg));
|
||||
|
||||
/*
|
||||
* Note: we can destructively nconc the subexpression's
|
||||
* arglist because we know the recursive invocation of
|
||||
* flatten_andors will have built a new arglist not shared
|
||||
* with any other expr. Otherwise we'd need a listCopy here.
|
||||
*/
|
||||
if (and_clause((Node *) subexpr))
|
||||
out_list = nconc(out_list, ((BoolExpr *) subexpr)->args);
|
||||
else
|
||||
out_list = lappend(out_list, subexpr);
|
||||
}
|
||||
return make_andclause(out_list);
|
||||
FastListInit(&out_list);
|
||||
flatten_andors_and_walker(&out_list, ((BoolExpr *) qual)->args);
|
||||
return make_andclause(FastListValue(&out_list));
|
||||
}
|
||||
else if (or_clause((Node *) qual))
|
||||
{
|
||||
List *out_list = NIL;
|
||||
List *arg;
|
||||
FastList out_list;
|
||||
|
||||
foreach(arg, ((BoolExpr *) qual)->args)
|
||||
{
|
||||
Expr *subexpr = flatten_andors((Expr *) lfirst(arg));
|
||||
|
||||
/*
|
||||
* Note: we can destructively nconc the subexpression's
|
||||
* arglist because we know the recursive invocation of
|
||||
* flatten_andors will have built a new arglist not shared
|
||||
* with any other expr. Otherwise we'd need a listCopy here.
|
||||
*/
|
||||
if (or_clause((Node *) subexpr))
|
||||
out_list = nconc(out_list, ((BoolExpr *) subexpr)->args);
|
||||
else
|
||||
out_list = lappend(out_list, subexpr);
|
||||
}
|
||||
return make_orclause(out_list);
|
||||
FastListInit(&out_list);
|
||||
flatten_andors_or_walker(&out_list, ((BoolExpr *) qual)->args);
|
||||
return make_orclause(FastListValue(&out_list));
|
||||
}
|
||||
else if (not_clause((Node *) qual))
|
||||
return make_notclause(flatten_andors(get_notclausearg(qual)));
|
||||
@ -351,10 +327,74 @@ flatten_andors(Expr *qual)
|
||||
return qual;
|
||||
}
|
||||
|
||||
static void
|
||||
flatten_andors_and_walker(FastList *out_list, List *andlist)
|
||||
{
|
||||
List *arg;
|
||||
|
||||
foreach(arg, andlist)
|
||||
{
|
||||
Expr *subexpr = (Expr *) lfirst(arg);
|
||||
|
||||
if (and_clause((Node *) subexpr))
|
||||
flatten_andors_and_walker(out_list, ((BoolExpr *) subexpr)->args);
|
||||
else
|
||||
FastAppend(out_list, flatten_andors(subexpr));
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
flatten_andors_or_walker(FastList *out_list, List *orlist)
|
||||
{
|
||||
List *arg;
|
||||
|
||||
foreach(arg, orlist)
|
||||
{
|
||||
Expr *subexpr = (Expr *) lfirst(arg);
|
||||
|
||||
if (or_clause((Node *) subexpr))
|
||||
flatten_andors_or_walker(out_list, ((BoolExpr *) subexpr)->args);
|
||||
else
|
||||
FastAppend(out_list, flatten_andors(subexpr));
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* pull_ands
|
||||
* Recursively flatten nested AND clauses into a single and-clause list.
|
||||
*
|
||||
* Input is the arglist of an AND clause.
|
||||
* Returns the rebuilt arglist (note original list structure is not touched).
|
||||
*/
|
||||
static List *
|
||||
pull_ands(List *andlist)
|
||||
{
|
||||
FastList out_list;
|
||||
|
||||
FastListInit(&out_list);
|
||||
pull_ands_walker(&out_list, andlist);
|
||||
return FastListValue(&out_list);
|
||||
}
|
||||
|
||||
static void
|
||||
pull_ands_walker(FastList *out_list, List *andlist)
|
||||
{
|
||||
List *arg;
|
||||
|
||||
foreach(arg, andlist)
|
||||
{
|
||||
Expr *subexpr = (Expr *) lfirst(arg);
|
||||
|
||||
if (and_clause((Node *) subexpr))
|
||||
pull_ands_walker(out_list, ((BoolExpr *) subexpr)->args);
|
||||
else
|
||||
FastAppend(out_list, subexpr);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* pull_ors
|
||||
* Pull the arguments of an 'or' clause nested within another 'or'
|
||||
* clause up into the argument list of the parent.
|
||||
* Recursively flatten nested OR clauses into a single or-clause list.
|
||||
*
|
||||
* Input is the arglist of an OR clause.
|
||||
* Returns the rebuilt arglist (note original list structure is not touched).
|
||||
@ -362,58 +402,27 @@ flatten_andors(Expr *qual)
|
||||
static List *
|
||||
pull_ors(List *orlist)
|
||||
{
|
||||
List *out_list = NIL;
|
||||
FastList out_list;
|
||||
|
||||
FastListInit(&out_list);
|
||||
pull_ors_walker(&out_list, orlist);
|
||||
return FastListValue(&out_list);
|
||||
}
|
||||
|
||||
static void
|
||||
pull_ors_walker(FastList *out_list, List *orlist)
|
||||
{
|
||||
List *arg;
|
||||
|
||||
foreach(arg, orlist)
|
||||
{
|
||||
Expr *subexpr = (Expr *) lfirst(arg);
|
||||
|
||||
/*
|
||||
* Note: we can destructively nconc the subexpression's arglist
|
||||
* because we know the recursive invocation of pull_ors will have
|
||||
* built a new arglist not shared with any other expr. Otherwise
|
||||
* we'd need a listCopy here.
|
||||
*/
|
||||
if (or_clause((Node *) subexpr))
|
||||
out_list = nconc(out_list,
|
||||
pull_ors(((BoolExpr *) subexpr)->args));
|
||||
pull_ors_walker(out_list, ((BoolExpr *) subexpr)->args);
|
||||
else
|
||||
out_list = lappend(out_list, subexpr);
|
||||
FastAppend(out_list, subexpr);
|
||||
}
|
||||
return out_list;
|
||||
}
|
||||
|
||||
/*
|
||||
* pull_ands
|
||||
* Pull the arguments of an 'and' clause nested within another 'and'
|
||||
* clause up into the argument list of the parent.
|
||||
*
|
||||
* Returns the modified list.
|
||||
*/
|
||||
static List *
|
||||
pull_ands(List *andlist)
|
||||
{
|
||||
List *out_list = NIL;
|
||||
List *arg;
|
||||
|
||||
foreach(arg, andlist)
|
||||
{
|
||||
Expr *subexpr = (Expr *) lfirst(arg);
|
||||
|
||||
/*
|
||||
* Note: we can destructively nconc the subexpression's arglist
|
||||
* because we know the recursive invocation of pull_ands will have
|
||||
* built a new arglist not shared with any other expr. Otherwise
|
||||
* we'd need a listCopy here.
|
||||
*/
|
||||
if (and_clause((Node *) subexpr))
|
||||
out_list = nconc(out_list,
|
||||
pull_ands(((BoolExpr *) subexpr)->args));
|
||||
else
|
||||
out_list = lappend(out_list, subexpr);
|
||||
}
|
||||
return out_list;
|
||||
}
|
||||
|
||||
/*
|
||||
@ -447,21 +456,23 @@ find_nots(Expr *qual)
|
||||
#endif
|
||||
if (and_clause((Node *) qual))
|
||||
{
|
||||
List *t_list = NIL;
|
||||
FastList t_list;
|
||||
List *temp;
|
||||
|
||||
FastListInit(&t_list);
|
||||
foreach(temp, ((BoolExpr *) qual)->args)
|
||||
t_list = lappend(t_list, find_nots(lfirst(temp)));
|
||||
return make_andclause(pull_ands(t_list));
|
||||
FastAppend(&t_list, find_nots(lfirst(temp)));
|
||||
return make_andclause(pull_ands(FastListValue(&t_list)));
|
||||
}
|
||||
else if (or_clause((Node *) qual))
|
||||
{
|
||||
List *t_list = NIL;
|
||||
FastList t_list;
|
||||
List *temp;
|
||||
|
||||
FastListInit(&t_list);
|
||||
foreach(temp, ((BoolExpr *) qual)->args)
|
||||
t_list = lappend(t_list, find_nots(lfirst(temp)));
|
||||
return make_orclause(pull_ors(t_list));
|
||||
FastAppend(&t_list, find_nots(lfirst(temp)));
|
||||
return make_orclause(pull_ors(FastListValue(&t_list)));
|
||||
}
|
||||
else if (not_clause((Node *) qual))
|
||||
return push_nots(get_notclausearg(qual));
|
||||
@ -511,21 +522,23 @@ push_nots(Expr *qual)
|
||||
* i.e., swap AND for OR and negate all the subclauses.
|
||||
*--------------------
|
||||
*/
|
||||
List *t_list = NIL;
|
||||
FastList t_list;
|
||||
List *temp;
|
||||
|
||||
FastListInit(&t_list);
|
||||
foreach(temp, ((BoolExpr *) qual)->args)
|
||||
t_list = lappend(t_list, push_nots(lfirst(temp)));
|
||||
return make_orclause(pull_ors(t_list));
|
||||
FastAppend(&t_list, push_nots(lfirst(temp)));
|
||||
return make_orclause(pull_ors(FastListValue(&t_list)));
|
||||
}
|
||||
else if (or_clause((Node *) qual))
|
||||
{
|
||||
List *t_list = NIL;
|
||||
FastList t_list;
|
||||
List *temp;
|
||||
|
||||
FastListInit(&t_list);
|
||||
foreach(temp, ((BoolExpr *) qual)->args)
|
||||
t_list = lappend(t_list, push_nots(lfirst(temp)));
|
||||
return make_andclause(pull_ands(t_list));
|
||||
FastAppend(&t_list, push_nots(lfirst(temp)));
|
||||
return make_andclause(pull_ands(FastListValue(&t_list)));
|
||||
}
|
||||
else if (not_clause((Node *) qual))
|
||||
{
|
||||
|
@ -8,7 +8,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/util/clauses.c,v 1.137 2003/05/28 16:03:56 tgl Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/util/clauses.c,v 1.138 2003/05/28 22:32:49 tgl Exp $
|
||||
*
|
||||
* HISTORY
|
||||
* AUTHOR DATE MAJOR EVENT
|
||||
@ -771,21 +771,24 @@ is_pseudo_constant_clause(Node *clause)
|
||||
List *
|
||||
pull_constant_clauses(List *quals, List **constantQual)
|
||||
{
|
||||
List *constqual = NIL;
|
||||
List *restqual = NIL;
|
||||
FastList constqual,
|
||||
restqual;
|
||||
List *q;
|
||||
|
||||
FastListInit(&constqual);
|
||||
FastListInit(&restqual);
|
||||
|
||||
foreach(q, quals)
|
||||
{
|
||||
Node *qual = (Node *) lfirst(q);
|
||||
|
||||
if (is_pseudo_constant_clause(qual))
|
||||
constqual = lappend(constqual, qual);
|
||||
FastAppend(&constqual, qual);
|
||||
else
|
||||
restqual = lappend(restqual, qual);
|
||||
FastAppend(&restqual, qual);
|
||||
}
|
||||
*constantQual = constqual;
|
||||
return restqual;
|
||||
*constantQual = FastListValue(&constqual);
|
||||
return FastListValue(&restqual);
|
||||
}
|
||||
|
||||
|
||||
@ -1187,16 +1190,17 @@ eval_const_expressions_mutator(Node *node, List *active_fns)
|
||||
* when no input is TRUE and at least one is NULL.
|
||||
*----------
|
||||
*/
|
||||
List *newargs = NIL;
|
||||
FastList newargs;
|
||||
List *arg;
|
||||
bool haveNull = false;
|
||||
bool forceTrue = false;
|
||||
|
||||
FastListInit(&newargs);
|
||||
foreach(arg, args)
|
||||
{
|
||||
if (!IsA(lfirst(arg), Const))
|
||||
{
|
||||
newargs = lappend(newargs, lfirst(arg));
|
||||
FastAppend(&newargs, lfirst(arg));
|
||||
continue;
|
||||
}
|
||||
const_input = (Const *) lfirst(arg);
|
||||
@ -1217,15 +1221,15 @@ eval_const_expressions_mutator(Node *node, List *active_fns)
|
||||
if (forceTrue)
|
||||
return MAKEBOOLCONST(true, false);
|
||||
if (haveNull)
|
||||
newargs = lappend(newargs, MAKEBOOLCONST(false, true));
|
||||
FastAppend(&newargs, MAKEBOOLCONST(false, true));
|
||||
/* If all the inputs are FALSE, result is FALSE */
|
||||
if (newargs == NIL)
|
||||
if (FastListValue(&newargs) == NIL)
|
||||
return MAKEBOOLCONST(false, false);
|
||||
/* If only one nonconst-or-NULL input, it's the result */
|
||||
if (lnext(newargs) == NIL)
|
||||
return (Node *) lfirst(newargs);
|
||||
if (lnext(FastListValue(&newargs)) == NIL)
|
||||
return (Node *) lfirst(FastListValue(&newargs));
|
||||
/* Else we still need an OR node */
|
||||
return (Node *) make_orclause(newargs);
|
||||
return (Node *) make_orclause(FastListValue(&newargs));
|
||||
}
|
||||
case AND_EXPR:
|
||||
{
|
||||
@ -1239,16 +1243,17 @@ eval_const_expressions_mutator(Node *node, List *active_fns)
|
||||
* when no input is FALSE and at least one is NULL.
|
||||
*----------
|
||||
*/
|
||||
List *newargs = NIL;
|
||||
FastList newargs;
|
||||
List *arg;
|
||||
bool haveNull = false;
|
||||
bool forceFalse = false;
|
||||
|
||||
FastListInit(&newargs);
|
||||
foreach(arg, args)
|
||||
{
|
||||
if (!IsA(lfirst(arg), Const))
|
||||
{
|
||||
newargs = lappend(newargs, lfirst(arg));
|
||||
FastAppend(&newargs, lfirst(arg));
|
||||
continue;
|
||||
}
|
||||
const_input = (Const *) lfirst(arg);
|
||||
@ -1269,15 +1274,15 @@ eval_const_expressions_mutator(Node *node, List *active_fns)
|
||||
if (forceFalse)
|
||||
return MAKEBOOLCONST(false, false);
|
||||
if (haveNull)
|
||||
newargs = lappend(newargs, MAKEBOOLCONST(false, true));
|
||||
FastAppend(&newargs, MAKEBOOLCONST(false, true));
|
||||
/* If all the inputs are TRUE, result is TRUE */
|
||||
if (newargs == NIL)
|
||||
if (FastListValue(&newargs) == NIL)
|
||||
return MAKEBOOLCONST(true, false);
|
||||
/* If only one nonconst-or-NULL input, it's the result */
|
||||
if (lnext(newargs) == NIL)
|
||||
return (Node *) lfirst(newargs);
|
||||
if (lnext(FastListValue(&newargs)) == NIL)
|
||||
return (Node *) lfirst(FastListValue(&newargs));
|
||||
/* Else we still need an AND node */
|
||||
return (Node *) make_andclause(newargs);
|
||||
return (Node *) make_andclause(FastListValue(&newargs));
|
||||
}
|
||||
case NOT_EXPR:
|
||||
Assert(length(args) == 1);
|
||||
@ -1370,11 +1375,12 @@ eval_const_expressions_mutator(Node *node, List *active_fns)
|
||||
*/
|
||||
CaseExpr *caseexpr = (CaseExpr *) node;
|
||||
CaseExpr *newcase;
|
||||
List *newargs = NIL;
|
||||
FastList newargs;
|
||||
Node *defresult;
|
||||
Const *const_input;
|
||||
List *arg;
|
||||
|
||||
FastListInit(&newargs);
|
||||
foreach(arg, caseexpr->args)
|
||||
{
|
||||
/* Simplify this alternative's condition and result */
|
||||
@ -1387,7 +1393,7 @@ eval_const_expressions_mutator(Node *node, List *active_fns)
|
||||
if (casewhen->expr == NULL ||
|
||||
!IsA(casewhen->expr, Const))
|
||||
{
|
||||
newargs = lappend(newargs, casewhen);
|
||||
FastAppend(&newargs, casewhen);
|
||||
continue;
|
||||
}
|
||||
const_input = (Const *) casewhen->expr;
|
||||
@ -1399,13 +1405,13 @@ eval_const_expressions_mutator(Node *node, List *active_fns)
|
||||
* Found a TRUE condition. If it's the first (un-dropped)
|
||||
* alternative, the CASE reduces to just this alternative.
|
||||
*/
|
||||
if (newargs == NIL)
|
||||
if (FastListValue(&newargs) == NIL)
|
||||
return (Node *) casewhen->result;
|
||||
|
||||
/*
|
||||
* Otherwise, add it to the list, and drop all the rest.
|
||||
*/
|
||||
newargs = lappend(newargs, casewhen);
|
||||
FastAppend(&newargs, casewhen);
|
||||
break;
|
||||
}
|
||||
|
||||
@ -1417,13 +1423,13 @@ eval_const_expressions_mutator(Node *node, List *active_fns)
|
||||
* If no non-FALSE alternatives, CASE reduces to the default
|
||||
* result
|
||||
*/
|
||||
if (newargs == NIL)
|
||||
if (FastListValue(&newargs) == NIL)
|
||||
return defresult;
|
||||
/* Otherwise we need a new CASE node */
|
||||
newcase = makeNode(CaseExpr);
|
||||
newcase->casetype = caseexpr->casetype;
|
||||
newcase->arg = NULL;
|
||||
newcase->args = newargs;
|
||||
newcase->args = FastListValue(&newargs);
|
||||
newcase->defresult = (Expr *) defresult;
|
||||
return (Node *) newcase;
|
||||
}
|
||||
@ -1432,9 +1438,10 @@ eval_const_expressions_mutator(Node *node, List *active_fns)
|
||||
ArrayExpr *arrayexpr = (ArrayExpr *) node;
|
||||
ArrayExpr *newarray;
|
||||
bool all_const = true;
|
||||
List *newelems = NIL;
|
||||
FastList newelems;
|
||||
List *element;
|
||||
|
||||
FastListInit(&newelems);
|
||||
foreach(element, arrayexpr->elements)
|
||||
{
|
||||
Node *e;
|
||||
@ -1443,13 +1450,13 @@ eval_const_expressions_mutator(Node *node, List *active_fns)
|
||||
active_fns);
|
||||
if (!IsA(e, Const))
|
||||
all_const = false;
|
||||
newelems = lappend(newelems, e);
|
||||
FastAppend(&newelems, e);
|
||||
}
|
||||
|
||||
newarray = makeNode(ArrayExpr);
|
||||
newarray->array_typeid = arrayexpr->array_typeid;
|
||||
newarray->element_typeid = arrayexpr->element_typeid;
|
||||
newarray->elements = newelems;
|
||||
newarray->elements = FastListValue(&newelems);
|
||||
newarray->ndims = arrayexpr->ndims;
|
||||
|
||||
if (all_const)
|
||||
@ -1462,9 +1469,10 @@ eval_const_expressions_mutator(Node *node, List *active_fns)
|
||||
{
|
||||
CoalesceExpr *coalesceexpr = (CoalesceExpr *) node;
|
||||
CoalesceExpr *newcoalesce;
|
||||
List *newargs = NIL;
|
||||
FastList newargs;
|
||||
List *arg;
|
||||
|
||||
FastListInit(&newargs);
|
||||
foreach(arg, coalesceexpr->args)
|
||||
{
|
||||
Node *e;
|
||||
@ -1480,15 +1488,15 @@ eval_const_expressions_mutator(Node *node, List *active_fns)
|
||||
{
|
||||
if (((Const *) e)->constisnull)
|
||||
continue; /* drop null constant */
|
||||
if (newargs == NIL)
|
||||
if (FastListValue(&newargs) == NIL)
|
||||
return e; /* first expr */
|
||||
}
|
||||
newargs = lappend(newargs, e);
|
||||
FastAppend(&newargs, e);
|
||||
}
|
||||
|
||||
newcoalesce = makeNode(CoalesceExpr);
|
||||
newcoalesce->coalescetype = coalesceexpr->coalescetype;
|
||||
newcoalesce->args = newargs;
|
||||
newcoalesce->args = FastListValue(&newargs);
|
||||
return (Node *) newcoalesce;
|
||||
}
|
||||
if (IsA(node, FieldSelect))
|
||||
@ -2647,16 +2655,16 @@ expression_tree_mutator(Node *node,
|
||||
* NOTE: this would fail badly on a list with integer
|
||||
* elements!
|
||||
*/
|
||||
List *resultlist = NIL;
|
||||
FastList resultlist;
|
||||
List *temp;
|
||||
|
||||
FastListInit(&resultlist);
|
||||
foreach(temp, (List *) node)
|
||||
{
|
||||
resultlist = lappend(resultlist,
|
||||
mutator((Node *) lfirst(temp),
|
||||
context));
|
||||
FastAppend(&resultlist,
|
||||
mutator((Node *) lfirst(temp), context));
|
||||
}
|
||||
return (Node *) resultlist;
|
||||
return (Node *) FastListValue(&resultlist);
|
||||
}
|
||||
break;
|
||||
case T_FromExpr:
|
||||
@ -2739,7 +2747,7 @@ query_tree_mutator(Query *query,
|
||||
void *context,
|
||||
int flags)
|
||||
{
|
||||
List *newrt = NIL;
|
||||
FastList newrt;
|
||||
List *rt;
|
||||
|
||||
Assert(query != NULL && IsA(query, Query));
|
||||
@ -2757,6 +2765,7 @@ query_tree_mutator(Query *query,
|
||||
MUTATE(query->setOperations, query->setOperations, Node *);
|
||||
MUTATE(query->havingQual, query->havingQual, Node *);
|
||||
MUTATE(query->in_info_list, query->in_info_list, List *);
|
||||
FastListInit(&newrt);
|
||||
foreach(rt, query->rtable)
|
||||
{
|
||||
RangeTblEntry *rte = (RangeTblEntry *) lfirst(rt);
|
||||
@ -2791,9 +2800,9 @@ query_tree_mutator(Query *query,
|
||||
rte = newrte;
|
||||
break;
|
||||
}
|
||||
newrt = lappend(newrt, rte);
|
||||
FastAppend(&newrt, rte);
|
||||
}
|
||||
query->rtable = newrt;
|
||||
query->rtable = FastListValue(&newrt);
|
||||
return query;
|
||||
}
|
||||
|
||||
|
@ -8,7 +8,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/util/var.c,v 1.49 2003/02/08 20:20:55 tgl Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/util/var.c,v 1.50 2003/05/28 22:32:50 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -37,7 +37,7 @@ typedef struct
|
||||
|
||||
typedef struct
|
||||
{
|
||||
List *varlist;
|
||||
FastList varlist;
|
||||
bool includeUpperVars;
|
||||
} pull_var_clause_context;
|
||||
|
||||
@ -344,11 +344,11 @@ pull_var_clause(Node *node, bool includeUpperVars)
|
||||
{
|
||||
pull_var_clause_context context;
|
||||
|
||||
context.varlist = NIL;
|
||||
FastListInit(&context.varlist);
|
||||
context.includeUpperVars = includeUpperVars;
|
||||
|
||||
pull_var_clause_walker(node, &context);
|
||||
return context.varlist;
|
||||
return FastListValue(&context.varlist);
|
||||
}
|
||||
|
||||
static bool
|
||||
@ -359,7 +359,7 @@ pull_var_clause_walker(Node *node, pull_var_clause_context *context)
|
||||
if (IsA(node, Var))
|
||||
{
|
||||
if (((Var *) node)->varlevelsup == 0 || context->includeUpperVars)
|
||||
context->varlist = lappend(context->varlist, node);
|
||||
FastAppend(&context->varlist, node);
|
||||
return false;
|
||||
}
|
||||
return expression_tree_walker(node, pull_var_clause_walker,
|
||||
|
Reference in New Issue
Block a user