Begin MemoryContext/ResourceOwner implementation

In addition to MemoryContextImpl and ResourceOwnerImpl proper, this step
will require reworking DualState so state lives are bounded by Lifespan
instances instead of arbitrary pointer values. Invocation will be made
into yet another subtype of Lifespan, appropriate for the life of an
object passed by PostgreSQL in a call and presumed good while the call
is in progress.

The DualState change will have to be rototilled through all of its
clients. That will take the next several commits.

The DualState.Key requirement that was introduced in 1.5.1 as a way to
force DualState-guarded objects to be constructed only in upcalls from C
(as a hedge against Java code inadvertently doing it on the wrong
thread) will go away. We *want* Adapters to be able to easily construct
things without leaving Java. Just don't do it on the wrong thread.

Author: jcflack

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

@@ -38,4 +38,5 @@ public interface Attribute
 	RegClass CLASS = formObjectId(RegClass.CLASSID, AttributeRelationId);
 
 	RegType type();
+	short length();
 }

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

@@ -757,7 +757,7 @@ static void initsequencer(enum initstage is, bool tolerant)
 					"and \"pljava-api.jar\" files, separated by the correct "
 					"path separator for this platform.")
 					));
-			pljava_DualState_unregister();
+			pljava_ResourceOwner_unregister();
 			_destroyJavaVM(0, 0);
 			goto check_tolerant;
 		}

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

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018-2019 Tada AB and other contributors, as listed below.
+ * Copyright (c) 2018-2022 Tada AB and other contributors, as listed below.
  *
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the The BSD 3-Clause License
@@ -20,7 +20,6 @@
 #include "org_postgresql_pljava_internal_DualState_SingleSPIcursorClose.h"
 #include "pljava/DualState.h"
 
-#include "pljava/Backend.h"
 #include "pljava/Exception.h"
 #include "pljava/Invocation.h"
 #include "pljava/PgObject.h"
@@ -50,22 +49,8 @@ extern void pljava_ExecutionPlan_initialize(void);
 
 static jclass s_DualState_class;
 
-static jmethodID s_DualState_resourceOwnerRelease;
 static jmethodID s_DualState_cleanEnqueuedInstances;
 
-static jobject s_DualState_key;
-
-static void resourceReleaseCB(ResourceReleasePhase phase,
-							  bool isCommit, bool isTopLevel, void *arg);
-
-/*
- * Return a capability that is only expected to be accessible to native code.
- */
-jobject pljava_DualState_key(void)
-{
-	return s_DualState_key;
-}
-
 /*
  * Rather than using finalizers (deprecated in recent Java anyway), which can
  * increase the number of threads needing to interact with PG, DualState objects
@@ -79,39 +64,9 @@ void pljava_DualState_cleanEnqueuedInstances(void)
 								   s_DualState_cleanEnqueuedInstances);
 }
 
-/*
- * Called when the lifespan/scope of a particular PG resource owner is about to
- * expire, to make the associated DualState objects inaccessible from Java. As
- * described in DualState.java, the argument will often be a PG ResourceOwner
- * (when this function is called by resourceReleaseCB), but pointers to other
- * structures can also be used (such a pointer clearly can't be confused with a
- * ResourceOwner existing at the same time). In PG 9.5+, it could be a
- * MemoryContext, with a MemoryContextCallback established to call this
- * function. For items whose scope is limited to a single PL/Java function
- * invocation, this can be a pointer to the Invocation.
- */
-void pljava_DualState_nativeRelease(void *ro)
-{
-	Ptr2Long p2l;
-
-	/*
-	 * This static assertion does not need to be in every file
-	 * that uses Ptr2Long, but it should be somewhere once, so here it is.
-	 */
-	StaticAssertStmt(sizeof p2l.ptrVal <= sizeof p2l.longVal,
-					 "Pointer will not fit in long on this platform");
-
-	p2l.longVal = 0L;
-	p2l.ptrVal = ro;
-	JNI_callStaticVoidMethodLocked(s_DualState_class,
-								   s_DualState_resourceOwnerRelease,
-								   p2l.longVal);
-}
-
 void pljava_DualState_initialize(void)
 {
 	jclass clazz;
-	jmethodID ctor;
 
 	JNINativeMethod singlePfreeMethods[] =
 	{
@@ -185,17 +140,9 @@ void pljava_DualState_initialize(void)
 
 	s_DualState_class = (jclass)JNI_newGlobalRef(PgObject_getJavaClass(
 		"org/postgresql/pljava/internal/DualState"));
-	s_DualState_resourceOwnerRelease = PgObject_getStaticJavaMethod(
-		s_DualState_class, "resourceOwnerRelease", "(J)V");
 	s_DualState_cleanEnqueuedInstances = PgObject_getStaticJavaMethod(
 		s_DualState_class, "cleanEnqueuedInstances", "()V");
 
-	clazz = (jclass)PgObject_getJavaClass(
-		"org/postgresql/pljava/internal/DualState$Key");
-	ctor = PgObject_getJavaMethod(clazz, "<init>", "()V");
-	s_DualState_key = JNI_newGlobalRef(JNI_newObject(clazz, ctor));
-	JNI_deleteLocalRef(clazz);
-
 	clazz = (jclass)PgObject_getJavaClass(
 		"org/postgresql/pljava/internal/DualState$SinglePfree");
 	PgObject_registerNatives2(clazz, singlePfreeMethods);
@@ -231,8 +178,6 @@ void pljava_DualState_initialize(void)
 	PgObject_registerNatives2(clazz, singleSPIcursorCloseMethods);
 	JNI_deleteLocalRef(clazz);
 
-	RegisterResourceReleaseCallback(resourceReleaseCB, NULL);
-
 	/*
 	 * Call initialize() methods of known classes built upon DualState.
 	 */
@@ -248,32 +193,6 @@ void pljava_DualState_initialize(void)
 	pljava_VarlenaWrapper_initialize();
 }
 
-void pljava_DualState_unregister(void)
-{
-	UnregisterResourceReleaseCallback(resourceReleaseCB, NULL);
-}
-
-static void resourceReleaseCB(ResourceReleasePhase phase,
-							  bool isCommit, bool isTopLevel, void *arg)
-{
-	/*
-	 * The way ResourceOwnerRelease is implemented, callbacks to loadable
-	 * modules (like us!) happen /after/ all of the built-in releasey actions
-	 * for a particular phase. So, by looking for RESOURCE_RELEASE_LOCKS here,
-	 * we actually end up executing after all the built-in lock-related stuff
-	 * has been released, but before any of the built-in stuff released in the
-	 * RESOURCE_RELEASE_AFTER_LOCKS phase. Which, at least for the currently
-	 * implemented DualState subclasses, is about the right time.
-	 */
-	if ( RESOURCE_RELEASE_LOCKS != phase )
-		return;
-
-	pljava_DualState_nativeRelease(CurrentResourceOwner);
-
-	if ( isTopLevel )
-		Backend_warnJEP411(isCommit);
-}
-
 
 
 /*