database/postgres
1
0
Fork 0
mirror of https://github.com/postgres/postgres.git synced 2025-07-09 22:41:56 +03:00
Code Activity

Fix some planner performance problems with large WHERE clauses, by

Browse Source 
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:
Tom Lane
2003-05-28 22:32:50 +00:00
parent 0f3c68aa43
commit 8a6ac83dab
8 changed files with 374 additions and 202 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -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);
}
/*

15
src/backend/optimizer/path/orindxpath.c
View File

@ -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);
}
/*

203
src/backend/optimizer/prep/prepqual.c
View File

@ -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))
{

93
src/backend/optimizer/util/clauses.c
View File

@ -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;
}

10
src/backend/optimizer/util/var.c
View File

@ -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,