*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/execQual.c,v 1.129 2003/05/02 20:54:33 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/execQual.c,v 1.130 2003/05/28 22:32:49 tgl Exp $
*
*-------------------------------------------------------------------------
*/
{
CaseExpr *caseexpr = (CaseExpr *) node;
CaseExprState *cstate = makeNode(CaseExprState);
- List *outlist = NIL;
+ FastList outlist;
List *inlist;
+ FastListInit(&outlist);
foreach(inlist, caseexpr->args)
{
CaseWhen *when = (CaseWhen *) lfirst(inlist);
wstate->xprstate.expr = (Expr *) when;
wstate->expr = ExecInitExpr(when->expr, parent);
wstate->result = ExecInitExpr(when->result, parent);
- outlist = lappend(outlist, wstate);
+ FastAppend(&outlist, wstate);
}
- cstate->args = outlist;
+ cstate->args = FastListValue(&outlist);
/* caseexpr->arg should be null by now */
Assert(caseexpr->arg == NULL);
cstate->defresult = ExecInitExpr(caseexpr->defresult, parent);
{
ArrayExpr *arrayexpr = (ArrayExpr *) node;
ArrayExprState *astate = makeNode(ArrayExprState);
- List *outlist = NIL;
+ FastList outlist;
List *inlist;
+ FastListInit(&outlist);
foreach(inlist, arrayexpr->elements)
{
Expr *e = (Expr *) lfirst(inlist);
ExprState *estate;
estate = ExecInitExpr(e, parent);
- outlist = lappend(outlist, estate);
+ FastAppend(&outlist, estate);
}
- astate->elements = outlist;
+ astate->elements = FastListValue(&outlist);
/* do one-time catalog lookup for type info */
get_typlenbyvalalign(arrayexpr->element_typeid,
&astate->elemlength,
{
CoalesceExpr *coalesceexpr = (CoalesceExpr *) node;
CoalesceExprState *cstate = makeNode(CoalesceExprState);
- List *outlist = NIL;
+ FastList outlist;
List *inlist;
+ FastListInit(&outlist);
foreach(inlist, coalesceexpr->args)
{
Expr *e = (Expr *) lfirst(inlist);
ExprState *estate;
estate = ExecInitExpr(e, parent);
- outlist = lappend(outlist, estate);
+ FastAppend(&outlist, estate);
}
- cstate->args = outlist;
+ cstate->args = FastListValue(&outlist);
state = (ExprState *) cstate;
}
break;
break;
case T_List:
{
- List *outlist = NIL;
+ FastList outlist;
List *inlist;
+ FastListInit(&outlist);
foreach(inlist, (List *) node)
{
- outlist = lappend(outlist,
- ExecInitExpr((Expr *) lfirst(inlist),
- parent));
+ FastAppend(&outlist,
+ ExecInitExpr((Expr *) lfirst(inlist),
+ parent));
}
/* Don't fall through to the "common" code below */
- return (ExprState *) outlist;
+ return (ExprState *) FastListValue(&outlist);
}
default:
elog(ERROR, "ExecInitExpr: unknown expression type %d",
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/list.c,v 1.48 2003/02/09 06:56:27 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/list.c,v 1.49 2003/05/28 22:32:49 tgl Exp $
*
* NOTES
* XXX a few of the following functions are duplicated to handle
* MORE EXPENSIVE THAN lcons
*/
List *
-lappend(List *list, void *obj)
+lappend(List *list, void *datum)
{
- return nconc(list, makeList1(obj));
+ return nconc(list, makeList1(datum));
}
/*
return l1; /* list1 is now list1+list2 */
}
+/*
+ * FastAppend - append to a FastList.
+ *
+ * For long lists this is significantly faster than repeated lappend's,
+ * since we avoid having to chase down the list again each time.
+ */
+void
+FastAppend(FastList *fl, void *datum)
+{
+ List *cell = makeList1(datum);
+
+ if (fl->tail)
+ {
+ lnext(fl->tail) = cell;
+ fl->tail = cell;
+ }
+ else
+ {
+ /* First cell of list */
+ Assert(fl->head == NIL);
+ fl->head = fl->tail = cell;
+ }
+}
+
+/*
+ * FastAppendi - same for integers
+ */
+void
+FastAppendi(FastList *fl, int datum)
+{
+ List *cell = makeListi1(datum);
+
+ if (fl->tail)
+ {
+ lnext(fl->tail) = cell;
+ fl->tail = cell;
+ }
+ else
+ {
+ /* First cell of list */
+ Assert(fl->head == NIL);
+ fl->head = fl->tail = cell;
+ }
+}
+
+/*
+ * FastAppendo - same for Oids
+ */
+void
+FastAppendo(FastList *fl, Oid datum)
+{
+ List *cell = makeListo1(datum);
+
+ if (fl->tail)
+ {
+ lnext(fl->tail) = cell;
+ fl->tail = cell;
+ }
+ else
+ {
+ /* First cell of list */
+ Assert(fl->head == NIL);
+ fl->head = fl->tail = cell;
+ }
+}
+
+/*
+ * FastConc - nconc() for FastList building
+ *
+ * Note that the cells of the second argument are absorbed into the FastList.
+ */
+void
+FastConc(FastList *fl, List *cells)
+{
+ if (cells == NIL)
+ return; /* nothing to do */
+ if (fl->tail)
+ {
+ lnext(fl->tail) = cells;
+ }
+ else
+ {
+ /* First cell of list */
+ Assert(fl->head == NIL);
+ fl->head = cells;
+ }
+ while (lnext(cells) != NIL)
+ cells = lnext(cells);
+ fl->tail = cells;
+}
+
+/*
+ * FastConcFast - nconc() for FastList building
+ *
+ * Note that the cells of the second argument are absorbed into the first.
+ */
+void
+FastConcFast(FastList *fl, FastList *fl2)
+{
+ if (fl2->head == NIL)
+ return; /* nothing to do */
+ if (fl->tail)
+ {
+ lnext(fl->tail) = fl2->head;
+ }
+ else
+ {
+ /* First cell of list */
+ Assert(fl->head == NIL);
+ fl->head = fl2->head;
+ }
+ fl->tail = fl2->tail;
+}
+
/*
* nth
*
*
*
* 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 $
*
*-------------------------------------------------------------------------
*/
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
do
{
Oid curClass = classes[0];
- List *clausegroup = NIL;
+ FastList clausegroup;
List *item;
+ FastListInit(&clausegroup);
if (and_clause((Node *) orsubclause))
{
foreach(item, ((BoolExpr *) orsubclause)->args)
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)
{
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));
}
}
* 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);
}
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;
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);
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);
}
/*
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)
{
curClass,
rinfo->clause))
{
- clausegroup = lappend(clausegroup, rinfo);
+ FastAppend(&clausegroup, rinfo);
jfound = true;
}
}
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++;
/* 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);
}
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];
{
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);
Assert(clausegroups == NIL); /* else more groups than indexkeys... */
- return resultquals;
+ return FastListValue(&resultquals);
}
/*
*
*
* 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 $
*
*-------------------------------------------------------------------------
*/
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;
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);
}
/*
*
*
* 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 $
*
*-------------------------------------------------------------------------
*/
#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);
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)));
return qual;
}
-/*
- * pull_ors
- * Pull the arguments of an 'or' clause nested within another 'or'
- * clause up into the argument list of the parent.
- *
- * Input is the arglist of an OR clause.
- * Returns the rebuilt arglist (note original list structure is not touched).
- */
-static List *
-pull_ors(List *orlist)
+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 *out_list = NIL;
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));
+ flatten_andors_or_walker(out_list, ((BoolExpr *) subexpr)->args);
else
- out_list = lappend(out_list, subexpr);
+ FastAppend(out_list, flatten_andors(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.
+ * Recursively flatten nested AND clauses into a single and-clause list.
*
- * Returns the modified 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)
{
- List *out_list = NIL;
+ 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);
- /*
- * 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));
+ pull_ands_walker(out_list, ((BoolExpr *) subexpr)->args);
+ else
+ FastAppend(out_list, subexpr);
+ }
+}
+
+/*
+ * pull_ors
+ * 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).
+ */
+static List *
+pull_ors(List *orlist)
+{
+ 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);
+
+ if (or_clause((Node *) subexpr))
+ pull_ors_walker(out_list, ((BoolExpr *) subexpr)->args);
else
- out_list = lappend(out_list, subexpr);
+ FastAppend(out_list, subexpr);
}
- return out_list;
}
/*
#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));
* 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))
{
*
*
* 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
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);
}
* 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);
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:
{
* 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);
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);
*/
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 */
if (casewhen->expr == NULL ||
!IsA(casewhen->expr, Const))
{
- newargs = lappend(newargs, casewhen);
+ FastAppend(&newargs, casewhen);
continue;
}
const_input = (Const *) casewhen->expr;
* 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;
}
* 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;
}
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;
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)
{
CoalesceExpr *coalesceexpr = (CoalesceExpr *) node;
CoalesceExpr *newcoalesce;
- List *newargs = NIL;
+ FastList newargs;
List *arg;
+ FastListInit(&newargs);
foreach(arg, coalesceexpr->args)
{
Node *e;
{
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))
* 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:
void *context,
int flags)
{
- List *newrt = NIL;
+ FastList newrt;
List *rt;
Assert(query != NULL && IsA(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);
rte = newrte;
break;
}
- newrt = lappend(newrt, rte);
+ FastAppend(&newrt, rte);
}
- query->rtable = newrt;
+ query->rtable = FastListValue(&newrt);
return query;
}
*
*
* 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 $
*
*-------------------------------------------------------------------------
*/
typedef struct
{
- List *varlist;
+ FastList varlist;
bool includeUpperVars;
} pull_var_clause_context;
{
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
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,
* Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: pg_list.h,v 1.35 2003/02/09 06:56:28 tgl Exp $
+ * $Id: pg_list.h,v 1.36 2003/05/28 22:32:50 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#define makeListo1(x1) lconso(x1, NIL)
#define makeListo2(x1,x2) lconso(x1, makeListo1(x2))
+/*
+ * FastList is an optimization for building large lists. The conventional
+ * way to build a list is repeated lappend() operations, but that is O(N^2)
+ * in the number of list items, which gets tedious for large lists.
+ */
+typedef struct FastList
+{
+ List *head;
+ List *tail;
+} FastList;
+
+#define FastListInit(fl) ( (fl)->head = (fl)->tail = NIL )
+#define FastListValue(fl) ( (fl)->head )
+
+
/*
* function prototypes in nodes/list.c
*/
extern List *lappendi(List *list, int datum);
extern List *lappendo(List *list, Oid datum);
extern List *nconc(List *list1, List *list2);
+extern void FastAppend(FastList *fl, void *datum);
+extern void FastAppendi(FastList *fl, int datum);
+extern void FastAppendo(FastList *fl, Oid datum);
+extern void FastConc(FastList *fl, List *cells);
+extern void FastConcFast(FastList *fl, FastList *fl2);
extern void *nth(int n, List *l);
extern int length(List *list);
extern void *llast(List *list);
projects / postgresql.git / commitdiff