mirrors/postgres
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Use the new List API function names throughout the backend, and disable the

Browse Source 
list compatibility API by default. While doing this, I decided to keep
the llast() macro around and introduce llast_int() and llast_oid() variants.
This commit is contained in:
Neil Conway 2004-05-30 23:40:41 +00:00
parent ec0b1f2716
commit 72b6ad6313
83 changed files with 798 additions and 828 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
contrib/tsearch2/tsvector.c
View File

@ -779,10 +779,10 @@ findFunc(char *fname)
FuncCandidateList clist,
ptr;
Oid funcid = InvalidOid;
List *names = makeList1(makeString(fname));
List *names = list_make1(makeString(fname));
ptr = clist = FuncnameGetCandidates(names, 1);
freeList(names);
list_free(names);
if (!ptr)
return funcid;

12
src/backend/access/common/tupdesc.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/access/common/tupdesc.c,v 1.103 2004/05/26 04:41:03 neilc Exp $
* $PostgreSQL: pgsql/src/backend/access/common/tupdesc.c,v 1.104 2004/05/30 23:40:25 neilc Exp $
*
* NOTES
* some of the executor utility code such as "ExecTypeFromTL" should be
@ -484,7 +484,7 @@ BuildDescForRelation(List *schema)
/*
* allocate a new tuple descriptor
*/
natts = length(schema);
natts = list_length(schema);
desc = CreateTemplateTupleDesc(natts, false);
constr->has_not_null = false;
@ -503,7 +503,7 @@ BuildDescForRelation(List *schema)
attname = entry->colname;
atttypmod = entry->typename->typmod;
attdim = length(entry->typename->arrayBounds);
attdim = list_length(entry->typename->arrayBounds);
if (entry->typename->setof)
ereport(ERROR,
@ -624,7 +624,7 @@ TypeGetTupleDesc(Oid typeoid, List *colaliases)
int varattno;
/* does the list length match the number of attributes? */
if (length(colaliases) != natts)
if (list_length(colaliases) != natts)
ereport(ERROR,
(errcode(ERRCODE_DATATYPE_MISMATCH),
errmsg("number of aliases does not match number of columns")));
@ -632,7 +632,7 @@ TypeGetTupleDesc(Oid typeoid, List *colaliases)
/* OK, use the aliases instead */
for (varattno = 0; varattno < natts; varattno++)
{
char *label = strVal(nth(varattno, colaliases));
char *label = strVal(list_nth(colaliases, varattno));
if (label != NULL)
namestrcpy(&(tupdesc->attrs[varattno]->attname), label);
@ -655,7 +655,7 @@ TypeGetTupleDesc(Oid typeoid, List *colaliases)
errmsg("no column alias was provided")));
/* the alias list length must be 1 */
if (length(colaliases) != 1)
if (list_length(colaliases) != 1)
ereport(ERROR,
(errcode(ERRCODE_DATATYPE_MISMATCH),
errmsg("number of aliases does not match number of columns")));

4
src/backend/access/nbtree/nbtxlog.c
View File

@ -8,7 +8,7 @@
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/access/nbtree/nbtxlog.c,v 1.11 2004/05/26 04:41:05 neilc Exp $
* $PostgreSQL: pgsql/src/backend/access/nbtree/nbtxlog.c,v 1.12 2004/05/30 23:40:25 neilc Exp $
*
*-------------------------------------------------------------------------
*/
@ -81,7 +81,7 @@ forget_matching_split(Relation reln, RelFileNode node,
{
if (is_root != split->is_root)
elog(LOG, "forget_matching_split: fishy is_root data");
incomplete_splits = lremove(split, incomplete_splits);
incomplete_splits = list_delete_ptr(incomplete_splits, split);
break; /* need not look further */
}
}

10
src/backend/executor/execMain.c
View File

@ -26,7 +26,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/executor/execMain.c,v 1.232 2004/05/26 04:41:14 neilc Exp $
* $PostgreSQL: pgsql/src/backend/executor/execMain.c,v 1.233 2004/05/30 23:40:26 neilc Exp $
*
*-------------------------------------------------------------------------
*/
@ -524,7 +524,7 @@ InitPlan(QueryDesc *queryDesc, bool explainOnly)
ResultRelInfo *resultRelInfo;
ListCell *l;
numResultRelations = length(resultRelations);
numResultRelations = list_length(resultRelations);
resultRelInfos = (ResultRelInfo *)
palloc(numResultRelations * sizeof(ResultRelInfo));
resultRelInfo = resultRelInfos;
@ -590,7 +590,7 @@ InitPlan(QueryDesc *queryDesc, bool explainOnly)
foreach(l, parseTree->rowMarks)
{
Index rti = lfirsti(l);
Index rti = lfirst_int(l);
Oid relid = getrelid(rti, rangeTable);
Relation relation;
execRowMark *erm;
@ -614,7 +614,7 @@ InitPlan(QueryDesc *queryDesc, bool explainOnly)
int nSlots = ExecCountSlotsNode(plan);
if (parseTree->resultRelations != NIL)
nSlots += length(parseTree->resultRelations);
nSlots += list_length(parseTree->resultRelations);
else
nSlots += 1;
estate->es_tupleTable = ExecCreateTupleTable(nSlots);
@ -2067,7 +2067,7 @@ EvalPlanQualStart(evalPlanQual *epq, EState *estate, evalPlanQual *priorepq)
int rtsize;
MemoryContext oldcontext;
rtsize = length(estate->es_range_table);
rtsize = list_length(estate->es_range_table);
epq->estate = epqstate = CreateExecutorState();

12
src/backend/executor/execQual.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/executor/execQual.c,v 1.160 2004/05/26 04:41:15 neilc Exp $
* $PostgreSQL: pgsql/src/backend/executor/execQual.c,v 1.161 2004/05/30 23:40:26 neilc Exp $
*
*-------------------------------------------------------------------------
*/
@ -760,7 +760,7 @@ init_fcache(Oid foid, FuncExprState *fcache, MemoryContext fcacheCxt)
aclcheck_error(aclresult, ACL_KIND_PROC, get_func_name(foid));
/* Safety check (should never fail, as parser should check sooner) */
if (length(fcache->args) > FUNC_MAX_ARGS)
if (list_length(fcache->args) > FUNC_MAX_ARGS)
elog(ERROR, "too many arguments");
/* Set up the primary fmgr lookup information */
@ -1958,7 +1958,7 @@ ExecEvalArray(ArrayExprState *astate, ExprContext *econtext,
int i = 0;
ndims = 1;
nelems = length(astate->elements);
nelems = list_length(astate->elements);
/* Shouldn't happen here, but if length is 0, return NULL */
if (nelems == 0)
@ -1999,7 +1999,7 @@ ExecEvalArray(ArrayExprState *astate, ExprContext *econtext,
char *dat = NULL;
Size ndatabytes = 0;
int nbytes;
int outer_nelems = length(astate->elements);
int outer_nelems = list_length(astate->elements);
int elem_ndims = 0;
int *elem_dims = NULL;
int *elem_lbs = NULL;
@ -2128,7 +2128,7 @@ ExecEvalRow(RowExprState *rstate,
*isDone = ExprSingleResult;
/* Allocate workspace */
nargs = length(rstate->args);
nargs = list_length(rstate->args);
if (nargs == 0) /* avoid palloc(0) if no fields */
nargs = 1;
values = (Datum *) palloc(nargs * sizeof(Datum));
@ -3170,7 +3170,7 @@ int
ExecTargetListLength(List *targetlist)
{
/* This used to be more complex, but fjoins are dead */
return length(targetlist);
return list_length(targetlist);
}
/*

4
src/backend/executor/execTuples.c
View File

@ -15,7 +15,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/executor/execTuples.c,v 1.78 2004/05/26 04:41:15 neilc Exp $
* $PostgreSQL: pgsql/src/backend/executor/execTuples.c,v 1.79 2004/05/30 23:40:26 neilc Exp $
*
*-------------------------------------------------------------------------
*/
@ -610,7 +610,7 @@ ExecTypeFromExprList(List *exprList)
int cur_resno = 1;
char fldname[NAMEDATALEN];
typeInfo = CreateTemplateTupleDesc(length(exprList), false);
typeInfo = CreateTemplateTupleDesc(list_length(exprList), false);
foreach(l, exprList)
{

12
src/backend/executor/execUtils.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/executor/execUtils.c,v 1.111 2004/05/26 04:41:15 neilc Exp $
* $PostgreSQL: pgsql/src/backend/executor/execUtils.c,v 1.112 2004/05/30 23:40:26 neilc Exp $
*
*-------------------------------------------------------------------------
*/
@ -249,7 +249,7 @@ FreeExecutorState(EState *estate)
while (estate->es_exprcontexts)
{
/* XXX: seems there ought to be a faster way to implement this
* than repeated lremove(), no?
* than repeated list_delete(), no?
*/
FreeExprContext((ExprContext *) linitial(estate->es_exprcontexts));
/* FreeExprContext removed the list link for us */
@ -355,7 +355,7 @@ FreeExprContext(ExprContext *econtext)
MemoryContextDelete(econtext->ecxt_per_tuple_memory);
/* Unlink self from owning EState */
estate = econtext->ecxt_estate;
estate->es_exprcontexts = lremove(econtext, estate->es_exprcontexts);
estate->es_exprcontexts = list_delete_ptr(estate->es_exprcontexts, econtext);
/* And delete the ExprContext node */
pfree(econtext);
}
@ -656,7 +656,7 @@ ExecOpenIndices(ResultRelInfo *resultRelInfo)
* Get cached list of index OIDs
*/
indexoidlist = RelationGetIndexList(resultRelation);
len = length(indexoidlist);
len = list_length(indexoidlist);
if (len == 0)
return;
@ -676,7 +676,7 @@ ExecOpenIndices(ResultRelInfo *resultRelInfo)
i = 0;
foreach(l, indexoidlist)
{
Oid indexOid = lfirsto(l);
Oid indexOid = lfirst_oid(l);
Relation indexDesc;
IndexInfo *ii;
@ -713,7 +713,7 @@ ExecOpenIndices(ResultRelInfo *resultRelInfo)
i++;
}
freeList(indexoidlist);
list_free(indexoidlist);
}
/* ----------------------------------------------------------------

4
src/backend/executor/nodeAgg.c
View File

@ -45,7 +45,7 @@
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/executor/nodeAgg.c,v 1.120 2004/05/26 04:41:15 neilc Exp $
* $PostgreSQL: pgsql/src/backend/executor/nodeAgg.c,v 1.121 2004/05/30 23:40:26 neilc Exp $
*
*-------------------------------------------------------------------------
*/
@ -1120,7 +1120,7 @@ ExecInitAgg(Agg *node, EState *estate)
* get the count of aggregates in targetlist and quals
*/
numaggs = aggstate->numaggs;
Assert(numaggs == length(aggstate->aggs));
Assert(numaggs == list_length(aggstate->aggs));
if (numaggs <= 0)
{
/*

6
src/backend/executor/nodeAppend.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/executor/nodeAppend.c,v 1.57 2004/05/26 04:41:15 neilc Exp $
* $PostgreSQL: pgsql/src/backend/executor/nodeAppend.c,v 1.58 2004/05/30 23:40:26 neilc Exp $
*
*-------------------------------------------------------------------------
*/
@ -155,7 +155,7 @@ ExecInitAppend(Append *node, EState *estate)
/*
* Set up empty vector of subplan states
*/
nplans = length(node->appendplans);
nplans = list_length(node->appendplans);
appendplanstates = (PlanState **) palloc0(nplans * sizeof(PlanState *));
@ -215,7 +215,7 @@ ExecInitAppend(Append *node, EState *estate)
appendstate->as_whichplan = i;
exec_append_initialize_next(appendstate);
initNode = (Plan *) nth(i, node->appendplans);
initNode = (Plan *) list_nth(node->appendplans, i);
appendplanstates[i] = ExecInitNode(initNode, estate);
}

8
src/backend/executor/nodeHash.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/executor/nodeHash.c,v 1.84 2004/05/26 04:41:15 neilc Exp $
* $PostgreSQL: pgsql/src/backend/executor/nodeHash.c,v 1.85 2004/05/30 23:40:26 neilc Exp $
*
*-------------------------------------------------------------------------
*/
@ -240,17 +240,17 @@ ExecHashTableCreate(Hash *node, List *hashOperators)
/*
* Get info about the hash functions to be used for each hash key.
*/
nkeys = length(hashOperators);
nkeys = list_length(hashOperators);
hashtable->hashfunctions = (FmgrInfo *) palloc(nkeys * sizeof(FmgrInfo));
i = 0;
foreach(ho, hashOperators)
{
Oid hashfn;
hashfn = get_op_hash_function(lfirsto(ho));
hashfn = get_op_hash_function(lfirst_oid(ho));
if (!OidIsValid(hashfn))
elog(ERROR, "could not find hash function for hash operator %u",
lfirsto(ho));
lfirst_oid(ho));
fmgr_info(hashfn, &hashtable->hashfunctions[i]);
i++;
}

4
src/backend/executor/nodeHashjoin.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/executor/nodeHashjoin.c,v 1.61 2004/05/26 04:41:15 neilc Exp $
* $PostgreSQL: pgsql/src/backend/executor/nodeHashjoin.c,v 1.62 2004/05/30 23:40:26 neilc Exp $
*
*-------------------------------------------------------------------------
*/
@ -429,7 +429,7 @@ ExecInitHashJoin(HashJoin *node, EState *estate)
Assert(IsA(hclause, OpExpr));
lclauses = lappend(lclauses, linitial(fstate->args));
rclauses = lappend(rclauses, lsecond(fstate->args));
hoperators = lappendo(hoperators, hclause->opno);
hoperators = lappend_oid(hoperators, hclause->opno);
}
hjstate->hj_OuterHashKeys = lclauses;
hjstate->hj_InnerHashKeys = rclauses;

29
src/backend/executor/nodeIndexscan.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/executor/nodeIndexscan.c,v 1.94 2004/05/26 04:41:16 neilc Exp $
* $PostgreSQL: pgsql/src/backend/executor/nodeIndexscan.c,v 1.95 2004/05/30 23:40:26 neilc Exp $
*
*-------------------------------------------------------------------------
*/
@ -720,7 +720,7 @@ ExecInitIndexScan(IndexScan *node, EState *estate)
* get the index node information
*/
indxid_item = list_head(node->indxid);
numIndices = length(node->indxid);
numIndices = list_length(node->indxid);
indexPtr = -1;
CXT1_printf("ExecInitIndexScan: context is %d\n", CurrentMemoryContext);
@ -772,7 +772,7 @@ ExecInitIndexScan(IndexScan *node, EState *estate)
indxsubtype = lnext(indxsubtype);
lossyflags = (List *) lfirst(indxlossy);
indxlossy = lnext(indxlossy);
n_keys = length(quals);
n_keys = list_length(quals);
scan_keys = (n_keys <= 0) ? NULL :
(ScanKey) palloc(n_keys * sizeof(ScanKeyData));
run_keys = (n_keys <= 0) ? NULL :
@ -804,11 +804,11 @@ ExecInitIndexScan(IndexScan *node, EState *estate)
*/
clause = (OpExpr *) lfirst(qual_cell);
qual_cell = lnext(qual_cell);
strategy = lfirsti(strategy_cell);
strategy = lfirst_int(strategy_cell);
strategy_cell = lnext(strategy_cell);
subtype = lfirsto(subtype_cell);
subtype = lfirst_oid(subtype_cell);
subtype_cell = lnext(subtype_cell);
lossy = lfirsti(lossyflag_cell);
lossy = lfirst_int(lossyflag_cell);
lossyflag_cell = lnext(lossyflag_cell);
if (!IsA(clause, OpExpr))
@ -892,17 +892,18 @@ ExecInitIndexScan(IndexScan *node, EState *estate)
scanvalue); /* constant */
/*
* If this operator is lossy, add its indxqualorig expression
* to the list of quals to recheck. The nth() calls here could
* be avoided by chasing the lists in parallel to all the other
* lists, but since lossy operators are very uncommon, it's
* probably a waste of time to do so.
* If this operator is lossy, add its indxqualorig
* expression to the list of quals to recheck. The
* list_nth() calls here could be avoided by chasing the
* lists in parallel to all the other lists, but since
* lossy operators are very uncommon, it's probably a
* waste of time to do so.
*/
if (lossy)
{
List *qualOrig = indexstate->indxqualorig;
lossyQuals[i] = lappend(lossyQuals[i],
nth(j,
(List *) nth(i, indexstate->indxqualorig)));
list_nth((List *) list_nth(qualOrig, i), j));
}
}
@ -980,7 +981,7 @@ ExecInitIndexScan(IndexScan *node, EState *estate)
*/
for (i = 0; i < numIndices; i++)
{
Oid indexOid = lfirsto(indxid_item);
Oid indexOid = lfirst_oid(indxid_item);
indexDescs[i] = index_open(indexOid);
scanDescs[i] = index_beginscan(currentRelation,

4
src/backend/executor/nodeMergejoin.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/executor/nodeMergejoin.c,v 1.65 2004/05/26 04:41:16 neilc Exp $
* $PostgreSQL: pgsql/src/backend/executor/nodeMergejoin.c,v 1.66 2004/05/30 23:40:26 neilc Exp $
*
*-------------------------------------------------------------------------
*/
@ -188,7 +188,7 @@ MergeCompare(List *eqQual, List *compareQual, ExprContext *econtext)
/*
* We can't run out of one list before the other
*/
Assert(length(compareQual) == length(eqQual));
Assert(list_length(compareQual) == list_length(eqQual));
forboth(clause, compareQual, eqclause, eqQual)
{

22
src/backend/executor/nodeSubplan.c
View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/executor/nodeSubplan.c,v 1.62 2004/05/26 04:41:16 neilc Exp $
* $PostgreSQL: pgsql/src/backend/executor/nodeSubplan.c,v 1.63 2004/05/30 23:40:26 neilc Exp $
*
*-------------------------------------------------------------------------
*/
@ -228,7 +228,7 @@ ExecScanSubPlan(SubPlanState *node,
* calculation we have to do is done in the parent econtext, since the
* Param values don't need to have per-query lifetime.)
*/
Assert(length(subplan->parParam) == length(node->args));
Assert(list_length(subplan->parParam) == list_length(node->args));
forboth(l, subplan->parParam, pvar, node->args)
{
@ -341,7 +341,7 @@ ExecScanSubPlan(SubPlanState *node,
* For ALL, ANY, and MULTIEXPR sublinks, iterate over combining
* operators for columns of tuple.
*/
Assert(length(node->exprs) == length(subplan->paramIds));
Assert(list_length(node->exprs) == list_length(subplan->paramIds));
forboth(l, node->exprs, plst, subplan->paramIds)
{
@ -469,7 +469,7 @@ buildSubPlanHash(SubPlanState *node)
{
SubPlan *subplan = (SubPlan *) node->xprstate.expr;
PlanState *planstate = node->planstate;
int ncols = length(node->exprs);
int ncols = list_length(node->exprs);
ExprContext *innerecontext = node->innerecontext;
MemoryContext tempcxt = innerecontext->ecxt_per_tuple_memory;
MemoryContext oldcontext;
@ -566,7 +566,7 @@ buildSubPlanHash(SubPlanState *node)
*/
foreach(plst, subplan->paramIds)
{
int paramid = lfirsti(plst);
int paramid = lfirst_int(plst);
ParamExecData *prmdata;
prmdata = &(innerecontext->ecxt_param_exec_vals[paramid]);
@ -739,7 +739,7 @@ ExecInitSubPlan(SubPlanState *node, EState *estate)
foreach(lst, subplan->setParam)
{
int paramid = lfirsti(lst);
int paramid = lfirst_int(lst);
ParamExecData *prm = &(estate->es_param_exec_vals[paramid]);
prm->execPlan = node;
@ -773,7 +773,7 @@ ExecInitSubPlan(SubPlanState *node, EState *estate)
/* and a short-lived exprcontext for function evaluation */
node->innerecontext = CreateExprContext(estate);
/* Silly little array of column numbers 1..n */
ncols = length(node->exprs);
ncols = list_length(node->exprs);
node->keyColIdx = (AttrNumber *) palloc(ncols * sizeof(AttrNumber));
for (i = 0; i < ncols; i++)
node->keyColIdx[i] = i + 1;
@ -810,7 +810,7 @@ ExecInitSubPlan(SubPlanState *node, EState *estate)
Assert(IsA(fstate, FuncExprState));
Assert(IsA(opexpr, OpExpr));
Assert(length(fstate->args) == 2);
Assert(list_length(fstate->args) == 2);
/* Process lefthand argument */
exstate = (ExprState *) linitial(fstate->args);
@ -992,7 +992,7 @@ ExecSetParamPlan(SubPlanState *node, ExprContext *econtext)
*/
foreach(l, subplan->setParam)
{
int paramid = lfirsti(l);
int paramid = lfirst_int(l);
ParamExecData *prm = &(econtext->ecxt_param_exec_vals[paramid]);
prm->execPlan = NULL;
@ -1017,7 +1017,7 @@ ExecSetParamPlan(SubPlanState *node, ExprContext *econtext)
{
foreach(l, subplan->setParam)
{
int paramid = lfirsti(l);
int paramid = lfirst_int(l);
ParamExecData *prm = &(econtext->ecxt_param_exec_vals[paramid]);
prm->execPlan = NULL;
@ -1091,7 +1091,7 @@ ExecReScanSetParamPlan(SubPlanState *node, PlanState *parent)
*/
foreach(l, subplan->setParam)
{
int paramid = lfirsti(l);
int paramid = lfirst_int(l);
ParamExecData *prm = &(estate->es_param_exec_vals[paramid]);
prm->execPlan = node;

4
src/backend/executor/nodeTidscan.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/executor/nodeTidscan.c,v 1.38 2004/05/26 04:41:16 neilc Exp $
* $PostgreSQL: pgsql/src/backend/executor/nodeTidscan.c,v 1.39 2004/05/30 23:40:26 neilc Exp $
*
*-------------------------------------------------------------------------
*/
@ -48,7 +48,7 @@ TidListCreate(TidScanState *tidstate)
ListCell *l;
tidList = (ItemPointerData *)
palloc(length(tidstate->tss_tideval) * sizeof(ItemPointerData));
palloc(list_length(tidstate->tss_tideval) * sizeof(ItemPointerData));
foreach(l, evalList)
{

10
src/backend/executor/spi.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/executor/spi.c,v 1.114 2004/05/26 04:41:16 neilc Exp $
* $PostgreSQL: pgsql/src/backend/executor/spi.c,v 1.115 2004/05/30 23:40:26 neilc Exp $
*
*-------------------------------------------------------------------------
*/
@ -740,7 +740,7 @@ SPI_cursor_open(const char *name, void *plan, Datum *Values, const char *Nulls)
int k;
/* Ensure that the plan contains only one regular SELECT query */
if (length(ptlist) != 1 || length(qtlist) != 1)
if (list_length(ptlist) != 1 || list_length(qtlist) != 1)
ereport(ERROR,
(errcode(ERRCODE_INVALID_CURSOR_DEFINITION),
errmsg("cannot open multi-query plan as cursor")));
@ -821,8 +821,8 @@ SPI_cursor_open(const char *name, void *plan, Datum *Values, const char *Nulls)
PortalDefineQuery(portal,
NULL, /* unfortunately don't have sourceText */
"SELECT", /* cursor's query is always a SELECT */
makeList1(queryTree),
makeList1(planTree),
list_make1(queryTree),
list_make1(planTree),
PortalGetHeapMemory(portal));
MemoryContextSwitchTo(oldcontext);
@ -951,7 +951,7 @@ SPI_is_cursor_plan(void *plan)
}
qtlist = spiplan->qtlist;
if (length(spiplan->ptlist) == 1 && length(qtlist) == 1)
if (list_length(spiplan->ptlist) == 1 && list_length(qtlist) == 1)
{
Query *queryTree = (Query *) linitial((List *) linitial(qtlist));

4
src/backend/libpq/hba.c
View File

@ -10,14 +10,12 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/libpq/hba.c,v 1.124 2004/05/26 18:35:33 momjian Exp $
* $PostgreSQL: pgsql/src/backend/libpq/hba.c,v 1.125 2004/05/30 23:40:26 neilc Exp $
*
*-------------------------------------------------------------------------
*/
#include "postgres.h"
#define DISABLE_LIST_COMPAT
#include <errno.h>
#include <pwd.h>
#include <fcntl.h>

4
src/backend/nodes/copyfuncs.c
View File

@ -15,13 +15,11 @@
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/nodes/copyfuncs.c,v 1.283 2004/05/26 13:56:47 momjian Exp $
* $PostgreSQL: pgsql/src/backend/nodes/copyfuncs.c,v 1.284 2004/05/30 23:40:27 neilc Exp $
*
*-------------------------------------------------------------------------
*/
#define DISABLE_LIST_COMPAT
#include "postgres.h"
#include "nodes/parsenodes.h"

4
src/backend/nodes/equalfuncs.c
View File

@ -18,13 +18,11 @@
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/nodes/equalfuncs.c,v 1.222 2004/05/26 13:56:47 momjian Exp $
* $PostgreSQL: pgsql/src/backend/nodes/equalfuncs.c,v 1.223 2004/05/30 23:40:27 neilc Exp $
*
*-------------------------------------------------------------------------
*/
#define DISABLE_LIST_COMPAT
#include "postgres.h"
#include "nodes/params.h"

4
src/backend/nodes/list.c
View File

@ -9,12 +9,10 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/nodes/list.c,v 1.57 2004/05/26 04:41:19 neilc Exp $
* $PostgreSQL: pgsql/src/backend/nodes/list.c,v 1.58 2004/05/30 23:40:27 neilc Exp $
*
*-------------------------------------------------------------------------
*/
#define DISABLE_LIST_COMPAT
#include "postgres.h"
#include "nodes/pg_list.h"

6
src/backend/nodes/makefuncs.c
View File

@ -9,7 +9,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/nodes/makefuncs.c,v 1.43 2004/05/10 22:44:44 tgl Exp $
* $PostgreSQL: pgsql/src/backend/nodes/makefuncs.c,v 1.44 2004/05/30 23:40:27 neilc Exp $
*
*-------------------------------------------------------------------------
*/
@ -47,7 +47,7 @@ makeSimpleA_Expr(A_Expr_Kind kind, const char *name,
A_Expr *a = makeNode(A_Expr);
a->kind = kind;
a->name = makeList1(makeString((char *) name));
a->name = list_make1(makeString((char *) name));
a->lexpr = lexpr;
a->rexpr = rexpr;
return a;
@ -259,7 +259,7 @@ makeTypeName(char *typnam)
{
TypeName *n = makeNode(TypeName);
n->names = makeList1(makeString(typnam));
n->names = list_make1(makeString(typnam));
n->typmod = -1;
return n;
}

4
src/backend/nodes/outfuncs.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/nodes/outfuncs.c,v 1.237 2004/05/26 04:41:19 neilc Exp $
* $PostgreSQL: pgsql/src/backend/nodes/outfuncs.c,v 1.238 2004/05/30 23:40:27 neilc Exp $
*
* NOTES
* Every node type that can appear in stored rules' parsetrees *must*
@ -19,8 +19,6 @@
*
*-------------------------------------------------------------------------
*/
#define DISABLE_LIST_COMPAT
#include "postgres.h"
#include <ctype.h>

6
src/backend/nodes/print.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/nodes/print.c,v 1.67 2004/05/26 04:41:19 neilc Exp $
* $PostgreSQL: pgsql/src/backend/nodes/print.c,v 1.68 2004/05/30 23:40:27 neilc Exp $
*
* HISTORY
* AUTHOR DATE MAJOR EVENT
@ -333,7 +333,7 @@ print_expr(Node *expr, List *rtable)
RangeTblEntry *rte;
Assert(var->varno > 0 &&
(int) var->varno <= length(rtable));
(int) var->varno <= list_length(rtable));
rte = rt_fetch(var->varno, rtable);
relname = rte->eref->aliasname;
attname = get_rte_attribute_name(rte, var->varattno);
@ -378,7 +378,7 @@ print_expr(Node *expr, List *rtable)
char *opname;
opname = get_opname(e->opno);
if (length(e->args) > 1)
if (list_length(e->args) > 1)
{
print_expr(get_leftop((Expr *) e), rtable);
printf(" %s ", ((opname != NULL) ? opname : "(invalid operator)"));

6
src/backend/nodes/read.c
View File

@ -9,7 +9,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/nodes/read.c,v 1.42 2004/05/26 04:41:19 neilc Exp $
* $PostgreSQL: pgsql/src/backend/nodes/read.c,v 1.43 2004/05/30 23:40:27 neilc Exp $
*
* HISTORY
* AUTHOR DATE MAJOR EVENT
@ -327,7 +327,7 @@ nodeRead(char *token, int tok_len)
if (endptr != token + tok_len)
elog(ERROR, "unrecognized integer: \"%.*s\"",
tok_len, token);
l = lappendi(l, val);
l = lappend_int(l, val);
}
}
else if (tok_len == 1 && token[0] == 'o')
@ -347,7 +347,7 @@ nodeRead(char *token, int tok_len)
if (endptr != token + tok_len)
elog(ERROR, "unrecognized OID: \"%.*s\"",
tok_len, token);
l = lappendo(l, val);
l = lappend_oid(l, val);
}
}
else

4
src/backend/nodes/readfuncs.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/nodes/readfuncs.c,v 1.170 2004/05/26 04:41:19 neilc Exp $
* $PostgreSQL: pgsql/src/backend/nodes/readfuncs.c,v 1.171 2004/05/30 23:40:27 neilc Exp $
*
* NOTES
* Path and Plan nodes do not have any readfuncs support, because we
@ -18,8 +18,6 @@
*
*-------------------------------------------------------------------------
*/
#define DISABLE_LIST_COMPAT
#include "postgres.h"
#include <math.h>

6
src/backend/optimizer/geqo/geqo_eval.c
View File

@ -6,7 +6,7 @@
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $PostgreSQL: pgsql/src/backend/optimizer/geqo/geqo_eval.c,v 1.68 2004/05/26 04:41:20 neilc Exp $
* $PostgreSQL: pgsql/src/backend/optimizer/geqo/geqo_eval.c,v 1.69 2004/05/30 23:40:27 neilc Exp $
*
*-------------------------------------------------------------------------
*/
@ -175,8 +175,8 @@ gimme_tree(Gene *tour, int num_gene, GeqoEvalData *evaldata)
/* Get the next input relation and push it */
cur_rel_index = (int) tour[rel_count];
stack[stack_depth] = (RelOptInfo *) nth(cur_rel_index - 1,
evaldata->initial_rels);
stack[stack_depth] = (RelOptInfo *) list_nth(evaldata->initial_rels,
cur_rel_index - 1);
stack_depth++;
/*

16
src/backend/optimizer/path/allpaths.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/optimizer/path/allpaths.c,v 1.115 2004/05/26 04:41:21 neilc Exp $
* $PostgreSQL: pgsql/src/backend/optimizer/path/allpaths.c,v 1.116 2004/05/30 23:40:28 neilc Exp $
*
*-------------------------------------------------------------------------
*/
@ -88,7 +88,7 @@ make_one_rel(Query *root)
/*
* The result should join all the query's base rels.
*/
Assert(bms_num_members(rel->relids) == length(root->base_rel_list));
Assert(bms_num_members(rel->relids) == list_length(root->base_rel_list));
return rel;
}
@ -218,7 +218,7 @@ set_inherited_rel_pathlist(Query *root, RelOptInfo *rel,
* XXX for now, can't handle inherited expansion of FOR UPDATE; can we
* do better?
*/
if (intMember(parentRTindex, root->rowMarks))
if (list_member_int(root->rowMarks, parentRTindex))
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("SELECT FOR UPDATE is not supported for inheritance queries")));
@ -242,7 +242,7 @@ set_inherited_rel_pathlist(Query *root, RelOptInfo *rel,
*/
foreach(il, inheritlist)
{
int childRTindex = lfirsti(il);
int childRTindex = lfirst_int(il);
RangeTblEntry *childrte;
Oid childOID;
RelOptInfo *childrel;
@ -338,7 +338,7 @@ set_subquery_pathlist(Query *root, RelOptInfo *rel,
/* We need a workspace for keeping track of set-op type coercions */
differentTypes = (bool *)
palloc0((length(subquery->targetList) + 1) * sizeof(bool));
palloc0((list_length(subquery->targetList) + 1) * sizeof(bool));
/*
* If there are any restriction clauses that have been attached to the
@ -441,7 +441,7 @@ make_fromexpr_rel(Query *root, FromExpr *from)
* dynamic-programming algorithm we must employ to consider all ways
* of joining the child nodes.
*/
levels_needed = length(from->fromlist);
levels_needed = list_length(from->fromlist);
if (levels_needed <= 0)
return NULL; /* nothing to do? */
@ -546,7 +546,7 @@ make_one_rel_by_joins(Query *root, int levels_needed, List *initial_rels)
*/
if (joinitems[levels_needed] == NIL)
elog(ERROR, "failed to build any %d-way joins", levels_needed);
Assert(length(joinitems[levels_needed]) == 1);
Assert(list_length(joinitems[levels_needed]) == 1);
rel = (RelOptInfo *) linitial(joinitems[levels_needed]);
@ -770,7 +770,7 @@ qual_is_pushdown_safe(Query *subquery, Index rti, Node *qual,
}
}
freeList(vars);
list_free(vars);
bms_free(tested);
return safe;

8
src/backend/optimizer/path/clausesel.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/optimizer/path/clausesel.c,v 1.66 2004/05/26 04:41:21 neilc Exp $
* $PostgreSQL: pgsql/src/backend/optimizer/path/clausesel.c,v 1.67 2004/05/30 23:40:28 neilc Exp $
*
*-------------------------------------------------------------------------
*/
@ -131,7 +131,7 @@ clauselist_selectivity(Query *root,
* behave in the simple way we are expecting.) Most of the tests
* here can be done more efficiently with rinfo than without.
*/
if (is_opclause(clause) && length(((OpExpr *) clause)->args) == 2)
if (is_opclause(clause) && list_length(((OpExpr *) clause)->args) == 2)
{
OpExpr *expr = (OpExpr *) clause;
bool varonleft = true;
@ -480,8 +480,8 @@ clause_selectivity(Query *root,
*/
s1 = restriction_selectivity(root,
BooleanEqualOperator,
makeList2(var,
makeBoolConst(true,
list_make2(var,
makeBoolConst(true,
false)),
varRelid);
}

6
src/backend/optimizer/path/costsize.c
View File

@ -49,7 +49,7 @@
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/optimizer/path/costsize.c,v 1.127 2004/05/26 04:41:21 neilc Exp $
* $PostgreSQL: pgsql/src/backend/optimizer/path/costsize.c,v 1.128 2004/05/30 23:40:28 neilc Exp $
*
*-------------------------------------------------------------------------
*/
@ -412,7 +412,7 @@ cost_tidscan(Path *path, Query *root,
Cost startup_cost = 0;
Cost run_cost = 0;
Cost cpu_per_tuple;
int ntuples = length(tideval);
int ntuples = list_length(tideval);
/* Should only be applied to base relations */
Assert(baserel->relid > 0);
@ -1063,7 +1063,7 @@ cost_hashjoin(HashPath *path, Query *root)
outer_path->parent->width);
double innerbytes = relation_byte_size(inner_path_rows,
inner_path->parent->width);
int num_hashclauses = length(hashclauses);
int num_hashclauses = list_length(hashclauses);
int virtualbuckets;
int physicalbuckets;
int numbatches;

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

@ -9,7 +9,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/optimizer/path/indxpath.c,v 1.159 2004/05/26 04:41:21 neilc Exp $
* $PostgreSQL: pgsql/src/backend/optimizer/path/indxpath.c,v 1.160 2004/05/30 23:40:28 neilc Exp $
*
*-------------------------------------------------------------------------
*/
@ -1042,11 +1042,11 @@ pred_test_simple_clause(Expr *predicate, Node *clause)
Expr *nonnullarg = ((NullTest *) predicate)->arg;
if (is_opclause(clause) &&
member(nonnullarg, ((OpExpr *) clause)->args) &&
list_member(((OpExpr *) clause)->args, nonnullarg) &&
op_strict(((OpExpr *) clause)->opno))
return true;
if (is_funcclause(clause) &&
member(nonnullarg, ((FuncExpr *) clause)->args) &&
list_member(((FuncExpr *) clause)->args, nonnullarg) &&
func_strict(((FuncExpr *) clause)->funcid))
return true;
return false; /* we can't succeed below... */
@ -1624,9 +1624,9 @@ make_innerjoin_index_path(Query *root,
* Note that we are making a pathnode for a single-scan indexscan;
* therefore, indexinfo etc should be single-element lists.
*/
pathnode->indexinfo = makeList1(index);
pathnode->indexclauses = makeList1(allclauses);
pathnode->indexquals = makeList1(indexquals);
pathnode->indexinfo = list_make1(index);
pathnode->indexclauses = list_make1(allclauses);
pathnode->indexquals = list_make1(indexquals);
pathnode->isjoininner = true;
@ -1649,7 +1649,7 @@ make_innerjoin_index_path(Query *root,
* Always assume the join type is JOIN_INNER; even if some of the join
* clauses come from other contexts, that's not our problem.
*/
allclauses = set_ptrUnion(rel->baserestrictinfo, allclauses);
allclauses = list_union_ptr(rel->baserestrictinfo, allclauses);
pathnode->rows = rel->tuples *
clauselist_selectivity(root,
allclauses,
@ -1679,7 +1679,7 @@ flatten_clausegroups_list(List *clausegroups)
foreach(l, clausegroups)
{
allclauses = nconc(allclauses, listCopy((List *) lfirst(l)));
allclauses = list_concat(allclauses, list_copy((List *) lfirst(l)));
}
return allclauses;
}
@ -1711,7 +1711,7 @@ make_expr_from_indexclauses(List *indexclauses)
orclauses = lappend(orclauses, make_ands_explicit(andlist));
}
if (length(orclauses) > 1)
if (list_length(orclauses) > 1)
return make_orclause(orclauses);
else
return (Expr *) linitial(orclauses);
@ -2114,7 +2114,7 @@ expand_indexqual_condition(RestrictInfo *rinfo, Oid opclass)
break;
default:
result = makeList1(rinfo);
result = list_make1(rinfo);
break;
}
@ -2209,7 +2209,7 @@ prefix_quals(Node *leftop, Oid opclass,
elog(ERROR, "no = operator for opclass %u", opclass);
expr = make_opclause(oproid, BOOLOID, false,
(Expr *) leftop, (Expr *) prefix_const);
result = makeList1(make_restrictinfo(expr, true, true));
result = list_make1(make_restrictinfo(expr, true, true));
return result;
}
@ -2224,7 +2224,7 @@ prefix_quals(Node *leftop, Oid opclass,
elog(ERROR, "no >= operator for opclass %u", opclass);
expr = make_opclause(oproid, BOOLOID, false,
(Expr *) leftop, (Expr *) prefix_const);
result = makeList1(make_restrictinfo(expr, true, true));
result = list_make1(make_restrictinfo(expr, true, true));
/*-------
* If we can create a string larger than the prefix, we can say
@ -2311,7 +2311,7 @@ network_prefix_quals(Node *leftop, Oid expr_op, Oid opclass, Datum rightop)
(Expr *) leftop,
(Expr *) makeConst(datatype, -1, opr1right,
false, false));
result = makeList1(make_restrictinfo(expr, true, true));
result = list_make1(make_restrictinfo(expr, true, true));
/* create clause "key <= network_scan_last( rightop )" */

16
src/backend/optimizer/path/joinpath.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/optimizer/path/joinpath.c,v 1.87 2004/05/26 04:41:22 neilc Exp $
* $PostgreSQL: pgsql/src/backend/optimizer/path/joinpath.c,v 1.88 2004/05/30 23:40:28 neilc Exp $
*
*-------------------------------------------------------------------------
*/
@ -236,8 +236,8 @@ sort_inner_and_outer(Query *root,
/* Make a pathkey list with this guy first. */
if (l != list_head(all_pathkeys))
cur_pathkeys = lcons(front_pathkey,
lremove(front_pathkey,
listCopy(all_pathkeys)));
list_delete_ptr(list_copy(all_pathkeys),
front_pathkey));
else
cur_pathkeys = all_pathkeys; /* no work at first one... */
@ -254,7 +254,7 @@ sort_inner_and_outer(Query *root,
/* Forget it if can't use all the clauses in right/full join */
if (useallclauses &&
length(cur_mergeclauses) != length(mergeclause_list))
list_length(cur_mergeclauses) != list_length(mergeclause_list))
continue;
/*
@ -510,7 +510,7 @@ match_unsorted_outer(Query *root,
else
continue;
}
if (useallclauses && length(mergeclauses) != length(mergeclause_list))
if (useallclauses && list_length(mergeclauses) != list_length(mergeclause_list))
continue;
/* Compute the required ordering of the inner path */
@ -547,9 +547,9 @@ match_unsorted_outer(Query *root,
* consider both cheap startup cost and cheap total cost. Ignore
* inner_cheapest_total, since we already made a path with it.
*/
num_sortkeys = length(innersortkeys);
num_sortkeys = list_length(innersortkeys);
if (num_sortkeys > 1 && !useallclauses)
trialsortkeys = listCopy(innersortkeys); /* need modifiable copy */
trialsortkeys = list_copy(innersortkeys); /* need modifiable copy */
else
trialsortkeys = innersortkeys; /* won't really truncate */
cheapest_startup_inner = NULL;
@ -565,7 +565,7 @@ match_unsorted_outer(Query *root,
* 'sortkeycnt' innersortkeys. NB: trialsortkeys list is
* modified destructively, which is why we made a copy...
*/
trialsortkeys = ltruncate(sortkeycnt, trialsortkeys);
trialsortkeys = list_truncate(trialsortkeys, sortkeycnt);
innerpath = get_cheapest_path_for_pathkeys(innerrel->pathlist,
trialsortkeys,
TOTAL_COST);

10
src/backend/optimizer/path/joinrels.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/optimizer/path/joinrels.c,v 1.68 2004/05/26 04:41:22 neilc Exp $
* $PostgreSQL: pgsql/src/backend/optimizer/path/joinrels.c,v 1.69 2004/05/30 23:40:28 neilc Exp $
*
*-------------------------------------------------------------------------
*/
@ -121,7 +121,7 @@ make_rels_by_joins(Query *root, int level, List **joinrels)
{
RelOptInfo *jrel = (RelOptInfo *) lfirst(nr);
if (!ptrMember(jrel, result_rels))
if (!list_member_ptr(result_rels, jrel))
result_rels = lcons(jrel, result_rels);
}
}
@ -185,7 +185,7 @@ make_rels_by_joins(Query *root, int level, List **joinrels)
jrel = make_join_rel(root, old_rel, new_rel,
JOIN_INNER);
/* Avoid making duplicate entries ... */
if (jrel && !ptrMember(jrel, result_rels))
if (jrel && !list_member_ptr(result_rels, jrel))
result_rels = lcons(jrel, result_rels);
break; /* need not consider more
* joininfos */
@ -234,7 +234,7 @@ make_rels_by_joins(Query *root, int level, List **joinrels)
{
RelOptInfo *jrel = (RelOptInfo *) lfirst(nr);
if (!ptrMember(jrel, result_rels))
if (!list_member_ptr(result_rels, jrel))
result_rels = lcons(jrel, result_rels);
}
}
@ -308,7 +308,7 @@ make_rels_by_clause_joins(Query *root,
* Avoid entering same joinrel into our output list more
* than once.
*/
if (jrel && !ptrMember(jrel, result))
if (jrel && !list_member_ptr(result, jrel))
result = lcons(jrel, result);
}
}

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

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/optimizer/path/orindxpath.c,v 1.58 2004/05/26 04:41:22 neilc Exp $
* $PostgreSQL: pgsql/src/backend/optimizer/path/orindxpath.c,v 1.59 2004/05/30 23:40:28 neilc Exp $
*
*-------------------------------------------------------------------------
*/
@ -149,9 +149,9 @@ create_or_index_quals(Query *root, RelOptInfo *rel)
*/
newrinfos = make_restrictinfo_from_indexclauses(bestpath->indexclauses,
true, true);
Assert(length(newrinfos) == 1);
Assert(list_length(newrinfos) == 1);
or_rinfo = (RestrictInfo *) linitial(newrinfos);
rel->baserestrictinfo = nconc(rel->baserestrictinfo, newrinfos);
rel->baserestrictinfo = list_concat(rel->baserestrictinfo, newrinfos);
/*
* Adjust the original OR clause's cached selectivity to compensate

61
src/backend/optimizer/path/pathkeys.c
View File

@ -11,7 +11,7 @@
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/optimizer/path/pathkeys.c,v 1.57 2004/05/26 04:41:22 neilc Exp $
* $PostgreSQL: pgsql/src/backend/optimizer/path/pathkeys.c,v 1.58 2004/05/30 23:40:28 neilc Exp $
*
*-------------------------------------------------------------------------
*/
@ -126,8 +126,8 @@ add_equijoined_keys(Query *root, RestrictInfo *restrictinfo)
while (cursetlink)
{
List *curset = (List *) lfirst(cursetlink);
bool item1here = member(item1, curset);
bool item2here = member(item2, curset);
bool item1here = list_member(curset, item1);
bool item2here = list_member(curset, item2);
/* must advance cursetlink before lremove possibly pfree's it */
cursetlink = lnext(cursetlink);
@ -147,22 +147,22 @@ add_equijoined_keys(Query *root, RestrictInfo *restrictinfo)
/* Build the new set only when we know we must */
if (newset == NIL)
newset = makeList2(item1, item2);
newset = list_make2(item1, item2);
/* Found a set to merge into our new set */
newset = set_union(newset, curset);
newset = list_union(newset, curset);
/*
* Remove old set from equi_key_list.
*/
root->equi_key_list = lremove(curset, root->equi_key_list);
freeList(curset); /* might as well recycle old cons cells */
root->equi_key_list = list_delete_ptr(root->equi_key_list, curset);
list_free(curset); /* might as well recycle old cons cells */
}
}
/* Build the new set only when we know we must */
if (newset == NIL)
newset = makeList2(item1, item2);
newset = list_make2(item1, item2);
root->equi_key_list = lcons(newset, root->equi_key_list);
}
@ -204,7 +204,7 @@ generate_implied_equalities(Query *root)
foreach(cursetlink, root->equi_key_list)
{
List *curset = (List *) lfirst(cursetlink);
int nitems = length(curset);
int nitems = list_length(curset);
Relids *relids;
bool have_consts;
ListCell *ptr1;
@ -341,10 +341,10 @@ make_canonical_pathkey(Query *root, PathKeyItem *item)
{
List *curset = (List *) lfirst(cursetlink);
if (member(item, curset))
if (list_member(curset, item))
return curset;
}
newset = makeList1(item);
newset = list_make1(item);
root->equi_key_list = lcons(newset, root->equi_key_list);
return newset;
}
@ -383,7 +383,7 @@ canonicalize_pathkeys(Query *root, List *pathkeys)
* canonicalized the keys, so that equivalent-key knowledge is
* used when deciding if an item is redundant.
*/
if (!ptrMember(cpathkey, new_pathkeys))
if (!list_member_ptr(new_pathkeys, cpathkey))
new_pathkeys = lappend(new_pathkeys, cpathkey);
}
return new_pathkeys;
@ -408,8 +408,8 @@ count_canonical_peers(Query *root, PathKeyItem *item)
{
List *curset = (List *) lfirst(cursetlink);
if (member(item, curset))
return length(curset) - 1;
if (list_member(curset, item))
return list_length(curset) - 1;
}
return 0;
}
@ -443,8 +443,8 @@ compare_pathkeys(List *keys1, List *keys2)
* input, but query root not accessible here...
*/
#ifdef NOT_USED
Assert(ptrMember(subkey1, root->equi_key_list));
Assert(ptrMember(subkey2, root->equi_key_list));
Assert(list_member_ptr(root->equi_key_list, subkey1));
Assert(list_member_ptr(root->equi_key_list, subkey2));
#endif
/*
@ -499,8 +499,8 @@ compare_noncanonical_pathkeys(List *keys1, List *keys2)
List *subkey1 = (List *) lfirst(key1);
List *subkey2 = (List *) lfirst(key2);
Assert(length(subkey1) == 1);
Assert(length(subkey2) == 1);
Assert(list_length(subkey1) == 1);
Assert(list_length(subkey2) == 1);
if (!equal(subkey1, subkey2))
return PATHKEYS_DIFFERENT; /* no need to keep looking */
}
@ -693,7 +693,7 @@ build_index_pathkeys(Query *root,
* Eliminate redundant ordering info; could happen if query is
* such that index keys are equijoined...
*/
if (!ptrMember(cpathkey, retval))
if (!list_member_ptr(retval, cpathkey))
retval = lappend(retval, cpathkey);
indexkeys++;
@ -752,7 +752,7 @@ build_subquery_pathkeys(Query *root, RelOptInfo *rel, Query *subquery)
{
List *retval = NIL;
int retvallen = 0;
int outer_query_keys = length(root->query_pathkeys);
int outer_query_keys = list_length(root->query_pathkeys);
List *sub_tlist = rel->subplan->targetlist;
ListCell *i;
@ -810,8 +810,7 @@ build_subquery_pathkeys(Query *root, RelOptInfo *rel, Query *subquery)
score = count_canonical_peers(root, outer_item);
/* +1 if it matches the proper query_pathkeys item */
if (retvallen < outer_query_keys &&
member(outer_item,
nth(retvallen, root->query_pathkeys)))
list_member(list_nth(root->query_pathkeys, retvallen), outer_item))
score++;
if (score > best_score)
{
@ -836,7 +835,7 @@ build_subquery_pathkeys(Query *root, RelOptInfo *rel, Query *subquery)
* Eliminate redundant ordering info; could happen if outer query
* equijoins subquery keys...
*/
if (!ptrMember(cpathkey, retval))
if (!list_member_ptr(retval, cpathkey))
{
retval = lappend(retval, cpathkey);
retvallen++;
@ -920,7 +919,7 @@ make_pathkeys_for_sortclauses(List *sortclauses,
* canonicalize_pathkeys() might replace it with a longer sublist
* later.
*/
pathkeys = lappend(pathkeys, makeList1(pathkey));
pathkeys = lappend(pathkeys, list_make1(pathkey));
}
return pathkeys;
}
@ -1041,7 +1040,7 @@ find_mergeclauses_for_pathkeys(Query *root,
*/
if ((pathkey == restrictinfo->left_pathkey ||
pathkey == restrictinfo->right_pathkey) &&
!ptrMember(restrictinfo, mergeclauses))
!list_member_ptr(mergeclauses, restrictinfo))
{
matched_restrictinfos = lappend(matched_restrictinfos,
restrictinfo);
@ -1060,7 +1059,7 @@ find_mergeclauses_for_pathkeys(Query *root,
* If we did find usable mergeclause(s) for this sort-key
* position, add them to result list.
*/
mergeclauses = nconc(mergeclauses, matched_restrictinfos);
mergeclauses = list_concat(mergeclauses, matched_restrictinfos);
}
return mergeclauses;
@ -1124,7 +1123,7 @@ make_pathkeys_for_mergeclauses(Query *root,
* pathkey, a simple ptrMember test is sufficient to detect
* redundant keys.
*/
if (!ptrMember(pathkey, pathkeys))
if (!list_member_ptr(pathkeys, pathkey))
pathkeys = lappend(pathkeys, pathkey);
}
@ -1214,7 +1213,7 @@ pathkeys_useful_for_merging(Query *root, RelOptInfo *rel, List *pathkeys)
*
* Unlike merge pathkeys, this is an all-or-nothing affair: it does us
* no good to order by just the first key(s) of the requested ordering.
* So the result is always either 0 or length(root->query_pathkeys).
* So the result is always either 0 or list_length(root->query_pathkeys).
*/
int
pathkeys_useful_for_ordering(Query *root, List *pathkeys)
@ -1228,7 +1227,7 @@ pathkeys_useful_for_ordering(Query *root, List *pathkeys)
if (pathkeys_contained_in(root->query_pathkeys, pathkeys))
{
/* It's useful ... or at least the first N keys are */
return length(root->query_pathkeys);
return list_length(root->query_pathkeys);
}
return 0; /* path ordering not useful */
@ -1255,8 +1254,8 @@ truncate_useless_pathkeys(Query *root,
* Note: not safe to modify input list destructively, but we can avoid
* copying the list if we're not actually going to change it
*/
if (nuseful == length(pathkeys))
if (nuseful == list_length(pathkeys))
return pathkeys;
else
return ltruncate(nuseful, listCopy(pathkeys));
return list_truncate(list_copy(pathkeys), nuseful);
}

8
src/backend/optimizer/path/tidpath.c
View File

@ -9,7 +9,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/optimizer/path/tidpath.c,v 1.19 2004/05/26 04:41:22 neilc Exp $
* $PostgreSQL: pgsql/src/backend/optimizer/path/tidpath.c,v 1.20 2004/05/30 23:40:28 neilc Exp $
*
*-------------------------------------------------------------------------
*/
@ -79,7 +79,7 @@ TidequalClause(int varno, OpExpr *node)
if (node->opno != TIDEqualOperator)
return rnode;
if (length(node->args) != 2)
if (list_length(node->args) != 2)
return rnode;
arg1 = linitial(node->args);
arg2 = lsecond(node->args);
@ -184,11 +184,11 @@ TidqualFromExpr(int varno, Expr *expr)
node = (Node *) lfirst(l);
frtn = TidqualFromExpr(varno, (Expr *) node);
if (frtn)
rlst = nconc(rlst, frtn);
rlst = list_concat(rlst, frtn);
else
{
if (rlst)
freeList(rlst);
list_free(rlst);
rlst = NIL;
break;
}

56
src/backend/optimizer/plan/createplan.c
View File

@ -10,7 +10,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/optimizer/plan/createplan.c,v 1.170 2004/05/26 04:41:24 neilc Exp $
* $PostgreSQL: pgsql/src/backend/optimizer/plan/createplan.c,v 1.171 2004/05/30 23:40:28 neilc Exp $
*
*-------------------------------------------------------------------------
*/
@ -395,7 +395,7 @@ create_join_plan(Query *root, JoinPath *best_path)
*/
if (get_loc_restrictinfo(best_path) != NIL)
set_qpqual((Plan) plan,
nconc(get_qpqual((Plan) plan),
list_concat(get_qpqual((Plan) plan),
get_actual_clauses(get_loc_restrictinfo(best_path))));
#endif
@ -548,12 +548,12 @@ create_unique_plan(Query *root, UniquePath *best_path)
elog(ERROR, "could not find UniquePath in in_info_list");
/* set up to record positions of unique columns */
numGroupCols = length(uniq_exprs);
numGroupCols = list_length(uniq_exprs);
groupColIdx = (AttrNumber *) palloc(numGroupCols * sizeof(AttrNumber));
groupColPos = 0;
/* not sure if tlist might be shared with other nodes, so copy */
newtlist = copyObject(subplan->targetlist);
nextresno = length(newtlist) + 1;
nextresno = list_length(newtlist) + 1;
newitems = false;
foreach(l, uniq_exprs)
@ -725,9 +725,9 @@ create_indexscan_plan(Query *root,
* need to worry about the plain AND case. Also, pointer comparison
* should be enough to determine RestrictInfo matches.
*/
Assert(length(best_path->indexclauses) == 1);
scan_clauses = set_ptrUnion(scan_clauses,
(List *) linitial(best_path->indexclauses));
Assert(list_length(best_path->indexclauses) == 1);
scan_clauses = list_union_ptr(scan_clauses,
(List *) linitial(best_path->indexclauses));
}
/* Reduce RestrictInfo list to bare expressions */
@ -766,7 +766,7 @@ create_indexscan_plan(Query *root,
* added to qpqual. The upshot is that qpquals must contain scan_clauses
* minus whatever appears in indxquals.
*/
if (length(indxquals) > 1)
if (list_length(indxquals) > 1)
{
/*
* Build an expression representation of the indexqual, expanding
@ -775,7 +775,7 @@ create_indexscan_plan(Query *root,
* scan_clause are not great; perhaps we need more smarts here.)
*/
indxqual_or_expr = make_expr_from_indexclauses(indxquals);
qpqual = set_difference(scan_clauses, makeList1(indxqual_or_expr));
qpqual = list_difference(scan_clauses, list_make1(indxqual_or_expr));
}
else
{
@ -785,7 +785,7 @@ create_indexscan_plan(Query *root,
* behavior.
*/
Assert(stripped_indxquals != NIL);
qpqual = set_difference(scan_clauses, linitial(stripped_indxquals));
qpqual = list_difference(scan_clauses, linitial(stripped_indxquals));
}
/*
@ -950,7 +950,7 @@ create_nestloop_plan(Query *root,
List *indexclauses = innerpath->indexclauses;
if (innerpath->isjoininner &&
length(indexclauses) == 1) /* single indexscan? */
list_length(indexclauses) == 1) /* single indexscan? */
{
joinrestrictclauses =
select_nonredundant_join_clauses(root,
@ -1019,7 +1019,7 @@ create_mergejoin_plan(Query *root,
* the list of quals that must be checked as qpquals.
*/
mergeclauses = get_actual_clauses(best_path->path_mergeclauses);
joinclauses = set_difference(joinclauses, mergeclauses);
joinclauses = list_difference(joinclauses, mergeclauses);
/*
* Rearrange mergeclauses, if needed, so that the outer variable is
@ -1103,7 +1103,7 @@ create_hashjoin_plan(Query *root,
* the list of quals that must be checked as qpquals.
*/
hashclauses = get_actual_clauses(best_path->path_hashclauses);
joinclauses = set_difference(joinclauses, hashclauses);
joinclauses = list_difference(joinclauses, hashclauses);
/*
* Rearrange hashclauses, if needed, so that the outer variable is
@ -1248,7 +1248,7 @@ fix_indxqual_sublist(List *indexqual,
Assert(IsA(rinfo, RestrictInfo));
clause = (OpExpr *) rinfo->clause;
if (!IsA(clause, OpExpr) || length(clause->args) != 2)
if (!IsA(clause, OpExpr) || list_length(clause->args) != 2)
elog(ERROR, "indexqual clause is not binary opclause");
/*
@ -1287,9 +1287,9 @@ fix_indxqual_sublist(List *indexqual,
get_op_opclass_properties(newclause->opno, opclass,
&stratno, &stratsubtype, &recheck);
*strategy = lappendi(*strategy, stratno);
*subtype = lappendo(*subtype, stratsubtype);
*lossy = lappendi(*lossy, (int) recheck);
*strategy = lappend_int(*strategy, stratno);
*subtype = lappend_oid(*subtype, stratsubtype);
*lossy = lappend_int(*lossy, (int) recheck);
}
}
@ -1401,7 +1401,7 @@ get_switched_clauses(List *clauses, Relids outerrelids)
temp->opfuncid = InvalidOid;
temp->opresulttype = clause->opresulttype;
temp->opretset = clause->opretset;
temp->args = listCopy(clause->args);
temp->args = list_copy(clause->args);
/* Commute it --- note this modifies the temp node in-place. */
CommuteClause(temp);
t_list = lappend(t_list, temp);
@ -1839,8 +1839,8 @@ make_sort_from_pathkeys(Query *root, Plan *lefttree, List *pathkeys)
AttrNumber *sortColIdx;
Oid *sortOperators;
/* We will need at most length(pathkeys) sort columns; possibly less */
numsortkeys = length(pathkeys);
/* We will need at most list_length(pathkeys) sort columns; possibly less */
numsortkeys = list_length(pathkeys);
sortColIdx = (AttrNumber *) palloc(numsortkeys * sizeof(AttrNumber));
sortOperators = (Oid *) palloc(numsortkeys * sizeof(Oid));
@ -1888,7 +1888,7 @@ make_sort_from_pathkeys(Query *root, Plan *lefttree, List *pathkeys)
if (!tlist_member(lfirst(k), tlist))
break;
}
freeList(exprvars);
list_free(exprvars);
if (!k)
break; /* found usable expression */
}
@ -1907,7 +1907,7 @@ make_sort_from_pathkeys(Query *root, Plan *lefttree, List *pathkeys)
/*
* Add resjunk entry to input's tlist
*/
resdom = makeResdom(length(tlist) + 1,
resdom = makeResdom(list_length(tlist) + 1,
exprType(pathkey->key),
exprTypmod(pathkey->key),
NULL,
@ -1950,8 +1950,8 @@ make_sort_from_sortclauses(Query *root, List *sortcls, Plan *lefttree)
AttrNumber *sortColIdx;
Oid *sortOperators;
/* We will need at most length(sortcls) sort columns; possibly less */
numsortkeys = length(sortcls);
/* We will need at most list_length(sortcls) sort columns; possibly less */
numsortkeys = list_length(sortcls);
sortColIdx = (AttrNumber *) palloc(numsortkeys * sizeof(AttrNumber));
sortOperators = (Oid *) palloc(numsortkeys * sizeof(Oid));
@ -2003,8 +2003,8 @@ make_sort_from_groupcols(Query *root,
AttrNumber *sortColIdx;
Oid *sortOperators;
/* We will need at most length(groupcls) sort columns; possibly less */
numsortkeys = length(groupcls);
/* We will need at most list_length(groupcls) sort columns; possibly less */
numsortkeys = list_length(groupcls);
sortColIdx = (AttrNumber *) palloc(numsortkeys * sizeof(AttrNumber));
sortOperators = (Oid *) palloc(numsortkeys * sizeof(Oid));
@ -2207,7 +2207,7 @@ make_unique(Plan *lefttree, List *distinctList)
{
Unique *node = makeNode(Unique);
Plan *plan = &node->plan;
int numCols = length(distinctList);
int numCols = list_length(distinctList);
int keyno = 0;
AttrNumber *uniqColIdx;
ListCell *slitem;
@ -2264,7 +2264,7 @@ make_setop(SetOpCmd cmd, Plan *lefttree,
{
SetOp *node = makeNode(SetOp);
Plan *plan = &node->plan;
int numCols = length(distinctList);
int numCols = list_length(distinctList);
int keyno = 0;
AttrNumber *dupColIdx;
ListCell *slitem;

30
src/backend/optimizer/plan/initsplan.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/optimizer/plan/initsplan.c,v 1.99 2004/05/26 04:41:24 neilc Exp $
* $PostgreSQL: pgsql/src/backend/optimizer/plan/initsplan.c,v 1.100 2004/05/30 23:40:29 neilc Exp $
*
*-------------------------------------------------------------------------
*/
@ -121,7 +121,7 @@ build_base_rel_tlists(Query *root, List *final_tlist)
if (tlist_vars != NIL)
{
add_vars_to_targetlist(root, tlist_vars, bms_make_singleton(0));
freeList(tlist_vars);
list_free(tlist_vars);
}
}
@ -333,7 +333,7 @@ mark_baserels_for_outer_join(Query *root, Relids rels, Relids outerrels)
*/
if (rel->outerjoinset == NULL)
{
if (intMember(relno, root->rowMarks))
if (list_member_int(root->rowMarks, relno))
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("SELECT FOR UPDATE cannot be applied to the nullable side of an outer join")));
@ -585,7 +585,7 @@ distribute_qual_to_rels(Query *root, Node *clause,
*/
vars = pull_var_clause(clause, false);
add_vars_to_targetlist(root, vars, relids);
freeList(vars);
list_free(vars);
break;
default:
@ -705,8 +705,8 @@ process_implied_equality(Query *root,
if (membership == BMS_SINGLETON)
{
/* delete it from local restrictinfo list */
rel1->baserestrictinfo = lremove(restrictinfo,
rel1->baserestrictinfo);
rel1->baserestrictinfo = list_delete_ptr(rel1->baserestrictinfo,
restrictinfo);
}
else
{
@ -728,7 +728,7 @@ process_implied_equality(Query *root,
*/
ltype = exprType(item1);
rtype = exprType(item2);
eq_operator = compatible_oper(makeList1(makeString("=")),
eq_operator = compatible_oper(list_make1(makeString("=")),
ltype, rtype, true);
if (!HeapTupleIsValid(eq_operator))
{
@ -854,11 +854,11 @@ qual_is_redundant(Query *root,
* done. We give up when we can't expand the equalexprs list any
* more.
*/
equalexprs = makeList1(newleft);
equalexprs = list_make1(newleft);
do
{
someadded = false;
/* cannot use foreach here because of possible lremove */
/* cannot use foreach here because of possible list_delete */
olditem = list_head(oldquals);
while (olditem)
{
@ -867,12 +867,12 @@ qual_is_redundant(Query *root,
Node *oldright = get_rightop(oldrinfo->clause);
Node *newguy = NULL;
/* must advance olditem before lremove possibly pfree's it */
/* must advance olditem before list_delete possibly pfree's it */
olditem = lnext(olditem);
if (member(oldleft, equalexprs))
if (list_member(equalexprs, oldleft))
newguy = oldright;
else if (member(oldright, equalexprs))
else if (list_member(equalexprs, oldright))
newguy = oldleft;
else
continue;
@ -884,7 +884,7 @@ qual_is_redundant(Query *root,
/*
* Remove this qual from list, since we don't need it anymore.
*/
oldquals = lremove(oldrinfo, oldquals);
oldquals = list_delete_ptr(oldquals, oldrinfo);
}
} while (someadded);
@ -917,7 +917,7 @@ check_mergejoinable(RestrictInfo *restrictinfo)
if (!is_opclause(clause))
return;
if (length(((OpExpr *) clause)->args) != 2)
if (list_length(((OpExpr *) clause)->args) != 2)
return;
opno = ((OpExpr *) clause)->opno;
@ -950,7 +950,7 @@ check_hashjoinable(RestrictInfo *restrictinfo)
if (!is_opclause(clause))
return;
if (length(((OpExpr *) clause)->args) != 2)
if (list_length(((OpExpr *) clause)->args) != 2)
return;
opno = ((OpExpr *) clause)->opno;

24
src/backend/optimizer/plan/planner.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/optimizer/plan/planner.c,v 1.170 2004/05/26 04:41:24 neilc Exp $
* $PostgreSQL: pgsql/src/backend/optimizer/plan/planner.c,v 1.171 2004/05/30 23:40:29 neilc Exp $
*
*-------------------------------------------------------------------------
*/
@ -131,7 +131,7 @@ planner(Query *parse, bool isCursor, int cursorOptions)
}
/* executor wants to know total number of Params used overall */
result_plan->nParamExec = length(PlannerParamList);
result_plan->nParamExec = list_length(PlannerParamList);
/* final cleanup of the plan */
set_plan_references(result_plan, parse->rtable);
@ -493,14 +493,14 @@ inheritance_planner(Query *parse, List *inheritlist)
{
int parentRTindex = parse->resultRelation;
Oid parentOID = getrelid(parentRTindex, parse->rtable);
int mainrtlength = length(parse->rtable);
int mainrtlength = list_length(parse->rtable);
List *subplans = NIL;
List *tlist = NIL;
ListCell *l;
foreach(l, inheritlist)
{
int childRTindex = lfirsti(l);
int childRTindex = lfirst_int(l);
Oid childOID = getrelid(childRTindex, parse->rtable);
int subrtlength;
Query *subquery;
@ -522,13 +522,13 @@ inheritance_planner(Query *parse, List *inheritlist)
* XXX my goodness this is ugly. Really need to think about ways to
* rein in planner's habit of scribbling on its input.
*/
subrtlength = length(subquery->rtable);
subrtlength = list_length(subquery->rtable);
if (subrtlength > mainrtlength)
{
List *subrt;
subrt = list_copy_tail(subquery->rtable, mainrtlength);
parse->rtable = nconc(parse->rtable, subrt);
parse->rtable = list_concat(parse->rtable, subrt);
mainrtlength = subrtlength;
}
/* Save preprocessed tlist from first rel for use in Append */
@ -634,7 +634,7 @@ grouping_planner(Query *parse, double tuple_fraction)
double dNumGroups = 0;
long numGroups = 0;
int numAggs = 0;
int numGroupCols = length(parse->groupClause);
int numGroupCols = list_length(parse->groupClause);
bool use_hashed_grouping = false;
/* Preprocess targetlist in case we are inside an INSERT/UPDATE. */
@ -672,7 +672,7 @@ grouping_planner(Query *parse, double tuple_fraction)
foreach(l, parse->rowMarks)
{
Index rti = lfirsti(l);
Index rti = lfirst_int(l);
char *resname;
Resdom *resdom;
Var *var;
@ -680,7 +680,7 @@ grouping_planner(Query *parse, double tuple_fraction)
resname = (char *) palloc(32);
snprintf(resname, 32, "ctid%u", rti);
resdom = makeResdom(length(tlist) + 1,
resdom = makeResdom(list_length(tlist) + 1,
TIDOID,
-1,
resname,
@ -1421,7 +1421,7 @@ make_subplanTargetList(Query *parse,
sub_tlist = flatten_tlist(tlist);
extravars = pull_var_clause(parse->havingQual, false);
sub_tlist = add_to_flat_tlist(sub_tlist, extravars);
freeList(extravars);
list_free(extravars);
*need_tlist_eval = false; /* only eval if not flat tlist */
/*
@ -1430,7 +1430,7 @@ make_subplanTargetList(Query *parse,
* already), and make an array showing where the group columns are in
* the sub_tlist.
*/
numCols = length(parse->groupClause);
numCols = list_length(parse->groupClause);
if (numCols > 0)
{
int keyno = 0;
@ -1456,7 +1456,7 @@ make_subplanTargetList(Query *parse,
}
if (!sl)
{
te = makeTargetEntry(makeResdom(length(sub_tlist) + 1,
te = makeTargetEntry(makeResdom(list_length(sub_tlist) + 1,
exprType(groupexpr),
exprTypmod(groupexpr),
NULL,

38
src/backend/optimizer/plan/subselect.c
View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/optimizer/plan/subselect.c,v 1.90 2004/05/26 04:41:24 neilc Exp $
* $PostgreSQL: pgsql/src/backend/optimizer/plan/subselect.c,v 1.91 2004/05/30 23:40:29 neilc Exp $
*
*-------------------------------------------------------------------------
*/
@ -191,7 +191,7 @@ replace_outer_agg(Aggref *agg)
pitem->abslevel = abslevel;
PlannerParamList = lappend(PlannerParamList, pitem);
i = length(PlannerParamList) - 1;
i = list_length(PlannerParamList) - 1;
retval = makeNode(Param);
retval->paramkind = PARAM_EXEC;
@ -216,7 +216,7 @@ generate_new_param(Oid paramtype, int32 paramtypmod)
retval = makeNode(Param);
retval->paramkind = PARAM_EXEC;
retval->paramid = (AttrNumber) length(PlannerParamList);
retval->paramid = (AttrNumber) list_length(PlannerParamList);
retval->paramtype = paramtype;
pitem = (PlannerParamItem *) palloc(sizeof(PlannerParamItem));
@ -320,10 +320,10 @@ make_subplan(SubLink *slink, List *lefthand, bool isTopQual)
tmpset = bms_copy(plan->extParam);
while ((paramid = bms_first_member(tmpset)) >= 0)
{
PlannerParamItem *pitem = nth(paramid, PlannerParamList);
PlannerParamItem *pitem = list_nth(PlannerParamList, paramid);
if (pitem->abslevel == PlannerQueryLevel)
node->parParam = lappendi(node->parParam, paramid);
node->parParam = lappend_int(node->parParam, paramid);
}
bms_free(tmpset);
@ -341,7 +341,7 @@ make_subplan(SubLink *slink, List *lefthand, bool isTopQual)
Param *prm;
prm = generate_new_param(BOOLOID, -1);
node->setParam = makeListi1(prm->paramid);
node->setParam = list_make1_int(prm->paramid);
PlannerInitPlan = lappend(PlannerInitPlan, node);
result = (Node *) prm;
}
@ -352,7 +352,7 @@ make_subplan(SubLink *slink, List *lefthand, bool isTopQual)
Assert(!te->resdom->resjunk);
prm = generate_new_param(te->resdom->restype, te->resdom->restypmod);
node->setParam = makeListi1(prm->paramid);
node->setParam = list_make1_int(prm->paramid);
PlannerInitPlan = lappend(PlannerInitPlan, node);
result = (Node *) prm;
}
@ -368,7 +368,7 @@ make_subplan(SubLink *slink, List *lefthand, bool isTopQual)
elog(ERROR, "could not find array type for datatype %s",
format_type_be(te->resdom->restype));
prm = generate_new_param(arraytype, -1);
node->setParam = makeListi1(prm->paramid);
node->setParam = list_make1_int(prm->paramid);
PlannerInitPlan = lappend(PlannerInitPlan, node);
result = (Node *) prm;
}
@ -382,7 +382,7 @@ make_subplan(SubLink *slink, List *lefthand, bool isTopQual)
plan->targetlist,
0,
&node->paramIds);
node->setParam = listCopy(node->paramIds);
node->setParam = list_copy(node->paramIds);
PlannerInitPlan = lappend(PlannerInitPlan, node);
/*
@ -390,7 +390,7 @@ make_subplan(SubLink *slink, List *lefthand, bool isTopQual)
* outer plan's expression tree; they are not kept in the initplan
* node.
*/
if (length(exprs) > 1)
if (list_length(exprs) > 1)
result = (Node *) (node->useOr ? make_orclause(exprs) :
make_andclause(exprs));
else
@ -473,7 +473,7 @@ make_subplan(SubLink *slink, List *lefthand, bool isTopQual)
args = NIL;
foreach(l, node->parParam)
{
PlannerParamItem *pitem = nth(lfirsti(l), PlannerParamList);
PlannerParamItem *pitem = list_nth(PlannerParamList, lfirst_int(l));
/*
* The Var or Aggref has already been adjusted to have the
@ -517,7 +517,7 @@ convert_sublink_opers(List *lefthand, List *operOids,
foreach(l, operOids)
{
Oid opid = lfirsto(l);
Oid opid = lfirst_oid(l);
Node *leftop = (Node *) lfirst(lefthand_item);
TargetEntry *te = (TargetEntry *) lfirst(tlist_item);
Node *rightop;
@ -547,7 +547,7 @@ convert_sublink_opers(List *lefthand, List *operOids,
prm = generate_new_param(te->resdom->restype,
te->resdom->restypmod);
/* Record its ID */
*righthandIds = lappendi(*righthandIds, prm->paramid);
*righthandIds = lappend_int(*righthandIds, prm->paramid);
rightop = (Node *) prm;
}
@ -603,7 +603,7 @@ subplan_is_hashable(SubLink *slink, SubPlan *node)
*/
if (slink->subLinkType != ANY_SUBLINK)
return false;
if (length(slink->operName) != 1 ||
if (list_length(slink->operName) != 1 ||
strcmp(strVal(linitial(slink->operName)), "=") != 0)
return false;
@ -640,7 +640,7 @@ subplan_is_hashable(SubLink *slink, SubPlan *node)
*/
foreach(l, slink->operOids)
{
Oid opid = lfirsto(l);
Oid opid = lfirst_oid(l);
HeapTuple tup;
Form_pg_operator optup;
@ -691,7 +691,7 @@ convert_IN_to_join(Query *parse, SubLink *sublink)
*/
if (sublink->subLinkType != ANY_SUBLINK)
return NULL;
if (length(sublink->operName) != 1 ||
if (list_length(sublink->operName) != 1 ||
strcmp(strVal(linitial(sublink->operName)), "=") != 0)
return NULL;
@ -731,7 +731,7 @@ convert_IN_to_join(Query *parse, SubLink *sublink)
makeAlias("IN_subquery", NIL),
false);
parse->rtable = lappend(parse->rtable, rte);
rtindex = length(parse->rtable);
rtindex = list_length(parse->rtable);
rtr = makeNode(RangeTblRef);
rtr->rtindex = rtindex;
parse->jointree->fromlist = lappend(parse->jointree->fromlist, rtr);
@ -874,7 +874,7 @@ process_sublinks_mutator(Node *node, bool *isTopQual)
newarg = process_sublinks_mutator(lfirst(l),
(void *) &locTopQual);
if (and_clause(newarg))
newargs = nconc(newargs, ((BoolExpr *) newarg)->args);
newargs = list_concat(newargs, ((BoolExpr *) newarg)->args);
else
newargs = lappend(newargs, newarg);
}
@ -896,7 +896,7 @@ process_sublinks_mutator(Node *node, bool *isTopQual)
newarg = process_sublinks_mutator(lfirst(l),
(void *) &locTopQual);
if (or_clause(newarg))
newargs = nconc(newargs, ((BoolExpr *) newarg)->args);
newargs = list_concat(newargs, ((BoolExpr *) newarg)->args);
else
newargs = lappend(newargs, newarg);
}

40
src/backend/optimizer/prep/prepjointree.c
View File

@ -16,7 +16,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/optimizer/prep/prepjointree.c,v 1.19 2004/05/26 18:35:41 tgl Exp $
* $PostgreSQL: pgsql/src/backend/optimizer/prep/prepjointree.c,v 1.20 2004/05/30 23:40:29 neilc Exp $
*
*-------------------------------------------------------------------------
*/
@ -224,7 +224,7 @@ pull_up_subqueries(Query *parse, Node *jtnode, bool below_outer_join)
* Adjust level-0 varnos in subquery so that we can append its
* rangetable to upper query's.
*/
rtoffset = length(parse->rtable);
rtoffset = list_length(parse->rtable);
OffsetVarNodes((Node *) subquery, rtoffset, 0);
/*
@ -269,14 +269,14 @@ pull_up_subqueries(Query *parse, Node *jtnode, bool below_outer_join)
* hold off until after fixing the upper rtable entries; no
* point in running that code on the subquery ones too.)
*/
parse->rtable = nconc(parse->rtable, subquery->rtable);
parse->rtable = list_concat(parse->rtable, subquery->rtable);
/*
* Pull up any FOR UPDATE markers, too. (OffsetVarNodes
* already adjusted the marker values, so just nconc the
* list.)
* already adjusted the marker values, so just list_concat
* the list.)
*/
parse->rowMarks = nconc(parse->rowMarks, subquery->rowMarks);
parse->rowMarks = list_concat(parse->rowMarks, subquery->rowMarks);
/*
* We also have to fix the relid sets of any parent
@ -295,8 +295,8 @@ pull_up_subqueries(Query *parse, Node *jtnode, bool below_outer_join)
/*
* And now append any subquery InClauseInfos to our list.
*/
parse->in_info_list = nconc(parse->in_info_list,
subquery->in_info_list);
parse->in_info_list = list_concat(parse->in_info_list,
subquery->in_info_list);
/*
* Miscellaneous housekeeping.
@ -662,7 +662,7 @@ reduce_outer_joins_pass2(Node *jtnode,
pass_nonnullable = bms_add_members(pass_nonnullable,
nonnullable_rels);
/* And recurse --- but only into interesting subtrees */
Assert(length(f->fromlist) == length(state->sub_states));
Assert(list_length(f->fromlist) == list_length(state->sub_states));
forboth(l, f->fromlist, s, state->sub_states)
{
reduce_outer_joins_state *sub_state = lfirst(s);
@ -919,20 +919,20 @@ simplify_jointree(Query *parse, Node *jtnode)
* from_collapse_limit.
*/
FromExpr *subf = (FromExpr *) child;
int childlen = length(subf->fromlist);
int myothers = length(newlist) + children_remaining;
int childlen = list_length(subf->fromlist);
int myothers = list_length(newlist) + children_remaining;
if (childlen <= 1 ||
(childlen + myothers) <= from_collapse_limit)
{
newlist = nconc(newlist, subf->fromlist);
newlist = list_concat(newlist, subf->fromlist);
/*
* By now, the quals have been converted to
* implicit-AND lists, so we just need to join the
* lists. NOTE: we put the pulled-up quals first.
*/
f->quals = (Node *) nconc((List *) subf->quals,
f->quals = (Node *) list_concat((List *) subf->quals,
(List *) f->quals);
}
else
@ -963,11 +963,11 @@ simplify_jointree(Query *parse, Node *jtnode)
rightlen;
if (j->larg && IsA(j->larg, FromExpr))
leftlen = length(((FromExpr *) j->larg)->fromlist);
leftlen = list_length(((FromExpr *) j->larg)->fromlist);
else
leftlen = 1;
if (j->rarg && IsA(j->rarg, FromExpr))
rightlen = length(((FromExpr *) j->rarg)->fromlist);
rightlen = list_length(((FromExpr *) j->rarg)->fromlist);
else
rightlen = 1;
if ((leftlen + rightlen) <= join_collapse_limit)
@ -985,22 +985,22 @@ simplify_jointree(Query *parse, Node *jtnode)
f->quals = subf->quals;
}
else
f->fromlist = makeList1(j->larg);
f->fromlist = list_make1(j->larg);
if (j->rarg && IsA(j->rarg, FromExpr))
{
FromExpr *subf = (FromExpr *) j->rarg;
f->fromlist = nconc(f->fromlist,
subf->fromlist);
f->quals = (Node *) nconc((List *) f->quals,
f->fromlist = list_concat(f->fromlist,
subf->fromlist);
f->quals = (Node *) list_concat((List *) f->quals,
(List *) subf->quals);
}
else
f->fromlist = lappend(f->fromlist, j->rarg);
/* pulled-up quals first */
f->quals = (Node *) nconc((List *) f->quals,
f->quals = (Node *) list_concat((List *) f->quals,
(List *) j->quals);
return (Node *) f;

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

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/optimizer/prep/prepqual.c,v 1.42 2004/05/26 04:41:26 neilc Exp $
* $PostgreSQL: pgsql/src/backend/optimizer/prep/prepqual.c,v 1.43 2004/05/30 23:40:29 neilc Exp $
*
*-------------------------------------------------------------------------
*/
@ -445,7 +445,7 @@ process_duplicate_ors(List *orlist)
if (orlist == NIL)
return NULL; /* probably can't happen */
if (length(orlist) == 1) /* single-expression OR (can this happen?) */
if (list_length(orlist) == 1) /* single-expression OR (can this happen?) */
return linitial(orlist);
/*
@ -461,7 +461,7 @@ process_duplicate_ors(List *orlist)
if (and_clause((Node *) clause))
{
List *subclauses = ((BoolExpr *) clause)->args;
int nclauses = length(subclauses);
int nclauses = list_length(subclauses);
if (reference == NIL || nclauses < num_subclauses)
{
@ -471,7 +471,7 @@ process_duplicate_ors(List *orlist)
}
else
{
reference = makeList1(clause);
reference = list_make1(clause);
break;
}
}
@ -479,7 +479,7 @@ process_duplicate_ors(List *orlist)
/*
* Just in case, eliminate any duplicates in the reference list.
*/
reference = set_union(NIL, reference);
reference = list_union(NIL, reference);
/*
* Check each element of the reference list to see if it's in all the
@ -498,7 +498,7 @@ process_duplicate_ors(List *orlist)
if (and_clause((Node *) clause))
{
if (!member(refclause, ((BoolExpr *) clause)->args))
if (!list_member(((BoolExpr *) clause)->args, refclause))
{
win = false;
break;
@ -531,7 +531,7 @@ process_duplicate_ors(List *orlist)
* (A AND B) OR (A), which can be reduced to just A --- that is, the
* additional conditions in other arms of the OR are irrelevant.
*
* Note that because we use set_difference, any multiple occurrences of
* Note that because we use list_difference, any multiple occurrences of
* a winning clause in an AND sub-clause will be removed automatically.
*/
neworlist = NIL;
@ -543,10 +543,10 @@ process_duplicate_ors(List *orlist)
{
List *subclauses = ((BoolExpr *) clause)->args;
subclauses = set_difference(subclauses, winners);
subclauses = list_difference(subclauses, winners);
if (subclauses != NIL)
{
if (length(subclauses) == 1)
if (list_length(subclauses) == 1)
neworlist = lappend(neworlist, linitial(subclauses));
else
neworlist = lappend(neworlist, make_andclause(subclauses));
@ -559,7 +559,7 @@ process_duplicate_ors(List *orlist)
}
else
{
if (!member(clause, winners))
if (!list_member(winners, clause))
neworlist = lappend(neworlist, clause);
else
{
@ -577,7 +577,7 @@ process_duplicate_ors(List *orlist)
*/
if (neworlist != NIL)
{
if (length(neworlist) == 1)
if (list_length(neworlist) == 1)
winners = lappend(winners, linitial(neworlist));
else
winners = lappend(winners, make_orclause(pull_ors(neworlist)));
@ -587,7 +587,7 @@ process_duplicate_ors(List *orlist)
* And return the constructed AND clause, again being wary of a single
* element and AND/OR flatness.
*/
if (length(winners) == 1)
if (list_length(winners) == 1)
return (Expr *) linitial(winners);
else
return make_andclause(pull_ands(winners));

6
src/backend/optimizer/prep/preptlist.c
View File

@ -15,7 +15,7 @@
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/optimizer/prep/preptlist.c,v 1.67 2004/05/26 04:41:26 neilc Exp $
* $PostgreSQL: pgsql/src/backend/optimizer/prep/preptlist.c,v 1.68 2004/05/30 23:40:29 neilc Exp $
*
*-------------------------------------------------------------------------
*/
@ -79,7 +79,7 @@ preprocess_targetlist(List *tlist,
Resdom *resdom;
Var *var;
resdom = makeResdom(length(tlist) + 1,
resdom = makeResdom(list_length(tlist) + 1,
TIDOID,
-1,
pstrdup("ctid"),
@ -94,7 +94,7 @@ preprocess_targetlist(List *tlist,
* modify the original tlist (is this really necessary?).
*/
if (command_type == CMD_DELETE)
tlist = listCopy(tlist);
tlist = list_copy(tlist);
tlist = lappend(tlist, makeTargetEntry(resdom, (Expr *) var));
}

60
src/backend/optimizer/prep/prepunion.c
View File

@ -14,7 +14,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/optimizer/prep/prepunion.c,v 1.111 2004/05/26 04:41:26 neilc Exp $
* $PostgreSQL: pgsql/src/backend/optimizer/prep/prepunion.c,v 1.112 2004/05/30 23:40:29 neilc Exp $
*
*-------------------------------------------------------------------------
*/
@ -235,10 +235,10 @@ generate_union_plan(SetOperationStmt *op, Query *parse,
* generate only one Append and Sort for the lot. Recurse to find
* such nodes and compute their children's plans.
*/
planlist = nconc(recurse_union_children(op->larg, parse,
op, refnames_tlist),
recurse_union_children(op->rarg, parse,
op, refnames_tlist));
planlist = list_concat(recurse_union_children(op->larg, parse,
op, refnames_tlist),
recurse_union_children(op->rarg, parse,
op, refnames_tlist));
/*
* Generate tlist for Append plan node.
@ -303,7 +303,7 @@ generate_nonunion_plan(SetOperationStmt *op, Query *parse,
op->colTypes, false, 1,
refnames_tlist,
&child_sortclauses);
planlist = makeList2(lplan, rplan);
planlist = list_make2(lplan, rplan);
/*
* Generate tlist for Append plan node.
@ -349,7 +349,7 @@ generate_nonunion_plan(SetOperationStmt *op, Query *parse,
cmd = SETOPCMD_INTERSECT; /* keep compiler quiet */
break;
}
plan = (Plan *) make_setop(cmd, plan, sortList, length(op->colTypes) + 1);
plan = (Plan *) make_setop(cmd, plan, sortList, list_length(op->colTypes) + 1);
*sortClauses = sortList;
@ -375,15 +375,15 @@ recurse_union_children(Node *setOp, Query *parse,
if (op->op == top_union->op &&
(op->all == top_union->all || op->all) &&
equalo(op->colTypes, top_union->colTypes))
equal(op->colTypes, top_union->colTypes))
{
/* Same UNION, so fold children into parent's subplan list */
return nconc(recurse_union_children(op->larg, parse,
top_union,
refnames_tlist),
recurse_union_children(op->rarg, parse,
top_union,
refnames_tlist));
return list_concat(recurse_union_children(op->larg, parse,
top_union,
refnames_tlist),
recurse_union_children(op->rarg, parse,
top_union,
refnames_tlist));
}
}
@ -397,10 +397,10 @@ recurse_union_children(Node *setOp, Query *parse,
* we have an EXCEPT or INTERSECT as child, else there won't be
* resjunk anyway.
*/
return makeList1(recurse_set_operations(setOp, parse,
top_union->colTypes, false,
-1, refnames_tlist,
&child_sortclauses));
return list_make1(recurse_set_operations(setOp, parse,
top_union->colTypes, false,
-1, refnames_tlist,
&child_sortclauses));
}
/*
@ -430,7 +430,7 @@ generate_setop_tlist(List *colTypes, int flag,
k = list_head(refnames_tlist);
foreach(i, colTypes)
{
Oid colType = lfirsto(i);
Oid colType = lfirst_oid(i);
TargetEntry *inputtle = (TargetEntry *) lfirst(j);
TargetEntry *reftle = (TargetEntry *) lfirst(k);
int32 colTypmod;
@ -536,7 +536,7 @@ generate_append_tlist(List *colTypes, bool flag,
* If the inputs all agree on type and typmod of a particular column, use
* that typmod; else use -1. (+1 here in case of zero columns.)
*/
colTypmods = (int32 *) palloc(length(colTypes) * sizeof(int32) + 1);
colTypmods = (int32 *) palloc(list_length(colTypes) * sizeof(int32) + 1);
foreach(planl, input_plans)
{
@ -577,7 +577,7 @@ generate_append_tlist(List *colTypes, bool flag,
colindex = 0;
forboth(curColType, colTypes, ref_tl_item, refnames_tlist)
{
Oid colType = lfirsto(curColType);
Oid colType = lfirst_oid(curColType);
int32 colTypmod = colTypmods[colindex++];
TargetEntry *reftle = (TargetEntry *) lfirst(ref_tl_item);
@ -663,7 +663,7 @@ List *
find_all_inheritors(Oid parentrel)
{
List *examined_relids = NIL;
List *unexamined_relids = makeListo1(parentrel);
List *unexamined_relids = list_make1_oid(parentrel);
/*
* While the queue of unexamined relids is nonempty, remove the first
@ -676,7 +676,7 @@ find_all_inheritors(Oid parentrel)
List *currentchildren;
unexamined_relids = list_delete_first(unexamined_relids);
examined_relids = lappendo(examined_relids, currentrel);
examined_relids = lappend_oid(examined_relids, currentrel);
currentchildren = find_inheritance_children(currentrel);
/*
@ -686,8 +686,8 @@ find_all_inheritors(Oid parentrel)
* into an infinite loop, though theoretically there can't be any
* cycles in the inheritance graph anyway.)
*/
currentchildren = set_differenceo(currentchildren, examined_relids);
unexamined_relids = set_uniono(unexamined_relids, currentchildren);
currentchildren = list_difference_oid(currentchildren, examined_relids);
unexamined_relids = list_union_oid(unexamined_relids, currentchildren);
}
return examined_relids;
@ -744,17 +744,17 @@ expand_inherited_rtentry(Query *parse, Index rti, bool dup_parent)
* case. This could happen despite above has_subclass() check, if
* table once had a child but no longer does.
*/
if (length(inhOIDs) < 2)
if (list_length(inhOIDs) < 2)
return NIL;
/* OK, it's an inheritance set; expand it */
if (dup_parent)
inhRTIs = NIL;
else
inhRTIs = makeListi1(rti); /* include original RTE in result */
inhRTIs = list_make1_int(rti); /* include original RTE in result */
foreach(l, inhOIDs)
{
Oid childOID = lfirsto(l);
Oid childOID = lfirst_oid(l);
RangeTblEntry *childrte;
Index childRTindex;
@ -771,9 +771,9 @@ expand_inherited_rtentry(Query *parse, Index rti, bool dup_parent)
childrte = copyObject(rte);
childrte->relid = childOID;
parse->rtable = lappend(parse->rtable, childrte);
childRTindex = length(parse->rtable);
childRTindex = list_length(parse->rtable);
inhRTIs = lappendi(inhRTIs, childRTindex);
inhRTIs = lappend_int(inhRTIs, childRTindex);
}
return inhRTIs;

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

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/optimizer/util/clauses.c,v 1.171 2004/05/26 04:41:27 neilc Exp $
* $PostgreSQL: pgsql/src/backend/optimizer/util/clauses.c,v 1.172 2004/05/30 23:40:30 neilc Exp $
*
* HISTORY
* AUTHOR DATE MAJOR EVENT
@ -96,9 +96,9 @@ make_opclause(Oid opno, Oid opresulttype, bool opretset,
expr->opresulttype = opresulttype;
expr->opretset = opretset;
if (rightop)
expr->args = makeList2(leftop, rightop);
expr->args = list_make2(leftop, rightop);
else
expr->args = makeList1(leftop);
expr->args = list_make1(leftop);
return (Expr *) expr;
}
@ -164,7 +164,7 @@ make_notclause(Expr *notclause)
BoolExpr *expr = makeNode(BoolExpr);
expr->boolop = NOT_EXPR;
expr->args = makeList1(notclause);
expr->args = list_make1(notclause);
return (Expr *) expr;
}
@ -261,7 +261,7 @@ make_and_qual(Node *qual1, Node *qual2)
return qual2;
if (qual2 == NULL)
return qual1;
return (Node *) make_andclause(makeList2(qual1, qual2));
return (Node *) make_andclause(list_make2(qual1, qual2));
}
/*
@ -278,7 +278,7 @@ make_ands_explicit(List *andclauses)
{
if (andclauses == NIL)
return (Expr *) makeBoolConst(true, false);
else if (length(andclauses) == 1)
else if (list_length(andclauses) == 1)
return (Expr *) linitial(andclauses);
else
return make_andclause(andclauses);
@ -302,7 +302,7 @@ make_ands_implicit(Expr *clause)
DatumGetBool(((Const *) clause)->constvalue))
return NIL; /* constant TRUE input -> NIL list */
else
return makeList1(clause);
return list_make1(clause);
}
@ -599,7 +599,7 @@ contain_mutable_functions_walker(Node *node, void *context)
foreach(opid, sublink->operOids)
{
if (op_volatile(lfirsto(opid)) != PROVOLATILE_IMMUTABLE)
if (op_volatile(lfirst_oid(opid)) != PROVOLATILE_IMMUTABLE)
return true;
}
/* else fall through to check args */
@ -682,7 +682,7 @@ contain_volatile_functions_walker(Node *node, void *context)
foreach(opid, sublink->operOids)
{
if (op_volatile(lfirsto(opid)) == PROVOLATILE_VOLATILE)
if (op_volatile(lfirst_oid(opid)) == PROVOLATILE_VOLATILE)
return true;
}
/* else fall through to check args */
@ -982,7 +982,7 @@ CommuteClause(OpExpr *clause)
/* Sanity checks: caller is at fault if these fail */
if (!is_opclause(clause) ||
length(clause->args) != 2)
list_length(clause->args) != 2)
elog(ERROR, "cannot commute non-binary-operator clause");
opoid = get_commutator(clause->opno);
@ -1281,7 +1281,7 @@ eval_const_expressions_mutator(Node *node, List *active_fns)
if (newargs == NIL)
return makeBoolConst(false, false);
/* If only one nonconst-or-NULL input, it's the result */
if (length(newargs) == 1)
if (list_length(newargs) == 1)
return (Node *) linitial(newargs);
/* Else we still need an OR node */
return (Node *) make_orclause(newargs);
@ -1302,13 +1302,13 @@ eval_const_expressions_mutator(Node *node, List *active_fns)
if (newargs == NIL)
return makeBoolConst(true, false);
/* If only one nonconst-or-NULL input, it's the result */
if (length(newargs) == 1)
if (list_length(newargs) == 1)
return (Node *) linitial(newargs);
/* Else we still need an AND node */
return (Node *) make_andclause(newargs);
}
case NOT_EXPR:
Assert(length(args) == 1);
Assert(list_length(args) == 1);
if (IsA(linitial(args), Const))
{
Const *const_input = (Const *) linitial(args);
@ -1570,8 +1570,8 @@ eval_const_expressions_mutator(Node *node, List *active_fns)
RowExpr *rowexpr = (RowExpr *) arg;
if (fselect->fieldnum > 0 &&
fselect->fieldnum <= length(rowexpr->args))
return (Node *) nth(fselect->fieldnum - 1, rowexpr->args);
fselect->fieldnum <= list_length(rowexpr->args))
return (Node *) list_nth(rowexpr->args, fselect->fieldnum - 1);
}
newfselect = makeNode(FieldSelect);
newfselect->arg = (Expr *) arg;
@ -1640,9 +1640,9 @@ simplify_or_arguments(List *args, bool *haveNull, bool *forceTrue)
}
else if (or_clause(arg))
{
newargs = nconc(newargs,
simplify_or_arguments(((BoolExpr *) arg)->args,
haveNull, forceTrue));
newargs = list_concat(newargs,
simplify_or_arguments(((BoolExpr *) arg)->args,
haveNull, forceTrue));
}
else
{
@ -1701,9 +1701,9 @@ simplify_and_arguments(List *args, bool *haveNull, bool *forceFalse)
}
else if (and_clause(arg))
{
newargs = nconc(newargs,
simplify_and_arguments(((BoolExpr *) arg)->args,
haveNull, forceFalse));
newargs = list_concat(newargs,
simplify_and_arguments(((BoolExpr *) arg)->args,
haveNull, forceFalse));
}
else
{
@ -1880,11 +1880,11 @@ inline_function(Oid funcid, Oid result_type, List *args,
if (funcform->prolang != SQLlanguageId ||
funcform->prosecdef ||
funcform->proretset ||
funcform->pronargs != length(args))
funcform->pronargs != list_length(args))
return NULL;
/* Check for recursive function, and give up trying to expand if so */
if (oidMember(funcid, active_fns))
if (list_member_oid(active_fns, funcid))
return NULL;
/* Check permission to call function (fail later, if not) */
@ -1899,7 +1899,7 @@ inline_function(Oid funcid, Oid result_type, List *args,
argtypes[i] == ANYELEMENTOID)
{
polymorphic = true;
argtypes[i] = exprType((Node *) nth(i, args));
argtypes[i] = exprType((Node *) list_nth(args, i));
}
}
@ -1943,13 +1943,13 @@ inline_function(Oid funcid, Oid result_type, List *args,
* more than one command in the function body.
*/
raw_parsetree_list = pg_parse_query(src);
if (length(raw_parsetree_list) != 1)
if (list_length(raw_parsetree_list) != 1)
goto fail;
querytree_list = parse_analyze(linitial(raw_parsetree_list),
argtypes, funcform->pronargs);
if (length(querytree_list) != 1)
if (list_length(querytree_list) != 1)
goto fail;
querytree = (Query *) linitial(querytree_list);
@ -1973,7 +1973,7 @@ inline_function(Oid funcid, Oid result_type, List *args,
querytree->limitOffset ||
querytree->limitCount ||
querytree->setOperations ||
length(querytree->targetList) != 1)
list_length(querytree->targetList) != 1)
goto fail;
newexpr = (Node *) ((TargetEntry *) linitial(querytree->targetList))->expr;
@ -2048,7 +2048,7 @@ inline_function(Oid funcid, Oid result_type, List *args,
*/
if (contain_subplans(param))
goto fail;
cost_qual_eval(&eval_cost, makeList1(param));
cost_qual_eval(&eval_cost, list_make1(param));
if (eval_cost.startup + eval_cost.per_tuple >
10 * cpu_operator_cost)
goto fail;
@ -2078,7 +2078,7 @@ inline_function(Oid funcid, Oid result_type, List *args,
* add the current function to the context list of active functions.
*/
newexpr = eval_const_expressions_mutator(newexpr,
lconso(funcid, active_fns));
lcons_oid(funcid, active_fns));
error_context_stack = sqlerrcontext.previous;
@ -2129,7 +2129,7 @@ substitute_actual_parameters_mutator(Node *node,
/* Select the appropriate actual arg and replace the Param with it */
/* We don't need to copy at this time (it'll get done later) */
return nth(param->paramid - 1, context->args);
return list_nth(context->args, param->paramid - 1);
}
return expression_tree_mutator(node, substitute_actual_parameters_mutator,
(void *) context);

8
src/backend/optimizer/util/joininfo.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/optimizer/util/joininfo.c,v 1.38 2004/05/26 04:41:27 neilc Exp $
* $PostgreSQL: pgsql/src/backend/optimizer/util/joininfo.c,v 1.39 2004/05/30 23:40:31 neilc Exp $
*
*-------------------------------------------------------------------------
*/
@ -162,9 +162,9 @@ remove_join_clause_from_rels(Query *root,
* Remove the restrictinfo from the list. Pointer comparison is
* sufficient.
*/
Assert(ptrMember(restrictinfo, joininfo->jinfo_restrictinfo));
joininfo->jinfo_restrictinfo = lremove(restrictinfo,
joininfo->jinfo_restrictinfo);
Assert(list_member_ptr(joininfo->jinfo_restrictinfo, restrictinfo));
joininfo->jinfo_restrictinfo = list_delete_ptr(joininfo->jinfo_restrictinfo,
restrictinfo);
bms_free(unjoined_relids);
}
bms_free(tmprelids);

12
src/backend/optimizer/util/pathnode.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/optimizer/util/pathnode.c,v 1.105 2004/05/26 04:41:27 neilc Exp $
* $PostgreSQL: pgsql/src/backend/optimizer/util/pathnode.c,v 1.106 2004/05/30 23:40:31 neilc Exp $
*
*-------------------------------------------------------------------------
*/
@ -452,9 +452,9 @@ create_index_path(Query *root,
* We are making a pathnode for a single-scan indexscan; therefore,
* indexinfo etc should be single-element lists.
*/
pathnode->indexinfo = makeList1(index);
pathnode->indexclauses = makeList1(restriction_clauses);
pathnode->indexquals = makeList1(indexquals);
pathnode->indexinfo = list_make1(index);
pathnode->indexclauses = list_make1(restriction_clauses);
pathnode->indexquals = list_make1(indexquals);
/* It's not an innerjoin path. */
pathnode->isjoininner = false;
@ -686,12 +686,12 @@ create_unique_path(Query *root, RelOptInfo *rel, Path *subpath)
if (sub_targetlist)
{
pathnode->rows = estimate_num_groups(root, sub_targetlist, rel->rows);
numCols = length(sub_targetlist);
numCols = list_length(sub_targetlist);
}
else
{
pathnode->rows = rel->rows;
numCols = length(FastListValue(&rel->reltargetlist));
numCols = list_length(FastListValue(&rel->reltargetlist));
}
/*

8
src/backend/optimizer/util/plancat.c
View File

@ -9,7 +9,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/optimizer/util/plancat.c,v 1.92 2004/05/26 04:41:27 neilc Exp $
* $PostgreSQL: pgsql/src/backend/optimizer/util/plancat.c,v 1.93 2004/05/30 23:40:31 neilc Exp $
*
*-------------------------------------------------------------------------
*/
@ -82,7 +82,7 @@ get_relation_info(Oid relationObjectId, RelOptInfo *rel)
foreach(l, indexoidlist)
{
Oid indexoid = lfirsto(l);
Oid indexoid = lfirst_oid(l);
Relation indexRelation;
Form_pg_index index;
IndexOptInfo *info;
@ -158,7 +158,7 @@ get_relation_info(Oid relationObjectId, RelOptInfo *rel)
indexinfos = lcons(info, indexinfos);
}
freeList(indexoidlist);
list_free(indexoidlist);
}
rel->indexlist = indexinfos;
@ -338,7 +338,7 @@ find_inheritance_children(Oid inhparent)
while ((inheritsTuple = heap_getnext(scan, ForwardScanDirection)) != NULL)
{
inhrelid = ((Form_pg_inherits) GETSTRUCT(inheritsTuple))->inhrelid;
list = lappendo(list, inhrelid);
list = lappend_oid(list, inhrelid);
}
heap_endscan(scan);
heap_close(relation, AccessShareLock);

22
src/backend/optimizer/util/relnode.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/optimizer/util/relnode.c,v 1.57 2004/05/26 04:41:27 neilc Exp $
* $PostgreSQL: pgsql/src/backend/optimizer/util/relnode.c,v 1.58 2004/05/30 23:40:31 neilc Exp $
*
*-------------------------------------------------------------------------
*/
@ -162,7 +162,7 @@ make_base_rel(Query *root, int relid)
/* Subquery or function --- need only set up attr range */
/* Note: 0 is included in range to support whole-row Vars */
rel->min_attr = 0;
rel->max_attr = length(rte->eref->colnames);
rel->max_attr = list_length(rte->eref->colnames);
break;
default:
elog(ERROR, "unrecognized RTE kind: %d",
@ -446,10 +446,10 @@ build_joinrel_restrictlist(Query *root,
/*
* Collect all the clauses that syntactically belong at this level.
*/
rlist = nconc(subbuild_joinrel_restrictlist(joinrel,
outer_rel->joininfo),
subbuild_joinrel_restrictlist(joinrel,
inner_rel->joininfo));
rlist = list_concat(subbuild_joinrel_restrictlist(joinrel,
outer_rel->joininfo),
subbuild_joinrel_restrictlist(joinrel,
inner_rel->joininfo));
/*
* Eliminate duplicate and redundant clauses.
@ -462,7 +462,7 @@ build_joinrel_restrictlist(Query *root,
*/
result = remove_redundant_join_clauses(root, rlist, jointype);
freeList(rlist);
list_free(rlist);
return result;
}
@ -496,8 +496,8 @@ subbuild_joinrel_restrictlist(RelOptInfo *joinrel,
* We must copy the list to avoid disturbing the input relation,
* but we can use a shallow copy.
*/
restrictlist = nconc(restrictlist,
listCopy(joininfo->jinfo_restrictinfo));
restrictlist = list_concat(restrictlist,
list_copy(joininfo->jinfo_restrictinfo));
}
else
{
@ -549,8 +549,8 @@ subbuild_joinrel_joinlist(RelOptInfo *joinrel,
new_joininfo = make_joininfo_node(joinrel, new_unjoined_relids);
new_joininfo->jinfo_restrictinfo =
set_ptrUnion(new_joininfo->jinfo_restrictinfo,
joininfo->jinfo_restrictinfo);
list_union_ptr(new_joininfo->jinfo_restrictinfo,
joininfo->jinfo_restrictinfo);
}
}
}

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

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/optimizer/util/restrictinfo.c,v 1.27 2004/05/26 04:41:27 neilc Exp $
* $PostgreSQL: pgsql/src/backend/optimizer/util/restrictinfo.c,v 1.28 2004/05/30 23:40:31 neilc Exp $
*
*-------------------------------------------------------------------------
*/
@ -99,7 +99,7 @@ make_restrictinfo_from_indexclauses(List *indexclauses,
if (indexclauses == NIL)
return NIL;
/* If single indexscan, just return the ANDed clauses */
if (length(indexclauses) == 1)
if (list_length(indexclauses) == 1)
return (List *) linitial(indexclauses);
/* Else we need an OR RestrictInfo structure */
foreach(orlist, indexclauses)
@ -112,7 +112,7 @@ make_restrictinfo_from_indexclauses(List *indexclauses,
andlist = get_actual_clauses(andlist);
withoutris = lappend(withoutris, make_ands_explicit(andlist));
}
return makeList1(make_restrictinfo_internal(make_orclause(withoutris),
return list_make1(make_restrictinfo_internal(make_orclause(withoutris),
make_orclause(withris),
is_pushed_down,
valid_everywhere));
@ -139,7 +139,7 @@ make_restrictinfo_internal(Expr *clause, Expr *orclause,
* If it's a binary opclause, set up left/right relids info.
* In any case set up the total clause relids info.
*/
if (is_opclause(clause) && length(((OpExpr *) clause)->args) == 2)
if (is_opclause(clause) && list_length(((OpExpr *) clause)->args) == 2)
{
restrictinfo->left_relids = pull_varnos(get_leftop(clause));
restrictinfo->right_relids = pull_varnos(get_rightop(clause));
@ -350,7 +350,7 @@ remove_redundant_join_clauses(Query *root, List *restrictinfo_list,
else if (CLAUSECOST(rinfo) < CLAUSECOST(prevrinfo))
{
/* keep this one, drop the previous one */
result = lremove(prevrinfo, result);
result = list_delete_ptr(result, prevrinfo);
result = lappend(result, rinfo);
}
/* else, drop this one */

6
src/backend/optimizer/util/tlist.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/optimizer/util/tlist.c,v 1.63 2004/05/26 04:41:27 neilc Exp $
* $PostgreSQL: pgsql/src/backend/optimizer/util/tlist.c,v 1.64 2004/05/30 23:40:31 neilc Exp $
*
*-------------------------------------------------------------------------
*/
@ -121,7 +121,7 @@ flatten_tlist(List *tlist)
List *new_tlist;
new_tlist = add_to_flat_tlist(NIL, vlist);
freeList(vlist);
list_free(vlist);
return new_tlist;
}
@ -137,7 +137,7 @@ flatten_tlist(List *tlist)
List *
add_to_flat_tlist(List *tlist, List *vars)
{
int next_resdomno = length(tlist) + 1;
int next_resdomno = list_length(tlist) + 1;
ListCell *v;
foreach(v, vars)

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

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/optimizer/util/var.c,v 1.57 2004/05/26 04:41:27 neilc Exp $
* $PostgreSQL: pgsql/src/backend/optimizer/util/var.c,v 1.58 2004/05/30 23:40:31 neilc Exp $
*
*-------------------------------------------------------------------------
*/
@ -543,7 +543,7 @@ flatten_join_alias_vars_mutator(Node *node,
/* Expand join alias reference */
Assert(var->varattno > 0);
newvar = (Node *) nth(var->varattno - 1, rte->joinaliasvars);
newvar = (Node *) list_nth(rte->joinaliasvars, var->varattno - 1);
/*
* If we are expanding an alias carried down from an upper query,

100
src/backend/parser/analyze.c
View File

@ -6,7 +6,7 @@
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $PostgreSQL: pgsql/src/backend/parser/analyze.c,v 1.301 2004/05/26 04:41:29 neilc Exp $
* $PostgreSQL: pgsql/src/backend/parser/analyze.c,v 1.302 2004/05/30 23:40:32 neilc Exp $
*
*-------------------------------------------------------------------------
*/
@ -248,12 +248,12 @@ do_parse_analyze(Node *parseTree, ParseState *pstate)
release_pstate_resources(pstate);
foreach(l, extras_before)
result = nconc(result, parse_sub_analyze(lfirst(l), pstate));
result = list_concat(result, parse_sub_analyze(lfirst(l), pstate));
result = lappend(result, query);
foreach(l, extras_after)
result = nconc(result, parse_sub_analyze(lfirst(l), pstate));
result = list_concat(result, parse_sub_analyze(lfirst(l), pstate));
/*
* Make sure that only the original query is marked original. We have
@ -592,7 +592,7 @@ transformInsertStmt(ParseState *pstate, InsertStmt *stmt,
true);
rtr = makeNode(RangeTblRef);
/* assume new rte is at end */
rtr->rtindex = length(pstate->p_rtable);
rtr->rtindex = list_length(pstate->p_rtable);
Assert(rte == rt_fetch(rtr->rtindex, pstate->p_rtable));
pstate->p_joinlist = lappend(pstate->p_joinlist, rtr);
@ -674,7 +674,7 @@ transformInsertStmt(ParseState *pstate, InsertStmt *stmt,
Assert(IsA(col, ResTarget));
Assert(!tle->resdom->resjunk);
updateTargetListEntry(pstate, tle, col->name, lfirsti(attnos),
updateTargetListEntry(pstate, tle, col->name, lfirst_int(attnos),
col->indirection);
icols = lnext(icols);
@ -874,8 +874,8 @@ transformCreateStmt(ParseState *pstate, CreateStmt *stmt,
q->utilityStmt = (Node *) stmt;
stmt->tableElts = cxt.columns;
stmt->constraints = cxt.ckconstraints;
*extras_before = nconc(*extras_before, cxt.blist);
*extras_after = nconc(cxt.alist, *extras_after);
*extras_before = list_concat(*extras_before, cxt.blist);
*extras_after = list_concat(cxt.alist, *extras_after);
return q;
}
@ -893,7 +893,7 @@ transformColumnDefinition(ParseState *pstate, CreateStmtContext *cxt,
/* Check for SERIAL pseudo-types */
is_serial = false;
if (length(column->typename->names) == 1)
if (list_length(column->typename->names) == 1)
{
char *typname = strVal(linitial(column->typename->names));
@ -969,7 +969,7 @@ transformColumnDefinition(ParseState *pstate, CreateStmtContext *cxt,
snamenode->val.val.str = qstring;
funccallnode = makeNode(FuncCall);
funccallnode->funcname = SystemFuncName("nextval");
funccallnode->args = makeList1(snamenode);
funccallnode->args = list_make1(snamenode);
funccallnode->agg_star = false;
funccallnode->agg_distinct = false;
@ -1004,7 +1004,7 @@ transformColumnDefinition(ParseState *pstate, CreateStmtContext *cxt,
{
FkConstraint *fkconstraint = (FkConstraint *) constraint;
fkconstraint->fk_attrs = makeList1(makeString(column->colname));
fkconstraint->fk_attrs = list_make1(makeString(column->colname));
cxt->fkconstraints = lappend(cxt->fkconstraints, fkconstraint);
continue;
}
@ -1049,7 +1049,7 @@ transformColumnDefinition(ParseState *pstate, CreateStmtContext *cxt,
NULL,
"pkey");
if (constraint->keys == NIL)
constraint->keys = makeList1(makeString(column->colname));
constraint->keys = list_make1(makeString(column->colname));
cxt->ixconstraints = lappend(cxt->ixconstraints, constraint);
break;
@ -1059,7 +1059,7 @@ transformColumnDefinition(ParseState *pstate, CreateStmtContext *cxt,
column->colname,
"key");
if (constraint->keys == NIL)
constraint->keys = makeList1(makeString(column->colname));
constraint->keys = list_make1(makeString(column->colname));
cxt->ixconstraints = lappend(cxt->ixconstraints, constraint);
break;
@ -1437,7 +1437,7 @@ transformIndexConstraints(ParseState *pstate, CreateStmtContext *cxt)
if (cxt->pkey != NULL)
{
/* Make sure we keep the PKEY index in preference to others... */
cxt->alist = makeList1(cxt->pkey);
cxt->alist = list_make1(cxt->pkey);
}
foreach(l, indexlist)
@ -1679,7 +1679,7 @@ transformRuleStmt(ParseState *pstate, RuleStmt *stmt,
stmt->whereClause = transformWhereClause(pstate, stmt->whereClause,
"WHERE");
if (length(pstate->p_rtable) != 2) /* naughty, naughty... */
if (list_length(pstate->p_rtable) != 2) /* naughty, naughty... */
ereport(ERROR,
(errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
errmsg("rule WHERE condition may not contain references to other relations")));
@ -1708,7 +1708,7 @@ transformRuleStmt(ParseState *pstate, RuleStmt *stmt,
nothing_qry->rtable = pstate->p_rtable;
nothing_qry->jointree = makeFromExpr(NIL, NULL); /* no join wanted */
stmt->actions = makeList1(nothing_qry);
stmt->actions = list_make1(nothing_qry);
}
else
{
@ -2062,7 +2062,7 @@ transformSetOperationStmt(ParseState *pstate, SelectStmt *stmt)
foreach(dtlist, sostmt->colTypes)
{
Oid colType = lfirsto(dtlist);
Oid colType = lfirst_oid(dtlist);
Resdom *leftResdom;
char *colName;
Resdom *resdom;
@ -2123,10 +2123,10 @@ transformSetOperationStmt(ParseState *pstate, SelectStmt *stmt)
jrtr->rtindex = 1; /* only entry in dummy rtable */
sv_rtable = pstate->p_rtable;
pstate->p_rtable = makeList1(jrte);
pstate->p_rtable = list_make1(jrte);
sv_namespace = pstate->p_namespace;
pstate->p_namespace = makeList1(jrtr);
pstate->p_namespace = list_make1(jrtr);
/*
* For now, we don't support resjunk sort clauses on the output of a
@ -2134,7 +2134,7 @@ transformSetOperationStmt(ParseState *pstate, SelectStmt *stmt)
* selecting an output column by name or number. Enforce by checking
* that transformSortClause doesn't add any items to tlist.
*/
tllen = length(qry->targetList);
tllen = list_length(qry->targetList);
qry->sortClause = transformSortClause(pstate,
sortClause,
@ -2144,7 +2144,7 @@ transformSetOperationStmt(ParseState *pstate, SelectStmt *stmt)
pstate->p_namespace = sv_namespace;
pstate->p_rtable = sv_rtable;
if (tllen != length(qry->targetList))
if (tllen != list_length(qry->targetList))
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("ORDER BY on a UNION/INTERSECT/EXCEPT result must be on one of the result columns")));
@ -2231,7 +2231,7 @@ transformSetOperationTree(ParseState *pstate, SelectStmt *stmt)
*/
selectList = parse_sub_analyze((Node *) stmt, pstate);
Assert(length(selectList) == 1);
Assert(list_length(selectList) == 1);
selectQuery = (Query *) linitial(selectList);
Assert(IsA(selectQuery, Query));
@ -2253,7 +2253,7 @@ transformSetOperationTree(ParseState *pstate, SelectStmt *stmt)
* Make the leaf query be a subquery in the top-level rangetable.
*/
snprintf(selectName, sizeof(selectName), "*SELECT* %d",
length(pstate->p_rtable) + 1);
list_length(pstate->p_rtable) + 1);
rte = addRangeTableEntryForSubquery(pstate,
selectQuery,
makeAlias(selectName, NIL),
@ -2265,7 +2265,7 @@ transformSetOperationTree(ParseState *pstate, SelectStmt *stmt)
*/
rtr = makeNode(RangeTblRef);
/* assume new rte is at end */
rtr->rtindex = length(pstate->p_rtable);
rtr->rtindex = list_length(pstate->p_rtable);
Assert(rte == rt_fetch(rtr->rtindex, pstate->p_rtable));
return (Node *) rtr;
}
@ -2298,7 +2298,7 @@ transformSetOperationTree(ParseState *pstate, SelectStmt *stmt)
*/
lcoltypes = getSetColTypes(pstate, op->larg);
rcoltypes = getSetColTypes(pstate, op->rarg);
if (length(lcoltypes) != length(rcoltypes))
if (list_length(lcoltypes) != list_length(rcoltypes))
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("each %s query must have the same number of columns",
@ -2307,13 +2307,13 @@ transformSetOperationTree(ParseState *pstate, SelectStmt *stmt)
op->colTypes = NIL;
forboth(l, lcoltypes, r, rcoltypes)
{
Oid lcoltype = lfirsto(l);
Oid rcoltype = lfirsto(r);
Oid lcoltype = lfirst_oid(l);
Oid rcoltype = lfirst_oid(r);
Oid rescoltype;
rescoltype = select_common_type(makeListo2(lcoltype, rcoltype),
rescoltype = select_common_type(list_make2_oid(lcoltype, rcoltype),
context);
op->colTypes = lappendo(op->colTypes, rescoltype);
op->colTypes = lappend_oid(op->colTypes, rescoltype);
}
return (Node *) op;
@ -2344,7 +2344,7 @@ getSetColTypes(ParseState *pstate, Node *node)
if (resnode->resjunk)
continue;
result = lappendo(result, resnode->restype);
result = lappend_oid(result, resnode->restype);
}
return result;
}
@ -2370,7 +2370,7 @@ applyColumnNames(List *dst, List *src)
ListCell *dst_item = list_head(dst);
ListCell *src_item = list_head(src);
if (length(src) > length(dst))
if (list_length(src) > list_length(dst))
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("CREATE TABLE AS specifies too many column names")));
@ -2632,8 +2632,8 @@ transformAlterTableStmt(ParseState *pstate, AlterTableStmt *stmt,
qry->commandType = CMD_UTILITY;
qry->utilityStmt = (Node *) stmt;
*extras_before = nconc(*extras_before, cxt.blist);
*extras_after = nconc(cxt.alist, *extras_after);
*extras_before = list_concat(*extras_before, cxt.blist);
*extras_after = list_concat(cxt.alist, *extras_after);
return qry;
}
@ -2681,7 +2681,7 @@ transformPrepareStmt(ParseState *pstate, PrepareStmt *stmt)
result->utilityStmt = (Node *) stmt;
/* Transform list of TypeNames to list (and array) of type OIDs */
nargs = length(stmt->argtypes);
nargs = list_length(stmt->argtypes);
if (nargs)
{
@ -2695,7 +2695,7 @@ transformPrepareStmt(ParseState *pstate, PrepareStmt *stmt)
TypeName *tn = lfirst(l);
Oid toid = typenameTypeId(tn);
argtype_oids = lappendo(argtype_oids, toid);
argtype_oids = lappend_oid(argtype_oids, toid);
argtoids[i++] = toid;
}
}
@ -2712,7 +2712,7 @@ transformPrepareStmt(ParseState *pstate, PrepareStmt *stmt)
* Shouldn't get any extra statements, since grammar only allows
* OptimizableStmt
*/
if (length(queries) != 1)
if (list_length(queries) != 1)
elog(ERROR, "unexpected extra stuff in prepared statement");
stmt->query = linitial(queries);
@ -2733,8 +2733,8 @@ transformExecuteStmt(ParseState *pstate, ExecuteStmt *stmt)
if (stmt->params || paramtypes)
{
int nparams = length(stmt->params);
int nexpected = length(paramtypes);
int nparams = list_length(stmt->params);
int nexpected = list_length(paramtypes);
ListCell *l, *l2;
int i = 1;
@ -2749,7 +2749,7 @@ transformExecuteStmt(ParseState *pstate, ExecuteStmt *stmt)
forboth(l, stmt->params, l2, paramtypes)
{
Node *expr = lfirst(l);
Oid expected_type_id = lfirsto(l2);
Oid expected_type_id = lfirst_oid(l2);
Oid given_type_id;
expr = transformExpr(pstate, expr);
@ -2838,8 +2838,8 @@ transformForUpdate(Query *qry, List *forUpdate)
switch (rte->rtekind)
{
case RTE_RELATION:
if (!intMember(i, rowMarks)) /* avoid duplicates */
rowMarks = lappendi(rowMarks, i);
if (!list_member_int(rowMarks, i)) /* avoid duplicates */
rowMarks = lappend_int(rowMarks, i);
rte->requiredPerms |= ACL_SELECT_FOR_UPDATE;
break;
case RTE_SUBQUERY:
@ -2847,7 +2847,7 @@ transformForUpdate(Query *qry, List *forUpdate)
* FOR UPDATE of subquery is propagated to subquery's
* rels
*/
transformForUpdate(rte->subquery, makeList1(NULL));
transformForUpdate(rte->subquery, list_make1(NULL));
break;
default:
/* ignore JOIN, SPECIAL, FUNCTION RTEs */
@ -2873,8 +2873,8 @@ transformForUpdate(Query *qry, List *forUpdate)
switch (rte->rtekind)
{
case RTE_RELATION:
if (!intMember(i, rowMarks)) /* avoid duplicates */
rowMarks = lappendi(rowMarks, i);
if (!list_member_int(rowMarks, i)) /* avoid duplicates */
rowMarks = lappend_int(rowMarks, i);
rte->requiredPerms |= ACL_SELECT_FOR_UPDATE;
break;
case RTE_SUBQUERY:
@ -2882,7 +2882,7 @@ transformForUpdate(Query *qry, List *forUpdate)
* FOR UPDATE of subquery is propagated to
* subquery's rels
*/
transformForUpdate(rte->subquery, makeList1(NULL));
transformForUpdate(rte->subquery, list_make1(NULL));
break;
case RTE_JOIN:
ereport(ERROR,
@ -3198,12 +3198,12 @@ analyzeCreateSchemaStmt(CreateSchemaStmt *stmt)
}
result = NIL;
result = nconc(result, cxt.sequences);
result = nconc(result, cxt.tables);
result = nconc(result, cxt.views);
result = nconc(result, cxt.indexes);
result = nconc(result, cxt.triggers);
result = nconc(result, cxt.grants);
result = list_concat(result, cxt.sequences);
result = list_concat(result, cxt.tables);
result = list_concat(result, cxt.views);
result = list_concat(result, cxt.indexes);
result = list_concat(result, cxt.triggers);
result = list_concat(result, cxt.grants);
return result;
}

252
src/backend/parser/gram.y
View File

@ -11,7 +11,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/parser/gram.y,v 2.457 2004/05/26 15:07:37 momjian Exp $
* $PostgreSQL: pgsql/src/backend/parser/gram.y,v 2.458 2004/05/30 23:40:34 neilc Exp $
*
* HISTORY
* AUTHOR DATE MAJOR EVENT
@ -480,7 +480,7 @@ stmtmulti: stmtmulti ';' stmt
}
| stmt
{ if ($1 != NULL)
$$ = makeList1($1);
$$ = list_make1($1);
else
$$ = NIL;
}
@ -693,7 +693,7 @@ OptUserElem:
;
user_list: user_list ',' UserId { $$ = lappend($1, makeString($3)); }
| UserId { $$ = makeList1(makeString($1)); }
| UserId { $$ = list_make1(makeString($1)); }
;
@ -878,7 +878,7 @@ set_rest: var_name TO var_list_or_default
VariableSetStmt *n = makeNode(VariableSetStmt);
n->name = "timezone";
if ($3 != NULL)
n->args = makeList1($3);
n->args = list_make1($3);
$$ = n;
}
| TRANSACTION transaction_mode_list
@ -900,14 +900,14 @@ set_rest: var_name TO var_list_or_default
VariableSetStmt *n = makeNode(VariableSetStmt);
n->name = "client_encoding";
if ($2 != NULL)
n->args = makeList1(makeStringConst($2, NULL));
n->args = list_make1(makeStringConst($2, NULL));
$$ = n;
}
| SESSION AUTHORIZATION ColId_or_Sconst
{
VariableSetStmt *n = makeNode(VariableSetStmt);
n->name = "session_authorization";
n->args = makeList1(makeStringConst($3, NULL));
n->args = list_make1(makeStringConst($3, NULL));
$$ = n;
}
| SESSION AUTHORIZATION DEFAULT
@ -937,7 +937,7 @@ var_list_or_default:
| DEFAULT { $$ = NIL; }
;
var_list: var_value { $$ = makeList1($1); }
var_list: var_value { $$ = list_make1($1); }
| var_list ',' var_value { $$ = lappend($1, $3); }
;
@ -1153,7 +1153,7 @@ AlterTableStmt:
;
alter_table_cmds:
alter_table_cmd { $$ = makeList1($1); }
alter_table_cmd { $$ = list_make1($1); }
| alter_table_cmds ',' alter_table_cmd { $$ = lappend($1, $3); }
;
@ -1348,7 +1348,7 @@ CopyStmt: COPY opt_binary qualified_name opt_column_list opt_oids
if ($8)
n->options = lappend(n->options, $8);
if ($10)
n->options = nconc(n->options, $10);
n->options = list_concat(n->options, $10);
$$ = (Node *)n;
}
;
@ -1479,7 +1479,7 @@ CreateStmt: CREATE OptTemp TABLE qualified_name '(' OptTableElementList ')'
$4->istemp = $2;
n->relation = $4;
n->tableElts = $8;
n->inhRelations = makeList1($6);
n->inhRelations = list_make1($6);
n->constraints = NIL;
n->hasoids = $10;
n->oncommit = $11;
@ -1511,7 +1511,7 @@ OptTableElementList:
TableElementList:
TableElement
{
$$ = makeList1($1);
$$ = list_make1($1);
}
| TableElementList ',' TableElement
{
@ -1814,7 +1814,7 @@ opt_column_list:
;
columnList:
columnElem { $$ = makeList1($1); }
columnElem { $$ = list_make1($1); }
| columnList ',' columnElem { $$ = lappend($1, $3); }
;
@ -1941,7 +1941,7 @@ OptCreateAs:
;
CreateAsList:
CreateAsElement { $$ = makeList1($1); }
CreateAsElement { $$ = list_make1($1); }
| CreateAsList ',' CreateAsElement { $$ = lappend($1, $3); }
;
@ -2099,7 +2099,7 @@ opt_trusted:
*/
handler_name:
name
{ $$ = makeList1(makeString($1)); }
{ $$ = list_make1(makeString($1)); }
| dotted_name { $$ = $1; }
;
@ -2236,7 +2236,7 @@ TriggerForType:
;
TriggerFuncArgs:
TriggerFuncArg { $$ = makeList1($1); }
TriggerFuncArg { $$ = list_make1($1); }
| TriggerFuncArgs ',' TriggerFuncArg { $$ = lappend($1, $3); }
| /*EMPTY*/ { $$ = NIL; }
;
@ -2328,7 +2328,7 @@ CreateAssertStmt:
{
CreateTrigStmt *n = makeNode(CreateTrigStmt);
n->trigname = $3;
n->args = makeList1($6);
n->args = list_make1($6);
n->isconstraint = TRUE;
n->deferrable = ($8 & 1) != 0;
n->initdeferred = ($8 & 2) != 0;
@ -2395,7 +2395,7 @@ DefineStmt:
RangeVar *r = makeNode(RangeVar);
/* can't use qualified_name, sigh */
switch (length($3))
switch (list_length($3))
{
case 1:
r->catalogname = NULL;
@ -2428,7 +2428,7 @@ DefineStmt:
definition: '(' def_list ')' { $$ = $2; }
;
def_list: def_elem { $$ = makeList1($1); }
def_list: def_elem { $$ = list_make1($1); }
| def_list ',' def_elem { $$ = lappend($1, $3); }
;
@ -2473,7 +2473,7 @@ CreateOpClassStmt:
;
opclass_item_list:
opclass_item { $$ = makeList1($1); }
opclass_item { $$ = list_make1($1); }
| opclass_item_list ',' opclass_item { $$ = lappend($1, $3); }
;
@ -2566,11 +2566,11 @@ drop_type: TABLE { $$ = OBJECT_TABLE; }
;
any_name_list:
any_name { $$ = makeList1($1); }
any_name { $$ = list_make1($1); }
| any_name_list ',' any_name { $$ = lappend($1, $3); }
;
any_name: ColId { $$ = makeList1(makeString($1)); }
any_name: ColId { $$ = list_make1(makeString($1)); }
| dotted_name { $$ = $1; }
;
@ -2623,7 +2623,7 @@ CommentStmt:
CommentStmt *n = makeNode(CommentStmt);
n->objtype = OBJECT_AGGREGATE;
n->objname = $4;
n->objargs = makeList1($6);
n->objargs = list_make1($6);
n->comment = $9;
$$ = (Node *) n;
}
@ -2669,7 +2669,7 @@ CommentStmt:
/* Obsolete syntax supported for awhile for compatibility */
CommentStmt *n = makeNode(CommentStmt);
n->objtype = OBJECT_RULE;
n->objname = makeList1(makeString($4));
n->objname = list_make1(makeString($4));
n->objargs = NIL;
n->comment = $6;
$$ = (Node *) n;
@ -2688,7 +2688,7 @@ CommentStmt:
CommentStmt *n = makeNode(CommentStmt);
n->objtype = OBJECT_OPCLASS;
n->objname = $5;
n->objargs = makeList1(makeString($7));
n->objargs = list_make1(makeString($7));
n->comment = $9;
$$ = (Node *) n;
}
@ -2696,7 +2696,7 @@ CommentStmt:
{
CommentStmt *n = makeNode(CommentStmt);
n->objtype = OBJECT_LARGEOBJECT;
n->objname = makeList1($5);
n->objname = list_make1($5);
n->objargs = NIL;
n->comment = $7;
$$ = (Node *) n;
@ -2705,8 +2705,8 @@ CommentStmt:
{
CommentStmt *n = makeNode(CommentStmt);
n->objtype = OBJECT_CAST;
n->objname = makeList1($5);
n->objargs = makeList1($7);
n->objname = list_make1($5);
n->objargs = list_make1($7);
n->comment = $10;
$$ = (Node *) n;
}
@ -2937,13 +2937,13 @@ RevokeStmt: REVOKE opt_revoke_grant_option privileges ON privilege_target
/* either ALL [PRIVILEGES] or a list of individual privileges */
privileges: privilege_list { $$ = $1; }
| ALL { $$ = makeListi1(ACL_ALL_RIGHTS); }
| ALL PRIVILEGES { $$ = makeListi1(ACL_ALL_RIGHTS); }
| ALL { $$ = list_make1_int(ACL_ALL_RIGHTS); }
| ALL PRIVILEGES { $$ = list_make1_int(ACL_ALL_RIGHTS); }
;
privilege_list:
privilege { $$ = makeListi1($1); }
| privilege_list ',' privilege { $$ = lappendi($1, $3); }
privilege { $$ = list_make1_int($1); }
| privilege_list ',' privilege { $$ = lappend_int($1, $3); }
;
/* Not all of these privilege types apply to all objects, but that
@ -3013,7 +3013,7 @@ privilege_target:
grantee_list:
grantee { $$ = makeList1($1); }
grantee { $$ = list_make1($1); }
| grantee_list ',' grantee { $$ = lappend($1, $3); }
;
@ -3054,7 +3054,7 @@ opt_revoke_grant_option:
function_with_argtypes_list:
function_with_argtypes { $$ = makeList1($1); }
function_with_argtypes { $$ = list_make1($1); }
| function_with_argtypes_list ',' function_with_argtypes
{ $$ = lappend($1, $3); }
;
@ -3103,7 +3103,7 @@ access_method_clause:
| /*EMPTY*/ { $$ = DEFAULT_INDEX_TYPE; }
;
index_params: index_elem { $$ = makeList1($1); }
index_params: index_elem { $$ = list_make1($1); }
| index_params ',' index_elem { $$ = lappend($1, $3); }
;
@ -3182,7 +3182,7 @@ func_args: '(' func_args_list ')' { $$ = $2; }
;
func_args_list:
func_arg { $$ = makeList1($1); }
func_arg { $$ = list_make1($1); }
| func_args_list ',' func_arg { $$ = lappend($1, $3); }
;
@ -3259,7 +3259,7 @@ func_type: Typename { $$ = $1; }
createfunc_opt_list:
/* Must be at least one to prevent conflict */
createfunc_opt_item { $$ = makeList1($1); }
createfunc_opt_item { $$ = list_make1($1); }
| createfunc_opt_list createfunc_opt_item { $$ = lappend($1, $2); }
;
@ -3314,10 +3314,10 @@ createfunc_opt_item:
}
;
func_as: Sconst { $$ = makeList1(makeString($1)); }
func_as: Sconst { $$ = list_make1(makeString($1)); }
| Sconst ',' Sconst
{
$$ = makeList2(makeString($1), makeString($3));
$$ = list_make2(makeString($1), makeString($3));
}
;
@ -3384,16 +3384,16 @@ oper_argtypes:
errhint("Use NONE to denote the missing argument of a unary operator.")));
}
| Typename ',' Typename
{ $$ = makeList2($1, $3); }
{ $$ = list_make2($1, $3); }
| NONE ',' Typename /* left unary */
{ $$ = makeList2(NULL, $3); }
{ $$ = list_make2(NULL, $3); }
| Typename ',' NONE /* right unary */
{ $$ = makeList2($1, NULL); }
{ $$ = list_make2($1, NULL); }
;
any_operator:
all_Op
{ $$ = makeList1(makeString($1)); }
{ $$ = list_make1(makeString($1)); }
| ColId '.' any_operator
{ $$ = lcons(makeString($1), $3); }
;
@ -3495,7 +3495,7 @@ RenameStmt: ALTER AGGREGATE func_name '(' aggr_argtype ')' RENAME TO name
RenameStmt *n = makeNode(RenameStmt);
n->renameType = OBJECT_AGGREGATE;
n->object = $3;
n->objarg = makeList1($5);
n->objarg = list_make1($5);
n->newname = $9;
$$ = (Node *)n;
}
@ -3625,7 +3625,7 @@ RuleStmt: CREATE opt_or_replace RULE name AS
RuleActionList:
NOTHING { $$ = NIL; }
| RuleActionStmt { $$ = makeList1($1); }
| RuleActionStmt { $$ = list_make1($1); }
| '(' RuleActionMulti ')' { $$ = $2; }
;
@ -3639,7 +3639,7 @@ RuleActionMulti:
}
| RuleActionStmtOrEmpty
{ if ($1 != NULL)
$$ = makeList1($1);
$$ = list_make1($1);
else
$$ = NIL;
}
@ -3788,24 +3788,24 @@ opt_transaction: WORK {}
transaction_mode_list:
ISOLATION LEVEL iso_level
{ $$ = makeList1(makeDefElem("transaction_isolation",
makeStringConst($3, NULL))); }
{ $$ = list_make1(makeDefElem("transaction_isolation",
makeStringConst($3, NULL))); }
| transaction_access_mode
{ $$ = makeList1(makeDefElem("transaction_read_only",
makeIntConst($1))); }
{ $$ = list_make1(makeDefElem("transaction_read_only",
makeIntConst($1))); }
| ISOLATION LEVEL iso_level transaction_access_mode
{
$$ = makeList2(makeDefElem("transaction_isolation",
makeStringConst($3, NULL)),
makeDefElem("transaction_read_only",
makeIntConst($4)));
$$ = list_make2(makeDefElem("transaction_isolation",
makeStringConst($3, NULL)),
makeDefElem("transaction_read_only",
makeIntConst($4)));
}
| transaction_access_mode ISOLATION LEVEL iso_level
{
$$ = makeList2(makeDefElem("transaction_read_only",
makeIntConst($1)),
makeDefElem("transaction_isolation",
makeStringConst($4, NULL)));
$$ = list_make2(makeDefElem("transaction_read_only",
makeIntConst($1)),
makeDefElem("transaction_isolation",
makeStringConst($4, NULL)));
}
;
@ -4258,7 +4258,7 @@ prep_type_clause: '(' prep_type_list ')' { $$ = $2; }
| /* EMPTY */ { $$ = NIL; }
;
prep_type_list: Typename { $$ = makeList1($1); }
prep_type_list: Typename { $$ = list_make1($1); }
| prep_type_list ',' Typename
{ $$ = lappend($1, $3); }
;
@ -4380,7 +4380,7 @@ insert_rest:
;
insert_column_list:
insert_column_item { $$ = makeList1($1); }
insert_column_item { $$ = list_make1($1); }
| insert_column_list ',' insert_column_item
{ $$ = lappend($1, $3); }
;
@ -4566,13 +4566,13 @@ select_no_parens:
| select_clause opt_sort_clause for_update_clause opt_select_limit
{
insertSelectOptions((SelectStmt *) $1, $2, $3,
nth(0, $4), nth(1, $4));
list_nth($4, 0), list_nth($4, 1));
$$ = $1;
}
| select_clause opt_sort_clause select_limit opt_for_update_clause
{
insertSelectOptions((SelectStmt *) $1, $2, $4,
nth(0, $3), nth(1, $3));
list_nth($3, 0), list_nth($3, 1));
$$ = $1;
}
;
@ -4701,7 +4701,7 @@ opt_all: ALL { $$ = TRUE; }
* should be placed in the DISTINCT list during parsetree analysis.
*/
opt_distinct:
DISTINCT { $$ = makeList1(NIL); }
DISTINCT { $$ = list_make1(NIL); }
| DISTINCT ON '(' expr_list ')' { $$ = $4; }
| ALL { $$ = NIL; }
| /*EMPTY*/ { $$ = NIL; }
@ -4717,7 +4717,7 @@ sort_clause:
;
sortby_list:
sortby { $$ = makeList1($1); }
sortby { $$ = list_make1($1); }
| sortby_list ',' sortby { $$ = lappend($1, $3); }
;
@ -4754,13 +4754,13 @@ sortby: a_expr USING qual_all_Op
select_limit:
LIMIT select_limit_value OFFSET select_offset_value
{ $$ = makeList2($4, $2); }
{ $$ = list_make2($4, $2); }
| OFFSET select_offset_value LIMIT select_limit_value
{ $$ = makeList2($2, $4); }
{ $$ = list_make2($2, $4); }
| LIMIT select_limit_value
{ $$ = makeList2(NULL, $2); }
{ $$ = list_make2(NULL, $2); }
| OFFSET select_offset_value
{ $$ = makeList2($2, NULL); }
{ $$ = list_make2($2, NULL); }
| LIMIT select_limit_value ',' select_offset_value
{
/* Disabled because it was too confusing, bjm 2002-02-18 */
@ -4774,7 +4774,7 @@ select_limit:
opt_select_limit:
select_limit { $$ = $1; }
| /* EMPTY */
{ $$ = makeList2(NULL,NULL); }
{ $$ = list_make2(NULL,NULL); }
;
select_limit_value:
@ -4822,7 +4822,7 @@ opt_for_update_clause:
update_list:
OF name_list { $$ = $2; }
| /* EMPTY */ { $$ = makeList1(NULL); }
| /* EMPTY */ { $$ = list_make1(NULL); }
;
/*****************************************************************************
@ -4839,7 +4839,7 @@ from_clause:
;
from_list:
table_ref { $$ = makeList1($1); }
table_ref { $$ = list_make1($1); }
| from_list ',' table_ref { $$ = lappend($1, $3); }
;
@ -5151,7 +5151,7 @@ where_clause:
TableFuncElementList:
TableFuncElement
{
$$ = makeList1($1);
$$ = list_make1($1);
}
| TableFuncElementList ',' TableFuncElement
{
@ -5195,13 +5195,13 @@ Typename: SimpleTypename opt_array_bounds
{
/* SQL99's redundant syntax */
$$ = $1;
$$->arrayBounds = makeList1(makeInteger($4));
$$->arrayBounds = list_make1(makeInteger($4));
}
| SETOF SimpleTypename ARRAY '[' Iconst ']'
{
/* SQL99's redundant syntax */
$$ = $2;
$$->arrayBounds = makeList1(makeInteger($5));
$$->arrayBounds = list_make1(makeInteger($5));
$$->setof = TRUE;
}
;
@ -5755,7 +5755,7 @@ a_expr: c_expr { $$ = $1; }
{
FuncCall *n = makeNode(FuncCall);
n->funcname = SystemFuncName("timezone");
n->args = makeList2($5, $1);
n->args = list_make2($5, $1);
n->agg_star = FALSE;
n->agg_distinct = FALSE;
$$ = (Node *) n;
@ -5820,7 +5820,7 @@ a_expr: c_expr { $$ = $1; }
{
FuncCall *n = makeNode(FuncCall);
n->funcname = SystemFuncName("like_escape");
n->args = makeList2($3, $5);
n->args = list_make2($3, $5);
n->agg_star = FALSE;
n->agg_distinct = FALSE;
$$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "~~", $1, (Node *) n);
@ -5831,7 +5831,7 @@ a_expr: c_expr { $$ = $1; }
{
FuncCall *n = makeNode(FuncCall);
n->funcname = SystemFuncName("like_escape");
n->args = makeList2($4, $6);
n->args = list_make2($4, $6);
n->agg_star = FALSE;
n->agg_distinct = FALSE;
$$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "!~~", $1, (Node *) n);
@ -5842,7 +5842,7 @@ a_expr: c_expr { $$ = $1; }
{
FuncCall *n = makeNode(FuncCall);
n->funcname = SystemFuncName("like_escape");
n->args = makeList2($3, $5);
n->args = list_make2($3, $5);
n->agg_star = FALSE;
n->agg_distinct = FALSE;
$$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "~~*", $1, (Node *) n);
@ -5853,7 +5853,7 @@ a_expr: c_expr { $$ = $1; }
{
FuncCall *n = makeNode(FuncCall);
n->funcname = SystemFuncName("like_escape");
n->args = makeList2($4, $6);
n->args = list_make2($4, $6);
n->agg_star = FALSE;
n->agg_distinct = FALSE;
$$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "!~~*", $1, (Node *) n);
@ -5865,7 +5865,7 @@ a_expr: c_expr { $$ = $1; }
FuncCall *n = makeNode(FuncCall);
c->val.type = T_Null;
n->funcname = SystemFuncName("similar_escape");
n->args = makeList2($4, (Node *) c);
n->args = list_make2($4, (Node *) c);
n->agg_star = FALSE;
n->agg_distinct = FALSE;
$$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "~", $1, (Node *) n);
@ -5874,7 +5874,7 @@ a_expr: c_expr { $$ = $1; }
{
FuncCall *n = makeNode(FuncCall);
n->funcname = SystemFuncName("similar_escape");
n->args = makeList2($4, $6);
n->args = list_make2($4, $6);
n->agg_star = FALSE;
n->agg_distinct = FALSE;
$$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "~", $1, (Node *) n);
@ -5885,7 +5885,7 @@ a_expr: c_expr { $$ = $1; }
FuncCall *n = makeNode(FuncCall);
c->val.type = T_Null;
n->funcname = SystemFuncName("similar_escape");
n->args = makeList2($5, (Node *) c);
n->args = list_make2($5, (Node *) c);
n->agg_star = FALSE;
n->agg_distinct = FALSE;
$$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "!~", $1, (Node *) n);
@ -5894,7 +5894,7 @@ a_expr: c_expr { $$ = $1; }
{
FuncCall *n = makeNode(FuncCall);
n->funcname = SystemFuncName("similar_escape");
n->args = makeList2($5, $7);
n->args = list_make2($5, $7);
n->agg_star = FALSE;
n->agg_distinct = FALSE;
$$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "!~", $1, (Node *) n);
@ -6037,8 +6037,8 @@ a_expr: c_expr { $$ = $1; }
if (IsA($1, RowExpr))
n->lefthand = ((RowExpr *) $1)->args;
else
n->lefthand = makeList1($1);
n->operName = makeList1(makeString("="));
n->lefthand = list_make1($1);
n->operName = list_make1(makeString("="));
$$ = (Node *)n;
}
else
@ -6068,8 +6068,8 @@ a_expr: c_expr { $$ = $1; }
if (IsA($1, RowExpr))
n->lefthand = ((RowExpr *) $1)->args;
else
n->lefthand = makeList1($1);
n->operName = makeList1(makeString("="));
n->lefthand = list_make1($1);
n->operName = list_make1(makeString("="));
/* Stick a NOT on top */
$$ = (Node *) makeA_Expr(AEXPR_NOT, NIL, NULL, (Node *) n);
}
@ -6096,7 +6096,7 @@ a_expr: c_expr { $$ = $1; }
if (IsA($1, RowExpr))
n->lefthand = ((RowExpr *) $1)->args;
else
n->lefthand = makeList1($1);
n->lefthand = list_make1($1);
n->operName = $2;
n->subselect = $4;
$$ = (Node *)n;
@ -6293,7 +6293,7 @@ c_expr: columnref { $$ = (Node *) $1; }
star->val.type = T_Integer;
star->val.val.ival = 1;
n->funcname = $1;
n->args = makeList1(star);
n->args = list_make1(star);
n->agg_star = TRUE;
n->agg_distinct = FALSE;
$$ = (Node *)n;
@ -6625,7 +6625,7 @@ c_expr: columnref { $$ = (Node *) $1; }
* at the moment they result in the same thing.
*/
n->funcname = SystemFuncName(((Value *)llast($5->names))->val.str);
n->args = makeList1($3);
n->args = list_make1($3);
$$ = (Node *)n;
}
| TRIM '(' BOTH trim_list ')'
@ -6676,7 +6676,7 @@ c_expr: columnref { $$ = (Node *) $1; }
c->val.val.str = NameListToQuotedString($5);
n->funcname = SystemFuncName("convert_using");
n->args = makeList2($3, c);
n->args = list_make2($3, c);
n->agg_star = FALSE;
n->agg_distinct = FALSE;
$$ = (Node *)n;
@ -6764,31 +6764,31 @@ MathOp: '+' { $$ = "+"; }
;
qual_Op: Op
{ $$ = makeList1(makeString($1)); }
{ $$ = list_make1(makeString($1)); }
| OPERATOR '(' any_operator ')'
{ $$ = $3; }
;
qual_all_Op:
all_Op
{ $$ = makeList1(makeString($1)); }
{ $$ = list_make1(makeString($1)); }
| OPERATOR '(' any_operator ')'
{ $$ = $3; }
;
subquery_Op:
all_Op
{ $$ = makeList1(makeString($1)); }
{ $$ = list_make1(makeString($1)); }
| OPERATOR '(' any_operator ')'
{ $$ = $3; }
| LIKE
{ $$ = makeList1(makeString("~~")); }
{ $$ = list_make1(makeString("~~")); }
| NOT LIKE
{ $$ = makeList1(makeString("!~~")); }
{ $$ = list_make1(makeString("!~~")); }
| ILIKE
{ $$ = makeList1(makeString("~~*")); }
{ $$ = list_make1(makeString("~~*")); }
| NOT ILIKE
{ $$ = makeList1(makeString("!~~*")); }
{ $$ = list_make1(makeString("!~~*")); }
/* cannot put SIMILAR TO here, because SIMILAR TO is a hack.
* the regular expression is preprocessed by a function (similar_escape),
* and the ~ operator for posix regular expressions is used.
@ -6838,7 +6838,7 @@ extract_list:
A_Const *n = makeNode(A_Const);
n->val.type = T_String;
n->val.val.str = $1;
$$ = makeList2((Node *) n, $3);
$$ = list_make2((Node *) n, $3);
}
| /*EMPTY*/ { $$ = NIL; }
;
@ -6849,12 +6849,12 @@ type_list: type_list ',' Typename
}
| Typename
{
$$ = makeList1($1);
$$ = list_make1($1);
}
;
array_expr_list: array_expr
{ $$ = makeList1($1); }
{ $$ = list_make1($1); }
| array_expr_list ',' array_expr
{ $$ = lappend($1, $3); }
;
@ -6896,11 +6896,11 @@ extract_arg:
overlay_list:
a_expr overlay_placing substr_from substr_for
{
$$ = makeList4($1, $2, $3, $4);
$$ = list_make4($1, $2, $3, $4);
}
| a_expr overlay_placing substr_from
{
$$ = makeList3($1, $2, $3);
$$ = list_make3($1, $2, $3);
}
;
@ -6912,7 +6912,7 @@ overlay_placing:
/* position_list uses b_expr not a_expr to avoid conflict with general IN */
position_list:
b_expr IN_P b_expr { $$ = makeList2($3, $1); }
b_expr IN_P b_expr { $$ = list_make2($3, $1); }
| /*EMPTY*/ { $$ = NIL; }
;
@ -6930,22 +6930,22 @@ position_list:
substr_list:
a_expr substr_from substr_for
{
$$ = makeList3($1, $2, $3);
$$ = list_make3($1, $2, $3);
}
| a_expr substr_for substr_from
{
$$ = makeList3($1, $3, $2);
$$ = list_make3($1, $3, $2);
}
| a_expr substr_from
{
$$ = makeList2($1, $2);
$$ = list_make2($1, $2);
}
| a_expr substr_for
{
A_Const *n = makeNode(A_Const);
n->val.type = T_Integer;
n->val.val.ival = 1;
$$ = makeList3($1, (Node *)n, $2);
$$ = list_make3($1, (Node *)n, $2);
}
| expr_list
{
@ -7019,7 +7019,7 @@ case_expr: CASE case_arg when_clause_list case_default END_P
when_clause_list:
/* There must be at least one */
when_clause { $$ = makeList1($1); }
when_clause { $$ = list_make1($1); }
| when_clause_list when_clause { $$ = lappend($1, $2); }
;
@ -7050,7 +7050,7 @@ case_arg: a_expr { $$ = $1; }
columnref: relation_name opt_indirection
{
$$ = makeNode(ColumnRef);
$$->fields = makeList1(makeString($1));
$$->fields = list_make1(makeString($1));
$$->indirection = $2;
}
| dotted_name opt_indirection
@ -7067,9 +7067,9 @@ dotted_name:
;
attrs: '.' attr_name
{ $$ = makeList1(makeString($2)); }
{ $$ = list_make1(makeString($2)); }
| '.' '*'
{ $$ = makeList1(makeString("*")); }
{ $$ = list_make1(makeString("*")); }
| '.' attr_name attrs
{ $$ = lcons(makeString($2), $3); }
;
@ -7084,7 +7084,7 @@ attrs: '.' attr_name
/* Target lists as found in SELECT ... and INSERT VALUES ( ... ) */
target_list:
target_el { $$ = makeList1($1); }
target_el { $$ = list_make1($1); }
| target_list ',' target_el { $$ = lappend($1, $3); }
;
@ -7106,7 +7106,7 @@ target_el: a_expr AS ColLabel
| '*'
{
ColumnRef *n = makeNode(ColumnRef);
n->fields = makeList1(makeString("*"));
n->fields = list_make1(makeString("*"));
n->indirection = NIL;
$$ = makeNode(ResTarget);
$$->name = NULL;
@ -7122,7 +7122,7 @@ target_el: a_expr AS ColLabel
}
*/
update_target_list:
update_target_el { $$ = makeList1($1); }
update_target_el { $$ = list_make1($1); }
| update_target_list ',' update_target_el { $$ = lappend($1,$3); }
;
@ -7145,7 +7145,7 @@ update_target_el:
;
insert_target_list:
insert_target_el { $$ = makeList1($1); }
insert_target_el { $$ = list_make1($1); }
| insert_target_list ',' insert_target_el { $$ = lappend($1, $3); }
;
@ -7173,7 +7173,7 @@ relation_name:
;
qualified_name_list:
qualified_name { $$ = makeList1($1); }
qualified_name { $$ = list_make1($1); }
| qualified_name_list ',' qualified_name { $$ = lappend($1, $3); }
;
@ -7188,7 +7188,7 @@ qualified_name:
| dotted_name
{
$$ = makeNode(RangeVar);
switch (length($1))
switch (list_length($1))
{
case 2:
$$->catalogname = NULL;
@ -7211,7 +7211,7 @@ qualified_name:
;
name_list: name
{ $$ = makeList1(makeString($1)); }
{ $$ = list_make1(makeString($1)); }
| name_list ',' name
{ $$ = lappend($1, makeString($3)); }
;
@ -7232,7 +7232,7 @@ index_name: ColId { $$ = $1; };
file_name: Sconst { $$ = $1; };
func_name: function_name
{ $$ = makeList1(makeString($1)); }
{ $$ = list_make1(makeString($1)); }
| dotted_name { $$ = $1; }
;
@ -7924,19 +7924,19 @@ makeOverlaps(List *largs, List *rargs)
{
FuncCall *n = makeNode(FuncCall);
n->funcname = SystemFuncName("overlaps");
if (length(largs) == 1)
if (list_length(largs) == 1)
largs = lappend(largs, largs);
else if (length(largs) != 2)
else if (list_length(largs) != 2)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("wrong number of parameters on left side of OVERLAPS expression")));
if (length(rargs) == 1)
if (list_length(rargs) == 1)
rargs = lappend(rargs, rargs);
else if (length(rargs) != 2)
else if (list_length(rargs) != 2)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("wrong number of parameters on right side of OVERLAPS expression")));
n->args = nconc(largs, rargs);
n->args = list_concat(largs, rargs);
n->agg_star = FALSE;
n->agg_distinct = FALSE;
return n;
@ -8041,7 +8041,7 @@ makeSetOp(SetOperation op, bool all, Node *larg, Node *rarg)
List *
SystemFuncName(char *name)
{
return makeList2(makeString("pg_catalog"), makeString(name));
return list_make2(makeString("pg_catalog"), makeString(name));
}
/* SystemTypeName()
@ -8054,7 +8054,7 @@ SystemTypeName(char *name)
{
TypeName *n = makeNode(TypeName);
n->names = makeList2(makeString("pg_catalog"), makeString(name));
n->names = list_make2(makeString("pg_catalog"), makeString(name));
n->typmod = -1;
return n;
}

10
src/backend/parser/parse_agg.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/parser/parse_agg.c,v 1.62 2004/05/26 04:41:29 neilc Exp $
* $PostgreSQL: pgsql/src/backend/parser/parse_agg.c,v 1.63 2004/05/30 23:40:34 neilc Exp $
*
*-------------------------------------------------------------------------
*/
@ -307,7 +307,7 @@ check_ungrouped_columns_walker(Node *node,
/* Found an ungrouped local variable; generate error message */
Assert(var->varno > 0 &&
(int) var->varno <= length(context->pstate->p_rtable));
(int) var->varno <= list_length(context->pstate->p_rtable));
rte = rt_fetch(var->varno, context->pstate->p_rtable);
attname = get_rte_attribute_name(rte, var->varattno);
if (context->sublevels_up == 0)
@ -394,10 +394,10 @@ build_aggregate_fnexprs(Oid agg_input_type,
arg1->paramid = -1;
arg1->paramtype = agg_input_type;
args = makeList2(arg0, arg1);
args = list_make2(arg0, arg1);
}
else
args = makeList1(arg0);
args = list_make1(arg0);
*transfnexpr = (Expr *) makeFuncExpr(transfn_oid,
agg_state_type,
@ -418,7 +418,7 @@ build_aggregate_fnexprs(Oid agg_input_type,
arg0->paramkind = PARAM_EXEC;
arg0->paramid = -1;
arg0->paramtype = agg_state_type;
args = makeList1(arg0);
args = list_make1(arg0);
*finalfnexpr = (Expr *) makeFuncExpr(finalfn_oid,
agg_result_type,

52
src/backend/parser/parse_clause.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/parser/parse_clause.c,v 1.130 2004/05/26 04:41:29 neilc Exp $
* $PostgreSQL: pgsql/src/backend/parser/parse_clause.c,v 1.131 2004/05/30 23:40:34 neilc Exp $
*
*-------------------------------------------------------------------------
*/
@ -148,7 +148,7 @@ setTargetTable(ParseState *pstate, RangeVar *relation,
pstate->p_target_rangetblentry = rte;
/* assume new rte is at end */
rtindex = length(pstate->p_rtable);
rtindex = list_length(pstate->p_rtable);
Assert(rte == rt_fetch(rtindex, pstate->p_rtable));
/*
@ -233,7 +233,7 @@ extractRemainingColumns(List *common_colnames,
List *new_colvars = NIL;
ListCell *lnames, *lvars;
Assert(length(src_colnames) == length(src_colvars));
Assert(list_length(src_colnames) == list_length(src_colvars));
forboth(lnames, src_colnames, lvars, src_colvars)
{
@ -336,7 +336,7 @@ transformJoinOnClause(ParseState *pstate, JoinExpr *j,
* to be added.
*/
save_namespace = pstate->p_namespace;
pstate->p_namespace = makeList2(j->larg, j->rarg);
pstate->p_namespace = list_make2(j->larg, j->rarg);
result = transformWhereClause(pstate, j->quals, "JOIN/ON");
@ -353,7 +353,7 @@ transformJoinOnClause(ParseState *pstate, JoinExpr *j,
clause_varnos = pull_varnos(result);
while ((varno = bms_first_member(clause_varnos)) >= 0)
{
if (!intMember(varno, containedRels))
if (!list_member_int(containedRels, varno))
{
ereport(ERROR,
(errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
@ -391,7 +391,7 @@ transformTableEntry(ParseState *pstate, RangeVar *r)
*/
rtr = makeNode(RangeTblRef);
/* assume new rte is at end */
rtr->rtindex = length(pstate->p_rtable);
rtr->rtindex = list_length(pstate->p_rtable);
Assert(rte == rt_fetch(rtr->rtindex, pstate->p_rtable));
return rtr;
@ -429,7 +429,7 @@ transformRangeSubselect(ParseState *pstate, RangeSubselect *r)
* are probably impossible given restrictions of the grammar, but
* check 'em anyway.
*/
if (length(parsetrees) != 1)
if (list_length(parsetrees) != 1)
elog(ERROR, "unexpected parse analysis result for subquery in FROM");
query = (Query *) linitial(parsetrees);
if (query == NULL || !IsA(query, Query))
@ -476,7 +476,7 @@ transformRangeSubselect(ParseState *pstate, RangeSubselect *r)
*/
rtr = makeNode(RangeTblRef);
/* assume new rte is at end */
rtr->rtindex = length(pstate->p_rtable);
rtr->rtindex = list_length(pstate->p_rtable);
Assert(rte == rt_fetch(rtr->rtindex, pstate->p_rtable));
return rtr;
@ -556,7 +556,7 @@ transformRangeFunction(ParseState *pstate, RangeFunction *r)
*/
rtr = makeNode(RangeTblRef);
/* assume new rte is at end */
rtr->rtindex = length(pstate->p_rtable);
rtr->rtindex = list_length(pstate->p_rtable);
Assert(rte == rt_fetch(rtr->rtindex, pstate->p_rtable));
return rtr;
@ -584,7 +584,7 @@ transformFromClauseItem(ParseState *pstate, Node *n, List **containedRels)
RangeTblRef *rtr;
rtr = transformTableEntry(pstate, (RangeVar *) n);
*containedRels = makeListi1(rtr->rtindex);
*containedRels = list_make1_int(rtr->rtindex);
return (Node *) rtr;
}
else if (IsA(n, RangeSubselect))
@ -593,7 +593,7 @@ transformFromClauseItem(ParseState *pstate, Node *n, List **containedRels)
RangeTblRef *rtr;
rtr = transformRangeSubselect(pstate, (RangeSubselect *) n);
*containedRels = makeListi1(rtr->rtindex);
*containedRels = list_make1_int(rtr->rtindex);
return (Node *) rtr;
}
else if (IsA(n, RangeFunction))
@ -602,7 +602,7 @@ transformFromClauseItem(ParseState *pstate, Node *n, List **containedRels)
RangeTblRef *rtr;
rtr = transformRangeFunction(pstate, (RangeFunction *) n);
*containedRels = makeListi1(rtr->rtindex);
*containedRels = list_make1_int(rtr->rtindex);
return (Node *) rtr;
}
else if (IsA(n, JoinExpr))
@ -632,7 +632,7 @@ transformFromClauseItem(ParseState *pstate, Node *n, List **containedRels)
* Generate combined list of relation indexes for possible use by
* transformJoinOnClause below.
*/
my_containedRels = nconc(l_containedRels, r_containedRels);
my_containedRels = list_concat(l_containedRels, r_containedRels);
/*
* Check for conflicting refnames in left and right subtrees. Must
@ -799,9 +799,9 @@ transformFromClauseItem(ParseState *pstate, Node *n, List **containedRels)
errmsg("column \"%s\" specified in USING clause does not exist in right table",
u_colname)));
l_colvar = nth(l_index, l_colvars);
l_colvar = list_nth(l_colvars, l_index);
l_usingvars = lappend(l_usingvars, l_colvar);
r_colvar = nth(r_index, r_colvars);
r_colvar = list_nth(r_colvars, r_index);
r_usingvars = lappend(r_usingvars, r_colvar);
res_colnames = lappend(res_colnames, lfirst(ucol));
@ -833,10 +833,10 @@ transformFromClauseItem(ParseState *pstate, Node *n, List **containedRels)
extractRemainingColumns(res_colnames,
r_colnames, r_colvars,
&r_colnames, &r_colvars);
res_colnames = nconc(res_colnames, l_colnames);
res_colvars = nconc(res_colvars, l_colvars);
res_colnames = nconc(res_colnames, r_colnames);
res_colvars = nconc(res_colvars, r_colvars);
res_colnames = list_concat(res_colnames, l_colnames);
res_colvars = list_concat(res_colvars, l_colvars);
res_colnames = list_concat(res_colnames, r_colnames);
res_colvars = list_concat(res_colvars, r_colvars);
/*
* Check alias (AS clause), if any.
@ -845,7 +845,7 @@ transformFromClauseItem(ParseState *pstate, Node *n, List **containedRels)
{
if (j->alias->colnames != NIL)
{
if (length(j->alias->colnames) > length(res_colnames))
if (list_length(j->alias->colnames) > list_length(res_colnames))
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("column alias list for \"%s\" has too many entries",
@ -864,13 +864,13 @@ transformFromClauseItem(ParseState *pstate, Node *n, List **containedRels)
true);
/* assume new rte is at end */
j->rtindex = length(pstate->p_rtable);
j->rtindex = list_length(pstate->p_rtable);
Assert(rte == rt_fetch(j->rtindex, pstate->p_rtable));
/*
* Include join RTE in returned containedRels list
*/
*containedRels = lconsi(j->rtindex, my_containedRels);
*containedRels = lcons_int(j->rtindex, my_containedRels);
return (Node *) j;
}
@ -900,8 +900,8 @@ buildMergedJoinVar(ParseState *pstate, JoinType jointype,
outcoltypmod = l_colvar->vartypmod;
if (outcoltype != r_colvar->vartype)
{
outcoltype = select_common_type(makeListo2(l_colvar->vartype,
r_colvar->vartype),
outcoltype = select_common_type(list_make2_oid(l_colvar->vartype,
r_colvar->vartype),
"JOIN/USING");
outcoltypmod = -1; /* ie, unknown */
}
@ -973,7 +973,7 @@ buildMergedJoinVar(ParseState *pstate, JoinType jointype,
CoalesceExpr *c = makeNode(CoalesceExpr);
c->coalescetype = outcoltype;
c->args = makeList2(l_node, r_node);
c->args = list_make2(l_node, r_node);
res_node = (Node *) c;
break;
}
@ -1122,7 +1122,7 @@ findTargetlistEntry(ParseState *pstate, Node *node, List **tlist, int clause)
*----------
*/
if (IsA(node, ColumnRef) &&
length(((ColumnRef *) node)->fields) == 1 &&
list_length(((ColumnRef *) node)->fields) == 1 &&
((ColumnRef *) node)->indirection == NIL)
{
char *name = strVal(linitial(((ColumnRef *) node)->fields));

12
src/backend/parser/parse_coerce.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/parser/parse_coerce.c,v 2.116 2004/05/26 04:41:30 neilc Exp $
* $PostgreSQL: pgsql/src/backend/parser/parse_coerce.c,v 2.117 2004/05/30 23:40:35 neilc Exp $
*
*-------------------------------------------------------------------------
*/
@ -245,7 +245,7 @@ coerce_type(ParseState *pstate, Node *node,
Oid baseTypeId = getBaseType(targetTypeId);
result = (Node *) makeFuncExpr(funcId, baseTypeId,
makeList1(node),
list_make1(node),
cformat);
/*
@ -508,7 +508,7 @@ coerce_type_typmod(Node *node, Oid targetTypeId, int32 targetTypMod,
false,
true);
args = makeList2(node, cons);
args = list_make2(node, cons);
if (nargs == 3)
{
@ -562,7 +562,7 @@ coerce_record_to_complex(ParseState *pstate, Node *node,
rte = GetRTEByRangeTablePosn(pstate,
((Var *) node)->varno,
((Var *) node)->varlevelsup);
nfields = length(rte->eref->colnames);
nfields = list_length(rte->eref->colnames);
for (nf = 1; nf <= nfields; nf++)
{
Oid vartype;
@ -585,7 +585,7 @@ coerce_record_to_complex(ParseState *pstate, Node *node,
format_type_be(targetTypeId))));
tupdesc = lookup_rowtype_tupdesc(targetTypeId, -1);
if (length(args) != tupdesc->natts)
if (list_length(args) != tupdesc->natts)
ereport(ERROR,
(errcode(ERRCODE_CANNOT_COERCE),
errmsg("cannot cast type %s to %s",
@ -728,7 +728,7 @@ select_common_type(List *typeids, const char *context)
for_each_cell(type_item, lnext(list_head(typeids)))
{
Oid ntype = getBaseType(lfirsto(type_item));
Oid ntype = getBaseType(lfirst_oid(type_item));
/* move on to next one if no new information... */
if ((ntype != InvalidOid) && (ntype != UNKNOWNOID) && (ntype != ptype))

70
src/backend/parser/parse_expr.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/parser/parse_expr.c,v 1.171 2004/05/26 04:41:30 neilc Exp $
* $PostgreSQL: pgsql/src/backend/parser/parse_expr.c,v 1.172 2004/05/30 23:40:35 neilc Exp $
*
*-------------------------------------------------------------------------
*/
@ -153,8 +153,8 @@ transformExpr(ParseState *pstate, Node *expr)
foreach(fields, pref->fields)
{
result = ParseFuncOrColumn(pstate,
makeList1(lfirst(fields)),
makeList1(result),
list_make1(lfirst(fields)),
list_make1(result),
false, false, true);
}
/* handle subscripts, if any */
@ -183,8 +183,8 @@ transformExpr(ParseState *pstate, Node *expr)
foreach(fields, efs->fields)
{
result = ParseFuncOrColumn(pstate,
makeList1(lfirst(fields)),
makeList1(result),
list_make1(lfirst(fields)),
list_make1(result),
false, false, true);
}
/* handle subscripts, if any */
@ -218,7 +218,7 @@ transformExpr(ParseState *pstate, Node *expr)
* into IS NULL exprs.
*/
if (Transform_null_equals &&
length(a->name) == 1 &&
list_length(a->name) == 1 &&
strcmp(strVal(linitial(a->name)), "=") == 0 &&
(exprIsNullConstant(lexpr) ||
exprIsNullConstant(rexpr)))
@ -284,8 +284,8 @@ transformExpr(ParseState *pstate, Node *expr)
rexpr = coerce_to_boolean(pstate, rexpr, "AND");
result = (Node *) makeBoolExpr(AND_EXPR,
makeList2(lexpr,
rexpr));
list_make2(lexpr,
rexpr));
}
break;
case AEXPR_OR:
@ -299,8 +299,8 @@ transformExpr(ParseState *pstate, Node *expr)
rexpr = coerce_to_boolean(pstate, rexpr, "OR");
result = (Node *) makeBoolExpr(OR_EXPR,
makeList2(lexpr,
rexpr));
list_make2(lexpr,
rexpr));
}
break;
case AEXPR_NOT:
@ -311,7 +311,7 @@ transformExpr(ParseState *pstate, Node *expr)
rexpr = coerce_to_boolean(pstate, rexpr, "NOT");
result = (Node *) makeBoolExpr(NOT_EXPR,
makeList1(rexpr));
list_make1(rexpr));
}
break;
case AEXPR_OP_ANY:
@ -446,7 +446,7 @@ transformExpr(ParseState *pstate, Node *expr)
* XXX: repeated lappend() would no longer result in
* O(n^2) behavior; worth reconsidering this design?
*/
targs = listCopy(fn->args);
targs = list_copy(fn->args);
foreach(args, targs)
{
lfirst(args) = transformExpr(pstate,
@ -474,7 +474,7 @@ transformExpr(ParseState *pstate, Node *expr)
}
pstate->p_hasSubLinks = true;
qtrees = parse_sub_analyze(sublink->subselect, pstate);
if (length(qtrees) != 1)
if (list_length(qtrees) != 1)
elog(ERROR, "bad query in sub-select");
qtree = (Query *) linitial(qtrees);
if (qtree->commandType != CMD_SELECT ||
@ -530,7 +530,7 @@ transformExpr(ParseState *pstate, Node *expr)
/* ALL, ANY, or MULTIEXPR: generate operator list */
List *left_list = sublink->lefthand;
List *right_list = qtree->targetList;
int row_length = length(left_list);
int row_length = list_length(left_list);
bool needNot = false;
List *op = sublink->operName;
char *opname = strVal(llast(op));
@ -548,11 +548,11 @@ transformExpr(ParseState *pstate, Node *expr)
* pre-7.4 Postgres.
*/
if (sublink->subLinkType == ALL_SUBLINK &&
length(op) == 1 && strcmp(opname, "<>") == 0)
list_length(op) == 1 && strcmp(opname, "<>") == 0)
{
sublink->subLinkType = ANY_SUBLINK;
opname = pstrdup("=");
op = makeList1(makeString(opname));
op = list_make1(makeString(opname));
sublink->operName = op;
needNot = true;
}
@ -626,8 +626,8 @@ transformExpr(ParseState *pstate, Node *expr)
opname),
errhint("The operator of a quantified predicate subquery must return type boolean.")));
sublink->operOids = lappendo(sublink->operOids,
oprid(optup));
sublink->operOids = lappend_oid(sublink->operOids,
oprid(optup));
ReleaseSysCache(optup);
}
@ -640,7 +640,7 @@ transformExpr(ParseState *pstate, Node *expr)
{
expr = coerce_to_boolean(pstate, expr, "NOT");
expr = (Node *) makeBoolExpr(NOT_EXPR,
makeList1(expr));
list_make1(expr));
}
}
result = (Node *) expr;
@ -709,7 +709,7 @@ transformExpr(ParseState *pstate, Node *expr)
neww->result = (Expr *) transformExpr(pstate, warg);
newargs = lappend(newargs, neww);
typeids = lappendo(typeids, exprType((Node *) neww->result));
typeids = lappend_oid(typeids, exprType((Node *) neww->result));
}
newc->args = newargs;
@ -731,7 +731,7 @@ transformExpr(ParseState *pstate, Node *expr)
* code worked before, but it seems a little bogus to me
* --- tgl
*/
typeids = lconso(exprType((Node *) newc->defresult), typeids);
typeids = lcons_oid(exprType((Node *) newc->defresult), typeids);
ptype = select_common_type(typeids, "CASE");
Assert(OidIsValid(ptype));
@ -779,7 +779,7 @@ transformExpr(ParseState *pstate, Node *expr)
newe = transformExpr(pstate, e);
newelems = lappend(newelems, newe);
typeids = lappendo(typeids, exprType(newe));
typeids = lappend_oid(typeids, exprType(newe));
}
/* Select a common type for the elements */
@ -868,7 +868,7 @@ transformExpr(ParseState *pstate, Node *expr)
newe = transformExpr(pstate, e);
newargs = lappend(newargs, newe);
typeids = lappendo(typeids, exprType(newe));
typeids = lappend_oid(typeids, exprType(newe));
}
newc->coalescetype = select_common_type(typeids, "COALESCE");
@ -997,7 +997,7 @@ transformIndirection(ParseState *pstate, Node *basenode, List *indirection)
static Node *
transformColumnRef(ParseState *pstate, ColumnRef *cref)
{
int numnames = length(cref->fields);
int numnames = list_length(cref->fields);
Node *node;
int levels_up;
@ -1095,8 +1095,8 @@ transformColumnRef(ParseState *pstate, ColumnRef *cref)
*/
node = transformWholeRowRef(pstate, NULL, name1);
node = ParseFuncOrColumn(pstate,
makeList1(makeString(name2)),
makeList1(node),
list_make1(makeString(name2)),
list_make1(node),
false, false, true);
}
break;
@ -1121,8 +1121,8 @@ transformColumnRef(ParseState *pstate, ColumnRef *cref)
/* Try it as a function call */
node = transformWholeRowRef(pstate, name1, name2);
node = ParseFuncOrColumn(pstate,
makeList1(makeString(name3)),
makeList1(node),
list_make1(makeString(name3)),
list_make1(node),
false, false, true);
}
break;
@ -1157,8 +1157,8 @@ transformColumnRef(ParseState *pstate, ColumnRef *cref)
/* Try it as a function call */
node = transformWholeRowRef(pstate, name2, name3);
node = ParseFuncOrColumn(pstate,
makeList1(makeString(name4)),
makeList1(node),
list_make1(makeString(name4)),
list_make1(node),
false, false, true);
}
break;
@ -1587,7 +1587,7 @@ exprIsLengthCoercion(Node *expr, int32 *coercedTypmod)
* second argument being an int4 constant, it can't have been created
* from a length coercion (it must be a type coercion, instead).
*/
nargs = length(func->args);
nargs = list_length(func->args);
if (nargs < 2 || nargs > 3)
return false;
@ -1661,7 +1661,7 @@ make_row_op(ParseState *pstate, List *opname, Node *ltree, Node *rtree)
largs = lrow->args;
rargs = rrow->args;
if (length(largs) != length(rargs))
if (list_length(largs) != list_length(rargs))
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("unequal number of entries in row expression")));
@ -1706,7 +1706,7 @@ make_row_op(ParseState *pstate, List *opname, Node *ltree, Node *rtree)
result = cmp;
else
result = (Node *) makeBoolExpr(boolop,
makeList2(result, cmp));
list_make2(result, cmp));
}
if (result == NULL)
@ -1744,7 +1744,7 @@ make_row_distinct_op(ParseState *pstate, List *opname,
largs = lrow->args;
rargs = rrow->args;
if (length(largs) != length(rargs))
if (list_length(largs) != list_length(rargs))
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("unequal number of entries in row expression")));
@ -1760,7 +1760,7 @@ make_row_distinct_op(ParseState *pstate, List *opname,
result = cmp;
else
result = (Node *) makeBoolExpr(OR_EXPR,
makeList2(result, cmp));
list_make2(result, cmp));
}
if (result == NULL)

14
src/backend/parser/parse_func.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/parser/parse_func.c,v 1.169 2004/05/26 04:41:30 neilc Exp $
* $PostgreSQL: pgsql/src/backend/parser/parse_func.c,v 1.170 2004/05/30 23:40:35 neilc Exp $
*
*-------------------------------------------------------------------------
*/
@ -69,7 +69,7 @@ ParseFuncOrColumn(ParseState *pstate, List *funcname, List *fargs,
Oid funcid;
ListCell *l;
Node *first_arg = NULL;
int nargs = length(fargs);
int nargs = list_length(fargs);
int argn;
Oid actual_arg_types[FUNC_MAX_ARGS];
Oid *declared_arg_types;
@ -101,7 +101,7 @@ ParseFuncOrColumn(ParseState *pstate, List *funcname, List *fargs,
* then the "function call" could be a projection. We also check that
* there wasn't any aggregate decoration.
*/
if (nargs == 1 && !agg_star && !agg_distinct && length(funcname) == 1)
if (nargs == 1 && !agg_star && !agg_distinct && list_length(funcname) == 1)
{
Oid argtype = exprType(first_arg);
@ -182,7 +182,7 @@ ParseFuncOrColumn(ParseState *pstate, List *funcname, List *fargs,
if (is_column)
{
Assert(nargs == 1);
Assert(length(funcname) == 1);
Assert(list_length(funcname) == 1);
unknown_attribute(pstate, first_arg, strVal(linitial(funcname)));
}
@ -974,8 +974,8 @@ find_inheritors(Oid relid, Oid **supervec)
else
*supervec = NULL;
freeList(visited);
freeList(queue);
list_free(visited);
list_free(queue);
return nvisited;
}
@ -1400,7 +1400,7 @@ LookupFuncNameTypeNames(List *funcname, List *argtypes, bool noError)
ListCell *args_item;
MemSet(argoids, 0, FUNC_MAX_ARGS * sizeof(Oid));
argcount = length(argtypes);
argcount = list_length(argtypes);
if (argcount > FUNC_MAX_ARGS)
ereport(ERROR,
(errcode(ERRCODE_TOO_MANY_ARGUMENTS),

10
src/backend/parser/parse_oper.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/parser/parse_oper.c,v 1.77 2003/11/29 19:51:52 pgsql Exp $
* $PostgreSQL: pgsql/src/backend/parser/parse_oper.c,v 1.78 2004/05/30 23:40:35 neilc Exp $
*
*-------------------------------------------------------------------------
*/
@ -881,7 +881,7 @@ make_scalar_array_op(ParseState *pstate, List *opname,
tup = oper(opname, ltypeId, rtypeId, false);
opform = (Form_pg_operator) GETSTRUCT(tup);
args = makeList2(ltree, rtree);
args = list_make2(ltree, rtree);
actual_arg_types[0] = ltypeId;
actual_arg_types[1] = rtypeId;
declared_arg_types[0] = opform->oprleft;
@ -960,7 +960,7 @@ make_op_expr(ParseState *pstate, Operator op,
if (rtree == NULL)
{
/* right operator */
args = makeList1(ltree);
args = list_make1(ltree);
actual_arg_types[0] = ltypeId;
declared_arg_types[0] = opform->oprleft;
nargs = 1;
@ -968,7 +968,7 @@ make_op_expr(ParseState *pstate, Operator op,
else if (ltree == NULL)
{
/* left operator */
args = makeList1(rtree);
args = list_make1(rtree);
actual_arg_types[0] = rtypeId;
declared_arg_types[0] = opform->oprright;
nargs = 1;
@ -976,7 +976,7 @@ make_op_expr(ParseState *pstate, Operator op,
else
{
/* otherwise, binary operator */
args = makeList2(ltree, rtree);
args = list_make2(ltree, rtree);
actual_arg_types[0] = ltypeId;
actual_arg_types[1] = rtypeId;
declared_arg_types[0] = opform->oprleft;

50
src/backend/parser/parse_relation.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/parser/parse_relation.c,v 1.95 2004/05/26 04:41:30 neilc Exp $
* $PostgreSQL: pgsql/src/backend/parser/parse_relation.c,v 1.96 2004/05/30 23:40:35 neilc Exp $
*
*-------------------------------------------------------------------------
*/
@ -436,7 +436,7 @@ GetRTEByRangeTablePosn(ParseState *pstate,
pstate = pstate->parentParseState;
Assert(pstate != NULL);
}
Assert(varno > 0 && varno <= length(pstate->p_rtable));
Assert(varno > 0 && varno <= list_length(pstate->p_rtable));
return rt_fetch(varno, pstate->p_rtable);
}
@ -674,7 +674,7 @@ addRangeTableEntry(ParseState *pstate,
rte->relid = RelationGetRelid(rel);
eref = alias ? (Alias *) copyObject(alias) : makeAlias(refname, NIL);
numaliases = length(eref->colnames);
numaliases = list_length(eref->colnames);
/*
* Since the rel is open anyway, let's check that the number of column
@ -768,7 +768,7 @@ addRangeTableEntryForRelation(ParseState *pstate,
rte->relid = relid;
eref = (Alias *) copyObject(alias);
numaliases = length(eref->colnames);
numaliases = list_length(eref->colnames);
/*
* Since the rel is open anyway, let's check that the number of column
@ -849,7 +849,7 @@ addRangeTableEntryForSubquery(ParseState *pstate,
rte->alias = alias;
eref = copyObject(alias);
numaliases = length(eref->colnames);
numaliases = list_length(eref->colnames);
/* fill in any unspecified alias columns */
varattno = 0;
@ -933,7 +933,7 @@ addRangeTableEntryForFunction(ParseState *pstate,
eref = alias ? (Alias *) copyObject(alias) : makeAlias(funcname, NIL);
rte->eref = eref;
numaliases = length(eref->colnames);
numaliases = list_length(eref->colnames);
/*
* Now determine if the function returns a simple or composite type,
@ -1023,7 +1023,7 @@ addRangeTableEntryForFunction(ParseState *pstate,
errmsg("too many column aliases specified for function %s",
funcname)));
if (numaliases == 0)
eref->colnames = makeList1(makeString(eref->aliasname));
eref->colnames = list_make1(makeString(eref->aliasname));
}
else if (functyptype == 'p' && funcrettype == RECORDOID)
{
@ -1097,12 +1097,12 @@ addRangeTableEntryForJoin(ParseState *pstate,
rte->alias = alias;
eref = alias ? (Alias *) copyObject(alias) : makeAlias("unnamed_join", NIL);
numaliases = length(eref->colnames);
numaliases = list_length(eref->colnames);
/* fill in any unspecified alias columns */
if (numaliases < length(colnames))
eref->colnames = nconc(eref->colnames,
list_copy_tail(colnames, numaliases));
if (numaliases < list_length(colnames))
eref->colnames = list_concat(eref->colnames,
list_copy_tail(colnames, numaliases));
rte->eref = eref;
@ -1241,7 +1241,7 @@ expandRTE(ParseState *pstate, RangeTblEntry *rte,
rel = heap_open(rte->relid, AccessShareLock);
maxattrs = RelationGetNumberOfAttributes(rel);
numaliases = length(rte->eref->colnames);
numaliases = list_length(rte->eref->colnames);
for (varattno = 0; varattno < maxattrs; varattno++)
{
@ -1255,7 +1255,7 @@ expandRTE(ParseState *pstate, RangeTblEntry *rte,
char *label;
if (varattno < numaliases)
label = strVal(nth(varattno, rte->eref->colnames));
label = strVal(list_nth(rte->eref->colnames, varattno));
else
label = NameStr(attr->attname);
*colnames = lappend(*colnames, makeString(pstrdup(label)));
@ -1339,7 +1339,7 @@ expandRTE(ParseState *pstate, RangeTblEntry *rte,
rel = relation_open(funcrelid, AccessShareLock);
maxattrs = RelationGetNumberOfAttributes(rel);
numaliases = length(rte->eref->colnames);
numaliases = list_length(rte->eref->colnames);
for (varattno = 0; varattno < maxattrs; varattno++)
{
@ -1353,7 +1353,7 @@ expandRTE(ParseState *pstate, RangeTblEntry *rte,
char *label;
if (varattno < numaliases)
label = strVal(nth(varattno, rte->eref->colnames));
label = strVal(list_nth(rte->eref->colnames, varattno));
else
label = NameStr(attr->attname);
*colnames = lappend(*colnames, makeString(pstrdup(label)));
@ -1442,7 +1442,7 @@ expandRTE(ParseState *pstate, RangeTblEntry *rte,
ListCell *colname;
ListCell *aliasvar;
Assert(length(rte->eref->colnames) == length(rte->joinaliasvars));
Assert(list_length(rte->eref->colnames) == list_length(rte->joinaliasvars));
varattno = 0;
forboth (colname, rte->eref->colnames, aliasvar, rte->joinaliasvars)
@ -1533,8 +1533,8 @@ get_rte_attribute_name(RangeTblEntry *rte, AttrNumber attnum)
* If there is a user-written column alias, use it.
*/
if (rte->alias &&
attnum > 0 && attnum <= length(rte->alias->colnames))
return strVal(nth(attnum - 1, rte->alias->colnames));
attnum > 0 && attnum <= list_length(rte->alias->colnames))
return strVal(list_nth(rte->alias->colnames, attnum - 1));
/*
* If the RTE is a relation, go to the system catalogs not the
@ -1549,8 +1549,8 @@ get_rte_attribute_name(RangeTblEntry *rte, AttrNumber attnum)
* Otherwise use the column name from eref. There should always be
* one.
*/
if (attnum > 0 && attnum <= length(rte->eref->colnames))
return strVal(nth(attnum - 1, rte->eref->colnames));
if (attnum > 0 && attnum <= list_length(rte->eref->colnames))
return strVal(list_nth(rte->eref->colnames, attnum - 1));
/* else caller gave us a bogus attnum */
elog(ERROR, "invalid attnum %d for rangetable entry %s",
@ -1665,7 +1665,7 @@ get_rte_attribute_type(RangeTblEntry *rte, AttrNumber attnum,
}
else if (functyptype == 'p' && funcrettype == RECORDOID)
{
ColumnDef *colDef = nth(attnum - 1, coldeflist);
ColumnDef *colDef = list_nth(coldeflist, attnum - 1);
*vartype = typenameTypeId(colDef->typename);
*vartypmod = -1;
@ -1684,8 +1684,8 @@ get_rte_attribute_type(RangeTblEntry *rte, AttrNumber attnum,
*/
Node *aliasvar;
Assert(attnum > 0 && attnum <= length(rte->joinaliasvars));
aliasvar = (Node *) nth(attnum - 1, rte->joinaliasvars);
Assert(attnum > 0 && attnum <= list_length(rte->joinaliasvars));
aliasvar = (Node *) list_nth(rte->joinaliasvars, attnum - 1);
*vartype = exprType(aliasvar);
*vartypmod = exprTypmod(aliasvar);
}
@ -1777,8 +1777,8 @@ get_rte_attribute_is_dropped(RangeTblEntry *rte, AttrNumber attnum)
*
* Returns NULL if resno is not present in list.
*
* Note: we need to search, rather than just indexing with nth(), because
* not all tlists are sorted by resno.
* Note: we need to search, rather than just indexing with list_nth(),
* because not all tlists are sorted by resno.
*/
TargetEntry *
get_tle_by_resno(List *tlist, AttrNumber resno)

16
src/backend/parser/parse_target.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/parser/parse_target.c,v 1.118 2004/05/26 04:41:30 neilc Exp $
* $PostgreSQL: pgsql/src/backend/parser/parse_target.c,v 1.119 2004/05/30 23:40:35 neilc Exp $
*
*-------------------------------------------------------------------------
*/
@ -108,7 +108,7 @@ transformTargetList(ParseState *pstate, List *targetlist)
if (strcmp(strVal(llast(fields)), "*") == 0)
{
int numnames = length(fields);
int numnames = list_length(fields);
if (numnames == 1)
{
@ -268,8 +268,8 @@ markTargetListOrigin(ParseState *pstate, Resdom *res, Var *var)
/* Join RTE --- recursively inspect the alias variable */
Var *aliasvar;
Assert(attnum > 0 && attnum <= length(rte->joinaliasvars));
aliasvar = (Var *) nth(attnum - 1, rte->joinaliasvars);
Assert(attnum > 0 && attnum <= list_length(rte->joinaliasvars));
aliasvar = (Var *) list_nth(rte->joinaliasvars, attnum - 1);
markTargetListOrigin(pstate, res, aliasvar);
}
break;
@ -460,7 +460,7 @@ checkInsertTargets(ParseState *pstate, List *cols, List **attrnos)
col->indirection = NIL;
col->val = NULL;
cols = lappend(cols, col);
*attrnos = lappendi(*attrnos, i + 1);
*attrnos = lappend_int(*attrnos, i + 1);
}
}
else
@ -478,12 +478,12 @@ checkInsertTargets(ParseState *pstate, List *cols, List **attrnos)
/* Lookup column name, ereport on failure */
attrno = attnameAttNum(pstate->p_target_relation, name, false);
/* Check for duplicates */
if (intMember(attrno, *attrnos))
if (list_member_int(*attrnos, attrno))
ereport(ERROR,
(errcode(ERRCODE_DUPLICATE_COLUMN),
errmsg("column \"%s\" specified more than once",
name)));
*attrnos = lappendi(*attrnos, attrno);
*attrnos = lappend_int(*attrnos, attrno);
}
}
@ -529,7 +529,7 @@ ExpandAllTables(ParseState *pstate)
continue;
found_table = true;
target = nconc(target, expandRelAttrs(pstate, rte));
target = list_concat(target, expandRelAttrs(pstate, rte));
}
/* Check for SELECT *; */

8
src/backend/parser/parse_type.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/parser/parse_type.c,v 1.66 2004/05/26 04:41:30 neilc Exp $
* $PostgreSQL: pgsql/src/backend/parser/parse_type.c,v 1.67 2004/05/30 23:40:35 neilc Exp $
*
*-------------------------------------------------------------------------
*/
@ -54,7 +54,7 @@ LookupTypeName(const TypeName *typename)
AttrNumber attnum;
/* deconstruct the name list */
switch (length(typename->names))
switch (list_length(typename->names))
{
case 1:
ereport(ERROR,
@ -486,7 +486,7 @@ parseTypeString(const char *str, Oid *type_id, int32 *typmod)
* Make sure we got back exactly what we expected and no more;
* paranoia is justified since the string might contain anything.
*/
if (length(raw_parsetree_list) != 1)
if (list_length(raw_parsetree_list) != 1)
goto fail;
stmt = (SelectStmt *) linitial(raw_parsetree_list);
if (stmt == NULL ||
@ -503,7 +503,7 @@ parseTypeString(const char *str, Oid *type_id, int32 *typmod)
stmt->forUpdate != NIL ||
stmt->op != SETOP_NONE)
goto fail;
if (length(stmt->targetList) != 1)
if (list_length(stmt->targetList) != 1)
goto fail;
restarget = (ResTarget *) linitial(stmt->targetList);
if (restarget == NULL ||

6
src/backend/rewrite/rewriteDefine.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/rewrite/rewriteDefine.c,v 1.95 2004/05/26 04:41:33 neilc Exp $
* $PostgreSQL: pgsql/src/backend/rewrite/rewriteDefine.c,v 1.96 2004/05/30 23:40:35 neilc Exp $
*
*-------------------------------------------------------------------------
*/
@ -251,7 +251,7 @@ DefineQueryRewrite(RuleStmt *stmt)
/*
* So there cannot be INSTEAD NOTHING, ...
*/
if (length(action) == 0)
if (list_length(action) == 0)
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("INSTEAD NOTHING rules on SELECT are not implemented"),
@ -260,7 +260,7 @@ DefineQueryRewrite(RuleStmt *stmt)
/*
* ... there cannot be multiple actions, ...
*/
if (length(action) > 1)
if (list_length(action) > 1)
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("multiple actions for rules on SELECT are not implemented")));

32
src/backend/rewrite/rewriteHandler.c
View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/rewrite/rewriteHandler.c,v 1.137 2004/05/29 05:55:13 tgl Exp $
* $PostgreSQL: pgsql/src/backend/rewrite/rewriteHandler.c,v 1.138 2004/05/30 23:40:35 neilc Exp $
*
*-------------------------------------------------------------------------
*/
@ -82,7 +82,7 @@ rewriteRuleAction(Query *parsetree,
rule_qual = (Node *) copyObject(rule_qual);
current_varno = rt_index;
rt_length = length(parsetree->rtable);
rt_length = list_length(parsetree->rtable);
new_varno = PRS2_NEW_VARNO + rt_length;
/*
@ -131,7 +131,7 @@ rewriteRuleAction(Query *parsetree,
* that rule action's rtable is separate and shares no substructure
* with the main rtable. Hence do a deep copy here.
*/
sub_action->rtable = nconc((List *) copyObject(parsetree->rtable),
sub_action->rtable = list_concat((List *) copyObject(parsetree->rtable),
sub_action->rtable);
/*
@ -174,7 +174,7 @@ rewriteRuleAction(Query *parsetree,
errmsg("conditional UNION/INTERSECT/EXCEPT statements are not implemented")));
sub_action->jointree->fromlist =
nconc(newjointree, sub_action->jointree->fromlist);
list_concat(newjointree, sub_action->jointree->fromlist);
}
}
@ -249,8 +249,8 @@ adjustJoinTreeList(Query *parsetree, bool removert, int rt_index)
if (IsA(rtr, RangeTblRef) &&
rtr->rtindex == rt_index)
{
newjointree = lremove(rtr, newjointree);
/* foreach is safe because we exit loop after lremove... */
newjointree = list_delete_ptr(newjointree, rtr);
/* foreach is safe because we exit loop after list_delete... */
break;
}
}
@ -616,7 +616,7 @@ ApplyRetrieveRule(Query *parsetree,
RangeTblEntry *rte,
*subrte;
if (length(rule->actions) != 1)
if (list_length(rule->actions) != 1)
elog(ERROR, "expected just one rule action");
if (rule->qual != NULL)
elog(ERROR, "cannot handle qualified ON SELECT rule");
@ -657,14 +657,14 @@ ApplyRetrieveRule(Query *parsetree,
/*
* FOR UPDATE of view?
*/
if (intMember(rt_index, parsetree->rowMarks))
if (list_member_int(parsetree->rowMarks, rt_index))
{
/*
* Remove the view from the list of rels that will actually be
* marked FOR UPDATE by the executor. It will still be access-
* checked for write access, though.
*/
parsetree->rowMarks = lremovei(rt_index, parsetree->rowMarks);
parsetree->rowMarks = list_delete_int(parsetree->rowMarks, rt_index);
/*
* Set up the view's referenced tables as if FOR UPDATE.
@ -702,8 +702,8 @@ markQueryForUpdate(Query *qry, bool skipOldNew)
if (rte->rtekind == RTE_RELATION)
{
if (!intMember(rti, qry->rowMarks))
qry->rowMarks = lappendi(qry->rowMarks, rti);
if (!list_member_int(qry->rowMarks, rti))
qry->rowMarks = lappend_int(qry->rowMarks, rti);
rte->requiredPerms |= ACL_SELECT_FOR_UPDATE;
}
else if (rte->rtekind == RTE_SUBQUERY)
@ -766,7 +766,7 @@ fireRIRrules(Query *parsetree, List *activeRIRs)
* can get changed each time through...
*/
rt_index = 0;
while (rt_index < length(parsetree->rtable))
while (rt_index < list_length(parsetree->rtable))
{
RangeTblEntry *rte;
Relation rel;
@ -825,7 +825,7 @@ fireRIRrules(Query *parsetree, List *activeRIRs)
*/
if (rt_index == parsetree->resultRelation)
lockmode = NoLock;
else if (intMember(rt_index, parsetree->rowMarks))
else if (list_member_int(parsetree->rowMarks, rt_index))
lockmode = RowShareLock;
else
lockmode = AccessShareLock;
@ -866,12 +866,12 @@ fireRIRrules(Query *parsetree, List *activeRIRs)
{
ListCell *l;
if (oidMember(RelationGetRelid(rel), activeRIRs))
if (list_member_oid(activeRIRs, RelationGetRelid(rel)))
ereport(ERROR,
(errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
errmsg("infinite recursion detected in rules for relation \"%s\"",
RelationGetRelationName(rel))));
activeRIRs = lconso(RelationGetRelid(rel), activeRIRs);
activeRIRs = lcons_oid(RelationGetRelid(rel), activeRIRs);
foreach(l, locks)
{
@ -1169,7 +1169,7 @@ RewriteQuery(Query *parsetree, List *rewrite_events)
List *newstuff;
newstuff = RewriteQuery(pt, rewrite_events);
rewritten = nconc(rewritten, newstuff);
rewritten = list_concat(rewritten, newstuff);
}
}
}

16
src/backend/rewrite/rewriteManip.c
View File

@ -7,7 +7,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/rewrite/rewriteManip.c,v 1.83 2004/05/26 04:41:33 neilc Exp $
* $PostgreSQL: pgsql/src/backend/rewrite/rewriteManip.c,v 1.84 2004/05/30 23:40:35 neilc Exp $
*
*-------------------------------------------------------------------------
*/
@ -231,7 +231,7 @@ OffsetVarNodes(Node *node, int offset, int sublevels_up)
if (qry->resultRelation)
qry->resultRelation += offset;
foreach(l, qry->rowMarks)
lfirsti(l) += offset;
lfirst_int(l) += offset;
}
query_tree_walker(qry, OffsetVarNodes_walker,
(void *) &context, 0);
@ -373,8 +373,8 @@ ChangeVarNodes(Node *node, int rt_index, int new_index, int sublevels_up)
qry->resultRelation = new_index;
foreach(l, qry->rowMarks)
{
if (lfirsti(l) == rt_index)
lfirsti(l) = new_index;
if (lfirst_int(l) == rt_index)
lfirst_int(l) = new_index;
}
}
query_tree_walker(qry, ChangeVarNodes_walker,
@ -671,14 +671,14 @@ getInsertSelectQuery(Query *parsetree, Query ***subquery_ptr)
* query. If they're not there, it must be an INSERT/SELECT in which
* they've been pushed down to the SELECT.
*/
if (length(parsetree->rtable) >= 2 &&
if (list_length(parsetree->rtable) >= 2 &&
strcmp(rt_fetch(PRS2_OLD_VARNO, parsetree->rtable)->eref->aliasname,
"*OLD*") == 0 &&
strcmp(rt_fetch(PRS2_NEW_VARNO, parsetree->rtable)->eref->aliasname,
"*NEW*") == 0)
return parsetree;
Assert(parsetree->jointree && IsA(parsetree->jointree, FromExpr));
if (length(parsetree->jointree->fromlist) != 1)
if (list_length(parsetree->jointree->fromlist) != 1)
elog(ERROR, "expected to find SELECT subquery");
rtr = (RangeTblRef *) linitial(parsetree->jointree->fromlist);
Assert(IsA(rtr, RangeTblRef));
@ -687,7 +687,7 @@ getInsertSelectQuery(Query *parsetree, Query ***subquery_ptr)
if (!(selectquery && IsA(selectquery, Query) &&
selectquery->commandType == CMD_SELECT))
elog(ERROR, "expected to find SELECT subquery");
if (length(selectquery->rtable) >= 2 &&
if (list_length(selectquery->rtable) >= 2 &&
strcmp(rt_fetch(PRS2_OLD_VARNO, selectquery->rtable)->eref->aliasname,
"*OLD*") == 0 &&
strcmp(rt_fetch(PRS2_NEW_VARNO, selectquery->rtable)->eref->aliasname,
@ -933,7 +933,7 @@ ResolveNew_mutator(Node *node, ResolveNew_context *context)
RangeTblEntry *rte = context->target_rte;
RowExpr *rowexpr;
List *fields = NIL;
AttrNumber nfields = length(rte->eref->colnames);
AttrNumber nfields = list_length(rte->eref->colnames);
AttrNumber nf;
for (nf = 1; nf <= nfields; nf++)

4
src/backend/utils/adt/name.c
View File

@ -14,7 +14,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/utils/adt/name.c,v 1.51 2004/05/26 04:41:37 neilc Exp $
* $PostgreSQL: pgsql/src/backend/utils/adt/name.c,v 1.52 2004/05/30 23:40:35 neilc Exp $
*
*-------------------------------------------------------------------------
*/
@ -360,7 +360,7 @@ current_schemas(PG_FUNCTION_ARGS)
/* +1 here is just to avoid palloc(0) error */
names = (Datum *) palloc((length(search_path) + 1) * sizeof(Datum));
names = (Datum *) palloc((list_length(search_path) + 1) * sizeof(Datum));
i = 0;
foreach(l, search_path)
{

6
src/backend/utils/adt/not_in.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/utils/adt/not_in.c,v 1.38 2003/11/29 19:51:59 pgsql Exp $
* $PostgreSQL: pgsql/src/backend/utils/adt/not_in.c,v 1.39 2004/05/30 23:40:35 neilc Exp $
*
*-------------------------------------------------------------------------
*/
@ -57,14 +57,14 @@ int4notin(PG_FUNCTION_ARGS)
/* Parse the argument */
names = textToQualifiedNameList(relation_and_attr, "int4notin");
nnames = length(names);
nnames = list_length(names);
if (nnames < 2)
ereport(ERROR,
(errcode(ERRCODE_INVALID_NAME),
errmsg("invalid name syntax"),
errhint("Must provide \"relationname.columnname\".")));
attribute = strVal(llast(names));
names = ltruncate(nnames - 1, names);
names = list_truncate(names, nnames - 1);
relrv = makeRangeVarFromNameList(names);
/* Open the relation and get a relation descriptor */

8
src/backend/utils/adt/regproc.c
View File

@ -13,7 +13,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/utils/adt/regproc.c,v 1.88 2004/05/26 04:41:37 neilc Exp $
* $PostgreSQL: pgsql/src/backend/utils/adt/regproc.c,v 1.89 2004/05/30 23:40:36 neilc Exp $
*
*-------------------------------------------------------------------------
*/
@ -188,7 +188,7 @@ regprocout(PG_FUNCTION_ARGS)
* Would this proc be found (uniquely!) by regprocin? If not,
* qualify it.
*/
clist = FuncnameGetCandidates(makeList1(makeString(proname)), -1);
clist = FuncnameGetCandidates(list_make1(makeString(proname)), -1);
if (clist != NULL && clist->next == NULL &&
clist->oid == proid)
nspname = NULL;
@ -536,7 +536,7 @@ regoperout(PG_FUNCTION_ARGS)
* Would this oper be found (uniquely!) by regoperin? If not,
* qualify it.
*/
clist = OpernameGetCandidates(makeList1(makeString(oprname)),
clist = OpernameGetCandidates(list_make1(makeString(oprname)),
'\0');
if (clist != NULL && clist->next == NULL &&
clist->oid == oprid)
@ -1122,7 +1122,7 @@ stringToQualifiedNameList(const char *string, const char *caller)
}
pfree(rawname);
freeList(namelist);
list_free(namelist);
return result;
}

4
src/backend/utils/adt/ri_triggers.c
View File

@ -17,7 +17,7 @@
*
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
*
* $PostgreSQL: pgsql/src/backend/utils/adt/ri_triggers.c,v 1.68 2004/05/26 04:41:38 neilc Exp $
* $PostgreSQL: pgsql/src/backend/utils/adt/ri_triggers.c,v 1.69 2004/05/30 23:40:36 neilc Exp $
*
* ----------
*/
@ -2712,7 +2712,7 @@ RI_Initial_Check(FkConstraint *fkconstraint, Relation rel, Relation pkrel)
{
HeapTuple tuple = SPI_tuptable->vals[0];
TupleDesc tupdesc = SPI_tuptable->tupdesc;
int nkeys = length(fkconstraint->fk_attrs);
int nkeys = list_length(fkconstraint->fk_attrs);
int i;
RI_QueryKey qkey;

44
src/backend/utils/adt/ruleutils.c
View File

@ -3,7 +3,7 @@
* back to source text
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/utils/adt/ruleutils.c,v 1.168 2004/05/26 19:30:12 tgl Exp $
* $PostgreSQL: pgsql/src/backend/utils/adt/ruleutils.c,v 1.169 2004/05/30 23:40:36 neilc Exp $
*
* This software is copyrighted by Jan Wieck - Hamburg.
*
@ -1290,12 +1290,12 @@ deparse_context_for(const char *aliasname, Oid relid)
rte->inFromCl = true;
/* Build one-element rtable */
dpns->rtable = makeList1(rte);
dpns->rtable = list_make1(rte);
dpns->outer_varno = dpns->inner_varno = 0;
dpns->outer_rte = dpns->inner_rte = NULL;
/* Return a one-deep namespace stack */
return makeList1(dpns);
return list_make1(dpns);
}
/*
@ -1327,7 +1327,7 @@ deparse_context_for_plan(int outer_varno, Node *outercontext,
dpns->inner_rte = (RangeTblEntry *) innercontext;
/* Return a one-deep namespace stack */
return makeList1(dpns);
return list_make1(dpns);
}
/*
@ -1360,7 +1360,7 @@ deparse_context_for_subplan(const char *name, List *tlist,
RangeTblEntry *rte = makeNode(RangeTblEntry);
List *attrs = NIL;
int nattrs = 0;
int rtablelength = length(rtable);
int rtablelength = list_length(rtable);
ListCell *tl;
char buf[32];
@ -1539,8 +1539,8 @@ make_ruledef(StringInfo buf, HeapTuple ruletup, TupleDesc rulettc,
query = getInsertSelectQuery(query, NULL);
context.buf = buf;
context.namespaces = makeList1(&dpns);
context.varprefix = (length(query->rtable) != 1);
context.namespaces = list_make1(&dpns);
context.varprefix = (list_length(query->rtable) != 1);
context.prettyFlags = prettyFlags;
context.indentLevel = PRETTYINDENT_STD;
dpns.rtable = query->rtable;
@ -1557,7 +1557,7 @@ make_ruledef(StringInfo buf, HeapTuple ruletup, TupleDesc rulettc,
appendStringInfo(buf, "INSTEAD ");
/* Finally the rules actions */
if (length(actions) > 1)
if (list_length(actions) > 1)
{
ListCell *action;
Query *query;
@ -1574,7 +1574,7 @@ make_ruledef(StringInfo buf, HeapTuple ruletup, TupleDesc rulettc,
}
appendStringInfo(buf, ");");
}
else if (length(actions) == 0)
else if (list_length(actions) == 0)
{
appendStringInfo(buf, "NOTHING;");
}
@ -1633,7 +1633,7 @@ make_viewdef(StringInfo buf, HeapTuple ruletup, TupleDesc rulettc,
if (ev_action != NULL)
actions = (List *) stringToNode(ev_action);
if (length(actions) != 1)
if (list_length(actions) != 1)
{
appendStringInfo(buf, "Not a view");
return;
@ -1675,7 +1675,7 @@ get_query_def(Query *query, StringInfo buf, List *parentnamespace,
context.buf = buf;
context.namespaces = lcons(&dpns, list_copy(parentnamespace));
context.varprefix = (parentnamespace != NIL ||
length(query->rtable) != 1);
list_length(query->rtable) != 1);
context.prettyFlags = prettyFlags;
context.indentLevel = startIndent;
@ -2284,7 +2284,7 @@ get_names_for_var(Var *var, deparse_context *context,
var->varlevelsup);
/* Find the relevant RTE */
if (var->varno >= 1 && var->varno <= length(dpns->rtable))
if (var->varno >= 1 && var->varno <= list_length(dpns->rtable))
rte = rt_fetch(var->varno, dpns->rtable);
else if (var->varno == dpns->outer_varno)
rte = dpns->outer_rte;
@ -2393,7 +2393,7 @@ get_simple_binary_op_name(OpExpr *expr)
{
List *args = expr->args;
if (length(args) == 2)
if (list_length(args) == 2)
{
/* binary operator */
Node *arg1 = (Node *) linitial(args);
@ -3063,7 +3063,7 @@ get_rule_expr(Node *node, deparse_context *context,
char *sep;
/*
* SQL99 allows "ROW" to be omitted when length(args) > 1,
* SQL99 allows "ROW" to be omitted when list_length(args) > 1,
* but for simplicity we always print it.
*/
appendStringInfo(buf, "ROW(");
@ -3240,7 +3240,7 @@ get_oper_expr(OpExpr *expr, deparse_context *context)
if (!PRETTY_PAREN(context))
appendStringInfoChar(buf, '(');
if (length(args) == 2)
if (list_length(args) == 2)
{
/* binary operator */
Node *arg1 = (Node *) linitial(args);
@ -3595,7 +3595,7 @@ get_sublink_expr(SubLink *sublink, deparse_context *context)
if (sublink->lefthand != NIL)
{
need_paren = (length(sublink->lefthand) > 1);
need_paren = (list_length(sublink->lefthand) > 1);
if (need_paren)
appendStringInfoChar(buf, '(');
@ -3628,7 +3628,7 @@ get_sublink_expr(SubLink *sublink, deparse_context *context)
break;
case ANY_SUBLINK:
if (length(sublink->operName) == 1 &&
if (list_length(sublink->operName) == 1 &&
strcmp(strVal(linitial(sublink->operName)), "=") == 0)
{
/* Represent = ANY as IN */
@ -4244,7 +4244,7 @@ generate_function_name(Oid funcid, int nargs, Oid *argtypes)
* resolve the correct function given the unqualified func name with
* the specified argtypes.
*/
p_result = func_get_detail(makeList1(makeString(proname)),
p_result = func_get_detail(list_make1(makeString(proname)),
NIL, nargs, argtypes,
&p_funcid, &p_rettype,
&p_retset, &p_true_typeids);
@ -4300,13 +4300,13 @@ generate_operator_name(Oid operid, Oid arg1, Oid arg2)
switch (operform->oprkind)
{
case 'b':
p_result = oper(makeList1(makeString(oprname)), arg1, arg2, true);
p_result = oper(list_make1(makeString(oprname)), arg1, arg2, true);
break;
case 'l':
p_result = left_oper(makeList1(makeString(oprname)), arg2, true);
p_result = left_oper(list_make1(makeString(oprname)), arg2, true);
break;
case 'r':
p_result = right_oper(makeList1(makeString(oprname)), arg1, true);
p_result = right_oper(list_make1(makeString(oprname)), arg1, true);
break;
default:
elog(ERROR, "unrecognized oprkind: %d", operform->oprkind);
@ -4342,7 +4342,7 @@ static void
print_operator_name(StringInfo buf, List *opname)
{
ListCell *op = list_head(opname);
int nnames = length(opname);
int nnames = list_length(opname);
if (nnames == 1)
appendStringInfoString(buf, strVal(lfirst(op)));

32
src/backend/utils/adt/selfuncs.c
View File

@ -15,7 +15,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/utils/adt/selfuncs.c,v 1.159 2004/05/26 04:41:39 neilc Exp $
* $PostgreSQL: pgsql/src/backend/utils/adt/selfuncs.c,v 1.160 2004/05/30 23:40:36 neilc Exp $
*
*-------------------------------------------------------------------------
*/
@ -983,7 +983,7 @@ patternsel(PG_FUNCTION_ARGS, Pattern_Type ptype)
if (eqopr == InvalidOid)
elog(ERROR, "no = operator for opclass %u", opclass);
eqargs = makeList2(vardata.var, prefix);
eqargs = list_make2(vardata.var, prefix);
result = DatumGetFloat8(DirectFunctionCall4(eqsel,
PointerGetDatum(root),
ObjectIdGetDatum(eqopr),
@ -1966,15 +1966,15 @@ estimate_num_groups(Query *root, List *groupExprs, double input_rows)
return input_rows;
continue;
}
allvars = nconc(allvars, varshere);
allvars = list_concat(allvars, varshere);
}
/* If now no Vars, we must have an all-constant GROUP BY list. */
if (allvars == NIL)
return 1.0;
/* Use set_union() to discard duplicates */
allvars = set_union(NIL, allvars);
/* Use list_union() to discard duplicates */
allvars = list_union(NIL, allvars);
/*
* Step 2: acquire statistical estimate of number of distinct values
@ -1993,13 +1993,13 @@ estimate_num_groups(Query *root, List *groupExprs, double input_rows)
ndistinct = get_variable_numdistinct(&vardata);
ReleaseVariableStats(vardata);
/* cannot use foreach here because of possible lremove */
/* cannot use foreach here because of possible list_delete */
l2 = list_head(varinfos);
while (l2)
{
MyVarInfo *varinfo = (MyVarInfo *) lfirst(l2);
/* must advance l2 before lremove possibly pfree's it */
/* must advance l2 before list_delete possibly pfree's it */
l2 = lnext(l2);
if (var->varno != varinfo->var->varno &&
@ -2015,7 +2015,7 @@ estimate_num_groups(Query *root, List *groupExprs, double input_rows)
else
{
/* Delete the older item */
varinfos = lremove(varinfo, varinfos);
varinfos = list_delete_ptr(varinfos, varinfo);
}
}
}
@ -2841,7 +2841,7 @@ get_restriction_variable(Query *root, List *args, int varRelid,
VariableStatData rdata;
/* Fail if not a binary opclause (probably shouldn't happen) */
if (length(args) != 2)
if (list_length(args) != 2)
return false;
left = (Node *) linitial(args);
@ -2892,7 +2892,7 @@ get_join_variables(Query *root, List *args,
Node *left,
*right;
if (length(args) != 2)
if (list_length(args) != 2)
elog(ERROR, "join operator should take two arguments");
left = (Node *) linitial(args);
@ -3654,7 +3654,7 @@ prefix_selectivity(Query *root, VariableStatData *vardata,
BTGreaterEqualStrategyNumber);
if (cmpopr == InvalidOid)
elog(ERROR, "no >= operator for opclass %u", opclass);
cmpargs = makeList2(vardata->var, prefixcon);
cmpargs = list_make2(vardata->var, prefixcon);
/* Assume scalargtsel is appropriate for all supported types */
prefixsel = DatumGetFloat8(DirectFunctionCall4(scalargtsel,
PointerGetDatum(root),
@ -3676,7 +3676,7 @@ prefix_selectivity(Query *root, VariableStatData *vardata,
BTLessStrategyNumber);
if (cmpopr == InvalidOid)
elog(ERROR, "no < operator for opclass %u", opclass);
cmpargs = makeList2(vardata->var, greaterstrcon);
cmpargs = list_make2(vardata->var, greaterstrcon);
/* Assume scalarltsel is appropriate for all supported types */
topsel = DatumGetFloat8(DirectFunctionCall4(scalarltsel,
PointerGetDatum(root),
@ -4177,7 +4177,7 @@ genericcostestimate(Query *root, RelOptInfo *rel,
* eliminating duplicates is a bit trickier because indexQuals contains
* RestrictInfo nodes and the indpred does not. It is okay to pass a
* mixed list to clauselist_selectivity, but we have to work a bit to
* generate a list without logical duplicates. (We could just set_union
* generate a list without logical duplicates. (We could just list_union
* indpred and strippedQuals, but then we'd not get caching of per-qual
* selectivity estimates.)
*/
@ -4187,8 +4187,8 @@ genericcostestimate(Query *root, RelOptInfo *rel,
List *predExtraQuals;
strippedQuals = get_actual_clauses(indexQuals);
predExtraQuals = set_difference(index->indpred, strippedQuals);
selectivityQuals = nconc(predExtraQuals, indexQuals);
predExtraQuals = list_difference(index->indpred, strippedQuals);
selectivityQuals = list_concat(predExtraQuals, indexQuals);
}
else
selectivityQuals = indexQuals;
@ -4253,7 +4253,7 @@ genericcostestimate(Query *root, RelOptInfo *rel,
* inaccuracies here ...
*/
cost_qual_eval(&index_qual_cost, indexQuals);
qual_op_cost = cpu_operator_cost * length(indexQuals);
qual_op_cost = cpu_operator_cost * list_length(indexQuals);
qual_arg_cost = index_qual_cost.startup +
index_qual_cost.per_tuple - qual_op_cost;
if (qual_arg_cost < 0) /* just in case... */

4
src/backend/utils/adt/tid.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/utils/adt/tid.c,v 1.44 2004/05/26 04:41:39 neilc Exp $
* $PostgreSQL: pgsql/src/backend/utils/adt/tid.c,v 1.45 2004/05/30 23:40:36 neilc Exp $
*
* NOTES
* input routine largely stolen from boxin().
@ -239,7 +239,7 @@ currtid_for_view(Relation viewrel, ItemPointer tid)
Query *query;
TargetEntry *tle;
if (length(rewrite->actions) != 1)
if (list_length(rewrite->actions) != 1)
elog(ERROR, "only one select rule is allowed in views");
query = (Query *) linitial(rewrite->actions);
tle = get_tle_by_resno(query->targetList, tididx+1);

4
src/backend/utils/adt/varlena.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/utils/adt/varlena.c,v 1.113 2004/05/26 04:41:39 neilc Exp $
* $PostgreSQL: pgsql/src/backend/utils/adt/varlena.c,v 1.114 2004/05/30 23:40:36 neilc Exp $
*
*-------------------------------------------------------------------------
*/
@ -1648,7 +1648,7 @@ textToQualifiedNameList(text *textval, const char *caller)
}
pfree(rawname);
freeList(namelist);
list_free(namelist);
return result;
}

24
src/backend/utils/cache/relcache.c vendored
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/utils/cache/relcache.c,v 1.203 2004/05/26 04:41:40 neilc Exp $
* $PostgreSQL: pgsql/src/backend/utils/cache/relcache.c,v 1.204 2004/05/30 23:40:37 neilc Exp $
*
*-------------------------------------------------------------------------
*/
@ -1658,7 +1658,7 @@ RelationClearRelation(Relation relation, bool rebuild)
pfree(relation->rd_am);
if (relation->rd_rel)
pfree(relation->rd_rel);
freeList(relation->rd_indexlist);
list_free(relation->rd_indexlist);
if (relation->rd_indexcxt)
MemoryContextDelete(relation->rd_indexcxt);
@ -1922,7 +1922,7 @@ RelationCacheInvalidate(void)
}
}
rebuildList = nconc(rebuildFirstList, rebuildList);
rebuildList = list_concat(rebuildFirstList, rebuildList);
/*
* Now zap any remaining smgr cache entries. This must happen before
@ -1937,7 +1937,7 @@ RelationCacheInvalidate(void)
relation = (Relation) lfirst(l);
RelationClearRelation(relation, true);
}
freeList(rebuildList);
list_free(rebuildList);
}
/*
@ -2024,7 +2024,7 @@ AtEOXact_RelationCache(bool commit)
*/
if (relation->rd_indexvalid == 2)
{
freeList(relation->rd_indexlist);
list_free(relation->rd_indexlist);
relation->rd_indexlist = NIL;
relation->rd_indexvalid = 0;
}
@ -2526,7 +2526,7 @@ RelationGetIndexList(Relation relation)
/* Quick exit if we already computed the list. */
if (relation->rd_indexvalid != 0)
return listCopy(relation->rd_indexlist);
return list_copy(relation->rd_indexlist);
/*
* We build the list we intend to return (in the caller's context)
@ -2558,7 +2558,7 @@ RelationGetIndexList(Relation relation)
/* Now save a copy of the completed list in the relcache entry. */
oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
relation->rd_indexlist = listCopy(result);
relation->rd_indexlist = list_copy(result);
relation->rd_indexvalid = 1;
MemoryContextSwitchTo(oldcxt);
@ -2619,10 +2619,10 @@ RelationSetIndexList(Relation relation, List *indexIds)
Assert(relation->rd_isnailed == 1);
/* Copy the list into the cache context (could fail for lack of mem) */
oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
indexIds = listCopy(indexIds);
indexIds = list_copy(indexIds);
MemoryContextSwitchTo(oldcxt);
/* Okay to replace old list */
freeList(relation->rd_indexlist);
list_free(relation->rd_indexlist);
relation->rd_indexlist = indexIds;
relation->rd_indexvalid = 2; /* mark list as forced */
}
@ -3083,7 +3083,7 @@ load_relcache_init_file(void)
{
RelationCacheInsert(rels[relno]);
/* also make a list of their OIDs, for RelationIdIsInInitFile */
initFileRelationIds = lconso(RelationGetRelid(rels[relno]),
initFileRelationIds = lcons_oid(RelationGetRelid(rels[relno]),
initFileRelationIds);
}
@ -3242,7 +3242,7 @@ write_relcache_init_file(void)
/* also make a list of their OIDs, for RelationIdIsInInitFile */
oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
initFileRelationIds = lconso(RelationGetRelid(rel),
initFileRelationIds = lcons_oid(RelationGetRelid(rel),
initFileRelationIds);
MemoryContextSwitchTo(oldcxt);
}
@ -3299,7 +3299,7 @@ write_relcache_init_file(void)
bool
RelationIdIsInInitFile(Oid relationId)
{
return oidMember(relationId, initFileRelationIds);
return list_member_oid(initFileRelationIds, relationId);
}
/*

6
src/backend/utils/fmgr/fmgr.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/utils/fmgr/fmgr.c,v 1.80 2004/01/19 02:06:41 tgl Exp $
* $PostgreSQL: pgsql/src/backend/utils/fmgr/fmgr.c,v 1.81 2004/05/30 23:40:37 neilc Exp $
*
*-------------------------------------------------------------------------
*/
@ -1794,10 +1794,10 @@ get_fn_expr_argtype(FmgrInfo *flinfo, int argnum)
else
return InvalidOid;
if (argnum < 0 || argnum >= length(args))
if (argnum < 0 || argnum >= list_length(args))
return InvalidOid;
argtype = exprType((Node *) nth(argnum, args));
argtype = exprType((Node *) list_nth(args, argnum));
/*
* special hack for ScalarArrayOpExpr: what the underlying function

6
src/backend/utils/init/miscinit.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/utils/init/miscinit.c,v 1.125 2004/05/26 04:41:43 neilc Exp $
* $PostgreSQL: pgsql/src/backend/utils/init/miscinit.c,v 1.126 2004/05/30 23:40:38 neilc Exp $
*
*-------------------------------------------------------------------------
*/
@ -896,7 +896,7 @@ process_preload_libraries(char *preload_libraries_string)
{
/* syntax error in list */
pfree(rawstring);
freeList(elemlist);
list_free(elemlist);
ereport(LOG,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("invalid list syntax for parameter \"preload_libraries\"")));
@ -957,5 +957,5 @@ process_preload_libraries(char *preload_libraries_string)
}
pfree(rawstring);
freeList(elemlist);
list_free(elemlist);
}

8
src/backend/utils/misc/guc.c
View File

@ -10,7 +10,7 @@
* Written by Peter Eisentraut <peter_e@gmx.net>.
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/utils/misc/guc.c,v 1.209 2004/05/29 22:48:21 tgl Exp $
* $PostgreSQL: pgsql/src/backend/utils/misc/guc.c,v 1.210 2004/05/30 23:40:38 neilc Exp $
*
*--------------------------------------------------------------------
*/
@ -4761,7 +4761,7 @@ assign_log_destination(const char *value, bool doit, GucSource source)
{
/* syntax error in list */
pfree(rawstring);
freeList(elemlist);
list_free(elemlist);
if (source >= PGC_S_INTERACTIVE)
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
@ -4790,13 +4790,13 @@ assign_log_destination(const char *value, bool doit, GucSource source)
errmsg("unrecognised \"log_destination\" key word: \"%s\"",
tok)));
pfree(rawstring);
freeList(elemlist);
list_free(elemlist);
return NULL;
}
}
pfree(rawstring);
freeList(elemlist);
list_free(elemlist);
/* If we aren't going to do the assignment, just return OK indicator. */
if (!doit)

4
src/backend/utils/mmgr/portalmem.c
View File

@ -12,7 +12,7 @@
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/utils/mmgr/portalmem.c,v 1.64 2004/02/03 17:34:03 tgl Exp $
* $PostgreSQL: pgsql/src/backend/utils/mmgr/portalmem.c,v 1.65 2004/05/30 23:40:39 neilc Exp $
*
*-------------------------------------------------------------------------
*/
@ -245,7 +245,7 @@ PortalDefineQuery(Portal portal,
AssertArg(PortalIsValid(portal));
AssertState(portal->queryContext == NULL); /* else defined already */
Assert(length(parseTrees) == length(planTrees));
Assert(list_length(parseTrees) == list_length(planTrees));
Assert(commandTag != NULL || parseTrees == NIL);

40
src/include/nodes/pg_list.h
View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $PostgreSQL: pgsql/src/include/nodes/pg_list.h,v 1.45 2004/05/26 19:30:17 tgl Exp $
* $PostgreSQL: pgsql/src/include/nodes/pg_list.h,v 1.46 2004/05/30 23:40:39 neilc Exp $
*
*-------------------------------------------------------------------------
*/
@ -16,15 +16,6 @@
#include "nodes/nodes.h"
/*
* As a temporary measure, enable the compatibility API unless the
* include site specifically disabled it. Once the rest of the source
* tree has been converted to the new API, this will be removed.
*/
#ifndef DISABLE_LIST_COMPAT
#define ENABLE_LIST_COMPAT
#endif
/*
* This package implements singly-linked homogeneous lists. It is
* important to have constant-time length, append, and prepend
@ -50,15 +41,14 @@
*/
typedef struct ListCell ListCell;
typedef struct List List;
struct List
typedef struct List
{
NodeTag type; /* T_List, T_IntList, or T_OidList */
int length;
ListCell *head;
ListCell *tail;
};
ListCell *head;
ListCell *tail;
} List;
struct ListCell
{
@ -132,6 +122,10 @@ extern int list_length(List *l);
#define linitial_int(l) lfirst_int(list_head(l))
#define linitial_oid(l) lfirst_oid(list_head(l))
#define llast(l) lfirst(list_tail(l))
#define llast_int(l) lfirst_int(list_tail(l))
#define llast_oid(l) lfirst_oid(list_tail(l))
#define lsecond(l) lfirst(lnext(list_head(l)))
#define lsecond_int(l) lfirst_int(lnext(list_head(l)))
#define lsecond_oid(l) lfirst_oid(lnext(list_head(l)))
@ -183,7 +177,7 @@ extern int list_length(List *l);
* simultaneously. This macro loops through both lists at the same
* time, stopping when either list runs out of elements. Depending
* on the requirements of the call site, it may also be wise to
* ensure that the lengths of the two lists are equal.
* assert that the lengths of the two lists are equal.
*/
#define forboth(cell1, list1, cell2, list2) \
for ((cell1) = list_head(list1), (cell2) = list_head(list2); \
@ -249,8 +243,6 @@ extern List *list_copy_tail(List *list, int nskip);
#define lfirsti(lc) lfirst_int(lc)
#define lfirsto(lc) lfirst_oid(lc)
#define llast(l) lfirst(list_tail(l))
#define makeList1(x1) list_make1(x1)
#define makeList2(x1, x2) list_make2(x1, x2)
#define makeList3(x1, x2, x3) list_make3(x1, x2, x3)
@ -307,21 +299,13 @@ extern List *list_copy_tail(List *list, int nskip);
extern int length(List *list);
#endif
#endif /* ENABLE_LIST_COMPAT */
/*
* Temporary hack: we define the FastList type whether the
* compatibility API is enabled or not, since this allows files that
* don't use the compatibility API to include headers that reference
* the FastList type without an error.
*/
typedef struct FastList
{
List *list;
} FastList;
#ifdef ENABLE_LIST_COMPAT
extern void FastListInit(FastList *fl);
extern void FastListFromList(FastList *fl, List *list);
extern List *FastListValue(FastList *fl);
@ -332,6 +316,4 @@ extern void FastAppendo(FastList *fl, Oid datum);
extern void FastConc(FastList *fl, List *cells);
extern void FastConcFast(FastList *fl1, FastList *fl2);
#endif
#endif /* PG_LIST_H */

6
src/include/nodes/primnodes.h
View File

@ -10,7 +10,7 @@
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $PostgreSQL: pgsql/src/include/nodes/primnodes.h,v 1.98 2004/05/10 22:44:49 tgl Exp $
* $PostgreSQL: pgsql/src/include/nodes/primnodes.h,v 1.99 2004/05/30 23:40:39 neilc Exp $
*
*-------------------------------------------------------------------------
*/
@ -42,8 +42,8 @@
* transforms INSERT/UPDATE tlists into a normalized form with exactly
* one entry for each column of the destination table. Before that's
* happened, however, it is risky to assume that resno == position.
* Generally get_tle_by_resno() should be used rather than nth() to fetch
* tlist entries by resno.
* Generally get_tle_by_resno() should be used rather than list_nth()
* to fetch tlist entries by resno.
*
* resname is required to represent the correct column name in non-resjunk
* entries of top-level SELECT targetlists, since it will be used as the

4
src/interfaces/ecpg/preproc/preproc.y
View File

@ -1,4 +1,4 @@
/* $PostgreSQL: pgsql/src/interfaces/ecpg/preproc/preproc.y,v 1.284 2004/05/26 13:57:04 momjian Exp $ */
/* $PostgreSQL: pgsql/src/interfaces/ecpg/preproc/preproc.y,v 1.285 2004/05/30 23:40:40 neilc Exp $ */
/* Copyright comment */
%{
@ -4093,7 +4093,7 @@ file_name: StringConst { $$ = $1; };
/* func_name will soon return a List ... but not yet */
/*
func_name: function_name
{ $$ = makeList1(makeString($1)); }
{ $$ = list_make1(makeString($1)); }
| dotted_name
{ $$ = $1; }
;

6
src/pl/plpgsql/src/pl_exec.c
View File

@ -3,7 +3,7 @@
* procedural language
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/pl/plpgsql/src/pl_exec.c,v 1.101 2004/05/26 04:41:48 neilc Exp $
* $PostgreSQL: pgsql/src/pl/plpgsql/src/pl_exec.c,v 1.102 2004/05/30 23:40:41 neilc Exp $
*
* This software is copyrighted by Jan Wieck - Hamburg.
*
@ -3835,7 +3835,7 @@ exec_simple_check_plan(PLpgSQL_expr * expr)
* 1. We can only evaluate queries that resulted in one single
* execution plan
*/
if (length(spi_plan->ptlist) != 1)
if (list_length(spi_plan->ptlist) != 1)
return;
plan = (Plan *) linitial(spi_plan->ptlist);
@ -3862,7 +3862,7 @@ exec_simple_check_plan(PLpgSQL_expr * expr)
/*
* 4. The plan must have a single attribute as result
*/
if (length(plan->targetlist) != 1)
if (list_length(plan->targetlist) != 1)
return;
tle = (TargetEntry *) linitial(plan->targetlist);

6
src/pl/tcl/pltcl.c
View File

@ -31,7 +31,7 @@
* ENHANCEMENTS, OR MODIFICATIONS.
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/pl/tcl/pltcl.c,v 1.84 2004/05/26 04:41:50 neilc Exp $
* $PostgreSQL: pgsql/src/pl/tcl/pltcl.c,v 1.85 2004/05/30 23:40:41 neilc Exp $
*
**********************************************************************/
@ -1868,9 +1868,9 @@ pltcl_SPI_prepare(ClientData cdata, Tcl_Interp *interp,
qdesc->argtypelems[i] = ((Form_pg_type) GETSTRUCT(typeTup))->typelem;
ReleaseSysCache(typeTup);
freeList(typename->names);
list_free(typename->names);
pfree(typename);
freeList(names);
list_free(names);
pfree(argcopy);
}