From 9d232d7b00c37b1ad386fc5ed387c2e8bac6728a Mon Sep 17 00:00:00 2001 From: aykutbozkurt Date: Thu, 14 Jul 2022 14:38:29 +0300 Subject: [PATCH 1/2] change address method to return list of addresses --- src/backend/distributed/commands/collation.c | 35 ++-- src/backend/distributed/commands/database.c | 8 +- src/backend/distributed/commands/domain.c | 26 +-- src/backend/distributed/commands/extension.c | 16 +- .../distributed/commands/foreign_server.c | 30 +-- src/backend/distributed/commands/function.c | 34 ++-- src/backend/distributed/commands/role.c | 22 +-- src/backend/distributed/commands/schema.c | 14 +- src/backend/distributed/commands/sequence.c | 32 +-- src/backend/distributed/commands/statistics.c | 16 +- src/backend/distributed/commands/table.c | 8 +- .../distributed/commands/text_search.c | 102 +++++----- src/backend/distributed/commands/trigger.c | 8 +- src/backend/distributed/commands/type.c | 64 +++--- src/backend/distributed/commands/view.c | 32 +-- .../distributed/deparser/objectaddress.c | 24 ++- src/include/distributed/commands.h | 182 +++++++++--------- src/include/distributed/deparser.h | 2 +- 18 files changed, 345 insertions(+), 310 deletions(-) diff --git a/src/backend/distributed/commands/collation.c b/src/backend/distributed/commands/collation.c index f9b977447..492e2ace2 100644 --- a/src/backend/distributed/commands/collation.c +++ b/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); } diff --git a/src/backend/distributed/commands/database.c b/src/backend/distributed/commands/database.c index 6f451893e..2bd03d5d8 100644 --- a/src/backend/distributed/commands/database.c +++ b/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); } diff --git a/src/backend/distributed/commands/domain.c b/src/backend/distributed/commands/domain.c index c75af0024..50d195d58 100644 --- a/src/backend/distributed/commands/domain.c +++ b/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); diff --git a/src/backend/distributed/commands/extension.c b/src/backend/distributed/commands/extension.c index 6f45cec5b..e4979f035 100644 --- a/src/backend/distributed/commands/extension.c +++ b/src/backend/distributed/commands/extension.c @@ -1128,7 +1128,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 +1145,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 +1156,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 +1171,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); } diff --git a/src/backend/distributed/commands/foreign_server.c b/src/backend/distributed/commands/foreign_server.c index 0502b2ef4..36b6094a9 100644 --- a/src/backend/distributed/commands/foreign_server.c +++ b/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); @@ -121,7 +122,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 +140,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 +246,16 @@ NameListHasDistributedServer(List *serverNames) String *serverValue = NULL; foreach_ptr(serverValue, serverNames) { - ObjectAddress address = GetObjectAddressByServerName(strVal(serverValue), false); + List *addresses = GetObjectAddressByServerName(strVal(serverValue), false); + if (list_length(addresses) > 1) + { + ereport(ERROR, errmsg( + "citus does not support multiple object addresses in NameListHasDistributedServer")); + } - if (IsObjectDistributed(&address)) + ObjectAddress *address = linitial(addresses); + + if (IsObjectDistributed(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); } diff --git a/src/backend/distributed/commands/function.c b/src/backend/distributed/commands/function.c index 73c014c6a..ccf2ef2f3 100644 --- a/src/backend/distributed/commands/function.c +++ b/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, @@ -1405,7 +1405,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 +1440,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); @@ -1576,7 +1576,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 +1592,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 +1604,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 +1617,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 +1635,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 +1680,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 +1827,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); } diff --git a/src/backend/distributed/commands/role.c b/src/backend/distributed/commands/role.c index 4c4a7053a..6d19d6726 100644 --- a/src/backend/distributed/commands/role.c +++ b/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); } @@ -1179,15 +1179,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); } diff --git a/src/backend/distributed/commands/schema.c b/src/backend/distributed/commands/schema.c index 47af36efd..825a56b09 100644 --- a/src/backend/distributed/commands/schema.c +++ b/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); } diff --git a/src/backend/distributed/commands/sequence.c b/src/backend/distributed/commands/sequence.c index 4e5cd18de..324e373b5 100644 --- a/src/backend/distributed/commands/sequence.c +++ b/src/backend/distributed/commands/sequence.c @@ -358,7 +358,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 +366,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); } @@ -471,17 +471,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); } @@ -521,7 +521,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 +555,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); } @@ -623,7 +623,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 +631,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); } diff --git a/src/backend/distributed/commands/statistics.c b/src/backend/distributed/commands/statistics.c index bf48505a5..48ed8df20 100644 --- a/src/backend/distributed/commands/statistics.c +++ b/src/backend/distributed/commands/statistics.c @@ -138,16 +138,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); } @@ -322,18 +322,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); } diff --git a/src/backend/distributed/commands/table.c b/src/backend/distributed/commands/table.c index 8a73f1471..05f2a82ab 100644 --- a/src/backend/distributed/commands/table.c +++ b/src/backend/distributed/commands/table.c @@ -3353,7 +3353,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 +3389,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); } diff --git a/src/backend/distributed/commands/text_search.c b/src/backend/distributed/commands/text_search.c index 05319324d..22ff5df2f 100644 --- a/src/backend/distributed/commands/text_search.c +++ b/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); } diff --git a/src/backend/distributed/commands/trigger.c b/src/backend/distributed/commands/trigger.c index 94f4f4cef..12d7253e2 100644 --- a/src/backend/distributed/commands/trigger.c +++ b/src/backend/distributed/commands/trigger.c @@ -241,7 +241,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 +260,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); } diff --git a/src/backend/distributed/commands/type.c b/src/backend/distributed/commands/type.c index 9931f430a..9ebe51510 100644 --- a/src/backend/distributed/commands/type.c +++ b/src/backend/distributed/commands/type.c @@ -300,16 +300,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 +321,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 +342,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 +350,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 +361,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 +378,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 +386,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 +402,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 +447,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 +462,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 +471,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 +482,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 +490,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); } diff --git a/src/backend/distributed/commands/view.c b/src/backend/distributed/commands/view.c index adae0c84e..daf255652 100644 --- a/src/backend/distributed/commands/view.c +++ b/src/backend/distributed/commands/view.c @@ -152,17 +152,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); } @@ -520,16 +520,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); } @@ -572,17 +572,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); } @@ -648,7 +648,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 +676,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); } diff --git a/src/backend/distributed/deparser/objectaddress.c b/src/backend/distributed/deparser/objectaddress.c index a9f1663bc..123445c23 100644 --- a/src/backend/distributed/deparser/objectaddress.c +++ b/src/backend/distributed/deparser/objectaddress.c @@ -33,11 +33,23 @@ GetObjectAddressFromParseTree(Node *parseTree, bool missing_ok) ereport(ERROR, (errmsg("unsupported statement to get object address for"))); } - return ops->address(parseTree, missing_ok); + List *objectAddresses = ops->address(parseTree, missing_ok); + + if (list_length(objectAddresses) > 1) + { + ereport(ERROR, (errmsg( + "citus does not support multiple object addresses in GetObjectAddressFromParseTree"))); + } + + Assert(list_length(objectAddresses) == 1); + + ObjectAddress *objectAddress = linitial(objectAddresses); + + return *objectAddress; } -ObjectAddress +List * RenameAttributeStmtObjectAddress(Node *node, bool missing_ok) { RenameStmt *stmt = castNode(RenameStmt, node); @@ -67,11 +79,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 +97,7 @@ CreateExtensionStmtObjectAddress(Node *node, bool missing_ok) extensionName))); } - ObjectAddressSet(address, ExtensionRelationId, extensionoid); + ObjectAddressSet(*address, ExtensionRelationId, extensionoid); - return address; + return list_make1(address); } diff --git a/src/include/distributed/commands.h b/src/include/distributed/commands.h index 370810cfa..0bc565aff 100644 --- a/src/include/distributed/commands.h +++ b/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); diff --git a/src/include/distributed/deparser.h b/src/include/distributed/deparser.h index f036d7ea8..f3bdb19b2 100644 --- a/src/include/distributed/deparser.h +++ b/src/include/distributed/deparser.h @@ -149,7 +149,7 @@ 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 * RenameAttributeStmtObjectAddress(Node *stmt, bool missing_ok); /* forward declarations for deparse_view_stmts.c */ extern void QualifyDropViewStmt(Node *node); From ebb6d1c8c00c29beb08b162ea87edc11bf8c7814 Mon Sep 17 00:00:00 2001 From: aykutbozkurt Date: Thu, 14 Jul 2022 16:33:08 +0300 Subject: [PATCH 2/2] refactor code where GetObjectAddressFromParseTree is called because it returns list of addresses now --- .../distributed/commands/alter_table.c | 9 +- .../citus_add_local_table_to_metadata.c | 6 +- src/backend/distributed/commands/common.c | 37 +++++--- .../commands/create_distributed_table.c | 7 +- .../distributed/commands/dependencies.c | 70 +++++++++++++-- src/backend/distributed/commands/extension.c | 23 +++-- .../commands/foreign_data_wrapper.c | 10 ++- .../distributed/commands/foreign_server.c | 12 +-- src/backend/distributed/commands/function.c | 75 ++++++++++------ src/backend/distributed/commands/grant.c | 6 +- src/backend/distributed/commands/index.c | 8 +- src/backend/distributed/commands/role.c | 30 ++++--- src/backend/distributed/commands/schema.c | 7 +- src/backend/distributed/commands/sequence.c | 87 +++++++++++------- src/backend/distributed/commands/statistics.c | 21 +++-- src/backend/distributed/commands/table.c | 32 ++++--- src/backend/distributed/commands/trigger.c | 8 +- src/backend/distributed/commands/type.c | 8 +- .../distributed/commands/utility_hook.c | 8 +- src/backend/distributed/commands/view.c | 87 ++++++++++++------ .../distributed/deparser/objectaddress.c | 20 +---- src/backend/distributed/metadata/dependency.c | 90 ++++++++++++++++--- src/backend/distributed/metadata/distobject.c | 36 ++++++-- .../distributed/metadata/metadata_sync.c | 15 ++-- .../distributed/operations/create_shards.c | 6 +- .../distributed/operations/stage_protocol.c | 6 +- .../worker/worker_create_or_replace.c | 15 ++-- .../distributed/worker/worker_drop_protocol.c | 18 ++-- src/include/distributed/deparser.h | 2 +- src/include/distributed/metadata/dependency.h | 7 +- src/include/distributed/metadata/distobject.h | 6 +- src/include/distributed/metadata_utility.h | 6 +- 32 files changed, 525 insertions(+), 253 deletions(-) diff --git a/src/backend/distributed/commands/alter_table.c b/src/backend/distributed/commands/alter_table.c index 9c0f07be3..8258919f4 100644 --- a/src/backend/distributed/commands/alter_table.c +++ b/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; } diff --git a/src/backend/distributed/commands/citus_add_local_table_to_metadata.c b/src/backend/distributed/commands/citus_add_local_table_to_metadata.c index 9d58cc716..0e2bd0ecd 100644 --- a/src/backend/distributed/commands/citus_add_local_table_to_metadata.c +++ b/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 diff --git a/src/backend/distributed/commands/common.c b/src/backend/distributed/commands/common.c index 1c6a71de3..29cb96e9a 100644 --- a/src/backend/distributed/commands/common.c +++ b/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); } diff --git a/src/backend/distributed/commands/create_distributed_table.c b/src/backend/distributed/commands/create_distributed_table.c index 26a905f23..1416cbb3b 100644 --- a/src/backend/distributed/commands/create_distributed_table.c +++ b/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, diff --git a/src/backend/distributed/commands/dependencies.c b/src/backend/distributed/commands/dependencies.c index 2f8182fe6..6329cf6f4 100644 --- a/src/backend/distributed/commands/dependencies.c +++ b/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. diff --git a/src/backend/distributed/commands/extension.c b/src/backend/distributed/commands/extension.c index e4979f035..122c68dfa 100644 --- a/src/backend/distributed/commands/extension.c +++ b/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. diff --git a/src/backend/distributed/commands/foreign_data_wrapper.c b/src/backend/distributed/commands/foreign_data_wrapper.c index 9cfd5f10e..c9a08c41a 100644 --- a/src/backend/distributed/commands/foreign_data_wrapper.c +++ b/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; } diff --git a/src/backend/distributed/commands/foreign_server.c b/src/backend/distributed/commands/foreign_server.c index 36b6094a9..d98393e48 100644 --- a/src/backend/distributed/commands/foreign_server.c +++ b/src/backend/distributed/commands/foreign_server.c @@ -102,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); @@ -247,15 +248,14 @@ NameListHasDistributedServer(List *serverNames) foreach_ptr(serverValue, serverNames) { List *addresses = GetObjectAddressByServerName(strVal(serverValue), false); - if (list_length(addresses) > 1) - { - ereport(ERROR, errmsg( - "citus does not support multiple object addresses in NameListHasDistributedServer")); - } + /* 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 (IsObjectDistributed(address)) + if (IsAnyObjectDistributed(list_make1(address))) { return true; } diff --git a/src/backend/distributed/commands/function.c b/src/backend/distributed/commands/function.c index ccf2ef2f3..048c0a299 100644 --- a/src/backend/distributed/commands/function.c +++ b/src/backend/distributed/commands/function.c @@ -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); @@ -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 " @@ -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); } diff --git a/src/backend/distributed/commands/grant.c b/src/backend/distributed/commands/grant.c index bf7c39b3b..c7861060a 100644 --- a/src/backend/distributed/commands/grant.c +++ b/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); } diff --git a/src/backend/distributed/commands/index.c b/src/backend/distributed/commands/index.c index 2e9d2d58d..ee7098289 100644 --- a/src/backend/distributed/commands/index.c +++ b/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. diff --git a/src/backend/distributed/commands/role.c b/src/backend/distributed/commands/role.c index 6d19d6726..dcec5c2cc 100644 --- a/src/backend/distributed/commands/role.c +++ b/src/backend/distributed/commands/role.c @@ -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; diff --git a/src/backend/distributed/commands/schema.c b/src/backend/distributed/commands/schema.c index 825a56b09..571064130 100644 --- a/src/backend/distributed/commands/schema.c +++ b/src/backend/distributed/commands/schema.c @@ -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; } diff --git a/src/backend/distributed/commands/sequence.c b/src/backend/distributed/commands/sequence.c index 324e373b5..b3ae475aa 100644 --- a/src/backend/distributed/commands/sequence.c +++ b/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; } @@ -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; } @@ -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; } @@ -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; } @@ -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); } diff --git a/src/backend/distributed/commands/statistics.c b/src/backend/distributed/commands/statistics.c index 48ed8df20..b93abcc79 100644 --- a/src/backend/distributed/commands/statistics.c +++ b/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; } @@ -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; } @@ -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; } diff --git a/src/backend/distributed/commands/table.c b/src/backend/distributed/commands/table.c index 05f2a82ab..0b660af70 100644 --- a/src/backend/distributed/commands/table.c +++ b/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 */ diff --git a/src/backend/distributed/commands/trigger.c b/src/backend/distributed/commands/trigger.c index 12d7253e2..9d9d62342 100644 --- a/src/backend/distributed/commands/trigger.c +++ b/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, diff --git a/src/backend/distributed/commands/type.c b/src/backend/distributed/commands/type.c index 9ebe51510..a074fa649 100644 --- a/src/backend/distributed/commands/type.c +++ b/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; } diff --git a/src/backend/distributed/commands/utility_hook.c b/src/backend/distributed/commands/utility_hook.c index aae9c6104..0205a0ab9 100644 --- a/src/backend/distributed/commands/utility_hook.c +++ b/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); + } } } diff --git a/src/backend/distributed/commands/view.c b/src/backend/distributed/commands/view.c index daf255652..f8900a800 100644 --- a/src/backend/distributed/commands/view.c +++ b/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; @@ -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; } @@ -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; @@ -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; } diff --git a/src/backend/distributed/deparser/objectaddress.c b/src/backend/distributed/deparser/objectaddress.c index 123445c23..c6638b4e6 100644 --- a/src/backend/distributed/deparser/objectaddress.c +++ b/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); @@ -33,19 +33,7 @@ GetObjectAddressFromParseTree(Node *parseTree, bool missing_ok) ereport(ERROR, (errmsg("unsupported statement to get object address for"))); } - List *objectAddresses = ops->address(parseTree, missing_ok); - - if (list_length(objectAddresses) > 1) - { - ereport(ERROR, (errmsg( - "citus does not support multiple object addresses in GetObjectAddressFromParseTree"))); - } - - Assert(list_length(objectAddresses) == 1); - - ObjectAddress *objectAddress = linitial(objectAddresses); - - return *objectAddress; + return ops->address(parseTree, missing_ok); } diff --git a/src/backend/distributed/metadata/dependency.c b/src/backend/distributed/metadata/dependency.c index 99bcfc240..d787b17aa 100644 --- a/src/backend/distributed/metadata/dependency.c +++ b/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; } diff --git a/src/backend/distributed/metadata/distobject.c b/src/backend/distributed/metadata/distobject.c index 0581e54b3..55d7c9f33 100644 --- a/src/backend/distributed/metadata/distobject.c +++ b/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 diff --git a/src/backend/distributed/metadata/metadata_sync.c b/src/backend/distributed/metadata/metadata_sync.c index aa6294ca2..38a2308ff 100644 --- a/src/backend/distributed/metadata/metadata_sync.c +++ b/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)); } diff --git a/src/backend/distributed/operations/create_shards.c b/src/backend/distributed/operations/create_shards.c index c43da76aa..b9841dabf 100644 --- a/src/backend/distributed/operations/create_shards.c +++ b/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(); diff --git a/src/backend/distributed/operations/stage_protocol.c b/src/backend/distributed/operations/stage_protocol.c index 8f77205cb..e67691e44 100644 --- a/src/backend/distributed/operations/stage_protocol.c +++ b/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 */ diff --git a/src/backend/distributed/worker/worker_create_or_replace.c b/src/backend/distributed/worker/worker_create_or_replace.c index 2ba4797bf..84a257e04 100644 --- a/src/backend/distributed/worker/worker_create_or_replace.c +++ b/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, diff --git a/src/backend/distributed/worker/worker_drop_protocol.c b/src/backend/distributed/worker/worker_drop_protocol.c index 452de62e3..14166e30b 100644 --- a/src/backend/distributed/worker/worker_drop_protocol.c +++ b/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(); diff --git a/src/include/distributed/deparser.h b/src/include/distributed/deparser.h index f3bdb19b2..23bfbae78 100644 --- a/src/include/distributed/deparser.h +++ b/src/include/distributed/deparser.h @@ -148,7 +148,7 @@ extern void QualifyAlterTypeOwnerStmt(Node *stmt); extern char * GetTypeNamespaceNameByNameList(List *names); extern Oid TypeOidGetNamespaceOid(Oid typeOid); -extern ObjectAddress GetObjectAddressFromParseTree(Node *parseTree, 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 */ diff --git a/src/include/distributed/metadata/dependency.h b/src/include/distributed/metadata/dependency.h index dfe5a7ebc..f04e3a869 100644 --- a/src/include/distributed/metadata/dependency.h +++ b/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, diff --git a/src/include/distributed/metadata/distobject.h b/src/include/distributed/metadata/distobject.h index 2bcb50778..cb905bbfe 100644 --- a/src/include/distributed/metadata/distobject.h +++ b/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); diff --git a/src/include/distributed/metadata_utility.h b/src/include/distributed/metadata_utility.h index e5b0877d7..bad361ae6 100644 --- a/src/include/distributed/metadata_utility.h +++ b/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 */