storing intermediate results in recursive plpgsql functions

Hello,

I have a table 'entity'. It has an id column and a parent_id column
that refers to another entity in the same table. I often need to
calculate all of the "descendants" of a particular id. I wrote a
plpgsql function 'get_descendants' that, given an id, recurses over all
the children of that id, and the children's children, etc... As it
recurses, it puts the ids of the descendants into a one-column table
called 'descendants'.

Since the return of this function needs to be a setof int4, and as best
I can tell there's no way to return a setof from a recursive plpgsql
function (nowhere internally to store the intermediate result set), I
call this function from a wrapper sql function that simply calls the
recursive function, and then selects from the 'descendants' table.

This all works great until two users simultaneously call
get_descendants() wanting the descendants of two different people. They
of course get mixed and matched in the descendants table. I thought I
knew of a couple of different ways to possibly solve the problem but I'm
finding out that they don't work so well after all.

First I thought I would just have the function create 'descendants' as a
temporary table instead of a permanent one, but since table names get
converted to OIDs when I load the function into the db, I'm getting
Relation Not Found errors. I'm guessing that trying to refer to
temporary tables from stored procedures is not a common practice. :-)

Then I thought I'd just have the sql function obtain an access exclusive
lock on the 'descendants' table, call the recursive plpgsql function,
select the results from 'descendants', then unlock the 'descendants'
table. Then the second instance of get_descendants would sit and wait
for descendants to come free. That doesn't work because the sql
function wants the last statement called to be the one that returns the
setof int4, not the commit; that is necessary.

Right now the only way I can think of to do this is to have a bit flag
that the client can examine to see if anyone else is currently calling
get_descendants and to wait if so and try again to obtain the bit for
itself in a second or so. I am the first to admit that this would be a
horrendous hack (yeah, like the rest of what I've already done isn't ;)

I feel like I'm missing something obvious. But it seems the exact
combination I have here (sql function calling a recursive plpgsql
function and then selecting the result set from a table) is just enough
to thwart all the usual techniques. I have a short mental list of
things I should have done/could do to maybe help:

1. Stop using recursive functions and represent the family tree in Joe
Celko fashion (I learned about his existence after the creation of this
database, unfortunately)

2. Figure out how to store an array of integers as the intermediate
result set on every pass of a recursive plpgsql function and return them
as a setof int4 when I'm done recursing. I remember trying a while on
this and finding it impossible.

I still feel like I'm missing some obvious solution. Anyone have any
insight?

Thanks,
Fran