lazily create hashset for root transaction

src/backend/distributed/shared_library_init.c

@@ -482,7 +482,6 @@ _PG_init(void)
 
 	/* initialize coordinated transaction management */
 	InitializeTransactionManagement();
-	InitTransactionPropagatedObjectsHash();
 	InitializeBackendManagement();
 	InitializeConnectionManagement();
 	InitPlacementConnectionManagement();

src/backend/distributed/transaction/transaction_management.c

@@ -164,7 +164,9 @@ static void EnsurePrepareTransactionIsAllowed(void);
 static HTAB * CurrentTransactionPropagatedObjects(bool readonly);
 static HTAB * ParentTransactionPropagatedObjects(bool readonly);
 static void MovePropagatedObjectsToParentTransaction(void);
-static HTAB * CreateSubtransactionPropagatedObjectsHash(void);
+static bool DependencyInPropagatedObjectsHash(HTAB *propagatedObjects,
+											  const ObjectAddress *dependency);
+static HTAB * CreateTxPropagatedObjectsHash(void);
 
 
 /*
@@ -961,6 +963,11 @@ CurrentTransactionPropagatedObjects(bool readonly)
 	if (activeSubXactContexts == NIL)
 	{
 		/* hashset in the root transaction if there is no sub-transaction */
+		if (PropagatedObjectsInTx == NULL && !readonly)
+		{
+			/* lazily create hashset for root transaction, for mutating uses */
+			PropagatedObjectsInTx = CreateTxPropagatedObjectsHash();
+		}
 		return PropagatedObjectsInTx;
 	}
 
@@ -969,7 +976,7 @@ CurrentTransactionPropagatedObjects(bool readonly)
 	if (state->propagatedObjects == NULL && !readonly)
 	{
 		/* lazily create hashset for sub-transaction, for mutating uses */
-		state->propagatedObjects = CreateSubtransactionPropagatedObjectsHash();
+		state->propagatedObjects = CreateTxPropagatedObjectsHash();
 	}
 	return state->propagatedObjects;
 }
@@ -993,6 +1000,11 @@ ParentTransactionPropagatedObjects(bool readonly)
 		 * The parent is the root transaction, when there is single level sub-transaction
 		 * or no sub-transaction.
 		 */
+		if (PropagatedObjectsInTx == NULL && !readonly)
+		{
+			/* lazily create hashset for root transaction, for mutating uses */
+			PropagatedObjectsInTx = CreateTxPropagatedObjectsHash();
+		}
 		return PropagatedObjectsInTx;
 	}
 
@@ -1002,7 +1014,7 @@ ParentTransactionPropagatedObjects(bool readonly)
 	if (state->propagatedObjects == NULL && !readonly)
 	{
 		/* lazily create hashset for parent sub-transaction */
-		state->propagatedObjects = CreateSubtransactionPropagatedObjectsHash();
+		state->propagatedObjects = CreateTxPropagatedObjectsHash();
 	}
 	return state->propagatedObjects;
 }
@@ -1042,42 +1054,40 @@ MovePropagatedObjectsToParentTransaction(void)
 
 
 /*
- * CreateSubtransactionPropagatedObjectsHash creates a hash table used to keep
- * track of the objects propagated in the current subtransaction.
+ * DependencyInPropagatedObjectsHash checks if dependency is in given hashset
+ * of propagated objects.
  */
-static HTAB *
-CreateSubtransactionPropagatedObjectsHash(void)
+static bool
+DependencyInPropagatedObjectsHash(HTAB *propagatedObjects, const
+								  ObjectAddress *dependency)
 {
-	HASHCTL info;
-	memset(&info, 0, sizeof(info));
-	info.keysize = sizeof(ObjectAddress);
-	info.entrysize = sizeof(ObjectAddress);
-	info.hash = tag_hash;
-	info.hcxt = CitusXactCallbackContext;
+	if (propagatedObjects == NULL)
+	{
+		return false;
+	}
 
-	int hashFlags = (HASH_ELEM | HASH_CONTEXT | HASH_FUNCTION);
-	return hash_create("Subtx-%d Propagated Objects", 16,
-					   &info, hashFlags);
+	bool found = false;
+	hash_search(propagatedObjects, dependency, HASH_FIND, &found);
+	return found;
 }
 
 
 /*
- * InitTransactionPropagatedObjectsHash initiates a hash table used to keep
- * track of the objects propagated in the root transaction.
+ * CreateTxPropagatedObjectsHash creates a hashset to keep track of the objects
+ * propagated in the current root transaction or sub-transaction.
  */
-void
-InitTransactionPropagatedObjectsHash(void)
+static HTAB *
+CreateTxPropagatedObjectsHash(void)
 {
 	HASHCTL info;
 	memset(&info, 0, sizeof(info));
 	info.keysize = sizeof(ObjectAddress);
 	info.entrysize = sizeof(ObjectAddress);
 	info.hash = tag_hash;
-	info.hcxt = TopMemoryContext;
+	info.hcxt = CitusXactCallbackContext;
 
 	int hashFlags = (HASH_ELEM | HASH_CONTEXT | HASH_FUNCTION);
-	PropagatedObjectsInTx = hash_create("Tx Propagated Objects", 16,
-										&info, hashFlags);
+	return hash_create("Tx Propagated Objects", 16, &info, hashFlags);
 }
 
 
@@ -1118,13 +1128,13 @@ TrackPropagatedTableAndSequences(Oid relationId)
 
 
 /*
- * ResetPropagatedObjects resets all objects propagated in the current
- * transaction from hash.
+ * ResetPropagatedObjects destroys hashset of propagated objects in the root transaction.
  */
 void
 ResetPropagatedObjects(void)
 {
-	hash_delete_all(PropagatedObjectsInTx);
+	hash_destroy(PropagatedObjectsInTx);
+	PropagatedObjectsInTx = NULL;
 }
 
 
@@ -1139,29 +1149,21 @@ HasAnyDependencyInPropagatedObjects(const ObjectAddress *objectAddress)
 	ObjectAddress *dependency = NULL;
 	foreach_ptr(dependency, dependencyList)
 	{
-		/* first search in top transaction level */
-		bool found = false;
-		hash_search(PropagatedObjectsInTx, dependency, HASH_FIND, &found);
-		if (found)
+		/* first search in root transaction */
+		if (DependencyInPropagatedObjectsHash(PropagatedObjectsInTx, dependency))
 		{
 			return true;
 		}
 
-		/* then depth search in all nested subtransactions */
+		/* search in all nested sub-transactions */
 		if (activeSubXactContexts == NIL)
 		{
 			continue;
 		}
 		SubXactContext *state = NULL;
 		foreach_ptr(state, activeSubXactContexts)
 		{
-			if (state->propagatedObjects == NULL)
-			{
-				continue;
-			}
-
-			hash_search(state->propagatedObjects, dependency, HASH_FIND, &found);
-			if (found)
+			if (DependencyInPropagatedObjectsHash(state->propagatedObjects, dependency))
 			{
 				return true;
 			}

src/include/distributed/transaction_management.h

@@ -161,7 +161,6 @@ extern void EnsureDistributedTransactionId(void);
 extern bool MaybeExecutingUDF(void);
 
 /* functions for tracking the objects propagated in current transaction */
-extern void InitTransactionPropagatedObjectsHash(void);
 extern void TrackPropagatedObject(const ObjectAddress *objectAddress);
 extern void TrackPropagatedTableAndSequences(Oid relationId);
 extern void ResetPropagatedObjects(void);