Build out the TupleDescriptor implementation

As before, JNI methods for this 'model' framework continue to
be grouped together in ModelUtils.c; their total number and
complexity is expected to be low enough for that to be practical,
and then they can all be seen in one place.

RegClassImpl and RegTypeImpl acquire m_tupDescHolder arrays in
this commit, without much explanation; that will come a few commits
later.

pljava-api/src/main/java/org/postgresql/pljava/model/RegType.java

@@ -105,6 +105,20 @@ public interface RegType
 	RegType       REGROLE = formObjectId(CLASSID,       REGROLEOID);
 	RegType  REGCOLLATION = formObjectId(CLASSID,  REGCOLLATIONOID);
 
+	RegClass relation();
+	RegType modifier(int typmod);
+
+	/**
+	 * Returns the modifier if this instance has one, else -1.
+	 */
+	int modifier();
+
+	/**
+	 * The corresponding {@link TupleDescriptor TupleDescriptor}, non-null only
+	 * for composite types.
+	 */
+	TupleDescriptor.Interned tupleDescriptor();
+
 	/**
 	 * The name of this type as a {@code String}, as the JDBC
 	 * {@link SQLType SQLType} interface requires.

pljava-so/src/main/c/ModelUtils.c

@@ -36,6 +36,7 @@
 #include "org_postgresql_pljava_pg_DatumUtils.h"
 #include "org_postgresql_pljava_pg_MemoryContextImpl_EarlyNatives.h"
 #include "org_postgresql_pljava_pg_ResourceOwnerImpl_EarlyNatives.h"
+#include "org_postgresql_pljava_pg_TupleDescImpl.h"
 
 /*
  * A compilation unit collecting various native methods used in the pg model
@@ -61,6 +62,24 @@ static jmethodID s_ResourceOwnerImpl_callback;
 static void resourceReleaseCB(ResourceReleasePhase phase,
 							  bool isCommit, bool isTopLevel, void *arg);
 
+static jclass s_TupleDescImpl_class;
+static jmethodID s_TupleDescImpl_fromByteBuffer;
+
+jobject pljava_TupleDescriptor_create(TupleDesc tupdesc, Oid reloid)
+{
+	jlong tupdesc_size = (jlong)TupleDescSize(tupdesc);
+	jobject td_b = JNI_newDirectByteBuffer(tupdesc, tupdesc_size);
+
+	jobject result = JNI_callStaticObjectMethodLocked(s_TupleDescImpl_class,
+		s_TupleDescImpl_fromByteBuffer,
+		td_b,
+		(jint)tupdesc->tdtypeid, (jint)tupdesc->tdtypmod,
+		(jint)reloid, (jint)tupdesc->tdrefcount);
+
+	JNI_deleteLocalRef(td_b);
+	return result;
+}
+
 static void memoryContextCallback(void *arg)
 {
 	Ptr2Long p2l;
@@ -200,6 +219,16 @@ void pljava_ModelUtils_initialize(void)
 		{ 0, 0, 0 }
 	};
 
+	JNINativeMethod tdiMethods[] =
+	{
+		{
+		"_assign_record_type_typmod",
+		"(Ljava/nio/ByteBuffer;)I",
+		Java_org_postgresql_pljava_pg_TupleDescImpl__1assign_1record_1type_1typmod
+		},
+		{ 0, 0, 0 }
+	};
+
 	cls = PgObject_getJavaClass("org/postgresql/pljava/pg/CharsetEncodingImpl$EarlyNatives");
 	PgObject_registerNatives2(cls, charsetMethods);
 	JNI_deleteLocalRef(cls);
@@ -228,6 +257,17 @@ void pljava_ModelUtils_initialize(void)
 	s_ResourceOwnerImpl_callback = PgObject_getStaticJavaMethod(
 		s_ResourceOwnerImpl_class, "callback", "(J)V");
 
+	cls = PgObject_getJavaClass("org/postgresql/pljava/pg/TupleDescImpl");
+	s_TupleDescImpl_class = JNI_newGlobalRef(cls);
+	PgObject_registerNatives2(cls, tdiMethods);
+	JNI_deleteLocalRef(cls);
+
+	s_TupleDescImpl_fromByteBuffer = PgObject_getStaticJavaMethod(
+		s_TupleDescImpl_class,
+		"fromByteBuffer",
+		"(Ljava/nio/ByteBuffer;IIII)"
+		"Lorg/postgresql/pljava/model/TupleDescriptor;");
+
 	RegisterResourceReleaseCallback(resourceReleaseCB, NULL);
 }
 
@@ -504,3 +544,21 @@ Java_org_postgresql_pljava_pg_ResourceOwnerImpl_00024EarlyNatives__1window(JNIEn
 
 	return r;
 }
+
+/*
+ * Class:     org_postgresql_pljava_pg_TupleDescImpl
+ * Method:    _assign_record_type_typmod
+ * Signature: (Ljava/nio/ByteBuffer)I
+ */
+JNIEXPORT jint JNICALL
+Java_org_postgresql_pljava_pg_TupleDescImpl__1assign_1record_1type_1typmod(JNIEnv* env, jobject _cls, jobject td_b)
+{
+	TupleDesc td = (*env)->GetDirectBufferAddress(env, td_b);
+	if ( NULL == td )
+		return -1;
+
+	BEGIN_NATIVE_AND_TRY
+	assign_record_type_typmod(td);
+	END_NATIVE_AND_CATCH("_assign_record_type_typmod")
+	return td->tdtypmod;
+}

pljava-so/src/main/include/pljava/ModelUtils.h

@@ -26,6 +26,26 @@ extern void pljava_ModelUtils_initialize(void);
 
 extern void pljava_ResourceOwner_unregister(void);
 
+/*
+ * Return a Java TupleDescriptor based on a PostgreSQL one.
+ *
+ * If the descriptor's tdtypeid is not RECORDOID (meaning the descriptor is
+ * for a named composite type), passing the relation oid here, if handy, will
+ * save a lookup in the Java code. In other cases, or if it simply is not
+ * handily available, InvalidOid can be passed, and the relation will be looked
+ * up if needed.
+ *
+ * If there is already a cached Java representation, the existing one
+ * is returned, and the supplied one's reference count (if it is counted) is
+ * untouched. If the supplied one is used to create a cached Java version, its
+ * reference count is incremented (without registering it for descriptor leak
+ * warnings), and it will be released upon removal from PL/Java's cache for
+ * invalidation or unreachability. If the descriptor is non-reference-counted,
+ * the returned Java object will not depend on it, and it is expendable
+ * after this function returns.
+ */
+extern jobject pljava_TupleDescriptor_create(TupleDesc tupdesc,  Oid reloid);
+
 #ifdef __cplusplus
 }
 #endif

pljava/src/main/java/org/postgresql/pljava/pg/AttributeImpl.java

@@ -55,6 +55,12 @@ boolean foundIn(TupleDescriptor td)
 	 */
 	static class Cataloged extends AttributeImpl
 	{
+		private final RegClassImpl m_relation;
+
+		Cataloged(RegClassImpl relation)
+		{
+			m_relation = requireNonNull(relation);
+		}
 	}
 
 	/**

pljava/src/main/java/org/postgresql/pljava/pg/RegClassImpl.java

@@ -39,6 +39,8 @@ static class Known<T extends CatalogObject.Addressed<T>>
 	{
 	}
 
+	TupleDescriptor.Interned[] m_tupDescHolder;
+
 	@Override
 	public TupleDescriptor.Interned tupleDescriptor()
 	{

pljava/src/main/java/org/postgresql/pljava/pg/RegTypeImpl.java

@@ -38,13 +38,68 @@ abstract class RegTypeImpl extends Addressed<RegType>
 	Nonshared<RegType>,	Namespaced<Simple>, Owned,
 	AccessControlled<CatalogObject.USAGE>, RegType
 {
+	@Override
+	public TupleDescriptor.Interned tupleDescriptor()
+	{
+		throw notyet();
+	}
+
+	@Override
+	public RegClass relation()
+	{
+		throw notyet();
+	}
+
+	/**
+	 * Return the expected zero value for {@code subId}.
+	 *<p>
+	 * For keying the {@code CacheMap}, we sneak type modifiers in there
+	 * (PG types do not otherwise use {@code subId}), but that's an
+	 * implementation detail that could be done a different way if upstream
+	 * ever decided to have subIds for types, and having it show in the address
+	 * triple of a modified type could be surprising to an old PostgreSQL hand.
+	 */
+	@Override
+	public int subId()
+	{
+		return 0;
+	}
+
+	/**
+	 * Return the type modifier.
+	 *<p>
+	 * In this implementation, where we snuck it in as the third component
+	 * of the cache key, sneak it back out.
+	 */
+	@Override
+	public int modifier()
+	{
+		int m = super.subId();
+		if ( -1 == m )
+			return 0;
+		return m;
+	}
 
 	/**
 	 * Represents a type that has been mentioned without an accompanying type
 	 * modifier (or with the 'unspecified' value -1 for its type modifier).
 	 */
 	static class NoModifier extends RegTypeImpl
 	{
+		@Override
+		public int modifier()
+		{
+			return -1;
+		}
+
+		@Override
+		public RegType modifier(int typmod)
+		{
+			if ( -1 == typmod )
+				return this;
+			return (RegType)
+				CatalogObjectImpl.Factory.formMaybeModifiedType(oid(), typmod);
+		}
 	}
 
 	/**
@@ -56,8 +111,19 @@ static class NoModifier extends RegTypeImpl
 	 */
 	static class Modified extends RegTypeImpl
 	{
+		private final NoModifier m_base;
+
 		Modified(NoModifier base)
 		{
+			m_base = base;
+		}
+
+		@Override
+		public RegType modifier(int typmod)
+		{
+			if ( modifier() == typmod )
+				return this;
+			return m_base.modifier(typmod);
 		}
 	}
 
@@ -70,5 +136,13 @@ static class Modified extends RegTypeImpl
 	 */
 	static class Blessed extends RegTypeImpl
 	{
+		TupleDescriptor.Interned[] m_tupDescHolder;
+
+		@Override
+		public RegType modifier(int typmod)
+		{
+			throw new UnsupportedOperationException(
+				"may not alter the type modifier of an interned row type");
+		}
 	}
 }