objectaddress.h File Reference

#include "nodes/pg_list.h"
#include "storage/lockdefs.h"
#include "utils/acl.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)
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)
char *	getObjectDescriptionOids (Oid classid, Oid objid)
int	read_objtype_from_string (const char *objtype)
char *	getObjectTypeDescription (const ObjectAddress *object)
char *	getObjectIdentity (const ObjectAddress *address)
char *	getObjectIdentityParts (const ObjectAddress *address, List **objname, List **objargs)
struct ArrayType *	strlist_to_textarray (List *list)
ObjectType	get_relkind_objtype (char relkind)

Variables
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.

Referenced by addFkRecurseReferenced(), addFkRecurseReferencing(), AlterCollation(), AlterDatabaseOwner(), AlterDomainAddConstraint(), AlterDomainDefault(), AlterDomainDropConstraint(), AlterDomainNotNull(), AlterDomainValidateConstraint(), AlterEnum(), AlterEventTriggerOwner(), AlterExtensionNamespace(), AlterForeignDataWrapper(), AlterForeignDataWrapperOwner(), AlterForeignServer(), AlterForeignServerOwner(), AlterFunction(), AlterPublicationOptions(), AlterPublicationOwner(), AlterSchemaOwner(), AlterSequence(), AlterStatistics(), AlterSubscription(), AlterSubscriptionOwner(), AlterTableNamespace(), AlterTSConfiguration(), AlterTSDictionary(), AlterTypeNamespace(), AlterTypeOwner(), AlterUserMapping(), ATAddCheckConstraint(), ATExecAddInherit(), ATExecAlterConstraint(), ATExecAttachPartition(), ATExecAttachPartitionIdx(), ATExecClusterOn(), ATExecDetachPartition(), ATExecDropInherit(), ATExecValidateConstraint(), ATPostAlterTypeCleanup(), CloneFkReferencing(), ConstraintSetParentConstraint(), CreatePublication(), CreateSchemaCommand(), CreateStatistics(), CreateSubscription(), CreateTrigger(), DefineCollation(), DefineIndex(), DefineQueryRewrite(), DefineRelation(), DefineTSConfiguration(), DefineVirtualRelation(), domainAddConstraint(), DropSubscription(), EventTriggerCollectAlterOpFam(), EventTriggerCollectAlterTSConfig(), EventTriggerCollectCreateOpClass(), ExecAlterExtensionStmt(), ExecAlterObjectSchemaStmt(), ExecRefreshMatView(), get_object_address_defacl(), get_object_address_opf_member(), get_object_address_publication_rel(), get_object_address_usermapping(), index_constraint_create(), IndexSetParentIndex(), pg_event_trigger_ddl_commands(), publication_add_relation(), PublicationDropTables(), rename_constraint_internal(), rename_policy(), RenameDatabase(), RenameRelation(), RenameRewriteRule(), RenameRole(), RenameSchema(), RenameTableSpace(), renametrig(), RenameType(), SetFunctionArgType(), SetFunctionReturnType(), tryAttachPartitionForeignKey(), TypeCreate(), and TypeShellMake().

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.

Referenced by ATExecAddColumn(), ATExecAddIdentity(), ATExecAlterColumnGenericOptions(), ATExecAlterColumnType(), ATExecColumnDefault(), ATExecDropExpression(), ATExecDropIdentity(), ATExecDropNotNull(), ATExecSetIdentity(), ATExecSetNotNull(), ATExecSetOptions(), ATExecSetStatistics(), ATExecSetStorage(), CreateStatistics(), and renameatt().

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 2270 of file objectaddress.c.

References aclcheck_error(), aclcheck_error_type(), ACLCHECK_NOT_OWNER, castNode, CONSTROID, elog, ereport, errcode(), errmsg(), ERROR, format_type_be(), GETSTRUCT, has_createrole_privilege(), HeapTupleIsValid, linitial_node, lo_compat_privileges, lsecond_node, NameListToString(), OBJECT_ACCESS_METHOD, OBJECT_AGGREGATE, OBJECT_ATTRIBUTE, OBJECT_CAST, OBJECT_COLLATION, OBJECT_COLUMN, OBJECT_CONVERSION, OBJECT_DATABASE, 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_POLICY, OBJECT_PROCEDURE, OBJECT_PUBLICATION, 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_VIEW, ObjectAddress::objectId, ObjectIdGetDatum, pg_class_ownercheck(), pg_collation_ownercheck(), pg_conversion_ownercheck(), pg_database_ownercheck(), pg_event_trigger_ownercheck(), pg_extension_ownercheck(), pg_foreign_data_wrapper_ownercheck(), pg_foreign_server_ownercheck(), pg_language_ownercheck(), pg_largeobject_ownercheck(), pg_namespace_ownercheck(), pg_opclass_ownercheck(), pg_oper_ownercheck(), pg_opfamily_ownercheck(), pg_proc_ownercheck(), pg_publication_ownercheck(), pg_statistics_object_ownercheck(), pg_subscription_ownercheck(), pg_tablespace_ownercheck(), pg_ts_config_ownercheck(), pg_ts_dict_ownercheck(), pg_type_ownercheck(), RelationGetRelationName, RelationGetRelid, ReleaseSysCache(), SearchSysCache1(), strVal, superuser_arg(), and typenameTypeId().

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

{
    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 (!pg_class_ownercheck(RelationGetRelid(relation), roleid))
                aclcheck_error(ACLCHECK_NOT_OWNER, objtype,
                               RelationGetRelationName(relation));
            break;
        case OBJECT_DATABASE:
            if (!pg_database_ownercheck(address.objectId, roleid))
                aclcheck_error(ACLCHECK_NOT_OWNER, objtype,
                               strVal((Value *) object));
            break;
        case OBJECT_TYPE:
        case OBJECT_DOMAIN:
        case OBJECT_ATTRIBUTE:
            if (!pg_type_ownercheck(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 (!pg_type_ownercheck(contypid, roleid))
                    aclcheck_error_type(ACLCHECK_NOT_OWNER, contypid);
            }
            break;
        case OBJECT_AGGREGATE:
        case OBJECT_FUNCTION:
        case OBJECT_PROCEDURE:
        case OBJECT_ROUTINE:
            if (!pg_proc_ownercheck(address.objectId, roleid))
                aclcheck_error(ACLCHECK_NOT_OWNER, objtype,
                               NameListToString((castNode(ObjectWithArgs, object))->objname));
            break;
        case OBJECT_OPERATOR:
            if (!pg_oper_ownercheck(address.objectId, roleid))
                aclcheck_error(ACLCHECK_NOT_OWNER, objtype,
                               NameListToString((castNode(ObjectWithArgs, object))->objname));
            break;
        case OBJECT_SCHEMA:
            if (!pg_namespace_ownercheck(address.objectId, roleid))
                aclcheck_error(ACLCHECK_NOT_OWNER, objtype,
                               strVal((Value *) object));
            break;
        case OBJECT_COLLATION:
            if (!pg_collation_ownercheck(address.objectId, roleid))
                aclcheck_error(ACLCHECK_NOT_OWNER, objtype,
                               NameListToString(castNode(List, object)));
            break;
        case OBJECT_CONVERSION:
            if (!pg_conversion_ownercheck(address.objectId, roleid))
                aclcheck_error(ACLCHECK_NOT_OWNER, objtype,
                               NameListToString(castNode(List, object)));
            break;
        case OBJECT_EXTENSION:
            if (!pg_extension_ownercheck(address.objectId, roleid))
                aclcheck_error(ACLCHECK_NOT_OWNER, objtype,
                               strVal((Value *) object));
            break;
        case OBJECT_FDW:
            if (!pg_foreign_data_wrapper_ownercheck(address.objectId, roleid))
                aclcheck_error(ACLCHECK_NOT_OWNER, objtype,
                               strVal((Value *) object));
            break;
        case OBJECT_FOREIGN_SERVER:
            if (!pg_foreign_server_ownercheck(address.objectId, roleid))
                aclcheck_error(ACLCHECK_NOT_OWNER, objtype,
                               strVal((Value *) object));
            break;
        case OBJECT_EVENT_TRIGGER:
            if (!pg_event_trigger_ownercheck(address.objectId, roleid))
                aclcheck_error(ACLCHECK_NOT_OWNER, objtype,
                               strVal((Value *) object));
            break;
        case OBJECT_LANGUAGE:
            if (!pg_language_ownercheck(address.objectId, roleid))
                aclcheck_error(ACLCHECK_NOT_OWNER, objtype,
                               strVal((Value *) object));
            break;
        case OBJECT_OPCLASS:
            if (!pg_opclass_ownercheck(address.objectId, roleid))
                aclcheck_error(ACLCHECK_NOT_OWNER, objtype,
                               NameListToString(castNode(List, object)));
            break;
        case OBJECT_OPFAMILY:
            if (!pg_opfamily_ownercheck(address.objectId, roleid))
                aclcheck_error(ACLCHECK_NOT_OWNER, objtype,
                               NameListToString(castNode(List, object)));
            break;
        case OBJECT_LARGEOBJECT:
            if (!lo_compat_privileges &&
                !pg_largeobject_ownercheck(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 (!pg_type_ownercheck(sourcetypeid, roleid)
                    && !pg_type_ownercheck(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_PUBLICATION:
            if (!pg_publication_ownercheck(address.objectId, roleid))
                aclcheck_error(ACLCHECK_NOT_OWNER, objtype,
                               strVal((Value *) object));
            break;
        case OBJECT_SUBSCRIPTION:
            if (!pg_subscription_ownercheck(address.objectId, roleid))
                aclcheck_error(ACLCHECK_NOT_OWNER, objtype,
                               strVal((Value *) object));
            break;
        case OBJECT_TRANSFORM:
            {
                TypeName   *typename = linitial_node(TypeName, castNode(List, object));
                Oid         typeid = typenameTypeId(NULL, typename);

                if (!pg_type_ownercheck(typeid, roleid))
                    aclcheck_error_type(ACLCHECK_NOT_OWNER, typeid);
            }
            break;
        case OBJECT_TABLESPACE:
            if (!pg_tablespace_ownercheck(address.objectId, roleid))
                aclcheck_error(ACLCHECK_NOT_OWNER, objtype,
                               strVal((Value *) object));
            break;
        case OBJECT_TSDICTIONARY:
            if (!pg_ts_dict_ownercheck(address.objectId, roleid))
                aclcheck_error(ACLCHECK_NOT_OWNER, objtype,
                               NameListToString(castNode(List, object)));
            break;
        case OBJECT_TSCONFIGURATION:
            if (!pg_ts_config_ownercheck(address.objectId, roleid))
                aclcheck_error(ACLCHECK_NOT_OWNER, objtype,
                               NameListToString(castNode(List, object)));
            break;
        case OBJECT_ROLE:

            /*
             * We treat roles as being "owned" by those with CREATEROLE priv,
             * except that superusers are only owned by superusers.
             */
            if (superuser_arg(address.objectId))
            {
                if (!superuser_arg(roleid))
                    ereport(ERROR,
                            (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                             errmsg("must be superuser")));
            }
            else
            {
                if (!has_createrole_privilege(roleid))
                    ereport(ERROR,
                            (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                             errmsg("must have CREATEROLE privilege")));
            }
            break;
        case OBJECT_TSPARSER:
        case OBJECT_TSTEMPLATE:
        case OBJECT_ACCESS_METHOD:
            /* 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_STATISTIC_EXT:
            if (!pg_statistics_object_ownercheck(address.objectId, roleid))
                aclcheck_error_type(ACLCHECK_NOT_OWNER, address.objectId);
            break;
        default:
            elog(ERROR, "unrecognized object type: %d",
                 (int) objtype);
    }
}

get_catalog_object_by_oid()

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

Definition at line 2705 of file objectaddress.c.

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().

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

get_object_address()

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

Definition at line 833 of file objectaddress.c.

References Assert, castNode, ObjectAddress::classId, elog, ereport, errcode(), errmsg(), ERROR, get_cast_oid(), get_collation_oid(), get_conversion_oid(), get_domain_constraint_oid(), get_language_oid(), get_object_address_attrdef(), get_object_address_attribute(), get_object_address_defacl(), get_object_address_opcf(), get_object_address_opf_member(), get_object_address_publication_rel(), get_object_address_relobject(), get_object_address_type(), get_object_address_unqualified(), get_object_address_usermapping(), get_relation_by_qualified_name(), get_statistics_object_oid(), get_transform_oid(), get_ts_config_oid(), get_ts_dict_oid(), get_ts_parser_oid(), get_ts_template_oid(), InvalidOid, IsSharedRelation(), LargeObjectExists(), linitial_node, LockDatabaseObject(), LockSharedObject(), LookupFuncWithArgs(), LookupOperWithArgs(), LookupTypeNameOid(), lsecond, lsecond_node, NoLock, OBJECT_ACCESS_METHOD, OBJECT_AGGREGATE, OBJECT_AMOP, OBJECT_AMPROC, 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_POLICY, OBJECT_PROCEDURE, OBJECT_PUBLICATION, 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, ObjectAddress::objectSubId, OidIsValid, oidparse(), SharedInvalidMessageCounter, strVal, UnlockDatabaseObject(), and UnlockSharedObject().

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

{
    ObjectAddress address;
    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_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_ACCESS_METHOD:
            case OBJECT_PUBLICATION:
            case OBJECT_SUBSCRIPTION:
                address = get_object_address_unqualified(objtype,
                                                         (Value *) 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_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;
            default:
                elog(ERROR, "unrecognized objtype: %d", (int) objtype);
                /* placate compiler, in case it thinks elog might return */
                address.classId = InvalidOid;
                address.objectId = InvalidOid;
                address.objectSubId = 0;
        }

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

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 1128 of file objectaddress.c.

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

Referenced by ExecAlterObjectDependsStmt().

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

get_object_attnum_acl()

AttrNumber get_object_attnum_acl

(

Oid

class_id

)

Definition at line 2608 of file objectaddress.c.

References ObjectPropertyType::attnum_acl, and get_object_property_data().

Referenced by AlterObjectOwner_internal().

{
    const ObjectPropertyType *prop = get_object_property_data(class_id);

    return prop->attnum_acl;
}

get_object_attnum_name()

AttrNumber get_object_attnum_name

(

Oid

class_id

)

Definition at line 2584 of file objectaddress.c.

References ObjectPropertyType::attnum_name, and get_object_property_data().

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

{
    const ObjectPropertyType *prop = get_object_property_data(class_id);

    return prop->attnum_name;
}

get_object_attnum_namespace()

AttrNumber get_object_attnum_namespace

(

Oid

class_id

)

Definition at line 2592 of file objectaddress.c.

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().

{
    const ObjectPropertyType *prop = get_object_property_data(class_id);

    return prop->attnum_namespace;
}

get_object_attnum_oid()

AttrNumber get_object_attnum_oid

(

Oid

class_id

)

Definition at line 2576 of file objectaddress.c.

References ObjectPropertyType::attnum_oid, and get_object_property_data().

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

{
    const ObjectPropertyType *prop = get_object_property_data(class_id);

    return prop->attnum_oid;
}

get_object_attnum_owner()

AttrNumber get_object_attnum_owner

(

Oid

class_id

)

Definition at line 2600 of file objectaddress.c.

References ObjectPropertyType::attnum_owner, and get_object_property_data().

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

{
    const ObjectPropertyType *prop = get_object_property_data(class_id);

    return prop->attnum_owner;
}

get_object_catcache_name()

int get_object_catcache_name

(

Oid

class_id

)

Definition at line 2568 of file objectaddress.c.

References get_object_property_data(), and ObjectPropertyType::name_catcache_id.

Referenced by AlterObjectNamespace_internal(), and AlterObjectRename_internal().

{
    const ObjectPropertyType *prop = get_object_property_data(class_id);

    return prop->name_catcache_id;
}

get_object_catcache_oid()

int get_object_catcache_oid

(

Oid

class_id

)

Definition at line 2560 of file objectaddress.c.

References get_object_property_data(), and ObjectPropertyType::oid_catcache_id.

Referenced by AlterObjectNamespace_internal(), AlterObjectRename_internal(), and get_catalog_object_by_oid().

{
    const ObjectPropertyType *prop = get_object_property_data(class_id);

    return prop->oid_catcache_id;
}

get_object_namensp_unique()

bool get_object_namensp_unique

(

Oid

class_id

)

Definition at line 2641 of file objectaddress.c.

References get_object_property_data(), and ObjectPropertyType::is_nsp_name_unique.

Referenced by EventTriggerSQLDropAddObject(), and pg_identify_object().

{
    const ObjectPropertyType *prop = get_object_property_data(class_id);

    return prop->is_nsp_name_unique;
}

get_object_namespace()

Oid get_object_namespace

(

const ObjectAddress *

address

)

Definition at line 2493 of file objectaddress.c.

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

Referenced by RemoveObjects().

{
    int         cache;
    HeapTuple   tuple;
    bool        isnull;
    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(SysCacheGetAttr(cache,
                                           tuple,
                                           property->attnum_namespace,
                                           &isnull));
    Assert(!isnull);
    ReleaseSysCache(tuple);

    return oid;
}

get_object_oid_index()

Oid get_object_oid_index

(

Oid

class_id

)

Definition at line 2552 of file objectaddress.c.

References get_object_property_data(), and ObjectPropertyType::oid_index_oid.

Referenced by get_catalog_object_by_oid().

{
    const ObjectPropertyType *prop = get_object_property_data(class_id);

    return prop->oid_index_oid;
}

get_object_type()

ObjectType get_object_type	(	Oid	class_id,
		Oid	object_id
	)

Definition at line 2623 of file objectaddress.c.

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

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

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

get_relkind_objtype()

ObjectType get_relkind_objtype

(

char

relkind

)

Definition at line 5354 of file objectaddress.c.

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

Referenced by AlterTableMoveAll(), ATExecChangeOwner(), ATSimplePermissions(), checkFkeyPermissions(), CreateStatistics(), CreateTrigger(), currtid_byrelname(), currtid_byreloid(), DefineQueryRewrite(), EnableDisableRule(), ExecCheckRTPerms(), get_object_type(), get_rel_from_relname(), LockTableRecurse(), LockViewRecurse_walker(), MergeAttributes(), pg_prewarm(), pgrowlocks(), PublicationAddTables(), RangeVarCallbackForAlterRelation(), RangeVarCallbackForDropRelation(), RangeVarCallbackForLockTable(), RangeVarCallbackForPolicy(), RangeVarCallbackForRenameRule(), RangeVarCallbackForRenameTrigger(), RangeVarCallbackOwnsRelation(), RangeVarCallbackOwnsTable(), RangeVarGetAndCheckCreationNamespace(), renameatt_check(), transformTableLikeClause(), and truncate_check_rel().

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

getObjectDescription()

char* getObjectDescription

(

const ObjectAddress *

object

)

Definition at line 2752 of file objectaddress.c.

References _, AccessMethodOperatorOidIndexId, AccessMethodProcedureOidIndexId, AccessShareLock, AMOID, appendStringInfo(), Assert, AttrDefaultOidIndexId, BTEqualStrategyNumber, CastOidIndexId, CLAOID, ObjectAddress::classId, CollationIsVisible(), COLLOID, CONSTROID, ConversionIsVisible(), CONVOID, StringInfoData::data, datname, DefaultAclOidIndexId, elog, ERROR, EVENTTRIGGEROID, ForeignDataWrapper::fdwname, format_operator(), format_procedure(), format_type_be(), get_attname(), get_database_name(), get_extension_name(), get_language_name(), get_namespace_name(), get_publication_name(), get_subscription_name(), get_tablespace_name(), GetForeignDataWrapper(), GetForeignServer(), getObjectClass(), getObjectDescription(), getOpFamilyDescription(), getRelationDescription(), GETSTRUCT, GetUserNameFromId(), HeapTupleIsValid, initStringInfo(), 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_POLICY, OCLASS_PROC, OCLASS_PUBLICATION, OCLASS_PUBLICATION_REL, OCLASS_REWRITE, OCLASS_ROLE, 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(), pfree(), PolicyOidIndexId, PUBLICATIONREL, quote_qualified_identifier(), ReleaseSysCache(), RewriteOidIndexId, ScanKeyInit(), SearchSysCache1(), ForeignServer::servername, STATEXTOID, StatisticsObjIsVisible(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), table_open(), TRFOID, TriggerOidIndexId, TSConfigIsVisible(), TSCONFIGOID, TSDictionaryIsVisible(), TSDICTOID, TSParserIsVisible(), TSPARSEROID, TSTemplateIsVisible(), TSTEMPLATEOID, and USERMAPPINGOID.

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

{
    StringInfoData buffer;

    initStringInfo(&buffer);

    switch (getObjectClass(object))
    {
        case OCLASS_CLASS:
            if (object->objectSubId == 0)
                getRelationDescription(&buffer, object->objectId);
            else
            {
                /* column, not whole relation */
                StringInfoData rel;

                initStringInfo(&rel);
                getRelationDescription(&rel, object->objectId);
                /* translator: second %s is, e.g., "table %s" */
                appendStringInfo(&buffer, _("column %s of %s"),
                                 get_attname(object->objectId,
                                             object->objectSubId,
                                             false),
                                 rel.data);
                pfree(rel.data);
            }
            break;

        case OCLASS_PROC:
            appendStringInfo(&buffer, _("function %s"),
                             format_procedure(object->objectId));
            break;

        case OCLASS_TYPE:
            appendStringInfo(&buffer, _("type %s"),
                             format_type_be(object->objectId));
            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))
                    elog(ERROR, "could not find tuple for cast %u",
                         object->objectId);

                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))
                    elog(ERROR, "cache lookup failed for collation %u",
                         object->objectId);
                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))
                    elog(ERROR, "cache lookup failed for constraint %u",
                         object->objectId);
                con = (Form_pg_constraint) GETSTRUCT(conTup);

                if (OidIsValid(con->conrelid))
                {
                    StringInfoData rel;

                    initStringInfo(&rel);
                    getRelationDescription(&rel, con->conrelid);
                    /* 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))
                    elog(ERROR, "cache lookup failed for conversion %u",
                         object->objectId);
                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:
            {
                Relation    attrdefDesc;
                ScanKeyData skey[1];
                SysScanDesc adscan;
                HeapTuple   tup;
                Form_pg_attrdef attrdef;
                ObjectAddress colobject;

                attrdefDesc = table_open(AttrDefaultRelationId, AccessShareLock);

                ScanKeyInit(&skey[0],
                            Anum_pg_attrdef_oid,
                            BTEqualStrategyNumber, F_OIDEQ,
                            ObjectIdGetDatum(object->objectId));

                adscan = systable_beginscan(attrdefDesc, AttrDefaultOidIndexId,
                                            true, NULL, 1, skey);

                tup = systable_getnext(adscan);

                if (!HeapTupleIsValid(tup))
                    elog(ERROR, "could not find tuple for attrdef %u",
                         object->objectId);

                attrdef = (Form_pg_attrdef) GETSTRUCT(tup);

                colobject.classId = RelationRelationId;
                colobject.objectId = attrdef->adrelid;
                colobject.objectSubId = attrdef->adnum;

                /* translator: %s is typically "column %s of table %s" */
                appendStringInfo(&buffer, _("default value for %s"),
                                 getObjectDescription(&colobject));

                systable_endscan(adscan);
                table_close(attrdefDesc, AccessShareLock);
                break;
            }

        case OCLASS_LANGUAGE:
            appendStringInfo(&buffer, _("language %s"),
                             get_language_name(object->objectId, false));
            break;

        case OCLASS_LARGEOBJECT:
            appendStringInfo(&buffer, _("large object %u"),
                             object->objectId);
            break;

        case OCLASS_OPERATOR:
            appendStringInfo(&buffer, _("operator %s"),
                             format_operator(object->objectId));
            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))
                    elog(ERROR, "cache lookup failed for opclass %u",
                         object->objectId);
                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);
            break;

        case OCLASS_AM:
            {
                HeapTuple   tup;

                tup = SearchSysCache1(AMOID,
                                      ObjectIdGetDatum(object->objectId));
                if (!HeapTupleIsValid(tup))
                    elog(ERROR, "cache lookup failed for access method %u",
                         object->objectId);
                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))
                    elog(ERROR, "could not find tuple for amop entry %u",
                         object->objectId);

                amopForm = (Form_pg_amop) GETSTRUCT(tup);

                initStringInfo(&opfam);
                getOpFamilyDescription(&opfam, amopForm->amopfamily);

                /*------
                   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))
                    elog(ERROR, "could not find tuple for amproc entry %u",
                         object->objectId);

                amprocForm = (Form_pg_amproc) GETSTRUCT(tup);

                initStringInfo(&opfam);
                getOpFamilyDescription(&opfam, amprocForm->amprocfamily);

                /*------
                   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))
                    elog(ERROR, "could not find tuple for rule %u",
                         object->objectId);
                rule = (Form_pg_rewrite) GETSTRUCT(tup);

                initStringInfo(&rel);
                getRelationDescription(&rel, rule->ev_class);

                /* 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))
                    elog(ERROR, "could not find tuple for trigger %u",
                         object->objectId);
                trig = (Form_pg_trigger) GETSTRUCT(tup);

                initStringInfo(&rel);
                getRelationDescription(&rel, trig->tgrelid);

                /* 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)
                    elog(ERROR, "cache lookup failed for namespace %u",
                         object->objectId);
                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))
                    elog(ERROR, "could not find tuple for statistics object %u",
                         object->objectId);
                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))
                    elog(ERROR, "cache lookup failed for text search parser %u",
                         object->objectId);
                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))
                    elog(ERROR, "cache lookup failed for text search dictionary %u",
                         object->objectId);
                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))
                    elog(ERROR, "cache lookup failed for text search template %u",
                         object->objectId);
                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))
                    elog(ERROR, "cache lookup failed for text search configuration %u",
                         object->objectId);
                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:
            {
                appendStringInfo(&buffer, _("role %s"),
                                 GetUserNameFromId(object->objectId, false));
                break;
            }

        case OCLASS_DATABASE:
            {
                char       *datname;

                datname = get_database_name(object->objectId);
                if (!datname)
                    elog(ERROR, "cache lookup failed for database %u",
                         object->objectId);
                appendStringInfo(&buffer, _("database %s"), datname);
                break;
            }

        case OCLASS_TBLSPACE:
            {
                char       *tblspace;

                tblspace = get_tablespace_name(object->objectId);
                if (!tblspace)
                    elog(ERROR, "cache lookup failed for tablespace %u",
                         object->objectId);
                appendStringInfo(&buffer, _("tablespace %s"), tblspace);
                break;
            }

        case OCLASS_FDW:
            {
                ForeignDataWrapper *fdw;

                fdw = GetForeignDataWrapper(object->objectId);
                appendStringInfo(&buffer, _("foreign-data wrapper %s"), fdw->fdwname);
                break;
            }

        case OCLASS_FOREIGN_SERVER:
            {
                ForeignServer *srv;

                srv = GetForeignServer(object->objectId);
                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))
                    elog(ERROR, "cache lookup failed for user mapping %u",
                         object->objectId);
                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))
                    elog(ERROR, "could not find tuple for default ACL %u",
                         object->objectId);

                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)
                    elog(ERROR, "cache lookup failed for extension %u",
                         object->objectId);
                appendStringInfo(&buffer, _("extension %s"), extname);
                break;
            }

        case OCLASS_EVENT_TRIGGER:
            {
                HeapTuple   tup;

                tup = SearchSysCache1(EVENTTRIGGEROID,
                                      ObjectIdGetDatum(object->objectId));
                if (!HeapTupleIsValid(tup))
                    elog(ERROR, "cache lookup failed for event trigger %u",
                         object->objectId);
                appendStringInfo(&buffer, _("event trigger %s"),
                                 NameStr(((Form_pg_event_trigger) GETSTRUCT(tup))->evtname));
                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))
                    elog(ERROR, "could not find tuple for policy %u",
                         object->objectId);
                form_policy = (Form_pg_policy) GETSTRUCT(tuple);

                initStringInfo(&rel);
                getRelationDescription(&rel, form_policy->polrelid);

                /* 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:
            {
                appendStringInfo(&buffer, _("publication %s"),
                                 get_publication_name(object->objectId,
                                                      false));
                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))
                    elog(ERROR, "cache lookup failed for publication table %u",
                         object->objectId);

                prform = (Form_pg_publication_rel) GETSTRUCT(tup);
                pubname = get_publication_name(prform->prpubid, false);

                initStringInfo(&rel);
                getRelationDescription(&rel, prform->prrelid);

                /* 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:
            {
                appendStringInfo(&buffer, _("subscription %s"),
                                 get_subscription_name(object->objectId,
                                                       false));
                break;
            }

        case OCLASS_TRANSFORM:
            {
                HeapTuple   trfTup;
                Form_pg_transform trfForm;

                trfTup = SearchSysCache1(TRFOID,
                                         ObjectIdGetDatum(object->objectId));
                if (!HeapTupleIsValid(trfTup))
                    elog(ERROR, "could not find tuple for transform %u",
                         object->objectId);

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

    return buffer.data;
}

getObjectDescriptionOids()

char* getObjectDescriptionOids	(	Oid	classid,
		Oid	objid
	)

Definition at line 3662 of file objectaddress.c.

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

Referenced by AlterObjectNamespace_internal(), and AlterObjectRename_internal().

{
    ObjectAddress address;

    address.classId = classid;
    address.objectId = objid;
    address.objectSubId = 0;

    return getObjectDescription(&address);
}

getObjectIdentity()

char* getObjectIdentity

(

const ObjectAddress *

address

)

Definition at line 4281 of file objectaddress.c.

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().

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

getObjectIdentityParts()

char* getObjectIdentityParts	(	const ObjectAddress *	address,
		List **	objname,
		List **	objargs
	)

Definition at line 4295 of file objectaddress.c.

References AccessMethodOperatorOidIndexId, AccessMethodProcedureOidIndexId, AccessShareLock, AMOID, appendStringInfo(), appendStringInfoString(), Assert, AttrDefaultOidIndexId, BTEqualStrategyNumber, CLAOID, ObjectAddress::classId, COLLOID, CONSTROID, CONVOID, StringInfoData::data, datname, DefaultAclOidIndexId, elog, ERROR, EVENTTRIGGEROID, ForeignDataWrapper::fdwname, format_operator_parts(), format_operator_qualified(), format_procedure_parts(), format_procedure_qualified(), format_type_be_qualified(), 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(), GetForeignDataWrapper(), GetForeignServer(), getObjectClass(), getObjectIdentityParts(), getOpFamilyIdentity(), getRelationIdentity(), GETSTRUCT, GetUserNameFromId(), HeapTupleIsValid, initStringInfo(), LANGOID, lappend(), 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_POLICY, OCLASS_PROC, OCLASS_PUBLICATION, OCLASS_PUBLICATION_REL, OCLASS_REWRITE, OCLASS_ROLE, 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, pfree(), PointerIsValid, psprintf(), pstrdup(), PUBLICATIONREL, quote_identifier(), quote_qualified_identifier(), ReleaseSysCache(), ScanKeyInit(), SearchSysCache1(), ForeignServer::servername, STATEXTOID, subname, systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), table_open(), TSCONFIGOID, TSDICTOID, TSPARSEROID, TSTEMPLATEOID, USERMAPPINGOID, and username.

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

{
    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:
            getRelationIdentity(&buffer, object->objectId, objname);
            if (object->objectSubId != 0)
            {
                char       *attr;

                attr = get_attname(object->objectId, object->objectSubId,
                                   false);
                appendStringInfo(&buffer, ".%s", quote_identifier(attr));
                if (objname)
                    *objname = lappend(*objname, attr);
            }
            break;

        case OCLASS_PROC:
            appendStringInfoString(&buffer,
                                   format_procedure_qualified(object->objectId));
            if (objname)
                format_procedure_parts(object->objectId, objname, objargs);
            break;

        case OCLASS_TYPE:
            {
                char       *typeout;

                typeout = format_type_be_qualified(object->objectId);
                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))
                    elog(ERROR, "could not find tuple for cast %u",
                         object->objectId);

                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))
                    elog(ERROR, "cache lookup failed for collation %u",
                         object->objectId);
                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))
                    elog(ERROR, "cache lookup failed for constraint %u",
                         object->objectId);
                con = (Form_pg_constraint) GETSTRUCT(conTup);

                if (OidIsValid(con->conrelid))
                {
                    appendStringInfo(&buffer, "%s on ",
                                     quote_identifier(NameStr(con->conname)));
                    getRelationIdentity(&buffer, con->conrelid, objname);
                    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));

                    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))
                    elog(ERROR, "cache lookup failed for conversion %u",
                         object->objectId);
                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:
            {
                Relation    attrdefDesc;
                ScanKeyData skey[1];
                SysScanDesc adscan;

                HeapTuple   tup;
                Form_pg_attrdef attrdef;
                ObjectAddress colobject;

                attrdefDesc = table_open(AttrDefaultRelationId, AccessShareLock);

                ScanKeyInit(&skey[0],
                            Anum_pg_attrdef_oid,
                            BTEqualStrategyNumber, F_OIDEQ,
                            ObjectIdGetDatum(object->objectId));

                adscan = systable_beginscan(attrdefDesc, AttrDefaultOidIndexId,
                                            true, NULL, 1, skey);

                tup = systable_getnext(adscan);

                if (!HeapTupleIsValid(tup))
                    elog(ERROR, "could not find tuple for attrdef %u",
                         object->objectId);

                attrdef = (Form_pg_attrdef) GETSTRUCT(tup);

                colobject.classId = RelationRelationId;
                colobject.objectId = attrdef->adrelid;
                colobject.objectSubId = attrdef->adnum;

                appendStringInfo(&buffer, "for %s",
                                 getObjectIdentityParts(&colobject,
                                                        objname, objargs));

                systable_endscan(adscan);
                table_close(attrdefDesc, AccessShareLock);
                break;
            }

        case OCLASS_LANGUAGE:
            {
                HeapTuple   langTup;
                Form_pg_language langForm;

                langTup = SearchSysCache1(LANGOID,
                                          ObjectIdGetDatum(object->objectId));
                if (!HeapTupleIsValid(langTup))
                    elog(ERROR, "cache lookup failed for language %u",
                         object->objectId);
                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:
            appendStringInfo(&buffer, "%u",
                             object->objectId);
            if (objname)
                *objname = list_make1(psprintf("%u", object->objectId));
            break;

        case OCLASS_OPERATOR:
            appendStringInfoString(&buffer,
                                   format_operator_qualified(object->objectId));
            if (objname)
                format_operator_parts(object->objectId, objname, objargs);
            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))
                    elog(ERROR, "cache lookup failed for opclass %u",
                         object->objectId);
                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);
            break;

        case OCLASS_AM:
            {
                char       *amname;

                amname = get_am_name(object->objectId);
                if (!amname)
                    elog(ERROR, "cache lookup failed for access method %u",
                         object->objectId);
                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))
                    elog(ERROR, "could not find tuple for amop entry %u",
                         object->objectId);

                amopForm = (Form_pg_amop) GETSTRUCT(tup);

                initStringInfo(&opfam);
                getOpFamilyIdentity(&opfam, amopForm->amopfamily, objname);

                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))
                    elog(ERROR, "could not find tuple for amproc entry %u",
                         object->objectId);

                amprocForm = (Form_pg_amproc) GETSTRUCT(tup);

                initStringInfo(&opfam);
                getOpFamilyIdentity(&opfam, amprocForm->amprocfamily, objname);

                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))
                    elog(ERROR, "could not find tuple for rule %u",
                         object->objectId);

                rule = (Form_pg_rewrite) GETSTRUCT(tup);

                appendStringInfo(&buffer, "%s on ",
                                 quote_identifier(NameStr(rule->rulename)));
                getRelationIdentity(&buffer, rule->ev_class, objname);
                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))
                    elog(ERROR, "could not find tuple for trigger %u",
                         object->objectId);

                trig = (Form_pg_trigger) GETSTRUCT(tup);

                appendStringInfo(&buffer, "%s on ",
                                 quote_identifier(NameStr(trig->tgname)));
                getRelationIdentity(&buffer, trig->tgrelid, objname);
                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)
                    elog(ERROR, "cache lookup failed for namespace %u",
                         object->objectId);
                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))
                    elog(ERROR, "cache lookup failed for statistics object %u",
                         object->objectId);
                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))
                    elog(ERROR, "cache lookup failed for text search parser %u",
                         object->objectId);
                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))
                    elog(ERROR, "cache lookup failed for text search dictionary %u",
                         object->objectId);
                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))
                    elog(ERROR, "cache lookup failed for text search template %u",
                         object->objectId);
                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))
                    elog(ERROR, "cache lookup failed for text search configuration %u",
                         object->objectId);
                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, false);
                if (objname)
                    *objname = list_make1(username);
                appendStringInfoString(&buffer,
                                       quote_identifier(username));
                break;
            }

        case OCLASS_DATABASE:
            {
                char       *datname;

                datname = get_database_name(object->objectId);
                if (!datname)
                    elog(ERROR, "cache lookup failed for database %u",
                         object->objectId);
                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)
                    elog(ERROR, "cache lookup failed for tablespace %u",
                         object->objectId);
                if (objname)
                    *objname = list_make1(tblspace);
                appendStringInfoString(&buffer,
                                       quote_identifier(tblspace));
                break;
            }

        case OCLASS_FDW:
            {
                ForeignDataWrapper *fdw;

                fdw = GetForeignDataWrapper(object->objectId);
                appendStringInfoString(&buffer, quote_identifier(fdw->fdwname));
                if (objname)
                    *objname = list_make1(pstrdup(fdw->fdwname));
                break;
            }

        case OCLASS_FOREIGN_SERVER:
            {
                ForeignServer *srv;

                srv = GetForeignServer(object->objectId);
                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))
                    elog(ERROR, "cache lookup failed for user mapping %u",
                         object->objectId);
                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))
                    elog(ERROR, "could not find tuple for default ACL %u",
                         object->objectId);

                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)
                    elog(ERROR, "cache lookup failed for extension %u",
                         object->objectId);
                appendStringInfoString(&buffer, quote_identifier(extname));
                if (objname)
                    *objname = list_make1(extname);
                break;
            }

        case OCLASS_EVENT_TRIGGER:
            {
                HeapTuple   tup;
                Form_pg_event_trigger trigForm;

                /* no objname support here */
                if (objname)
                    *objname = NIL;

                tup = SearchSysCache1(EVENTTRIGGEROID,
                                      ObjectIdGetDatum(object->objectId));
                if (!HeapTupleIsValid(tup))
                    elog(ERROR, "cache lookup failed for event trigger %u",
                         object->objectId);
                trigForm = (Form_pg_event_trigger) GETSTRUCT(tup);
                appendStringInfoString(&buffer,
                                       quote_identifier(NameStr(trigForm->evtname)));
                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))
                    elog(ERROR, "could not find tuple for policy %u",
                         object->objectId);

                policy = (Form_pg_policy) GETSTRUCT(tup);

                appendStringInfo(&buffer, "%s on ",
                                 quote_identifier(NameStr(policy->polname)));
                getRelationIdentity(&buffer, policy->polrelid, objname);
                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, false);
                appendStringInfoString(&buffer,
                                       quote_identifier(pubname));
                if (objname)
                    *objname = list_make1(pubname);
                break;
            }

        case OCLASS_PUBLICATION_REL:
            {
                HeapTuple   tup;
                char       *pubname;
                Form_pg_publication_rel prform;

                tup = SearchSysCache1(PUBLICATIONREL,
                                      ObjectIdGetDatum(object->objectId));
                if (!HeapTupleIsValid(tup))
                    elog(ERROR, "cache lookup failed for publication table %u",
                         object->objectId);

                prform = (Form_pg_publication_rel) GETSTRUCT(tup);
                pubname = get_publication_name(prform->prpubid, false);

                getRelationIdentity(&buffer, prform->prrelid, objname);
                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, false);
                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))
                    elog(ERROR, "could not find tuple for transform %u",
                         object->objectId);

                transform = (Form_pg_transform) GETSTRUCT(tup);

                transformType = format_type_be_qualified(transform->trftype);
                transformLang = get_language_name(transform->trflang, false);

                appendStringInfo(&buffer, "for %s on 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 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);

    return buffer.data;
}

getObjectTypeDescription()

char* getObjectTypeDescription

(

const ObjectAddress *

object

)

Definition at line 3996 of file objectaddress.c.

References appendStringInfoString(), StringInfoData::data, getConstraintTypeDescription(), getObjectClass(), getProcedureTypeDescription(), getRelationTypeDescription(), initStringInfo(), 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_POLICY, OCLASS_PROC, OCLASS_PUBLICATION, OCLASS_PUBLICATION_REL, OCLASS_REWRITE, OCLASS_ROLE, 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().

{
    StringInfoData buffer;

    initStringInfo(&buffer);

    switch (getObjectClass(object))
    {
        case OCLASS_CLASS:
            getRelationTypeDescription(&buffer, object->objectId,
                                       object->objectSubId);
            break;

        case OCLASS_PROC:
            getProcedureTypeDescription(&buffer, object->objectId);
            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);
            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_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_POLICY:
            appendStringInfoString(&buffer, "policy");
            break;

        case OCLASS_PUBLICATION:
            appendStringInfoString(&buffer, "publication");
            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.
             */
    }

    return buffer.data;
}

is_objectclass_supported()

bool is_objectclass_supported

(

Oid

class_id

)

Definition at line 2653 of file objectaddress.c.

References lengthof.

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

{
    int         index;

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

    return false;
}

read_objtype_from_string()

int read_objtype_from_string

(

const char *

objtype

)

Definition at line 2532 of file objectaddress.c.

References ereport, errcode(), errmsg(), ERROR, i, lengthof, ObjectTypeMap, object_type_map::tm_name, and object_type_map::tm_type.

Referenced by pg_get_object_address().

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

strlist_to_textarray()

struct ArrayType* strlist_to_textarray

(

List *

list

)

Definition at line 5299 of file objectaddress.c.

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, construct_md_array(), CStringGetTextDatum, CurrentMemoryContext, lfirst, list_length(), MemoryContextDelete(), MemoryContextSwitchTo(), name, and palloc().

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

{
    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, 'i');

    MemoryContextDelete(memcxt);

    return arr;
}

Variable Documentation

InvalidObjectAddress

const ObjectAddress InvalidObjectAddress

Definition at line 756 of file objectaddress.c.

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