design & available tricks: traversing heterogeneous tree (table-level + linked list)

I've such a structure:

create table catalog_fam (
famid int primary key,
name varchar(255),
action smallint
);
create table catalog_macro (
macroid int primary key,
famid int references catalog_fam (famid),
name varchar(255),
action smallint
);
create table catalog_cat (
catid int primary key,
macroid int references catalog_macro (macroid),
name varchar(255),
action smallint
);
create table catalog_group (
groupid int primary key,
catid int references catalog_cat (catid),
groupup references catalog_group (groupid),
action smallint
);
create table catalog_categoryitem(
itemid int references catalog_item (itemid),
famid int references catalog_fam (famid),
macroid int references catalog_macro (macroid),
catid int references catalog_cat (catid),
groupid references catalog_group (groupid),
action smallint
);

where action is (update, delete, insert).

And I've to build up functions that eg.
- tell me what are the categories (where category may stand for
famid, macroid, catid, groupid) have the same parent
- tell me which are the items that belong to the same category
- tell me which are the categories that belong to the same level of
a parent...

And I'd like to:
- offer a uniform interface to the client (php) through plpsql
functions
- avoid to get crazy writing and maintaining such functions.

I could even implement a completely different schema to solve the
above, but then I'll have to face the problem of importing the data.

I've just a constraint if I'll have to change the schema: there is
already some logic depending on:

create table catalog_categoryitem(
itemid int references catalog_item (itemid),
famid int references catalog_fam (famid),
-- ... the rest doesn't matter
);

and

catalog_fam

but refactoring this could be worth since:
a) there is no item that belong to more than one fam
b) famid is frequently accessed when items are and I could avoid a
join

Still there may be some interest in having fast access/grouping and
traversing of stuff with same catid and macroid in the future.
So a nested set (mptt) to represent the hierarchy may not be optimal
and wring a safe and *fast* import function may not be trivial.

I was wondering if there is some cool feature or cool contrib
(8.3) that could make the choice much easier to take or just some
suggestion.

thanks

--
Ivan Sergio Borgonovo
http://www.webthatworks.it