Merge pull request #6063 from citusdata/list-of-address-api

change address method to return list of addresses

src/backend/distributed/commands/alter_table.c

@@ -1302,7 +1302,7 @@ ErrorIfUnsupportedCascadeObjects(Oid relationId)
  *
  * Extension dependency is different than the rest. If an object depends on an extension
  * dropping the object would drop the extension too.
- * So we check with IsObjectAddressOwnedByExtension function.
+ * So we check with IsAnyObjectAddressOwnedByExtension function.
  */
 static bool
 DoesCascadeDropUnsupportedObject(Oid classId, Oid objectId, HTAB *nodeMap)
@@ -1315,10 +1315,9 @@ DoesCascadeDropUnsupportedObject(Oid classId, Oid objectId, HTAB *nodeMap)
 		return false;
 	}
 
-	ObjectAddress objectAddress = { 0 };
-	ObjectAddressSet(objectAddress, classId, objectId);
-
-	if (IsObjectAddressOwnedByExtension(&objectAddress, NULL))
+	ObjectAddress *objectAddress = palloc0(sizeof(ObjectAddress));
+	ObjectAddressSet(*objectAddress, classId, objectId);
+	if (IsAnyObjectAddressOwnedByExtension(list_make1(objectAddress), NULL))
 	{
 		return true;
 	}

src/backend/distributed/commands/citus_add_local_table_to_metadata.c

@@ -307,8 +307,8 @@ CreateCitusLocalTable(Oid relationId, bool cascadeViaForeignKeys, bool autoConve
 		}
 	}
 
-	ObjectAddress tableAddress = { 0 };
-	ObjectAddressSet(tableAddress, RelationRelationId, relationId);
+	ObjectAddress *tableAddress = palloc0(sizeof(ObjectAddress));
+	ObjectAddressSet(*tableAddress, RelationRelationId, relationId);
 
 	/*
 	 * Ensure that the sequences used in column defaults of the table
@@ -320,7 +320,7 @@ CreateCitusLocalTable(Oid relationId, bool cascadeViaForeignKeys, bool autoConve
 	 * Ensure dependencies exist as we will create shell table on the other nodes
 	 * in the MX case.
 	 */
-	EnsureDependenciesExistOnAllNodes(&tableAddress);
+	EnsureAllObjectDependenciesExistOnAllNodes(list_make1(tableAddress));
 
 	/*
 	 * Make sure that existing reference tables have been replicated to all

src/backend/distributed/commands/collation.c

@@ -169,7 +169,7 @@ CreateCollationDDLsIdempotent(Oid collationId)
 }
 
 
-ObjectAddress
+List *
 AlterCollationOwnerObjectAddress(Node *node, bool missing_ok)
 {
 	AlterOwnerStmt *stmt = castNode(AlterOwnerStmt, node);
@@ -177,8 +177,13 @@ AlterCollationOwnerObjectAddress(Node *node, bool missing_ok)
 
 	Assert(stmt->objectType == OBJECT_COLLATION);
 
-	return get_object_address(stmt->objectType, stmt->object, &relation,
-							  AccessExclusiveLock, missing_ok);
+	ObjectAddress objectAddress = get_object_address(stmt->objectType, stmt->object,
+													 &relation, AccessExclusiveLock,
+													 missing_ok);
+
+	ObjectAddress *objectAddressCopy = palloc0(sizeof(ObjectAddress));
+	*objectAddressCopy = objectAddress;
+	return list_make1(objectAddressCopy);
 }
 
 
@@ -186,17 +191,17 @@ AlterCollationOwnerObjectAddress(Node *node, bool missing_ok)
  * RenameCollationStmtObjectAddress returns the ObjectAddress of the type that is the object
  * of the RenameStmt. Errors if missing_ok is false.
  */
-ObjectAddress
+List *
 RenameCollationStmtObjectAddress(Node *node, bool missing_ok)
 {
 	RenameStmt *stmt = castNode(RenameStmt, node);
 	Assert(stmt->renameType == OBJECT_COLLATION);
 
 	Oid collationOid = get_collation_oid((List *) stmt->object, missing_ok);
-	ObjectAddress address = { 0 };
-	ObjectAddressSet(address, CollationRelationId, collationOid);
+	ObjectAddress *address = palloc0(sizeof(ObjectAddress));
+	ObjectAddressSet(*address, CollationRelationId, collationOid);
 
-	return address;
+	return list_make1(address);
 }
 
 
@@ -209,7 +214,7 @@ RenameCollationStmtObjectAddress(Node *node, bool missing_ok)
  * new schema. Errors if missing_ok is false and the type cannot be found in either of the
  * schemas.
  */
-ObjectAddress
+List *
 AlterCollationSchemaStmtObjectAddress(Node *node, bool missing_ok)
 {
 	AlterObjectSchemaStmt *stmt = castNode(AlterObjectSchemaStmt, node);
@@ -232,9 +237,9 @@ AlterCollationSchemaStmtObjectAddress(Node *node, bool missing_ok)
 		}
 	}
 
-	ObjectAddress address = { 0 };
-	ObjectAddressSet(address, CollationRelationId, collationOid);
-	return address;
+	ObjectAddress *address = palloc0(sizeof(ObjectAddress));
+	ObjectAddressSet(*address, CollationRelationId, collationOid);
+	return list_make1(address);
 }
 
 
@@ -291,15 +296,15 @@ GenerateBackupNameForCollationCollision(const ObjectAddress *address)
 }
 
 
-ObjectAddress
+List *
 DefineCollationStmtObjectAddress(Node *node, bool missing_ok)
 {
 	DefineStmt *stmt = castNode(DefineStmt, node);
 	Assert(stmt->kind == OBJECT_COLLATION);
 
 	Oid collOid = get_collation_oid(stmt->defnames, missing_ok);
-	ObjectAddress address = { 0 };
-	ObjectAddressSet(address, CollationRelationId, collOid);
+	ObjectAddress *address = palloc0(sizeof(ObjectAddress));
+	ObjectAddressSet(*address, CollationRelationId, collOid);
 
-	return address;
+	return list_make1(address);
 }

src/backend/distributed/commands/common.c

@@ -61,22 +61,26 @@ PostprocessCreateDistributedObjectFromCatalogStmt(Node *stmt, const char *queryS
 		return NIL;
 	}
 
-	ObjectAddress address = GetObjectAddressFromParseTree(stmt, false);
+	List *addresses = GetObjectAddressListFromParseTree(stmt, false);
+
+	/*  the code-path only supports a single object */
+	Assert(list_length(addresses) == 1);
 
 	EnsureCoordinator();
 	EnsureSequentialMode(ops->objectType);
 
 	/* If the object has any unsupported dependency warn, and only create locally */
-	DeferredErrorMessage *depError = DeferErrorIfHasUnsupportedDependency(&address);
+	DeferredErrorMessage *depError = DeferErrorIfAnyObjectHasUnsupportedDependency(
+		addresses);
 	if (depError != NULL)
 	{
 		RaiseDeferredError(depError, WARNING);
 		return NIL;
 	}
 
-	EnsureDependenciesExistOnAllNodes(&address);
+	EnsureAllObjectDependenciesExistOnAllNodes(addresses);
 
-	List *commands = GetDependencyCreateDDLCommands(&address);
+	List *commands = GetAllDependencyCreateDDLCommands(addresses);
 
 	commands = lcons(DISABLE_DDL_PROPAGATION, commands);
 	commands = lappend(commands, ENABLE_DDL_PROPAGATION);
@@ -111,8 +115,12 @@ PreprocessAlterDistributedObjectStmt(Node *stmt, const char *queryString,
 	const DistributeObjectOps *ops = GetDistributeObjectOps(stmt);
 	Assert(ops != NULL);
 
-	ObjectAddress address = GetObjectAddressFromParseTree(stmt, false);
-	if (!ShouldPropagateObject(&address))
+	List *addresses = GetObjectAddressListFromParseTree(stmt, false);
+
+	/*  the code-path only supports a single object */
+	Assert(list_length(addresses) == 1);
+
+	if (!ShouldPropagateAnyObject(addresses))
 	{
 		return NIL;
 	}
@@ -156,8 +164,12 @@ PostprocessAlterDistributedObjectStmt(Node *stmt, const char *queryString)
 	const DistributeObjectOps *ops = GetDistributeObjectOps(stmt);
 	Assert(ops != NULL);
 
-	ObjectAddress address = GetObjectAddressFromParseTree(stmt, false);
-	if (!ShouldPropagateObject(&address))
+	List *addresses = GetObjectAddressListFromParseTree(stmt, false);
+
+	/*  the code-path only supports a single object */
+	Assert(list_length(addresses) == 1);
+
+	if (!ShouldPropagateAnyObject(addresses))
 	{
 		return NIL;
 	}
@@ -168,7 +180,7 @@ PostprocessAlterDistributedObjectStmt(Node *stmt, const char *queryString)
 		return NIL;
 	}
 
-	EnsureDependenciesExistOnAllNodes(&address);
+	EnsureAllObjectDependenciesExistOnAllNodes(addresses);
 
 	return NIL;
 }
@@ -223,11 +235,10 @@ PreprocessDropDistributedObjectStmt(Node *node, const char *queryString,
 		Relation rel = NULL; /* not used, but required to pass to get_object_address */
 		ObjectAddress address = get_object_address(stmt->removeType, object, &rel,
 												   AccessShareLock, stmt->missing_ok);
-		if (IsObjectDistributed(&address))
+		ObjectAddress *addressPtr = palloc0(sizeof(ObjectAddress));
+		*addressPtr = address;
+		if (IsAnyObjectDistributed(list_make1(addressPtr)))
 		{
-			ObjectAddress *addressPtr = palloc0(sizeof(ObjectAddress));
-			*addressPtr = address;
-
 			distributedObjects = lappend(distributedObjects, object);
 			distributedObjectAddresses = lappend(distributedObjectAddresses, addressPtr);
 		}

src/backend/distributed/commands/create_distributed_table.c

@@ -442,10 +442,9 @@ CreateDistributedTable(Oid relationId, char *distributionColumnName,
 	 * via their own connection and committed immediately so they become visible to all
 	 * sessions creating shards.
 	 */
-	ObjectAddress tableAddress = { 0 };
-	ObjectAddressSet(tableAddress, RelationRelationId, relationId);
-
-	EnsureDependenciesExistOnAllNodes(&tableAddress);
+	ObjectAddress *tableAddress = palloc0(sizeof(ObjectAddress));
+	ObjectAddressSet(*tableAddress, RelationRelationId, relationId);
+	EnsureAllObjectDependenciesExistOnAllNodes(list_make1(tableAddress));
 
 	char replicationModel = DecideReplicationModel(distributionMethod,
 												   colocateWithTableName,

src/backend/distributed/commands/database.c

@@ -40,17 +40,17 @@ bool EnableAlterDatabaseOwner = true;
  * AlterDatabaseOwnerObjectAddress returns the ObjectAddress of the database that is the
  * object of the AlterOwnerStmt. Errors if missing_ok is false.
  */
-ObjectAddress
+List *
 AlterDatabaseOwnerObjectAddress(Node *node, bool missing_ok)
 {
 	AlterOwnerStmt *stmt = castNode(AlterOwnerStmt, node);
 	Assert(stmt->objectType == OBJECT_DATABASE);
 
 	Oid databaseOid = get_database_oid(strVal((String *) stmt->object), missing_ok);
-	ObjectAddress address = { 0 };
-	ObjectAddressSet(address, DatabaseRelationId, databaseOid);
+	ObjectAddress *address = palloc0(sizeof(ObjectAddress));
+	ObjectAddressSet(*address, DatabaseRelationId, databaseOid);
 
-	return address;
+	return list_make1(address);
 }
 
 

src/backend/distributed/commands/dependencies.c

@@ -36,6 +36,9 @@ static void ErrorIfCircularDependencyExists(const ObjectAddress *objectAddress);
 static int ObjectAddressComparator(const void *a, const void *b);
 static List * FilterObjectAddressListByPredicate(List *objectAddressList,
 												 AddressPredicate predicate);
+static void EnsureDependenciesExistOnAllNodes(const ObjectAddress *target);
+static List * GetDependencyCreateDDLCommands(const ObjectAddress *dependency);
+static bool ShouldPropagateObject(const ObjectAddress *address);
 
 /*
  * EnsureDependenciesExistOnAllNodes finds all the dependencies that we support and makes
@@ -51,7 +54,7 @@ static List * FilterObjectAddressListByPredicate(List *objectAddressList,
  * This is solved by creating the dependencies in an idempotent manner, either via
  * postgres native CREATE IF NOT EXISTS, or citus helper functions.
  */
-void
+static void
 EnsureDependenciesExistOnAllNodes(const ObjectAddress *target)
 {
 	List *dependenciesWithCommands = NIL;
@@ -142,6 +145,21 @@ EnsureDependenciesExistOnAllNodes(const ObjectAddress *target)
 }
 
 
+/*
+ * EnsureAllObjectDependenciesExistOnAllNodes iteratively calls EnsureDependenciesExistOnAllNodes
+ * for given targets.
+ */
+void
+EnsureAllObjectDependenciesExistOnAllNodes(const List *targets)
+{
+	ObjectAddress *target = NULL;
+	foreach_ptr(target, targets)
+	{
+		EnsureDependenciesExistOnAllNodes(target);
+	}
+}
+
+
 /*
  * EnsureDependenciesCanBeDistributed ensures all dependencies of the given object
  * can be distributed.
@@ -153,7 +171,8 @@ EnsureDependenciesCanBeDistributed(const ObjectAddress *objectAddress)
 	ErrorIfCircularDependencyExists(objectAddress);
 
 	/* If the object has any unsupported dependency, error out */
-	DeferredErrorMessage *depError = DeferErrorIfHasUnsupportedDependency(objectAddress);
+	DeferredErrorMessage *depError = DeferErrorIfAnyObjectHasUnsupportedDependency(
+		list_make1((ObjectAddress *) objectAddress));
 
 	if (depError != NULL)
 	{
@@ -310,7 +329,7 @@ GetDistributableDependenciesForObject(const ObjectAddress *target)
  * GetDependencyCreateDDLCommands returns a list (potentially empty or NIL) of ddl
  * commands to execute on a worker to create the object.
  */
-List *
+static List *
 GetDependencyCreateDDLCommands(const ObjectAddress *dependency)
 {
 	switch (getObjectClass(dependency))
@@ -488,6 +507,25 @@ GetDependencyCreateDDLCommands(const ObjectAddress *dependency)
 }
 
 
+/*
+ * GetAllDependencyCreateDDLCommands iteratively calls GetDependencyCreateDDLCommands
+ * for given dependencies.
+ */
+List *
+GetAllDependencyCreateDDLCommands(const List *dependencies)
+{
+	List *commands = NIL;
+
+	ObjectAddress *dependency = NULL;
+	foreach_ptr(dependency, dependencies)
+	{
+		commands = list_concat(commands, GetDependencyCreateDDLCommands(dependency));
+	}
+
+	return commands;
+}
+
+
 /*
  * ReplicateAllObjectsToNodeCommandList returns commands to replicate all
  * previously marked objects to a worker node. The function also sets
@@ -531,7 +569,7 @@ ReplicateAllObjectsToNodeCommandList(const char *nodeName, int nodePort)
 	ObjectAddress *dependency = NULL;
 	foreach_ptr(dependency, dependencies)
 	{
-		if (IsObjectAddressOwnedByExtension(dependency, NULL))
+		if (IsAnyObjectAddressOwnedByExtension(list_make1(dependency), NULL))
 		{
 			/*
 			 * we expect extension-owned objects to be created as a result
@@ -663,7 +701,7 @@ ShouldPropagateCreateInCoordinatedTransction()
  * ShouldPropagateObject determines if we should be propagating DDLs based
  * on their object address.
  */
-bool
+static bool
 ShouldPropagateObject(const ObjectAddress *address)
 {
 	if (!ShouldPropagate())
@@ -671,7 +709,7 @@ ShouldPropagateObject(const ObjectAddress *address)
 		return false;
 	}
 
-	if (!IsObjectDistributed(address))
+	if (!IsAnyObjectDistributed(list_make1((ObjectAddress *) address)))
 	{
 		/* do not propagate for non-distributed types */
 		return false;
@@ -681,6 +719,26 @@ ShouldPropagateObject(const ObjectAddress *address)
 }
 
 
+/*
+ * ShouldPropagateAnyObject determines if we should be propagating DDLs based
+ * on their object addresses.
+ */
+bool
+ShouldPropagateAnyObject(List *addresses)
+{
+	ObjectAddress *address = NULL;
+	foreach_ptr(address, addresses)
+	{
+		if (ShouldPropagateObject(address))
+		{
+			return true;
+		}
+	}
+
+	return false;
+}
+
+
 /*
  * FilterObjectAddressListByPredicate takes a list of ObjectAddress *'s and returns a list
  * only containing the ObjectAddress *'s for which the predicate returned true.

src/backend/distributed/commands/domain.c

@@ -37,7 +37,7 @@
 
 
 static CollateClause * MakeCollateClauseFromOid(Oid collationOid);
-static ObjectAddress GetDomainAddressByName(TypeName *domainName, bool missing_ok);
+static List * GetDomainAddressByName(TypeName *domainName, bool missing_ok);
 
 /*
  * GetDomainAddressByName returns the ObjectAddress of the domain identified by
@@ -45,13 +45,13 @@ static ObjectAddress GetDomainAddressByName(TypeName *domainName, bool missing_o
  * InvalidOid. When missing_ok is false this function will raise an error instead when the
  * domain can't be found.
  */
-static ObjectAddress
+static List *
 GetDomainAddressByName(TypeName *domainName, bool missing_ok)
 {
-	ObjectAddress address = { 0 };
+	ObjectAddress *address = palloc0(sizeof(ObjectAddress));
 	Oid domainOid = LookupTypeNameOid(NULL, domainName, missing_ok);
-	ObjectAddressSet(address, TypeRelationId, domainOid);
-	return address;
+	ObjectAddressSet(*address, TypeRelationId, domainOid);
+	return list_make1(address);
 }
 
 
@@ -229,17 +229,17 @@ MakeCollateClauseFromOid(Oid collationOid)
  * created by the statement. When missing_ok is false the function will raise an error if
  * the domain cannot be found in the local catalog.
  */
-ObjectAddress
+List *
 CreateDomainStmtObjectAddress(Node *node, bool missing_ok)
 {
 	CreateDomainStmt *stmt = castNode(CreateDomainStmt, node);
 
 	TypeName *typeName = makeTypeNameFromNameList(stmt->domainname);
 	Oid typeOid = LookupTypeNameOid(NULL, typeName, missing_ok);
-	ObjectAddress address = { 0 };
-	ObjectAddressSet(address, TypeRelationId, typeOid);
+	ObjectAddress *address = palloc0(sizeof(ObjectAddress));
+	ObjectAddressSet(*address, TypeRelationId, typeOid);
 
-	return address;
+	return list_make1(address);
 }
 
 
@@ -248,7 +248,7 @@ CreateDomainStmtObjectAddress(Node *node, bool missing_ok)
  * When missing_ok is false this function will raise an error when the domain is not
  * found.
  */
-ObjectAddress
+List *
 AlterDomainStmtObjectAddress(Node *node, bool missing_ok)
 {
 	AlterDomainStmt *stmt = castNode(AlterDomainStmt, node);
@@ -263,7 +263,7 @@ AlterDomainStmtObjectAddress(Node *node, bool missing_ok)
  * which the constraint is being renamed. When missing_ok this function will raise an
  * error if the domain cannot be found.
  */
-ObjectAddress
+List *
 DomainRenameConstraintStmtObjectAddress(Node *node, bool missing_ok)
 {
 	RenameStmt *stmt = castNode(RenameStmt, node);
@@ -278,7 +278,7 @@ DomainRenameConstraintStmtObjectAddress(Node *node, bool missing_ok)
  * being changed. When missing_ok is false this function will raise an error if the domain
  * cannot be found.
  */
-ObjectAddress
+List *
 AlterDomainOwnerStmtObjectAddress(Node *node, bool missing_ok)
 {
 	AlterOwnerStmt *stmt = castNode(AlterOwnerStmt, node);
@@ -294,7 +294,7 @@ AlterDomainOwnerStmtObjectAddress(Node *node, bool missing_ok)
  * When missing_ok is false this function will raise an error when the domain cannot be
  * found.
  */
-ObjectAddress
+List *
 RenameDomainStmtObjectAddress(Node *node, bool missing_ok)
 {
 	RenameStmt *stmt = castNode(RenameStmt, node);

src/backend/distributed/commands/extension.c

@@ -181,9 +181,12 @@ PostprocessCreateExtensionStmt(Node *node, const char *queryString)
 								(void *) createExtensionStmtSql,
 								ENABLE_DDL_PROPAGATION);
 
-	ObjectAddress extensionAddress = GetObjectAddressFromParseTree(node, false);
+	List *extensionAddresses = GetObjectAddressListFromParseTree(node, false);
 
-	EnsureDependenciesExistOnAllNodes(&extensionAddress);
+	/*  the code-path only supports a single object */
+	Assert(list_length(extensionAddresses) == 1);
+
+	EnsureAllObjectDependenciesExistOnAllNodes(extensionAddresses);
 
 	return NodeDDLTaskList(NON_COORDINATOR_NODES, commands);
 }
@@ -319,10 +322,9 @@ FilterDistributedExtensions(List *extensionObjectList)
 			continue;
 		}
 
-		ObjectAddress address = { 0 };
-		ObjectAddressSet(address, ExtensionRelationId, extensionOid);
-
-		if (!IsObjectDistributed(&address))
+		ObjectAddress *address = palloc0(sizeof(ObjectAddress));
+		ObjectAddressSet(*address, ExtensionRelationId, extensionOid);
+		if (!IsAnyObjectDistributed(list_make1(address)))
 		{
 			continue;
 		}
@@ -411,7 +413,10 @@ PreprocessAlterExtensionSchemaStmt(Node *node, const char *queryString,
 List *
 PostprocessAlterExtensionSchemaStmt(Node *node, const char *queryString)
 {
-	ObjectAddress extensionAddress = GetObjectAddressFromParseTree(node, false);
+	List *extensionAddresses = GetObjectAddressListFromParseTree(node, false);
+
+	/*  the code-path only supports a single object */
+	Assert(list_length(extensionAddresses) == 1);
 
 	if (!ShouldPropagateExtensionCommand(node))
 	{
@@ -419,7 +424,7 @@ PostprocessAlterExtensionSchemaStmt(Node *node, const char *queryString)
 	}
 
 	/* dependencies (schema) have changed let's ensure they exist */
-	EnsureDependenciesExistOnAllNodes(&extensionAddress);
+	EnsureAllObjectDependenciesExistOnAllNodes(extensionAddresses);
 
 	return NIL;
 }
@@ -504,7 +509,7 @@ PostprocessAlterExtensionCitusUpdateStmt(Node *node)
  *
  * Note that this function is not responsible for ensuring if dependencies exist on
  * nodes and satisfying these dependendencies if not exists, which is already done by
- * EnsureDependenciesExistOnAllNodes on demand. Hence, this function is just designed
+ * EnsureAllObjectDependenciesExistOnAllNodes on demand. Hence, this function is just designed
  * to be used when "ALTER EXTENSION citus UPDATE" is executed.
  * This is because we want to add existing objects that would have already been in
  * pg_dist_object if we had created them in new version of Citus to pg_dist_object.
@@ -1128,7 +1133,7 @@ GetDependentFDWsToExtension(Oid extensionId)
  * AlterExtensionSchemaStmtObjectAddress returns the ObjectAddress of the extension that is
  * the subject of the AlterObjectSchemaStmt. Errors if missing_ok is false.
  */
-ObjectAddress
+List *
 AlterExtensionSchemaStmtObjectAddress(Node *node, bool missing_ok)
 {
 	AlterObjectSchemaStmt *stmt = castNode(AlterObjectSchemaStmt, node);
@@ -1145,10 +1150,10 @@ AlterExtensionSchemaStmtObjectAddress(Node *node, bool missing_ok)
 							   extensionName)));
 	}
 
-	ObjectAddress address = { 0 };
-	ObjectAddressSet(address, ExtensionRelationId, extensionOid);
+	ObjectAddress *address = palloc0(sizeof(ObjectAddress));
+	ObjectAddressSet(*address, ExtensionRelationId, extensionOid);
 
-	return address;
+	return list_make1(address);
 }
 
 
@@ -1156,7 +1161,7 @@ AlterExtensionSchemaStmtObjectAddress(Node *node, bool missing_ok)
  * AlterExtensionUpdateStmtObjectAddress returns the ObjectAddress of the extension that is
  * the subject of the AlterExtensionStmt. Errors if missing_ok is false.
  */
-ObjectAddress
+List *
 AlterExtensionUpdateStmtObjectAddress(Node *node, bool missing_ok)
 {
 	AlterExtensionStmt *stmt = castNode(AlterExtensionStmt, node);
@@ -1171,10 +1176,10 @@ AlterExtensionUpdateStmtObjectAddress(Node *node, bool missing_ok)
 							   extensionName)));
 	}
 
-	ObjectAddress address = { 0 };
-	ObjectAddressSet(address, ExtensionRelationId, extensionOid);
+	ObjectAddress *address = palloc0(sizeof(ObjectAddress));
+	ObjectAddressSet(*address, ExtensionRelationId, extensionOid);
 
-	return address;
+	return list_make1(address);
 }
 
 

src/backend/distributed/commands/foreign_data_wrapper.c

@@ -64,6 +64,7 @@ PreprocessGrantOnFDWStmt(Node *node, const char *queryString,
 
 	EnsureCoordinator();
 
+	/*  the code-path only supports a single object */
 	Assert(list_length(stmt->objects) == 1);
 
 	char *sql = DeparseTreeNode((Node *) stmt);
@@ -87,12 +88,15 @@ NameListHasFDWOwnedByDistributedExtension(List *FDWNames)
 	foreach_ptr(FDWValue, FDWNames)
 	{
 		/* captures the extension address during lookup */
-		ObjectAddress extensionAddress = { 0 };
+		ObjectAddress *extensionAddress = palloc0(sizeof(ObjectAddress));
 		ObjectAddress FDWAddress = GetObjectAddressByFDWName(strVal(FDWValue), false);
 
-		if (IsObjectAddressOwnedByExtension(&FDWAddress, &extensionAddress))
+		ObjectAddress *copyFDWAddress = palloc0(sizeof(ObjectAddress));
+		*copyFDWAddress = FDWAddress;
+		if (IsAnyObjectAddressOwnedByExtension(list_make1(copyFDWAddress),
+											   extensionAddress))
 		{
-			if (IsObjectDistributed(&extensionAddress))
+			if (IsAnyObjectDistributed(list_make1(extensionAddress)))
 			{
 				return true;
 			}

src/backend/distributed/commands/foreign_server.c

@@ -16,6 +16,7 @@
 #include "distributed/commands.h"
 #include "distributed/deparser.h"
 #include "distributed/listutils.h"
+#include "distributed/log_utils.h"
 #include "distributed/metadata/distobject.h"
 #include "distributed/metadata_sync.h"
 #include "distributed/multi_executor.h"
@@ -29,7 +30,7 @@
 static char * GetForeignServerAlterOwnerCommand(Oid serverId);
 static Node * RecreateForeignServerStmt(Oid serverId);
 static bool NameListHasDistributedServer(List *serverNames);
-static ObjectAddress GetObjectAddressByServerName(char *serverName, bool missing_ok);
+static List * GetObjectAddressByServerName(char *serverName, bool missing_ok);
 
 
 /*
@@ -40,7 +41,7 @@ static ObjectAddress GetObjectAddressByServerName(char *serverName, bool missing
  * Never returns NULL, but the objid in the address can be invalid if missingOk
  * was set to true.
  */
-ObjectAddress
+List *
 CreateForeignServerStmtObjectAddress(Node *node, bool missing_ok)
 {
 	CreateForeignServerStmt *stmt = castNode(CreateForeignServerStmt, node);
@@ -57,7 +58,7 @@ CreateForeignServerStmtObjectAddress(Node *node, bool missing_ok)
  * Never returns NULL, but the objid in the address can be invalid if missingOk
  * was set to true.
  */
-ObjectAddress
+List *
 AlterForeignServerStmtObjectAddress(Node *node, bool missing_ok)
 {
 	AlterForeignServerStmt *stmt = castNode(AlterForeignServerStmt, node);
@@ -101,6 +102,7 @@ PreprocessGrantOnForeignServerStmt(Node *node, const char *queryString,
 
 	EnsureCoordinator();
 
+	/*  the code-path only supports a single object */
 	Assert(list_length(stmt->objects) == 1);
 
 	char *sql = DeparseTreeNode((Node *) stmt);
@@ -121,7 +123,7 @@ PreprocessGrantOnForeignServerStmt(Node *node, const char *queryString,
  * Never returns NULL, but the objid in the address can be invalid if missingOk
  * was set to true.
  */
-ObjectAddress
+List *
 RenameForeignServerStmtObjectAddress(Node *node, bool missing_ok)
 {
 	RenameStmt *stmt = castNode(RenameStmt, node);
@@ -139,7 +141,7 @@ RenameForeignServerStmtObjectAddress(Node *node, bool missing_ok)
  * Never returns NULL, but the objid in the address can be invalid if missingOk
  * was set to true.
  */
-ObjectAddress
+List *
 AlterForeignServerOwnerStmtObjectAddress(Node *node, bool missing_ok)
 {
 	AlterOwnerStmt *stmt = castNode(AlterOwnerStmt, node);
@@ -245,9 +247,15 @@ NameListHasDistributedServer(List *serverNames)
 	String *serverValue = NULL;
 	foreach_ptr(serverValue, serverNames)
 	{
-		ObjectAddress address = GetObjectAddressByServerName(strVal(serverValue), false);
+		List *addresses = GetObjectAddressByServerName(strVal(serverValue), false);
 
-		if (IsObjectDistributed(&address))
+		/*  the code-path only supports a single object */
+		Assert(list_length(addresses) == 1);
+
+		/* We have already asserted that we have exactly 1 address in the addresses. */
+		ObjectAddress *address = linitial(addresses);
+
+		if (IsAnyObjectDistributed(list_make1(address)))
 		{
 			return true;
 		}
@@ -257,13 +265,13 @@ NameListHasDistributedServer(List *serverNames)
 }
 
 
-static ObjectAddress
+static List *
 GetObjectAddressByServerName(char *serverName, bool missing_ok)
 {
 	ForeignServer *server = GetForeignServerByName(serverName, missing_ok);
 	Oid serverOid = server->serverid;
-	ObjectAddress address = { 0 };
-	ObjectAddressSet(address, ForeignServerRelationId, serverOid);
+	ObjectAddress *address = palloc0(sizeof(ObjectAddress));
+	ObjectAddressSet(*address, ForeignServerRelationId, serverOid);
 
-	return address;
+	return list_make1(address);
 }

src/backend/distributed/commands/function.c

@@ -88,9 +88,9 @@ static void EnsureFunctionCanBeColocatedWithTable(Oid functionOid, Oid
 static bool ShouldPropagateCreateFunction(CreateFunctionStmt *stmt);
 static bool ShouldPropagateAlterFunction(const ObjectAddress *address);
 static bool ShouldAddFunctionSignature(FunctionParameterMode mode);
-static ObjectAddress FunctionToObjectAddress(ObjectType objectType,
-											 ObjectWithArgs *objectWithArgs,
-											 bool missing_ok);
+static List * FunctionToObjectAddress(ObjectType objectType,
+									  ObjectWithArgs *objectWithArgs,
+									  bool missing_ok);
 static void ErrorIfUnsupportedAlterFunctionStmt(AlterFunctionStmt *stmt);
 static char * quote_qualified_func_name(Oid funcOid);
 static void DistributeFunctionWithDistributionArgument(RegProcedure funcOid,
@@ -128,7 +128,7 @@ create_distributed_function(PG_FUNCTION_ARGS)
 	text *colocateWithText = NULL; /* optional */
 
 	StringInfoData ddlCommand = { 0 };
-	ObjectAddress functionAddress = { 0 };
+	ObjectAddress *functionAddress = palloc0(sizeof(ObjectAddress));
 
 	Oid distributionArgumentOid = InvalidOid;
 	bool colocatedWithReferenceTable = false;
@@ -203,9 +203,9 @@ create_distributed_function(PG_FUNCTION_ARGS)
 	EnsureCoordinator();
 	EnsureFunctionOwner(funcOid);
 
-	ObjectAddressSet(functionAddress, ProcedureRelationId, funcOid);
+	ObjectAddressSet(*functionAddress, ProcedureRelationId, funcOid);
 
-	if (RecreateSameNonColocatedFunction(functionAddress,
+	if (RecreateSameNonColocatedFunction(*functionAddress,
 										 distributionArgumentName,
 										 colocateWithTableNameDefault,
 										 forceDelegationAddress))
@@ -224,9 +224,10 @@ create_distributed_function(PG_FUNCTION_ARGS)
 	 * pg_dist_object, and not propagate the CREATE FUNCTION. Function
 	 * will be created by the virtue of the extension creation.
 	 */
-	if (IsObjectAddressOwnedByExtension(&functionAddress, &extensionAddress))
+	if (IsAnyObjectAddressOwnedByExtension(list_make1(functionAddress),
+										   &extensionAddress))
 	{
-		EnsureExtensionFunctionCanBeDistributed(functionAddress, extensionAddress,
+		EnsureExtensionFunctionCanBeDistributed(*functionAddress, extensionAddress,
 												distributionArgumentName);
 	}
 	else
@@ -237,7 +238,7 @@ create_distributed_function(PG_FUNCTION_ARGS)
 		 */
 		EnsureSequentialMode(OBJECT_FUNCTION);
 
-		EnsureDependenciesExistOnAllNodes(&functionAddress);
+		EnsureAllObjectDependenciesExistOnAllNodes(list_make1(functionAddress));
 
 		const char *createFunctionSQL = GetFunctionDDLCommand(funcOid, true);
 		const char *alterFunctionOwnerSQL = GetFunctionAlterOwnerCommand(funcOid);
@@ -257,7 +258,7 @@ create_distributed_function(PG_FUNCTION_ARGS)
 								   ddlCommand.data);
 	}
 
-	MarkObjectDistributed(&functionAddress);
+	MarkObjectDistributed(functionAddress);
 
 	if (distributionArgumentName != NULL)
 	{
@@ -272,12 +273,12 @@ create_distributed_function(PG_FUNCTION_ARGS)
 												   distributionArgumentOid,
 												   colocateWithTableName,
 												   forceDelegationAddress,
-												   &functionAddress);
+												   functionAddress);
 	}
 	else if (!colocatedWithReferenceTable)
 	{
 		DistributeFunctionColocatedWithDistributedTable(funcOid, colocateWithTableName,
-														&functionAddress);
+														functionAddress);
 	}
 	else if (colocatedWithReferenceTable)
 	{
@@ -288,7 +289,7 @@ create_distributed_function(PG_FUNCTION_ARGS)
 		 */
 		ErrorIfAnyNodeDoesNotHaveMetadata();
 
-		DistributeFunctionColocatedWithReferenceTable(&functionAddress);
+		DistributeFunctionColocatedWithReferenceTable(functionAddress);
 	}
 
 	PG_RETURN_VOID();
@@ -1308,7 +1309,7 @@ ShouldPropagateAlterFunction(const ObjectAddress *address)
 		return false;
 	}
 
-	if (!IsObjectDistributed(address))
+	if (!IsAnyObjectDistributed(list_make1((ObjectAddress *) address)))
 	{
 		/* do not propagate alter function for non-distributed functions */
 		return false;
@@ -1373,15 +1374,19 @@ PostprocessCreateFunctionStmt(Node *node, const char *queryString)
 		return NIL;
 	}
 
-	ObjectAddress functionAddress = GetObjectAddressFromParseTree((Node *) stmt, false);
+	List *functionAddresses = GetObjectAddressListFromParseTree((Node *) stmt, false);
 
-	if (IsObjectAddressOwnedByExtension(&functionAddress, NULL))
+	/*  the code-path only supports a single object */
+	Assert(list_length(functionAddresses) == 1);
+
+	if (IsAnyObjectAddressOwnedByExtension(functionAddresses, NULL))
 	{
 		return NIL;
 	}
 
 	/* If the function has any unsupported dependency, create it locally */
-	DeferredErrorMessage *errMsg = DeferErrorIfHasUnsupportedDependency(&functionAddress);
+	DeferredErrorMessage *errMsg = DeferErrorIfAnyObjectHasUnsupportedDependency(
+		functionAddresses);
 
 	if (errMsg != NULL)
 	{
@@ -1389,11 +1394,14 @@ PostprocessCreateFunctionStmt(Node *node, const char *queryString)
 		return NIL;
 	}
 
-	EnsureDependenciesExistOnAllNodes(&functionAddress);
+	EnsureAllObjectDependenciesExistOnAllNodes(functionAddresses);
+
+	/* We have already asserted that we have exactly 1 address in the addresses. */
+	ObjectAddress *functionAddress = linitial(functionAddresses);
 
 	List *commands = list_make1(DISABLE_DDL_PROPAGATION);
 	commands = list_concat(commands, CreateFunctionDDLCommandsIdempotent(
-							   &functionAddress));
+							   functionAddress));
 	commands = list_concat(commands, list_make1(ENABLE_DDL_PROPAGATION));
 
 	return NodeDDLTaskList(NON_COORDINATOR_NODES, commands);
@@ -1405,7 +1413,7 @@ PostprocessCreateFunctionStmt(Node *node, const char *queryString)
  * CREATE [OR REPLACE] FUNCTION statement. If missing_ok is false it will error with the
  * normal postgres error for unfound functions.
  */
-ObjectAddress
+List *
 CreateFunctionStmtObjectAddress(Node *node, bool missing_ok)
 {
 	CreateFunctionStmt *stmt = castNode(CreateFunctionStmt, node);
@@ -1440,7 +1448,7 @@ CreateFunctionStmtObjectAddress(Node *node, bool missing_ok)
  *
  * objectId in the address can be invalid if missing_ok was set to true.
  */
-ObjectAddress
+List *
 DefineAggregateStmtObjectAddress(Node *node, bool missing_ok)
 {
 	DefineStmt *stmt = castNode(DefineStmt, node);
@@ -1494,8 +1502,15 @@ PreprocessAlterFunctionStmt(Node *node, const char *queryString,
 	AlterFunctionStmt *stmt = castNode(AlterFunctionStmt, node);
 	AssertObjectTypeIsFunctional(stmt->objtype);
 
-	ObjectAddress address = GetObjectAddressFromParseTree((Node *) stmt, false);
-	if (!ShouldPropagateAlterFunction(&address))
+	List *addresses = GetObjectAddressListFromParseTree((Node *) stmt, false);
+
+	/*  the code-path only supports a single object */
+	Assert(list_length(addresses) == 1);
+
+	/* We have already asserted that we have exactly 1 address in the addresses. */
+	ObjectAddress *address = linitial(addresses);
+
+	if (!ShouldPropagateAlterFunction(address))
 	{
 		return NIL;
 	}
@@ -1549,20 +1564,26 @@ PreprocessAlterFunctionDependsStmt(Node *node, const char *queryString,
 		return NIL;
 	}
 
-	ObjectAddress address = GetObjectAddressFromParseTree((Node *) stmt, true);
-	if (!IsObjectDistributed(&address))
+	List *addresses = GetObjectAddressListFromParseTree((Node *) stmt, true);
+
+	/*  the code-path only supports a single object */
+	Assert(list_length(addresses) == 1);
+
+	if (!IsAnyObjectDistributed(addresses))
 	{
 		return NIL;
 	}
 
+	/* We have already asserted that we have exactly 1 address in the addresses. */
+	ObjectAddress *address = linitial(addresses);
+
 	/*
 	 * Distributed objects should not start depending on an extension, this will break
 	 * the dependency resolving mechanism we use to replicate distributed objects to new
 	 * workers
 	 */
-
 	const char *functionName =
-		getObjectIdentity_compat(&address, /* missingOk: */ false);
+		getObjectIdentity_compat(address, /* missingOk: */ false);
 	ereport(ERROR, (errmsg("distrtibuted functions are not allowed to depend on an "
 						   "extension"),
 					errdetail("Function \"%s\" is already distributed. Functions from "
@@ -1576,7 +1597,7 @@ PreprocessAlterFunctionDependsStmt(Node *node, const char *queryString,
  * is the subject of an ALTER FUNCTION ... DEPENS ON EXTENSION ... statement. If
  * missing_ok is set to false the lookup will raise an error.
  */
-ObjectAddress
+List *
 AlterFunctionDependsStmtObjectAddress(Node *node, bool missing_ok)
 {
 	AlterObjectDependsStmt *stmt = castNode(AlterObjectDependsStmt, node);
@@ -1592,7 +1613,7 @@ AlterFunctionDependsStmtObjectAddress(Node *node, bool missing_ok)
  * AlterFunctionStmt. If missing_ok is set to false an error will be raised if postgres
  * was unable to find the function/procedure that was the target of the statement.
  */
-ObjectAddress
+List *
 AlterFunctionStmtObjectAddress(Node *node, bool missing_ok)
 {
 	AlterFunctionStmt *stmt = castNode(AlterFunctionStmt, node);
@@ -1604,7 +1625,7 @@ AlterFunctionStmtObjectAddress(Node *node, bool missing_ok)
  * RenameFunctionStmtObjectAddress returns the ObjectAddress of the function that is the
  * subject of the RenameStmt. Errors if missing_ok is false.
  */
-ObjectAddress
+List *
 RenameFunctionStmtObjectAddress(Node *node, bool missing_ok)
 {
 	RenameStmt *stmt = castNode(RenameStmt, node);
@@ -1617,7 +1638,7 @@ RenameFunctionStmtObjectAddress(Node *node, bool missing_ok)
  * AlterFunctionOwnerObjectAddress returns the ObjectAddress of the function that is the
  * subject of the AlterOwnerStmt. Errors if missing_ok is false.
  */
-ObjectAddress
+List *
 AlterFunctionOwnerObjectAddress(Node *node, bool missing_ok)
 {
 	AlterOwnerStmt *stmt = castNode(AlterOwnerStmt, node);
@@ -1635,7 +1656,7 @@ AlterFunctionOwnerObjectAddress(Node *node, bool missing_ok)
  * the new schema. Errors if missing_ok is false and the type cannot be found in either of
  * the schemas.
  */
-ObjectAddress
+List *
 AlterFunctionSchemaStmtObjectAddress(Node *node, bool missing_ok)
 {
 	AlterObjectSchemaStmt *stmt = castNode(AlterObjectSchemaStmt, node);
@@ -1680,10 +1701,10 @@ AlterFunctionSchemaStmtObjectAddress(Node *node, bool missing_ok)
 		}
 	}
 
-	ObjectAddress address = { 0 };
-	ObjectAddressSet(address, ProcedureRelationId, funcOid);
+	ObjectAddress *address = palloc0(sizeof(ObjectAddress));
+	ObjectAddressSet(*address, ProcedureRelationId, funcOid);
 
-	return address;
+	return list_make1(address);
 }
 
 
@@ -1827,17 +1848,17 @@ ShouldAddFunctionSignature(FunctionParameterMode mode)
  * Function/Procedure/Aggregate. If missing_ok is set to false an error will be
  * raised by postgres explaining the Function/Procedure could not be found.
  */
-static ObjectAddress
+static List *
 FunctionToObjectAddress(ObjectType objectType, ObjectWithArgs *objectWithArgs,
 						bool missing_ok)
 {
 	AssertObjectTypeIsFunctional(objectType);
 
 	Oid funcOid = LookupFuncWithArgs(objectType, objectWithArgs, missing_ok);
-	ObjectAddress address = { 0 };
-	ObjectAddressSet(address, ProcedureRelationId, funcOid);
+	ObjectAddress *address = palloc0(sizeof(ObjectAddress));
+	ObjectAddressSet(*address, ProcedureRelationId, funcOid);
 
-	return address;
+	return list_make1(address);
 }
 
 
@@ -1920,7 +1941,7 @@ EnsureExtensionFunctionCanBeDistributed(const ObjectAddress functionAddress,
 	/*
 	 * Ensure corresponding extension is in pg_dist_object.
 	 * Functions owned by an extension are depending internally on that extension,
-	 * hence EnsureDependenciesExistOnAllNodes() creates the extension, which in
+	 * hence EnsureAllObjectDependenciesExistOnAllNodes() creates the extension, which in
 	 * turn creates the function, and thus we don't have to create it ourself like
 	 * we do for non-extension functions.
 	 */
@@ -1930,7 +1951,9 @@ EnsureExtensionFunctionCanBeDistributed(const ObjectAddress functionAddress,
 							get_extension_name(extensionAddress.objectId),
 							get_func_name(functionAddress.objectId))));
 
-	EnsureDependenciesExistOnAllNodes(&functionAddress);
+	ObjectAddress *copyFunctionAddress = palloc0(sizeof(ObjectAddress));
+	*copyFunctionAddress = functionAddress;
+	EnsureAllObjectDependenciesExistOnAllNodes(list_make1(copyFunctionAddress));
 }
 
 
@@ -2004,7 +2027,7 @@ PostprocessGrantOnFunctionStmt(Node *node, const char *queryString)
 	ObjectAddress *functionAddress = NULL;
 	foreach_ptr(functionAddress, distributedFunctions)
 	{
-		EnsureDependenciesExistOnAllNodes(functionAddress);
+		EnsureAllObjectDependenciesExistOnAllNodes(list_make1(functionAddress));
 	}
 	return NIL;
 }
@@ -2083,7 +2106,7 @@ FilterDistributedFunctions(GrantStmt *grantStmt)
 			 * if this function from GRANT .. ON FUNCTION .. is a distributed
 			 * function, add it to the list
 			 */
-			if (IsObjectDistributed(functionAddress))
+			if (IsAnyObjectDistributed(list_make1(functionAddress)))
 			{
 				grantFunctionList = lappend(grantFunctionList, functionAddress);
 			}

src/backend/distributed/commands/grant.c

@@ -238,9 +238,9 @@ CollectGrantTableIdList(GrantStmt *grantStmt)
 			}
 
 			/* check for distributed sequences included in GRANT ON TABLE statement */
-			ObjectAddress sequenceAddress = { 0 };
-			ObjectAddressSet(sequenceAddress, RelationRelationId, relationId);
-			if (IsObjectDistributed(&sequenceAddress))
+			ObjectAddress *sequenceAddress = palloc0(sizeof(ObjectAddress));
+			ObjectAddressSet(*sequenceAddress, RelationRelationId, relationId);
+			if (IsAnyObjectDistributed(list_make1(sequenceAddress)))
 			{
 				grantTableList = lappend_oid(grantTableList, relationId);
 			}

src/backend/distributed/commands/index.c

@@ -761,9 +761,9 @@ PostprocessIndexStmt(Node *node, const char *queryString)
 	Oid indexRelationId = get_relname_relid(indexStmt->idxname, schemaId);
 
 	/* ensure dependencies of index exist on all nodes */
-	ObjectAddress address = { 0 };
-	ObjectAddressSet(address, RelationRelationId, indexRelationId);
-	EnsureDependenciesExistOnAllNodes(&address);
+	ObjectAddress *address = palloc0(sizeof(ObjectAddress));
+	ObjectAddressSet(*address, RelationRelationId, indexRelationId);
+	EnsureAllObjectDependenciesExistOnAllNodes(list_make1(address));
 
 	/* furtheron we are only processing CONCURRENT index statements */
 	if (!indexStmt->concurrent)
@@ -772,7 +772,7 @@ PostprocessIndexStmt(Node *node, const char *queryString)
 	}
 
 	/*
-	 * EnsureDependenciesExistOnAllNodes could have distributed objects that are required
+	 * EnsureAllObjectDependenciesExistOnAllNodes could have distributed objects that are required
 	 * by this index. During the propagation process an active snapshout might be left as
 	 * a side effect of inserting the local tuples via SPI. To not leak a snapshot like
 	 * that we will pop any snapshot if we have any right before we commit.

src/backend/distributed/commands/role.c

@@ -74,7 +74,7 @@ static Node * makeFloatConst(char *str, int location);
 static const char * WrapQueryInAlterRoleIfExistsCall(const char *query, RoleSpec *role);
 static VariableSetStmt * MakeVariableSetStmt(const char *config);
 static int ConfigGenericNameCompare(const void *lhs, const void *rhs);
-static ObjectAddress RoleSpecToObjectAddress(RoleSpec *role, bool missing_ok);
+static List * RoleSpecToObjectAddress(RoleSpec *role, bool missing_ok);
 
 /* controlled via GUC */
 bool EnableCreateRolePropagation = true;
@@ -87,7 +87,7 @@ bool EnableAlterRoleSetPropagation = true;
  * AlterRoleStmt. If missing_ok is set to false an error will be raised if postgres
  * was unable to find the role that was the target of the statement.
  */
-ObjectAddress
+List *
 AlterRoleStmtObjectAddress(Node *node, bool missing_ok)
 {
 	AlterRoleStmt *stmt = castNode(AlterRoleStmt, node);
@@ -100,7 +100,7 @@ AlterRoleStmtObjectAddress(Node *node, bool missing_ok)
  * AlterRoleSetStmt. If missing_ok is set to false an error will be raised if postgres
  * was unable to find the role that was the target of the statement.
  */
-ObjectAddress
+List *
 AlterRoleSetStmtObjectAddress(Node *node, bool missing_ok)
 {
 	AlterRoleSetStmt *stmt = castNode(AlterRoleSetStmt, node);
@@ -113,19 +113,19 @@ AlterRoleSetStmtObjectAddress(Node *node, bool missing_ok)
  * RoleSpec. If missing_ok is set to false an error will be raised by postgres
  * explaining the Role could not be found.
  */
-static ObjectAddress
+static List *
 RoleSpecToObjectAddress(RoleSpec *role, bool missing_ok)
 {
-	ObjectAddress address = { 0 };
+	ObjectAddress *address = palloc0(sizeof(ObjectAddress));
 
 	if (role != NULL)
 	{
 		/* roles can be NULL for statements on ALL roles eg. ALTER ROLE ALL SET ... */
 		Oid roleOid = get_rolespec_oid(role, missing_ok);
-		ObjectAddressSet(address, AuthIdRelationId, roleOid);
+		ObjectAddressSet(*address, AuthIdRelationId, roleOid);
 	}
 
-	return address;
+	return list_make1(address);
 }
 
 
@@ -137,8 +137,12 @@ RoleSpecToObjectAddress(RoleSpec *role, bool missing_ok)
 List *
 PostprocessAlterRoleStmt(Node *node, const char *queryString)
 {
-	ObjectAddress address = GetObjectAddressFromParseTree(node, false);
-	if (!ShouldPropagateObject(&address))
+	List *addresses = GetObjectAddressListFromParseTree(node, false);
+
+	/*  the code-path only supports a single object */
+	Assert(list_length(addresses) == 1);
+
+	if (!ShouldPropagateAnyObject(addresses))
 	{
 		return NIL;
 	}
@@ -208,14 +212,17 @@ PreprocessAlterRoleSetStmt(Node *node, const char *queryString,
 		return NIL;
 	}
 
-	ObjectAddress address = GetObjectAddressFromParseTree(node, false);
+	List *addresses = GetObjectAddressListFromParseTree(node, false);
+
+	/*  the code-path only supports a single object */
+	Assert(list_length(addresses) == 1);
 
 	/*
 	 * stmt->role could be NULL when the statement is on 'ALL' roles, we do propagate for
 	 * ALL roles. If it is not NULL the role is for a specific role. If that role is not
 	 * distributed we will not propagate the statement
 	 */
-	if (stmt->role != NULL && !IsObjectDistributed(&address))
+	if (stmt->role != NULL && !IsAnyObjectDistributed(addresses))
 	{
 		return NIL;
 	}
@@ -1056,7 +1063,6 @@ FilterDistributedRoles(List *roles)
 	foreach_ptr(roleNode, roles)
 	{
 		RoleSpec *role = castNode(RoleSpec, roleNode);
-		ObjectAddress roleAddress = { 0 };
 		Oid roleOid = get_rolespec_oid(role, true);
 		if (roleOid == InvalidOid)
 		{
@@ -1066,8 +1072,9 @@ FilterDistributedRoles(List *roles)
 			 */
 			continue;
 		}
-		ObjectAddressSet(roleAddress, AuthIdRelationId, roleOid);
-		if (IsObjectDistributed(&roleAddress))
+		ObjectAddress *roleAddress = palloc0(sizeof(ObjectAddress));
+		ObjectAddressSet(*roleAddress, AuthIdRelationId, roleOid);
+		if (IsAnyObjectDistributed(list_make1(roleAddress)))
 		{
 			distributedRoles = lappend(distributedRoles, role);
 		}
@@ -1137,12 +1144,13 @@ PostprocessGrantRoleStmt(Node *node, const char *queryString)
 	RoleSpec *role = NULL;
 	foreach_ptr(role, stmt->grantee_roles)
 	{
-		ObjectAddress roleAddress = { 0 };
 		Oid roleOid = get_rolespec_oid(role, false);
-		ObjectAddressSet(roleAddress, AuthIdRelationId, roleOid);
-		if (IsObjectDistributed(&roleAddress))
+		ObjectAddress *roleAddress = palloc0(sizeof(ObjectAddress));
+		ObjectAddressSet(*roleAddress, AuthIdRelationId, roleOid);
+
+		if (IsAnyObjectDistributed(list_make1(roleAddress)))
 		{
-			EnsureDependenciesExistOnAllNodes(&roleAddress);
+			EnsureAllObjectDependenciesExistOnAllNodes(list_make1(roleAddress));
 		}
 	}
 	return NIL;
@@ -1179,15 +1187,15 @@ ConfigGenericNameCompare(const void *a, const void *b)
  * Never returns NULL, but the objid in the address could be invalid if missing_ok was set
  * to true.
  */
-ObjectAddress
+List *
 CreateRoleStmtObjectAddress(Node *node, bool missing_ok)
 {
 	CreateRoleStmt *stmt = castNode(CreateRoleStmt, node);
 	Oid roleOid = get_role_oid(stmt->role, missing_ok);
-	ObjectAddress roleAddress = { 0 };
-	ObjectAddressSet(roleAddress, AuthIdRelationId, roleOid);
+	ObjectAddress *roleAddress = palloc0(sizeof(ObjectAddress));
+	ObjectAddressSet(*roleAddress, AuthIdRelationId, roleOid);
 
-	return roleAddress;
+	return list_make1(roleAddress);
 }
 
 

src/backend/distributed/commands/schema.c

@@ -40,7 +40,7 @@
 #include "utils/relcache.h"
 
 
-static ObjectAddress GetObjectAddressBySchemaName(char *schemaName, bool missing_ok);
+static List * GetObjectAddressBySchemaName(char *schemaName, bool missing_ok);
 static List * FilterDistributedSchemas(List *schemas);
 static bool SchemaHasDistributedTableWithFKey(char *schemaName);
 static bool ShouldPropagateCreateSchemaStmt(void);
@@ -183,7 +183,7 @@ PreprocessGrantOnSchemaStmt(Node *node, const char *queryString,
  * CreateSchemaStmtObjectAddress returns the ObjectAddress of the schema that is
  * the object of the CreateSchemaStmt. Errors if missing_ok is false.
  */
-ObjectAddress
+List *
 CreateSchemaStmtObjectAddress(Node *node, bool missing_ok)
 {
 	CreateSchemaStmt *stmt = castNode(CreateSchemaStmt, node);
@@ -213,7 +213,7 @@ CreateSchemaStmtObjectAddress(Node *node, bool missing_ok)
  * AlterSchemaRenameStmtObjectAddress returns the ObjectAddress of the schema that is
  * the object of the RenameStmt. Errors if missing_ok is false.
  */
-ObjectAddress
+List *
 AlterSchemaRenameStmtObjectAddress(Node *node, bool missing_ok)
 {
 	RenameStmt *stmt = castNode(RenameStmt, node);
@@ -227,15 +227,15 @@ AlterSchemaRenameStmtObjectAddress(Node *node, bool missing_ok)
  * GetObjectAddressBySchemaName returns the ObjectAddress of the schema with the
  * given name. Errors out if schema is not found and missing_ok is false.
  */
-ObjectAddress
+List *
 GetObjectAddressBySchemaName(char *schemaName, bool missing_ok)
 {
 	Oid schemaOid = get_namespace_oid(schemaName, missing_ok);
 
-	ObjectAddress address = { 0 };
-	ObjectAddressSet(address, NamespaceRelationId, schemaOid);
+	ObjectAddress *address = palloc0(sizeof(ObjectAddress));
+	ObjectAddressSet(*address, NamespaceRelationId, schemaOid);
 
-	return address;
+	return list_make1(address);
 }
 
 
@@ -259,10 +259,9 @@ FilterDistributedSchemas(List *schemas)
 			continue;
 		}
 
-		ObjectAddress address = { 0 };
-		ObjectAddressSet(address, NamespaceRelationId, schemaOid);
-
-		if (!IsObjectDistributed(&address))
+		ObjectAddress *address = palloc0(sizeof(ObjectAddress));
+		ObjectAddressSet(*address, NamespaceRelationId, schemaOid);
+		if (!IsAnyObjectDistributed(list_make1(address)))
 		{
 			continue;
 		}

src/backend/distributed/commands/sequence.c

@@ -268,18 +268,16 @@ PreprocessDropSequenceStmt(Node *node, const char *queryString,
 
 		Oid seqOid = RangeVarGetRelid(seq, NoLock, stmt->missing_ok);
 
-		ObjectAddress sequenceAddress = { 0 };
-		ObjectAddressSet(sequenceAddress, RelationRelationId, seqOid);
-
-		if (!IsObjectDistributed(&sequenceAddress))
+		ObjectAddress *sequenceAddress = palloc0(sizeof(ObjectAddress));
+		ObjectAddressSet(*sequenceAddress, RelationRelationId, seqOid);
+		if (!IsAnyObjectDistributed(list_make1(sequenceAddress)))
 		{
 			continue;
 		}
 
 		/* collect information for all distributed sequences */
-		ObjectAddress *addressp = palloc(sizeof(ObjectAddress));
-		*addressp = sequenceAddress;
-		distributedSequenceAddresses = lappend(distributedSequenceAddresses, addressp);
+		distributedSequenceAddresses = lappend(distributedSequenceAddresses,
+											   sequenceAddress);
 		distributedSequencesList = lappend(distributedSequencesList, objectNameList);
 	}
 
@@ -334,10 +332,13 @@ PreprocessRenameSequenceStmt(Node *node, const char *queryString, ProcessUtility
 	RenameStmt *stmt = castNode(RenameStmt, node);
 	Assert(stmt->renameType == OBJECT_SEQUENCE);
 
-	ObjectAddress address = GetObjectAddressFromParseTree((Node *) stmt,
-														  stmt->missing_ok);
+	List *addresses = GetObjectAddressListFromParseTree((Node *) stmt,
+														stmt->missing_ok);
 
-	if (!ShouldPropagateObject(&address))
+	/*  the code-path only supports a single object */
+	Assert(list_length(addresses) == 1);
+
+	if (!ShouldPropagateAnyObject(addresses))
 	{
 		return NIL;
 	}
@@ -358,7 +359,7 @@ PreprocessRenameSequenceStmt(Node *node, const char *queryString, ProcessUtility
  * RenameSequenceStmtObjectAddress returns the ObjectAddress of the sequence that is the
  * subject of the RenameStmt.
  */
-ObjectAddress
+List *
 RenameSequenceStmtObjectAddress(Node *node, bool missing_ok)
 {
 	RenameStmt *stmt = castNode(RenameStmt, node);
@@ -366,10 +367,10 @@ RenameSequenceStmtObjectAddress(Node *node, bool missing_ok)
 
 	RangeVar *sequence = stmt->relation;
 	Oid seqOid = RangeVarGetRelid(sequence, NoLock, missing_ok);
-	ObjectAddress sequenceAddress = { 0 };
-	ObjectAddressSet(sequenceAddress, RelationRelationId, seqOid);
+	ObjectAddress *sequenceAddress = palloc0(sizeof(ObjectAddress));
+	ObjectAddressSet(*sequenceAddress, RelationRelationId, seqOid);
 
-	return sequenceAddress;
+	return list_make1(sequenceAddress);
 }
 
 
@@ -395,21 +396,27 @@ PreprocessAlterSequenceStmt(Node *node, const char *queryString,
 {
 	AlterSeqStmt *stmt = castNode(AlterSeqStmt, node);
 
-	ObjectAddress address = GetObjectAddressFromParseTree((Node *) stmt,
-														  stmt->missing_ok);
+	List *addresses = GetObjectAddressListFromParseTree((Node *) stmt,
+														stmt->missing_ok);
+
+	/*  the code-path only supports a single object */
+	Assert(list_length(addresses) == 1);
 
 	/* error out if the sequence is distributed */
-	if (IsObjectDistributed(&address))
+	if (IsAnyObjectDistributed(addresses))
 	{
 		ereport(ERROR, (errmsg(
 							"Altering a distributed sequence is currently not supported.")));
 	}
 
+	/* We have already asserted that we have exactly 1 address in the addresses. */
+	ObjectAddress *address = linitial(addresses);
+
 	/*
 	 * error out if the sequence is used in a distributed table
 	 * and this is an ALTER SEQUENCE .. AS .. statement
 	 */
-	Oid citusTableId = SequenceUsedInDistributedTable(&address);
+	Oid citusTableId = SequenceUsedInDistributedTable(address);
 	if (citusTableId != InvalidOid)
 	{
 		List *options = stmt->options;
@@ -463,6 +470,7 @@ SequenceUsedInDistributedTable(const ObjectAddress *sequenceAddress)
 			}
 		}
 	}
+
 	return InvalidOid;
 }
 
@@ -471,17 +479,17 @@ SequenceUsedInDistributedTable(const ObjectAddress *sequenceAddress)
  * AlterSequenceStmtObjectAddress returns the ObjectAddress of the sequence that is the
  * subject of the AlterSeqStmt.
  */
-ObjectAddress
+List *
 AlterSequenceStmtObjectAddress(Node *node, bool missing_ok)
 {
 	AlterSeqStmt *stmt = castNode(AlterSeqStmt, node);
 
 	RangeVar *sequence = stmt->sequence;
 	Oid seqOid = RangeVarGetRelid(sequence, NoLock, stmt->missing_ok);
-	ObjectAddress sequenceAddress = { 0 };
-	ObjectAddressSet(sequenceAddress, RelationRelationId, seqOid);
+	ObjectAddress *sequenceAddress = palloc0(sizeof(ObjectAddress));
+	ObjectAddressSet(*sequenceAddress, RelationRelationId, seqOid);
 
-	return sequenceAddress;
+	return list_make1(sequenceAddress);
 }
 
 
@@ -498,9 +506,13 @@ PreprocessAlterSequenceSchemaStmt(Node *node, const char *queryString,
 	AlterObjectSchemaStmt *stmt = castNode(AlterObjectSchemaStmt, node);
 	Assert(stmt->objectType == OBJECT_SEQUENCE);
 
-	ObjectAddress address = GetObjectAddressFromParseTree((Node *) stmt,
-														  stmt->missing_ok);
-	if (!ShouldPropagateObject(&address))
+	List *addresses = GetObjectAddressListFromParseTree((Node *) stmt,
+														stmt->missing_ok);
+
+	/*  the code-path only supports a single object */
+	Assert(list_length(addresses) == 1);
+
+	if (!ShouldPropagateAnyObject(addresses))
 	{
 		return NIL;
 	}
@@ -521,7 +533,7 @@ PreprocessAlterSequenceSchemaStmt(Node *node, const char *queryString,
  * AlterSequenceSchemaStmtObjectAddress returns the ObjectAddress of the sequence that is
  * the subject of the AlterObjectSchemaStmt.
  */
-ObjectAddress
+List *
 AlterSequenceSchemaStmtObjectAddress(Node *node, bool missing_ok)
 {
 	AlterObjectSchemaStmt *stmt = castNode(AlterObjectSchemaStmt, node);
@@ -555,10 +567,10 @@ AlterSequenceSchemaStmtObjectAddress(Node *node, bool missing_ok)
 		}
 	}
 
-	ObjectAddress sequenceAddress = { 0 };
-	ObjectAddressSet(sequenceAddress, RelationRelationId, seqOid);
+	ObjectAddress *sequenceAddress = palloc0(sizeof(ObjectAddress));
+	ObjectAddressSet(*sequenceAddress, RelationRelationId, seqOid);
 
-	return sequenceAddress;
+	return list_make1(sequenceAddress);
 }
 
 
@@ -572,16 +584,19 @@ PostprocessAlterSequenceSchemaStmt(Node *node, const char *queryString)
 {
 	AlterObjectSchemaStmt *stmt = castNode(AlterObjectSchemaStmt, node);
 	Assert(stmt->objectType == OBJECT_SEQUENCE);
-	ObjectAddress address = GetObjectAddressFromParseTree((Node *) stmt,
-														  stmt->missing_ok);
+	List *addresses = GetObjectAddressListFromParseTree((Node *) stmt,
+														stmt->missing_ok);
 
-	if (!ShouldPropagateObject(&address))
+	/*  the code-path only supports a single object */
+	Assert(list_length(addresses) == 1);
+
+	if (!ShouldPropagateAnyObject(addresses))
 	{
 		return NIL;
 	}
 
 	/* dependencies have changed (schema) let's ensure they exist */
-	EnsureDependenciesExistOnAllNodes(&address);
+	EnsureAllObjectDependenciesExistOnAllNodes(addresses);
 
 	return NIL;
 }
@@ -601,8 +616,12 @@ PreprocessAlterSequenceOwnerStmt(Node *node, const char *queryString,
 	AlterTableStmt *stmt = castNode(AlterTableStmt, node);
 	Assert(AlterTableStmtObjType_compat(stmt) == OBJECT_SEQUENCE);
 
-	ObjectAddress sequenceAddress = GetObjectAddressFromParseTree((Node *) stmt, false);
-	if (!ShouldPropagateObject(&sequenceAddress))
+	List *sequenceAddresses = GetObjectAddressListFromParseTree((Node *) stmt, false);
+
+	/*  the code-path only supports a single object */
+	Assert(list_length(sequenceAddresses) == 1);
+
+	if (!ShouldPropagateAnyObject(sequenceAddresses))
 	{
 		return NIL;
 	}
@@ -623,7 +642,7 @@ PreprocessAlterSequenceOwnerStmt(Node *node, const char *queryString,
  * AlterSequenceOwnerStmtObjectAddress returns the ObjectAddress of the sequence that is the
  * subject of the AlterOwnerStmt.
  */
-ObjectAddress
+List *
 AlterSequenceOwnerStmtObjectAddress(Node *node, bool missing_ok)
 {
 	AlterTableStmt *stmt = castNode(AlterTableStmt, node);
@@ -631,10 +650,10 @@ AlterSequenceOwnerStmtObjectAddress(Node *node, bool missing_ok)
 
 	RangeVar *sequence = stmt->relation;
 	Oid seqOid = RangeVarGetRelid(sequence, NoLock, missing_ok);
-	ObjectAddress sequenceAddress = { 0 };
-	ObjectAddressSet(sequenceAddress, RelationRelationId, seqOid);
+	ObjectAddress *sequenceAddress = palloc0(sizeof(ObjectAddress));
+	ObjectAddressSet(*sequenceAddress, RelationRelationId, seqOid);
 
-	return sequenceAddress;
+	return list_make1(sequenceAddress);
 }
 
 
@@ -649,14 +668,18 @@ PostprocessAlterSequenceOwnerStmt(Node *node, const char *queryString)
 	AlterTableStmt *stmt = castNode(AlterTableStmt, node);
 	Assert(AlterTableStmtObjType_compat(stmt) == OBJECT_SEQUENCE);
 
-	ObjectAddress sequenceAddress = GetObjectAddressFromParseTree((Node *) stmt, false);
-	if (!ShouldPropagateObject(&sequenceAddress))
+	List *sequenceAddresses = GetObjectAddressListFromParseTree((Node *) stmt, false);
+
+	/*  the code-path only supports a single object */
+	Assert(list_length(sequenceAddresses) == 1);
+
+	if (!ShouldPropagateAnyObject(sequenceAddresses))
 	{
 		return NIL;
 	}
 
 	/* dependencies have changed (owner) let's ensure they exist */
-	EnsureDependenciesExistOnAllNodes(&sequenceAddress);
+	EnsureAllObjectDependenciesExistOnAllNodes(sequenceAddresses);
 
 	return NIL;
 }
@@ -744,10 +767,10 @@ PostprocessGrantOnSequenceStmt(Node *node, const char *queryString)
 	RangeVar *sequence = NULL;
 	foreach_ptr(sequence, distributedSequences)
 	{
-		ObjectAddress sequenceAddress = { 0 };
+		ObjectAddress *sequenceAddress = palloc0(sizeof(ObjectAddress));
 		Oid sequenceOid = RangeVarGetRelid(sequence, NoLock, false);
-		ObjectAddressSet(sequenceAddress, RelationRelationId, sequenceOid);
-		EnsureDependenciesExistOnAllNodes(&sequenceAddress);
+		ObjectAddressSet(*sequenceAddress, RelationRelationId, sequenceOid);
+		EnsureAllObjectDependenciesExistOnAllNodes(list_make1(sequenceAddress));
 	}
 	return NIL;
 }
@@ -866,15 +889,15 @@ FilterDistributedSequences(GrantStmt *stmt)
 		RangeVar *sequenceRangeVar = NULL;
 		foreach_ptr(sequenceRangeVar, stmt->objects)
 		{
-			ObjectAddress sequenceAddress = { 0 };
 			Oid sequenceOid = RangeVarGetRelid(sequenceRangeVar, NoLock, missing_ok);
-			ObjectAddressSet(sequenceAddress, RelationRelationId, sequenceOid);
+			ObjectAddress *sequenceAddress = palloc0(sizeof(ObjectAddress));
+			ObjectAddressSet(*sequenceAddress, RelationRelationId, sequenceOid);
 
 			/*
 			 * if this sequence from GRANT .. ON SEQUENCE .. is a distributed
 			 * sequence, add it to the list
 			 */
-			if (IsObjectDistributed(&sequenceAddress))
+			if (IsAnyObjectDistributed(list_make1(sequenceAddress)))
 			{
 				grantSequenceList = lappend(grantSequenceList, sequenceRangeVar);
 			}

src/backend/distributed/commands/statistics.c

@@ -122,9 +122,12 @@ PostprocessCreateStatisticsStmt(Node *node, const char *queryString)
 	}
 
 	bool missingOk = false;
-	ObjectAddress objectAddress = GetObjectAddressFromParseTree((Node *) stmt, missingOk);
+	List *objectAddresses = GetObjectAddressListFromParseTree((Node *) stmt, missingOk);
 
-	EnsureDependenciesExistOnAllNodes(&objectAddress);
+	/*  the code-path only supports a single object */
+	Assert(list_length(objectAddresses) == 1);
+
+	EnsureAllObjectDependenciesExistOnAllNodes(objectAddresses);
 
 	return NIL;
 }
@@ -138,16 +141,16 @@ PostprocessCreateStatisticsStmt(Node *node, const char *queryString)
  * Never returns NULL, but the objid in the address can be invalid if missingOk
  * was set to true.
  */
-ObjectAddress
+List *
 CreateStatisticsStmtObjectAddress(Node *node, bool missingOk)
 {
 	CreateStatsStmt *stmt = castNode(CreateStatsStmt, node);
 
-	ObjectAddress address = { 0 };
+	ObjectAddress *address = palloc0(sizeof(ObjectAddress));
 	Oid statsOid = get_statistics_object_oid(stmt->defnames, missingOk);
-	ObjectAddressSet(address, StatisticExtRelationId, statsOid);
+	ObjectAddressSet(*address, StatisticExtRelationId, statsOid);
 
-	return address;
+	return list_make1(address);
 }
 
 
@@ -306,9 +309,12 @@ PostprocessAlterStatisticsSchemaStmt(Node *node, const char *queryString)
 	}
 
 	bool missingOk = false;
-	ObjectAddress objectAddress = GetObjectAddressFromParseTree((Node *) stmt, missingOk);
+	List *objectAddresses = GetObjectAddressListFromParseTree((Node *) stmt, missingOk);
 
-	EnsureDependenciesExistOnAllNodes(&objectAddress);
+	/*  the code-path only supports a single object */
+	Assert(list_length(objectAddresses) == 1);
+
+	EnsureAllObjectDependenciesExistOnAllNodes(objectAddresses);
 
 	return NIL;
 }
@@ -322,18 +328,18 @@ PostprocessAlterStatisticsSchemaStmt(Node *node, const char *queryString)
  * Never returns NULL, but the objid in the address can be invalid if missingOk
  * was set to true.
  */
-ObjectAddress
+List *
 AlterStatisticsSchemaStmtObjectAddress(Node *node, bool missingOk)
 {
 	AlterObjectSchemaStmt *stmt = castNode(AlterObjectSchemaStmt, node);
 
-	ObjectAddress address = { 0 };
+	ObjectAddress *address = palloc0(sizeof(ObjectAddress));
 	String *statName = llast((List *) stmt->object);
 	Oid statsOid = get_statistics_object_oid(list_make2(makeString(stmt->newschema),
 														statName), missingOk);
-	ObjectAddressSet(address, StatisticExtRelationId, statsOid);
+	ObjectAddressSet(*address, StatisticExtRelationId, statsOid);
 
-	return address;
+	return list_make1(address);
 }
 
 
@@ -449,10 +455,9 @@ PostprocessAlterStatisticsOwnerStmt(Node *node, const char *queryString)
 		return NIL;
 	}
 
-	ObjectAddress statisticsAddress = { 0 };
-	ObjectAddressSet(statisticsAddress, StatisticExtRelationId, statsOid);
-
-	EnsureDependenciesExistOnAllNodes(&statisticsAddress);
+	ObjectAddress *statisticsAddress = palloc0(sizeof(ObjectAddress));
+	ObjectAddressSet(*statisticsAddress, StatisticExtRelationId, statsOid);
+	EnsureAllObjectDependenciesExistOnAllNodes(list_make1(statisticsAddress));
 
 	return NIL;
 }

src/backend/distributed/commands/table.c

@@ -649,13 +649,19 @@ PostprocessAlterTableSchemaStmt(Node *node, const char *queryString)
 	/*
 	 * We will let Postgres deal with missing_ok
 	 */
-	ObjectAddress tableAddress = GetObjectAddressFromParseTree((Node *) stmt, true);
+	List *tableAddresses = GetObjectAddressListFromParseTree((Node *) stmt, true);
+
+	/*  the code-path only supports a single object */
+	Assert(list_length(tableAddress) == 1);
+
+	/* We have already asserted that we have exactly 1 address in the addresses. */
+	ObjectAddress *tableAddress = linitial(tableAddresses);
 
 	/*
 	 * Check whether we are dealing with a sequence or view here and route queries
 	 * accordingly to the right processor function.
 	 */
-	char relKind = get_rel_relkind(tableAddress.objectId);
+	char relKind = get_rel_relkind(tableAddress->objectId);
 	if (relKind == RELKIND_SEQUENCE)
 	{
 		stmt->objectType = OBJECT_SEQUENCE;
@@ -667,12 +673,12 @@ PostprocessAlterTableSchemaStmt(Node *node, const char *queryString)
 		return PostprocessAlterViewSchemaStmt((Node *) stmt, queryString);
 	}
 
-	if (!ShouldPropagate() || !IsCitusTable(tableAddress.objectId))
+	if (!ShouldPropagate() || !IsCitusTable(tableAddress->objectId))
 	{
 		return NIL;
 	}
 
-	EnsureDependenciesExistOnAllNodes(&tableAddress);
+	EnsureAllObjectDependenciesExistOnAllNodes(tableAddresses);
 
 	return NIL;
 }
@@ -1776,9 +1782,15 @@ PreprocessAlterTableSchemaStmt(Node *node, const char *queryString,
 		return NIL;
 	}
 
-	ObjectAddress address = GetObjectAddressFromParseTree((Node *) stmt,
-														  stmt->missing_ok);
-	Oid relationId = address.objectId;
+	List *addresses = GetObjectAddressListFromParseTree((Node *) stmt,
+														stmt->missing_ok);
+
+	/*  the code-path only supports a single object */
+	Assert(list_length(addresses) == 1);
+
+	/* We have already asserted that we have exactly 1 address in the addresses. */
+	ObjectAddress *address = linitial(addresses);
+	Oid relationId = address->objectId;
 
 	/*
 	 * Check whether we are dealing with a sequence or view here and route queries
@@ -1990,9 +2002,9 @@ PostprocessAlterTableStmt(AlterTableStmt *alterTableStatement)
 		EnsureRelationHasCompatibleSequenceTypes(relationId);
 
 		/* changing a relation could introduce new dependencies */
-		ObjectAddress tableAddress = { 0 };
-		ObjectAddressSet(tableAddress, RelationRelationId, relationId);
-		EnsureDependenciesExistOnAllNodes(&tableAddress);
+		ObjectAddress *tableAddress = palloc0(sizeof(ObjectAddress));
+		ObjectAddressSet(*tableAddress, RelationRelationId, relationId);
+		EnsureAllObjectDependenciesExistOnAllNodes(list_make1(tableAddress));
 	}
 
 	/* for the new sequences coming with this ALTER TABLE statement */
@@ -3353,7 +3365,7 @@ ErrorIfUnsupportedAlterAddConstraintStmt(AlterTableStmt *alterTableStatement)
  * will look in the new schema. Errors if missing_ok is false and the table cannot
  * be found in either of the schemas.
  */
-ObjectAddress
+List *
 AlterTableSchemaStmtObjectAddress(Node *node, bool missing_ok)
 {
 	AlterObjectSchemaStmt *stmt = castNode(AlterObjectSchemaStmt, node);
@@ -3389,10 +3401,10 @@ AlterTableSchemaStmtObjectAddress(Node *node, bool missing_ok)
 		}
 	}
 
-	ObjectAddress address = { 0 };
-	ObjectAddressSet(address, RelationRelationId, tableOid);
+	ObjectAddress *address = palloc0(sizeof(ObjectAddress));
+	ObjectAddressSet(*address, RelationRelationId, tableOid);
 
-	return address;
+	return list_make1(address);
 }
 
 

src/backend/distributed/commands/text_search.c

@@ -569,7 +569,7 @@ get_ts_parser_namelist(Oid tsparserOid)
  * being created. If missing_pk is false the function will error, explaining to the user
  * the text search configuration described in the statement doesn't exist.
  */
-ObjectAddress
+List *
 CreateTextSearchConfigurationObjectAddress(Node *node, bool missing_ok)
 {
 	DefineStmt *stmt = castNode(DefineStmt, node);
@@ -577,9 +577,9 @@ CreateTextSearchConfigurationObjectAddress(Node *node, bool missing_ok)
 
 	Oid objid = get_ts_config_oid(stmt->defnames, missing_ok);
 
-	ObjectAddress address = { 0 };
-	ObjectAddressSet(address, TSConfigRelationId, objid);
-	return address;
+	ObjectAddress *address = palloc0(sizeof(ObjectAddress));
+	ObjectAddressSet(*address, TSConfigRelationId, objid);
+	return list_make1(address);
 }
 
 
@@ -588,7 +588,7 @@ CreateTextSearchConfigurationObjectAddress(Node *node, bool missing_ok)
  * being created. If missing_pk is false the function will error, explaining to the user
  * the text search dictionary described in the statement doesn't exist.
  */
-ObjectAddress
+List *
 CreateTextSearchDictObjectAddress(Node *node, bool missing_ok)
 {
 	DefineStmt *stmt = castNode(DefineStmt, node);
@@ -596,9 +596,9 @@ CreateTextSearchDictObjectAddress(Node *node, bool missing_ok)
 
 	Oid objid = get_ts_dict_oid(stmt->defnames, missing_ok);
 
-	ObjectAddress address = { 0 };
-	ObjectAddressSet(address, TSDictionaryRelationId, objid);
-	return address;
+	ObjectAddress *address = palloc0(sizeof(ObjectAddress));
+	ObjectAddressSet(*address, TSDictionaryRelationId, objid);
+	return list_make1(address);
 }
 
 
@@ -607,7 +607,7 @@ CreateTextSearchDictObjectAddress(Node *node, bool missing_ok)
  * SEARCH CONFIGURATION being renamed. Optionally errors if the configuration does not
  * exist based on the missing_ok flag passed in by the caller.
  */
-ObjectAddress
+List *
 RenameTextSearchConfigurationStmtObjectAddress(Node *node, bool missing_ok)
 {
 	RenameStmt *stmt = castNode(RenameStmt, node);
@@ -615,9 +615,9 @@ RenameTextSearchConfigurationStmtObjectAddress(Node *node, bool missing_ok)
 
 	Oid objid = get_ts_config_oid(castNode(List, stmt->object), missing_ok);
 
-	ObjectAddress address = { 0 };
-	ObjectAddressSet(address, TSConfigRelationId, objid);
-	return address;
+	ObjectAddress *address = palloc0(sizeof(ObjectAddress));
+	ObjectAddressSet(*address, TSConfigRelationId, objid);
+	return list_make1(address);
 }
 
 
@@ -626,7 +626,7 @@ RenameTextSearchConfigurationStmtObjectAddress(Node *node, bool missing_ok)
  * SEARCH DICTIONARY being renamed. Optionally errors if the dictionary does not
  * exist based on the missing_ok flag passed in by the caller.
  */
-ObjectAddress
+List *
 RenameTextSearchDictionaryStmtObjectAddress(Node *node, bool missing_ok)
 {
 	RenameStmt *stmt = castNode(RenameStmt, node);
@@ -634,9 +634,9 @@ RenameTextSearchDictionaryStmtObjectAddress(Node *node, bool missing_ok)
 
 	Oid objid = get_ts_dict_oid(castNode(List, stmt->object), missing_ok);
 
-	ObjectAddress address = { 0 };
-	ObjectAddressSet(address, TSDictionaryRelationId, objid);
-	return address;
+	ObjectAddress *address = palloc0(sizeof(ObjectAddress));
+	ObjectAddressSet(*address, TSDictionaryRelationId, objid);
+	return list_make1(address);
 }
 
 
@@ -645,16 +645,16 @@ RenameTextSearchDictionaryStmtObjectAddress(Node *node, bool missing_ok)
  * SEARCH CONFIGURATION being altered. Optionally errors if the configuration does not
  * exist based on the missing_ok flag passed in by the caller.
  */
-ObjectAddress
+List *
 AlterTextSearchConfigurationStmtObjectAddress(Node *node, bool missing_ok)
 {
 	AlterTSConfigurationStmt *stmt = castNode(AlterTSConfigurationStmt, node);
 
 	Oid objid = get_ts_config_oid(stmt->cfgname, missing_ok);
 
-	ObjectAddress address = { 0 };
-	ObjectAddressSet(address, TSConfigRelationId, objid);
-	return address;
+	ObjectAddress *address = palloc0(sizeof(ObjectAddress));
+	ObjectAddressSet(*address, TSConfigRelationId, objid);
+	return list_make1(address);
 }
 
 
@@ -663,16 +663,16 @@ AlterTextSearchConfigurationStmtObjectAddress(Node *node, bool missing_ok)
  * SEARCH CONFIGURATION being altered. Optionally errors if the configuration does not
  * exist based on the missing_ok flag passed in by the caller.
  */
-ObjectAddress
+List *
 AlterTextSearchDictionaryStmtObjectAddress(Node *node, bool missing_ok)
 {
 	AlterTSDictionaryStmt *stmt = castNode(AlterTSDictionaryStmt, node);
 
 	Oid objid = get_ts_dict_oid(stmt->dictname, missing_ok);
 
-	ObjectAddress address = { 0 };
-	ObjectAddressSet(address, TSDictionaryRelationId, objid);
-	return address;
+	ObjectAddress *address = palloc0(sizeof(ObjectAddress));
+	ObjectAddressSet(*address, TSDictionaryRelationId, objid);
+	return list_make1(address);
 }
 
 
@@ -685,7 +685,7 @@ AlterTextSearchDictionaryStmtObjectAddress(Node *node, bool missing_ok)
  * the triple checking before the error might be thrown. Errors for non-existing schema's
  * in edgecases will be raised by postgres while executing the move.
  */
-ObjectAddress
+List *
 AlterTextSearchConfigurationSchemaStmtObjectAddress(Node *node, bool missing_ok)
 {
 	AlterObjectSchemaStmt *stmt = castNode(AlterObjectSchemaStmt, node);
@@ -723,9 +723,9 @@ AlterTextSearchConfigurationSchemaStmtObjectAddress(Node *node, bool missing_ok)
 		}
 	}
 
-	ObjectAddress sequenceAddress = { 0 };
-	ObjectAddressSet(sequenceAddress, TSConfigRelationId, objid);
-	return sequenceAddress;
+	ObjectAddress *sequenceAddress = palloc0(sizeof(ObjectAddress));
+	ObjectAddressSet(*sequenceAddress, TSConfigRelationId, objid);
+	return list_make1(sequenceAddress);
 }
 
 
@@ -738,7 +738,7 @@ AlterTextSearchConfigurationSchemaStmtObjectAddress(Node *node, bool missing_ok)
  * the triple checking before the error might be thrown. Errors for non-existing schema's
  * in edgecases will be raised by postgres while executing the move.
  */
-ObjectAddress
+List *
 AlterTextSearchDictionarySchemaStmtObjectAddress(Node *node, bool missing_ok)
 {
 	AlterObjectSchemaStmt *stmt = castNode(AlterObjectSchemaStmt, node);
@@ -776,9 +776,9 @@ AlterTextSearchDictionarySchemaStmtObjectAddress(Node *node, bool missing_ok)
 		}
 	}
 
-	ObjectAddress sequenceAddress = { 0 };
-	ObjectAddressSet(sequenceAddress, TSDictionaryRelationId, objid);
-	return sequenceAddress;
+	ObjectAddress *sequenceAddress = palloc0(sizeof(ObjectAddress));
+	ObjectAddressSet(*sequenceAddress, TSDictionaryRelationId, objid);
+	return list_make1(sequenceAddress);
 }
 
 
@@ -787,7 +787,7 @@ AlterTextSearchDictionarySchemaStmtObjectAddress(Node *node, bool missing_ok)
  * SEARCH CONFIGURATION on which the comment is placed. Optionally errors if the
  * configuration does not exist based on the missing_ok flag passed in by the caller.
  */
-ObjectAddress
+List *
 TextSearchConfigurationCommentObjectAddress(Node *node, bool missing_ok)
 {
 	CommentStmt *stmt = castNode(CommentStmt, node);
@@ -795,9 +795,9 @@ TextSearchConfigurationCommentObjectAddress(Node *node, bool missing_ok)
 
 	Oid objid = get_ts_config_oid(castNode(List, stmt->object), missing_ok);
 
-	ObjectAddress address = { 0 };
-	ObjectAddressSet(address, TSConfigRelationId, objid);
-	return address;
+	ObjectAddress *address = palloc0(sizeof(ObjectAddress));
+	ObjectAddressSet(*address, TSConfigRelationId, objid);
+	return list_make1(address);
 }
 
 
@@ -806,7 +806,7 @@ TextSearchConfigurationCommentObjectAddress(Node *node, bool missing_ok)
  * DICTIONARY on which the comment is placed. Optionally errors if the dictionary does not
  * exist based on the missing_ok flag passed in by the caller.
  */
-ObjectAddress
+List *
 TextSearchDictCommentObjectAddress(Node *node, bool missing_ok)
 {
 	CommentStmt *stmt = castNode(CommentStmt, node);
@@ -814,9 +814,9 @@ TextSearchDictCommentObjectAddress(Node *node, bool missing_ok)
 
 	Oid objid = get_ts_dict_oid(castNode(List, stmt->object), missing_ok);
 
-	ObjectAddress address = { 0 };
-	ObjectAddressSet(address, TSDictionaryRelationId, objid);
-	return address;
+	ObjectAddress *address = palloc0(sizeof(ObjectAddress));
+	ObjectAddressSet(*address, TSDictionaryRelationId, objid);
+	return list_make1(address);
 }
 
 
@@ -825,7 +825,7 @@ TextSearchDictCommentObjectAddress(Node *node, bool missing_ok)
  * SEARCH CONFIGURATION for which the owner is changed. Optionally errors if the
  * configuration does not exist based on the missing_ok flag passed in by the caller.
  */
-ObjectAddress
+List *
 AlterTextSearchConfigurationOwnerObjectAddress(Node *node, bool missing_ok)
 {
 	AlterOwnerStmt *stmt = castNode(AlterOwnerStmt, node);
@@ -833,8 +833,14 @@ AlterTextSearchConfigurationOwnerObjectAddress(Node *node, bool missing_ok)
 
 	Assert(stmt->objectType == OBJECT_TSCONFIGURATION);
 
-	return get_object_address(stmt->objectType, stmt->object, &relation, AccessShareLock,
-							  missing_ok);
+	ObjectAddress objectAddress = get_object_address(stmt->objectType, stmt->object,
+													 &relation, AccessShareLock,
+													 missing_ok);
+
+	ObjectAddress *objectAddressCopy = palloc0(sizeof(ObjectAddress));
+	*objectAddressCopy = objectAddress;
+
+	return list_make1(objectAddressCopy);
 }
 
 
@@ -843,16 +849,20 @@ AlterTextSearchConfigurationOwnerObjectAddress(Node *node, bool missing_ok)
  * SEARCH DICTIONARY for which the owner is changed. Optionally errors if the
  * configuration does not exist based on the missing_ok flag passed in by the caller.
  */
-ObjectAddress
+List *
 AlterTextSearchDictOwnerObjectAddress(Node *node, bool missing_ok)
 {
 	AlterOwnerStmt *stmt = castNode(AlterOwnerStmt, node);
 	Relation relation = NULL;
 
 	Assert(stmt->objectType == OBJECT_TSDICTIONARY);
+	ObjectAddress objectAddress = get_object_address(stmt->objectType, stmt->object,
+													 &relation, AccessShareLock,
+													 missing_ok);
+	ObjectAddress *objectAddressCopy = palloc0(sizeof(ObjectAddress));
+	*objectAddressCopy = objectAddress;
 
-	return get_object_address(stmt->objectType, stmt->object, &relation, AccessShareLock,
-							  missing_ok);
+	return list_make1(objectAddressCopy);
 }
 
 

src/backend/distributed/commands/trigger.c

@@ -224,8 +224,12 @@ PostprocessCreateTriggerStmt(Node *node, const char *queryString)
 	EnsureCoordinator();
 	ErrorOutForTriggerIfNotSupported(relationId);
 
-	ObjectAddress objectAddress = GetObjectAddressFromParseTree(node, missingOk);
-	EnsureDependenciesExistOnAllNodes(&objectAddress);
+	List *objectAddresses = GetObjectAddressListFromParseTree(node, missingOk);
+
+	/*  the code-path only supports a single object */
+	Assert(list_length(objectAddresses) == 1);
+
+	EnsureAllObjectDependenciesExistOnAllNodes(objectAddresses);
 
 	char *triggerName = createTriggerStmt->trigname;
 	return CitusCreateTriggerCommandDDLJob(relationId, triggerName,
@@ -241,7 +245,7 @@ PostprocessCreateTriggerStmt(Node *node, const char *queryString)
  * Never returns NULL, but the objid in the address can be invalid if missingOk
  * was set to true.
  */
-ObjectAddress
+List *
 CreateTriggerStmtObjectAddress(Node *node, bool missingOk)
 {
 	CreateTrigStmt *createTriggerStmt = castNode(CreateTrigStmt, node);
@@ -260,9 +264,9 @@ CreateTriggerStmtObjectAddress(Node *node, bool missingOk)
 							   triggerName, relationName)));
 	}
 
-	ObjectAddress address = { 0 };
-	ObjectAddressSet(address, TriggerRelationId, triggerId);
-	return address;
+	ObjectAddress *address = palloc0(sizeof(ObjectAddress));
+	ObjectAddressSet(*address, TriggerRelationId, triggerId);
+	return list_make1(address);
 }
 
 

src/backend/distributed/commands/type.c

@@ -117,8 +117,12 @@ PreprocessRenameTypeAttributeStmt(Node *node, const char *queryString,
 	Assert(stmt->renameType == OBJECT_ATTRIBUTE);
 	Assert(stmt->relationType == OBJECT_TYPE);
 
-	ObjectAddress typeAddress = GetObjectAddressFromParseTree((Node *) stmt, false);
-	if (!ShouldPropagateObject(&typeAddress))
+	List *typeAddresses = GetObjectAddressListFromParseTree((Node *) stmt, false);
+
+	/*  the code-path only supports a single object */
+	Assert(list_length(objectAddresses) == 1);
+
+	if (!ShouldPropagateAnyObject(typeAddresses))
 	{
 		return NIL;
 	}
@@ -300,16 +304,16 @@ EnumValsList(Oid typeOid)
  * Never returns NULL, but the objid in the address could be invalid if missing_ok was set
  * to true.
  */
-ObjectAddress
+List *
 CompositeTypeStmtObjectAddress(Node *node, bool missing_ok)
 {
 	CompositeTypeStmt *stmt = castNode(CompositeTypeStmt, node);
 	TypeName *typeName = MakeTypeNameFromRangeVar(stmt->typevar);
 	Oid typeOid = LookupNonAssociatedArrayTypeNameOid(NULL, typeName, missing_ok);
-	ObjectAddress address = { 0 };
-	ObjectAddressSet(address, TypeRelationId, typeOid);
+	ObjectAddress *address = palloc0(sizeof(ObjectAddress));
+	ObjectAddressSet(*address, TypeRelationId, typeOid);
 
-	return address;
+	return list_make1(address);
 }
 
 
@@ -321,16 +325,16 @@ CompositeTypeStmtObjectAddress(Node *node, bool missing_ok)
  * Never returns NULL, but the objid in the address could be invalid if missing_ok was set
  * to true.
  */
-ObjectAddress
+List *
 CreateEnumStmtObjectAddress(Node *node, bool missing_ok)
 {
 	CreateEnumStmt *stmt = castNode(CreateEnumStmt, node);
 	TypeName *typeName = makeTypeNameFromNameList(stmt->typeName);
 	Oid typeOid = LookupNonAssociatedArrayTypeNameOid(NULL, typeName, missing_ok);
-	ObjectAddress address = { 0 };
-	ObjectAddressSet(address, TypeRelationId, typeOid);
+	ObjectAddress *address = palloc0(sizeof(ObjectAddress));
+	ObjectAddressSet(*address, TypeRelationId, typeOid);
 
-	return address;
+	return list_make1(address);
 }
 
 
@@ -342,7 +346,7 @@ CreateEnumStmtObjectAddress(Node *node, bool missing_ok)
  * Never returns NULL, but the objid in the address could be invalid if missing_ok was set
  * to true.
  */
-ObjectAddress
+List *
 AlterTypeStmtObjectAddress(Node *node, bool missing_ok)
 {
 	AlterTableStmt *stmt = castNode(AlterTableStmt, node);
@@ -350,10 +354,10 @@ AlterTypeStmtObjectAddress(Node *node, bool missing_ok)
 
 	TypeName *typeName = MakeTypeNameFromRangeVar(stmt->relation);
 	Oid typeOid = LookupTypeNameOid(NULL, typeName, missing_ok);
-	ObjectAddress address = { 0 };
-	ObjectAddressSet(address, TypeRelationId, typeOid);
+	ObjectAddress *address = palloc0(sizeof(ObjectAddress));
+	ObjectAddressSet(*address, TypeRelationId, typeOid);
 
-	return address;
+	return list_make1(address);
 }
 
 
@@ -361,16 +365,16 @@ AlterTypeStmtObjectAddress(Node *node, bool missing_ok)
  * AlterEnumStmtObjectAddress return the ObjectAddress of the enum type that is the
  * object of the AlterEnumStmt. Errors is missing_ok is false.
  */
-ObjectAddress
+List *
 AlterEnumStmtObjectAddress(Node *node, bool missing_ok)
 {
 	AlterEnumStmt *stmt = castNode(AlterEnumStmt, node);
 	TypeName *typeName = makeTypeNameFromNameList(stmt->typeName);
 	Oid typeOid = LookupTypeNameOid(NULL, typeName, missing_ok);
-	ObjectAddress address = { 0 };
-	ObjectAddressSet(address, TypeRelationId, typeOid);
+	ObjectAddress *address = palloc0(sizeof(ObjectAddress));
+	ObjectAddressSet(*address, TypeRelationId, typeOid);
 
-	return address;
+	return list_make1(address);
 }
 
 
@@ -378,7 +382,7 @@ AlterEnumStmtObjectAddress(Node *node, bool missing_ok)
  * RenameTypeStmtObjectAddress returns the ObjectAddress of the type that is the object
  * of the RenameStmt. Errors if missing_ok is false.
  */
-ObjectAddress
+List *
 RenameTypeStmtObjectAddress(Node *node, bool missing_ok)
 {
 	RenameStmt *stmt = castNode(RenameStmt, node);
@@ -386,10 +390,10 @@ RenameTypeStmtObjectAddress(Node *node, bool missing_ok)
 
 	TypeName *typeName = makeTypeNameFromNameList((List *) stmt->object);
 	Oid typeOid = LookupTypeNameOid(NULL, typeName, missing_ok);
-	ObjectAddress address = { 0 };
-	ObjectAddressSet(address, TypeRelationId, typeOid);
+	ObjectAddress *address = palloc0(sizeof(ObjectAddress));
+	ObjectAddressSet(*address, TypeRelationId, typeOid);
 
-	return address;
+	return list_make1(address);
 }
 
 
@@ -402,7 +406,7 @@ RenameTypeStmtObjectAddress(Node *node, bool missing_ok)
  * new schema. Errors if missing_ok is false and the type cannot be found in either of the
  * schemas.
  */
-ObjectAddress
+List *
 AlterTypeSchemaStmtObjectAddress(Node *node, bool missing_ok)
 {
 	AlterObjectSchemaStmt *stmt = castNode(AlterObjectSchemaStmt, node);
@@ -447,10 +451,10 @@ AlterTypeSchemaStmtObjectAddress(Node *node, bool missing_ok)
 		}
 	}
 
-	ObjectAddress address = { 0 };
-	ObjectAddressSet(address, TypeRelationId, typeOid);
+	ObjectAddress *address = palloc0(sizeof(ObjectAddress));
+	ObjectAddressSet(*address, TypeRelationId, typeOid);
 
-	return address;
+	return list_make1(address);
 }
 
 
@@ -462,7 +466,7 @@ AlterTypeSchemaStmtObjectAddress(Node *node, bool missing_ok)
  * changed as Attributes are not distributed on their own but as a side effect of the
  * whole type distribution.
  */
-ObjectAddress
+List *
 RenameTypeAttributeStmtObjectAddress(Node *node, bool missing_ok)
 {
 	RenameStmt *stmt = castNode(RenameStmt, node);
@@ -471,10 +475,10 @@ RenameTypeAttributeStmtObjectAddress(Node *node, bool missing_ok)
 
 	TypeName *typeName = MakeTypeNameFromRangeVar(stmt->relation);
 	Oid typeOid = LookupTypeNameOid(NULL, typeName, missing_ok);
-	ObjectAddress address = { 0 };
-	ObjectAddressSet(address, TypeRelationId, typeOid);
+	ObjectAddress *address = palloc0(sizeof(ObjectAddress));
+	ObjectAddressSet(*address, TypeRelationId, typeOid);
 
-	return address;
+	return list_make1(address);
 }
 
 
@@ -482,7 +486,7 @@ RenameTypeAttributeStmtObjectAddress(Node *node, bool missing_ok)
  * AlterTypeOwnerObjectAddress returns the ObjectAddress of the type that is the object
  * of the AlterOwnerStmt. Errors if missing_ok is false.
  */
-ObjectAddress
+List *
 AlterTypeOwnerObjectAddress(Node *node, bool missing_ok)
 {
 	AlterOwnerStmt *stmt = castNode(AlterOwnerStmt, node);
@@ -490,10 +494,10 @@ AlterTypeOwnerObjectAddress(Node *node, bool missing_ok)
 
 	TypeName *typeName = makeTypeNameFromNameList((List *) stmt->object);
 	Oid typeOid = LookupTypeNameOid(NULL, typeName, missing_ok);
-	ObjectAddress address = { 0 };
-	ObjectAddressSet(address, TypeRelationId, typeOid);
+	ObjectAddress *address = palloc0(sizeof(ObjectAddress));
+	ObjectAddressSet(*address, TypeRelationId, typeOid);
 
-	return address;
+	return list_make1(address);
 }
 
 

src/backend/distributed/commands/utility_hook.c

@@ -853,8 +853,12 @@ ProcessUtilityInternal(PlannedStmt *pstmt,
 		 */
 		if (ops && ops->markDistributed)
 		{
-			ObjectAddress address = GetObjectAddressFromParseTree(parsetree, false);
-			MarkObjectDistributed(&address);
+			List *addresses = GetObjectAddressListFromParseTree(parsetree, false);
+			ObjectAddress *address = NULL;
+			foreach_ptr(address, addresses)
+			{
+				MarkObjectDistributed(address);
+			}
 		}
 	}
 

src/backend/distributed/commands/view.c

@@ -94,22 +94,27 @@ PostprocessViewStmt(Node *node, const char *queryString)
 		return NIL;
 	}
 
-	ObjectAddress viewAddress = GetObjectAddressFromParseTree((Node *) stmt, false);
+	List *viewAddresses = GetObjectAddressListFromParseTree((Node *) stmt, false);
 
-	if (IsObjectAddressOwnedByExtension(&viewAddress, NULL))
+	/*  the code-path only supports a single object */
+	Assert(list_length(viewAddresses) == 1);
+
+	if (IsAnyObjectAddressOwnedByExtension(viewAddresses, NULL))
 	{
 		return NIL;
 	}
 
 	/* If the view has any unsupported dependency, create it locally */
-	if (ErrorOrWarnIfObjectHasUnsupportedDependency(&viewAddress))
+	if (ErrorOrWarnIfAnyObjectHasUnsupportedDependency(viewAddresses))
 	{
 		return NIL;
 	}
 
-	EnsureDependenciesExistOnAllNodes(&viewAddress);
+	EnsureAllObjectDependenciesExistOnAllNodes(viewAddresses);
 
-	char *command = CreateViewDDLCommand(viewAddress.objectId);
+	/* We have already asserted that we have exactly 1 address in the addresses. */
+	ObjectAddress *viewAddress = linitial(viewAddresses);
+	char *command = CreateViewDDLCommand(viewAddress->objectId);
 
 	/*
 	 * We'd typically use NodeDDLTaskList() for generating node-level DDL commands,
@@ -140,7 +145,7 @@ PostprocessViewStmt(Node *node, const char *queryString)
 	 *
 	 */
 	DDLJob *ddlJob = palloc0(sizeof(DDLJob));
-	ddlJob->targetObjectAddress = viewAddress;
+	ddlJob->targetObjectAddress = *viewAddress;
 	ddlJob->metadataSyncCommand = command;
 	ddlJob->taskList = NIL;
 
@@ -152,17 +157,17 @@ PostprocessViewStmt(Node *node, const char *queryString)
  * ViewStmtObjectAddress returns the ObjectAddress for the subject of the
  * CREATE [OR REPLACE] VIEW statement.
  */
-ObjectAddress
+List *
 ViewStmtObjectAddress(Node *node, bool missing_ok)
 {
 	ViewStmt *stmt = castNode(ViewStmt, node);
 
 	Oid viewOid = RangeVarGetRelid(stmt->view, NoLock, missing_ok);
 
-	ObjectAddress viewAddress = { 0 };
-	ObjectAddressSet(viewAddress, RelationRelationId, viewOid);
+	ObjectAddress *viewAddress = palloc0(sizeof(ObjectAddress));
+	ObjectAddressSet(*viewAddress, RelationRelationId, viewOid);
 
-	return viewAddress;
+	return list_make1(viewAddress);
 }
 
 
@@ -442,10 +447,9 @@ IsViewDistributed(Oid viewOid)
 	Assert(get_rel_relkind(viewOid) == RELKIND_VIEW ||
 		   get_rel_relkind(viewOid) == RELKIND_MATVIEW);
 
-	ObjectAddress viewAddress = { 0 };
-	ObjectAddressSet(viewAddress, RelationRelationId, viewOid);
-
-	return IsObjectDistributed(&viewAddress);
+	ObjectAddress *viewAddress = palloc0(sizeof(ObjectAddress));
+	ObjectAddressSet(*viewAddress, RelationRelationId, viewOid);
+	return IsAnyObjectDistributed(list_make1(viewAddress));
 }
 
 
@@ -458,8 +462,12 @@ PreprocessAlterViewStmt(Node *node, const char *queryString, ProcessUtilityConte
 {
 	AlterTableStmt *stmt = castNode(AlterTableStmt, node);
 
-	ObjectAddress viewAddress = GetObjectAddressFromParseTree((Node *) stmt, true);
-	if (!ShouldPropagateObject(&viewAddress))
+	List *viewAddresses = GetObjectAddressListFromParseTree((Node *) stmt, true);
+
+	/*  the code-path only supports a single object */
+	Assert(list_length(viewAddresses) == 1);
+
+	if (!ShouldPropagateAnyObject(viewAddresses))
 	{
 		return NIL;
 	}
@@ -471,12 +479,15 @@ PreprocessAlterViewStmt(Node *node, const char *queryString, ProcessUtilityConte
 	/* reconstruct alter statement in a portable fashion */
 	const char *alterViewStmtSql = DeparseTreeNode((Node *) stmt);
 
+	/* We have already asserted that we have exactly 1 address in the addresses. */
+	ObjectAddress *viewAddress = linitial(viewAddresses);
+
 	/*
 	 * To avoid sequential mode, we are using metadata connection. For the
 	 * detailed explanation, please check the comment on PostprocessViewStmt.
 	 */
 	DDLJob *ddlJob = palloc0(sizeof(DDLJob));
-	ddlJob->targetObjectAddress = viewAddress;
+	ddlJob->targetObjectAddress = *viewAddress;
 	ddlJob->metadataSyncCommand = alterViewStmtSql;
 	ddlJob->taskList = NIL;
 
@@ -493,24 +504,28 @@ PostprocessAlterViewStmt(Node *node, const char *queryString)
 	AlterTableStmt *stmt = castNode(AlterTableStmt, node);
 	Assert(AlterTableStmtObjType_compat(stmt) == OBJECT_VIEW);
 
-	ObjectAddress viewAddress = GetObjectAddressFromParseTree((Node *) stmt, true);
-	if (!ShouldPropagateObject(&viewAddress))
+	List *viewAddresses = GetObjectAddressListFromParseTree((Node *) stmt, true);
+
+	/*  the code-path only supports a single object */
+	Assert(list_length(viewAddresses) == 1);
+
+	if (!ShouldPropagateAnyObject(viewAddresses))
 	{
 		return NIL;
 	}
 
-	if (IsObjectAddressOwnedByExtension(&viewAddress, NULL))
+	if (IsAnyObjectAddressOwnedByExtension(viewAddresses, NULL))
 	{
 		return NIL;
 	}
 
 	/* If the view has any unsupported dependency, create it locally */
-	if (ErrorOrWarnIfObjectHasUnsupportedDependency(&viewAddress))
+	if (ErrorOrWarnIfAnyObjectHasUnsupportedDependency(viewAddresses))
 	{
 		return NIL;
 	}
 
-	EnsureDependenciesExistOnAllNodes(&viewAddress);
+	EnsureAllObjectDependenciesExistOnAllNodes(viewAddresses);
 
 	return NIL;
 }
@@ -520,16 +535,16 @@ PostprocessAlterViewStmt(Node *node, const char *queryString)
  * AlterViewStmtObjectAddress returns the ObjectAddress for the subject of the
  * ALTER VIEW statement.
  */
-ObjectAddress
+List *
 AlterViewStmtObjectAddress(Node *node, bool missing_ok)
 {
 	AlterTableStmt *stmt = castNode(AlterTableStmt, node);
 	Oid viewOid = RangeVarGetRelid(stmt->relation, NoLock, missing_ok);
 
-	ObjectAddress viewAddress = { 0 };
-	ObjectAddressSet(viewAddress, RelationRelationId, viewOid);
+	ObjectAddress *viewAddress = palloc0(sizeof(ObjectAddress));
+	ObjectAddressSet(*viewAddress, RelationRelationId, viewOid);
 
-	return viewAddress;
+	return list_make1(viewAddress);
 }
 
 
@@ -541,8 +556,12 @@ List *
 PreprocessRenameViewStmt(Node *node, const char *queryString,
 						 ProcessUtilityContext processUtilityContext)
 {
-	ObjectAddress viewAddress = GetObjectAddressFromParseTree(node, true);
-	if (!ShouldPropagateObject(&viewAddress))
+	List *viewAddresses = GetObjectAddressListFromParseTree(node, true);
+
+	/*  the code-path only supports a single object */
+	Assert(list_length(viewAddresses) == 1);
+
+	if (!ShouldPropagateAnyObject(viewAddresses))
 	{
 		return NIL;
 	}
@@ -555,12 +574,15 @@ PreprocessRenameViewStmt(Node *node, const char *queryString,
 	/* deparse sql*/
 	const char *renameStmtSql = DeparseTreeNode(node);
 
+	/* We have already asserted that we have exactly 1 address in the addresses. */
+	ObjectAddress *viewAddress = linitial(viewAddresses);
+
 	/*
 	 * To avoid sequential mode, we are using metadata connection. For the
 	 * detailed explanation, please check the comment on PostprocessViewStmt.
 	 */
 	DDLJob *ddlJob = palloc0(sizeof(DDLJob));
-	ddlJob->targetObjectAddress = viewAddress;
+	ddlJob->targetObjectAddress = *viewAddress;
 	ddlJob->metadataSyncCommand = renameStmtSql;
 	ddlJob->taskList = NIL;
 
@@ -572,17 +594,17 @@ PreprocessRenameViewStmt(Node *node, const char *queryString,
  * RenameViewStmtObjectAddress returns the ObjectAddress of the view that is the object
  * of the RenameStmt. Errors if missing_ok is false.
  */
-ObjectAddress
+List *
 RenameViewStmtObjectAddress(Node *node, bool missing_ok)
 {
 	RenameStmt *stmt = castNode(RenameStmt, node);
 
 	Oid viewOid = RangeVarGetRelid(stmt->relation, NoLock, missing_ok);
 
-	ObjectAddress viewAddress = { 0 };
-	ObjectAddressSet(viewAddress, RelationRelationId, viewOid);
+	ObjectAddress *viewAddress = palloc0(sizeof(ObjectAddress));
+	ObjectAddressSet(*viewAddress, RelationRelationId, viewOid);
 
-	return viewAddress;
+	return list_make1(viewAddress);
 }
 
 
@@ -596,8 +618,12 @@ PreprocessAlterViewSchemaStmt(Node *node, const char *queryString,
 {
 	AlterObjectSchemaStmt *stmt = castNode(AlterObjectSchemaStmt, node);
 
-	ObjectAddress viewAddress = GetObjectAddressFromParseTree((Node *) stmt, true);
-	if (!ShouldPropagateObject(&viewAddress))
+	List *viewAddresses = GetObjectAddressListFromParseTree((Node *) stmt, true);
+
+	/*  the code-path only supports a single object */
+	Assert(list_length(viewAddresses) == 1);
+
+	if (!ShouldPropagateAnyObject(viewAddresses))
 	{
 		return NIL;
 	}
@@ -608,12 +634,15 @@ PreprocessAlterViewSchemaStmt(Node *node, const char *queryString,
 
 	const char *sql = DeparseTreeNode((Node *) stmt);
 
+	/* We have already asserted that we have exactly 1 address in the addresses. */
+	ObjectAddress *viewAddress = linitial(viewAddresses);
+
 	/*
 	 * To avoid sequential mode, we are using metadata connection. For the
 	 * detailed explanation, please check the comment on PostprocessViewStmt.
 	 */
 	DDLJob *ddlJob = palloc0(sizeof(DDLJob));
-	ddlJob->targetObjectAddress = viewAddress;
+	ddlJob->targetObjectAddress = *viewAddress;
 	ddlJob->metadataSyncCommand = sql;
 	ddlJob->taskList = NIL;
 
@@ -631,14 +660,18 @@ PostprocessAlterViewSchemaStmt(Node *node, const char *queryString)
 {
 	AlterObjectSchemaStmt *stmt = castNode(AlterObjectSchemaStmt, node);
 
-	ObjectAddress viewAddress = GetObjectAddressFromParseTree((Node *) stmt, true);
-	if (!ShouldPropagateObject(&viewAddress))
+	List *viewAddresses = GetObjectAddressListFromParseTree((Node *) stmt, true);
+
+	/*  the code-path only supports a single object */
+	Assert(list_length(viewAddresses) == 1);
+
+	if (!ShouldPropagateAnyObject(viewAddresses))
 	{
 		return NIL;
 	}
 
 	/* dependencies have changed (schema) let's ensure they exist */
-	EnsureDependenciesExistOnAllNodes(&viewAddress);
+	EnsureAllObjectDependenciesExistOnAllNodes(viewAddresses);
 
 	return NIL;
 }
@@ -648,7 +681,7 @@ PostprocessAlterViewSchemaStmt(Node *node, const char *queryString)
  * AlterViewSchemaStmtObjectAddress returns the ObjectAddress of the view that is the object
  * of the alter schema statement.
  */
-ObjectAddress
+List *
 AlterViewSchemaStmtObjectAddress(Node *node, bool missing_ok)
 {
 	AlterObjectSchemaStmt *stmt = castNode(AlterObjectSchemaStmt, node);
@@ -676,10 +709,10 @@ AlterViewSchemaStmtObjectAddress(Node *node, bool missing_ok)
 		}
 	}
 
-	ObjectAddress viewAddress = { 0 };
-	ObjectAddressSet(viewAddress, RelationRelationId, viewOid);
+	ObjectAddress *viewAddress = palloc0(sizeof(ObjectAddress));
+	ObjectAddressSet(*viewAddress, RelationRelationId, viewOid);
 
-	return viewAddress;
+	return list_make1(viewAddress);
 }
 
 

src/backend/distributed/deparser/objectaddress.c

@@ -20,11 +20,11 @@
 
 
 /*
- * GetObjectAddressFromParseTree returns the ObjectAddress of the main target of the parse
+ * GetObjectAddressListFromParseTree returns the list of ObjectAddress of the main target of the parse
  * tree.
  */
-ObjectAddress
-GetObjectAddressFromParseTree(Node *parseTree, bool missing_ok)
+List *
+GetObjectAddressListFromParseTree(Node *parseTree, bool missing_ok)
 {
 	const DistributeObjectOps *ops = GetDistributeObjectOps(parseTree);
 
@@ -37,7 +37,7 @@ GetObjectAddressFromParseTree(Node *parseTree, bool missing_ok)
 }
 
 
-ObjectAddress
+List *
 RenameAttributeStmtObjectAddress(Node *node, bool missing_ok)
 {
 	RenameStmt *stmt = castNode(RenameStmt, node);
@@ -67,11 +67,11 @@ RenameAttributeStmtObjectAddress(Node *node, bool missing_ok)
  * Never returns NULL, but the objid in the address could be invalid if missing_ok was set
  * to true.
  */
-ObjectAddress
+List *
 CreateExtensionStmtObjectAddress(Node *node, bool missing_ok)
 {
 	CreateExtensionStmt *stmt = castNode(CreateExtensionStmt, node);
-	ObjectAddress address = { 0 };
+	ObjectAddress *address = palloc0(sizeof(ObjectAddress));
 
 	const char *extensionName = stmt->extname;
 
@@ -85,7 +85,7 @@ CreateExtensionStmtObjectAddress(Node *node, bool missing_ok)
 							   extensionName)));
 	}
 
-	ObjectAddressSet(address, ExtensionRelationId, extensionoid);
+	ObjectAddressSet(*address, ExtensionRelationId, extensionoid);
 
-	return address;
+	return list_make1(address);
 }

src/backend/distributed/metadata/dependency.c

@@ -137,6 +137,8 @@ static DependencyDefinition * CreateObjectAddressDependencyDef(Oid classId, Oid
 static List * GetTypeConstraintDependencyDefinition(Oid typeId);
 static List * CreateObjectAddressDependencyDefList(Oid classId, List *objectIdList);
 static ObjectAddress DependencyDefinitionObjectAddress(DependencyDefinition *definition);
+static DeferredErrorMessage * DeferErrorIfHasUnsupportedDependency(const ObjectAddress *
+																   objectAddress);
 
 /* forward declarations for functions to interact with the ObjectAddressCollector */
 static void InitObjectAddressCollector(ObjectAddressCollector *collector);
@@ -176,7 +178,10 @@ static List * ExpandCitusSupportedTypes(ObjectAddressCollector *collector,
 static List * GetDependentRoleIdsFDW(Oid FDWOid);
 static List * ExpandRolesToGroups(Oid roleid);
 static ViewDependencyNode * BuildViewDependencyGraph(Oid relationId, HTAB *nodeMap);
-
+static bool IsObjectAddressOwnedByExtension(const ObjectAddress *target,
+											ObjectAddress *extensionAddress);
+static bool ErrorOrWarnIfObjectHasUnsupportedDependency(const
+														ObjectAddress *objectAddress);
 
 /*
  * GetUniqueDependenciesList takes a list of object addresses and returns a new list
@@ -774,8 +779,8 @@ SupportedDependencyByCitus(const ObjectAddress *address)
  * object doesn't have any unsupported dependency, else throws a message with proper level
  * (except the cluster doesn't have any node) and return true.
  */
-bool
-ErrorOrWarnIfObjectHasUnsupportedDependency(ObjectAddress *objectAddress)
+static bool
+ErrorOrWarnIfObjectHasUnsupportedDependency(const ObjectAddress *objectAddress)
 {
 	DeferredErrorMessage *errMsg = DeferErrorIfHasUnsupportedDependency(objectAddress);
 	if (errMsg != NULL)
@@ -805,7 +810,7 @@ ErrorOrWarnIfObjectHasUnsupportedDependency(ObjectAddress *objectAddress)
 		 * is not distributed yet, we can create it locally to not affect user's local
 		 * usage experience.
 		 */
-		else if (IsObjectDistributed(objectAddress))
+		else if (IsAnyObjectDistributed(list_make1((ObjectAddress *) objectAddress)))
 		{
 			RaiseDeferredError(errMsg, ERROR);
 		}
@@ -821,11 +826,31 @@ ErrorOrWarnIfObjectHasUnsupportedDependency(ObjectAddress *objectAddress)
 }
 
 
+/*
+ * ErrorOrWarnIfAnyObjectHasUnsupportedDependency iteratively calls
+ * ErrorOrWarnIfObjectHasUnsupportedDependency for given addresses.
+ */
+bool
+ErrorOrWarnIfAnyObjectHasUnsupportedDependency(List *objectAddresses)
+{
+	ObjectAddress *objectAddress = NULL;
+	foreach_ptr(objectAddress, objectAddresses)
+	{
+		if (ErrorOrWarnIfObjectHasUnsupportedDependency(objectAddress))
+		{
+			return true;
+		}
+	}
+
+	return false;
+}
+
+
 /*
  * DeferErrorIfHasUnsupportedDependency returns deferred error message if the given
  * object has any undistributable dependency.
  */
-DeferredErrorMessage *
+static DeferredErrorMessage *
 DeferErrorIfHasUnsupportedDependency(const ObjectAddress *objectAddress)
 {
 	ObjectAddress *undistributableDependency = GetUndistributableDependency(
@@ -858,7 +883,7 @@ DeferErrorIfHasUnsupportedDependency(const ObjectAddress *objectAddress)
 	 * Otherwise, callers are expected to throw the error returned from this
 	 * function as a hard one by ignoring the detail part.
 	 */
-	if (!IsObjectDistributed(objectAddress))
+	if (!IsAnyObjectDistributed(list_make1((ObjectAddress *) objectAddress)))
 	{
 		appendStringInfo(detailInfo, "\"%s\" will be created only locally",
 						 objectDescription);
@@ -873,7 +898,7 @@ DeferErrorIfHasUnsupportedDependency(const ObjectAddress *objectAddress)
 						 objectDescription,
 						 dependencyDescription);
 
-		if (IsObjectDistributed(objectAddress))
+		if (IsAnyObjectDistributed(list_make1((ObjectAddress *) objectAddress)))
 		{
 			appendStringInfo(hintInfo,
 							 "Distribute \"%s\" first to modify \"%s\" on worker nodes",
@@ -900,6 +925,28 @@ DeferErrorIfHasUnsupportedDependency(const ObjectAddress *objectAddress)
 }
 
 
+/*
+ * DeferErrorIfAnyObjectHasUnsupportedDependency iteratively calls
+ * DeferErrorIfHasUnsupportedDependency for given addresses.
+ */
+DeferredErrorMessage *
+DeferErrorIfAnyObjectHasUnsupportedDependency(const List *objectAddresses)
+{
+	DeferredErrorMessage *deferredErrorMessage = NULL;
+	ObjectAddress *objectAddress = NULL;
+	foreach_ptr(objectAddress, objectAddresses)
+	{
+		deferredErrorMessage = DeferErrorIfHasUnsupportedDependency(objectAddress);
+		if (deferredErrorMessage)
+		{
+			return deferredErrorMessage;
+		}
+	}
+
+	return NULL;
+}
+
+
 /*
  * GetUndistributableDependency checks whether object has any non-distributable
  * dependency. If any one found, it will be returned.
@@ -936,7 +983,7 @@ GetUndistributableDependency(const ObjectAddress *objectAddress)
 		/*
 		 * If object is distributed already, ignore it.
 		 */
-		if (IsObjectDistributed(dependency))
+		if (IsAnyObjectDistributed(list_make1(dependency)))
 		{
 			continue;
 		}
@@ -1015,7 +1062,7 @@ IsTableOwnedByExtension(Oid relationId)
  * If extensionAddress is not set to a NULL pointer the function will write the extension
  * address this function depends on into this location.
  */
-bool
+static bool
 IsObjectAddressOwnedByExtension(const ObjectAddress *target,
 								ObjectAddress *extensionAddress)
 {
@@ -1055,6 +1102,27 @@ IsObjectAddressOwnedByExtension(const ObjectAddress *target,
 }
 
 
+/*
+ * IsAnyObjectAddressOwnedByExtension iteratively calls IsObjectAddressOwnedByExtension
+ * for given addresses to determine if any address is owned by an extension.
+ */
+bool
+IsAnyObjectAddressOwnedByExtension(const List *targets,
+								   ObjectAddress *extensionAddress)
+{
+	ObjectAddress *target = NULL;
+	foreach_ptr(target, targets)
+	{
+		if (IsObjectAddressOwnedByExtension(target, extensionAddress))
+		{
+			return true;
+		}
+	}
+
+	return false;
+}
+
+
 /*
  * FollowNewSupportedDependencies applies filters on pg_depend entries to follow all
  * objects which should be distributed before the root object can safely be created.
@@ -1097,7 +1165,9 @@ FollowNewSupportedDependencies(ObjectAddressCollector *collector,
 	 * If the object is already distributed it is not a `new` object that needs to be
 	 * distributed before we create a dependent object
 	 */
-	if (IsObjectDistributed(&address))
+	ObjectAddress *copyAddress = palloc0(sizeof(ObjectAddress));
+	*copyAddress = address;
+	if (IsAnyObjectDistributed(list_make1(copyAddress)))
 	{
 		return false;
 	}

src/backend/distributed/metadata/distobject.c

@@ -53,6 +53,7 @@
 static char * CreatePgDistObjectEntryCommand(const ObjectAddress *objectAddress);
 static int ExecuteCommandAsSuperuser(char *query, int paramCount, Oid *paramTypes,
 									 Datum *paramValues);
+static bool IsObjectDistributed(const ObjectAddress *address);
 
 PG_FUNCTION_INFO_V1(citus_unmark_object_distributed);
 PG_FUNCTION_INFO_V1(master_unmark_object_distributed);
@@ -240,17 +241,18 @@ ShouldMarkRelationDistributed(Oid relationId)
 		return false;
 	}
 
-	ObjectAddress relationAddress = { 0 };
-	ObjectAddressSet(relationAddress, RelationRelationId, relationId);
+	ObjectAddress *relationAddress = palloc0(sizeof(ObjectAddress));
+	ObjectAddressSet(*relationAddress, RelationRelationId, relationId);
 
 	bool pgObject = (relationId < FirstNormalObjectId);
-	bool isObjectSupported = SupportedDependencyByCitus(&relationAddress);
+	bool isObjectSupported = SupportedDependencyByCitus(relationAddress);
 	bool ownedByExtension = IsTableOwnedByExtension(relationId);
-	bool alreadyDistributed = IsObjectDistributed(&relationAddress);
+	bool alreadyDistributed = IsObjectDistributed(relationAddress);
 	bool hasUnsupportedDependency =
-		DeferErrorIfHasUnsupportedDependency(&relationAddress) != NULL;
+		DeferErrorIfAnyObjectHasUnsupportedDependency(list_make1(relationAddress)) !=
+		NULL;
 	bool hasCircularDependency =
-		DeferErrorIfCircularDependencyExists(&relationAddress) != NULL;
+		DeferErrorIfCircularDependencyExists(relationAddress) != NULL;
 
 	/*
 	 * pgObject: Citus never marks pg objects as distributed
@@ -390,7 +392,7 @@ UnmarkObjectDistributed(const ObjectAddress *address)
  * IsObjectDistributed returns if the object addressed is already distributed in the
  * cluster. This performs a local indexed lookup in pg_dist_object.
  */
-bool
+static bool
 IsObjectDistributed(const ObjectAddress *address)
 {
 	ScanKeyData key[3];
@@ -422,6 +424,26 @@ IsObjectDistributed(const ObjectAddress *address)
 }
 
 
+/*
+ * IsAnyObjectDistributed iteratively calls IsObjectDistributed for given addresses to
+ * determine if any object is distributed.
+ */
+bool
+IsAnyObjectDistributed(const List *addresses)
+{
+	ObjectAddress *address = NULL;
+	foreach_ptr(address, addresses)
+	{
+		if (IsObjectDistributed(address))
+		{
+			return true;
+		}
+	}
+
+	return false;
+}
+
+
 /*
  * GetDistributedObjectAddressList returns a list of ObjectAddresses that contains all
  * distributed objects as marked in pg_dist_object

src/backend/distributed/metadata/metadata_sync.c

@@ -356,10 +356,9 @@ CreateDependingViewsOnWorkers(Oid relationId)
 			continue;
 		}
 
-		ObjectAddress viewAddress = { 0 };
-		ObjectAddressSet(viewAddress, RelationRelationId, viewOid);
-
-		EnsureDependenciesExistOnAllNodes(&viewAddress);
+		ObjectAddress *viewAddress = palloc0(sizeof(ObjectAddress));
+		ObjectAddressSet(*viewAddress, RelationRelationId, viewOid);
+		EnsureAllObjectDependenciesExistOnAllNodes(list_make1(viewAddress));
 
 		char *createViewCommand = CreateViewDDLCommand(viewOid);
 		char *alterViewOwnerCommand = AlterViewOwnerCommand(viewOid);
@@ -367,7 +366,7 @@ CreateDependingViewsOnWorkers(Oid relationId)
 		SendCommandToWorkersWithMetadata(createViewCommand);
 		SendCommandToWorkersWithMetadata(alterViewOwnerCommand);
 
-		MarkObjectDistributed(&viewAddress);
+		MarkObjectDistributed(viewAddress);
 	}
 
 	SendCommandToWorkersWithMetadata(ENABLE_DDL_PROPAGATION);
@@ -603,10 +602,10 @@ ShouldSyncSequenceMetadata(Oid relationId)
 		return false;
 	}
 
-	ObjectAddress sequenceAddress = { 0 };
-	ObjectAddressSet(sequenceAddress, RelationRelationId, relationId);
+	ObjectAddress *sequenceAddress = palloc0(sizeof(ObjectAddress));
+	ObjectAddressSet(*sequenceAddress, RelationRelationId, relationId);
 
-	return IsObjectDistributed(&sequenceAddress);
+	return IsAnyObjectDistributed(list_make1(sequenceAddress));
 }
 
 

src/backend/distributed/operations/create_shards.c

@@ -70,7 +70,6 @@ master_create_worker_shards(PG_FUNCTION_ARGS)
 	text *tableNameText = PG_GETARG_TEXT_P(0);
 	int32 shardCount = PG_GETARG_INT32(1);
 	int32 replicationFactor = PG_GETARG_INT32(2);
-	ObjectAddress tableAddress = { 0 };
 
 	Oid distributedTableId = ResolveRelationId(tableNameText, false);
 
@@ -83,8 +82,9 @@ master_create_worker_shards(PG_FUNCTION_ARGS)
 	 * via their own connection and committed immediately so they become visible to all
 	 * sessions creating shards.
 	 */
-	ObjectAddressSet(tableAddress, RelationRelationId, distributedTableId);
-	EnsureDependenciesExistOnAllNodes(&tableAddress);
+	ObjectAddress *tableAddress = palloc0(sizeof(ObjectAddress));
+	ObjectAddressSet(*tableAddress, RelationRelationId, distributedTableId);
+	EnsureAllObjectDependenciesExistOnAllNodes(list_make1(tableAddress));
 
 	EnsureReferenceTablesExistOnAllNodes();
 

src/backend/distributed/operations/stage_protocol.c

@@ -96,7 +96,7 @@ master_create_empty_shard(PG_FUNCTION_ARGS)
 	text *relationNameText = PG_GETARG_TEXT_P(0);
 	char *relationName = text_to_cstring(relationNameText);
 	uint32 attemptableNodeCount = 0;
-	ObjectAddress tableAddress = { 0 };
+	ObjectAddress *tableAddress = palloc0(sizeof(ObjectAddress));
 
 	uint32 candidateNodeIndex = 0;
 	List *candidateNodeList = NIL;
@@ -115,8 +115,8 @@ master_create_empty_shard(PG_FUNCTION_ARGS)
 	 * via their own connection and committed immediately so they become visible to all
 	 * sessions creating shards.
 	 */
-	ObjectAddressSet(tableAddress, RelationRelationId, relationId);
-	EnsureDependenciesExistOnAllNodes(&tableAddress);
+	ObjectAddressSet(*tableAddress, RelationRelationId, relationId);
+	EnsureAllObjectDependenciesExistOnAllNodes(list_make1(tableAddress));
 	EnsureReferenceTablesExistOnAllNodes();
 
 	/* don't allow the table to be dropped */

src/backend/distributed/worker/worker_create_or_replace.c

@@ -181,8 +181,13 @@ WorkerCreateOrReplaceObject(List *sqlStatements)
 	 * same subject.
 	 */
 	Node *parseTree = ParseTreeNode(linitial(sqlStatements));
-	ObjectAddress address = GetObjectAddressFromParseTree(parseTree, true);
-	if (ObjectExists(&address))
+	List *addresses = GetObjectAddressListFromParseTree(parseTree, true);
+	Assert(list_length(viewAddresses) == 1);
+
+	/* We have already asserted that we have exactly 1 address in the addresses. */
+	ObjectAddress *address = linitial(addresses);
+
+	if (ObjectExists(address))
 	{
 		/*
 		 * Object with name from statement is already found locally, check if states are
@@ -195,7 +200,7 @@ WorkerCreateOrReplaceObject(List *sqlStatements)
 		 * recreate our version of the object. This we can compare to what the coordinator
 		 * sent us. If they match we don't do anything.
 		 */
-		List *localSqlStatements = CreateStmtListByObjectAddress(&address);
+		List *localSqlStatements = CreateStmtListByObjectAddress(address);
 		if (CompareStringList(sqlStatements, localSqlStatements))
 		{
 			/*
@@ -208,9 +213,9 @@ WorkerCreateOrReplaceObject(List *sqlStatements)
 			return false;
 		}
 
-		char *newName = GenerateBackupNameForCollision(&address);
+		char *newName = GenerateBackupNameForCollision(address);
 
-		RenameStmt *renameStmt = CreateRenameStatement(&address, newName);
+		RenameStmt *renameStmt = CreateRenameStatement(address, newName);
 		const char *sqlRenameStmt = DeparseTreeNode((Node *) renameStmt);
 		ProcessUtilityParseTree((Node *) renameStmt, sqlRenameStmt,
 								PROCESS_UTILITY_QUERY,

src/backend/distributed/worker/worker_drop_protocol.c

@@ -127,7 +127,8 @@ WorkerDropDistributedTable(Oid relationId)
 	relation_close(distributedRelation, AccessShareLock);
 
 	/* prepare distributedTableObject for dropping the table */
-	ObjectAddress distributedTableObject = { RelationRelationId, relationId, 0 };
+	ObjectAddress *distributedTableObject = palloc0(sizeof(ObjectAddress));
+	ObjectAddressSet(*distributedTableObject, RelationRelationId, relationId);
 
 	/* Drop dependent sequences from pg_dist_object */
 	#if PG_VERSION_NUM >= PG_VERSION_13
@@ -144,7 +145,7 @@ WorkerDropDistributedTable(Oid relationId)
 		UnmarkObjectDistributed(&ownedSequenceAddress);
 	}
 
-	UnmarkObjectDistributed(&distributedTableObject);
+	UnmarkObjectDistributed(distributedTableObject);
 
 	/*
 	 * Remove metadata before object's itself to make functions no-op within
@@ -177,7 +178,7 @@ WorkerDropDistributedTable(Oid relationId)
 	 * until the user runs DROP EXTENSION. Therefore, we skip dropping the
 	 * table.
 	 */
-	if (!IsObjectAddressOwnedByExtension(&distributedTableObject, NULL))
+	if (!IsAnyObjectAddressOwnedByExtension(list_make1(distributedTableObject), NULL))
 	{
 		char *relName = get_rel_name(relationId);
 		Oid schemaId = get_rel_namespace(relationId);
@@ -238,12 +239,9 @@ worker_drop_shell_table(PG_FUNCTION_ARGS)
 	relation_close(distributedRelation, AccessShareLock);
 
 	/* prepare distributedTableObject for dropping the table */
-	ObjectAddress distributedTableObject = { InvalidOid, InvalidOid, 0 };
-	distributedTableObject.classId = RelationRelationId;
-	distributedTableObject.objectId = relationId;
-	distributedTableObject.objectSubId = 0;
-
-	if (IsObjectAddressOwnedByExtension(&distributedTableObject, NULL))
+	ObjectAddress *distributedTableObject = palloc0(sizeof(ObjectAddress));
+	ObjectAddressSet(*distributedTableObject, RelationRelationId, relationId);
+	if (IsAnyObjectAddressOwnedByExtension(list_make1(distributedTableObject), NULL))
 	{
 		PG_RETURN_VOID();
 	}
@@ -270,7 +268,7 @@ worker_drop_shell_table(PG_FUNCTION_ARGS)
 	 *
 	 * We drop the table with cascade since other tables may be referring to it.
 	 */
-	performDeletion(&distributedTableObject, DROP_CASCADE,
+	performDeletion(distributedTableObject, DROP_CASCADE,
 					PERFORM_DELETION_INTERNAL);
 
 	PG_RETURN_VOID();

src/include/distributed/commands.h

@@ -63,7 +63,7 @@ typedef struct DistributeObjectOps
 	void (*qualify)(Node *);
 	List * (*preprocess)(Node *, const char *, ProcessUtilityContext);
 	List * (*postprocess)(Node *, const char *);
-	ObjectAddress (*address)(Node *, bool);
+	List * (*address)(Node *, bool);
 	bool markDistributed;
 
 	/* fields used by common implementations, omitted for specialized implementations */
@@ -159,24 +159,24 @@ extern bool CallDistributedProcedureRemotely(CallStmt *callStmt, DestReceiver *d
 /* collation.c - forward declarations */
 extern char * CreateCollationDDL(Oid collationId);
 extern List * CreateCollationDDLsIdempotent(Oid collationId);
-extern ObjectAddress AlterCollationOwnerObjectAddress(Node *stmt, bool missing_ok);
-extern ObjectAddress RenameCollationStmtObjectAddress(Node *stmt, bool missing_ok);
-extern ObjectAddress AlterCollationSchemaStmtObjectAddress(Node *stmt,
-														   bool missing_ok);
+extern List * AlterCollationOwnerObjectAddress(Node *stmt, bool missing_ok);
+extern List * RenameCollationStmtObjectAddress(Node *stmt, bool missing_ok);
+extern List * AlterCollationSchemaStmtObjectAddress(Node *stmt,
+													bool missing_ok);
 extern char * GenerateBackupNameForCollationCollision(const ObjectAddress *address);
-extern ObjectAddress DefineCollationStmtObjectAddress(Node *stmt, bool missing_ok);
+extern List * DefineCollationStmtObjectAddress(Node *stmt, bool missing_ok);
 
 /* database.c - forward declarations */
-extern ObjectAddress AlterDatabaseOwnerObjectAddress(Node *node, bool missing_ok);
+extern List * AlterDatabaseOwnerObjectAddress(Node *node, bool missing_ok);
 extern List * DatabaseOwnerDDLCommands(const ObjectAddress *address);
 
 /* domain.c - forward declarations */
-extern ObjectAddress CreateDomainStmtObjectAddress(Node *node, bool missing_ok);
-extern ObjectAddress AlterDomainStmtObjectAddress(Node *node, bool missing_ok);
-extern ObjectAddress DomainRenameConstraintStmtObjectAddress(Node *node,
-															 bool missing_ok);
-extern ObjectAddress AlterDomainOwnerStmtObjectAddress(Node *node, bool missing_ok);
-extern ObjectAddress RenameDomainStmtObjectAddress(Node *node, bool missing_ok);
+extern List * CreateDomainStmtObjectAddress(Node *node, bool missing_ok);
+extern List * AlterDomainStmtObjectAddress(Node *node, bool missing_ok);
+extern List * DomainRenameConstraintStmtObjectAddress(Node *node,
+													  bool missing_ok);
+extern List * AlterDomainOwnerStmtObjectAddress(Node *node, bool missing_ok);
+extern List * RenameDomainStmtObjectAddress(Node *node, bool missing_ok);
 extern CreateDomainStmt * RecreateDomainStmt(Oid domainOid);
 extern Oid get_constraint_typid(Oid conoid);
 
@@ -208,10 +208,10 @@ extern List * PreprocessAlterExtensionContentsStmt(Node *node,
 												   ProcessUtilityContext
 												   processUtilityContext);
 extern List * CreateExtensionDDLCommand(const ObjectAddress *extensionAddress);
-extern ObjectAddress AlterExtensionSchemaStmtObjectAddress(Node *stmt,
-														   bool missing_ok);
-extern ObjectAddress AlterExtensionUpdateStmtObjectAddress(Node *stmt,
-														   bool missing_ok);
+extern List * AlterExtensionSchemaStmtObjectAddress(Node *stmt,
+													bool missing_ok);
+extern List * AlterExtensionUpdateStmtObjectAddress(Node *stmt,
+													bool missing_ok);
 extern void CreateExtensionWithVersion(char *extname, char *extVersion);
 extern void AlterExtensionUpdateStmt(char *extname, char *extVersion);
 extern int GetExtensionVersionNumber(char *extVersion);
@@ -263,11 +263,11 @@ extern Acl * GetPrivilegesForFDW(Oid FDWOid);
 extern List * PreprocessGrantOnForeignServerStmt(Node *node, const char *queryString,
 												 ProcessUtilityContext
 												 processUtilityContext);
-extern ObjectAddress CreateForeignServerStmtObjectAddress(Node *node, bool missing_ok);
-extern ObjectAddress AlterForeignServerStmtObjectAddress(Node *node, bool missing_ok);
-extern ObjectAddress RenameForeignServerStmtObjectAddress(Node *node, bool missing_ok);
-extern ObjectAddress AlterForeignServerOwnerStmtObjectAddress(Node *node, bool
-															  missing_ok);
+extern List * CreateForeignServerStmtObjectAddress(Node *node, bool missing_ok);
+extern List * AlterForeignServerStmtObjectAddress(Node *node, bool missing_ok);
+extern List * RenameForeignServerStmtObjectAddress(Node *node, bool missing_ok);
+extern List * AlterForeignServerOwnerStmtObjectAddress(Node *node, bool
+													   missing_ok);
 extern List * GetForeignServerCreateDDLCommand(Oid serverId);
 
 
@@ -282,26 +282,26 @@ extern List * PreprocessCreateFunctionStmt(Node *stmt, const char *queryString,
 										   ProcessUtilityContext processUtilityContext);
 extern List * PostprocessCreateFunctionStmt(Node *stmt,
 											const char *queryString);
-extern ObjectAddress CreateFunctionStmtObjectAddress(Node *stmt,
-													 bool missing_ok);
-extern ObjectAddress DefineAggregateStmtObjectAddress(Node *stmt,
-													  bool missing_ok);
+extern List * CreateFunctionStmtObjectAddress(Node *stmt,
+											  bool missing_ok);
+extern List * DefineAggregateStmtObjectAddress(Node *stmt,
+											   bool missing_ok);
 extern List * PreprocessAlterFunctionStmt(Node *stmt, const char *queryString,
 										  ProcessUtilityContext processUtilityContext);
-extern ObjectAddress AlterFunctionStmtObjectAddress(Node *stmt,
-													bool missing_ok);
-extern ObjectAddress RenameFunctionStmtObjectAddress(Node *stmt,
-													 bool missing_ok);
-extern ObjectAddress AlterFunctionOwnerObjectAddress(Node *stmt,
-													 bool missing_ok);
-extern ObjectAddress AlterFunctionSchemaStmtObjectAddress(Node *stmt,
-														  bool missing_ok);
+extern List * AlterFunctionStmtObjectAddress(Node *stmt,
+											 bool missing_ok);
+extern List * RenameFunctionStmtObjectAddress(Node *stmt,
+											  bool missing_ok);
+extern List * AlterFunctionOwnerObjectAddress(Node *stmt,
+											  bool missing_ok);
+extern List * AlterFunctionSchemaStmtObjectAddress(Node *stmt,
+												   bool missing_ok);
 extern List * PreprocessAlterFunctionDependsStmt(Node *stmt,
 												 const char *queryString,
 												 ProcessUtilityContext
 												 processUtilityContext);
-extern ObjectAddress AlterFunctionDependsStmtObjectAddress(Node *stmt,
-														   bool missing_ok);
+extern List * AlterFunctionDependsStmtObjectAddress(Node *stmt,
+													bool missing_ok);
 extern List * PreprocessGrantOnFunctionStmt(Node *node, const char *queryString,
 											ProcessUtilityContext processUtilityContext);
 extern List * PostprocessGrantOnFunctionStmt(Node *node, const char *queryString);
@@ -340,7 +340,7 @@ extern List * ExecuteFunctionOnEachTableIndex(Oid relationId, PGIndexProcessor
 extern bool IsReindexWithParam_compat(ReindexStmt *stmt, char *paramName);
 
 /* objectaddress.c - forward declarations */
-extern ObjectAddress CreateExtensionStmtObjectAddress(Node *stmt, bool missing_ok);
+extern List * CreateExtensionStmtObjectAddress(Node *stmt, bool missing_ok);
 
 
 /* policy.c -  forward declarations */
@@ -376,10 +376,10 @@ extern List * PostprocessAlterRoleStmt(Node *stmt, const char *queryString);
 extern List * PreprocessAlterRoleSetStmt(Node *stmt, const char *queryString,
 										 ProcessUtilityContext processUtilityContext);
 extern List * GenerateAlterRoleSetCommandForRole(Oid roleid);
-extern ObjectAddress AlterRoleStmtObjectAddress(Node *node,
-												bool missing_ok);
-extern ObjectAddress AlterRoleSetStmtObjectAddress(Node *node,
-												   bool missing_ok);
+extern List * AlterRoleStmtObjectAddress(Node *node,
+										 bool missing_ok);
+extern List * AlterRoleSetStmtObjectAddress(Node *node,
+											bool missing_ok);
 extern List * PreprocessCreateRoleStmt(Node *stmt, const char *queryString,
 									   ProcessUtilityContext processUtilityContext);
 extern List * PreprocessDropRoleStmt(Node *stmt, const char *queryString,
@@ -388,7 +388,7 @@ extern List * PreprocessGrantRoleStmt(Node *stmt, const char *queryString,
 									  ProcessUtilityContext processUtilityContext);
 extern List * PostprocessGrantRoleStmt(Node *stmt, const char *queryString);
 extern List * GenerateCreateOrAlterRoleCommand(Oid roleOid);
-ObjectAddress CreateRoleStmtObjectAddress(Node *stmt, bool missing_ok);
+extern List * CreateRoleStmtObjectAddress(Node *stmt, bool missing_ok);
 extern void UnmarkRolesDistributed(List *roles);
 extern List * FilterDistributedRoles(List *roles);
 
@@ -402,8 +402,8 @@ extern List * PreprocessAlterObjectSchemaStmt(Node *alterObjectSchemaStmt,
 											  const char *alterObjectSchemaCommand);
 extern List * PreprocessGrantOnSchemaStmt(Node *node, const char *queryString,
 										  ProcessUtilityContext processUtilityContext);
-extern ObjectAddress CreateSchemaStmtObjectAddress(Node *node, bool missing_ok);
-extern ObjectAddress AlterSchemaRenameStmtObjectAddress(Node *node, bool missing_ok);
+extern List * CreateSchemaStmtObjectAddress(Node *node, bool missing_ok);
+extern List * AlterSchemaRenameStmtObjectAddress(Node *node, bool missing_ok);
 
 /* sequence.c - forward declarations */
 extern List * PreprocessAlterSequenceStmt(Node *node, const char *queryString,
@@ -422,10 +422,10 @@ extern List * PreprocessRenameSequenceStmt(Node *node, const char *queryString,
 extern List * PreprocessGrantOnSequenceStmt(Node *node, const char *queryString,
 											ProcessUtilityContext processUtilityContext);
 extern List * PostprocessGrantOnSequenceStmt(Node *node, const char *queryString);
-extern ObjectAddress AlterSequenceStmtObjectAddress(Node *node, bool missing_ok);
-extern ObjectAddress AlterSequenceSchemaStmtObjectAddress(Node *node, bool missing_ok);
-extern ObjectAddress AlterSequenceOwnerStmtObjectAddress(Node *node, bool missing_ok);
-extern ObjectAddress RenameSequenceStmtObjectAddress(Node *node, bool missing_ok);
+extern List * AlterSequenceStmtObjectAddress(Node *node, bool missing_ok);
+extern List * AlterSequenceSchemaStmtObjectAddress(Node *node, bool missing_ok);
+extern List * AlterSequenceOwnerStmtObjectAddress(Node *node, bool missing_ok);
+extern List * RenameSequenceStmtObjectAddress(Node *node, bool missing_ok);
 extern void ErrorIfUnsupportedSeqStmt(CreateSeqStmt *createSeqStmt);
 extern void ErrorIfDistributedAlterSeqOwnedBy(AlterSeqStmt *alterSeqStmt);
 extern char * GenerateBackupNameForSequenceCollision(const ObjectAddress *address);
@@ -436,7 +436,7 @@ extern void RenameExistingSequenceWithDifferentTypeIfExists(RangeVar *sequence,
 extern List * PreprocessCreateStatisticsStmt(Node *node, const char *queryString,
 											 ProcessUtilityContext processUtilityContext);
 extern List * PostprocessCreateStatisticsStmt(Node *node, const char *queryString);
-extern ObjectAddress CreateStatisticsStmtObjectAddress(Node *node, bool missingOk);
+extern List * CreateStatisticsStmtObjectAddress(Node *node, bool missingOk);
 extern List * PreprocessDropStatisticsStmt(Node *node, const char *queryString,
 										   ProcessUtilityContext processUtilityContext);
 extern List * PreprocessAlterStatisticsRenameStmt(Node *node, const char *queryString,
@@ -446,7 +446,7 @@ extern List * PreprocessAlterStatisticsSchemaStmt(Node *node, const char *queryS
 												  ProcessUtilityContext
 												  processUtilityContext);
 extern List * PostprocessAlterStatisticsSchemaStmt(Node *node, const char *queryString);
-extern ObjectAddress AlterStatisticsSchemaStmtObjectAddress(Node *node, bool missingOk);
+extern List * AlterStatisticsSchemaStmtObjectAddress(Node *node, bool missingOk);
 extern List * PreprocessAlterStatisticsStmt(Node *node, const char *queryString,
 											ProcessUtilityContext processUtilityContext);
 extern List * PreprocessAlterStatisticsOwnerStmt(Node *node, const char *queryString,
@@ -487,8 +487,8 @@ extern void ErrorUnsupportedAlterTableAddColumn(Oid relationId, AlterTableCmd *c
 extern void ErrorIfUnsupportedConstraint(Relation relation, char distributionMethod,
 										 char referencingReplicationModel,
 										 Var *distributionColumn, uint32 colocationId);
-extern ObjectAddress AlterTableSchemaStmtObjectAddress(Node *stmt,
-													   bool missing_ok);
+extern List * AlterTableSchemaStmtObjectAddress(Node *stmt,
+												bool missing_ok);
 extern List * MakeNameListFromRangeVar(const RangeVar *rel);
 extern Oid GetSequenceOid(Oid relationId, AttrNumber attnum);
 extern bool ConstrTypeUsesIndex(ConstrType constrType);
@@ -499,30 +499,30 @@ extern List * GetCreateTextSearchConfigStatements(const ObjectAddress *address);
 extern List * GetCreateTextSearchDictionaryStatements(const ObjectAddress *address);
 extern List * CreateTextSearchConfigDDLCommandsIdempotent(const ObjectAddress *address);
 extern List * CreateTextSearchDictDDLCommandsIdempotent(const ObjectAddress *address);
-extern ObjectAddress CreateTextSearchConfigurationObjectAddress(Node *node,
-																bool missing_ok);
-extern ObjectAddress CreateTextSearchDictObjectAddress(Node *node,
-													   bool missing_ok);
-extern ObjectAddress RenameTextSearchConfigurationStmtObjectAddress(Node *node,
-																	bool missing_ok);
-extern ObjectAddress RenameTextSearchDictionaryStmtObjectAddress(Node *node,
-																 bool missing_ok);
-extern ObjectAddress AlterTextSearchConfigurationStmtObjectAddress(Node *node,
-																   bool missing_ok);
-extern ObjectAddress AlterTextSearchDictionaryStmtObjectAddress(Node *node,
-																bool missing_ok);
-extern ObjectAddress AlterTextSearchConfigurationSchemaStmtObjectAddress(Node *node,
-																		 bool missing_ok);
-extern ObjectAddress AlterTextSearchDictionarySchemaStmtObjectAddress(Node *node,
-																	  bool missing_ok);
-extern ObjectAddress TextSearchConfigurationCommentObjectAddress(Node *node,
-																 bool missing_ok);
-extern ObjectAddress TextSearchDictCommentObjectAddress(Node *node,
-														bool missing_ok);
-extern ObjectAddress AlterTextSearchConfigurationOwnerObjectAddress(Node *node,
-																	bool missing_ok);
-extern ObjectAddress AlterTextSearchDictOwnerObjectAddress(Node *node,
-														   bool missing_ok);
+extern List * CreateTextSearchConfigurationObjectAddress(Node *node,
+														 bool missing_ok);
+extern List * CreateTextSearchDictObjectAddress(Node *node,
+												bool missing_ok);
+extern List * RenameTextSearchConfigurationStmtObjectAddress(Node *node,
+															 bool missing_ok);
+extern List * RenameTextSearchDictionaryStmtObjectAddress(Node *node,
+														  bool missing_ok);
+extern List * AlterTextSearchConfigurationStmtObjectAddress(Node *node,
+															bool missing_ok);
+extern List * AlterTextSearchDictionaryStmtObjectAddress(Node *node,
+														 bool missing_ok);
+extern List * AlterTextSearchConfigurationSchemaStmtObjectAddress(Node *node,
+																  bool missing_ok);
+extern List * AlterTextSearchDictionarySchemaStmtObjectAddress(Node *node,
+															   bool missing_ok);
+extern List * TextSearchConfigurationCommentObjectAddress(Node *node,
+														  bool missing_ok);
+extern List * TextSearchDictCommentObjectAddress(Node *node,
+												 bool missing_ok);
+extern List * AlterTextSearchConfigurationOwnerObjectAddress(Node *node,
+															 bool missing_ok);
+extern List * AlterTextSearchDictOwnerObjectAddress(Node *node,
+													bool missing_ok);
 extern char * GenerateBackupNameForTextSearchConfiguration(const ObjectAddress *address);
 extern char * GenerateBackupNameForTextSearchDict(const ObjectAddress *address);
 extern List * get_ts_config_namelist(Oid tsconfigOid);
@@ -535,16 +535,16 @@ extern List * PreprocessRenameTypeAttributeStmt(Node *stmt, const char *queryStr
 												ProcessUtilityContext
 												processUtilityContext);
 extern Node * CreateTypeStmtByObjectAddress(const ObjectAddress *address);
-extern ObjectAddress CompositeTypeStmtObjectAddress(Node *stmt, bool missing_ok);
-extern ObjectAddress CreateEnumStmtObjectAddress(Node *stmt, bool missing_ok);
-extern ObjectAddress AlterTypeStmtObjectAddress(Node *stmt, bool missing_ok);
-extern ObjectAddress AlterEnumStmtObjectAddress(Node *stmt, bool missing_ok);
-extern ObjectAddress RenameTypeStmtObjectAddress(Node *stmt, bool missing_ok);
-extern ObjectAddress AlterTypeSchemaStmtObjectAddress(Node *stmt,
-													  bool missing_ok);
-extern ObjectAddress RenameTypeAttributeStmtObjectAddress(Node *stmt,
-														  bool missing_ok);
-extern ObjectAddress AlterTypeOwnerObjectAddress(Node *stmt, bool missing_ok);
+extern List * CompositeTypeStmtObjectAddress(Node *stmt, bool missing_ok);
+extern List * CreateEnumStmtObjectAddress(Node *stmt, bool missing_ok);
+extern List * AlterTypeStmtObjectAddress(Node *stmt, bool missing_ok);
+extern List * AlterEnumStmtObjectAddress(Node *stmt, bool missing_ok);
+extern List * RenameTypeStmtObjectAddress(Node *stmt, bool missing_ok);
+extern List * AlterTypeSchemaStmtObjectAddress(Node *stmt,
+											   bool missing_ok);
+extern List * RenameTypeAttributeStmtObjectAddress(Node *stmt,
+												   bool missing_ok);
+extern List * AlterTypeOwnerObjectAddress(Node *stmt, bool missing_ok);
 extern List * CreateTypeDDLCommandsIdempotent(const ObjectAddress *typeAddress);
 extern char * GenerateBackupNameForTypeCollision(const ObjectAddress *address);
 
@@ -565,8 +565,8 @@ extern List * PostprocessVacuumStmt(Node *node, const char *vacuumCommand);
 extern List * PreprocessViewStmt(Node *node, const char *queryString,
 								 ProcessUtilityContext processUtilityContext);
 extern List * PostprocessViewStmt(Node *node, const char *queryString);
-extern ObjectAddress ViewStmtObjectAddress(Node *node, bool missing_ok);
-extern ObjectAddress AlterViewStmtObjectAddress(Node *node, bool missing_ok);
+extern List * ViewStmtObjectAddress(Node *node, bool missing_ok);
+extern List * AlterViewStmtObjectAddress(Node *node, bool missing_ok);
 extern List * PreprocessDropViewStmt(Node *node, const char *queryString,
 									 ProcessUtilityContext processUtilityContext);
 extern char * CreateViewDDLCommand(Oid viewOid);
@@ -582,11 +582,11 @@ extern List * PreprocessAlterViewStmt(Node *node, const char *queryString,
 extern List * PostprocessAlterViewStmt(Node *node, const char *queryString);
 extern List * PreprocessRenameViewStmt(Node *node, const char *queryString,
 									   ProcessUtilityContext processUtilityContext);
-extern ObjectAddress RenameViewStmtObjectAddress(Node *node, bool missing_ok);
+extern List * RenameViewStmtObjectAddress(Node *node, bool missing_ok);
 extern List * PreprocessAlterViewSchemaStmt(Node *node, const char *queryString,
 											ProcessUtilityContext processUtilityContext);
 extern List * PostprocessAlterViewSchemaStmt(Node *node, const char *queryString);
-extern ObjectAddress AlterViewSchemaStmtObjectAddress(Node *node, bool missing_ok);
+extern List * AlterViewSchemaStmtObjectAddress(Node *node, bool missing_ok);
 extern bool IsViewRenameStmt(RenameStmt *renameStmt);
 
 /* trigger.c - forward declarations */
@@ -594,7 +594,7 @@ extern List * GetExplicitTriggerCommandList(Oid relationId);
 extern HeapTuple GetTriggerTupleById(Oid triggerId, bool missingOk);
 extern List * GetExplicitTriggerIdList(Oid relationId);
 extern List * PostprocessCreateTriggerStmt(Node *node, const char *queryString);
-extern ObjectAddress CreateTriggerStmtObjectAddress(Node *node, bool missingOk);
+extern List * CreateTriggerStmtObjectAddress(Node *node, bool missingOk);
 extern void CreateTriggerEventExtendNames(CreateTrigStmt *createTriggerStmt,
 										  char *schemaName, uint64 shardId);
 extern List * PostprocessAlterTriggerRenameStmt(Node *node, const char *queryString);

src/include/distributed/deparser.h

@@ -148,8 +148,8 @@ extern void QualifyAlterTypeOwnerStmt(Node *stmt);
 extern char * GetTypeNamespaceNameByNameList(List *names);
 extern Oid TypeOidGetNamespaceOid(Oid typeOid);
 
-extern ObjectAddress GetObjectAddressFromParseTree(Node *parseTree, bool missing_ok);
-extern ObjectAddress RenameAttributeStmtObjectAddress(Node *stmt, bool missing_ok);
+extern List * GetObjectAddressListFromParseTree(Node *parseTree, bool missing_ok);
+extern List * RenameAttributeStmtObjectAddress(Node *stmt, bool missing_ok);
 
 /* forward declarations for deparse_view_stmts.c */
 extern void QualifyDropViewStmt(Node *node);

src/include/distributed/metadata/dependency.h

@@ -23,10 +23,9 @@ extern List * GetUniqueDependenciesList(List *objectAddressesList);
 extern List * GetDependenciesForObject(const ObjectAddress *target);
 extern List * GetAllSupportedDependenciesForObject(const ObjectAddress *target);
 extern List * GetAllDependenciesForObject(const ObjectAddress *target);
-extern bool ErrorOrWarnIfObjectHasUnsupportedDependency(ObjectAddress *objectAddress);
-extern DeferredErrorMessage * DeferErrorIfHasUnsupportedDependency(const
-																   ObjectAddress *
-																   objectAddress);
+extern bool ErrorOrWarnIfAnyObjectHasUnsupportedDependency(List *objectAddresses);
+extern DeferredErrorMessage * DeferErrorIfAnyObjectHasUnsupportedDependency(const List *
+																			objectAddresses);
 extern List * OrderObjectAddressListInDependencyOrder(List *objectAddressList);
 extern bool SupportedDependencyByCitus(const ObjectAddress *address);
 extern List * GetPgDependTuplesForDependingObjects(Oid targetObjectClassId,

src/include/distributed/metadata/distobject.h

@@ -20,15 +20,15 @@
 
 extern bool ObjectExists(const ObjectAddress *address);
 extern bool CitusExtensionObject(const ObjectAddress *objectAddress);
-extern bool IsObjectDistributed(const ObjectAddress *address);
+extern bool IsAnyObjectDistributed(const List *addresses);
 extern bool ClusterHasDistributedFunctionWithDistArgument(void);
 extern void MarkObjectDistributed(const ObjectAddress *distAddress);
 extern void MarkObjectDistributedViaSuperUser(const ObjectAddress *distAddress);
 extern void MarkObjectDistributedLocally(const ObjectAddress *distAddress);
 extern void UnmarkObjectDistributed(const ObjectAddress *address);
 extern bool IsTableOwnedByExtension(Oid relationId);
-extern bool IsObjectAddressOwnedByExtension(const ObjectAddress *target,
-											ObjectAddress *extensionAddress);
+extern bool IsAnyObjectAddressOwnedByExtension(const List *targets,
+											   ObjectAddress *extensionAddress);
 extern ObjectAddress PgGetObjectAddress(char *ttype, ArrayType *namearr,
 										ArrayType *argsarr);
 extern List * GetDistributedObjectAddressList(void);

src/include/distributed/metadata_utility.h

@@ -258,15 +258,15 @@ extern void CreateDistributedTable(Oid relationId, char *distributionColumnName,
 extern void CreateTruncateTrigger(Oid relationId);
 extern TableConversionReturn * UndistributeTable(TableConversionParameters *params);
 
-extern void EnsureDependenciesExistOnAllNodes(const ObjectAddress *target);
+extern void EnsureAllObjectDependenciesExistOnAllNodes(const List *targets);
 extern DeferredErrorMessage * DeferErrorIfCircularDependencyExists(const
 																   ObjectAddress *
 																   objectAddress);
 extern List * GetDistributableDependenciesForObject(const ObjectAddress *target);
-extern List * GetDependencyCreateDDLCommands(const ObjectAddress *dependency);
+extern List * GetAllDependencyCreateDDLCommands(const List *dependencies);
 extern bool ShouldPropagate(void);
 extern bool ShouldPropagateCreateInCoordinatedTransction(void);
-extern bool ShouldPropagateObject(const ObjectAddress *address);
+extern bool ShouldPropagateAnyObject(List *addresses);
 extern List * ReplicateAllObjectsToNodeCommandList(const char *nodeName, int nodePort);
 
 /* Remaining metadata utility functions  */