/*------------------------------------------------------------------------- * * objectaddress.c * functions for working with ObjectAddresses * * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group * Portions Copyright (c) 1994, Regents of the University of California * * * IDENTIFICATION * src/backend/catalog/objectaddress.c * *------------------------------------------------------------------------- */ #include "postgres.h" #include "access/genam.h" #include "access/htup_details.h" #include "access/relation.h" #include "access/table.h" #include "catalog/catalog.h" #include "catalog/objectaddress.h" #include "catalog/pg_am.h" #include "catalog/pg_amop.h" #include "catalog/pg_amproc.h" #include "catalog/pg_attrdef.h" #include "catalog/pg_authid.h" #include "catalog/pg_auth_members.h" #include "catalog/pg_cast.h" #include "catalog/pg_collation.h" #include "catalog/pg_constraint.h" #include "catalog/pg_conversion.h" #include "catalog/pg_database.h" #include "catalog/pg_default_acl.h" #include "catalog/pg_event_trigger.h" #include "catalog/pg_extension.h" #include "catalog/pg_foreign_data_wrapper.h" #include "catalog/pg_foreign_server.h" #include "catalog/pg_language.h" #include "catalog/pg_largeobject.h" #include "catalog/pg_largeobject_metadata.h" #include "catalog/pg_namespace.h" #include "catalog/pg_opclass.h" #include "catalog/pg_operator.h" #include "catalog/pg_opfamily.h" #include "catalog/pg_parameter_acl.h" #include "catalog/pg_policy.h" #include "catalog/pg_proc.h" #include "catalog/pg_publication.h" #include "catalog/pg_publication_namespace.h" #include "catalog/pg_publication_rel.h" #include "catalog/pg_rewrite.h" #include "catalog/pg_statistic_ext.h" #include "catalog/pg_subscription.h" #include "catalog/pg_tablespace.h" #include "catalog/pg_transform.h" #include "catalog/pg_trigger.h" #include "catalog/pg_ts_config.h" #include "catalog/pg_ts_dict.h" #include "catalog/pg_ts_parser.h" #include "catalog/pg_ts_template.h" #include "catalog/pg_type.h" #include "catalog/pg_user_mapping.h" #include "commands/dbcommands.h" #include "commands/defrem.h" #include "commands/event_trigger.h" #include "commands/extension.h" #include "commands/policy.h" #include "commands/proclang.h" #include "commands/tablespace.h" #include "commands/trigger.h" #include "foreign/foreign.h" #include "funcapi.h" #include "miscadmin.h" #include "parser/parse_func.h" #include "parser/parse_oper.h" #include "parser/parse_type.h" #include "rewrite/rewriteSupport.h" #include "storage/large_object.h" #include "storage/lmgr.h" #include "storage/sinval.h" #include "utils/acl.h" #include "utils/builtins.h" #include "utils/fmgroids.h" #include "utils/lsyscache.h" #include "utils/memutils.h" #include "utils/regproc.h" #include "utils/syscache.h" /* * ObjectProperty * * This array provides a common part of system object structure; to help * consolidate routines to handle various kind of object classes. */ typedef struct { const char *class_descr; /* string describing the catalog, for internal * error messages */ Oid class_oid; /* oid of catalog */ Oid oid_index_oid; /* oid of index on system oid column */ int oid_catcache_id; /* id of catcache on system oid column */ int name_catcache_id; /* id of catcache on (name,namespace), or * (name) if the object does not live in a * namespace */ AttrNumber attnum_oid; /* attribute number of oid column */ AttrNumber attnum_name; /* attnum of name field */ AttrNumber attnum_namespace; /* attnum of namespace field */ AttrNumber attnum_owner; /* attnum of owner field */ AttrNumber attnum_acl; /* attnum of acl field */ ObjectType objtype; /* OBJECT_* of this object type */ bool is_nsp_name_unique; /* can the nsp/name combination (or name * alone, if there's no namespace) be * considered a unique identifier for an * object of this class? */ } ObjectPropertyType; static const ObjectPropertyType ObjectProperty[] = { { "access method", AccessMethodRelationId, AmOidIndexId, AMOID, AMNAME, Anum_pg_am_oid, Anum_pg_am_amname, InvalidAttrNumber, InvalidAttrNumber, InvalidAttrNumber, OBJECT_ACCESS_METHOD, true }, { "access method operator", AccessMethodOperatorRelationId, AccessMethodOperatorOidIndexId, -1, -1, Anum_pg_amop_oid, InvalidAttrNumber, InvalidAttrNumber, InvalidAttrNumber, InvalidAttrNumber, OBJECT_AMOP, false }, { "access method procedure", AccessMethodProcedureRelationId, AccessMethodProcedureOidIndexId, -1, -1, Anum_pg_amproc_oid, InvalidAttrNumber, InvalidAttrNumber, InvalidAttrNumber, InvalidAttrNumber, OBJECT_AMPROC, false }, { "cast", CastRelationId, CastOidIndexId, -1, -1, Anum_pg_cast_oid, InvalidAttrNumber, InvalidAttrNumber, InvalidAttrNumber, InvalidAttrNumber, OBJECT_CAST, false }, { "collation", CollationRelationId, CollationOidIndexId, COLLOID, -1, /* COLLNAMEENCNSP also takes encoding */ Anum_pg_collation_oid, Anum_pg_collation_collname, Anum_pg_collation_collnamespace, Anum_pg_collation_collowner, InvalidAttrNumber, OBJECT_COLLATION, true }, { "constraint", ConstraintRelationId, ConstraintOidIndexId, CONSTROID, -1, Anum_pg_constraint_oid, Anum_pg_constraint_conname, Anum_pg_constraint_connamespace, InvalidAttrNumber, InvalidAttrNumber, -1, false }, { "conversion", ConversionRelationId, ConversionOidIndexId, CONVOID, CONNAMENSP, Anum_pg_conversion_oid, Anum_pg_conversion_conname, Anum_pg_conversion_connamespace, Anum_pg_conversion_conowner, InvalidAttrNumber, OBJECT_CONVERSION, true }, { "database", DatabaseRelationId, DatabaseOidIndexId, DATABASEOID, -1, Anum_pg_database_oid, Anum_pg_database_datname, InvalidAttrNumber, Anum_pg_database_datdba, Anum_pg_database_datacl, OBJECT_DATABASE, true }, { "default ACL", DefaultAclRelationId, DefaultAclOidIndexId, -1, -1, Anum_pg_default_acl_oid, InvalidAttrNumber, InvalidAttrNumber, InvalidAttrNumber, InvalidAttrNumber, OBJECT_DEFACL, false }, { "extension", ExtensionRelationId, ExtensionOidIndexId, -1, -1, Anum_pg_extension_oid, Anum_pg_extension_extname, InvalidAttrNumber, /* extension doesn't belong to extnamespace */ Anum_pg_extension_extowner, InvalidAttrNumber, OBJECT_EXTENSION, true }, { "foreign-data wrapper", ForeignDataWrapperRelationId, ForeignDataWrapperOidIndexId, FOREIGNDATAWRAPPEROID, FOREIGNDATAWRAPPERNAME, Anum_pg_foreign_data_wrapper_oid, Anum_pg_foreign_data_wrapper_fdwname, InvalidAttrNumber, Anum_pg_foreign_data_wrapper_fdwowner, Anum_pg_foreign_data_wrapper_fdwacl, OBJECT_FDW, true }, { "foreign server", ForeignServerRelationId, ForeignServerOidIndexId, FOREIGNSERVEROID, FOREIGNSERVERNAME, Anum_pg_foreign_server_oid, Anum_pg_foreign_server_srvname, InvalidAttrNumber, Anum_pg_foreign_server_srvowner, Anum_pg_foreign_server_srvacl, OBJECT_FOREIGN_SERVER, true }, { "function", ProcedureRelationId, ProcedureOidIndexId, PROCOID, -1, /* PROCNAMEARGSNSP also takes argument types */ Anum_pg_proc_oid, Anum_pg_proc_proname, Anum_pg_proc_pronamespace, Anum_pg_proc_proowner, Anum_pg_proc_proacl, OBJECT_FUNCTION, false }, { "language", LanguageRelationId, LanguageOidIndexId, LANGOID, LANGNAME, Anum_pg_language_oid, Anum_pg_language_lanname, InvalidAttrNumber, Anum_pg_language_lanowner, Anum_pg_language_lanacl, OBJECT_LANGUAGE, true }, { "large object metadata", LargeObjectMetadataRelationId, LargeObjectMetadataOidIndexId, -1, -1, Anum_pg_largeobject_metadata_oid, InvalidAttrNumber, InvalidAttrNumber, Anum_pg_largeobject_metadata_lomowner, Anum_pg_largeobject_metadata_lomacl, OBJECT_LARGEOBJECT, false }, { "operator class", OperatorClassRelationId, OpclassOidIndexId, CLAOID, -1, /* CLAAMNAMENSP also takes opcmethod */ Anum_pg_opclass_oid, Anum_pg_opclass_opcname, Anum_pg_opclass_opcnamespace, Anum_pg_opclass_opcowner, InvalidAttrNumber, OBJECT_OPCLASS, true }, { "operator", OperatorRelationId, OperatorOidIndexId, OPEROID, -1, /* OPERNAMENSP also takes left and right type */ Anum_pg_operator_oid, Anum_pg_operator_oprname, Anum_pg_operator_oprnamespace, Anum_pg_operator_oprowner, InvalidAttrNumber, OBJECT_OPERATOR, false }, { "operator family", OperatorFamilyRelationId, OpfamilyOidIndexId, OPFAMILYOID, -1, /* OPFAMILYAMNAMENSP also takes opfmethod */ Anum_pg_opfamily_oid, Anum_pg_opfamily_opfname, Anum_pg_opfamily_opfnamespace, Anum_pg_opfamily_opfowner, InvalidAttrNumber, OBJECT_OPFAMILY, true }, { "role", AuthIdRelationId, AuthIdOidIndexId, AUTHOID, AUTHNAME, Anum_pg_authid_oid, Anum_pg_authid_rolname, InvalidAttrNumber, InvalidAttrNumber, InvalidAttrNumber, OBJECT_ROLE, true }, { "role membership", AuthMemRelationId, AuthMemOidIndexId, -1, -1, Anum_pg_auth_members_oid, InvalidAttrNumber, InvalidAttrNumber, Anum_pg_auth_members_grantor, InvalidAttrNumber, -1, true }, { "rule", RewriteRelationId, RewriteOidIndexId, -1, -1, Anum_pg_rewrite_oid, Anum_pg_rewrite_rulename, InvalidAttrNumber, InvalidAttrNumber, InvalidAttrNumber, OBJECT_RULE, false }, { "schema", NamespaceRelationId, NamespaceOidIndexId, NAMESPACEOID, NAMESPACENAME, Anum_pg_namespace_oid, Anum_pg_namespace_nspname, InvalidAttrNumber, Anum_pg_namespace_nspowner, Anum_pg_namespace_nspacl, OBJECT_SCHEMA, true }, { "relation", RelationRelationId, ClassOidIndexId, RELOID, RELNAMENSP, Anum_pg_class_oid, Anum_pg_class_relname, Anum_pg_class_relnamespace, Anum_pg_class_relowner, Anum_pg_class_relacl, OBJECT_TABLE, true }, { "tablespace", TableSpaceRelationId, TablespaceOidIndexId, TABLESPACEOID, -1, Anum_pg_tablespace_oid, Anum_pg_tablespace_spcname, InvalidAttrNumber, Anum_pg_tablespace_spcowner, Anum_pg_tablespace_spcacl, OBJECT_TABLESPACE, true }, { "transform", TransformRelationId, TransformOidIndexId, TRFOID, -1, Anum_pg_transform_oid, InvalidAttrNumber, InvalidAttrNumber, InvalidAttrNumber, InvalidAttrNumber, OBJECT_TRANSFORM, false }, { "trigger", TriggerRelationId, TriggerOidIndexId, -1, -1, Anum_pg_trigger_oid, Anum_pg_trigger_tgname, InvalidAttrNumber, InvalidAttrNumber, InvalidAttrNumber, OBJECT_TRIGGER, false }, { "policy", PolicyRelationId, PolicyOidIndexId, -1, -1, Anum_pg_policy_oid, Anum_pg_policy_polname, InvalidAttrNumber, InvalidAttrNumber, InvalidAttrNumber, OBJECT_POLICY, false }, { "event trigger", EventTriggerRelationId, EventTriggerOidIndexId, EVENTTRIGGEROID, EVENTTRIGGERNAME, Anum_pg_event_trigger_oid, Anum_pg_event_trigger_evtname, InvalidAttrNumber, Anum_pg_event_trigger_evtowner, InvalidAttrNumber, OBJECT_EVENT_TRIGGER, true }, { "text search configuration", TSConfigRelationId, TSConfigOidIndexId, TSCONFIGOID, TSCONFIGNAMENSP, Anum_pg_ts_config_oid, Anum_pg_ts_config_cfgname, Anum_pg_ts_config_cfgnamespace, Anum_pg_ts_config_cfgowner, InvalidAttrNumber, OBJECT_TSCONFIGURATION, true }, { "text search dictionary", TSDictionaryRelationId, TSDictionaryOidIndexId, TSDICTOID, TSDICTNAMENSP, Anum_pg_ts_dict_oid, Anum_pg_ts_dict_dictname, Anum_pg_ts_dict_dictnamespace, Anum_pg_ts_dict_dictowner, InvalidAttrNumber, OBJECT_TSDICTIONARY, true }, { "text search parser", TSParserRelationId, TSParserOidIndexId, TSPARSEROID, TSPARSERNAMENSP, Anum_pg_ts_parser_oid, Anum_pg_ts_parser_prsname, Anum_pg_ts_parser_prsnamespace, InvalidAttrNumber, InvalidAttrNumber, OBJECT_TSPARSER, true }, { "text search template", TSTemplateRelationId, TSTemplateOidIndexId, TSTEMPLATEOID, TSTEMPLATENAMENSP, Anum_pg_ts_template_oid, Anum_pg_ts_template_tmplname, Anum_pg_ts_template_tmplnamespace, InvalidAttrNumber, InvalidAttrNumber, OBJECT_TSTEMPLATE, true, }, { "type", TypeRelationId, TypeOidIndexId, TYPEOID, TYPENAMENSP, Anum_pg_type_oid, Anum_pg_type_typname, Anum_pg_type_typnamespace, Anum_pg_type_typowner, Anum_pg_type_typacl, OBJECT_TYPE, true }, { "publication", PublicationRelationId, PublicationObjectIndexId, PUBLICATIONOID, PUBLICATIONNAME, Anum_pg_publication_oid, Anum_pg_publication_pubname, InvalidAttrNumber, Anum_pg_publication_pubowner, InvalidAttrNumber, OBJECT_PUBLICATION, true }, { "subscription", SubscriptionRelationId, SubscriptionObjectIndexId, SUBSCRIPTIONOID, SUBSCRIPTIONNAME, Anum_pg_subscription_oid, Anum_pg_subscription_subname, InvalidAttrNumber, Anum_pg_subscription_subowner, InvalidAttrNumber, OBJECT_SUBSCRIPTION, true }, { "extended statistics", StatisticExtRelationId, StatisticExtOidIndexId, STATEXTOID, STATEXTNAMENSP, Anum_pg_statistic_ext_oid, Anum_pg_statistic_ext_stxname, Anum_pg_statistic_ext_stxnamespace, Anum_pg_statistic_ext_stxowner, InvalidAttrNumber, /* no ACL (same as relation) */ OBJECT_STATISTIC_EXT, true }, { "user mapping", UserMappingRelationId, UserMappingOidIndexId, USERMAPPINGOID, -1, Anum_pg_user_mapping_oid, InvalidAttrNumber, InvalidAttrNumber, InvalidAttrNumber, InvalidAttrNumber, OBJECT_USER_MAPPING, false }, }; /* * This struct maps the string object types as returned by * getObjectTypeDescription into ObjectType enum values. Note that some enum * values can be obtained by different names, and that some string object types * do not have corresponding values in the output enum. The user of this map * must be careful to test for invalid values being returned. * * To ease maintenance, this follows the order of getObjectTypeDescription. */ static const struct object_type_map { const char *tm_name; ObjectType tm_type; } ObjectTypeMap[] = { { "table", OBJECT_TABLE }, { "index", OBJECT_INDEX }, { "sequence", OBJECT_SEQUENCE }, { "toast table", -1 }, /* unmapped */ { "view", OBJECT_VIEW }, { "materialized view", OBJECT_MATVIEW }, { "composite type", -1 }, /* unmapped */ { "foreign table", OBJECT_FOREIGN_TABLE }, { "table column", OBJECT_COLUMN }, { "index column", -1 }, /* unmapped */ { "sequence column", -1 }, /* unmapped */ { "toast table column", -1 }, /* unmapped */ { "view column", -1 }, /* unmapped */ { "materialized view column", -1 }, /* unmapped */ { "composite type column", -1 }, /* unmapped */ { "foreign table column", OBJECT_COLUMN }, { "aggregate", OBJECT_AGGREGATE }, { "function", OBJECT_FUNCTION }, { "procedure", OBJECT_PROCEDURE }, { "type", OBJECT_TYPE }, { "cast", OBJECT_CAST }, { "collation", OBJECT_COLLATION }, { "table constraint", OBJECT_TABCONSTRAINT }, { "domain constraint", OBJECT_DOMCONSTRAINT }, { "conversion", OBJECT_CONVERSION }, { "default value", OBJECT_DEFAULT }, { "language", OBJECT_LANGUAGE }, { "large object", OBJECT_LARGEOBJECT }, { "operator", OBJECT_OPERATOR }, { "operator class", OBJECT_OPCLASS }, { "operator family", OBJECT_OPFAMILY }, { "access method", OBJECT_ACCESS_METHOD }, { "operator of access method", OBJECT_AMOP }, { "function of access method", OBJECT_AMPROC }, { "rule", OBJECT_RULE }, { "trigger", OBJECT_TRIGGER }, { "schema", OBJECT_SCHEMA }, { "text search parser", OBJECT_TSPARSER }, { "text search dictionary", OBJECT_TSDICTIONARY }, { "text search template", OBJECT_TSTEMPLATE }, { "text search configuration", OBJECT_TSCONFIGURATION }, { "role", OBJECT_ROLE }, { "role membership", -1 /* unmapped */ }, { "database", OBJECT_DATABASE }, { "tablespace", OBJECT_TABLESPACE }, { "foreign-data wrapper", OBJECT_FDW }, { "server", OBJECT_FOREIGN_SERVER }, { "user mapping", OBJECT_USER_MAPPING }, { "default acl", OBJECT_DEFACL }, { "extension", OBJECT_EXTENSION }, { "event trigger", OBJECT_EVENT_TRIGGER }, { "parameter ACL", OBJECT_PARAMETER_ACL }, { "policy", OBJECT_POLICY }, { "publication", OBJECT_PUBLICATION }, { "publication namespace", OBJECT_PUBLICATION_NAMESPACE }, { "publication relation", OBJECT_PUBLICATION_REL }, { "subscription", OBJECT_SUBSCRIPTION }, { "transform", OBJECT_TRANSFORM }, { "statistics object", OBJECT_STATISTIC_EXT } }; const ObjectAddress InvalidObjectAddress = { InvalidOid, InvalidOid, 0 }; static ObjectAddress get_object_address_unqualified(ObjectType objtype, String *strval, bool missing_ok); static ObjectAddress get_relation_by_qualified_name(ObjectType objtype, List *object, Relation *relp, LOCKMODE lockmode, bool missing_ok); static ObjectAddress get_object_address_relobject(ObjectType objtype, List *object, Relation *relp, bool missing_ok); static ObjectAddress get_object_address_attribute(ObjectType objtype, List *object, Relation *relp, LOCKMODE lockmode, bool missing_ok); static ObjectAddress get_object_address_attrdef(ObjectType objtype, List *object, Relation *relp, LOCKMODE lockmode, bool missing_ok); static ObjectAddress get_object_address_type(ObjectType objtype, TypeName *typename, bool missing_ok); static ObjectAddress get_object_address_opcf(ObjectType objtype, List *object, bool missing_ok); static ObjectAddress get_object_address_opf_member(ObjectType objtype, List *object, bool missing_ok); static ObjectAddress get_object_address_usermapping(List *object, bool missing_ok); static ObjectAddress get_object_address_publication_rel(List *object, Relation *relp, bool missing_ok); static ObjectAddress get_object_address_publication_schema(List *object, bool missing_ok); static ObjectAddress get_object_address_defacl(List *object, bool missing_ok); static const ObjectPropertyType *get_object_property_data(Oid class_id); static void getRelationDescription(StringInfo buffer, Oid relid, bool missing_ok); static void getOpFamilyDescription(StringInfo buffer, Oid opfid, bool missing_ok); static void getRelationTypeDescription(StringInfo buffer, Oid relid, int32 objectSubId, bool missing_ok); static void getProcedureTypeDescription(StringInfo buffer, Oid procid, bool missing_ok); static void getConstraintTypeDescription(StringInfo buffer, Oid constroid, bool missing_ok); static void getOpFamilyIdentity(StringInfo buffer, Oid opfid, List **object, bool missing_ok); static void getRelationIdentity(StringInfo buffer, Oid relid, List **object, bool missing_ok); /* * Translate an object name and arguments (as passed by the parser) to an * ObjectAddress. * * The returned object will be locked using the specified lockmode. If a * sub-object is looked up, the parent object will be locked instead. * * If the object is a relation or a child object of a relation (e.g. an * attribute or constraint), the relation is also opened and *relp receives * the open relcache entry pointer; otherwise, *relp is set to NULL. * (relp can be NULL if the caller never passes a relation-related object.) This * is a bit grotty but it makes life simpler, since the caller will * typically need the relcache entry too. Caller must close the relcache * entry when done with it. The relation is locked with the specified lockmode * if the target object is the relation itself or an attribute, but for other * child objects, only AccessShareLock is acquired on the relation. * * If the object is not found, an error is thrown, unless missing_ok is * true. In this case, no lock is acquired, relp is set to NULL, and the * returned address has objectId set to InvalidOid. * * We don't currently provide a function to release the locks acquired here; * typically, the lock must be held until commit to guard against a concurrent * drop operation. * * Note: If the object is not found, we don't give any indication of the * reason. (It might have been a missing schema if the name was qualified, or * a nonexistent type name in case of a cast, function or operator; etc). * Currently there is only one caller that might be interested in such info, so * we don't spend much effort here. If more callers start to care, it might be * better to add some support for that in this function. */ ObjectAddress get_object_address(ObjectType objtype, Node *object, Relation *relp, LOCKMODE lockmode, bool missing_ok) { ObjectAddress address = {InvalidOid, InvalidOid, 0}; ObjectAddress old_address = {InvalidOid, InvalidOid, 0}; Relation relation = NULL; uint64 inval_count; /* Some kind of lock must be taken. */ Assert(lockmode != NoLock); for (;;) { /* * Remember this value, so that, after looking up the object name and * locking it, we can check whether any invalidation messages have * been processed that might require a do-over. */ inval_count = SharedInvalidMessageCounter; /* Look up object address. */ switch (objtype) { case OBJECT_INDEX: case OBJECT_SEQUENCE: case OBJECT_TABLE: case OBJECT_VIEW: case OBJECT_MATVIEW: case OBJECT_FOREIGN_TABLE: address = get_relation_by_qualified_name(objtype, castNode(List, object), &relation, lockmode, missing_ok); break; case OBJECT_ATTRIBUTE: case OBJECT_COLUMN: address = get_object_address_attribute(objtype, castNode(List, object), &relation, lockmode, missing_ok); break; case OBJECT_DEFAULT: address = get_object_address_attrdef(objtype, castNode(List, object), &relation, lockmode, missing_ok); break; case OBJECT_RULE: case OBJECT_TRIGGER: case OBJECT_TABCONSTRAINT: case OBJECT_POLICY: address = get_object_address_relobject(objtype, castNode(List, object), &relation, missing_ok); break; case OBJECT_DOMCONSTRAINT: { List *objlist; ObjectAddress domaddr; char *constrname; objlist = castNode(List, object); domaddr = get_object_address_type(OBJECT_DOMAIN, linitial_node(TypeName, objlist), missing_ok); constrname = strVal(lsecond(objlist)); address.classId = ConstraintRelationId; address.objectId = get_domain_constraint_oid(domaddr.objectId, constrname, missing_ok); address.objectSubId = 0; } break; case OBJECT_DATABASE: case OBJECT_EXTENSION: case OBJECT_TABLESPACE: case OBJECT_ROLE: case OBJECT_SCHEMA: case OBJECT_LANGUAGE: case OBJECT_FDW: case OBJECT_FOREIGN_SERVER: case OBJECT_EVENT_TRIGGER: case OBJECT_PARAMETER_ACL: case OBJECT_ACCESS_METHOD: case OBJECT_PUBLICATION: case OBJECT_SUBSCRIPTION: address = get_object_address_unqualified(objtype, castNode(String, object), missing_ok); break; case OBJECT_TYPE: case OBJECT_DOMAIN: address = get_object_address_type(objtype, castNode(TypeName, object), missing_ok); break; case OBJECT_AGGREGATE: case OBJECT_FUNCTION: case OBJECT_PROCEDURE: case OBJECT_ROUTINE: address.classId = ProcedureRelationId; address.objectId = LookupFuncWithArgs(objtype, castNode(ObjectWithArgs, object), missing_ok); address.objectSubId = 0; break; case OBJECT_OPERATOR: address.classId = OperatorRelationId; address.objectId = LookupOperWithArgs(castNode(ObjectWithArgs, object), missing_ok); address.objectSubId = 0; break; case OBJECT_COLLATION: address.classId = CollationRelationId; address.objectId = get_collation_oid(castNode(List, object), missing_ok); address.objectSubId = 0; break; case OBJECT_CONVERSION: address.classId = ConversionRelationId; address.objectId = get_conversion_oid(castNode(List, object), missing_ok); address.objectSubId = 0; break; case OBJECT_OPCLASS: case OBJECT_OPFAMILY: address = get_object_address_opcf(objtype, castNode(List, object), missing_ok); break; case OBJECT_AMOP: case OBJECT_AMPROC: address = get_object_address_opf_member(objtype, castNode(List, object), missing_ok); break; case OBJECT_LARGEOBJECT: address.classId = LargeObjectRelationId; address.objectId = oidparse(object); address.objectSubId = 0; if (!LargeObjectExists(address.objectId)) { if (!missing_ok) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_OBJECT), errmsg("large object %u does not exist", address.objectId))); } break; case OBJECT_CAST: { TypeName *sourcetype = linitial_node(TypeName, castNode(List, object)); TypeName *targettype = lsecond_node(TypeName, castNode(List, object)); Oid sourcetypeid; Oid targettypeid; sourcetypeid = LookupTypeNameOid(NULL, sourcetype, missing_ok); targettypeid = LookupTypeNameOid(NULL, targettype, missing_ok); address.classId = CastRelationId; address.objectId = get_cast_oid(sourcetypeid, targettypeid, missing_ok); address.objectSubId = 0; } break; case OBJECT_TRANSFORM: { TypeName *typename = linitial_node(TypeName, castNode(List, object)); char *langname = strVal(lsecond(castNode(List, object))); Oid type_id = LookupTypeNameOid(NULL, typename, missing_ok); Oid lang_id = get_language_oid(langname, missing_ok); address.classId = TransformRelationId; address.objectId = get_transform_oid(type_id, lang_id, missing_ok); address.objectSubId = 0; } break; case OBJECT_TSPARSER: address.classId = TSParserRelationId; address.objectId = get_ts_parser_oid(castNode(List, object), missing_ok); address.objectSubId = 0; break; case OBJECT_TSDICTIONARY: address.classId = TSDictionaryRelationId; address.objectId = get_ts_dict_oid(castNode(List, object), missing_ok); address.objectSubId = 0; break; case OBJECT_TSTEMPLATE: address.classId = TSTemplateRelationId; address.objectId = get_ts_template_oid(castNode(List, object), missing_ok); address.objectSubId = 0; break; case OBJECT_TSCONFIGURATION: address.classId = TSConfigRelationId; address.objectId = get_ts_config_oid(castNode(List, object), missing_ok); address.objectSubId = 0; break; case OBJECT_USER_MAPPING: address = get_object_address_usermapping(castNode(List, object), missing_ok); break; case OBJECT_PUBLICATION_NAMESPACE: address = get_object_address_publication_schema(castNode(List, object), missing_ok); break; case OBJECT_PUBLICATION_REL: address = get_object_address_publication_rel(castNode(List, object), &relation, missing_ok); break; case OBJECT_DEFACL: address = get_object_address_defacl(castNode(List, object), missing_ok); break; case OBJECT_STATISTIC_EXT: address.classId = StatisticExtRelationId; address.objectId = get_statistics_object_oid(castNode(List, object), missing_ok); address.objectSubId = 0; break; /* no default, to let compiler warn about missing case */ } if (!address.classId) elog(ERROR, "unrecognized object type: %d", (int) objtype); /* * If we could not find the supplied object, return without locking. */ if (!OidIsValid(address.objectId)) { Assert(missing_ok); return address; } /* * If we're retrying, see if we got the same answer as last time. If * so, we're done; if not, we locked the wrong thing, so give up our * lock. */ if (OidIsValid(old_address.classId)) { if (old_address.classId == address.classId && old_address.objectId == address.objectId && old_address.objectSubId == address.objectSubId) break; if (old_address.classId != RelationRelationId) { if (IsSharedRelation(old_address.classId)) UnlockSharedObject(old_address.classId, old_address.objectId, 0, lockmode); else UnlockDatabaseObject(old_address.classId, old_address.objectId, 0, lockmode); } } /* * If we're dealing with a relation or attribute, then the relation is * already locked. Otherwise, we lock it now. */ if (address.classId != RelationRelationId) { if (IsSharedRelation(address.classId)) LockSharedObject(address.classId, address.objectId, 0, lockmode); else LockDatabaseObject(address.classId, address.objectId, 0, lockmode); } /* * At this point, we've resolved the name to an OID and locked the * corresponding database object. However, it's possible that by the * time we acquire the lock on the object, concurrent DDL has modified * the database in such a way that the name we originally looked up no * longer resolves to that OID. * * We can be certain that this isn't an issue if (a) no shared * invalidation messages have been processed or (b) we've locked a * relation somewhere along the line. All the relation name lookups * in this module ultimately use RangeVarGetRelid() to acquire a * relation lock, and that function protects against the same kinds of * races we're worried about here. Even when operating on a * constraint, rule, or trigger, we still acquire AccessShareLock on * the relation, which is enough to freeze out any concurrent DDL. * * In all other cases, however, it's possible that the name we looked * up no longer refers to the object we locked, so we retry the lookup * and see whether we get the same answer. */ if (inval_count == SharedInvalidMessageCounter || relation != NULL) break; old_address = address; } /* relp must be given if it's a relation */ Assert(!relation || relp); /* Return the object address and the relation. */ if (relp) *relp = relation; return address; } /* * Return an ObjectAddress based on a RangeVar and an object name. The * name of the relation identified by the RangeVar is prepended to the * (possibly empty) list passed in as object. This is useful to find * the ObjectAddress of objects that depend on a relation. All other * considerations are exactly as for get_object_address above. */ ObjectAddress get_object_address_rv(ObjectType objtype, RangeVar *rel, List *object, Relation *relp, LOCKMODE lockmode, bool missing_ok) { if (rel) { object = lcons(makeString(rel->relname), object); if (rel->schemaname) object = lcons(makeString(rel->schemaname), object); if (rel->catalogname) object = lcons(makeString(rel->catalogname), object); } return get_object_address(objtype, (Node *) object, relp, lockmode, missing_ok); } /* * Find an ObjectAddress for a type of object that is identified by an * unqualified name. */ static ObjectAddress get_object_address_unqualified(ObjectType objtype, String *strval, bool missing_ok) { const char *name; ObjectAddress address; name = strVal(strval); /* Translate name to OID. */ switch (objtype) { case OBJECT_ACCESS_METHOD: address.classId = AccessMethodRelationId; address.objectId = get_am_oid(name, missing_ok); address.objectSubId = 0; break; case OBJECT_DATABASE: address.classId = DatabaseRelationId; address.objectId = get_database_oid(name, missing_ok); address.objectSubId = 0; break; case OBJECT_EXTENSION: address.classId = ExtensionRelationId; address.objectId = get_extension_oid(name, missing_ok); address.objectSubId = 0; break; case OBJECT_TABLESPACE: address.classId = TableSpaceRelationId; address.objectId = get_tablespace_oid(name, missing_ok); address.objectSubId = 0; break; case OBJECT_ROLE: address.classId = AuthIdRelationId; address.objectId = get_role_oid(name, missing_ok); address.objectSubId = 0; break; case OBJECT_SCHEMA: address.classId = NamespaceRelationId; address.objectId = get_namespace_oid(name, missing_ok); address.objectSubId = 0; break; case OBJECT_LANGUAGE: address.classId = LanguageRelationId; address.objectId = get_language_oid(name, missing_ok); address.objectSubId = 0; break; case OBJECT_FDW: address.classId = ForeignDataWrapperRelationId; address.objectId = get_foreign_data_wrapper_oid(name, missing_ok); address.objectSubId = 0; break; case OBJECT_FOREIGN_SERVER: address.classId = ForeignServerRelationId; address.objectId = get_foreign_server_oid(name, missing_ok); address.objectSubId = 0; break; case OBJECT_EVENT_TRIGGER: address.classId = EventTriggerRelationId; address.objectId = get_event_trigger_oid(name, missing_ok); address.objectSubId = 0; break; case OBJECT_PARAMETER_ACL: address.classId = ParameterAclRelationId; address.objectId = ParameterAclLookup(name, missing_ok); address.objectSubId = 0; break; case OBJECT_PUBLICATION: address.classId = PublicationRelationId; address.objectId = get_publication_oid(name, missing_ok); address.objectSubId = 0; break; case OBJECT_SUBSCRIPTION: address.classId = SubscriptionRelationId; address.objectId = get_subscription_oid(name, missing_ok); address.objectSubId = 0; break; default: elog(ERROR, "unrecognized object type: %d", (int) objtype); /* placate compiler, which doesn't know elog won't return */ address.classId = InvalidOid; address.objectId = InvalidOid; address.objectSubId = 0; } return address; } /* * Locate a relation by qualified name. */ static ObjectAddress get_relation_by_qualified_name(ObjectType objtype, List *object, Relation *relp, LOCKMODE lockmode, bool missing_ok) { Relation relation; ObjectAddress address; address.classId = RelationRelationId; address.objectId = InvalidOid; address.objectSubId = 0; relation = relation_openrv_extended(makeRangeVarFromNameList(object), lockmode, missing_ok); if (!relation) return address; switch (objtype) { case OBJECT_INDEX: if (relation->rd_rel->relkind != RELKIND_INDEX && relation->rd_rel->relkind != RELKIND_PARTITIONED_INDEX) ereport(ERROR, (errcode(ERRCODE_WRONG_OBJECT_TYPE), errmsg("\"%s\" is not an index", RelationGetRelationName(relation)))); break; case OBJECT_SEQUENCE: if (relation->rd_rel->relkind != RELKIND_SEQUENCE) ereport(ERROR, (errcode(ERRCODE_WRONG_OBJECT_TYPE), errmsg("\"%s\" is not a sequence", RelationGetRelationName(relation)))); break; case OBJECT_TABLE: if (relation->rd_rel->relkind != RELKIND_RELATION && relation->rd_rel->relkind != RELKIND_PARTITIONED_TABLE) ereport(ERROR, (errcode(ERRCODE_WRONG_OBJECT_TYPE), errmsg("\"%s\" is not a table", RelationGetRelationName(relation)))); break; case OBJECT_VIEW: if (relation->rd_rel->relkind != RELKIND_VIEW) ereport(ERROR, (errcode(ERRCODE_WRONG_OBJECT_TYPE), errmsg("\"%s\" is not a view", RelationGetRelationName(relation)))); break; case OBJECT_MATVIEW: if (relation->rd_rel->relkind != RELKIND_MATVIEW) ereport(ERROR, (errcode(ERRCODE_WRONG_OBJECT_TYPE), errmsg("\"%s\" is not a materialized view", RelationGetRelationName(relation)))); break; case OBJECT_FOREIGN_TABLE: if (relation->rd_rel->relkind != RELKIND_FOREIGN_TABLE) ereport(ERROR, (errcode(ERRCODE_WRONG_OBJECT_TYPE), errmsg("\"%s\" is not a foreign table", RelationGetRelationName(relation)))); break; default: elog(ERROR, "unrecognized object type: %d", (int) objtype); break; } /* Done. */ address.objectId = RelationGetRelid(relation); *relp = relation; return address; } /* * Find object address for an object that is attached to a relation. * * Note that we take only an AccessShareLock on the relation. We need not * pass down the LOCKMODE from get_object_address(), because that is the lock * mode for the object itself, not the relation to which it is attached. */ static ObjectAddress get_object_address_relobject(ObjectType objtype, List *object, Relation *relp, bool missing_ok) { ObjectAddress address; Relation relation = NULL; int nnames; const char *depname; List *relname; Oid reloid; /* Extract name of dependent object. */ depname = strVal(llast(object)); /* Separate relation name from dependent object name. */ nnames = list_length(object); if (nnames < 2) ereport(ERROR, (errcode(ERRCODE_SYNTAX_ERROR), errmsg("must specify relation and object name"))); /* Extract relation name and open relation. */ relname = list_copy_head(object, nnames - 1); relation = table_openrv_extended(makeRangeVarFromNameList(relname), AccessShareLock, missing_ok); reloid = relation ? RelationGetRelid(relation) : InvalidOid; switch (objtype) { case OBJECT_RULE: address.classId = RewriteRelationId; address.objectId = relation ? get_rewrite_oid(reloid, depname, missing_ok) : InvalidOid; address.objectSubId = 0; break; case OBJECT_TRIGGER: address.classId = TriggerRelationId; address.objectId = relation ? get_trigger_oid(reloid, depname, missing_ok) : InvalidOid; address.objectSubId = 0; break; case OBJECT_TABCONSTRAINT: address.classId = ConstraintRelationId; address.objectId = relation ? get_relation_constraint_oid(reloid, depname, missing_ok) : InvalidOid; address.objectSubId = 0; break; case OBJECT_POLICY: address.classId = PolicyRelationId; address.objectId = relation ? get_relation_policy_oid(reloid, depname, missing_ok) : InvalidOid; address.objectSubId = 0; break; default: elog(ERROR, "unrecognized object type: %d", (int) objtype); } /* Avoid relcache leak when object not found. */ if (!OidIsValid(address.objectId)) { if (relation != NULL) table_close(relation, AccessShareLock); relation = NULL; /* department of accident prevention */ return address; } /* Done. */ *relp = relation; return address; } /* * Find the ObjectAddress for an attribute. */ static ObjectAddress get_object_address_attribute(ObjectType objtype, List *object, Relation *relp, LOCKMODE lockmode, bool missing_ok) { ObjectAddress address; List *relname; Oid reloid; Relation relation; const char *attname; AttrNumber attnum; /* Extract relation name and open relation. */ if (list_length(object) < 2) ereport(ERROR, (errcode(ERRCODE_SYNTAX_ERROR), errmsg("column name must be qualified"))); attname = strVal(llast(object)); relname = list_copy_head(object, list_length(object) - 1); /* XXX no missing_ok support here */ relation = relation_openrv(makeRangeVarFromNameList(relname), lockmode); reloid = RelationGetRelid(relation); /* Look up attribute and construct return value. */ attnum = get_attnum(reloid, attname); if (attnum == InvalidAttrNumber) { if (!missing_ok) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_COLUMN), errmsg("column \"%s\" of relation \"%s\" does not exist", attname, NameListToString(relname)))); address.classId = RelationRelationId; address.objectId = InvalidOid; address.objectSubId = InvalidAttrNumber; relation_close(relation, lockmode); return address; } address.classId = RelationRelationId; address.objectId = reloid; address.objectSubId = attnum; *relp = relation; return address; } /* * Find the ObjectAddress for an attribute's default value. */ static ObjectAddress get_object_address_attrdef(ObjectType objtype, List *object, Relation *relp, LOCKMODE lockmode, bool missing_ok) { ObjectAddress address; List *relname; Oid reloid; Relation relation; const char *attname; AttrNumber attnum; TupleDesc tupdesc; Oid defoid; /* Extract relation name and open relation. */ if (list_length(object) < 2) ereport(ERROR, (errcode(ERRCODE_SYNTAX_ERROR), errmsg("column name must be qualified"))); attname = strVal(llast(object)); relname = list_copy_head(object, list_length(object) - 1); /* XXX no missing_ok support here */ relation = relation_openrv(makeRangeVarFromNameList(relname), lockmode); reloid = RelationGetRelid(relation); tupdesc = RelationGetDescr(relation); /* Look up attribute number and fetch the pg_attrdef OID */ attnum = get_attnum(reloid, attname); defoid = InvalidOid; if (attnum != InvalidAttrNumber && tupdesc->constr != NULL) defoid = GetAttrDefaultOid(reloid, attnum); if (!OidIsValid(defoid)) { if (!missing_ok) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_COLUMN), errmsg("default value for column \"%s\" of relation \"%s\" does not exist", attname, NameListToString(relname)))); address.classId = AttrDefaultRelationId; address.objectId = InvalidOid; address.objectSubId = InvalidAttrNumber; relation_close(relation, lockmode); return address; } address.classId = AttrDefaultRelationId; address.objectId = defoid; address.objectSubId = 0; *relp = relation; return address; } /* * Find the ObjectAddress for a type or domain */ static ObjectAddress get_object_address_type(ObjectType objtype, TypeName *typename, bool missing_ok) { ObjectAddress address; Type tup; address.classId = TypeRelationId; address.objectId = InvalidOid; address.objectSubId = 0; tup = LookupTypeName(NULL, typename, NULL, missing_ok); if (!HeapTupleIsValid(tup)) { if (!missing_ok) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_OBJECT), errmsg("type \"%s\" does not exist", TypeNameToString(typename)))); return address; } address.objectId = typeTypeId(tup); if (objtype == OBJECT_DOMAIN) { if (((Form_pg_type) GETSTRUCT(tup))->typtype != TYPTYPE_DOMAIN) ereport(ERROR, (errcode(ERRCODE_WRONG_OBJECT_TYPE), errmsg("\"%s\" is not a domain", TypeNameToString(typename)))); } ReleaseSysCache(tup); return address; } /* * Find the ObjectAddress for an opclass or opfamily. */ static ObjectAddress get_object_address_opcf(ObjectType objtype, List *object, bool missing_ok) { Oid amoid; ObjectAddress address; /* XXX no missing_ok support here */ amoid = get_index_am_oid(strVal(linitial(object)), false); object = list_copy_tail(object, 1); switch (objtype) { case OBJECT_OPCLASS: address.classId = OperatorClassRelationId; address.objectId = get_opclass_oid(amoid, object, missing_ok); address.objectSubId = 0; break; case OBJECT_OPFAMILY: address.classId = OperatorFamilyRelationId; address.objectId = get_opfamily_oid(amoid, object, missing_ok); address.objectSubId = 0; break; default: elog(ERROR, "unrecognized object type: %d", (int) objtype); /* placate compiler, which doesn't know elog won't return */ address.classId = InvalidOid; address.objectId = InvalidOid; address.objectSubId = 0; } return address; } /* * Find the ObjectAddress for an opclass/opfamily member. * * (The returned address corresponds to a pg_amop/pg_amproc object). */ static ObjectAddress get_object_address_opf_member(ObjectType objtype, List *object, bool missing_ok) { ObjectAddress famaddr; ObjectAddress address; ListCell *cell; List *copy; TypeName *typenames[2]; Oid typeoids[2]; int membernum; int i; /* * The last element of the object list contains the strategy or procedure * number. We need to strip that out before getting the opclass/family * address. The rest can be used directly by get_object_address_opcf(). */ membernum = atoi(strVal(llast(linitial(object)))); copy = list_copy_head(linitial(object), list_length(linitial(object)) - 1); /* no missing_ok support here */ famaddr = get_object_address_opcf(OBJECT_OPFAMILY, copy, false); /* find out left/right type names and OIDs */ typenames[0] = typenames[1] = NULL; typeoids[0] = typeoids[1] = InvalidOid; i = 0; foreach(cell, lsecond(object)) { ObjectAddress typaddr; typenames[i] = lfirst_node(TypeName, cell); typaddr = get_object_address_type(OBJECT_TYPE, typenames[i], missing_ok); typeoids[i] = typaddr.objectId; if (++i >= 2) break; } switch (objtype) { case OBJECT_AMOP: { HeapTuple tp; ObjectAddressSet(address, AccessMethodOperatorRelationId, InvalidOid); tp = SearchSysCache4(AMOPSTRATEGY, ObjectIdGetDatum(famaddr.objectId), ObjectIdGetDatum(typeoids[0]), ObjectIdGetDatum(typeoids[1]), Int16GetDatum(membernum)); if (!HeapTupleIsValid(tp)) { if (!missing_ok) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_OBJECT), errmsg("operator %d (%s, %s) of %s does not exist", membernum, TypeNameToString(typenames[0]), TypeNameToString(typenames[1]), getObjectDescription(&famaddr, false)))); } else { address.objectId = ((Form_pg_amop) GETSTRUCT(tp))->oid; ReleaseSysCache(tp); } } break; case OBJECT_AMPROC: { HeapTuple tp; ObjectAddressSet(address, AccessMethodProcedureRelationId, InvalidOid); tp = SearchSysCache4(AMPROCNUM, ObjectIdGetDatum(famaddr.objectId), ObjectIdGetDatum(typeoids[0]), ObjectIdGetDatum(typeoids[1]), Int16GetDatum(membernum)); if (!HeapTupleIsValid(tp)) { if (!missing_ok) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_OBJECT), errmsg("function %d (%s, %s) of %s does not exist", membernum, TypeNameToString(typenames[0]), TypeNameToString(typenames[1]), getObjectDescription(&famaddr, false)))); } else { address.objectId = ((Form_pg_amproc) GETSTRUCT(tp))->oid; ReleaseSysCache(tp); } } break; default: elog(ERROR, "unrecognized object type: %d", (int) objtype); } return address; } /* * Find the ObjectAddress for a user mapping. */ static ObjectAddress get_object_address_usermapping(List *object, bool missing_ok) { ObjectAddress address; Oid userid; char *username; char *servername; ForeignServer *server; HeapTuple tp; ObjectAddressSet(address, UserMappingRelationId, InvalidOid); /* fetch string names from input lists, for error messages */ username = strVal(linitial(object)); servername = strVal(lsecond(object)); /* look up pg_authid OID of mapped user; InvalidOid if PUBLIC */ if (strcmp(username, "public") == 0) userid = InvalidOid; else { tp = SearchSysCache1(AUTHNAME, CStringGetDatum(username)); if (!HeapTupleIsValid(tp)) { if (!missing_ok) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_OBJECT), errmsg("user mapping for user \"%s\" on server \"%s\" does not exist", username, servername))); return address; } userid = ((Form_pg_authid) GETSTRUCT(tp))->oid; ReleaseSysCache(tp); } /* Now look up the pg_user_mapping tuple */ server = GetForeignServerByName(servername, true); if (!server) { if (!missing_ok) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_OBJECT), errmsg("server \"%s\" does not exist", servername))); return address; } tp = SearchSysCache2(USERMAPPINGUSERSERVER, ObjectIdGetDatum(userid), ObjectIdGetDatum(server->serverid)); if (!HeapTupleIsValid(tp)) { if (!missing_ok) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_OBJECT), errmsg("user mapping for user \"%s\" on server \"%s\" does not exist", username, servername))); return address; } address.objectId = ((Form_pg_user_mapping) GETSTRUCT(tp))->oid; ReleaseSysCache(tp); return address; } /* * Find the ObjectAddress for a publication relation. The first element of * the object parameter is the relation name, the second is the * publication name. */ static ObjectAddress get_object_address_publication_rel(List *object, Relation *relp, bool missing_ok) { ObjectAddress address; Relation relation; List *relname; char *pubname; Publication *pub; ObjectAddressSet(address, PublicationRelRelationId, InvalidOid); relname = linitial(object); relation = relation_openrv_extended(makeRangeVarFromNameList(relname), AccessShareLock, missing_ok); if (!relation) return address; /* fetch publication name from input list */ pubname = strVal(lsecond(object)); /* Now look up the pg_publication tuple */ pub = GetPublicationByName(pubname, missing_ok); if (!pub) { relation_close(relation, AccessShareLock); return address; } /* Find the publication relation mapping in syscache. */ address.objectId = GetSysCacheOid2(PUBLICATIONRELMAP, Anum_pg_publication_rel_oid, ObjectIdGetDatum(RelationGetRelid(relation)), ObjectIdGetDatum(pub->oid)); if (!OidIsValid(address.objectId)) { if (!missing_ok) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_OBJECT), errmsg("publication relation \"%s\" in publication \"%s\" does not exist", RelationGetRelationName(relation), pubname))); relation_close(relation, AccessShareLock); return address; } *relp = relation; return address; } /* * Find the ObjectAddress for a publication schema. The first element of the * object parameter is the schema name, the second is the publication name. */ static ObjectAddress get_object_address_publication_schema(List *object, bool missing_ok) { ObjectAddress address; Publication *pub; char *pubname; char *schemaname; Oid schemaid; ObjectAddressSet(address, PublicationNamespaceRelationId, InvalidOid); /* Fetch schema name and publication name from input list */ schemaname = strVal(linitial(object)); pubname = strVal(lsecond(object)); schemaid = get_namespace_oid(schemaname, missing_ok); if (!OidIsValid(schemaid)) return address; /* Now look up the pg_publication tuple */ pub = GetPublicationByName(pubname, missing_ok); if (!pub) return address; /* Find the publication schema mapping in syscache */ address.objectId = GetSysCacheOid2(PUBLICATIONNAMESPACEMAP, Anum_pg_publication_namespace_oid, ObjectIdGetDatum(schemaid), ObjectIdGetDatum(pub->oid)); if (!OidIsValid(address.objectId) && !missing_ok) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_OBJECT), errmsg("publication schema \"%s\" in publication \"%s\" does not exist", schemaname, pubname))); return address; } /* * Find the ObjectAddress for a default ACL. */ static ObjectAddress get_object_address_defacl(List *object, bool missing_ok) { HeapTuple tp; Oid userid; Oid schemaid; char *username; char *schema; char objtype; char *objtype_str; ObjectAddress address; ObjectAddressSet(address, DefaultAclRelationId, InvalidOid); /* * First figure out the textual attributes so that they can be used for * error reporting. */ username = strVal(lsecond(object)); if (list_length(object) >= 3) schema = (char *) strVal(lthird(object)); else schema = NULL; /* * Decode defaclobjtype. Only first char is considered; the rest of the * string, if any, is blissfully ignored. */ objtype = ((char *) strVal(linitial(object)))[0]; switch (objtype) { case DEFACLOBJ_RELATION: objtype_str = "tables"; break; case DEFACLOBJ_SEQUENCE: objtype_str = "sequences"; break; case DEFACLOBJ_FUNCTION: objtype_str = "functions"; break; case DEFACLOBJ_TYPE: objtype_str = "types"; break; case DEFACLOBJ_NAMESPACE: objtype_str = "schemas"; break; case DEFACLOBJ_LARGEOBJECT: objtype_str = "large objects"; break; default: ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("unrecognized default ACL object type \"%c\"", objtype), errhint("Valid object types are \"%c\", \"%c\", \"%c\", \"%c\", \"%c\", \"%c\".", DEFACLOBJ_RELATION, DEFACLOBJ_SEQUENCE, DEFACLOBJ_FUNCTION, DEFACLOBJ_TYPE, DEFACLOBJ_NAMESPACE, DEFACLOBJ_LARGEOBJECT))); } /* * Look up user ID. Behave as "default ACL not found" if the user doesn't * exist. */ tp = SearchSysCache1(AUTHNAME, CStringGetDatum(username)); if (!HeapTupleIsValid(tp)) goto not_found; userid = ((Form_pg_authid) GETSTRUCT(tp))->oid; ReleaseSysCache(tp); /* * If a schema name was given, look up its OID. If it doesn't exist, * behave as "default ACL not found". */ if (schema) { schemaid = get_namespace_oid(schema, true); if (schemaid == InvalidOid) goto not_found; } else schemaid = InvalidOid; /* Finally, look up the pg_default_acl object */ tp = SearchSysCache3(DEFACLROLENSPOBJ, ObjectIdGetDatum(userid), ObjectIdGetDatum(schemaid), CharGetDatum(objtype)); if (!HeapTupleIsValid(tp)) goto not_found; address.objectId = ((Form_pg_default_acl) GETSTRUCT(tp))->oid; ReleaseSysCache(tp); return address; not_found: if (!missing_ok) { if (schema) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_OBJECT), errmsg("default ACL for user \"%s\" in schema \"%s\" on %s does not exist", username, schema, objtype_str))); else ereport(ERROR, (errcode(ERRCODE_UNDEFINED_OBJECT), errmsg("default ACL for user \"%s\" on %s does not exist", username, objtype_str))); } return address; } /* * Convert an array of TEXT into a List of string Values, as emitted by the * parser, which is what get_object_address uses as input. */ static List * textarray_to_strvaluelist(ArrayType *arr) { Datum *elems; bool *nulls; int nelems; List *list = NIL; int i; deconstruct_array_builtin(arr, TEXTOID, &elems, &nulls, &nelems); for (i = 0; i < nelems; i++) { if (nulls[i]) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("name or argument lists may not contain nulls"))); list = lappend(list, makeString(TextDatumGetCString(elems[i]))); } return list; } /* * SQL-callable version of get_object_address */ Datum pg_get_object_address(PG_FUNCTION_ARGS) { char *ttype = TextDatumGetCString(PG_GETARG_DATUM(0)); ArrayType *namearr = PG_GETARG_ARRAYTYPE_P(1); ArrayType *argsarr = PG_GETARG_ARRAYTYPE_P(2); int itype; ObjectType type; List *name = NIL; TypeName *typename = NULL; List *args = NIL; Node *objnode = NULL; ObjectAddress addr; TupleDesc tupdesc; Datum values[3]; bool nulls[3]; HeapTuple htup; Relation relation; /* Decode object type, raise error if unknown */ itype = read_objtype_from_string(ttype); if (itype < 0) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("unsupported object type \"%s\"", ttype))); type = (ObjectType) itype; /* * Convert the text array to the representation appropriate for the given * object type. Most use a simple string Values list, but there are some * exceptions. */ if (type == OBJECT_TYPE || type == OBJECT_DOMAIN || type == OBJECT_CAST || type == OBJECT_TRANSFORM || type == OBJECT_DOMCONSTRAINT) { Datum *elems; bool *nulls; int nelems; deconstruct_array_builtin(namearr, TEXTOID, &elems, &nulls, &nelems); if (nelems != 1) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("name list length must be exactly %d", 1))); if (nulls[0]) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("name or argument lists may not contain nulls"))); typename = typeStringToTypeName(TextDatumGetCString(elems[0]), NULL); } else if (type == OBJECT_LARGEOBJECT) { Datum *elems; bool *nulls; int nelems; deconstruct_array_builtin(namearr, TEXTOID, &elems, &nulls, &nelems); if (nelems != 1) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("name list length must be exactly %d", 1))); if (nulls[0]) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("large object OID may not be null"))); objnode = (Node *) makeFloat(TextDatumGetCString(elems[0])); } else { name = textarray_to_strvaluelist(namearr); if (name == NIL) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("name list length must be at least %d", 1))); } /* * If args are given, decode them according to the object type. */ if (type == OBJECT_AGGREGATE || type == OBJECT_FUNCTION || type == OBJECT_PROCEDURE || type == OBJECT_ROUTINE || type == OBJECT_OPERATOR || type == OBJECT_CAST || type == OBJECT_AMOP || type == OBJECT_AMPROC) { /* in these cases, the args list must be of TypeName */ Datum *elems; bool *nulls; int nelems; int i; deconstruct_array_builtin(argsarr, TEXTOID, &elems, &nulls, &nelems); args = NIL; for (i = 0; i < nelems; i++) { if (nulls[i]) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("name or argument lists may not contain nulls"))); args = lappend(args, typeStringToTypeName(TextDatumGetCString(elems[i]), NULL)); } } else { /* For all other object types, use string Values */ args = textarray_to_strvaluelist(argsarr); } /* * get_object_address is pretty sensitive to the length of its input * lists; check that they're what it wants. */ switch (type) { case OBJECT_PUBLICATION_NAMESPACE: case OBJECT_USER_MAPPING: if (list_length(name) != 1) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("name list length must be exactly %d", 1))); /* fall through to check args length */ /* FALLTHROUGH */ case OBJECT_DOMCONSTRAINT: case OBJECT_CAST: case OBJECT_PUBLICATION_REL: case OBJECT_DEFACL: case OBJECT_TRANSFORM: if (list_length(args) != 1) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("argument list length must be exactly %d", 1))); break; case OBJECT_OPFAMILY: case OBJECT_OPCLASS: if (list_length(name) < 2) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("name list length must be at least %d", 2))); break; case OBJECT_AMOP: case OBJECT_AMPROC: if (list_length(name) < 3) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("name list length must be at least %d", 3))); /* fall through to check args length */ /* FALLTHROUGH */ case OBJECT_OPERATOR: if (list_length(args) != 2) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("argument list length must be exactly %d", 2))); break; default: break; } /* * Now build the Node type that get_object_address() expects for the given * type. */ switch (type) { case OBJECT_TABLE: case OBJECT_SEQUENCE: case OBJECT_VIEW: case OBJECT_MATVIEW: case OBJECT_INDEX: case OBJECT_FOREIGN_TABLE: case OBJECT_COLUMN: case OBJECT_ATTRIBUTE: case OBJECT_COLLATION: case OBJECT_CONVERSION: case OBJECT_STATISTIC_EXT: case OBJECT_TSPARSER: case OBJECT_TSDICTIONARY: case OBJECT_TSTEMPLATE: case OBJECT_TSCONFIGURATION: case OBJECT_DEFAULT: case OBJECT_POLICY: case OBJECT_RULE: case OBJECT_TRIGGER: case OBJECT_TABCONSTRAINT: case OBJECT_OPCLASS: case OBJECT_OPFAMILY: objnode = (Node *) name; break; case OBJECT_ACCESS_METHOD: case OBJECT_DATABASE: case OBJECT_EVENT_TRIGGER: case OBJECT_EXTENSION: case OBJECT_FDW: case OBJECT_FOREIGN_SERVER: case OBJECT_LANGUAGE: case OBJECT_PARAMETER_ACL: case OBJECT_PUBLICATION: case OBJECT_ROLE: case OBJECT_SCHEMA: case OBJECT_SUBSCRIPTION: case OBJECT_TABLESPACE: if (list_length(name) != 1) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("name list length must be exactly %d", 1))); objnode = linitial(name); break; case OBJECT_TYPE: case OBJECT_DOMAIN: objnode = (Node *) typename; break; case OBJECT_CAST: case OBJECT_DOMCONSTRAINT: case OBJECT_TRANSFORM: objnode = (Node *) list_make2(typename, linitial(args)); break; case OBJECT_PUBLICATION_REL: objnode = (Node *) list_make2(name, linitial(args)); break; case OBJECT_PUBLICATION_NAMESPACE: case OBJECT_USER_MAPPING: objnode = (Node *) list_make2(linitial(name), linitial(args)); break; case OBJECT_DEFACL: objnode = (Node *) lcons(linitial(args), name); break; case OBJECT_AMOP: case OBJECT_AMPROC: objnode = (Node *) list_make2(name, args); break; case OBJECT_FUNCTION: case OBJECT_PROCEDURE: case OBJECT_ROUTINE: case OBJECT_AGGREGATE: case OBJECT_OPERATOR: { ObjectWithArgs *owa = makeNode(ObjectWithArgs); owa->objname = name; owa->objargs = args; objnode = (Node *) owa; break; } case OBJECT_LARGEOBJECT: /* already handled above */ break; /* no default, to let compiler warn about missing case */ } if (objnode == NULL) elog(ERROR, "unrecognized object type: %d", type); addr = get_object_address(type, objnode, &relation, AccessShareLock, false); /* We don't need the relcache entry, thank you very much */ if (relation) relation_close(relation, AccessShareLock); if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE) elog(ERROR, "return type must be a row type"); values[0] = ObjectIdGetDatum(addr.classId); values[1] = ObjectIdGetDatum(addr.objectId); values[2] = Int32GetDatum(addr.objectSubId); nulls[0] = false; nulls[1] = false; nulls[2] = false; htup = heap_form_tuple(tupdesc, values, nulls); PG_RETURN_DATUM(HeapTupleGetDatum(htup)); } /* * Check ownership of an object previously identified by get_object_address. */ void check_object_ownership(Oid roleid, ObjectType objtype, ObjectAddress address, Node *object, Relation relation) { switch (objtype) { case OBJECT_INDEX: case OBJECT_SEQUENCE: case OBJECT_TABLE: case OBJECT_VIEW: case OBJECT_MATVIEW: case OBJECT_FOREIGN_TABLE: case OBJECT_COLUMN: case OBJECT_RULE: case OBJECT_TRIGGER: case OBJECT_POLICY: case OBJECT_TABCONSTRAINT: if (!object_ownercheck(RelationRelationId, RelationGetRelid(relation), roleid)) aclcheck_error(ACLCHECK_NOT_OWNER, objtype, RelationGetRelationName(relation)); break; case OBJECT_TYPE: case OBJECT_DOMAIN: case OBJECT_ATTRIBUTE: if (!object_ownercheck(address.classId, address.objectId, roleid)) aclcheck_error_type(ACLCHECK_NOT_OWNER, address.objectId); break; case OBJECT_DOMCONSTRAINT: { HeapTuple tuple; Oid contypid; tuple = SearchSysCache1(CONSTROID, ObjectIdGetDatum(address.objectId)); if (!HeapTupleIsValid(tuple)) elog(ERROR, "constraint with OID %u does not exist", address.objectId); contypid = ((Form_pg_constraint) GETSTRUCT(tuple))->contypid; ReleaseSysCache(tuple); /* * Fallback to type ownership check in this case as this is * what domain constraints rely on. */ if (!object_ownercheck(TypeRelationId, contypid, roleid)) aclcheck_error_type(ACLCHECK_NOT_OWNER, contypid); } break; case OBJECT_AGGREGATE: case OBJECT_FUNCTION: case OBJECT_PROCEDURE: case OBJECT_ROUTINE: case OBJECT_OPERATOR: if (!object_ownercheck(address.classId, address.objectId, roleid)) aclcheck_error(ACLCHECK_NOT_OWNER, objtype, NameListToString((castNode(ObjectWithArgs, object))->objname)); break; case OBJECT_DATABASE: case OBJECT_EVENT_TRIGGER: case OBJECT_EXTENSION: case OBJECT_FDW: case OBJECT_FOREIGN_SERVER: case OBJECT_LANGUAGE: case OBJECT_PUBLICATION: case OBJECT_SCHEMA: case OBJECT_SUBSCRIPTION: case OBJECT_TABLESPACE: if (!object_ownercheck(address.classId, address.objectId, roleid)) aclcheck_error(ACLCHECK_NOT_OWNER, objtype, strVal(object)); break; case OBJECT_COLLATION: case OBJECT_CONVERSION: case OBJECT_OPCLASS: case OBJECT_OPFAMILY: case OBJECT_STATISTIC_EXT: case OBJECT_TSDICTIONARY: case OBJECT_TSCONFIGURATION: if (!object_ownercheck(address.classId, address.objectId, roleid)) aclcheck_error(ACLCHECK_NOT_OWNER, objtype, NameListToString(castNode(List, object))); break; case OBJECT_LARGEOBJECT: if (!lo_compat_privileges && !object_ownercheck(address.classId, address.objectId, roleid)) ereport(ERROR, (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE), errmsg("must be owner of large object %u", address.objectId))); break; case OBJECT_CAST: { /* We can only check permissions on the source/target types */ TypeName *sourcetype = linitial_node(TypeName, castNode(List, object)); TypeName *targettype = lsecond_node(TypeName, castNode(List, object)); Oid sourcetypeid = typenameTypeId(NULL, sourcetype); Oid targettypeid = typenameTypeId(NULL, targettype); if (!object_ownercheck(TypeRelationId, sourcetypeid, roleid) && !object_ownercheck(TypeRelationId, targettypeid, roleid)) ereport(ERROR, (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE), errmsg("must be owner of type %s or type %s", format_type_be(sourcetypeid), format_type_be(targettypeid)))); } break; case OBJECT_TRANSFORM: { TypeName *typename = linitial_node(TypeName, castNode(List, object)); Oid typeid = typenameTypeId(NULL, typename); if (!object_ownercheck(TypeRelationId, typeid, roleid)) aclcheck_error_type(ACLCHECK_NOT_OWNER, typeid); } break; case OBJECT_ROLE: /* * We treat roles as being "owned" by those with CREATEROLE priv, * provided that they also have admin option on the role. * * However, superusers are only owned by superusers. */ if (superuser_arg(address.objectId)) { if (!superuser_arg(roleid)) ereport(ERROR, (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE), errmsg("permission denied"), errdetail("The current user must have the %s attribute.", "SUPERUSER"))); } else { if (!has_createrole_privilege(roleid)) ereport(ERROR, (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE), errmsg("permission denied"), errdetail("The current user must have the %s attribute.", "CREATEROLE"))); if (!is_admin_of_role(roleid, address.objectId)) ereport(ERROR, (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE), errmsg("permission denied"), errdetail("The current user must have the %s option on role \"%s\".", "ADMIN", GetUserNameFromId(address.objectId, true)))); } break; case OBJECT_TSPARSER: case OBJECT_TSTEMPLATE: case OBJECT_ACCESS_METHOD: case OBJECT_PARAMETER_ACL: /* We treat these object types as being owned by superusers */ if (!superuser_arg(roleid)) ereport(ERROR, (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE), errmsg("must be superuser"))); break; case OBJECT_AMOP: case OBJECT_AMPROC: case OBJECT_DEFAULT: case OBJECT_DEFACL: case OBJECT_PUBLICATION_NAMESPACE: case OBJECT_PUBLICATION_REL: case OBJECT_USER_MAPPING: /* These are currently not supported or don't make sense here. */ elog(ERROR, "unsupported object type: %d", (int) objtype); break; } } /* * get_object_namespace * * Find the schema containing the specified object. For non-schema objects, * this function returns InvalidOid. */ Oid get_object_namespace(const ObjectAddress *address) { int cache; HeapTuple tuple; Oid oid; const ObjectPropertyType *property; /* If not owned by a namespace, just return InvalidOid. */ property = get_object_property_data(address->classId); if (property->attnum_namespace == InvalidAttrNumber) return InvalidOid; /* Currently, we can only handle object types with system caches. */ cache = property->oid_catcache_id; Assert(cache != -1); /* Fetch tuple from syscache and extract namespace attribute. */ tuple = SearchSysCache1(cache, ObjectIdGetDatum(address->objectId)); if (!HeapTupleIsValid(tuple)) elog(ERROR, "cache lookup failed for cache %d oid %u", cache, address->objectId); oid = DatumGetObjectId(SysCacheGetAttrNotNull(cache, tuple, property->attnum_namespace)); ReleaseSysCache(tuple); return oid; } /* * Return ObjectType for the given object type as given by * getObjectTypeDescription; if no valid ObjectType code exists, but it's a * possible output type from getObjectTypeDescription, return -1. * Otherwise, an error is thrown. */ int read_objtype_from_string(const char *objtype) { int i; for (i = 0; i < lengthof(ObjectTypeMap); i++) { if (strcmp(ObjectTypeMap[i].tm_name, objtype) == 0) return ObjectTypeMap[i].tm_type; } ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("unrecognized object type \"%s\"", objtype))); return -1; /* keep compiler quiet */ } /* * Interfaces to reference fields of ObjectPropertyType */ const char * get_object_class_descr(Oid class_id) { const ObjectPropertyType *prop = get_object_property_data(class_id); return prop->class_descr; } Oid get_object_oid_index(Oid class_id) { const ObjectPropertyType *prop = get_object_property_data(class_id); return prop->oid_index_oid; } int get_object_catcache_oid(Oid class_id) { const ObjectPropertyType *prop = get_object_property_data(class_id); return prop->oid_catcache_id; } int get_object_catcache_name(Oid class_id) { const ObjectPropertyType *prop = get_object_property_data(class_id); return prop->name_catcache_id; } AttrNumber get_object_attnum_oid(Oid class_id) { const ObjectPropertyType *prop = get_object_property_data(class_id); return prop->attnum_oid; } AttrNumber get_object_attnum_name(Oid class_id) { const ObjectPropertyType *prop = get_object_property_data(class_id); return prop->attnum_name; } AttrNumber get_object_attnum_namespace(Oid class_id) { const ObjectPropertyType *prop = get_object_property_data(class_id); return prop->attnum_namespace; } AttrNumber get_object_attnum_owner(Oid class_id) { const ObjectPropertyType *prop = get_object_property_data(class_id); return prop->attnum_owner; } AttrNumber get_object_attnum_acl(Oid class_id) { const ObjectPropertyType *prop = get_object_property_data(class_id); return prop->attnum_acl; } /* * get_object_type * * Return the object type associated with a given object. This routine * is primarily used to determine the object type to mention in ACL check * error messages, so it's desirable for it to avoid failing. */ ObjectType get_object_type(Oid class_id, Oid object_id) { const ObjectPropertyType *prop = get_object_property_data(class_id); if (prop->objtype == OBJECT_TABLE) { /* * If the property data says it's a table, dig a little deeper to get * the real relation kind, so that callers can produce more precise * error messages. */ return get_relkind_objtype(get_rel_relkind(object_id)); } else return prop->objtype; } bool get_object_namensp_unique(Oid class_id) { const ObjectPropertyType *prop = get_object_property_data(class_id); return prop->is_nsp_name_unique; } /* * Return whether we have useful data for the given object class in the * ObjectProperty table. */ bool is_objectclass_supported(Oid class_id) { int index; for (index = 0; index < lengthof(ObjectProperty); index++) { if (ObjectProperty[index].class_oid == class_id) return true; } return false; } /* * Find ObjectProperty structure by class_id. */ static const ObjectPropertyType * get_object_property_data(Oid class_id) { static const ObjectPropertyType *prop_last = NULL; int index; /* * A shortcut to speed up multiple consecutive lookups of a particular * object class. */ if (prop_last && prop_last->class_oid == class_id) return prop_last; for (index = 0; index < lengthof(ObjectProperty); index++) { if (ObjectProperty[index].class_oid == class_id) { prop_last = &ObjectProperty[index]; return &ObjectProperty[index]; } } ereport(ERROR, (errmsg_internal("unrecognized class ID: %u", class_id))); return NULL; /* keep MSC compiler happy */ } /* * Return a copy of the tuple for the object with the given object OID, from * the given catalog (which must have been opened by the caller and suitably * locked). NULL is returned if the OID is not found. * * We try a syscache first, if available. */ HeapTuple get_catalog_object_by_oid(Relation catalog, AttrNumber oidcol, Oid objectId) { return get_catalog_object_by_oid_extended(catalog, oidcol, objectId, false); } /* * Same as get_catalog_object_by_oid(), but with an additional "locktup" * argument controlling whether to acquire a LOCKTAG_TUPLE at mode * InplaceUpdateTupleLock. See README.tuplock section "Locking to write * inplace-updated tables". */ HeapTuple get_catalog_object_by_oid_extended(Relation catalog, AttrNumber oidcol, Oid objectId, bool locktup) { HeapTuple tuple; Oid classId = RelationGetRelid(catalog); int oidCacheId = get_object_catcache_oid(classId); if (oidCacheId > 0) { if (locktup) tuple = SearchSysCacheLockedCopy1(oidCacheId, ObjectIdGetDatum(objectId)); else tuple = SearchSysCacheCopy1(oidCacheId, ObjectIdGetDatum(objectId)); if (!HeapTupleIsValid(tuple)) /* should not happen */ return NULL; } else { Oid oidIndexId = get_object_oid_index(classId); SysScanDesc scan; ScanKeyData skey; Assert(OidIsValid(oidIndexId)); ScanKeyInit(&skey, oidcol, BTEqualStrategyNumber, F_OIDEQ, ObjectIdGetDatum(objectId)); scan = systable_beginscan(catalog, oidIndexId, true, NULL, 1, &skey); tuple = systable_getnext(scan); if (!HeapTupleIsValid(tuple)) { systable_endscan(scan); return NULL; } if (locktup) LockTuple(catalog, &tuple->t_self, InplaceUpdateTupleLock); tuple = heap_copytuple(tuple); systable_endscan(scan); } return tuple; } /* * getPublicationSchemaInfo * * Get publication name and schema name from the object address into pubname and * nspname. Both pubname and nspname are palloc'd strings which will be freed by * the caller. */ static bool getPublicationSchemaInfo(const ObjectAddress *object, bool missing_ok, char **pubname, char **nspname) { HeapTuple tup; Form_pg_publication_namespace pnform; tup = SearchSysCache1(PUBLICATIONNAMESPACE, ObjectIdGetDatum(object->objectId)); if (!HeapTupleIsValid(tup)) { if (!missing_ok) elog(ERROR, "cache lookup failed for publication schema %u", object->objectId); return false; } pnform = (Form_pg_publication_namespace) GETSTRUCT(tup); *pubname = get_publication_name(pnform->pnpubid, missing_ok); if (!(*pubname)) { ReleaseSysCache(tup); return false; } *nspname = get_namespace_name(pnform->pnnspid); if (!(*nspname)) { Oid schemaid = pnform->pnnspid; pfree(*pubname); ReleaseSysCache(tup); if (!missing_ok) elog(ERROR, "cache lookup failed for schema %u", schemaid); return false; } ReleaseSysCache(tup); return true; } /* * getObjectDescription: build an object description for messages * * The result is a palloc'd string. NULL is returned for an undefined * object if missing_ok is true, else an error is generated. */ char * getObjectDescription(const ObjectAddress *object, bool missing_ok) { StringInfoData buffer; initStringInfo(&buffer); switch (object->classId) { case RelationRelationId: if (object->objectSubId == 0) getRelationDescription(&buffer, object->objectId, missing_ok); else { /* column, not whole relation */ StringInfoData rel; char *attname = get_attname(object->objectId, object->objectSubId, missing_ok); if (!attname) break; initStringInfo(&rel); getRelationDescription(&rel, object->objectId, missing_ok); /* translator: second %s is, e.g., "table %s" */ appendStringInfo(&buffer, _("column %s of %s"), attname, rel.data); pfree(rel.data); } break; case ProcedureRelationId: { bits16 flags = FORMAT_PROC_INVALID_AS_NULL; char *proname = format_procedure_extended(object->objectId, flags); if (proname == NULL) break; appendStringInfo(&buffer, _("function %s"), proname); break; } case TypeRelationId: { bits16 flags = FORMAT_TYPE_INVALID_AS_NULL; char *typname = format_type_extended(object->objectId, -1, flags); if (typname == NULL) break; appendStringInfo(&buffer, _("type %s"), typname); break; } case CastRelationId: { Relation castDesc; ScanKeyData skey[1]; SysScanDesc rcscan; HeapTuple tup; Form_pg_cast castForm; castDesc = table_open(CastRelationId, AccessShareLock); ScanKeyInit(&skey[0], Anum_pg_cast_oid, BTEqualStrategyNumber, F_OIDEQ, ObjectIdGetDatum(object->objectId)); rcscan = systable_beginscan(castDesc, CastOidIndexId, true, NULL, 1, skey); tup = systable_getnext(rcscan); if (!HeapTupleIsValid(tup)) { if (!missing_ok) elog(ERROR, "could not find tuple for cast %u", object->objectId); systable_endscan(rcscan); table_close(castDesc, AccessShareLock); break; } castForm = (Form_pg_cast) GETSTRUCT(tup); appendStringInfo(&buffer, _("cast from %s to %s"), format_type_be(castForm->castsource), format_type_be(castForm->casttarget)); systable_endscan(rcscan); table_close(castDesc, AccessShareLock); break; } case CollationRelationId: { HeapTuple collTup; Form_pg_collation coll; char *nspname; collTup = SearchSysCache1(COLLOID, ObjectIdGetDatum(object->objectId)); if (!HeapTupleIsValid(collTup)) { if (!missing_ok) elog(ERROR, "cache lookup failed for collation %u", object->objectId); break; } coll = (Form_pg_collation) GETSTRUCT(collTup); /* Qualify the name if not visible in search path */ if (CollationIsVisible(object->objectId)) nspname = NULL; else nspname = get_namespace_name(coll->collnamespace); appendStringInfo(&buffer, _("collation %s"), quote_qualified_identifier(nspname, NameStr(coll->collname))); ReleaseSysCache(collTup); break; } case ConstraintRelationId: { HeapTuple conTup; Form_pg_constraint con; conTup = SearchSysCache1(CONSTROID, ObjectIdGetDatum(object->objectId)); if (!HeapTupleIsValid(conTup)) { if (!missing_ok) elog(ERROR, "cache lookup failed for constraint %u", object->objectId); break; } con = (Form_pg_constraint) GETSTRUCT(conTup); if (OidIsValid(con->conrelid)) { StringInfoData rel; initStringInfo(&rel); getRelationDescription(&rel, con->conrelid, false); /* translator: second %s is, e.g., "table %s" */ appendStringInfo(&buffer, _("constraint %s on %s"), NameStr(con->conname), rel.data); pfree(rel.data); } else { appendStringInfo(&buffer, _("constraint %s"), NameStr(con->conname)); } ReleaseSysCache(conTup); break; } case ConversionRelationId: { HeapTuple conTup; Form_pg_conversion conv; char *nspname; conTup = SearchSysCache1(CONVOID, ObjectIdGetDatum(object->objectId)); if (!HeapTupleIsValid(conTup)) { if (!missing_ok) elog(ERROR, "cache lookup failed for conversion %u", object->objectId); break; } conv = (Form_pg_conversion) GETSTRUCT(conTup); /* Qualify the name if not visible in search path */ if (ConversionIsVisible(object->objectId)) nspname = NULL; else nspname = get_namespace_name(conv->connamespace); appendStringInfo(&buffer, _("conversion %s"), quote_qualified_identifier(nspname, NameStr(conv->conname))); ReleaseSysCache(conTup); break; } case AttrDefaultRelationId: { ObjectAddress colobject; colobject = GetAttrDefaultColumnAddress(object->objectId); if (!OidIsValid(colobject.objectId)) { if (!missing_ok) elog(ERROR, "could not find tuple for attrdef %u", object->objectId); break; } /* translator: %s is typically "column %s of table %s" */ appendStringInfo(&buffer, _("default value for %s"), getObjectDescription(&colobject, false)); break; } case LanguageRelationId: { char *langname = get_language_name(object->objectId, missing_ok); if (langname) appendStringInfo(&buffer, _("language %s"), get_language_name(object->objectId, false)); break; } case LargeObjectRelationId: if (!LargeObjectExists(object->objectId)) break; appendStringInfo(&buffer, _("large object %u"), object->objectId); break; case OperatorRelationId: { bits16 flags = FORMAT_OPERATOR_INVALID_AS_NULL; char *oprname = format_operator_extended(object->objectId, flags); if (oprname == NULL) break; appendStringInfo(&buffer, _("operator %s"), oprname); break; } case OperatorClassRelationId: { HeapTuple opcTup; Form_pg_opclass opcForm; HeapTuple amTup; Form_pg_am amForm; char *nspname; opcTup = SearchSysCache1(CLAOID, ObjectIdGetDatum(object->objectId)); if (!HeapTupleIsValid(opcTup)) { if (!missing_ok) elog(ERROR, "cache lookup failed for opclass %u", object->objectId); break; } opcForm = (Form_pg_opclass) GETSTRUCT(opcTup); amTup = SearchSysCache1(AMOID, ObjectIdGetDatum(opcForm->opcmethod)); if (!HeapTupleIsValid(amTup)) elog(ERROR, "cache lookup failed for access method %u", opcForm->opcmethod); amForm = (Form_pg_am) GETSTRUCT(amTup); /* Qualify the name if not visible in search path */ if (OpclassIsVisible(object->objectId)) nspname = NULL; else nspname = get_namespace_name(opcForm->opcnamespace); appendStringInfo(&buffer, _("operator class %s for access method %s"), quote_qualified_identifier(nspname, NameStr(opcForm->opcname)), NameStr(amForm->amname)); ReleaseSysCache(amTup); ReleaseSysCache(opcTup); break; } case OperatorFamilyRelationId: getOpFamilyDescription(&buffer, object->objectId, missing_ok); break; case AccessMethodRelationId: { HeapTuple tup; tup = SearchSysCache1(AMOID, ObjectIdGetDatum(object->objectId)); if (!HeapTupleIsValid(tup)) { if (!missing_ok) elog(ERROR, "cache lookup failed for access method %u", object->objectId); break; } appendStringInfo(&buffer, _("access method %s"), NameStr(((Form_pg_am) GETSTRUCT(tup))->amname)); ReleaseSysCache(tup); break; } case AccessMethodOperatorRelationId: { Relation amopDesc; HeapTuple tup; ScanKeyData skey[1]; SysScanDesc amscan; Form_pg_amop amopForm; StringInfoData opfam; amopDesc = table_open(AccessMethodOperatorRelationId, AccessShareLock); ScanKeyInit(&skey[0], Anum_pg_amop_oid, BTEqualStrategyNumber, F_OIDEQ, ObjectIdGetDatum(object->objectId)); amscan = systable_beginscan(amopDesc, AccessMethodOperatorOidIndexId, true, NULL, 1, skey); tup = systable_getnext(amscan); if (!HeapTupleIsValid(tup)) { if (!missing_ok) elog(ERROR, "could not find tuple for amop entry %u", object->objectId); systable_endscan(amscan); table_close(amopDesc, AccessShareLock); break; } amopForm = (Form_pg_amop) GETSTRUCT(tup); initStringInfo(&opfam); getOpFamilyDescription(&opfam, amopForm->amopfamily, false); /* * We use FORMAT_TYPE_ALLOW_INVALID here so as not to fail * completely if the type links are dangling, which is a form * of catalog corruption that could occur due to old bugs. */ /*------ translator: %d is the operator strategy (a number), the first two %s's are data type names, the third %s is the description of the operator family, and the last %s is the textual form of the operator with arguments. */ appendStringInfo(&buffer, _("operator %d (%s, %s) of %s: %s"), amopForm->amopstrategy, format_type_extended(amopForm->amoplefttype, -1, FORMAT_TYPE_ALLOW_INVALID), format_type_extended(amopForm->amoprighttype, -1, FORMAT_TYPE_ALLOW_INVALID), opfam.data, format_operator(amopForm->amopopr)); pfree(opfam.data); systable_endscan(amscan); table_close(amopDesc, AccessShareLock); break; } case AccessMethodProcedureRelationId: { Relation amprocDesc; ScanKeyData skey[1]; SysScanDesc amscan; HeapTuple tup; Form_pg_amproc amprocForm; StringInfoData opfam; amprocDesc = table_open(AccessMethodProcedureRelationId, AccessShareLock); ScanKeyInit(&skey[0], Anum_pg_amproc_oid, BTEqualStrategyNumber, F_OIDEQ, ObjectIdGetDatum(object->objectId)); amscan = systable_beginscan(amprocDesc, AccessMethodProcedureOidIndexId, true, NULL, 1, skey); tup = systable_getnext(amscan); if (!HeapTupleIsValid(tup)) { if (!missing_ok) elog(ERROR, "could not find tuple for amproc entry %u", object->objectId); systable_endscan(amscan); table_close(amprocDesc, AccessShareLock); break; } amprocForm = (Form_pg_amproc) GETSTRUCT(tup); initStringInfo(&opfam); getOpFamilyDescription(&opfam, amprocForm->amprocfamily, false); /* * We use FORMAT_TYPE_ALLOW_INVALID here so as not to fail * completely if the type links are dangling, which is a form * of catalog corruption that could occur due to old bugs. */ /*------ translator: %d is the function number, the first two %s's are data type names, the third %s is the description of the operator family, and the last %s is the textual form of the function with arguments. */ appendStringInfo(&buffer, _("function %d (%s, %s) of %s: %s"), amprocForm->amprocnum, format_type_extended(amprocForm->amproclefttype, -1, FORMAT_TYPE_ALLOW_INVALID), format_type_extended(amprocForm->amprocrighttype, -1, FORMAT_TYPE_ALLOW_INVALID), opfam.data, format_procedure(amprocForm->amproc)); pfree(opfam.data); systable_endscan(amscan); table_close(amprocDesc, AccessShareLock); break; } case RewriteRelationId: { Relation ruleDesc; ScanKeyData skey[1]; SysScanDesc rcscan; HeapTuple tup; Form_pg_rewrite rule; StringInfoData rel; ruleDesc = table_open(RewriteRelationId, AccessShareLock); ScanKeyInit(&skey[0], Anum_pg_rewrite_oid, BTEqualStrategyNumber, F_OIDEQ, ObjectIdGetDatum(object->objectId)); rcscan = systable_beginscan(ruleDesc, RewriteOidIndexId, true, NULL, 1, skey); tup = systable_getnext(rcscan); if (!HeapTupleIsValid(tup)) { if (!missing_ok) elog(ERROR, "could not find tuple for rule %u", object->objectId); systable_endscan(rcscan); table_close(ruleDesc, AccessShareLock); break; } rule = (Form_pg_rewrite) GETSTRUCT(tup); initStringInfo(&rel); getRelationDescription(&rel, rule->ev_class, false); /* translator: second %s is, e.g., "table %s" */ appendStringInfo(&buffer, _("rule %s on %s"), NameStr(rule->rulename), rel.data); pfree(rel.data); systable_endscan(rcscan); table_close(ruleDesc, AccessShareLock); break; } case TriggerRelationId: { Relation trigDesc; ScanKeyData skey[1]; SysScanDesc tgscan; HeapTuple tup; Form_pg_trigger trig; StringInfoData rel; trigDesc = table_open(TriggerRelationId, AccessShareLock); ScanKeyInit(&skey[0], Anum_pg_trigger_oid, BTEqualStrategyNumber, F_OIDEQ, ObjectIdGetDatum(object->objectId)); tgscan = systable_beginscan(trigDesc, TriggerOidIndexId, true, NULL, 1, skey); tup = systable_getnext(tgscan); if (!HeapTupleIsValid(tup)) { if (!missing_ok) elog(ERROR, "could not find tuple for trigger %u", object->objectId); systable_endscan(tgscan); table_close(trigDesc, AccessShareLock); break; } trig = (Form_pg_trigger) GETSTRUCT(tup); initStringInfo(&rel); getRelationDescription(&rel, trig->tgrelid, false); /* translator: second %s is, e.g., "table %s" */ appendStringInfo(&buffer, _("trigger %s on %s"), NameStr(trig->tgname), rel.data); pfree(rel.data); systable_endscan(tgscan); table_close(trigDesc, AccessShareLock); break; } case NamespaceRelationId: { char *nspname; nspname = get_namespace_name(object->objectId); if (!nspname) { if (!missing_ok) elog(ERROR, "cache lookup failed for namespace %u", object->objectId); break; } appendStringInfo(&buffer, _("schema %s"), nspname); break; } case StatisticExtRelationId: { HeapTuple stxTup; Form_pg_statistic_ext stxForm; char *nspname; stxTup = SearchSysCache1(STATEXTOID, ObjectIdGetDatum(object->objectId)); if (!HeapTupleIsValid(stxTup)) { if (!missing_ok) elog(ERROR, "could not find tuple for statistics object %u", object->objectId); break; } stxForm = (Form_pg_statistic_ext) GETSTRUCT(stxTup); /* Qualify the name if not visible in search path */ if (StatisticsObjIsVisible(object->objectId)) nspname = NULL; else nspname = get_namespace_name(stxForm->stxnamespace); appendStringInfo(&buffer, _("statistics object %s"), quote_qualified_identifier(nspname, NameStr(stxForm->stxname))); ReleaseSysCache(stxTup); break; } case TSParserRelationId: { HeapTuple tup; Form_pg_ts_parser prsForm; char *nspname; tup = SearchSysCache1(TSPARSEROID, ObjectIdGetDatum(object->objectId)); if (!HeapTupleIsValid(tup)) { if (!missing_ok) elog(ERROR, "cache lookup failed for text search parser %u", object->objectId); break; } prsForm = (Form_pg_ts_parser) GETSTRUCT(tup); /* Qualify the name if not visible in search path */ if (TSParserIsVisible(object->objectId)) nspname = NULL; else nspname = get_namespace_name(prsForm->prsnamespace); appendStringInfo(&buffer, _("text search parser %s"), quote_qualified_identifier(nspname, NameStr(prsForm->prsname))); ReleaseSysCache(tup); break; } case TSDictionaryRelationId: { HeapTuple tup; Form_pg_ts_dict dictForm; char *nspname; tup = SearchSysCache1(TSDICTOID, ObjectIdGetDatum(object->objectId)); if (!HeapTupleIsValid(tup)) { if (!missing_ok) elog(ERROR, "cache lookup failed for text search dictionary %u", object->objectId); break; } dictForm = (Form_pg_ts_dict) GETSTRUCT(tup); /* Qualify the name if not visible in search path */ if (TSDictionaryIsVisible(object->objectId)) nspname = NULL; else nspname = get_namespace_name(dictForm->dictnamespace); appendStringInfo(&buffer, _("text search dictionary %s"), quote_qualified_identifier(nspname, NameStr(dictForm->dictname))); ReleaseSysCache(tup); break; } case TSTemplateRelationId: { HeapTuple tup; Form_pg_ts_template tmplForm; char *nspname; tup = SearchSysCache1(TSTEMPLATEOID, ObjectIdGetDatum(object->objectId)); if (!HeapTupleIsValid(tup)) { if (!missing_ok) elog(ERROR, "cache lookup failed for text search template %u", object->objectId); break; } tmplForm = (Form_pg_ts_template) GETSTRUCT(tup); /* Qualify the name if not visible in search path */ if (TSTemplateIsVisible(object->objectId)) nspname = NULL; else nspname = get_namespace_name(tmplForm->tmplnamespace); appendStringInfo(&buffer, _("text search template %s"), quote_qualified_identifier(nspname, NameStr(tmplForm->tmplname))); ReleaseSysCache(tup); break; } case TSConfigRelationId: { HeapTuple tup; Form_pg_ts_config cfgForm; char *nspname; tup = SearchSysCache1(TSCONFIGOID, ObjectIdGetDatum(object->objectId)); if (!HeapTupleIsValid(tup)) { if (!missing_ok) elog(ERROR, "cache lookup failed for text search configuration %u", object->objectId); break; } cfgForm = (Form_pg_ts_config) GETSTRUCT(tup); /* Qualify the name if not visible in search path */ if (TSConfigIsVisible(object->objectId)) nspname = NULL; else nspname = get_namespace_name(cfgForm->cfgnamespace); appendStringInfo(&buffer, _("text search configuration %s"), quote_qualified_identifier(nspname, NameStr(cfgForm->cfgname))); ReleaseSysCache(tup); break; } case AuthIdRelationId: { char *username = GetUserNameFromId(object->objectId, missing_ok); if (username) appendStringInfo(&buffer, _("role %s"), username); break; } case AuthMemRelationId: { Relation amDesc; ScanKeyData skey[1]; SysScanDesc rcscan; HeapTuple tup; Form_pg_auth_members amForm; amDesc = table_open(AuthMemRelationId, AccessShareLock); ScanKeyInit(&skey[0], Anum_pg_auth_members_oid, BTEqualStrategyNumber, F_OIDEQ, ObjectIdGetDatum(object->objectId)); rcscan = systable_beginscan(amDesc, AuthMemOidIndexId, true, NULL, 1, skey); tup = systable_getnext(rcscan); if (!HeapTupleIsValid(tup)) { if (!missing_ok) elog(ERROR, "could not find tuple for role membership %u", object->objectId); systable_endscan(rcscan); table_close(amDesc, AccessShareLock); break; } amForm = (Form_pg_auth_members) GETSTRUCT(tup); appendStringInfo(&buffer, _("membership of role %s in role %s"), GetUserNameFromId(amForm->member, false), GetUserNameFromId(amForm->roleid, false)); systable_endscan(rcscan); table_close(amDesc, AccessShareLock); break; } case DatabaseRelationId: { char *datname; datname = get_database_name(object->objectId); if (!datname) { if (!missing_ok) elog(ERROR, "cache lookup failed for database %u", object->objectId); break; } appendStringInfo(&buffer, _("database %s"), datname); break; } case TableSpaceRelationId: { char *tblspace; tblspace = get_tablespace_name(object->objectId); if (!tblspace) { if (!missing_ok) elog(ERROR, "cache lookup failed for tablespace %u", object->objectId); break; } appendStringInfo(&buffer, _("tablespace %s"), tblspace); break; } case ForeignDataWrapperRelationId: { ForeignDataWrapper *fdw; fdw = GetForeignDataWrapperExtended(object->objectId, missing_ok); if (fdw) appendStringInfo(&buffer, _("foreign-data wrapper %s"), fdw->fdwname); break; } case ForeignServerRelationId: { ForeignServer *srv; srv = GetForeignServerExtended(object->objectId, missing_ok); if (srv) appendStringInfo(&buffer, _("server %s"), srv->servername); break; } case UserMappingRelationId: { HeapTuple tup; Oid useid; char *usename; Form_pg_user_mapping umform; ForeignServer *srv; tup = SearchSysCache1(USERMAPPINGOID, ObjectIdGetDatum(object->objectId)); if (!HeapTupleIsValid(tup)) { if (!missing_ok) elog(ERROR, "cache lookup failed for user mapping %u", object->objectId); break; } umform = (Form_pg_user_mapping) GETSTRUCT(tup); useid = umform->umuser; srv = GetForeignServer(umform->umserver); ReleaseSysCache(tup); if (OidIsValid(useid)) usename = GetUserNameFromId(useid, false); else usename = "public"; appendStringInfo(&buffer, _("user mapping for %s on server %s"), usename, srv->servername); break; } case DefaultAclRelationId: { Relation defaclrel; ScanKeyData skey[1]; SysScanDesc rcscan; HeapTuple tup; Form_pg_default_acl defacl; char *rolename; char *nspname; defaclrel = table_open(DefaultAclRelationId, AccessShareLock); ScanKeyInit(&skey[0], Anum_pg_default_acl_oid, BTEqualStrategyNumber, F_OIDEQ, ObjectIdGetDatum(object->objectId)); rcscan = systable_beginscan(defaclrel, DefaultAclOidIndexId, true, NULL, 1, skey); tup = systable_getnext(rcscan); if (!HeapTupleIsValid(tup)) { if (!missing_ok) elog(ERROR, "could not find tuple for default ACL %u", object->objectId); systable_endscan(rcscan); table_close(defaclrel, AccessShareLock); break; } defacl = (Form_pg_default_acl) GETSTRUCT(tup); rolename = GetUserNameFromId(defacl->defaclrole, false); if (OidIsValid(defacl->defaclnamespace)) nspname = get_namespace_name(defacl->defaclnamespace); else nspname = NULL; switch (defacl->defaclobjtype) { case DEFACLOBJ_RELATION: if (nspname) appendStringInfo(&buffer, _("default privileges on new relations belonging to role %s in schema %s"), rolename, nspname); else appendStringInfo(&buffer, _("default privileges on new relations belonging to role %s"), rolename); break; case DEFACLOBJ_SEQUENCE: if (nspname) appendStringInfo(&buffer, _("default privileges on new sequences belonging to role %s in schema %s"), rolename, nspname); else appendStringInfo(&buffer, _("default privileges on new sequences belonging to role %s"), rolename); break; case DEFACLOBJ_FUNCTION: if (nspname) appendStringInfo(&buffer, _("default privileges on new functions belonging to role %s in schema %s"), rolename, nspname); else appendStringInfo(&buffer, _("default privileges on new functions belonging to role %s"), rolename); break; case DEFACLOBJ_TYPE: if (nspname) appendStringInfo(&buffer, _("default privileges on new types belonging to role %s in schema %s"), rolename, nspname); else appendStringInfo(&buffer, _("default privileges on new types belonging to role %s"), rolename); break; case DEFACLOBJ_NAMESPACE: Assert(!nspname); appendStringInfo(&buffer, _("default privileges on new schemas belonging to role %s"), rolename); break; case DEFACLOBJ_LARGEOBJECT: Assert(!nspname); appendStringInfo(&buffer, _("default privileges on new large objects belonging to role %s"), rolename); break; default: /* shouldn't get here */ if (nspname) appendStringInfo(&buffer, _("default privileges belonging to role %s in schema %s"), rolename, nspname); else appendStringInfo(&buffer, _("default privileges belonging to role %s"), rolename); break; } systable_endscan(rcscan); table_close(defaclrel, AccessShareLock); break; } case ExtensionRelationId: { char *extname; extname = get_extension_name(object->objectId); if (!extname) { if (!missing_ok) elog(ERROR, "cache lookup failed for extension %u", object->objectId); break; } appendStringInfo(&buffer, _("extension %s"), extname); break; } case EventTriggerRelationId: { HeapTuple tup; tup = SearchSysCache1(EVENTTRIGGEROID, ObjectIdGetDatum(object->objectId)); if (!HeapTupleIsValid(tup)) { if (!missing_ok) elog(ERROR, "cache lookup failed for event trigger %u", object->objectId); break; } appendStringInfo(&buffer, _("event trigger %s"), NameStr(((Form_pg_event_trigger) GETSTRUCT(tup))->evtname)); ReleaseSysCache(tup); break; } case ParameterAclRelationId: { HeapTuple tup; Datum nameDatum; char *parname; tup = SearchSysCache1(PARAMETERACLOID, ObjectIdGetDatum(object->objectId)); if (!HeapTupleIsValid(tup)) { if (!missing_ok) elog(ERROR, "cache lookup failed for parameter ACL %u", object->objectId); break; } nameDatum = SysCacheGetAttrNotNull(PARAMETERACLOID, tup, Anum_pg_parameter_acl_parname); parname = TextDatumGetCString(nameDatum); appendStringInfo(&buffer, _("parameter %s"), parname); ReleaseSysCache(tup); break; } case PolicyRelationId: { Relation policy_rel; ScanKeyData skey[1]; SysScanDesc sscan; HeapTuple tuple; Form_pg_policy form_policy; StringInfoData rel; policy_rel = table_open(PolicyRelationId, AccessShareLock); ScanKeyInit(&skey[0], Anum_pg_policy_oid, BTEqualStrategyNumber, F_OIDEQ, ObjectIdGetDatum(object->objectId)); sscan = systable_beginscan(policy_rel, PolicyOidIndexId, true, NULL, 1, skey); tuple = systable_getnext(sscan); if (!HeapTupleIsValid(tuple)) { if (!missing_ok) elog(ERROR, "could not find tuple for policy %u", object->objectId); systable_endscan(sscan); table_close(policy_rel, AccessShareLock); break; } form_policy = (Form_pg_policy) GETSTRUCT(tuple); initStringInfo(&rel); getRelationDescription(&rel, form_policy->polrelid, false); /* translator: second %s is, e.g., "table %s" */ appendStringInfo(&buffer, _("policy %s on %s"), NameStr(form_policy->polname), rel.data); pfree(rel.data); systable_endscan(sscan); table_close(policy_rel, AccessShareLock); break; } case PublicationRelationId: { char *pubname = get_publication_name(object->objectId, missing_ok); if (pubname) appendStringInfo(&buffer, _("publication %s"), pubname); break; } case PublicationNamespaceRelationId: { char *pubname; char *nspname; if (!getPublicationSchemaInfo(object, missing_ok, &pubname, &nspname)) break; appendStringInfo(&buffer, _("publication of schema %s in publication %s"), nspname, pubname); pfree(pubname); pfree(nspname); break; } case PublicationRelRelationId: { HeapTuple tup; char *pubname; Form_pg_publication_rel prform; StringInfoData rel; tup = SearchSysCache1(PUBLICATIONREL, ObjectIdGetDatum(object->objectId)); if (!HeapTupleIsValid(tup)) { if (!missing_ok) elog(ERROR, "cache lookup failed for publication table %u", object->objectId); break; } prform = (Form_pg_publication_rel) GETSTRUCT(tup); pubname = get_publication_name(prform->prpubid, false); initStringInfo(&rel); getRelationDescription(&rel, prform->prrelid, false); /* translator: first %s is, e.g., "table %s" */ appendStringInfo(&buffer, _("publication of %s in publication %s"), rel.data, pubname); pfree(rel.data); ReleaseSysCache(tup); break; } case SubscriptionRelationId: { char *subname = get_subscription_name(object->objectId, missing_ok); if (subname) appendStringInfo(&buffer, _("subscription %s"), subname); break; } case TransformRelationId: { HeapTuple trfTup; Form_pg_transform trfForm; trfTup = SearchSysCache1(TRFOID, ObjectIdGetDatum(object->objectId)); if (!HeapTupleIsValid(trfTup)) { if (!missing_ok) elog(ERROR, "could not find tuple for transform %u", object->objectId); break; } trfForm = (Form_pg_transform) GETSTRUCT(trfTup); appendStringInfo(&buffer, _("transform for %s language %s"), format_type_be(trfForm->trftype), get_language_name(trfForm->trflang, false)); ReleaseSysCache(trfTup); break; } default: elog(ERROR, "unsupported object class: %u", object->classId); } /* an empty buffer is equivalent to no object found */ if (buffer.len == 0) return NULL; return buffer.data; } /* * getObjectDescriptionOids: as above, except the object is specified by Oids */ char * getObjectDescriptionOids(Oid classid, Oid objid) { ObjectAddress address; address.classId = classid; address.objectId = objid; address.objectSubId = 0; return getObjectDescription(&address, false); } /* * subroutine for getObjectDescription: describe a relation * * The result is appended to "buffer". */ static void getRelationDescription(StringInfo buffer, Oid relid, bool missing_ok) { HeapTuple relTup; Form_pg_class relForm; char *nspname; char *relname; relTup = SearchSysCache1(RELOID, ObjectIdGetDatum(relid)); if (!HeapTupleIsValid(relTup)) { if (!missing_ok) elog(ERROR, "cache lookup failed for relation %u", relid); return; } relForm = (Form_pg_class) GETSTRUCT(relTup); /* Qualify the name if not visible in search path */ if (RelationIsVisible(relid)) nspname = NULL; else nspname = get_namespace_name(relForm->relnamespace); relname = quote_qualified_identifier(nspname, NameStr(relForm->relname)); switch (relForm->relkind) { case RELKIND_RELATION: case RELKIND_PARTITIONED_TABLE: appendStringInfo(buffer, _("table %s"), relname); break; case RELKIND_INDEX: case RELKIND_PARTITIONED_INDEX: appendStringInfo(buffer, _("index %s"), relname); break; case RELKIND_SEQUENCE: appendStringInfo(buffer, _("sequence %s"), relname); break; case RELKIND_TOASTVALUE: appendStringInfo(buffer, _("toast table %s"), relname); break; case RELKIND_VIEW: appendStringInfo(buffer, _("view %s"), relname); break; case RELKIND_MATVIEW: appendStringInfo(buffer, _("materialized view %s"), relname); break; case RELKIND_COMPOSITE_TYPE: appendStringInfo(buffer, _("composite type %s"), relname); break; case RELKIND_FOREIGN_TABLE: appendStringInfo(buffer, _("foreign table %s"), relname); break; default: /* shouldn't get here */ appendStringInfo(buffer, _("relation %s"), relname); break; } ReleaseSysCache(relTup); } /* * subroutine for getObjectDescription: describe an operator family */ static void getOpFamilyDescription(StringInfo buffer, Oid opfid, bool missing_ok) { HeapTuple opfTup; Form_pg_opfamily opfForm; HeapTuple amTup; Form_pg_am amForm; char *nspname; opfTup = SearchSysCache1(OPFAMILYOID, ObjectIdGetDatum(opfid)); if (!HeapTupleIsValid(opfTup)) { if (!missing_ok) elog(ERROR, "cache lookup failed for opfamily %u", opfid); return; } opfForm = (Form_pg_opfamily) GETSTRUCT(opfTup); amTup = SearchSysCache1(AMOID, ObjectIdGetDatum(opfForm->opfmethod)); if (!HeapTupleIsValid(amTup)) elog(ERROR, "cache lookup failed for access method %u", opfForm->opfmethod); amForm = (Form_pg_am) GETSTRUCT(amTup); /* Qualify the name if not visible in search path */ if (OpfamilyIsVisible(opfid)) nspname = NULL; else nspname = get_namespace_name(opfForm->opfnamespace); appendStringInfo(buffer, _("operator family %s for access method %s"), quote_qualified_identifier(nspname, NameStr(opfForm->opfname)), NameStr(amForm->amname)); ReleaseSysCache(amTup); ReleaseSysCache(opfTup); } /* * SQL-level callable version of getObjectDescription */ Datum pg_describe_object(PG_FUNCTION_ARGS) { Oid classid = PG_GETARG_OID(0); Oid objid = PG_GETARG_OID(1); int32 objsubid = PG_GETARG_INT32(2); char *description; ObjectAddress address; /* for "pinned" items in pg_depend, return null */ if (!OidIsValid(classid) && !OidIsValid(objid)) PG_RETURN_NULL(); address.classId = classid; address.objectId = objid; address.objectSubId = objsubid; description = getObjectDescription(&address, true); if (description == NULL) PG_RETURN_NULL(); PG_RETURN_TEXT_P(cstring_to_text(description)); } /* * SQL-level callable function to obtain object type + identity */ Datum pg_identify_object(PG_FUNCTION_ARGS) { Oid classid = PG_GETARG_OID(0); Oid objid = PG_GETARG_OID(1); int32 objsubid = PG_GETARG_INT32(2); Oid schema_oid = InvalidOid; const char *objname = NULL; char *objidentity; ObjectAddress address; Datum values[4]; bool nulls[4]; TupleDesc tupdesc; HeapTuple htup; address.classId = classid; address.objectId = objid; address.objectSubId = objsubid; if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE) elog(ERROR, "return type must be a row type"); if (is_objectclass_supported(address.classId)) { HeapTuple objtup; Relation catalog = table_open(address.classId, AccessShareLock); objtup = get_catalog_object_by_oid(catalog, get_object_attnum_oid(address.classId), address.objectId); if (objtup != NULL) { bool isnull; AttrNumber nspAttnum; AttrNumber nameAttnum; nspAttnum = get_object_attnum_namespace(address.classId); if (nspAttnum != InvalidAttrNumber) { schema_oid = heap_getattr(objtup, nspAttnum, RelationGetDescr(catalog), &isnull); if (isnull) elog(ERROR, "invalid null namespace in object %u/%u/%d", address.classId, address.objectId, address.objectSubId); } /* * We only return the object name if it can be used (together with * the schema name, if any) as a unique identifier. */ if (get_object_namensp_unique(address.classId)) { nameAttnum = get_object_attnum_name(address.classId); if (nameAttnum != InvalidAttrNumber) { Datum nameDatum; nameDatum = heap_getattr(objtup, nameAttnum, RelationGetDescr(catalog), &isnull); if (isnull) elog(ERROR, "invalid null name in object %u/%u/%d", address.classId, address.objectId, address.objectSubId); objname = quote_identifier(NameStr(*(DatumGetName(nameDatum)))); } } } table_close(catalog, AccessShareLock); } /* object type, which can never be NULL */ values[0] = CStringGetTextDatum(getObjectTypeDescription(&address, true)); nulls[0] = false; /* * Before doing anything, extract the object identity. If the identity * could not be found, set all the fields except the object type to NULL. */ objidentity = getObjectIdentity(&address, true); /* schema name */ if (OidIsValid(schema_oid) && objidentity) { const char *schema = quote_identifier(get_namespace_name(schema_oid)); values[1] = CStringGetTextDatum(schema); nulls[1] = false; } else nulls[1] = true; /* object name */ if (objname && objidentity) { values[2] = CStringGetTextDatum(objname); nulls[2] = false; } else nulls[2] = true; /* object identity */ if (objidentity) { values[3] = CStringGetTextDatum(objidentity); nulls[3] = false; } else nulls[3] = true; htup = heap_form_tuple(tupdesc, values, nulls); PG_RETURN_DATUM(HeapTupleGetDatum(htup)); } /* * SQL-level callable function to obtain object type + identity */ Datum pg_identify_object_as_address(PG_FUNCTION_ARGS) { Oid classid = PG_GETARG_OID(0); Oid objid = PG_GETARG_OID(1); int32 objsubid = PG_GETARG_INT32(2); ObjectAddress address; char *identity; List *names; List *args; Datum values[3]; bool nulls[3]; TupleDesc tupdesc; HeapTuple htup; address.classId = classid; address.objectId = objid; address.objectSubId = objsubid; if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE) elog(ERROR, "return type must be a row type"); /* object type, which can never be NULL */ values[0] = CStringGetTextDatum(getObjectTypeDescription(&address, true)); nulls[0] = false; /* object identity */ identity = getObjectIdentityParts(&address, &names, &args, true); if (identity == NULL) { nulls[1] = true; nulls[2] = true; } else { pfree(identity); /* object_names */ if (names != NIL) values[1] = PointerGetDatum(strlist_to_textarray(names)); else values[1] = PointerGetDatum(construct_empty_array(TEXTOID)); nulls[1] = false; /* object_args */ if (args) values[2] = PointerGetDatum(strlist_to_textarray(args)); else values[2] = PointerGetDatum(construct_empty_array(TEXTOID)); nulls[2] = false; } htup = heap_form_tuple(tupdesc, values, nulls); PG_RETURN_DATUM(HeapTupleGetDatum(htup)); } /* * SQL-level callable function to obtain the ACL of a specified object, given * its catalog OID, object OID and sub-object ID. */ Datum pg_get_acl(PG_FUNCTION_ARGS) { Oid classId = PG_GETARG_OID(0); Oid objectId = PG_GETARG_OID(1); int32 objsubid = PG_GETARG_INT32(2); Oid catalogId; AttrNumber Anum_acl; Datum datum; bool isnull; HeapTuple tup; /* for "pinned" items in pg_depend, return null */ if (!OidIsValid(classId) && !OidIsValid(objectId)) PG_RETURN_NULL(); /* for large objects, the catalog to look at is pg_largeobject_metadata */ catalogId = (classId == LargeObjectRelationId) ? LargeObjectMetadataRelationId : classId; Anum_acl = get_object_attnum_acl(catalogId); /* return NULL if no ACL field for this catalog */ if (Anum_acl == InvalidAttrNumber) PG_RETURN_NULL(); /* * If dealing with a relation's attribute (objsubid is set), the ACL is * retrieved from pg_attribute. */ if (classId == RelationRelationId && objsubid != 0) { AttrNumber attnum = (AttrNumber) objsubid; tup = SearchSysCacheCopyAttNum(objectId, attnum); if (!HeapTupleIsValid(tup)) PG_RETURN_NULL(); datum = SysCacheGetAttr(ATTNUM, tup, Anum_pg_attribute_attacl, &isnull); } else { Relation rel; rel = table_open(catalogId, AccessShareLock); tup = get_catalog_object_by_oid(rel, get_object_attnum_oid(catalogId), objectId); if (!HeapTupleIsValid(tup)) { table_close(rel, AccessShareLock); PG_RETURN_NULL(); } datum = heap_getattr(tup, Anum_acl, RelationGetDescr(rel), &isnull); table_close(rel, AccessShareLock); } if (isnull) PG_RETURN_NULL(); PG_RETURN_DATUM(datum); } /* * Return a palloc'ed string that describes the type of object that the * passed address is for. * * Keep ObjectTypeMap in sync with this. */ char * getObjectTypeDescription(const ObjectAddress *object, bool missing_ok) { StringInfoData buffer; initStringInfo(&buffer); switch (object->classId) { case RelationRelationId: getRelationTypeDescription(&buffer, object->objectId, object->objectSubId, missing_ok); break; case ProcedureRelationId: getProcedureTypeDescription(&buffer, object->objectId, missing_ok); break; case TypeRelationId: appendStringInfoString(&buffer, "type"); break; case CastRelationId: appendStringInfoString(&buffer, "cast"); break; case CollationRelationId: appendStringInfoString(&buffer, "collation"); break; case ConstraintRelationId: getConstraintTypeDescription(&buffer, object->objectId, missing_ok); break; case ConversionRelationId: appendStringInfoString(&buffer, "conversion"); break; case AttrDefaultRelationId: appendStringInfoString(&buffer, "default value"); break; case LanguageRelationId: appendStringInfoString(&buffer, "language"); break; case LargeObjectRelationId: appendStringInfoString(&buffer, "large object"); break; case OperatorRelationId: appendStringInfoString(&buffer, "operator"); break; case OperatorClassRelationId: appendStringInfoString(&buffer, "operator class"); break; case OperatorFamilyRelationId: appendStringInfoString(&buffer, "operator family"); break; case AccessMethodRelationId: appendStringInfoString(&buffer, "access method"); break; case AccessMethodOperatorRelationId: appendStringInfoString(&buffer, "operator of access method"); break; case AccessMethodProcedureRelationId: appendStringInfoString(&buffer, "function of access method"); break; case RewriteRelationId: appendStringInfoString(&buffer, "rule"); break; case TriggerRelationId: appendStringInfoString(&buffer, "trigger"); break; case NamespaceRelationId: appendStringInfoString(&buffer, "schema"); break; case StatisticExtRelationId: appendStringInfoString(&buffer, "statistics object"); break; case TSParserRelationId: appendStringInfoString(&buffer, "text search parser"); break; case TSDictionaryRelationId: appendStringInfoString(&buffer, "text search dictionary"); break; case TSTemplateRelationId: appendStringInfoString(&buffer, "text search template"); break; case TSConfigRelationId: appendStringInfoString(&buffer, "text search configuration"); break; case AuthIdRelationId: appendStringInfoString(&buffer, "role"); break; case AuthMemRelationId: appendStringInfoString(&buffer, "role membership"); break; case DatabaseRelationId: appendStringInfoString(&buffer, "database"); break; case TableSpaceRelationId: appendStringInfoString(&buffer, "tablespace"); break; case ForeignDataWrapperRelationId: appendStringInfoString(&buffer, "foreign-data wrapper"); break; case ForeignServerRelationId: appendStringInfoString(&buffer, "server"); break; case UserMappingRelationId: appendStringInfoString(&buffer, "user mapping"); break; case DefaultAclRelationId: appendStringInfoString(&buffer, "default acl"); break; case ExtensionRelationId: appendStringInfoString(&buffer, "extension"); break; case EventTriggerRelationId: appendStringInfoString(&buffer, "event trigger"); break; case ParameterAclRelationId: appendStringInfoString(&buffer, "parameter ACL"); break; case PolicyRelationId: appendStringInfoString(&buffer, "policy"); break; case PublicationRelationId: appendStringInfoString(&buffer, "publication"); break; case PublicationNamespaceRelationId: appendStringInfoString(&buffer, "publication namespace"); break; case PublicationRelRelationId: appendStringInfoString(&buffer, "publication relation"); break; case SubscriptionRelationId: appendStringInfoString(&buffer, "subscription"); break; case TransformRelationId: appendStringInfoString(&buffer, "transform"); break; default: elog(ERROR, "unsupported object class: %u", object->classId); } /* the result can never be empty */ Assert(buffer.len > 0); return buffer.data; } /* * subroutine for getObjectTypeDescription: describe a relation type */ static void getRelationTypeDescription(StringInfo buffer, Oid relid, int32 objectSubId, bool missing_ok) { HeapTuple relTup; Form_pg_class relForm; relTup = SearchSysCache1(RELOID, ObjectIdGetDatum(relid)); if (!HeapTupleIsValid(relTup)) { if (!missing_ok) elog(ERROR, "cache lookup failed for relation %u", relid); /* fallback to "relation" for an undefined object */ appendStringInfoString(buffer, "relation"); return; } relForm = (Form_pg_class) GETSTRUCT(relTup); switch (relForm->relkind) { case RELKIND_RELATION: case RELKIND_PARTITIONED_TABLE: appendStringInfoString(buffer, "table"); break; case RELKIND_INDEX: case RELKIND_PARTITIONED_INDEX: appendStringInfoString(buffer, "index"); break; case RELKIND_SEQUENCE: appendStringInfoString(buffer, "sequence"); break; case RELKIND_TOASTVALUE: appendStringInfoString(buffer, "toast table"); break; case RELKIND_VIEW: appendStringInfoString(buffer, "view"); break; case RELKIND_MATVIEW: appendStringInfoString(buffer, "materialized view"); break; case RELKIND_COMPOSITE_TYPE: appendStringInfoString(buffer, "composite type"); break; case RELKIND_FOREIGN_TABLE: appendStringInfoString(buffer, "foreign table"); break; default: /* shouldn't get here */ appendStringInfoString(buffer, "relation"); break; } if (objectSubId != 0) appendStringInfoString(buffer, " column"); ReleaseSysCache(relTup); } /* * subroutine for getObjectTypeDescription: describe a constraint type */ static void getConstraintTypeDescription(StringInfo buffer, Oid constroid, bool missing_ok) { Relation constrRel; HeapTuple constrTup; Form_pg_constraint constrForm; constrRel = table_open(ConstraintRelationId, AccessShareLock); constrTup = get_catalog_object_by_oid(constrRel, Anum_pg_constraint_oid, constroid); if (!HeapTupleIsValid(constrTup)) { if (!missing_ok) elog(ERROR, "cache lookup failed for constraint %u", constroid); table_close(constrRel, AccessShareLock); /* fallback to "constraint" for an undefined object */ appendStringInfoString(buffer, "constraint"); return; } constrForm = (Form_pg_constraint) GETSTRUCT(constrTup); if (OidIsValid(constrForm->conrelid)) appendStringInfoString(buffer, "table constraint"); else if (OidIsValid(constrForm->contypid)) appendStringInfoString(buffer, "domain constraint"); else elog(ERROR, "invalid constraint %u", constrForm->oid); table_close(constrRel, AccessShareLock); } /* * subroutine for getObjectTypeDescription: describe a procedure type */ static void getProcedureTypeDescription(StringInfo buffer, Oid procid, bool missing_ok) { HeapTuple procTup; Form_pg_proc procForm; procTup = SearchSysCache1(PROCOID, ObjectIdGetDatum(procid)); if (!HeapTupleIsValid(procTup)) { if (!missing_ok) elog(ERROR, "cache lookup failed for procedure %u", procid); /* fallback to "procedure" for an undefined object */ appendStringInfoString(buffer, "routine"); return; } procForm = (Form_pg_proc) GETSTRUCT(procTup); if (procForm->prokind == PROKIND_AGGREGATE) appendStringInfoString(buffer, "aggregate"); else if (procForm->prokind == PROKIND_PROCEDURE) appendStringInfoString(buffer, "procedure"); else /* function or window function */ appendStringInfoString(buffer, "function"); ReleaseSysCache(procTup); } /* * Obtain a given object's identity, as a palloc'ed string. * * This is for machine consumption, so it's not translated. All elements are * schema-qualified when appropriate. Returns NULL if the object could not * be found. */ char * getObjectIdentity(const ObjectAddress *object, bool missing_ok) { return getObjectIdentityParts(object, NULL, NULL, missing_ok); } /* * As above, but more detailed. * * There are two sets of return values: the identity itself as a palloc'd * string is returned. objname and objargs, if not NULL, are output parameters * that receive lists of C-strings that are useful to give back to * get_object_address() to reconstruct the ObjectAddress. Returns NULL if * the object could not be found. */ char * getObjectIdentityParts(const ObjectAddress *object, List **objname, List **objargs, bool missing_ok) { StringInfoData buffer; initStringInfo(&buffer); /* * Make sure that both objname and objargs were passed, or none was; and * initialize them to empty lists. For objname this is useless because it * will be initialized in all cases inside the switch; but we do it anyway * so that we can test below that no branch leaves it unset. */ Assert(PointerIsValid(objname) == PointerIsValid(objargs)); if (objname) { *objname = NIL; *objargs = NIL; } switch (object->classId) { case RelationRelationId: { char *attr = NULL; /* * Check for the attribute first, so as if it is missing we * can skip the entire relation description. */ if (object->objectSubId != 0) { attr = get_attname(object->objectId, object->objectSubId, missing_ok); if (missing_ok && attr == NULL) break; } getRelationIdentity(&buffer, object->objectId, objname, missing_ok); if (objname && *objname == NIL) break; if (attr) { appendStringInfo(&buffer, ".%s", quote_identifier(attr)); if (objname) *objname = lappend(*objname, attr); } } break; case ProcedureRelationId: { bits16 flags = FORMAT_PROC_FORCE_QUALIFY | FORMAT_PROC_INVALID_AS_NULL; char *proname = format_procedure_extended(object->objectId, flags); if (proname == NULL) break; appendStringInfoString(&buffer, proname); if (objname) format_procedure_parts(object->objectId, objname, objargs, missing_ok); break; } case TypeRelationId: { bits16 flags = FORMAT_TYPE_INVALID_AS_NULL | FORMAT_TYPE_FORCE_QUALIFY; char *typeout; typeout = format_type_extended(object->objectId, -1, flags); if (typeout == NULL) break; appendStringInfoString(&buffer, typeout); if (objname) *objname = list_make1(typeout); } break; case CastRelationId: { Relation castRel; HeapTuple tup; Form_pg_cast castForm; castRel = table_open(CastRelationId, AccessShareLock); tup = get_catalog_object_by_oid(castRel, Anum_pg_cast_oid, object->objectId); if (!HeapTupleIsValid(tup)) { if (!missing_ok) elog(ERROR, "could not find tuple for cast %u", object->objectId); table_close(castRel, AccessShareLock); break; } castForm = (Form_pg_cast) GETSTRUCT(tup); appendStringInfo(&buffer, "(%s AS %s)", format_type_be_qualified(castForm->castsource), format_type_be_qualified(castForm->casttarget)); if (objname) { *objname = list_make1(format_type_be_qualified(castForm->castsource)); *objargs = list_make1(format_type_be_qualified(castForm->casttarget)); } table_close(castRel, AccessShareLock); break; } case CollationRelationId: { HeapTuple collTup; Form_pg_collation coll; char *schema; collTup = SearchSysCache1(COLLOID, ObjectIdGetDatum(object->objectId)); if (!HeapTupleIsValid(collTup)) { if (!missing_ok) elog(ERROR, "cache lookup failed for collation %u", object->objectId); break; } coll = (Form_pg_collation) GETSTRUCT(collTup); schema = get_namespace_name_or_temp(coll->collnamespace); appendStringInfoString(&buffer, quote_qualified_identifier(schema, NameStr(coll->collname))); if (objname) *objname = list_make2(schema, pstrdup(NameStr(coll->collname))); ReleaseSysCache(collTup); break; } case ConstraintRelationId: { HeapTuple conTup; Form_pg_constraint con; conTup = SearchSysCache1(CONSTROID, ObjectIdGetDatum(object->objectId)); if (!HeapTupleIsValid(conTup)) { if (!missing_ok) elog(ERROR, "cache lookup failed for constraint %u", object->objectId); break; } con = (Form_pg_constraint) GETSTRUCT(conTup); if (OidIsValid(con->conrelid)) { appendStringInfo(&buffer, "%s on ", quote_identifier(NameStr(con->conname))); getRelationIdentity(&buffer, con->conrelid, objname, false); if (objname) *objname = lappend(*objname, pstrdup(NameStr(con->conname))); } else { ObjectAddress domain; Assert(OidIsValid(con->contypid)); domain.classId = TypeRelationId; domain.objectId = con->contypid; domain.objectSubId = 0; appendStringInfo(&buffer, "%s on %s", quote_identifier(NameStr(con->conname)), getObjectIdentityParts(&domain, objname, objargs, false)); if (objname) *objargs = lappend(*objargs, pstrdup(NameStr(con->conname))); } ReleaseSysCache(conTup); break; } case ConversionRelationId: { HeapTuple conTup; Form_pg_conversion conForm; char *schema; conTup = SearchSysCache1(CONVOID, ObjectIdGetDatum(object->objectId)); if (!HeapTupleIsValid(conTup)) { if (!missing_ok) elog(ERROR, "cache lookup failed for conversion %u", object->objectId); break; } conForm = (Form_pg_conversion) GETSTRUCT(conTup); schema = get_namespace_name_or_temp(conForm->connamespace); appendStringInfoString(&buffer, quote_qualified_identifier(schema, NameStr(conForm->conname))); if (objname) *objname = list_make2(schema, pstrdup(NameStr(conForm->conname))); ReleaseSysCache(conTup); break; } case AttrDefaultRelationId: { ObjectAddress colobject; colobject = GetAttrDefaultColumnAddress(object->objectId); if (!OidIsValid(colobject.objectId)) { if (!missing_ok) elog(ERROR, "could not find tuple for attrdef %u", object->objectId); break; } appendStringInfo(&buffer, "for %s", getObjectIdentityParts(&colobject, objname, objargs, false)); break; } case LanguageRelationId: { HeapTuple langTup; Form_pg_language langForm; langTup = SearchSysCache1(LANGOID, ObjectIdGetDatum(object->objectId)); if (!HeapTupleIsValid(langTup)) { if (!missing_ok) elog(ERROR, "cache lookup failed for language %u", object->objectId); break; } langForm = (Form_pg_language) GETSTRUCT(langTup); appendStringInfoString(&buffer, quote_identifier(NameStr(langForm->lanname))); if (objname) *objname = list_make1(pstrdup(NameStr(langForm->lanname))); ReleaseSysCache(langTup); break; } case LargeObjectRelationId: if (!LargeObjectExists(object->objectId)) break; appendStringInfo(&buffer, "%u", object->objectId); if (objname) *objname = list_make1(psprintf("%u", object->objectId)); break; case OperatorRelationId: { bits16 flags = FORMAT_OPERATOR_FORCE_QUALIFY | FORMAT_OPERATOR_INVALID_AS_NULL; char *oprname = format_operator_extended(object->objectId, flags); if (oprname == NULL) break; appendStringInfoString(&buffer, oprname); if (objname) format_operator_parts(object->objectId, objname, objargs, missing_ok); break; } case OperatorClassRelationId: { HeapTuple opcTup; Form_pg_opclass opcForm; HeapTuple amTup; Form_pg_am amForm; char *schema; opcTup = SearchSysCache1(CLAOID, ObjectIdGetDatum(object->objectId)); if (!HeapTupleIsValid(opcTup)) { if (!missing_ok) elog(ERROR, "cache lookup failed for opclass %u", object->objectId); break; } opcForm = (Form_pg_opclass) GETSTRUCT(opcTup); schema = get_namespace_name_or_temp(opcForm->opcnamespace); amTup = SearchSysCache1(AMOID, ObjectIdGetDatum(opcForm->opcmethod)); if (!HeapTupleIsValid(amTup)) elog(ERROR, "cache lookup failed for access method %u", opcForm->opcmethod); amForm = (Form_pg_am) GETSTRUCT(amTup); appendStringInfo(&buffer, "%s USING %s", quote_qualified_identifier(schema, NameStr(opcForm->opcname)), quote_identifier(NameStr(amForm->amname))); if (objname) *objname = list_make3(pstrdup(NameStr(amForm->amname)), schema, pstrdup(NameStr(opcForm->opcname))); ReleaseSysCache(amTup); ReleaseSysCache(opcTup); break; } case OperatorFamilyRelationId: getOpFamilyIdentity(&buffer, object->objectId, objname, missing_ok); break; case AccessMethodRelationId: { char *amname; amname = get_am_name(object->objectId); if (!amname) { if (!missing_ok) elog(ERROR, "cache lookup failed for access method %u", object->objectId); break; } appendStringInfoString(&buffer, quote_identifier(amname)); if (objname) *objname = list_make1(amname); } break; case AccessMethodOperatorRelationId: { Relation amopDesc; HeapTuple tup; ScanKeyData skey[1]; SysScanDesc amscan; Form_pg_amop amopForm; StringInfoData opfam; char *ltype; char *rtype; amopDesc = table_open(AccessMethodOperatorRelationId, AccessShareLock); ScanKeyInit(&skey[0], Anum_pg_amop_oid, BTEqualStrategyNumber, F_OIDEQ, ObjectIdGetDatum(object->objectId)); amscan = systable_beginscan(amopDesc, AccessMethodOperatorOidIndexId, true, NULL, 1, skey); tup = systable_getnext(amscan); if (!HeapTupleIsValid(tup)) { if (!missing_ok) elog(ERROR, "could not find tuple for amop entry %u", object->objectId); systable_endscan(amscan); table_close(amopDesc, AccessShareLock); break; } amopForm = (Form_pg_amop) GETSTRUCT(tup); initStringInfo(&opfam); getOpFamilyIdentity(&opfam, amopForm->amopfamily, objname, false); ltype = format_type_be_qualified(amopForm->amoplefttype); rtype = format_type_be_qualified(amopForm->amoprighttype); if (objname) { *objname = lappend(*objname, psprintf("%d", amopForm->amopstrategy)); *objargs = list_make2(ltype, rtype); } appendStringInfo(&buffer, "operator %d (%s, %s) of %s", amopForm->amopstrategy, ltype, rtype, opfam.data); pfree(opfam.data); systable_endscan(amscan); table_close(amopDesc, AccessShareLock); break; } case AccessMethodProcedureRelationId: { Relation amprocDesc; ScanKeyData skey[1]; SysScanDesc amscan; HeapTuple tup; Form_pg_amproc amprocForm; StringInfoData opfam; char *ltype; char *rtype; amprocDesc = table_open(AccessMethodProcedureRelationId, AccessShareLock); ScanKeyInit(&skey[0], Anum_pg_amproc_oid, BTEqualStrategyNumber, F_OIDEQ, ObjectIdGetDatum(object->objectId)); amscan = systable_beginscan(amprocDesc, AccessMethodProcedureOidIndexId, true, NULL, 1, skey); tup = systable_getnext(amscan); if (!HeapTupleIsValid(tup)) { if (!missing_ok) elog(ERROR, "could not find tuple for amproc entry %u", object->objectId); systable_endscan(amscan); table_close(amprocDesc, AccessShareLock); break; } amprocForm = (Form_pg_amproc) GETSTRUCT(tup); initStringInfo(&opfam); getOpFamilyIdentity(&opfam, amprocForm->amprocfamily, objname, false); ltype = format_type_be_qualified(amprocForm->amproclefttype); rtype = format_type_be_qualified(amprocForm->amprocrighttype); if (objname) { *objname = lappend(*objname, psprintf("%d", amprocForm->amprocnum)); *objargs = list_make2(ltype, rtype); } appendStringInfo(&buffer, "function %d (%s, %s) of %s", amprocForm->amprocnum, ltype, rtype, opfam.data); pfree(opfam.data); systable_endscan(amscan); table_close(amprocDesc, AccessShareLock); break; } case RewriteRelationId: { Relation ruleDesc; HeapTuple tup; Form_pg_rewrite rule; ruleDesc = table_open(RewriteRelationId, AccessShareLock); tup = get_catalog_object_by_oid(ruleDesc, Anum_pg_rewrite_oid, object->objectId); if (!HeapTupleIsValid(tup)) { if (!missing_ok) elog(ERROR, "could not find tuple for rule %u", object->objectId); table_close(ruleDesc, AccessShareLock); break; } rule = (Form_pg_rewrite) GETSTRUCT(tup); appendStringInfo(&buffer, "%s on ", quote_identifier(NameStr(rule->rulename))); getRelationIdentity(&buffer, rule->ev_class, objname, false); if (objname) *objname = lappend(*objname, pstrdup(NameStr(rule->rulename))); table_close(ruleDesc, AccessShareLock); break; } case TriggerRelationId: { Relation trigDesc; HeapTuple tup; Form_pg_trigger trig; trigDesc = table_open(TriggerRelationId, AccessShareLock); tup = get_catalog_object_by_oid(trigDesc, Anum_pg_trigger_oid, object->objectId); if (!HeapTupleIsValid(tup)) { if (!missing_ok) elog(ERROR, "could not find tuple for trigger %u", object->objectId); table_close(trigDesc, AccessShareLock); break; } trig = (Form_pg_trigger) GETSTRUCT(tup); appendStringInfo(&buffer, "%s on ", quote_identifier(NameStr(trig->tgname))); getRelationIdentity(&buffer, trig->tgrelid, objname, false); if (objname) *objname = lappend(*objname, pstrdup(NameStr(trig->tgname))); table_close(trigDesc, AccessShareLock); break; } case NamespaceRelationId: { char *nspname; nspname = get_namespace_name_or_temp(object->objectId); if (!nspname) { if (!missing_ok) elog(ERROR, "cache lookup failed for namespace %u", object->objectId); break; } appendStringInfoString(&buffer, quote_identifier(nspname)); if (objname) *objname = list_make1(nspname); break; } case StatisticExtRelationId: { HeapTuple tup; Form_pg_statistic_ext formStatistic; char *schema; tup = SearchSysCache1(STATEXTOID, ObjectIdGetDatum(object->objectId)); if (!HeapTupleIsValid(tup)) { if (!missing_ok) elog(ERROR, "cache lookup failed for statistics object %u", object->objectId); break; } formStatistic = (Form_pg_statistic_ext) GETSTRUCT(tup); schema = get_namespace_name_or_temp(formStatistic->stxnamespace); appendStringInfoString(&buffer, quote_qualified_identifier(schema, NameStr(formStatistic->stxname))); if (objname) *objname = list_make2(schema, pstrdup(NameStr(formStatistic->stxname))); ReleaseSysCache(tup); } break; case TSParserRelationId: { HeapTuple tup; Form_pg_ts_parser formParser; char *schema; tup = SearchSysCache1(TSPARSEROID, ObjectIdGetDatum(object->objectId)); if (!HeapTupleIsValid(tup)) { if (!missing_ok) elog(ERROR, "cache lookup failed for text search parser %u", object->objectId); break; } formParser = (Form_pg_ts_parser) GETSTRUCT(tup); schema = get_namespace_name_or_temp(formParser->prsnamespace); appendStringInfoString(&buffer, quote_qualified_identifier(schema, NameStr(formParser->prsname))); if (objname) *objname = list_make2(schema, pstrdup(NameStr(formParser->prsname))); ReleaseSysCache(tup); break; } case TSDictionaryRelationId: { HeapTuple tup; Form_pg_ts_dict formDict; char *schema; tup = SearchSysCache1(TSDICTOID, ObjectIdGetDatum(object->objectId)); if (!HeapTupleIsValid(tup)) { if (!missing_ok) elog(ERROR, "cache lookup failed for text search dictionary %u", object->objectId); break; } formDict = (Form_pg_ts_dict) GETSTRUCT(tup); schema = get_namespace_name_or_temp(formDict->dictnamespace); appendStringInfoString(&buffer, quote_qualified_identifier(schema, NameStr(formDict->dictname))); if (objname) *objname = list_make2(schema, pstrdup(NameStr(formDict->dictname))); ReleaseSysCache(tup); break; } case TSTemplateRelationId: { HeapTuple tup; Form_pg_ts_template formTmpl; char *schema; tup = SearchSysCache1(TSTEMPLATEOID, ObjectIdGetDatum(object->objectId)); if (!HeapTupleIsValid(tup)) { if (!missing_ok) elog(ERROR, "cache lookup failed for text search template %u", object->objectId); break; } formTmpl = (Form_pg_ts_template) GETSTRUCT(tup); schema = get_namespace_name_or_temp(formTmpl->tmplnamespace); appendStringInfoString(&buffer, quote_qualified_identifier(schema, NameStr(formTmpl->tmplname))); if (objname) *objname = list_make2(schema, pstrdup(NameStr(formTmpl->tmplname))); ReleaseSysCache(tup); break; } case TSConfigRelationId: { HeapTuple tup; Form_pg_ts_config formCfg; char *schema; tup = SearchSysCache1(TSCONFIGOID, ObjectIdGetDatum(object->objectId)); if (!HeapTupleIsValid(tup)) { if (!missing_ok) elog(ERROR, "cache lookup failed for text search configuration %u", object->objectId); break; } formCfg = (Form_pg_ts_config) GETSTRUCT(tup); schema = get_namespace_name_or_temp(formCfg->cfgnamespace); appendStringInfoString(&buffer, quote_qualified_identifier(schema, NameStr(formCfg->cfgname))); if (objname) *objname = list_make2(schema, pstrdup(NameStr(formCfg->cfgname))); ReleaseSysCache(tup); break; } case AuthIdRelationId: { char *username; username = GetUserNameFromId(object->objectId, missing_ok); if (!username) break; if (objname) *objname = list_make1(username); appendStringInfoString(&buffer, quote_identifier(username)); break; } case AuthMemRelationId: { Relation authMemDesc; ScanKeyData skey[1]; SysScanDesc amscan; HeapTuple tup; Form_pg_auth_members amForm; authMemDesc = table_open(AuthMemRelationId, AccessShareLock); ScanKeyInit(&skey[0], Anum_pg_auth_members_oid, BTEqualStrategyNumber, F_OIDEQ, ObjectIdGetDatum(object->objectId)); amscan = systable_beginscan(authMemDesc, AuthMemOidIndexId, true, NULL, 1, skey); tup = systable_getnext(amscan); if (!HeapTupleIsValid(tup)) { if (!missing_ok) elog(ERROR, "could not find tuple for pg_auth_members entry %u", object->objectId); systable_endscan(amscan); table_close(authMemDesc, AccessShareLock); break; } amForm = (Form_pg_auth_members) GETSTRUCT(tup); appendStringInfo(&buffer, _("membership of role %s in role %s"), GetUserNameFromId(amForm->member, false), GetUserNameFromId(amForm->roleid, false)); systable_endscan(amscan); table_close(authMemDesc, AccessShareLock); break; } case DatabaseRelationId: { char *datname; datname = get_database_name(object->objectId); if (!datname) { if (!missing_ok) elog(ERROR, "cache lookup failed for database %u", object->objectId); break; } if (objname) *objname = list_make1(datname); appendStringInfoString(&buffer, quote_identifier(datname)); break; } case TableSpaceRelationId: { char *tblspace; tblspace = get_tablespace_name(object->objectId); if (!tblspace) { if (!missing_ok) elog(ERROR, "cache lookup failed for tablespace %u", object->objectId); break; } if (objname) *objname = list_make1(tblspace); appendStringInfoString(&buffer, quote_identifier(tblspace)); break; } case ForeignDataWrapperRelationId: { ForeignDataWrapper *fdw; fdw = GetForeignDataWrapperExtended(object->objectId, missing_ok); if (fdw) { appendStringInfoString(&buffer, quote_identifier(fdw->fdwname)); if (objname) *objname = list_make1(pstrdup(fdw->fdwname)); } break; } case ForeignServerRelationId: { ForeignServer *srv; srv = GetForeignServerExtended(object->objectId, missing_ok); if (srv) { appendStringInfoString(&buffer, quote_identifier(srv->servername)); if (objname) *objname = list_make1(pstrdup(srv->servername)); } break; } case UserMappingRelationId: { HeapTuple tup; Oid useid; Form_pg_user_mapping umform; ForeignServer *srv; const char *usename; tup = SearchSysCache1(USERMAPPINGOID, ObjectIdGetDatum(object->objectId)); if (!HeapTupleIsValid(tup)) { if (!missing_ok) elog(ERROR, "cache lookup failed for user mapping %u", object->objectId); break; } umform = (Form_pg_user_mapping) GETSTRUCT(tup); useid = umform->umuser; srv = GetForeignServer(umform->umserver); ReleaseSysCache(tup); if (OidIsValid(useid)) usename = GetUserNameFromId(useid, false); else usename = "public"; if (objname) { *objname = list_make1(pstrdup(usename)); *objargs = list_make1(pstrdup(srv->servername)); } appendStringInfo(&buffer, "%s on server %s", quote_identifier(usename), srv->servername); break; } case DefaultAclRelationId: { Relation defaclrel; ScanKeyData skey[1]; SysScanDesc rcscan; HeapTuple tup; Form_pg_default_acl defacl; char *schema; char *username; defaclrel = table_open(DefaultAclRelationId, AccessShareLock); ScanKeyInit(&skey[0], Anum_pg_default_acl_oid, BTEqualStrategyNumber, F_OIDEQ, ObjectIdGetDatum(object->objectId)); rcscan = systable_beginscan(defaclrel, DefaultAclOidIndexId, true, NULL, 1, skey); tup = systable_getnext(rcscan); if (!HeapTupleIsValid(tup)) { if (!missing_ok) elog(ERROR, "could not find tuple for default ACL %u", object->objectId); systable_endscan(rcscan); table_close(defaclrel, AccessShareLock); break; } defacl = (Form_pg_default_acl) GETSTRUCT(tup); username = GetUserNameFromId(defacl->defaclrole, false); appendStringInfo(&buffer, "for role %s", quote_identifier(username)); if (OidIsValid(defacl->defaclnamespace)) { schema = get_namespace_name_or_temp(defacl->defaclnamespace); appendStringInfo(&buffer, " in schema %s", quote_identifier(schema)); } else schema = NULL; switch (defacl->defaclobjtype) { case DEFACLOBJ_RELATION: appendStringInfoString(&buffer, " on tables"); break; case DEFACLOBJ_SEQUENCE: appendStringInfoString(&buffer, " on sequences"); break; case DEFACLOBJ_FUNCTION: appendStringInfoString(&buffer, " on functions"); break; case DEFACLOBJ_TYPE: appendStringInfoString(&buffer, " on types"); break; case DEFACLOBJ_NAMESPACE: appendStringInfoString(&buffer, " on schemas"); break; case DEFACLOBJ_LARGEOBJECT: appendStringInfoString(&buffer, " on large objects"); break; } if (objname) { *objname = list_make1(username); if (schema) *objname = lappend(*objname, schema); *objargs = list_make1(psprintf("%c", defacl->defaclobjtype)); } systable_endscan(rcscan); table_close(defaclrel, AccessShareLock); break; } case ExtensionRelationId: { char *extname; extname = get_extension_name(object->objectId); if (!extname) { if (!missing_ok) elog(ERROR, "cache lookup failed for extension %u", object->objectId); break; } appendStringInfoString(&buffer, quote_identifier(extname)); if (objname) *objname = list_make1(extname); break; } case EventTriggerRelationId: { HeapTuple tup; Form_pg_event_trigger trigForm; char *evtname; tup = SearchSysCache1(EVENTTRIGGEROID, ObjectIdGetDatum(object->objectId)); if (!HeapTupleIsValid(tup)) { if (!missing_ok) elog(ERROR, "cache lookup failed for event trigger %u", object->objectId); break; } trigForm = (Form_pg_event_trigger) GETSTRUCT(tup); evtname = pstrdup(NameStr(trigForm->evtname)); appendStringInfoString(&buffer, quote_identifier(evtname)); if (objname) *objname = list_make1(evtname); ReleaseSysCache(tup); break; } case ParameterAclRelationId: { HeapTuple tup; Datum nameDatum; char *parname; tup = SearchSysCache1(PARAMETERACLOID, ObjectIdGetDatum(object->objectId)); if (!HeapTupleIsValid(tup)) { if (!missing_ok) elog(ERROR, "cache lookup failed for parameter ACL %u", object->objectId); break; } nameDatum = SysCacheGetAttrNotNull(PARAMETERACLOID, tup, Anum_pg_parameter_acl_parname); parname = TextDatumGetCString(nameDatum); appendStringInfoString(&buffer, parname); if (objname) *objname = list_make1(parname); ReleaseSysCache(tup); break; } case PolicyRelationId: { Relation polDesc; HeapTuple tup; Form_pg_policy policy; polDesc = table_open(PolicyRelationId, AccessShareLock); tup = get_catalog_object_by_oid(polDesc, Anum_pg_policy_oid, object->objectId); if (!HeapTupleIsValid(tup)) { if (!missing_ok) elog(ERROR, "could not find tuple for policy %u", object->objectId); table_close(polDesc, AccessShareLock); break; } policy = (Form_pg_policy) GETSTRUCT(tup); appendStringInfo(&buffer, "%s on ", quote_identifier(NameStr(policy->polname))); getRelationIdentity(&buffer, policy->polrelid, objname, false); if (objname) *objname = lappend(*objname, pstrdup(NameStr(policy->polname))); table_close(polDesc, AccessShareLock); break; } case PublicationRelationId: { char *pubname; pubname = get_publication_name(object->objectId, missing_ok); if (pubname) { appendStringInfoString(&buffer, quote_identifier(pubname)); if (objname) *objname = list_make1(pubname); } break; } case PublicationNamespaceRelationId: { char *pubname; char *nspname; if (!getPublicationSchemaInfo(object, missing_ok, &pubname, &nspname)) break; appendStringInfo(&buffer, "%s in publication %s", nspname, pubname); if (objargs) *objargs = list_make1(pubname); else pfree(pubname); if (objname) *objname = list_make1(nspname); else pfree(nspname); break; } case PublicationRelRelationId: { HeapTuple tup; char *pubname; Form_pg_publication_rel prform; tup = SearchSysCache1(PUBLICATIONREL, ObjectIdGetDatum(object->objectId)); if (!HeapTupleIsValid(tup)) { if (!missing_ok) elog(ERROR, "cache lookup failed for publication table %u", object->objectId); break; } prform = (Form_pg_publication_rel) GETSTRUCT(tup); pubname = get_publication_name(prform->prpubid, false); getRelationIdentity(&buffer, prform->prrelid, objname, false); appendStringInfo(&buffer, " in publication %s", pubname); if (objargs) *objargs = list_make1(pubname); ReleaseSysCache(tup); break; } case SubscriptionRelationId: { char *subname; subname = get_subscription_name(object->objectId, missing_ok); if (subname) { appendStringInfoString(&buffer, quote_identifier(subname)); if (objname) *objname = list_make1(subname); } break; } case TransformRelationId: { Relation transformDesc; HeapTuple tup; Form_pg_transform transform; char *transformLang; char *transformType; transformDesc = table_open(TransformRelationId, AccessShareLock); tup = get_catalog_object_by_oid(transformDesc, Anum_pg_transform_oid, object->objectId); if (!HeapTupleIsValid(tup)) { if (!missing_ok) elog(ERROR, "could not find tuple for transform %u", object->objectId); table_close(transformDesc, AccessShareLock); break; } transform = (Form_pg_transform) GETSTRUCT(tup); transformType = format_type_be_qualified(transform->trftype); transformLang = get_language_name(transform->trflang, false); appendStringInfo(&buffer, "for %s language %s", transformType, transformLang); if (objname) { *objname = list_make1(transformType); *objargs = list_make1(pstrdup(transformLang)); } table_close(transformDesc, AccessShareLock); } break; default: elog(ERROR, "unsupported object class: %u", object->classId); } if (!missing_ok) { /* * If a get_object_address() representation was requested, make sure * we are providing one. We don't check objargs, because many of the * cases above leave it as NIL. */ if (objname && *objname == NIL) elog(ERROR, "requested object address for unsupported object class %u: text result \"%s\"", object->classId, buffer.data); } else { /* an empty buffer is equivalent to no object found */ if (buffer.len == 0) { Assert((objname == NULL || *objname == NIL) && (objargs == NULL || *objargs == NIL)); return NULL; } } return buffer.data; } static void getOpFamilyIdentity(StringInfo buffer, Oid opfid, List **object, bool missing_ok) { HeapTuple opfTup; Form_pg_opfamily opfForm; HeapTuple amTup; Form_pg_am amForm; char *schema; opfTup = SearchSysCache1(OPFAMILYOID, ObjectIdGetDatum(opfid)); if (!HeapTupleIsValid(opfTup)) { if (!missing_ok) elog(ERROR, "cache lookup failed for opfamily %u", opfid); return; } opfForm = (Form_pg_opfamily) GETSTRUCT(opfTup); amTup = SearchSysCache1(AMOID, ObjectIdGetDatum(opfForm->opfmethod)); if (!HeapTupleIsValid(amTup)) elog(ERROR, "cache lookup failed for access method %u", opfForm->opfmethod); amForm = (Form_pg_am) GETSTRUCT(amTup); schema = get_namespace_name_or_temp(opfForm->opfnamespace); appendStringInfo(buffer, "%s USING %s", quote_qualified_identifier(schema, NameStr(opfForm->opfname)), NameStr(amForm->amname)); if (object) *object = list_make3(pstrdup(NameStr(amForm->amname)), pstrdup(schema), pstrdup(NameStr(opfForm->opfname))); ReleaseSysCache(amTup); ReleaseSysCache(opfTup); } /* * Append the relation identity (quoted qualified name) to the given * StringInfo. */ static void getRelationIdentity(StringInfo buffer, Oid relid, List **object, bool missing_ok) { HeapTuple relTup; Form_pg_class relForm; char *schema; relTup = SearchSysCache1(RELOID, ObjectIdGetDatum(relid)); if (!HeapTupleIsValid(relTup)) { if (!missing_ok) elog(ERROR, "cache lookup failed for relation %u", relid); if (object) *object = NIL; return; } relForm = (Form_pg_class) GETSTRUCT(relTup); schema = get_namespace_name_or_temp(relForm->relnamespace); appendStringInfoString(buffer, quote_qualified_identifier(schema, NameStr(relForm->relname))); if (object) *object = list_make2(schema, pstrdup(NameStr(relForm->relname))); ReleaseSysCache(relTup); } /* * Auxiliary function to build a TEXT array out of a list of C-strings. */ ArrayType * strlist_to_textarray(List *list) { ArrayType *arr; Datum *datums; bool *nulls; int j = 0; ListCell *cell; MemoryContext memcxt; MemoryContext oldcxt; int lb[1]; /* Work in a temp context; easier than individually pfree'ing the Datums */ memcxt = AllocSetContextCreate(CurrentMemoryContext, "strlist to array", ALLOCSET_DEFAULT_SIZES); oldcxt = MemoryContextSwitchTo(memcxt); datums = (Datum *) palloc(sizeof(Datum) * list_length(list)); nulls = palloc(sizeof(bool) * list_length(list)); foreach(cell, list) { char *name = lfirst(cell); if (name) { nulls[j] = false; datums[j++] = CStringGetTextDatum(name); } else nulls[j] = true; } MemoryContextSwitchTo(oldcxt); lb[0] = 1; arr = construct_md_array(datums, nulls, 1, &j, lb, TEXTOID, -1, false, TYPALIGN_INT); MemoryContextDelete(memcxt); return arr; } /* * get_relkind_objtype * * Return the object type for the relkind given by the caller. * * If an unexpected relkind is passed, we say OBJECT_TABLE rather than * failing. That's because this is mostly used for generating error messages * for failed ACL checks on relations, and we'd rather produce a generic * message saying "table" than fail entirely. */ ObjectType get_relkind_objtype(char relkind) { switch (relkind) { case RELKIND_RELATION: case RELKIND_PARTITIONED_TABLE: return OBJECT_TABLE; case RELKIND_INDEX: case RELKIND_PARTITIONED_INDEX: return OBJECT_INDEX; case RELKIND_SEQUENCE: return OBJECT_SEQUENCE; case RELKIND_VIEW: return OBJECT_VIEW; case RELKIND_MATVIEW: return OBJECT_MATVIEW; case RELKIND_FOREIGN_TABLE: return OBJECT_FOREIGN_TABLE; case RELKIND_TOASTVALUE: return OBJECT_TABLE; default: /* Per above, don't raise an error */ return OBJECT_TABLE; } }