#include "access/htup.h"
#include "nodes/parsenodes.h"
#include "storage/lockdefs.h"
#include "utils/relcache.h"

Include dependency graph for objectaddress.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	ObjectAddress

Macros
#define	ObjectAddressSubSet(addr, class_id, object_id, object_sub_id)

#define	ObjectAddressSet(addr, class_id, object_id) ObjectAddressSubSet(addr, class_id, object_id, 0)

Typedefs
typedef struct ObjectAddress	ObjectAddress

Functions
ObjectAddress	get_object_address (ObjectType objtype, Node object, Relation relp, LOCKMODE lockmode, bool missing_ok)

ObjectAddress	get_object_address_rv (ObjectType objtype, RangeVar rel, List object, Relation *relp, LOCKMODE lockmode, bool missing_ok)

void	check_object_ownership (Oid roleid, ObjectType objtype, ObjectAddress address, Node *object, Relation relation)

Oid	get_object_namespace (const ObjectAddress *address)

bool	is_objectclass_supported (Oid class_id)

const char *	get_object_class_descr (Oid class_id)

Oid	get_object_oid_index (Oid class_id)

int	get_object_catcache_oid (Oid class_id)

int	get_object_catcache_name (Oid class_id)

AttrNumber	get_object_attnum_oid (Oid class_id)

AttrNumber	get_object_attnum_name (Oid class_id)

AttrNumber	get_object_attnum_namespace (Oid class_id)

AttrNumber	get_object_attnum_owner (Oid class_id)

AttrNumber	get_object_attnum_acl (Oid class_id)

ObjectType	get_object_type (Oid class_id, Oid object_id)

bool	get_object_namensp_unique (Oid class_id)

HeapTuple	get_catalog_object_by_oid (Relation catalog, AttrNumber oidcol, Oid objectId)

char *	getObjectDescription (const ObjectAddress *object, bool missing_ok)

char *	getObjectDescriptionOids (Oid classid, Oid objid)

int	read_objtype_from_string (const char *objtype)

char *	getObjectTypeDescription (const ObjectAddress *object, bool missing_ok)

char *	getObjectIdentity (const ObjectAddress *object, bool missing_ok)

char *	getObjectIdentityParts (const ObjectAddress object, List objname, List *objargs, bool missing_ok)

struct ArrayType *	strlist_to_textarray (List *list)

ObjectType	get_relkind_objtype (char relkind)

Variables
PGDLLIMPORT const ObjectAddress	InvalidObjectAddress

Macro Definition Documentation

◆ ObjectAddressSet

#define ObjectAddressSet	(	addr,
		class_id,
		object_id
	)	ObjectAddressSubSet(addr, class_id, object_id, 0)

Definition at line 40 of file objectaddress.h.

◆ ObjectAddressSubSet

#define ObjectAddressSubSet	(	addr,
		class_id,
		object_id,
		object_sub_id
	)

Value:

    do { \
        (addr).classId = (class_id); \
        (addr).objectId = (object_id); \
        (addr).objectSubId = (object_sub_id); \
    } while (0)

Definition at line 33 of file objectaddress.h.

Typedef Documentation

◆ ObjectAddress

typedef struct ObjectAddress ObjectAddress

Function Documentation

◆ check_object_ownership()

void check_object_ownership	(	Oid	roleid,
		ObjectType	objtype,
		ObjectAddress	address,
		Node *	object,
		Relation	relation
	)

Definition at line 2382 of file objectaddress.c.

 {
     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;
     }
 }

References aclcheck_error(), aclcheck_error_type(), ACLCHECK_NOT_OWNER, castNode, ObjectAddress::classId, elog, ereport, errcode(), errdetail(), errmsg(), ERROR, format_type_be(), GETSTRUCT, GetUserNameFromId(), has_createrole_privilege(), HeapTupleIsValid, is_admin_of_role(), linitial_node, lo_compat_privileges, lsecond_node, NameListToString(), OBJECT_ACCESS_METHOD, OBJECT_AGGREGATE, OBJECT_AMOP, OBJECT_AMPROC, OBJECT_ATTRIBUTE, OBJECT_CAST, OBJECT_COLLATION, OBJECT_COLUMN, OBJECT_CONVERSION, OBJECT_DATABASE, OBJECT_DEFACL, OBJECT_DEFAULT, OBJECT_DOMAIN, OBJECT_DOMCONSTRAINT, OBJECT_EVENT_TRIGGER, OBJECT_EXTENSION, OBJECT_FDW, OBJECT_FOREIGN_SERVER, OBJECT_FOREIGN_TABLE, OBJECT_FUNCTION, OBJECT_INDEX, OBJECT_LANGUAGE, OBJECT_LARGEOBJECT, OBJECT_MATVIEW, OBJECT_OPCLASS, OBJECT_OPERATOR, OBJECT_OPFAMILY, object_ownercheck(), OBJECT_PARAMETER_ACL, OBJECT_POLICY, OBJECT_PROCEDURE, OBJECT_PUBLICATION, OBJECT_PUBLICATION_NAMESPACE, OBJECT_PUBLICATION_REL, OBJECT_ROLE, OBJECT_ROUTINE, OBJECT_RULE, OBJECT_SCHEMA, OBJECT_SEQUENCE, OBJECT_STATISTIC_EXT, OBJECT_SUBSCRIPTION, OBJECT_TABCONSTRAINT, OBJECT_TABLE, OBJECT_TABLESPACE, OBJECT_TRANSFORM, OBJECT_TRIGGER, OBJECT_TSCONFIGURATION, OBJECT_TSDICTIONARY, OBJECT_TSPARSER, OBJECT_TSTEMPLATE, OBJECT_TYPE, OBJECT_USER_MAPPING, OBJECT_VIEW, ObjectAddress::objectId, ObjectIdGetDatum(), RelationGetRelationName, RelationGetRelid, ReleaseSysCache(), SearchSysCache1(), strVal, superuser_arg(), and typenameTypeId().

Referenced by CommentObject(), ExecAlterExtensionContentsStmt(), ExecAlterObjectDependsStmt(), ExecSecLabelStmt(), and RemoveObjects().

◆ get_catalog_object_by_oid()

HeapTuple get_catalog_object_by_oid	(	Relation	catalog,
		AttrNumber	oidcol,
		Oid	objectId
	)

Definition at line 2781 of file objectaddress.c.

 {
     HeapTuple   tuple;
     Oid         classId = RelationGetRelid(catalog);
     int         oidCacheId = get_object_catcache_oid(classId);
  
     if (oidCacheId > 0)
     {
         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;
         }
         tuple = heap_copytuple(tuple);
  
         systable_endscan(scan);
     }
  
     return tuple;
 }

References Assert, BTEqualStrategyNumber, get_object_catcache_oid(), get_object_oid_index(), heap_copytuple(), HeapTupleIsValid, ObjectIdGetDatum(), OidIsValid, RelationGetRelid, ScanKeyInit(), SearchSysCacheCopy1, systable_beginscan(), systable_endscan(), and systable_getnext().

Referenced by AlterObjectOwner_internal(), EventTriggerSQLDropAddObject(), getConstraintTypeDescription(), getObjectIdentityParts(), pg_event_trigger_ddl_commands(), pg_get_acl(), and pg_identify_object().

◆ get_object_address()

ObjectAddress get_object_address	(	ObjectType	objtype,
		Node *	object,
		Relation *	relp,
		LOCKMODE	lockmode,
		bool	missing_ok
	)

Definition at line 922 of file objectaddress.c.

 {
     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;
     }
  
     /* Return the object address and the relation. */
     *relp = relation;
     return address;
 }

Referenced by CommentObject(), ExecAlterExtensionContentsStmt(), ExecAlterObjectDependsStmt(), ExecAlterObjectSchemaStmt(), ExecAlterOwnerStmt(), ExecRenameStmt(), ExecSecLabelStmt(), get_object_address_rv(), pg_get_object_address(), and RemoveObjects().

◆ get_object_address_rv()

ObjectAddress get_object_address_rv	(	ObjectType	objtype,
		RangeVar *	rel,
		List *	object,
		Relation *	relp,
		LOCKMODE	lockmode,
		bool	missing_ok
	)

Definition at line 1220 of file objectaddress.c.

 {
     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);
 }

References RangeVar::catalogname, get_object_address(), lcons(), makeString(), RangeVar::relname, and RangeVar::schemaname.

Referenced by ExecAlterObjectDependsStmt().

◆ get_object_attnum_acl()

AttrNumber get_object_attnum_acl ( Oid class_id )

Definition at line 2684 of file objectaddress.c.

 {
     const ObjectPropertyType *prop = get_object_property_data(class_id);
  
     return prop->attnum_acl;
 }

References ObjectPropertyType::attnum_acl, and get_object_property_data().

Referenced by AlterObjectOwner_internal(), ExecGrant_common(), object_aclmask_ext(), pg_get_acl(), and recordExtObjInitPriv().

◆ get_object_attnum_name()

AttrNumber get_object_attnum_name ( Oid class_id )

Definition at line 2660 of file objectaddress.c.

 {
     const ObjectPropertyType *prop = get_object_property_data(class_id);
  
     return prop->attnum_name;
 }

References ObjectPropertyType::attnum_name, and get_object_property_data().

Referenced by AlterObjectNamespace_internal(), AlterObjectOwner_internal(), AlterObjectRename_internal(), EventTriggerSQLDropAddObject(), ExecGrant_common(), and pg_identify_object().

◆ get_object_attnum_namespace()

AttrNumber get_object_attnum_namespace ( Oid class_id )

Definition at line 2668 of file objectaddress.c.

 {
     const ObjectPropertyType *prop = get_object_property_data(class_id);
  
     return prop->attnum_namespace;
 }

References ObjectPropertyType::attnum_namespace, and get_object_property_data().

Referenced by AlterObjectNamespace_internal(), AlterObjectNamespace_oid(), AlterObjectOwner_internal(), AlterObjectRename_internal(), EventTriggerSQLDropAddObject(), pg_event_trigger_ddl_commands(), and pg_identify_object().

◆ get_object_attnum_oid()

AttrNumber get_object_attnum_oid ( Oid class_id )

Definition at line 2652 of file objectaddress.c.

 {
     const ObjectPropertyType *prop = get_object_property_data(class_id);
  
     return prop->attnum_oid;
 }

References ObjectPropertyType::attnum_oid, and get_object_property_data().

Referenced by AlterObjectOwner_internal(), DropObjectById(), EventTriggerSQLDropAddObject(), object_ownercheck(), pg_event_trigger_ddl_commands(), pg_get_acl(), and pg_identify_object().

◆ get_object_attnum_owner()

AttrNumber get_object_attnum_owner ( Oid class_id )

Definition at line 2676 of file objectaddress.c.

 {
     const ObjectPropertyType *prop = get_object_property_data(class_id);
  
     return prop->attnum_owner;
 }

References ObjectPropertyType::attnum_owner, and get_object_property_data().

Referenced by AlterObjectNamespace_internal(), AlterObjectOwner_internal(), AlterObjectRename_internal(), ExecGrant_common(), object_aclmask_ext(), object_ownercheck(), and RemoveRoleFromInitPriv().

◆ get_object_catcache_name()

int get_object_catcache_name ( Oid class_id )

Definition at line 2644 of file objectaddress.c.

 {
     const ObjectPropertyType *prop = get_object_property_data(class_id);
  
     return prop->name_catcache_id;
 }

References get_object_property_data(), and ObjectPropertyType::name_catcache_id.

Referenced by AlterObjectNamespace_internal(), and AlterObjectRename_internal().

◆ get_object_catcache_oid()

int get_object_catcache_oid ( Oid class_id )

Definition at line 2636 of file objectaddress.c.

 {
     const ObjectPropertyType *prop = get_object_property_data(class_id);
  
     return prop->oid_catcache_id;
 }

References get_object_property_data(), and ObjectPropertyType::oid_catcache_id.

Referenced by AlterObjectNamespace_internal(), AlterObjectRename_internal(), DropObjectById(), ExecGrant_common(), get_catalog_object_by_oid(), object_aclmask_ext(), object_ownercheck(), recordExtObjInitPriv(), and RemoveRoleFromInitPriv().

◆ get_object_class_descr()

const char* get_object_class_descr ( Oid class_id )

Definition at line 2620 of file objectaddress.c.

 {
     const ObjectPropertyType *prop = get_object_property_data(class_id);
  
     return prop->class_descr;
 }

References ObjectPropertyType::class_descr, and get_object_property_data().

Referenced by DropObjectById(), ExecGrant_common(), object_aclmask_ext(), object_ownercheck(), recordExtObjInitPriv(), and RemoveRoleFromInitPriv().

◆ get_object_namensp_unique()

bool get_object_namensp_unique ( Oid class_id )

Definition at line 2717 of file objectaddress.c.

 {
     const ObjectPropertyType *prop = get_object_property_data(class_id);
  
     return prop->is_nsp_name_unique;
 }

References get_object_property_data(), and ObjectPropertyType::is_nsp_name_unique.

Referenced by EventTriggerSQLDropAddObject(), and pg_identify_object().

◆ get_object_namespace()

Oid get_object_namespace ( const ObjectAddress * address )

Definition at line 2564 of file objectaddress.c.

 {
     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;
 }

References Assert, ObjectPropertyType::attnum_namespace, ObjectAddress::classId, DatumGetObjectId(), elog, ERROR, get_object_property_data(), HeapTupleIsValid, InvalidAttrNumber, InvalidOid, ObjectAddress::objectId, ObjectIdGetDatum(), ReleaseSysCache(), SearchSysCache1(), and SysCacheGetAttrNotNull().

Referenced by RemoveObjects().

◆ get_object_oid_index()

Oid get_object_oid_index ( Oid class_id )

Definition at line 2628 of file objectaddress.c.

 {
     const ObjectPropertyType *prop = get_object_property_data(class_id);
  
     return prop->oid_index_oid;
 }

References get_object_property_data(), and ObjectPropertyType::oid_index_oid.

Referenced by DropObjectById(), get_catalog_object_by_oid(), and object_ownercheck().

◆ get_object_type()

ObjectType get_object_type	(	Oid	class_id,
		Oid	object_id
	)

Definition at line 2699 of file objectaddress.c.

 {
     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;
 }

References get_object_property_data(), get_rel_relkind(), get_relkind_objtype(), OBJECT_TABLE, and ObjectPropertyType::objtype.

Referenced by AlterObjectNamespace_internal(), AlterObjectOwner_internal(), AlterObjectRename_internal(), ExecGrant_common(), and object_aclmask_ext().

◆ get_relkind_objtype()

ObjectType get_relkind_objtype ( char relkind )

Definition at line 6126 of file objectaddress.c.

 {
     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;
     }
 }

References OBJECT_FOREIGN_TABLE, OBJECT_INDEX, OBJECT_MATVIEW, OBJECT_SEQUENCE, OBJECT_TABLE, and OBJECT_VIEW.

Referenced by AlterTableMoveAll(), ATExecChangeOwner(), ATSimplePermissions(), checkFkeyPermissions(), checkPartition(), CreateStatistics(), CreateTriggerFiringOn(), currtid_internal(), DefineQueryRewrite(), EnableDisableRule(), ExecCheckPermissions(), get_object_type(), get_rel_from_relname(), heap_force_common(), LockViewRecurse_walker(), LogicalRepSyncTableStart(), MergeAttributes(), pg_prewarm(), pgrowlocks(), PublicationAddTables(), RangeVarCallbackForAlterRelation(), RangeVarCallbackForDropRelation(), RangeVarCallbackForLockTable(), RangeVarCallbackForPolicy(), RangeVarCallbackForRenameRule(), RangeVarCallbackForRenameTrigger(), RangeVarCallbackMaintainsTable(), RangeVarCallbackOwnsRelation(), RangeVarGetAndCheckCreationNamespace(), renameatt_check(), TargetPrivilegesCheck(), transformTableLikeClause(), and truncate_check_perms().

◆ getObjectDescription()

char* getObjectDescription	(	const ObjectAddress *	object,
		bool	missing_ok
	)

Definition at line 2878 of file objectaddress.c.

 {
     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);
  
                 /*------
                    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_be(amopForm->amoplefttype),
                                  format_type_be(amopForm->amoprighttype),
                                  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);
  
                 /*------
                    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_be(amprocForm->amproclefttype),
                                  format_type_be(amprocForm->amprocrighttype),
                                  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;
                     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;
 }

References _, AccessShareLock, appendStringInfo(), Assert, attname, BTEqualStrategyNumber, ObjectAddress::classId, CollationIsVisible(), ConversionIsVisible(), StringInfoData::data, datname, elog, ERROR, ForeignDataWrapper::fdwname, format_operator(), format_operator_extended(), FORMAT_OPERATOR_INVALID_AS_NULL, FORMAT_PROC_INVALID_AS_NULL, format_procedure(), format_procedure_extended(), format_type_be(), format_type_extended(), FORMAT_TYPE_INVALID_AS_NULL, get_attname(), get_database_name(), get_extension_name(), get_language_name(), get_namespace_name(), get_publication_name(), get_subscription_name(), get_tablespace_name(), GetAttrDefaultColumnAddress(), GetForeignDataWrapperExtended(), GetForeignServer(), GetForeignServerExtended(), getOpFamilyDescription(), getPublicationSchemaInfo(), getRelationDescription(), GETSTRUCT, GetUserNameFromId(), HeapTupleIsValid, initStringInfo(), LargeObjectExists(), StringInfoData::len, NameStr, ObjectAddress::objectId, ObjectIdGetDatum(), ObjectAddress::objectSubId, OidIsValid, OpclassIsVisible(), pfree(), proname, quote_qualified_identifier(), ReleaseSysCache(), ScanKeyInit(), SearchSysCache1(), ForeignServer::servername, StatisticsObjIsVisible(), subname, SysCacheGetAttrNotNull(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), table_open(), TextDatumGetCString, TSConfigIsVisible(), TSDictionaryIsVisible(), TSParserIsVisible(), TSTemplateIsVisible(), typname, and username.

Referenced by AlterExtensionNamespace(), ATExecAlterColumnType(), changeDependenciesOn(), check_relation_privileges(), checkMembershipInCurrentExtension(), checkSharedDependencies(), ExecAlterExtensionContentsRecurse(), findDependentObjects(), get_altertable_subcmdinfo(), get_object_address_opf_member(), getObjectDescriptionOids(), pg_describe_object(), recordDependencyOnCurrentExtension(), RememberAllDependentForRebuilding(), reportDependentObjects(), sepgsql_fmgr_hook(), shdepDropOwned(), shdepReassignOwned(), and storeObjectDescription().

◆ getObjectDescriptionOids()

char* getObjectDescriptionOids	(	Oid	classid,
		Oid	objid
	)

Definition at line 4030 of file objectaddress.c.

 {
     ObjectAddress address;
  
     address.classId = classid;
     address.objectId = objid;
     address.objectSubId = 0;
  
     return getObjectDescription(&address, false);
 }

References ObjectAddress::classId, getObjectDescription(), ObjectAddress::objectId, and ObjectAddress::objectSubId.

Referenced by AlterObjectNamespace_internal(), and AlterObjectRename_internal().

◆ getObjectIdentity()

char* getObjectIdentity	(	const ObjectAddress *	object,
		bool	missing_ok
	)

Definition at line 4768 of file objectaddress.c.

 {
     return getObjectIdentityParts(object, NULL, NULL, missing_ok);
 }

References getObjectIdentityParts().

Referenced by check_relation_privileges(), check_schema_perms(), pg_event_trigger_ddl_commands(), pg_identify_object(), sepgsql_attribute_drop(), sepgsql_attribute_post_create(), sepgsql_attribute_relabel(), sepgsql_attribute_setattr(), sepgsql_database_drop(), sepgsql_database_relabel(), sepgsql_database_setattr(), sepgsql_proc_drop(), sepgsql_proc_execute(), sepgsql_proc_post_create(), sepgsql_proc_relabel(), sepgsql_proc_setattr(), sepgsql_relation_drop(), sepgsql_relation_post_create(), sepgsql_relation_relabel(), sepgsql_relation_setattr(), sepgsql_relation_truncate(), sepgsql_schema_drop(), and sepgsql_schema_relabel().

◆ getObjectIdentityParts()

char* getObjectIdentityParts	(	const ObjectAddress *	object,
		List **	objname,
		List **	objargs,
		bool	missing_ok
	)

Definition at line 4783 of file objectaddress.c.

 {
     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;
                 }
  
                 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;
 }

References _, AccessShareLock, appendStringInfo(), appendStringInfoString(), Assert, BTEqualStrategyNumber, ObjectAddress::classId, StringInfoData::data, datname, elog, ERROR, ForeignDataWrapper::fdwname, format_operator_extended(), FORMAT_OPERATOR_FORCE_QUALIFY, FORMAT_OPERATOR_INVALID_AS_NULL, format_operator_parts(), FORMAT_PROC_FORCE_QUALIFY, FORMAT_PROC_INVALID_AS_NULL, format_procedure_extended(), format_procedure_parts(), format_type_be_qualified(), format_type_extended(), FORMAT_TYPE_FORCE_QUALIFY, FORMAT_TYPE_INVALID_AS_NULL, get_am_name(), get_attname(), get_catalog_object_by_oid(), get_database_name(), get_extension_name(), get_language_name(), get_namespace_name_or_temp(), get_publication_name(), get_subscription_name(), get_tablespace_name(), GetAttrDefaultColumnAddress(), GetForeignDataWrapperExtended(), GetForeignServer(), GetForeignServerExtended(), getOpFamilyIdentity(), getPublicationSchemaInfo(), getRelationIdentity(), GETSTRUCT, GetUserNameFromId(), HeapTupleIsValid, initStringInfo(), lappend(), LargeObjectExists(), StringInfoData::len, list_make1, list_make2, list_make3, NameStr, NIL, ObjectAddress::objectId, ObjectIdGetDatum(), ObjectAddress::objectSubId, OidIsValid, pfree(), PointerIsValid, proname, psprintf(), pstrdup(), quote_identifier(), quote_qualified_identifier(), ReleaseSysCache(), ScanKeyInit(), SearchSysCache1(), ForeignServer::servername, subname, SysCacheGetAttrNotNull(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), table_open(), TextDatumGetCString, and username.

Referenced by EventTriggerSQLDropAddObject(), getObjectIdentity(), and pg_identify_object_as_address().

◆ getObjectTypeDescription()

char* getObjectTypeDescription	(	const ObjectAddress *	object,
		bool	missing_ok
	)

Definition at line 4441 of file objectaddress.c.

 {
     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;
 }

References appendStringInfoString(), Assert, ObjectAddress::classId, StringInfoData::data, elog, ERROR, getConstraintTypeDescription(), getProcedureTypeDescription(), getRelationTypeDescription(), initStringInfo(), StringInfoData::len, ObjectAddress::objectId, and ObjectAddress::objectSubId.

Referenced by EventTriggerSQLDropAddObject(), pg_event_trigger_ddl_commands(), pg_identify_object(), pg_identify_object_as_address(), and sepgsql_object_relabel().

◆ is_objectclass_supported()

bool is_objectclass_supported ( Oid class_id )

Definition at line 2729 of file objectaddress.c.

 {
     int         index;
  
     for (index = 0; index < lengthof(ObjectProperty); index++)
     {
         if (ObjectProperty[index].class_oid == class_id)
             return true;
     }
  
     return false;
 }

References lengthof, and ObjectProperty.

Referenced by EventTriggerSQLDropAddObject(), pg_event_trigger_ddl_commands(), and pg_identify_object().

◆ read_objtype_from_string()

int read_objtype_from_string ( const char * objtype )

Definition at line 2600 of file objectaddress.c.

 {
     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 */
 }

References ereport, errcode(), errmsg(), ERROR, i, lengthof, and ObjectTypeMap.

Referenced by pg_get_object_address().

◆ strlist_to_textarray()

struct ArrayType* strlist_to_textarray ( List * list )

Definition at line 6071 of file objectaddress.c.

 {
     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;
 }

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, construct_md_array(), CStringGetTextDatum, CurrentMemoryContext, j, lfirst, sort-test::list, list_length(), MemoryContextDelete(), MemoryContextSwitchTo(), name, and palloc().

Referenced by fill_hba_line(), pg_event_trigger_dropped_objects(), and pg_identify_object_as_address().

Variable Documentation

◆ InvalidObjectAddress

PGDLLIMPORT const ObjectAddress InvalidObjectAddress

extern

Definition at line 837 of file objectaddress.c.

Referenced by AlterDomainAddConstraint(), AlterDomainNotNull(), AlterExtensionNamespace(), AlterPublicationOptions(), AlterSequence(), AlterStatistics(), AlterTableNamespace(), ATAddCheckConstraint(), ATExecAddColumn(), ATExecAddConstraint(), ATExecAlterColumnGenericOptions(), ATExecAlterConstraint(), ATExecCmd(), ATExecDropColumn(), ATExecDropExpression(), ATExecDropIdentity(), ATExecDropNotNull(), ATExecSetIdentity(), ATExecSetNotNull(), ATExecValidateConstraint(), CommentObject(), CreateExtension(), CreateForeignServer(), CreateOpFamily(), CreateSchemaCommand(), CreateStatistics(), CreateUserMapping(), DefineCollation(), DefineSequence(), ExecAlterExtensionStmt(), ExecAlterObjectSchemaStmt(), ExecAlterOwnerStmt(), ExecCreateTableAs(), ExecRenameStmt(), GetAttrDefaultColumnAddress(), ProcessUtilitySlow(), publication_add_relation(), publication_add_schema(), PublicationAddSchemas(), PublicationAddTables(), reindex_index(), ReindexRelationConcurrently(), renameatt(), RenameConstraint(), and RenameRelation().

Data Structures

Macros

Typedefs

Functions

Variables