#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 2426 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, CONSTROID, 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 2825 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(), 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 966 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 1264 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 2728 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(), and recordExtObjInitPriv().

◆ get_object_attnum_name()

AttrNumber get_object_attnum_name ( Oid class_id )

Definition at line 2704 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 2712 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(), 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 2696 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(), and pg_identify_object().

◆ get_object_attnum_owner()

AttrNumber get_object_attnum_owner ( Oid class_id )

Definition at line 2720 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(), and object_ownercheck().

◆ get_object_catcache_name()

int get_object_catcache_name ( Oid class_id )

Definition at line 2688 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 2680 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(), and recordExtObjInitPriv().

◆ get_object_class_descr()

const char* get_object_class_descr ( Oid class_id )

Definition at line 2664 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(), and recordExtObjInitPriv().

◆ get_object_namensp_unique()

bool get_object_namensp_unique ( Oid class_id )

Definition at line 2761 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 2608 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 2672 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 2743 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 6106 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.

◆ getObjectDescription()

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

Definition at line 2922 of file objectaddress.c.

 {
     StringInfoData buffer;
  
     initStringInfo(&buffer);
  
     switch (getObjectClass(object))
     {
         case OCLASS_CLASS:
             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 OCLASS_PROC:
             {
                 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 OCLASS_TYPE:
             {
                 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 OCLASS_CAST:
             {
                 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 OCLASS_COLLATION:
             {
                 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 OCLASS_CONSTRAINT:
             {
                 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 OCLASS_CONVERSION:
             {
                 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 OCLASS_DEFAULT:
             {
                 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 OCLASS_LANGUAGE:
             {
                 char       *langname = get_language_name(object->objectId,
                                                          missing_ok);
  
                 if (langname)
                     appendStringInfo(&buffer, _("language %s"),
                                      get_language_name(object->objectId, false));
                 break;
             }
  
         case OCLASS_LARGEOBJECT:
             if (!LargeObjectExists(object->objectId))
                 break;
             appendStringInfo(&buffer, _("large object %u"),
                              object->objectId);
             break;
  
         case OCLASS_OPERATOR:
             {
                 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 OCLASS_OPCLASS:
             {
                 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 OCLASS_OPFAMILY:
             getOpFamilyDescription(&buffer, object->objectId, missing_ok);
             break;
  
         case OCLASS_AM:
             {
                 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 OCLASS_AMOP:
             {
                 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 OCLASS_AMPROC:
             {
                 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 OCLASS_REWRITE:
             {
                 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 OCLASS_TRIGGER:
             {
                 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 OCLASS_SCHEMA:
             {
                 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 OCLASS_STATISTIC_EXT:
             {
                 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 OCLASS_TSPARSER:
             {
                 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 OCLASS_TSDICT:
             {
                 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 OCLASS_TSTEMPLATE:
             {
                 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 OCLASS_TSCONFIG:
             {
                 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 OCLASS_ROLE:
             {
                 char       *username = GetUserNameFromId(object->objectId,
                                                          missing_ok);
  
                 if (username)
                     appendStringInfo(&buffer, _("role %s"), username);
                 break;
             }
  
         case OCLASS_ROLE_MEMBERSHIP:
             {
                 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 OCLASS_DATABASE:
             {
                 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 OCLASS_TBLSPACE:
             {
                 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 OCLASS_FDW:
             {
                 ForeignDataWrapper *fdw;
  
                 fdw = GetForeignDataWrapperExtended(object->objectId,
                                                     missing_ok);
                 if (fdw)
                     appendStringInfo(&buffer, _("foreign-data wrapper %s"), fdw->fdwname);
                 break;
             }
  
         case OCLASS_FOREIGN_SERVER:
             {
                 ForeignServer *srv;
  
                 srv = GetForeignServerExtended(object->objectId, missing_ok);
                 if (srv)
                     appendStringInfo(&buffer, _("server %s"), srv->servername);
                 break;
             }
  
         case OCLASS_USER_MAPPING:
             {
                 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 OCLASS_DEFACL:
             {
                 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 OCLASS_EXTENSION:
             {
                 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 OCLASS_EVENT_TRIGGER:
             {
                 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 OCLASS_PARAMETER_ACL:
             {
                 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 OCLASS_POLICY:
             {
                 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 OCLASS_PUBLICATION:
             {
                 char       *pubname = get_publication_name(object->objectId,
                                                            missing_ok);
  
                 if (pubname)
                     appendStringInfo(&buffer, _("publication %s"), pubname);
                 break;
             }
  
         case OCLASS_PUBLICATION_NAMESPACE:
             {
                 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 OCLASS_PUBLICATION_REL:
             {
                 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 OCLASS_SUBSCRIPTION:
             {
                 char       *subname = get_subscription_name(object->objectId,
                                                             missing_ok);
  
                 if (subname)
                     appendStringInfo(&buffer, _("subscription %s"), subname);
                 break;
             }
  
         case OCLASS_TRANSFORM:
             {
                 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;
             }
  
             /*
              * There's intentionally no default: case here; we want the
              * compiler to warn if a new OCLASS hasn't been handled above.
              */
     }
  
     /* an empty buffer is equivalent to no object found */
     if (buffer.len == 0)
         return NULL;
  
     return buffer.data;
 }

References _, AccessShareLock, AMOID, appendStringInfo(), Assert(), attname, BTEqualStrategyNumber, CLAOID, CollationIsVisible(), COLLOID, CONSTROID, ConversionIsVisible(), CONVOID, StringInfoData::data, datname, elog(), ERROR, EVENTTRIGGEROID, 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(), getObjectClass(), getOpFamilyDescription(), getPublicationSchemaInfo(), getRelationDescription(), GETSTRUCT, GetUserNameFromId(), HeapTupleIsValid, initStringInfo(), LargeObjectExists(), StringInfoData::len, NameStr, ObjectAddress::objectId, ObjectIdGetDatum(), ObjectAddress::objectSubId, OCLASS_AM, OCLASS_AMOP, OCLASS_AMPROC, OCLASS_CAST, OCLASS_CLASS, OCLASS_COLLATION, OCLASS_CONSTRAINT, OCLASS_CONVERSION, OCLASS_DATABASE, OCLASS_DEFACL, OCLASS_DEFAULT, OCLASS_EVENT_TRIGGER, OCLASS_EXTENSION, OCLASS_FDW, OCLASS_FOREIGN_SERVER, OCLASS_LANGUAGE, OCLASS_LARGEOBJECT, OCLASS_OPCLASS, OCLASS_OPERATOR, OCLASS_OPFAMILY, OCLASS_PARAMETER_ACL, OCLASS_POLICY, OCLASS_PROC, OCLASS_PUBLICATION, OCLASS_PUBLICATION_NAMESPACE, OCLASS_PUBLICATION_REL, OCLASS_REWRITE, OCLASS_ROLE, OCLASS_ROLE_MEMBERSHIP, OCLASS_SCHEMA, OCLASS_STATISTIC_EXT, OCLASS_SUBSCRIPTION, OCLASS_TBLSPACE, OCLASS_TRANSFORM, OCLASS_TRIGGER, OCLASS_TSCONFIG, OCLASS_TSDICT, OCLASS_TSPARSER, OCLASS_TSTEMPLATE, OCLASS_TYPE, OCLASS_USER_MAPPING, OidIsValid, OpclassIsVisible(), PARAMETERACLOID, pfree(), proname, PUBLICATIONREL, quote_qualified_identifier(), ReleaseSysCache(), ScanKeyInit(), SearchSysCache1(), ForeignServer::servername, STATEXTOID, StatisticsObjIsVisible(), subname, SysCacheGetAttrNotNull(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), table_open(), TextDatumGetCString, TRFOID, TSConfigIsVisible(), TSCONFIGOID, TSDictionaryIsVisible(), TSDICTOID, TSParserIsVisible(), TSPARSEROID, TSTemplateIsVisible(), TSTEMPLATEOID, typname, USERMAPPINGOID, and username.

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

◆ getObjectDescriptionOids()

char* getObjectDescriptionOids	(	Oid	classid,
		Oid	objid
	)

Definition at line 4076 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 4747 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 4762 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 (getObjectClass(object))
     {
         case OCLASS_CLASS:
             {
                 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 OCLASS_PROC:
             {
                 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 OCLASS_TYPE:
             {
                 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 OCLASS_CAST:
             {
                 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 OCLASS_COLLATION:
             {
                 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 OCLASS_CONSTRAINT:
             {
                 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 OCLASS_CONVERSION:
             {
                 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 OCLASS_DEFAULT:
             {
                 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 OCLASS_LANGUAGE:
             {
                 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 OCLASS_LARGEOBJECT:
             if (!LargeObjectExists(object->objectId))
                 break;
             appendStringInfo(&buffer, "%u",
                              object->objectId);
             if (objname)
                 *objname = list_make1(psprintf("%u", object->objectId));
             break;
  
         case OCLASS_OPERATOR:
             {
                 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 OCLASS_OPCLASS:
             {
                 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 OCLASS_OPFAMILY:
             getOpFamilyIdentity(&buffer, object->objectId, objname,
                                 missing_ok);
             break;
  
         case OCLASS_AM:
             {
                 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 OCLASS_AMOP:
             {
                 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 OCLASS_AMPROC:
             {
                 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 OCLASS_REWRITE:
             {
                 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 OCLASS_TRIGGER:
             {
                 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 OCLASS_SCHEMA:
             {
                 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 OCLASS_STATISTIC_EXT:
             {
                 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 OCLASS_TSPARSER:
             {
                 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 OCLASS_TSDICT:
             {
                 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 OCLASS_TSTEMPLATE:
             {
                 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 OCLASS_TSCONFIG:
             {
                 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 OCLASS_ROLE:
             {
                 char       *username;
  
                 username = GetUserNameFromId(object->objectId, missing_ok);
                 if (!username)
                     break;
                 if (objname)
                     *objname = list_make1(username);
                 appendStringInfoString(&buffer,
                                        quote_identifier(username));
                 break;
             }
  
         case OCLASS_ROLE_MEMBERSHIP:
             {
                 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 OCLASS_DATABASE:
             {
                 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 OCLASS_TBLSPACE:
             {
                 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 OCLASS_FDW:
             {
                 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 OCLASS_FOREIGN_SERVER:
             {
                 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 OCLASS_USER_MAPPING:
             {
                 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 OCLASS_DEFACL:
             {
                 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 OCLASS_EXTENSION:
             {
                 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 OCLASS_EVENT_TRIGGER:
             {
                 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 OCLASS_PARAMETER_ACL:
             {
                 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 OCLASS_POLICY:
             {
                 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 OCLASS_PUBLICATION:
             {
                 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 OCLASS_PUBLICATION_NAMESPACE:
             {
                 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 OCLASS_PUBLICATION_REL:
             {
                 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 OCLASS_SUBSCRIPTION:
             {
                 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 OCLASS_TRANSFORM:
             {
                 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;
  
             /*
              * There's intentionally no default: case here; we want the
              * compiler to warn if a new OCLASS hasn't been handled above.
              */
     }
  
     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 %d: text result \"%s\"",
                  (int) getObjectClass(object), 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, AMOID, appendStringInfo(), appendStringInfoString(), Assert(), BTEqualStrategyNumber, CLAOID, ObjectAddress::classId, COLLOID, CONSTROID, CONVOID, StringInfoData::data, datname, elog(), ERROR, EVENTTRIGGEROID, 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(), getObjectClass(), getOpFamilyIdentity(), getPublicationSchemaInfo(), getRelationIdentity(), GETSTRUCT, GetUserNameFromId(), HeapTupleIsValid, initStringInfo(), LANGOID, lappend(), LargeObjectExists(), StringInfoData::len, list_make1, list_make2, list_make3, NameStr, NIL, ObjectAddress::objectId, ObjectIdGetDatum(), ObjectAddress::objectSubId, OCLASS_AM, OCLASS_AMOP, OCLASS_AMPROC, OCLASS_CAST, OCLASS_CLASS, OCLASS_COLLATION, OCLASS_CONSTRAINT, OCLASS_CONVERSION, OCLASS_DATABASE, OCLASS_DEFACL, OCLASS_DEFAULT, OCLASS_EVENT_TRIGGER, OCLASS_EXTENSION, OCLASS_FDW, OCLASS_FOREIGN_SERVER, OCLASS_LANGUAGE, OCLASS_LARGEOBJECT, OCLASS_OPCLASS, OCLASS_OPERATOR, OCLASS_OPFAMILY, OCLASS_PARAMETER_ACL, OCLASS_POLICY, OCLASS_PROC, OCLASS_PUBLICATION, OCLASS_PUBLICATION_NAMESPACE, OCLASS_PUBLICATION_REL, OCLASS_REWRITE, OCLASS_ROLE, OCLASS_ROLE_MEMBERSHIP, OCLASS_SCHEMA, OCLASS_STATISTIC_EXT, OCLASS_SUBSCRIPTION, OCLASS_TBLSPACE, OCLASS_TRANSFORM, OCLASS_TRIGGER, OCLASS_TSCONFIG, OCLASS_TSDICT, OCLASS_TSPARSER, OCLASS_TSTEMPLATE, OCLASS_TYPE, OCLASS_USER_MAPPING, OidIsValid, PARAMETERACLOID, pfree(), PointerIsValid, proname, psprintf(), pstrdup(), PUBLICATIONREL, quote_identifier(), quote_qualified_identifier(), ReleaseSysCache(), ScanKeyInit(), SearchSysCache1(), ForeignServer::servername, STATEXTOID, subname, SysCacheGetAttrNotNull(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), table_open(), TextDatumGetCString, TSCONFIGOID, TSDICTOID, TSPARSEROID, TSTEMPLATEOID, USERMAPPINGOID, and username.

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

◆ getObjectTypeDescription()

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

Definition at line 4418 of file objectaddress.c.

 {
     StringInfoData buffer;
  
     initStringInfo(&buffer);
  
     switch (getObjectClass(object))
     {
         case OCLASS_CLASS:
             getRelationTypeDescription(&buffer, object->objectId,
                                        object->objectSubId,
                                        missing_ok);
             break;
  
         case OCLASS_PROC:
             getProcedureTypeDescription(&buffer, object->objectId,
                                         missing_ok);
             break;
  
         case OCLASS_TYPE:
             appendStringInfoString(&buffer, "type");
             break;
  
         case OCLASS_CAST:
             appendStringInfoString(&buffer, "cast");
             break;
  
         case OCLASS_COLLATION:
             appendStringInfoString(&buffer, "collation");
             break;
  
         case OCLASS_CONSTRAINT:
             getConstraintTypeDescription(&buffer, object->objectId,
                                          missing_ok);
             break;
  
         case OCLASS_CONVERSION:
             appendStringInfoString(&buffer, "conversion");
             break;
  
         case OCLASS_DEFAULT:
             appendStringInfoString(&buffer, "default value");
             break;
  
         case OCLASS_LANGUAGE:
             appendStringInfoString(&buffer, "language");
             break;
  
         case OCLASS_LARGEOBJECT:
             appendStringInfoString(&buffer, "large object");
             break;
  
         case OCLASS_OPERATOR:
             appendStringInfoString(&buffer, "operator");
             break;
  
         case OCLASS_OPCLASS:
             appendStringInfoString(&buffer, "operator class");
             break;
  
         case OCLASS_OPFAMILY:
             appendStringInfoString(&buffer, "operator family");
             break;
  
         case OCLASS_AM:
             appendStringInfoString(&buffer, "access method");
             break;
  
         case OCLASS_AMOP:
             appendStringInfoString(&buffer, "operator of access method");
             break;
  
         case OCLASS_AMPROC:
             appendStringInfoString(&buffer, "function of access method");
             break;
  
         case OCLASS_REWRITE:
             appendStringInfoString(&buffer, "rule");
             break;
  
         case OCLASS_TRIGGER:
             appendStringInfoString(&buffer, "trigger");
             break;
  
         case OCLASS_SCHEMA:
             appendStringInfoString(&buffer, "schema");
             break;
  
         case OCLASS_STATISTIC_EXT:
             appendStringInfoString(&buffer, "statistics object");
             break;
  
         case OCLASS_TSPARSER:
             appendStringInfoString(&buffer, "text search parser");
             break;
  
         case OCLASS_TSDICT:
             appendStringInfoString(&buffer, "text search dictionary");
             break;
  
         case OCLASS_TSTEMPLATE:
             appendStringInfoString(&buffer, "text search template");
             break;
  
         case OCLASS_TSCONFIG:
             appendStringInfoString(&buffer, "text search configuration");
             break;
  
         case OCLASS_ROLE:
             appendStringInfoString(&buffer, "role");
             break;
  
         case OCLASS_ROLE_MEMBERSHIP:
             appendStringInfoString(&buffer, "role membership");
             break;
  
         case OCLASS_DATABASE:
             appendStringInfoString(&buffer, "database");
             break;
  
         case OCLASS_TBLSPACE:
             appendStringInfoString(&buffer, "tablespace");
             break;
  
         case OCLASS_FDW:
             appendStringInfoString(&buffer, "foreign-data wrapper");
             break;
  
         case OCLASS_FOREIGN_SERVER:
             appendStringInfoString(&buffer, "server");
             break;
  
         case OCLASS_USER_MAPPING:
             appendStringInfoString(&buffer, "user mapping");
             break;
  
         case OCLASS_DEFACL:
             appendStringInfoString(&buffer, "default acl");
             break;
  
         case OCLASS_EXTENSION:
             appendStringInfoString(&buffer, "extension");
             break;
  
         case OCLASS_EVENT_TRIGGER:
             appendStringInfoString(&buffer, "event trigger");
             break;
  
         case OCLASS_PARAMETER_ACL:
             appendStringInfoString(&buffer, "parameter ACL");
             break;
  
         case OCLASS_POLICY:
             appendStringInfoString(&buffer, "policy");
             break;
  
         case OCLASS_PUBLICATION:
             appendStringInfoString(&buffer, "publication");
             break;
  
         case OCLASS_PUBLICATION_NAMESPACE:
             appendStringInfoString(&buffer, "publication namespace");
             break;
  
         case OCLASS_PUBLICATION_REL:
             appendStringInfoString(&buffer, "publication relation");
             break;
  
         case OCLASS_SUBSCRIPTION:
             appendStringInfoString(&buffer, "subscription");
             break;
  
         case OCLASS_TRANSFORM:
             appendStringInfoString(&buffer, "transform");
             break;
  
             /*
              * There's intentionally no default: case here; we want the
              * compiler to warn if a new OCLASS hasn't been handled above.
              */
     }
  
     /* the result can never be empty */
     Assert(buffer.len > 0);
  
     return buffer.data;
 }

References appendStringInfoString(), Assert(), StringInfoData::data, getConstraintTypeDescription(), getObjectClass(), getProcedureTypeDescription(), getRelationTypeDescription(), initStringInfo(), StringInfoData::len, ObjectAddress::objectId, ObjectAddress::objectSubId, OCLASS_AM, OCLASS_AMOP, OCLASS_AMPROC, OCLASS_CAST, OCLASS_CLASS, OCLASS_COLLATION, OCLASS_CONSTRAINT, OCLASS_CONVERSION, OCLASS_DATABASE, OCLASS_DEFACL, OCLASS_DEFAULT, OCLASS_EVENT_TRIGGER, OCLASS_EXTENSION, OCLASS_FDW, OCLASS_FOREIGN_SERVER, OCLASS_LANGUAGE, OCLASS_LARGEOBJECT, OCLASS_OPCLASS, OCLASS_OPERATOR, OCLASS_OPFAMILY, OCLASS_PARAMETER_ACL, OCLASS_POLICY, OCLASS_PROC, OCLASS_PUBLICATION, OCLASS_PUBLICATION_NAMESPACE, OCLASS_PUBLICATION_REL, OCLASS_REWRITE, OCLASS_ROLE, OCLASS_ROLE_MEMBERSHIP, OCLASS_SCHEMA, OCLASS_STATISTIC_EXT, OCLASS_SUBSCRIPTION, OCLASS_TBLSPACE, OCLASS_TRANSFORM, OCLASS_TRIGGER, OCLASS_TSCONFIG, OCLASS_TSDICT, OCLASS_TSPARSER, OCLASS_TSTEMPLATE, OCLASS_TYPE, and OCLASS_USER_MAPPING.

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 2773 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 2644 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 6051 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 881 of file objectaddress.c.

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

Data Structures

Macros

Typedefs

Functions

Variables