When PL/Java is told to map a PostgreSQL composite type to a certain
Java class, on its first use of the type mapping it calls
lookup_rowtype_tupdesc_noerror and then creates a PL/Java UDT structure
that retains a reference to the TupleDesc. This seems to be what is leading
to a TupleDesc reference leak warning at completion of the transaction.

So I am wondering what a recommended way of managing these TupleDescs
would be. I could use lookup_rowtype_tupdesc_copy before saving it in
the UDT struct, and I assume that would silence the leak warning, but
would that be asking for trouble if the composite type gets altered
during the session and the saved TupleDesc is stale?

If that's an issue, what would be better? Should UDT not retain a
TupleDesc, but rather look it up with each use? (That would happen
in preparation for calling a Java function with a parameter or return
of that type, or when a Java function makes JDBC-SPI calls touching
that type.) Reading typcache.c, I get the impression that it may be
intended to be fast enough for such usage, and that it manages the
complexity of invalidating entries when something gets altered.

Should there be some intermediate solution where UDT does retain a
TupleDesc reference within a transaction, but certain callbacks are
registered to know when to release or refresh it?

Is there a canonical, preferred approach?


Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:

Reply via email to