Skip to content

P
Postgres FD Implementation
Commit 51e29a2b authored by Tom Lane's avatar Tom Lane
Browse files
Options

LispUnion routine didn't generate a proper union: anytime 

l2 contained more than one entry, there would be duplicates in the output
list.  Miscellaneous code beautification in other routines, too.
parent 448d1ab0
Hide whitespace changes
Inline Side-by-side
Showing with 133 additions and 212 deletions
src/backend/nodes/list.c
View file @ 51e29a2b
......@@ -7,7 +7,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/nodes/list.c,v 1.25 1999/07/17 20:17:06 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/nodes/list.c,v 1.26 1999/08/14 19:29:35 tgl Exp $
*
* NOTES
* XXX a few of the following functions are duplicated to handle
......@@ -57,6 +57,45 @@ makeList(void *elem,...)
return retval;
}
/*
* makeInteger
*/
Value *
makeInteger(long i)
{
Value *v = makeNode(Value);
v->type = T_Integer;
v->val.ival = i;
return v;
}
/*
* makeFloat
*/
Value *
makeFloat(double d)
{
Value *v = makeNode(Value);
v->type = T_Float;
v->val.dval = d;
return v;
}
/*
* makeString
*/
Value *
makeString(char *str)
{
Value *v = makeNode(Value);
v->type = T_String;
v->val.str = str;
return v;
}
/*
* lcons
*
......@@ -115,6 +154,9 @@ lappendi(List *list, int datum)
* nconc
*
* Concat l2 on to the end of l1
*
* NB: l1 is destructively changed! Use nconc(listCopy(l1), l2)
* if you need to make a merged list without touching the original lists.
*/
List *
nconc(List *l1, List *l2)
......@@ -128,76 +170,13 @@ nconc(List *l1, List *l2)
if (l1 == l2)
elog(ERROR, "tryout to nconc a list to itself");
for (temp = l1; lnext(temp) != NULL; temp = lnext(temp))
for (temp = l1; lnext(temp) != NIL; temp = lnext(temp))
;
lnext(temp) = l2;
return l1; /* list1 is now list1+list2 */
}
#ifdef NOT_USED
List *
nreverse(List *list)
{
List *rlist = NIL;
List *p = NIL;
if (list == NULL)
return NIL;
if (length(list) == 1)
return list;
for (p = list; p != NULL; p = lnext(p))
rlist = lcons(lfirst(p), rlist);
lfirst(list) = lfirst(rlist);
lnext(list) = lnext(rlist);
return list;
}
#endif
/*
* makeInteger
*/
Value *
makeInteger(long i)
{
Value *v = makeNode(Value);
v->type = T_Integer;
v->val.ival = i;
return v;
}
/*
* makeFloat
*/
Value *
makeFloat(double d)
{
Value *v = makeNode(Value);
v->type = T_Float;
v->val.dval = d;
return v;
}
/*
* makeString
*/
Value *
makeString(char *str)
{
Value *v = makeNode(Value);
v->type = T_String;
v->val.str = str;
return v;
}
/*
* nth
*
......@@ -243,7 +222,6 @@ set_nth(List *l, int n, void *elem)
n--;
}
lfirst(l) = elem;
return;
}
/*
......@@ -268,6 +246,9 @@ length(List *l)
* freeList
*
* Free the List nodes of a list
* The pointed-to nodes, if any, are NOT freed.
* This works for integer lists too.
*
*/
void
freeList(List *list)
......@@ -281,73 +262,24 @@ freeList(List *list)
}
}
#ifdef NOT_USED
/*
* below are for backwards compatibility
*/
List *
append(List *l1, List *l2)
{
List *newlist,
*newlist2,
*p;
if (l1 == NIL)
return copyObject(l2);
newlist = copyObject(l1);
newlist2 = copyObject(l2);
for (p = newlist; lnext(p) != NIL; p = lnext(p))
;
lnext(p) = newlist2;
return newlist;
}
#endif
#ifdef NOT_USED
/*
* below are for backwards compatibility
*/
List *
intAppend(List *l1, List *l2)
{
List *newlist,
*newlist2,
*p;
if (l1 == NIL)
return listCopy(l2);
newlist = listCopy(l1);
newlist2 = listCopy(l2);
for (p = newlist; lnext(p) != NIL; p = lnext(p))
;
lnext(p) = newlist2;
return newlist;
}
#endif
/*
* same
*
* Returns t if two lists contain the same elements.
* now defined in lispdep.c
* Returns t if two lists contain the same elements
* (but unlike equal(), they need not be in the same order)
*
*
* XXX only good for IntList -ay
* XXX should be called samei() --- only good for IntList -ay
*/
bool
same(List *l1, List *l2)
{
List *temp = NIL;
List *temp;
if (l1 == NULL)
return l2 == NULL;
if (l2 == NULL)
return l1 == NULL;
if (l1 == NIL)
return l2 == NIL;
if (l2 == NIL)
return l1 == NIL;
if (length(l1) == length(l2))
{
foreach(temp, l1)
......@@ -361,70 +293,47 @@ same(List *l1, List *l2)
}
/*
* Generate the union of two lists,
* ie, l1 plus all members of l2 that are not already in l1.
*
* NOTE: if there are duplicates in l1 they will still be duplicate in the
* result; but duplicates in l2 are discarded.
*
* The result is a fresh List, but it points to the same member nodes
* as were in the inputs.
*/
List *
LispUnion(List *l1, List *l2)
{
List *retval = NIL;
List *i = NIL;
List *j = NIL;
if (l1 == NIL)
return l2; /* XXX - should be copy of l2 */
if (l2 == NIL)
return l1; /* XXX - should be copy of l1 */
List *retval = listCopy(l1);
List *i;
foreach(i, l1)
foreach(i, l2)
{
foreach(j, l2)
{
if (!equal(lfirst(i), lfirst(j)))
{
retval = lappend(retval, lfirst(i));
break;
}
}
if (! member(lfirst(i), retval))
retval = lappend(retval, lfirst(i));
}
foreach(i, l2)
retval = lappend(retval, lfirst(i));
return retval;
}
List *
LispUnioni(List *l1, List *l2)
{
List *retval = NIL;
List *i = NIL;
List *j = NIL;
if (l1 == NIL)
return l2; /* XXX - should be copy of l2 */
if (l2 == NIL)
return l1; /* XXX - should be copy of l1 */
List *retval = listCopy(l1);
List *i;
foreach(i, l1)
foreach(i, l2)
{
foreach(j, l2)
{
if (lfirsti(i) != lfirsti(j))
{
retval = lappendi(retval, lfirsti(i));
break;
}
}
if (! intMember(lfirsti(i), retval))
retval = lappendi(retval, lfirsti(i));
}
foreach(i, l2)
retval = lappendi(retval, lfirsti(i));
return retval;
}
/*
* member()
* - nondestructive, returns t iff l1 is a member of the list
* l2
* nondestructive, returns t iff l1 is a member of the list l2
*/
bool
member(void *l1, List *l2)
......@@ -432,8 +341,10 @@ member(void *l1, List *l2)
List *i;
foreach(i, l2)
{
if (equal((Node *) l1, (Node *) lfirst(i)))
return true;
return true;
}
return false;
}
......@@ -443,14 +354,18 @@ intMember(int l1, List *l2)
List *i;
foreach(i, l2)
{
if (l1 == lfirsti(i))
return true;
return true;
}
return false;
}
/*
* lremove -
* only does pointer comparisons. Removes 'elem' from the the linked list.
* lremove
* Removes 'elem' from the the linked list.
* This version matches 'elem' using simple pointer comparison.
* See also LispRemove.
*/
List *
lremove(void *elem, List *list)
......@@ -465,10 +380,10 @@ lremove(void *elem, List *list)
break;
prev = l;
}
if (l != NULL)
if (l != NIL)
{
if (prev == NIL)
result = lnext(list);
result = lnext(l);
else
lnext(prev) = lnext(l);
}
......@@ -477,54 +392,57 @@ lremove(void *elem, List *list)
/*
* LispRemove
* Removes 'elem' from the the linked list.
* This version matches 'elem' using equal().
* (If there is more than one equal list member, the first is removed.)
* See also lremove.
*/
List *
LispRemove(void *elem, List *list)
{
List *temp = NIL;
List *l;
List *prev = NIL;
List *result = list;
if (equal(elem, lfirst(list)))
return lnext(list);
temp = lnext(list);
prev = list;
while (temp != NIL)
foreach(l, list)
{
if (equal(elem, lfirst(temp)))
{
lnext(prev) = lnext(temp);
if (equal(elem, lfirst(l)))
break;
}
temp = lnext(temp);
prev = lnext(prev);
prev = l;
}
if (l != NIL)
{
if (prev == NIL)
result = lnext(l);
else
lnext(prev) = lnext(l);
}
return list;
return result;
}
#ifdef NOT_USED
List *
intLispRemove(int elem, List *list)
{
List *temp = NIL;
List *l;
List *prev = NIL;
List *result = list;
if (elem == lfirsti(list))
return lnext(list);
temp = lnext(list);
prev = list;
while (temp != NIL)
foreach(l, list)
{
if (elem == lfirsti(temp))
{
lnext(prev) = lnext(temp);
if (elem == lfirsti(l))
break;
}
temp = lnext(temp);
prev = lnext(prev);
prev = l;
}
if (l != NIL)
{
if (prev == NIL)
result = lnext(l);
else
lnext(prev) = lnext(l);
}
return list;
return result;
}
#endif
......@@ -533,20 +451,23 @@ intLispRemove(int elem, List *list)
* set_difference
*
* Return l1 without the elements in l2.
*
* The result is a fresh List, but it points to the same member nodes
* as were in l1.
*/
List *
set_difference(List *l1, List *l2)
{
List *temp1 = NIL;
List *result = NIL;
List *i;
if (l2 == NIL)
return l1;
return listCopy(l1); /* slightly faster path for empty l2 */
foreach(temp1, l1)
foreach(i, l1)
{
if (!member(lfirst(temp1), l2))
result = lappend(result, lfirst(temp1));
if (! member(lfirst(i), l2))
result = lappend(result, lfirst(i));
}
return result;
}
......@@ -559,16 +480,16 @@ set_difference(List *l1, List *l2)
List *
set_differencei(List *l1, List *l2)
{
List *temp1 = NIL;
List *result = NIL;
List *i;
if (l2 == NIL)
return l1;
return listCopy(l1); /* slightly faster path for empty l2 */
foreach(temp1, l1)
foreach(i, l1)
{
if (!intMember(lfirsti(temp1), l2))
result = lappendi(result, lfirsti(temp1));
if (! intMember(lfirsti(i), l2))
result = lappendi(result, lfirsti(i));
}
return result;
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment