return the i'th element in list.
lconsi, ...
- There are integer versions of these: lconsi, lappendi, nthi.
- List's containing integers instead of Node pointers are used to
- hold list of relation object id's and other integer quantities.
+ There are integer versions of these: lconsi, lappendi, etc.
+ Also versions for OID lists: lconso, lappendo, etc.
You can print nodes easily inside gdb. First, to disable output
truncation when you use the gdb print command:
<DT>lconsi, ...</DT>
- <DD>There are integer versions of these: <I>lconsi, lappendi,
- nthi.</I> <I>List's</I> containing integers instead of Node
- pointers are used to hold list of relation object id's and
- other integer quantities.</DD>
+ <DD>There are integer versions of these: <I>lconsi, lappendi</I>,
+ etc. Also versions for OID lists: <I>lconso, lappendo</I>, etc.</DD>
</DL>
</BLOCKQUOTE>
You can print nodes easily inside <I>gdb.</I> First, to disable
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/catalog/dependency.c,v 1.20 2003/02/07 01:33:06 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/catalog/dependency.c,v 1.21 2003/02/09 06:56:26 tgl Exp $
*
*-------------------------------------------------------------------------
*/
foreach(opid, sublink->operOids)
{
- add_object_address(OCLASS_OPERATOR, (Oid) lfirsti(opid), 0,
+ add_object_address(OCLASS_OPERATOR, lfirsto(opid), 0,
&context->addrs);
}
/* fall through to examine arguments */
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/catalog/namespace.c,v 1.46 2003/02/07 01:33:06 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/catalog/namespace.c,v 1.47 2003/02/09 06:56:26 tgl Exp $
*
*-------------------------------------------------------------------------
*/
foreach(lptr, namespaceSearchPath)
{
- Oid namespaceId = (Oid) lfirsti(lptr);
+ Oid namespaceId = lfirsto(lptr);
relid = get_relname_relid(relname, namespaceId);
if (OidIsValid(relid))
/*
* Quick check: if it ain't in the path at all, it ain't visible.
* Items in the system namespace are surely in the path and so we
- * needn't even do intMember() for them.
+ * needn't even do oidMember() for them.
*/
relnamespace = relform->relnamespace;
if (relnamespace != PG_CATALOG_NAMESPACE &&
- !intMember(relnamespace, namespaceSearchPath))
+ !oidMember(relnamespace, namespaceSearchPath))
visible = false;
else
{
foreach(lptr, namespaceSearchPath)
{
- Oid namespaceId = (Oid) lfirsti(lptr);
+ Oid namespaceId = lfirsto(lptr);
typid = GetSysCacheOid(TYPENAMENSP,
PointerGetDatum(typname),
/*
* Quick check: if it ain't in the path at all, it ain't visible.
* Items in the system namespace are surely in the path and so we
- * needn't even do intMember() for them.
+ * needn't even do oidMember() for them.
*/
typnamespace = typform->typnamespace;
if (typnamespace != PG_CATALOG_NAMESPACE &&
- !intMember(typnamespace, namespaceSearchPath))
+ !oidMember(typnamespace, namespaceSearchPath))
visible = false;
else
{
foreach(nsp, namespaceSearchPath)
{
- if (procform->pronamespace == (Oid) lfirsti(nsp))
+ if (procform->pronamespace == lfirsto(nsp))
break;
pathpos++;
}
/*
* Quick check: if it ain't in the path at all, it ain't visible.
* Items in the system namespace are surely in the path and so we
- * needn't even do intMember() for them.
+ * needn't even do oidMember() for them.
*/
pronamespace = procform->pronamespace;
if (pronamespace != PG_CATALOG_NAMESPACE &&
- !intMember(pronamespace, namespaceSearchPath))
+ !oidMember(pronamespace, namespaceSearchPath))
visible = false;
else
{
foreach(nsp, namespaceSearchPath)
{
- if (operform->oprnamespace == (Oid) lfirsti(nsp))
+ if (operform->oprnamespace == lfirsto(nsp))
break;
pathpos++;
}
/*
* Quick check: if it ain't in the path at all, it ain't visible.
* Items in the system namespace are surely in the path and so we
- * needn't even do intMember() for them.
+ * needn't even do oidMember() for them.
*/
oprnamespace = oprform->oprnamespace;
if (oprnamespace != PG_CATALOG_NAMESPACE &&
- !intMember(oprnamespace, namespaceSearchPath))
+ !oidMember(oprnamespace, namespaceSearchPath))
visible = false;
else
{
/* Consider only opclasses that are in the search path */
foreach(nsp, namespaceSearchPath)
{
- if (opcform->opcnamespace == (Oid) lfirsti(nsp))
+ if (opcform->opcnamespace == lfirsto(nsp))
break;
pathpos++;
}
foreach(lptr, namespaceSearchPath)
{
- Oid namespaceId = (Oid) lfirsti(lptr);
+ Oid namespaceId = lfirsto(lptr);
opcid = GetSysCacheOid(CLAAMNAMENSP,
ObjectIdGetDatum(amid),
/*
* Quick check: if it ain't in the path at all, it ain't visible.
* Items in the system namespace are surely in the path and so we
- * needn't even do intMember() for them.
+ * needn't even do oidMember() for them.
*/
opcnamespace = opcform->opcnamespace;
if (opcnamespace != PG_CATALOG_NAMESPACE &&
- !intMember(opcnamespace, namespaceSearchPath))
+ !oidMember(opcnamespace, namespaceSearchPath))
visible = false;
else
{
foreach(lptr, namespaceSearchPath)
{
- Oid namespaceId = (Oid) lfirsti(lptr);
+ Oid namespaceId = lfirsto(lptr);
conid = GetSysCacheOid(CONNAMENSP,
PointerGetDatum(conname),
/*
* Quick check: if it ain't in the path at all, it ain't visible.
* Items in the system namespace are surely in the path and so we
- * needn't even do intMember() for them.
+ * needn't even do oidMember() for them.
*/
connamespace = conform->connamespace;
if (connamespace != PG_CATALOG_NAMESPACE &&
- !intMember(connamespace, namespaceSearchPath))
+ !oidMember(connamespace, namespaceSearchPath))
visible = false;
else
{
case 3:
catalogname = strVal(lfirst(names));
schemaname = strVal(lsecond(names));
- objname = strVal(lfirst(lnext(lnext(names))));
+ objname = strVal(lthird(names));
/*
* We check the catalog name and then ignore it.
case 3:
rel->catalogname = strVal(lfirst(names));
rel->schemaname = strVal(lsecond(names));
- rel->relname = strVal(lfirst(lnext(lnext(names))));
+ rel->relname = strVal(lthird(names));
break;
default:
elog(ERROR, "Improper relation name (too many dotted names)");
foreach(lptr, namespaceSearchPath)
{
- namespaceId = (Oid) lfirsti(lptr);
+ namespaceId = lfirsto(lptr);
conoid = FindConversion(conversion_name, namespaceId);
if (OidIsValid(conoid))
return conoid;
foreach(lptr, namespaceSearchPath)
{
- Oid namespaceId = (Oid) lfirsti(lptr);
+ Oid namespaceId = lfirsto(lptr);
proc = FindDefaultConversion(namespaceId, for_encoding, to_encoding);
if (OidIsValid(proc))
0, 0, 0);
ReleaseSysCache(tuple);
if (OidIsValid(namespaceId) &&
- !intMember(namespaceId, oidlist) &&
+ !oidMember(namespaceId, oidlist) &&
pg_namespace_aclcheck(namespaceId, userId,
ACL_USAGE) == ACLCHECK_OK)
- oidlist = lappendi(oidlist, namespaceId);
+ oidlist = lappendo(oidlist, namespaceId);
}
}
else
CStringGetDatum(curname),
0, 0, 0);
if (OidIsValid(namespaceId) &&
- !intMember(namespaceId, oidlist) &&
+ !oidMember(namespaceId, oidlist) &&
pg_namespace_aclcheck(namespaceId, userId,
ACL_USAGE) == ACLCHECK_OK)
- oidlist = lappendi(oidlist, namespaceId);
+ oidlist = lappendo(oidlist, namespaceId);
}
}
if (oidlist == NIL)
firstNS = InvalidOid;
else
- firstNS = (Oid) lfirsti(oidlist);
+ firstNS = lfirsto(oidlist);
/*
* Add any implicitly-searched namespaces to the list. Note these go
* on the front, not the back; also notice that we do not check USAGE
* permissions for these.
*/
- if (!intMember(PG_CATALOG_NAMESPACE, oidlist))
- oidlist = lconsi(PG_CATALOG_NAMESPACE, oidlist);
+ if (!oidMember(PG_CATALOG_NAMESPACE, oidlist))
+ oidlist = lconso(PG_CATALOG_NAMESPACE, oidlist);
if (OidIsValid(myTempNamespace) &&
- !intMember(myTempNamespace, oidlist))
- oidlist = lconsi(myTempNamespace, oidlist);
+ !oidMember(myTempNamespace, oidlist))
+ oidlist = lconso(myTempNamespace, oidlist);
if (OidIsValid(mySpecialNamespace) &&
- !intMember(mySpecialNamespace, oidlist))
- oidlist = lconsi(mySpecialNamespace, oidlist);
+ !oidMember(mySpecialNamespace, oidlist))
+ oidlist = lconso(mySpecialNamespace, oidlist);
/*
* Now that we've successfully built the new list of namespace OIDs,
MemoryContext oldcxt;
oldcxt = MemoryContextSwitchTo(TopMemoryContext);
- namespaceSearchPath = makeListi1(PG_CATALOG_NAMESPACE);
+ namespaceSearchPath = makeListo1(PG_CATALOG_NAMESPACE);
MemoryContextSwitchTo(oldcxt);
defaultCreationNamespace = PG_CATALOG_NAMESPACE;
firstExplicitNamespace = PG_CATALOG_NAMESPACE;
result = namespaceSearchPath;
if (!includeImplicit)
{
- while (result && (Oid) lfirsti(result) != firstExplicitNamespace)
+ while (result && lfirsto(result) != firstExplicitNamespace)
result = lnext(result);
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/cluster.c,v 1.104 2002/12/30 19:45:15 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/cluster.c,v 1.105 2003/02/09 06:56:26 tgl Exp $
*
*-------------------------------------------------------------------------
*/
HeapTuple idxtuple;
Form_pg_index indexForm;
- indexOid = lfirsti(index);
+ indexOid = lfirsto(index);
idxtuple = SearchSysCache(INDEXRELID,
ObjectIdGetDatum(indexOid),
0, 0, 0);
/* Ask the relcache to produce a list of the indexes of the old rel */
foreach(indlist, RelationGetIndexList(OldHeap))
{
- Oid indexOID = (Oid) lfirsti(indlist);
+ Oid indexOID = lfirsto(indlist);
HeapTuple indexTuple;
HeapTuple classTuple;
Form_pg_index indexForm;
* Portions Copyright (c) 1994-5, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/explain.c,v 1.101 2003/02/08 20:20:53 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/explain.c,v 1.102 2003/02/09 06:56:26 tgl Exp $
*
*-------------------------------------------------------------------------
*/
{
Relation relation;
- relation = index_open(lfirsti(l));
+ relation = index_open(lfirsto(l));
appendStringInfo(str, "%s%s",
(++i > 1) ? ", " : "",
quote_identifier(RelationGetRelationName(relation)));
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/tablecmds.c,v 1.65 2003/01/08 22:06:23 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/tablecmds.c,v 1.66 2003/02/09 06:56:26 tgl Exp $
*
*-------------------------------------------------------------------------
*/
* 'istemp' is TRUE if we are creating a temp relation.
*
* Output arguments:
- * 'supOids' receives an integer list of the OIDs of the parent relations.
+ * 'supOids' receives a list of the OIDs of the parent relations.
* 'supconstr' receives a list of constraints belonging to the parents,
* updated as necessary to be valid for the child.
* 'supHasOids' is set TRUE if any parent has OIDs, else it is set FALSE.
/*
* Reject duplications in the list of parents.
*/
- if (intMember(RelationGetRelid(relation), parentOids))
+ if (oidMember(RelationGetRelid(relation), parentOids))
elog(ERROR, "CREATE TABLE: inherited relation \"%s\" duplicated",
parent->relname);
- parentOids = lappendi(parentOids, RelationGetRelid(relation));
+ parentOids = lappendo(parentOids, RelationGetRelid(relation));
setRelhassubclassInRelation(RelationGetRelid(relation), true);
parentHasOids |= relation->rd_rel->relhasoids;
* StoreCatalogInheritance
* Updates the system catalogs with proper inheritance information.
*
- * supers is an integer list of the OIDs of the new relation's direct
- * ancestors. NB: it is destructively changed to include indirect ancestors.
+ * supers is a list of the OIDs of the new relation's direct ancestors.
+ * NB: it is destructively changed to include indirect ancestors.
*/
static void
StoreCatalogInheritance(Oid relationId, List *supers)
seqNumber = 1;
foreach(entry, supers)
{
- Oid entryOid = lfirsti(entry);
+ Oid entryOid = lfirsto(entry);
Datum datum[Natts_pg_inherits];
char nullarr[Natts_pg_inherits];
ObjectAddress childobject,
*/
foreach(entry, supers)
{
+ Oid id = lfirsto(entry);
HeapTuple tuple;
- Oid id;
int16 number;
- List *next;
List *current;
+ List *next;
- id = (Oid) lfirsti(entry);
current = entry;
next = lnext(entry);
if (!HeapTupleIsValid(tuple))
break;
- lnext(current) = lconsi(((Form_pg_inherits)
+ lnext(current) = lconso(((Form_pg_inherits)
GETSTRUCT(tuple))->inhparent,
NIL);
+ current = lnext(current);
ReleaseSysCache(tuple);
-
- current = lnext(current);
}
lnext(current) = next;
}
List *rest;
again:
- thisone = lfirsti(entry);
found = false;
+ thisone = lfirsto(entry);
foreach(rest, lnext(entry))
{
- if (thisone == lfirsti(rest))
+ if (thisone == lfirsto(rest))
{
found = true;
break;
/*
* found a later duplicate, so remove this entry.
*/
- lfirsti(entry) = lfirsti(lnext(entry));
+ lfirsto(entry) = lfirsto(lnext(entry));
lnext(entry) = lnext(lnext(entry));
goto again;
*/
foreach(child, children)
{
- Oid childrelid = lfirsti(child);
+ Oid childrelid = lfirsto(child);
if (childrelid == myrelid)
continue;
foreach(indexoidscan, indexoidlist)
{
- Oid indexoid = lfirsti(indexoidscan);
+ Oid indexoid = lfirsto(indexoidscan);
HeapTuple indextup;
/*
foreach(child, children)
{
- Oid childrelid = lfirsti(child);
+ Oid childrelid = lfirsto(child);
HeapTuple tuple;
Form_pg_attribute childatt;
Relation childrel;
*/
foreach(child, children)
{
- Oid childrelid = lfirsti(child);
+ Oid childrelid = lfirsto(child);
if (childrelid == myrelid)
continue;
foreach(indexoidscan, indexoidlist)
{
- Oid indexoid = lfirsti(indexoidscan);
+ Oid indexoid = lfirsto(indexoidscan);
HeapTuple indexTuple;
Form_pg_index indexStruct;
int i;
*/
foreach(child, children)
{
- Oid childrelid = lfirsti(child);
+ Oid childrelid = lfirsto(child);
if (childrelid == myrelid)
continue;
*/
foreach(child, children)
{
- Oid childrelid = lfirsti(child);
+ Oid childrelid = lfirsto(child);
if (childrelid == myrelid)
continue;
*/
foreach(child, children)
{
- Oid childrelid = lfirsti(child);
+ Oid childrelid = lfirsto(child);
if (childrelid == myrelid)
continue;
attr_rel = heap_openr(AttributeRelationName, RowExclusiveLock);
foreach(child, children)
{
- Oid childrelid = lfirsti(child);
+ Oid childrelid = lfirsto(child);
Relation childrel;
HeapTuple tuple;
Form_pg_attribute childatt;
attr_rel = heap_openr(AttributeRelationName, RowExclusiveLock);
foreach(child, children)
{
- Oid childrelid = lfirsti(child);
+ Oid childrelid = lfirsto(child);
Relation childrel;
HeapTuple tuple;
Form_pg_attribute childatt;
*/
foreach(child, children)
{
- Oid childrelid = lfirsti(child);
+ Oid childrelid = lfirsto(child);
if (childrelid == myrelid)
continue;
foreach(indexoidscan, indexoidlist)
{
- Oid indexoid = lfirsti(indexoidscan);
+ Oid indexoid = lfirsto(indexoidscan);
indexTuple = SearchSysCache(INDEXRELID,
ObjectIdGetDatum(indexoid),
Form_pg_index indexStruct;
int i, j;
- indexoid = lfirsti(indexoidscan);
+ indexoid = lfirsto(indexoidscan);
indexTuple = SearchSysCache(INDEXRELID,
ObjectIdGetDatum(indexoid),
0, 0, 0);
*/
foreach(child, children)
{
- Oid childrelid = lfirsti(child);
+ Oid childrelid = lfirsto(child);
Relation inhrel;
if (childrelid == myrelid)
/* For each index, recursively change its ownership */
foreach(i, index_oid_list)
- AlterTableOwner(lfirsti(i), newOwnerSysId);
+ AlterTableOwner(lfirsto(i), newOwnerSysId);
freeList(index_oid_list);
}
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/trigger.c,v 1.144 2003/01/08 22:29:23 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/trigger.c,v 1.145 2003/02/09 06:56:26 tgl Exp $
*
*-------------------------------------------------------------------------
*/
cname);
constr_oid = HeapTupleGetOid(htup);
- loid = lappendi(loid, constr_oid);
+ loid = lappendo(loid, constr_oid);
found = true;
}
foreach(ls, deftrig_trigstates)
{
state = (DeferredTriggerStatus) lfirst(ls);
- if (state->dts_tgoid == (Oid) lfirsti(l))
+ if (state->dts_tgoid == lfirsto(l))
{
state->dts_tgisdeferred = stmt->deferred;
found = true;
{
state = (DeferredTriggerStatus)
palloc(sizeof(DeferredTriggerStatusData));
- state->dts_tgoid = (Oid) lfirsti(l);
+ state->dts_tgoid = lfirsto(l);
state->dts_tgisdeferred = stmt->deferred;
deftrig_trigstates =
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/vacuum.c,v 1.246 2003/01/07 22:23:17 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/vacuum.c,v 1.247 2003/02/09 06:56:27 tgl Exp $
*
*-------------------------------------------------------------------------
*/
*/
foreach(cur, vrl)
{
- Oid relid = (Oid) lfirsti(cur);
+ Oid relid = lfirsto(cur);
if (vacstmt->vacuum)
{
/* Make a relation list entry for this guy */
oldcontext = MemoryContextSwitchTo(vac_context);
- vrl = lappendi(vrl, relid);
+ vrl = lappendo(vrl, relid);
MemoryContextSwitchTo(oldcontext);
}
else
{
/* Make a relation list entry for this guy */
oldcontext = MemoryContextSwitchTo(vac_context);
- vrl = lappendi(vrl, HeapTupleGetOid(tuple));
+ vrl = lappendo(vrl, HeapTupleGetOid(tuple));
MemoryContextSwitchTo(oldcontext);
}
i = 0;
foreach(indexoidscan, indexoidlist)
{
- Oid indexoid = lfirsti(indexoidscan);
+ Oid indexoid = lfirsto(indexoidscan);
(*Irel)[i] = index_open(indexoid);
i++;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/execUtils.c,v 1.97 2003/02/09 00:30:39 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/execUtils.c,v 1.98 2003/02/09 06:56:27 tgl Exp $
*
*-------------------------------------------------------------------------
*/
i = 0;
foreach(indexoidscan, indexoidlist)
{
- Oid indexOid = lfirsti(indexoidscan);
+ Oid indexOid = lfirsto(indexoidscan);
Relation indexDesc;
IndexInfo *ii;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/nodeIndexscan.c,v 1.78 2003/02/03 15:07:07 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/nodeIndexscan.c,v 1.79 2003/02/09 06:56:27 tgl Exp $
*
*-------------------------------------------------------------------------
*/
listscan = indxid;
for (i = 0; i < numIndices; i++)
{
- Oid indexOid = (Oid) lfirsti(listscan);
+ Oid indexOid = lfirsto(listscan);
indexDescs[i] = index_open(indexOid);
scanDescs[i] = index_beginscan(currentRelation,
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/copyfuncs.c,v 1.241 2003/02/09 00:30:39 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/copyfuncs.c,v 1.242 2003/02/09 06:56:27 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#define COPY_INTLIST_FIELD(fldname) \
(newnode->fldname = listCopy(from->fldname))
+/* Copy a field that is a pointer to a list of Oids */
+#define COPY_OIDLIST_FIELD(fldname) \
+ (newnode->fldname = listCopy(from->fldname))
+
/* Copy a field that is a pointer to a Bitmapset */
#define COPY_BITMAPSET_FIELD(fldname) \
(newnode->fldname = bms_copy(from->fldname))
* This copy function only copies the "cons-cells" of the list, not the
* pointed-to objects. (Use copyObject if you want a "deep" copy.)
*
- * We also use this function for copying lists of integers, which is
- * grotty but unlikely to break --- it could fail if sizeof(pointer)
- * is less than sizeof(int), but I don't know any such machines...
+ * We also use this function for copying lists of integers and Oids,
+ * which is notationally a bit ugly, but perfectly safe.
*
* Note that copyObject will surely coredump if applied to a list
- * of integers!
+ * of integers or Oids!
*/
List *
listCopy(List *list)
{
List *newlist,
- *l,
- *nl;
+ *oldl,
+ *newcell,
+ *prev;
/* rather ugly coding for speed... */
if (list == NIL)
return NIL;
- newlist = nl = makeList1(lfirst(list));
+ newcell = makeNode(List);
+ newcell->elem = list->elem;
+
+ newlist = prev = newcell;
- foreach(l, lnext(list))
+ foreach(oldl, lnext(list))
{
- lnext(nl) = makeList1(lfirst(l));
- nl = lnext(nl);
+ newcell = makeNode(List);
+ newcell->elem = oldl->elem;
+ prev->next = newcell;
+ prev = newcell;
}
+ prev->next = NIL;
+
return newlist;
}
/*
* copy remainder of node
*/
- COPY_INTLIST_FIELD(indxid);
+ COPY_OIDLIST_FIELD(indxid);
COPY_NODE_FIELD(indxqual);
COPY_NODE_FIELD(indxqualorig);
COPY_SCALAR_FIELD(indxorderdir);
COPY_SCALAR_FIELD(useOr);
COPY_NODE_FIELD(lefthand);
COPY_NODE_FIELD(operName);
- COPY_INTLIST_FIELD(operOids);
+ COPY_OIDLIST_FIELD(operOids);
COPY_NODE_FIELD(subselect);
return newnode;
COPY_SCALAR_FIELD(all);
COPY_NODE_FIELD(larg);
COPY_NODE_FIELD(rarg);
- COPY_INTLIST_FIELD(colTypes);
+ COPY_OIDLIST_FIELD(colTypes);
return newnode;
}
COPY_STRING_FIELD(name);
COPY_NODE_FIELD(argtypes);
- COPY_INTLIST_FIELD(argtype_oids);
+ COPY_OIDLIST_FIELD(argtype_oids);
COPY_NODE_FIELD(query);
return newnode;
case T_List:
{
List *list = from,
- *l,
- *nl;
+ *oldl,
+ *newcell,
+ *prev;
/* rather ugly coding for speed... */
/* Note the input list cannot be NIL if we got here. */
- nl = makeList1(copyObject(lfirst(list)));
- retval = nl;
+ newcell = makeNode(List);
+ lfirst(newcell) = copyObject(lfirst(list));
+
+ retval = (void *) newcell;
+ prev = newcell;
- foreach(l, lnext(list))
+ foreach(oldl, lnext(list))
{
- lnext(nl) = makeList1(copyObject(lfirst(l)));
- nl = lnext(nl);
+ newcell = makeNode(List);
+ lfirst(newcell) = copyObject(lfirst(oldl));
+ prev->next = newcell;
+ prev = newcell;
}
+ prev->next = NIL;
}
break;
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/equalfuncs.c,v 1.184 2003/02/08 20:20:53 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/equalfuncs.c,v 1.185 2003/02/09 06:56:27 tgl Exp $
*
*-------------------------------------------------------------------------
*/
return false; \
} while (0)
+/* Compare a field that is a pointer to a list of Oids */
+#define COMPARE_OIDLIST_FIELD(fldname) \
+ do { \
+ if (!equalo(a->fldname, b->fldname)) \
+ return false; \
+ } while (0)
+
/* Compare a field that is a pointer to a Bitmapset */
#define COMPARE_BITMAPSET_FIELD(fldname) \
do { \
COMPARE_SCALAR_FIELD(useOr);
COMPARE_NODE_FIELD(lefthand);
COMPARE_NODE_FIELD(operName);
- COMPARE_INTLIST_FIELD(operOids);
+ COMPARE_OIDLIST_FIELD(operOids);
COMPARE_NODE_FIELD(subselect);
return true;
COMPARE_SCALAR_FIELD(all);
COMPARE_NODE_FIELD(larg);
COMPARE_NODE_FIELD(rarg);
- COMPARE_INTLIST_FIELD(colTypes);
+ COMPARE_OIDLIST_FIELD(colTypes);
return true;
}
{
COMPARE_STRING_FIELD(name);
COMPARE_NODE_FIELD(argtypes);
- COMPARE_INTLIST_FIELD(argtype_oids);
+ COMPARE_OIDLIST_FIELD(argtype_oids);
COMPARE_NODE_FIELD(query);
return true;
/*-------------------------------------------------------------------------
*
* list.c
- * various list handling routines
+ * POSTGRES generic list package
+ *
*
* Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/list.c,v 1.47 2003/02/08 20:20:54 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/list.c,v 1.48 2003/02/09 06:56:27 tgl Exp $
*
* NOTES
* XXX a few of the following functions are duplicated to handle
}
/*
+ * lconso
+ *
+ * Same as lcons, but for Oid data
+ */
+List *
+lconso(Oid datum, List *list)
+{
+ List *l = makeNode(List);
+
+ lfirsto(l) = datum;
+ lnext(l) = list;
+ return l;
+}
+
+/*
* lappend
*
* Add obj to the end of list, or make a new list if 'list' is NIL
}
/*
+ * lappendo
+ *
+ * Same as lappend, but for Oids
+ */
+List *
+lappendo(List *list, Oid datum)
+{
+ return nconc(list, makeListo1(datum));
+}
+
+/*
* nconc
*
* Concat l2 on to the end of l1
if (l2 == NIL)
return l1;
if (l1 == l2)
- elog(ERROR, "tryout to nconc a list to itself");
+ elog(ERROR, "can't nconc a list to itself");
for (temp = l1; lnext(temp) != NIL; temp = lnext(temp))
;
nth(int n, List *l)
{
/* XXX assume list is long enough */
- while (n > 0)
+ while (n-- > 0)
{
l = lnext(l);
- n--;
}
return lfirst(l);
}
/*
- * nthi
- *
- * Same as nthi, but for integers
- */
-int
-nthi(int n, List *l)
-{
- /* XXX assume list is long enough */
- while (n > 0)
- {
- l = lnext(l);
- n--;
- }
- return lfirsti(l);
-}
-
-/* this is here solely for rt_store. Get rid of me some day! */
-void
-set_nth(List *l, int n, void *elem)
-{
- /* XXX assume list is long enough */
- while (n > 0)
- {
- l = lnext(l);
- n--;
- }
- lfirst(l) = elem;
-}
-
-/*
* length
*
* Get the length of l
*
* Free the List nodes of a list
* The pointed-to nodes, if any, are NOT freed.
- * This works for integer lists too.
+ * This works for integer and Oid lists too.
*/
void
freeList(List *list)
}
/*
+ * equalo
+ * compares two lists of Oids
+ */
+bool
+equalo(List *list1, List *list2)
+{
+ List *l;
+
+ foreach(l, list1)
+ {
+ if (list2 == NIL)
+ return false;
+ if (lfirsto(l) != lfirsto(list2))
+ return false;
+ list2 = lnext(list2);
+ }
+ if (list2 != NIL)
+ return false;
+ return true;
+}
+
+/*
* Generate the union of two lists,
* ie, l1 plus all members of l2 that are not already in l1.
*
return retval;
}
-/* set_union for integer lists */
+/* set_union for Oid lists */
List *
-set_unioni(List *l1, List *l2)
+set_uniono(List *l1, List *l2)
{
List *retval = listCopy(l1);
List *i;
foreach(i, l2)
{
- if (!intMember(lfirsti(i), retval))
- retval = lappendi(retval, lfirsti(i));
+ if (!oidMember(lfirsto(i), retval))
+ retval = lappendo(retval, lfirsto(i));
}
return retval;
}
* The result is a fresh List, but it points to the same member nodes
* as were in the inputs.
*/
+#ifdef NOT_USED
List *
set_intersect(List *l1, List *l2)
{
}
return retval;
}
-
-List *
-set_intersecti(List *l1, List *l2)
-{
- List *retval = NIL;
- List *i;
-
- foreach(i, l1)
- {
- if (intMember(lfirsti(i), l2))
- retval = lappendi(retval, lfirsti(i));
- }
- return retval;
-}
+#endif
/*
* member()
foreach(i, l2)
{
- if (l1 == ((void *) lfirst(i)))
+ if (l1 == lfirst(i))
return true;
}
return false;
}
/*
+ * membership test for Oid lists
+ */
+bool
+oidMember(Oid l1, List *l2)
+{
+ List *i;
+
+ foreach(i, l2)
+ {
+ if (l1 == lfirsto(i))
+ return true;
+ }
+ return false;
+}
+
+/*
* lremove
* Removes 'elem' from the linked list (destructively changing the list!).
+ * (If there is more than one equal list member, the first is removed.)
*
* This version matches 'elem' using simple pointer comparison.
* See also LispRemove.
/*
* LispRemove
* Removes 'elem' from the linked list (destructively changing the list!).
+ * (If there is more than one equal list member, the first is removed.)
*
* This version matches 'elem' using equal().
- * (If there is more than one equal list member, the first is removed.)
* See also lremove.
*/
List *
}
/*
- * set_differencei
+ * set_differenceo
*
- * Same as set_difference, but for integers
+ * Same as set_difference, but for Oid lists
*/
List *
-set_differencei(List *l1, List *l2)
+set_differenceo(List *l1, List *l2)
{
List *result = NIL;
List *i;
foreach(i, l1)
{
- if (!intMember(lfirsti(i), l2))
- result = lappendi(result, lfirsti(i));
+ if (!oidMember(lfirsto(i), l2))
+ result = lappendo(result, lfirsto(i));
}
return result;
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/outfuncs.c,v 1.197 2003/02/09 00:30:39 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/outfuncs.c,v 1.198 2003/02/09 06:56:27 tgl Exp $
*
* NOTES
* Every node type that can appear in stored rules' parsetrees *must*
appendStringInfoChar(str, '(');
foreach(l, list)
- appendStringInfo(str, " %u", (Oid) lfirsti(l));
+ appendStringInfo(str, " %u", lfirsto(l));
appendStringInfoChar(str, ')');
}
WRITE_BOOL_FIELD(useOr);
WRITE_NODE_FIELD(lefthand);
WRITE_NODE_FIELD(operName);
- WRITE_INTLIST_FIELD(operOids);
+ WRITE_OIDLIST_FIELD(operOids);
WRITE_NODE_FIELD(subselect);
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/readfuncs.c,v 1.147 2003/02/03 21:15:44 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/readfuncs.c,v 1.148 2003/02/09 06:56:27 tgl Exp $
*
* NOTES
* Path and Plan nodes do not have any readfuncs support, because we
*/
if (IsA(v, Integer))
{
- lfirsti(l) = (Oid) intVal(v);
+ lfirsto(l) = (Oid) intVal(v);
pfree(v);
}
else if (IsA(v, Float))
{
- lfirsti(l) = atooid(strVal(v));
+ lfirsto(l) = atooid(strVal(v));
pfree(strVal(v));
pfree(v);
}
READ_BOOL_FIELD(useOr);
READ_NODE_FIELD(lefthand);
READ_NODE_FIELD(operName);
- READ_INTLIST_FIELD(operOids);
+ READ_OIDLIST_FIELD(operOids);
READ_NODE_FIELD(subselect);
READ_DONE();
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/createplan.c,v 1.135 2003/02/08 20:20:54 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/createplan.c,v 1.136 2003/02/09 06:56:27 tgl Exp $
*
*-------------------------------------------------------------------------
*/
{
IndexOptInfo *index = (IndexOptInfo *) lfirst(ixinfo);
- indexids = lappendi(indexids, index->indexoid);
+ indexids = lappendo(indexids, index->indexoid);
}
/*
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/subselect.c,v 1.71 2003/02/09 00:30:39 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/subselect.c,v 1.72 2003/02/09 06:56:27 tgl Exp $
*
*-------------------------------------------------------------------------
*/
foreach(lst, operOids)
{
- Oid opid = (Oid) lfirsti(lst);
+ Oid opid = lfirsto(lst);
Node *leftop = lfirst(lefthand);
TargetEntry *te = lfirst(targetlist);
Node *rightop;
*/
foreach(opids, slink->operOids)
{
- Oid opid = (Oid) lfirsti(opids);
+ Oid opid = lfirsto(opids);
HeapTuple tup;
Form_pg_operator optup;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/prep/prepunion.c,v 1.89 2003/02/08 20:20:55 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/prep/prepunion.c,v 1.90 2003/02/09 06:56:27 tgl Exp $
*
*-------------------------------------------------------------------------
*/
* recurse_set_operations
* Recursively handle one step in a tree of set operations
*
- * colTypes: integer list of type OIDs of expected output columns
+ * colTypes: list of type OIDs of expected output columns
* junkOK: if true, child resjunk columns may be left in the result
* flag: if >= 0, add a resjunk output column indicating value of flag
* refnames_tlist: targetlist to take column names from
if (op->op == top_union->op &&
(op->all == top_union->all || op->all) &&
- equali(op->colTypes, top_union->colTypes))
+ equalo(op->colTypes, top_union->colTypes))
{
/* Same UNION, so fold children into parent's subplan list */
return nconc(recurse_union_children(op->larg, parse,
foreach(i, colTypes)
{
- Oid colType = (Oid) lfirsti(i);
+ Oid colType = lfirsto(i);
TargetEntry *inputtle = (TargetEntry *) lfirst(input_tlist);
TargetEntry *reftle = (TargetEntry *) lfirst(refnames_tlist);
int32 colTypmod;
if (subtle->resdom->resjunk)
continue;
Assert(curColType != NIL);
- if (subtle->resdom->restype == (Oid) lfirsti(curColType))
+ if (subtle->resdom->restype == lfirsto(curColType))
{
/* If first subplan, copy the typmod; else compare */
if (planl == input_plans)
colindex = 0;
foreach(curColType, colTypes)
{
- Oid colType = (Oid) lfirsti(curColType);
+ Oid colType = lfirsto(curColType);
int32 colTypmod = colTypmods[colindex++];
TargetEntry *reftle = (TargetEntry *) lfirst(refnames_tlist);
{
if (colTypes == NIL)
return false;
- if (tle->resdom->restype != (Oid) lfirsti(colTypes))
+ if (tle->resdom->restype != lfirsto(colTypes))
return false;
colTypes = lnext(colTypes);
}
/*
* find_all_inheritors -
- * Returns an integer list of relation OIDs including the given rel plus
+ * Returns a list of relation OIDs including the given rel plus
* all relations that inherit from it, directly or indirectly.
*/
List *
find_all_inheritors(Oid parentrel)
{
List *examined_relids = NIL;
- List *unexamined_relids = makeListi1(parentrel);
+ List *unexamined_relids = makeListo1(parentrel);
/*
* While the queue of unexamined relids is nonempty, remove the first
*/
while (unexamined_relids != NIL)
{
- Oid currentrel = lfirsti(unexamined_relids);
+ Oid currentrel = lfirsto(unexamined_relids);
List *currentchildren;
unexamined_relids = lnext(unexamined_relids);
- examined_relids = lappendi(examined_relids, currentrel);
+ examined_relids = lappendo(examined_relids, currentrel);
currentchildren = find_inheritance_children(currentrel);
/*
* into an infinite loop, though theoretically there can't be any
* cycles in the inheritance graph anyway.)
*/
- currentchildren = set_differencei(currentchildren, examined_relids);
- unexamined_relids = set_unioni(unexamined_relids, currentchildren);
+ currentchildren = set_differenceo(currentchildren, examined_relids);
+ unexamined_relids = set_uniono(unexamined_relids, currentchildren);
}
return examined_relids;
foreach(l, inhOIDs)
{
- Oid childOID = (Oid) lfirsti(l);
+ Oid childOID = lfirsto(l);
RangeTblEntry *childrte;
Index childRTindex;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/util/clauses.c,v 1.128 2003/02/08 20:20:55 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/util/clauses.c,v 1.129 2003/02/09 06:56:27 tgl Exp $
*
* HISTORY
* AUTHOR DATE MAJOR EVENT
foreach(opid, sublink->operOids)
{
- if (op_volatile((Oid) lfirsti(opid)) != PROVOLATILE_IMMUTABLE)
+ if (op_volatile(lfirsto(opid)) != PROVOLATILE_IMMUTABLE)
return true;
}
/* else fall through to check args */
foreach(opid, sublink->operOids)
{
- if (op_volatile((Oid) lfirsti(opid)) == PROVOLATILE_VOLATILE)
+ if (op_volatile(lfirsto(opid)) == PROVOLATILE_VOLATILE)
return true;
}
/* else fall through to check args */
foreach(opid, sublink->operOids)
{
- if (!op_strict((Oid) lfirsti(opid)))
+ if (!op_strict(lfirsto(opid)))
return true;
}
/* else fall through to check args */
return NULL;
/* Check for recursive function, and give up trying to expand if so */
- if (intMember(funcid, active_fns))
+ if (oidMember(funcid, active_fns))
return NULL;
/* Check permission to call function (fail later, if not) */
* add the current function to the context list of active functions.
*/
newexpr = eval_const_expressions_mutator(newexpr,
- lconsi(funcid, active_fns));
+ lconso(funcid, active_fns));
return (Expr *) newexpr;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/util/plancat.c,v 1.78 2003/02/08 20:20:55 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/util/plancat.c,v 1.79 2003/02/09 06:56:27 tgl Exp $
*
*-------------------------------------------------------------------------
*/
foreach(indexoidscan, indexoidlist)
{
- Oid indexoid = lfirsti(indexoidscan);
+ Oid indexoid = lfirsto(indexoidscan);
Relation indexRelation;
Form_pg_index index;
IndexOptInfo *info;
/*
* find_inheritance_children
*
- * Returns an integer list containing the OIDs of all relations which
+ * Returns a list containing the OIDs of all relations which
* inherit *directly* from the relation with OID 'inhparent'.
*
* XXX might be a good idea to create an index on pg_inherits' inhparent
while ((inheritsTuple = heap_getnext(scan, ForwardScanDirection)) != NULL)
{
inhrelid = ((Form_pg_inherits) GETSTRUCT(inheritsTuple))->inhrelid;
- list = lappendi(list, inhrelid);
+ list = lappendo(list, inhrelid);
}
heap_endscan(scan);
heap_close(relation, AccessShareLock);
* Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Header: /cvsroot/pgsql/src/backend/parser/analyze.c,v 1.260 2003/01/17 03:25:04 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/analyze.c,v 1.261 2003/02/09 06:56:28 tgl Exp $
*
*-------------------------------------------------------------------------
*/
lefttl = leftmostQuery->targetList;
foreach(dtlist, sostmt->colTypes)
{
- Oid colType = (Oid) lfirsti(dtlist);
+ Oid colType = lfirsto(dtlist);
Resdom *leftResdom = ((TargetEntry *) lfirst(lefttl))->resdom;
char *colName = pstrdup(leftResdom->resname);
Resdom *resdom;
op->colTypes = NIL;
while (lcoltypes != NIL)
{
- Oid lcoltype = (Oid) lfirsti(lcoltypes);
- Oid rcoltype = (Oid) lfirsti(rcoltypes);
+ Oid lcoltype = lfirsto(lcoltypes);
+ Oid rcoltype = lfirsto(rcoltypes);
Oid rescoltype;
- rescoltype = select_common_type(makeListi2(lcoltype, rcoltype),
+ rescoltype = select_common_type(makeListo2(lcoltype, rcoltype),
context);
- op->colTypes = lappendi(op->colTypes, rescoltype);
+ op->colTypes = lappendo(op->colTypes, rescoltype);
lcoltypes = lnext(lcoltypes);
rcoltypes = lnext(rcoltypes);
}
if (resnode->resjunk)
continue;
- result = lappendi(result, resnode->restype);
+ result = lappendo(result, resnode->restype);
}
return result;
}
TypeName *tn = lfirst(l);
Oid toid = typenameTypeId(tn);
- argtype_oids = lappendi(argtype_oids, toid);
+ argtype_oids = lappendo(argtype_oids, toid);
argtoids[i++] = toid;
}
}
elog(ERROR, "Cannot use aggregates in EXECUTE parameters");
given_type_id = exprType(expr);
- expected_type_id = (Oid) lfirsti(paramtypes);
+ expected_type_id = lfirsto(paramtypes);
expr = coerce_to_target_type(expr, given_type_id,
expected_type_id, -1,
foreach(indexoidscan, indexoidlist)
{
- Oid indexoid = lfirsti(indexoidscan);
+ Oid indexoid = lfirsto(indexoidscan);
HeapTuple indexTuple;
indexTuple = SearchSysCache(INDEXRELID,
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/gram.y,v 2.399 2003/02/05 20:16:42 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/gram.y,v 2.400 2003/02/09 06:56:28 tgl Exp $
*
* HISTORY
* AUTHOR DATE MAJOR EVENT
case 3:
r->catalogname = strVal(lfirst($3));
r->schemaname = strVal(lsecond($3));
- r->relname = strVal(lfirst(lnext(lnext($3))));
+ r->relname = strVal(lthird($3));
break;
default:
elog(ERROR,
case 3:
$$->catalogname = strVal(lfirst($1));
$$->schemaname = strVal(lsecond($1));
- $$->relname = strVal(lfirst(lnext(lnext($1))));
+ $$->relname = strVal(lthird($1));
break;
default:
elog(ERROR,
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_clause.c,v 1.104 2003/02/08 20:20:55 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_clause.c,v 1.105 2003/02/09 06:56:28 tgl Exp $
*
*-------------------------------------------------------------------------
*/
outcoltypmod = l_colvar->vartypmod;
if (outcoltype != r_colvar->vartype)
{
- outcoltype = select_common_type(makeListi2(l_colvar->vartype,
+ outcoltype = select_common_type(makeListo2(l_colvar->vartype,
r_colvar->vartype),
"JOIN/USING");
outcoltypmod = -1; /* ie, unknown */
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_coerce.c,v 2.92 2003/02/03 21:15:44 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_coerce.c,v 2.93 2003/02/09 06:56:28 tgl Exp $
*
*-------------------------------------------------------------------------
*/
* This is used for determining the output type of CASE and UNION
* constructs.
*
- * typeids is a nonempty integer list of type OIDs. Note that earlier items
+ * typeids is a nonempty list of type OIDs. Note that earlier items
* in the list will be preferred if there is doubt.
* 'context' is a phrase to use in the error message if we fail to select
* a usable type.
List *l;
Assert(typeids != NIL);
- ptype = (Oid) lfirsti(typeids);
+ ptype = lfirsto(typeids);
pcategory = TypeCategory(ptype);
foreach(l, lnext(typeids))
{
- Oid ntype = (Oid) lfirsti(l);
+ Oid ntype = lfirsto(l);
/* move on to next one if no new information... */
if ((ntype != InvalidOid) && (ntype != UNKNOWNOID) && (ntype != ptype))
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_expr.c,v 1.142 2003/02/03 21:15:44 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_expr.c,v 1.143 2003/02/09 06:56:28 tgl Exp $
*
*-------------------------------------------------------------------------
*/
" to be used with quantified predicate subquery",
opname);
- sublink->operOids = lappendi(sublink->operOids,
+ sublink->operOids = lappendo(sublink->operOids,
oprid(optup));
ReleaseSysCache(optup);
neww->result = (Expr *) transformExpr(pstate, warg);
newargs = lappend(newargs, neww);
- typeids = lappendi(typeids, exprType((Node *) neww->result));
+ typeids = lappendo(typeids, exprType((Node *) neww->result));
}
newc->args = newargs;
* code worked before, but it seems a little bogus to me
* --- tgl
*/
- typeids = lconsi(exprType((Node *) newc->defresult), typeids);
+ typeids = lconso(exprType((Node *) newc->defresult), typeids);
ptype = select_common_type(typeids, "CASE");
newc->casetype = ptype;
{
char *name1 = strVal(lfirst(cref->fields));
char *name2 = strVal(lsecond(cref->fields));
- char *name3 = strVal(lfirst(lnext(lnext(cref->fields))));
+ char *name3 = strVal(lthird(cref->fields));
/* Whole-row reference? */
if (strcmp(name3, "*") == 0)
{
char *name1 = strVal(lfirst(cref->fields));
char *name2 = strVal(lsecond(cref->fields));
- char *name3 = strVal(lfirst(lnext(lnext(cref->fields))));
- char *name4 = strVal(lfirst(lnext(lnext(lnext(cref->fields)))));
+ char *name3 = strVal(lthird(cref->fields));
+ char *name4 = strVal(lfourth(cref->fields));
/*
* We check the catalog name and then ignore it.
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_func.c,v 1.143 2002/12/12 15:49:39 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_func.c,v 1.144 2003/02/09 06:56:28 tgl Exp $
*
*-------------------------------------------------------------------------
*/
* Use queue to do a breadth-first traversal of the inheritance graph
* from the relid supplied up to the root. At the top of the loop,
* relid is the OID of the reltype to check next, queue is the list of
- * pending rels to check after this one, and visited is the list of
+ * pending relids to check after this one, and visited is the list of
* relids we need to output.
*/
do
{
Form_pg_inherits inh = (Form_pg_inherits) GETSTRUCT(inhtup);
- queue = lappendi(queue, inh->inhparent);
+ queue = lappendo(queue, inh->inhparent);
}
heap_endscan(inhscan);
newrelid = false;
while (queue != NIL)
{
- relid = lfirsti(queue);
+ relid = lfirsto(queue);
queue = lnext(queue);
- if (!intMember(relid, visited))
+ if (!oidMember(relid, visited))
{
newrelid = true;
break;
if (newrelid)
{
- visited = lappendi(visited, relid);
+ visited = lappendo(visited, relid);
nvisited++;
}
} while (newrelid);
foreach(elt, visited)
{
/* return the type id, rather than the relation id */
- *relidvec++ = get_rel_type_id((Oid) lfirsti(elt));
+ *relidvec++ = get_rel_type_id(lfirsto(elt));
}
}
else
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_target.c,v 1.94 2002/12/12 20:35:13 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_target.c,v 1.95 2003/02/09 06:56:28 tgl Exp $
*
*-------------------------------------------------------------------------
*/
if (strcmp(name1, DatabaseName) != 0)
elog(ERROR, "Cross-database references are not implemented");
schemaname = strVal(lsecond(fields));
- relname = strVal(lfirst(lnext(lnext(fields))));
+ relname = strVal(lthird(fields));
break;
}
default:
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_type.c,v 1.50 2002/09/04 20:31:24 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_type.c,v 1.51 2003/02/09 06:56:28 tgl Exp $
*
*-------------------------------------------------------------------------
*/
case 3:
rel->schemaname = strVal(lfirst(typename->names));
rel->relname = strVal(lsecond(typename->names));
- field = strVal(lfirst(lnext(lnext(typename->names))));
+ field = strVal(lthird(typename->names));
break;
case 4:
rel->catalogname = strVal(lfirst(typename->names));
rel->schemaname = strVal(lsecond(typename->names));
- rel->relname = strVal(lfirst(lnext(lnext(typename->names))));
- field = strVal(lfirst(lnext(lnext(lnext(typename->names)))));
+ rel->relname = strVal(lthird(typename->names));
+ field = strVal(lfourth(typename->names));
break;
default:
elog(ERROR, "Improper %%TYPE reference (too many dotted names): %s",
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/name.c,v 1.41 2002/09/04 20:31:28 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/name.c,v 1.42 2003/02/09 06:56:28 tgl Exp $
*
*-------------------------------------------------------------------------
*/
if (search_path == NIL)
PG_RETURN_NULL();
- nspname = get_namespace_name((Oid) lfirsti(search_path));
+ nspname = get_namespace_name(lfirsto(search_path));
PG_RETURN_DATUM(DirectFunctionCall1(namein, CStringGetDatum(nspname)));
}
{
char *nspname;
- nspname = get_namespace_name((Oid) lfirsti(search_path));
+ nspname = get_namespace_name(lfirsto(search_path));
names[i] = DirectFunctionCall1(namein, CStringGetDatum(nspname));
i++;
search_path = lnext(search_path);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/cache/relcache.c,v 1.183 2002/12/16 18:39:22 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/cache/relcache.c,v 1.184 2003/02/09 06:56:28 tgl Exp $
*
*-------------------------------------------------------------------------
*/
List *l;
/* Does the datum belong at the front? */
- if (list == NIL || datum < (Oid) lfirsti(list))
- return lconsi(datum, list);
+ if (list == NIL || datum < lfirsto(list))
+ return lconso(datum, list);
/* No, so find the entry it belongs after */
l = list;
for (;;)
{
List *n = lnext(l);
- if (n == NIL || datum < (Oid) lfirsti(n))
+ if (n == NIL || datum < lfirsto(n))
break; /* it belongs before n */
l = n;
}
/* Insert datum into list after item l */
- lnext(l) = lconsi(datum, lnext(l));
+ lnext(l) = lconso(datum, lnext(l));
return list;
}
{
RelationCacheInsert(rels[relno]);
/* also make a list of their OIDs, for RelationIdIsInInitFile */
- initFileRelationIds = lconsi((int) RelationGetRelid(rels[relno]),
+ initFileRelationIds = lconso(RelationGetRelid(rels[relno]),
initFileRelationIds);
}
/* also make a list of their OIDs, for RelationIdIsInInitFile */
oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
- initFileRelationIds = lconsi((int) RelationGetRelid(rel),
+ initFileRelationIds = lconso(RelationGetRelid(rel),
initFileRelationIds);
MemoryContextSwitchTo(oldcxt);
}
bool
RelationIdIsInInitFile(Oid relationId)
{
- return intMember((int) relationId, initFileRelationIds);
+ return oidMember(relationId, initFileRelationIds);
}
/*
* Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: parsenodes.h,v 1.227 2003/01/23 23:39:07 petere Exp $
+ * $Id: parsenodes.h,v 1.228 2003/02/09 06:56:28 tgl Exp $
*
*-------------------------------------------------------------------------
*/
/* Eventually add fields for CORRESPONDING spec here */
/* Fields derived during parse analysis: */
- List *colTypes; /* integer list of OIDs of output column
- * types */
+ List *colTypes; /* list of OIDs of output column types */
} SetOperationStmt;
* Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: pg_list.h,v 1.34 2003/02/08 20:20:55 tgl Exp $
+ * $Id: pg_list.h,v 1.35 2003/02/09 06:56:28 tgl Exp $
*
*-------------------------------------------------------------------------
*/
/*----------------------
* List node
+ *
+ * We support three types of lists:
+ * lists of pointers (in practice always pointers to Nodes, but declare as
+ * "void *" to minimize casting annoyances)
+ * lists of integers
+ * lists of Oids
+ *
+ * (At this writing, ints and Oids are the same size, but they may not always
+ * be so; try to be careful to maintain the distinction.)
*----------------------
*/
typedef struct List
{
void *ptr_value;
int int_value;
+ Oid oid_value;
} elem;
struct List *next;
} List;
/* ----------------
* accessor macros
+ *
+ * The general naming convention is that the base name xyz() is for the
+ * pointer version, xyzi() is for integers, xyzo() is for Oids. We don't
+ * bother with multiple names if the same routine can handle all cases.
* ----------------
*/
-/* anything that doesn't end in 'i' is assumed to be referring to the */
-/* pointer version of the list (where it makes a difference) */
#define lfirst(l) ((l)->elem.ptr_value)
+#define lfirsti(l) ((l)->elem.int_value)
+#define lfirsto(l) ((l)->elem.oid_value)
+
#define lnext(l) ((l)->next)
+
#define lsecond(l) lfirst(lnext(l))
-#define lfirsti(l) ((l)->elem.int_value)
+#define lthird(l) lfirst(lnext(lnext(l)))
+
+#define lfourth(l) lfirst(lnext(lnext(lnext(l))))
/*
* foreach -
* a convenience macro which loops through the list
*/
#define foreach(_elt_,_list_) \
- for(_elt_=(_list_); _elt_!=NIL; _elt_=lnext(_elt_))
+ for (_elt_ = (_list_); _elt_ != NIL; _elt_ = lnext(_elt_))
/*
* Convenience macros for building fixed-length lists
#define makeListi1(x1) lconsi(x1, NIL)
#define makeListi2(x1,x2) lconsi(x1, makeListi1(x2))
-#define makeListi3(x1,x2,x3) lconsi(x1, makeListi2(x2,x3))
-#define makeListi4(x1,x2,x3,x4) lconsi(x1, makeListi3(x2,x3,x4))
+
+#define makeListo1(x1) lconso(x1, NIL)
+#define makeListo2(x1,x2) lconso(x1, makeListo1(x2))
/*
* function prototypes in nodes/list.c
*/
-extern int length(List *list);
-extern void *llast(List *list);
-extern List *nconc(List *list1, List *list2);
-extern List *lcons(void *datum, List *list);
-extern List *lconsi(int datum, List *list);
-extern bool member(void *datum, List *list);
-extern bool ptrMember(void *datum, List *list);
-extern bool intMember(int datum, List *list);
extern Value *makeInteger(long i);
extern Value *makeFloat(char *numericStr);
extern Value *makeString(char *str);
extern Value *makeBitString(char *str);
+
+extern List *lcons(void *datum, List *list);
+extern List *lconsi(int datum, List *list);
+extern List *lconso(Oid datum, List *list);
extern List *lappend(List *list, void *datum);
extern List *lappendi(List *list, int datum);
+extern List *lappendo(List *list, Oid datum);
+extern List *nconc(List *list1, List *list2);
+extern void *nth(int n, List *l);
+extern int length(List *list);
+extern void *llast(List *list);
+extern bool member(void *datum, List *list);
+extern bool ptrMember(void *datum, List *list);
+extern bool intMember(int datum, List *list);
+extern bool oidMember(Oid datum, List *list);
extern List *lremove(void *elem, List *list);
extern List *LispRemove(void *elem, List *list);
extern List *lremovei(int elem, List *list);
extern List *ltruncate(int n, List *list);
-extern void *nth(int n, List *l);
-extern int nthi(int n, List *l);
-extern void set_nth(List *l, int n, void *elem);
-
extern List *set_union(List *list1, List *list2);
-extern List *set_unioni(List *list1, List *list2);
+extern List *set_uniono(List *list1, List *list2);
extern List *set_ptrUnion(List *list1, List *list2);
-extern List *set_intersect(List *l1, List *l2);
-extern List *set_intersecti(List *list1, List *list2);
extern List *set_difference(List *list1, List *list2);
-extern List *set_differencei(List *list1, List *list2);
+extern List *set_differenceo(List *list1, List *list2);
extern List *set_ptrDifference(List *list1, List *list2);
extern bool equali(List *list1, List *list2);
+extern bool equalo(List *list1, List *list2);
extern void freeList(List *list);
-/* should be in nodes.h but needs List */
-
/* in copyfuncs.c */
extern List *listCopy(List *list);
* Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: parsetree.h,v 1.19 2002/09/04 20:31:45 momjian Exp $
+ * $Id: parsetree.h,v 1.20 2003/02/09 06:56:28 tgl Exp $
*
*-------------------------------------------------------------------------
*/
/*
* rt_fetch
- * rt_store
*
- * Access and (destructively) replace rangetable entries.
+ * NB: this will crash and burn if handed an out-of-range RT index
*/
#define rt_fetch(rangetable_index, rangetable) \
((RangeTblEntry *) nth((rangetable_index)-1, rangetable))
-#define rt_store(rangetable_index, rangetable, rt) \
- set_nth(rangetable, (rangetable_index)-1, rt)
-
/*
* getrelid
*
OSDN Git Service
