Parameters in Object MethodsIn Oracle you can define an object method such that you can do something like:
SELECT li.length(30) from line_segment li;
In PostgreSQL there is no way to pass parameters to an object method called with object.method syntax. The equivalent in PostgreSQL would be:
SELECT length(li, 30) from line_segment li;
This isn't a huge deal but it would make it a lot clearer that length was closely tied to the line_segment type structure if it was possible to do things that way.
Inheritable foreign key constraintsA very useful and extension to what we have would be to allow foreign keys to be inherited on the referencing side. This would save one from having to define foreign keys over and over for each child table and it would make key classes even more useful.
Ideally I would like to be able to do
CREATE TABLE country_ref (
country_id int references country(id)
and have the foreign key properly enforced on all inheriting tables. This would just involve copying the foreign key constraint and so would probably not require any deep changes to structure the way the ability to reference child table and parent tables together might.
Inheritable unique constraintsRelated to this I think another thing that would smooth things over down the road and might ultimately lead to more functionality down the road. For now, I think the first step would be a SCOPE predicate for unique constraints and indexes. This could be something like:
CREATE TABLE country_ref_u (
unique (country_id) SCOPE PER TABLE
FOREIGN KEY (country_id) REFERENCES country(id)
Such a unique constraint could then specify that this is unique on each table where it is inherited. Initially PER TABLE and ONLY HERE (i.e. not inherited) might be supported with an effort to eventually support SCOPE FULL (and DRI against an inheritance tree).
One of the fundamental problems that one runs into with the issue of unique constraints cross tables is that extending the index format to include tableoid might lead to significantly larger indexes and very likely slower lookups where inheritance is not used. One option might be to have an additional index page with special pointers to other indexes. So per table indexes might be useful jumping off points for full tree constraints.