#include "postgres.h"
#include "access/genam.h"
#include "access/htup_details.h"
#include "access/relation.h"
#include "access/table.h"
#include "catalog/catalog.h"
#include "catalog/objectaddress.h"
#include "catalog/pg_am.h"
#include "catalog/pg_amop.h"
#include "catalog/pg_amproc.h"
#include "catalog/pg_attrdef.h"
#include "catalog/pg_authid.h"
#include "catalog/pg_auth_members.h"
#include "catalog/pg_cast.h"
#include "catalog/pg_collation.h"
#include "catalog/pg_constraint.h"
#include "catalog/pg_conversion.h"
#include "catalog/pg_database.h"
#include "catalog/pg_default_acl.h"
#include "catalog/pg_event_trigger.h"
#include "catalog/pg_extension.h"
#include "catalog/pg_foreign_data_wrapper.h"
#include "catalog/pg_foreign_server.h"
#include "catalog/pg_language.h"
#include "catalog/pg_largeobject.h"
#include "catalog/pg_largeobject_metadata.h"
#include "catalog/pg_namespace.h"
#include "catalog/pg_opclass.h"
#include "catalog/pg_operator.h"
#include "catalog/pg_opfamily.h"
#include "catalog/pg_parameter_acl.h"
#include "catalog/pg_policy.h"
#include "catalog/pg_proc.h"
#include "catalog/pg_propgraph_element.h"
#include "catalog/pg_propgraph_element_label.h"
#include "catalog/pg_propgraph_label.h"
#include "catalog/pg_propgraph_label_property.h"
#include "catalog/pg_propgraph_property.h"
#include "catalog/pg_publication.h"
#include "catalog/pg_publication_namespace.h"
#include "catalog/pg_publication_rel.h"
#include "catalog/pg_rewrite.h"
#include "catalog/pg_statistic_ext.h"
#include "catalog/pg_subscription.h"
#include "catalog/pg_tablespace.h"
#include "catalog/pg_transform.h"
#include "catalog/pg_trigger.h"
#include "catalog/pg_ts_config.h"
#include "catalog/pg_ts_dict.h"
#include "catalog/pg_ts_parser.h"
#include "catalog/pg_ts_template.h"
#include "catalog/pg_type.h"
#include "catalog/pg_user_mapping.h"
#include "commands/defrem.h"
#include "commands/event_trigger.h"
#include "commands/extension.h"
#include "commands/policy.h"
#include "commands/proclang.h"
#include "commands/tablespace.h"
#include "commands/trigger.h"
#include "foreign/foreign.h"
#include "funcapi.h"
#include "miscadmin.h"
#include "parser/parse_func.h"
#include "parser/parse_oper.h"
#include "parser/parse_type.h"
#include "rewrite/rewriteSupport.h"
#include "storage/large_object.h"
#include "storage/lmgr.h"
#include "storage/sinval.h"
#include "utils/acl.h"
#include "utils/builtins.h"
#include "utils/fmgroids.h"
#include "utils/lsyscache.h"
#include "utils/memutils.h"
#include "utils/regproc.h"
#include "utils/syscache.h"

Include dependency graph for objectaddress.c:

Data Structures
struct	ObjectPropertyType

struct	object_type_map

Functions
static ObjectAddress	get_object_address_unqualified (ObjectType objtype, String *strval, bool missing_ok)

static ObjectAddress	get_relation_by_qualified_name (ObjectType objtype, List object, Relation relp, LOCKMODE lockmode, bool missing_ok)

static ObjectAddress	get_object_address_relobject (ObjectType objtype, List object, Relation relp, bool missing_ok)

static ObjectAddress	get_object_address_attribute (ObjectType objtype, List object, Relation relp, LOCKMODE lockmode, bool missing_ok)

static ObjectAddress	get_object_address_attrdef (ObjectType objtype, List object, Relation relp, LOCKMODE lockmode, bool missing_ok)

static ObjectAddress	get_object_address_type (ObjectType objtype, TypeName *typename, bool missing_ok)

static ObjectAddress	get_object_address_opcf (ObjectType objtype, List *object, bool missing_ok)

static ObjectAddress	get_object_address_opf_member (ObjectType objtype, List *object, bool missing_ok)

static ObjectAddress	get_object_address_usermapping (List *object, bool missing_ok)

static ObjectAddress	get_object_address_publication_rel (List object, Relation relp, bool missing_ok)

static ObjectAddress	get_object_address_publication_schema (List *object, bool missing_ok)

static ObjectAddress	get_object_address_defacl (List *object, bool missing_ok)

static const ObjectPropertyType *	get_object_property_data (Oid class_id)

static void	getRelationDescription (StringInfo buffer, Oid relid, bool missing_ok)

static void	getOpFamilyDescription (StringInfo buffer, Oid opfid, bool missing_ok)

static void	getRelationTypeDescription (StringInfo buffer, Oid relid, int32 objectSubId, bool missing_ok)

static void	getProcedureTypeDescription (StringInfo buffer, Oid procid, bool missing_ok)

static void	getConstraintTypeDescription (StringInfo buffer, Oid constroid, bool missing_ok)

static void	getOpFamilyIdentity (StringInfo buffer, Oid opfid, List **object, bool missing_ok)

static void	getRelationIdentity (StringInfo buffer, Oid relid, List **object, bool missing_ok)

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)

static List *	textarray_to_strvaluelist (ArrayType *arr)

Datum	pg_get_object_address (PG_FUNCTION_ARGS)

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

Oid	get_object_namespace (const ObjectAddress *address)

int	read_objtype_from_string (const char *objtype)

const char *	get_object_class_descr (Oid class_id)

Oid	get_object_oid_index (Oid class_id)

SysCacheIdentifier	get_object_catcache_oid (Oid class_id)

SysCacheIdentifier	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)

bool	is_objectclass_supported (Oid class_id)

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

HeapTuple	get_catalog_object_by_oid_extended (Relation catalog, AttrNumber oidcol, Oid objectId, bool locktup)

static bool	getPublicationSchemaInfo (const ObjectAddress object, bool missing_ok, char pubname, char *nspname)

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

char *	getObjectDescriptionOids (Oid classid, Oid objid)

Datum	pg_describe_object (PG_FUNCTION_ARGS)

Datum	pg_identify_object (PG_FUNCTION_ARGS)

Datum	pg_identify_object_as_address (PG_FUNCTION_ARGS)

Datum	pg_get_acl (PG_FUNCTION_ARGS)

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

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

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

ArrayType *	strlist_to_textarray (List *list)

ObjectType	get_relkind_objtype (char relkind)

Variables
static const ObjectPropertyType	ObjectProperty []

static const struct object_type_map	ObjectTypeMap []

const ObjectAddress	InvalidObjectAddress

Function Documentation

◆ check_object_ownership()

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

Definition at line 2487 of file objectaddress.c.

{
    switch (objtype)
    {
        case OBJECT_INDEX:
        case OBJECT_SEQUENCE:
        case OBJECT_TABLE:
        case OBJECT_VIEW:
        case OBJECT_MATVIEW:
        case OBJECT_FOREIGN_TABLE:
        case OBJECT_PROPGRAPH:
        case OBJECT_COLUMN:
        case OBJECT_RULE:
        case OBJECT_TRIGGER:
        case OBJECT_POLICY:
        case OBJECT_TABCONSTRAINT:
            if (!object_ownercheck(RelationRelationId, RelationGetRelid(relation), roleid))
                aclcheck_error(ACLCHECK_NOT_OWNER, objtype,
                               RelationGetRelationName(relation));
            break;
        case OBJECT_TYPE:
        case OBJECT_DOMAIN:
        case OBJECT_ATTRIBUTE:
            if (!object_ownercheck(address.classId, address.objectId, roleid))
                aclcheck_error_type(ACLCHECK_NOT_OWNER, address.objectId);
            break;
        case OBJECT_DOMCONSTRAINT:
            {
                HeapTuple   tuple;
                Oid         contypid;
 
                tuple = SearchSysCache1(CONSTROID,
                                        ObjectIdGetDatum(address.objectId));
                if (!HeapTupleIsValid(tuple))
                    elog(ERROR, "constraint with OID %u does not exist",
                         address.objectId);
 
                contypid = ((Form_pg_constraint) GETSTRUCT(tuple))->contypid;
 
                ReleaseSysCache(tuple);
 
                /*
                 * Fallback to type ownership check in this case as this is
                 * what domain constraints rely on.
                 */
                if (!object_ownercheck(TypeRelationId, contypid, roleid))
                    aclcheck_error_type(ACLCHECK_NOT_OWNER, contypid);
            }
            break;
        case OBJECT_AGGREGATE:
        case OBJECT_FUNCTION:
        case OBJECT_PROCEDURE:
        case OBJECT_ROUTINE:
        case OBJECT_OPERATOR:
            if (!object_ownercheck(address.classId, address.objectId, roleid))
                aclcheck_error(ACLCHECK_NOT_OWNER, objtype,
                               NameListToString((castNode(ObjectWithArgs, object))->objname));
            break;
        case OBJECT_DATABASE:
        case OBJECT_EVENT_TRIGGER:
        case OBJECT_EXTENSION:
        case OBJECT_FDW:
        case OBJECT_FOREIGN_SERVER:
        case OBJECT_LANGUAGE:
        case OBJECT_PUBLICATION:
        case OBJECT_SCHEMA:
        case OBJECT_SUBSCRIPTION:
        case OBJECT_TABLESPACE:
            if (!object_ownercheck(address.classId, address.objectId, roleid))
                aclcheck_error(ACLCHECK_NOT_OWNER, objtype,
                               strVal(object));
            break;
        case OBJECT_COLLATION:
        case OBJECT_CONVERSION:
        case OBJECT_OPCLASS:
        case OBJECT_OPFAMILY:
        case OBJECT_STATISTIC_EXT:
        case OBJECT_TSDICTIONARY:
        case OBJECT_TSCONFIGURATION:
            if (!object_ownercheck(address.classId, address.objectId, roleid))
                aclcheck_error(ACLCHECK_NOT_OWNER, objtype,
                               NameListToString(castNode(List, object)));
            break;
        case OBJECT_LARGEOBJECT:
            if (!lo_compat_privileges &&
                !object_ownercheck(address.classId, address.objectId, roleid))
                ereport(ERROR,
                        (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                         errmsg("must be owner of large object %u",
                                address.objectId)));
            break;
        case OBJECT_CAST:
            {
                /* We can only check permissions on the source/target types */
                TypeName   *sourcetype = linitial_node(TypeName, castNode(List, object));
                TypeName   *targettype = lsecond_node(TypeName, castNode(List, object));
                Oid         sourcetypeid = typenameTypeId(NULL, sourcetype);
                Oid         targettypeid = typenameTypeId(NULL, targettype);
 
                if (!object_ownercheck(TypeRelationId, sourcetypeid, roleid)
                    && !object_ownercheck(TypeRelationId, targettypeid, roleid))
                    ereport(ERROR,
                            (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                             errmsg("must be owner of type %s or type %s",
                                    format_type_be(sourcetypeid),
                                    format_type_be(targettypeid))));
            }
            break;
        case OBJECT_TRANSFORM:
            {
                TypeName   *typename = linitial_node(TypeName, castNode(List, object));
                Oid         typeid = typenameTypeId(NULL, typename);
 
                if (!object_ownercheck(TypeRelationId, typeid, roleid))
                    aclcheck_error_type(ACLCHECK_NOT_OWNER, typeid);
            }
            break;
        case OBJECT_ROLE:
 
            /*
             * We treat roles as being "owned" by those with CREATEROLE priv,
             * provided that they also have admin option on the role.
             *
             * However, superusers are only owned by superusers.
             */
            if (superuser_arg(address.objectId))
            {
                if (!superuser_arg(roleid))
                    ereport(ERROR,
                            (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                             errmsg("permission denied"),
                             errdetail("The current user must have the %s attribute.",
                                       "SUPERUSER")));
            }
            else
            {
                if (!has_createrole_privilege(roleid))
                    ereport(ERROR,
                            (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                             errmsg("permission denied"),
                             errdetail("The current user must have the %s attribute.",
                                       "CREATEROLE")));
                if (!is_admin_of_role(roleid, address.objectId))
                    ereport(ERROR,
                            (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                             errmsg("permission denied"),
                             errdetail("The current user must have the %s option on role \"%s\".",
                                       "ADMIN",
                                       GetUserNameFromId(address.objectId,
                                                         true))));
            }
            break;
        case OBJECT_TSPARSER:
        case OBJECT_TSTEMPLATE:
        case OBJECT_ACCESS_METHOD:
        case OBJECT_PARAMETER_ACL:
            /* We treat these object types as being owned by superusers */
            if (!superuser_arg(roleid))
                ereport(ERROR,
                        (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                         errmsg("must be superuser")));
            break;
        case OBJECT_AMOP:
        case OBJECT_AMPROC:
        case OBJECT_DEFAULT:
        case OBJECT_DEFACL:
        case OBJECT_PUBLICATION_NAMESPACE:
        case OBJECT_PUBLICATION_REL:
        case OBJECT_USER_MAPPING:
            /* These are currently not supported or don't make sense here. */
            elog(ERROR, "unsupported object type: %d", (int) objtype);
            break;
    }
}

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

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

◆ get_catalog_object_by_oid()

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

Definition at line 2887 of file objectaddress.c.

{
    return
        get_catalog_object_by_oid_extended(catalog, oidcol, objectId, false);
}

References fb(), and get_catalog_object_by_oid_extended().

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

◆ get_catalog_object_by_oid_extended()

HeapTuple get_catalog_object_by_oid_extended	(	Relation	catalog,
		AttrNumber	oidcol,
		Oid	objectId,
		bool	locktup
	)

Definition at line 2900 of file objectaddress.c.

{
    HeapTuple   tuple;
    Oid         classId = RelationGetRelid(catalog);
    SysCacheIdentifier oidCacheId = get_object_catcache_oid(classId);
 
    if (oidCacheId >= 0)
    {
        if (locktup)
            tuple = SearchSysCacheLockedCopy1(oidCacheId,
                                              ObjectIdGetDatum(objectId));
        else
            tuple = SearchSysCacheCopy1(oidCacheId,
                                        ObjectIdGetDatum(objectId));
        if (!HeapTupleIsValid(tuple))   /* should not happen */
            return NULL;
    }
    else
    {
        Oid         oidIndexId = get_object_oid_index(classId);
        SysScanDesc scan;
        ScanKeyData skey;
 
        Assert(OidIsValid(oidIndexId));
 
        ScanKeyInit(&skey,
                    oidcol,
                    BTEqualStrategyNumber, F_OIDEQ,
                    ObjectIdGetDatum(objectId));
 
        scan = systable_beginscan(catalog, oidIndexId, true,
                                  NULL, 1, &skey);
        tuple = systable_getnext(scan);
        if (!HeapTupleIsValid(tuple))
        {
            systable_endscan(scan);
            return NULL;
        }
 
        if (locktup)
            LockTuple(catalog, &tuple->t_self, InplaceUpdateTupleLock);
 
        tuple = heap_copytuple(tuple);
 
        systable_endscan(scan);
    }
 
    return tuple;
}

References Assert, BTEqualStrategyNumber, fb(), get_object_catcache_oid(), get_object_oid_index(), heap_copytuple(), HeapTupleIsValid, InplaceUpdateTupleLock, LockTuple(), ObjectIdGetDatum(), OidIsValid, RelationGetRelid, ScanKeyInit(), SearchSysCacheCopy1, SearchSysCacheLockedCopy1(), systable_beginscan(), systable_endscan(), systable_getnext(), and HeapTupleData::t_self.

Referenced by AlterObjectOwner_internal(), and get_catalog_object_by_oid().

◆ get_object_address()

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

Definition at line 1010 of file objectaddress.c.

{
    ObjectAddress address = {InvalidOid, InvalidOid, 0};
    ObjectAddress old_address = {InvalidOid, InvalidOid, 0};
    Relation    relation = NULL;
    uint64      inval_count;
 
    /* Some kind of lock must be taken. */
    Assert(lockmode != NoLock);
 
    for (;;)
    {
        /*
         * Remember this value, so that, after looking up the object name and
         * locking it, we can check whether any invalidation messages have
         * been processed that might require a do-over.
         */
        inval_count = SharedInvalidMessageCounter;
 
        /* Look up object address. */
        switch (objtype)
        {
            case OBJECT_INDEX:
            case OBJECT_SEQUENCE:
            case OBJECT_TABLE:
            case OBJECT_VIEW:
            case OBJECT_MATVIEW:
            case OBJECT_FOREIGN_TABLE:
            case OBJECT_PROPGRAPH:
                address =
                    get_relation_by_qualified_name(objtype, castNode(List, object),
                                                   &relation, lockmode,
                                                   missing_ok);
                break;
            case OBJECT_ATTRIBUTE:
            case OBJECT_COLUMN:
                address =
                    get_object_address_attribute(objtype, castNode(List, object),
                                                 &relation, lockmode,
                                                 missing_ok);
                break;
            case OBJECT_DEFAULT:
                address =
                    get_object_address_attrdef(objtype, castNode(List, object),
                                               &relation, lockmode,
                                               missing_ok);
                break;
            case OBJECT_RULE:
            case OBJECT_TRIGGER:
            case OBJECT_TABCONSTRAINT:
            case OBJECT_POLICY:
                address = get_object_address_relobject(objtype, castNode(List, object),
                                                       &relation, missing_ok);
                break;
            case OBJECT_DOMCONSTRAINT:
                {
                    List       *objlist;
                    ObjectAddress domaddr;
                    char       *constrname;
 
                    objlist = castNode(List, object);
                    domaddr = get_object_address_type(OBJECT_DOMAIN,
                                                      linitial_node(TypeName, objlist),
                                                      missing_ok);
                    constrname = strVal(lsecond(objlist));
 
                    address.classId = ConstraintRelationId;
                    address.objectId = get_domain_constraint_oid(domaddr.objectId,
                                                                 constrname, missing_ok);
                    address.objectSubId = 0;
                }
                break;
            case OBJECT_DATABASE:
            case OBJECT_EXTENSION:
            case OBJECT_TABLESPACE:
            case OBJECT_ROLE:
            case OBJECT_SCHEMA:
            case OBJECT_LANGUAGE:
            case OBJECT_FDW:
            case OBJECT_FOREIGN_SERVER:
            case OBJECT_EVENT_TRIGGER:
            case OBJECT_PARAMETER_ACL:
            case OBJECT_ACCESS_METHOD:
            case OBJECT_PUBLICATION:
            case OBJECT_SUBSCRIPTION:
                address = get_object_address_unqualified(objtype,
                                                         castNode(String, object), missing_ok);
                break;
            case OBJECT_TYPE:
            case OBJECT_DOMAIN:
                address = get_object_address_type(objtype, castNode(TypeName, object), missing_ok);
                break;
            case OBJECT_AGGREGATE:
            case OBJECT_FUNCTION:
            case OBJECT_PROCEDURE:
            case OBJECT_ROUTINE:
                address.classId = ProcedureRelationId;
                address.objectId = LookupFuncWithArgs(objtype, castNode(ObjectWithArgs, object), missing_ok);
                address.objectSubId = 0;
                break;
            case OBJECT_OPERATOR:
                address.classId = OperatorRelationId;
                address.objectId = LookupOperWithArgs(castNode(ObjectWithArgs, object), missing_ok);
                address.objectSubId = 0;
                break;
            case OBJECT_COLLATION:
                address.classId = CollationRelationId;
                address.objectId = get_collation_oid(castNode(List, object), missing_ok);
                address.objectSubId = 0;
                break;
            case OBJECT_CONVERSION:
                address.classId = ConversionRelationId;
                address.objectId = get_conversion_oid(castNode(List, object), missing_ok);
                address.objectSubId = 0;
                break;
            case OBJECT_OPCLASS:
            case OBJECT_OPFAMILY:
                address = get_object_address_opcf(objtype, castNode(List, object), missing_ok);
                break;
            case OBJECT_AMOP:
            case OBJECT_AMPROC:
                address = get_object_address_opf_member(objtype, castNode(List, object), missing_ok);
                break;
            case OBJECT_LARGEOBJECT:
                address.classId = LargeObjectRelationId;
                address.objectId = oidparse(object);
                address.objectSubId = 0;
                if (!LargeObjectExists(address.objectId))
                {
                    if (!missing_ok)
                        ereport(ERROR,
                                (errcode(ERRCODE_UNDEFINED_OBJECT),
                                 errmsg("large object %u does not exist",
                                        address.objectId)));
                }
                break;
            case OBJECT_CAST:
                {
                    TypeName   *sourcetype = linitial_node(TypeName, castNode(List, object));
                    TypeName   *targettype = lsecond_node(TypeName, castNode(List, object));
                    Oid         sourcetypeid;
                    Oid         targettypeid;
 
                    sourcetypeid = LookupTypeNameOid(NULL, sourcetype, missing_ok);
                    targettypeid = LookupTypeNameOid(NULL, targettype, missing_ok);
                    address.classId = CastRelationId;
                    address.objectId =
                        get_cast_oid(sourcetypeid, targettypeid, missing_ok);
                    address.objectSubId = 0;
                }
                break;
            case OBJECT_TRANSFORM:
                {
                    TypeName   *typename = linitial_node(TypeName, castNode(List, object));
                    char       *langname = strVal(lsecond(castNode(List, object)));
                    Oid         type_id = LookupTypeNameOid(NULL, typename, missing_ok);
                    Oid         lang_id = get_language_oid(langname, missing_ok);
 
                    address.classId = TransformRelationId;
                    address.objectId =
                        get_transform_oid(type_id, lang_id, missing_ok);
                    address.objectSubId = 0;
                }
                break;
            case OBJECT_TSPARSER:
                address.classId = TSParserRelationId;
                address.objectId = get_ts_parser_oid(castNode(List, object), missing_ok);
                address.objectSubId = 0;
                break;
            case OBJECT_TSDICTIONARY:
                address.classId = TSDictionaryRelationId;
                address.objectId = get_ts_dict_oid(castNode(List, object), missing_ok);
                address.objectSubId = 0;
                break;
            case OBJECT_TSTEMPLATE:
                address.classId = TSTemplateRelationId;
                address.objectId = get_ts_template_oid(castNode(List, object), missing_ok);
                address.objectSubId = 0;
                break;
            case OBJECT_TSCONFIGURATION:
                address.classId = TSConfigRelationId;
                address.objectId = get_ts_config_oid(castNode(List, object), missing_ok);
                address.objectSubId = 0;
                break;
            case OBJECT_USER_MAPPING:
                address = get_object_address_usermapping(castNode(List, object),
                                                         missing_ok);
                break;
            case OBJECT_PUBLICATION_NAMESPACE:
                address = get_object_address_publication_schema(castNode(List, object),
                                                                missing_ok);
                break;
            case OBJECT_PUBLICATION_REL:
                address = get_object_address_publication_rel(castNode(List, object),
                                                             &relation,
                                                             missing_ok);
                break;
            case OBJECT_DEFACL:
                address = get_object_address_defacl(castNode(List, object),
                                                    missing_ok);
                break;
            case OBJECT_STATISTIC_EXT:
                address.classId = StatisticExtRelationId;
                address.objectId = get_statistics_object_oid(castNode(List, object),
                                                             missing_ok);
                address.objectSubId = 0;
                break;
                /* no default, to let compiler warn about missing case */
        }
 
        if (!address.classId)
            elog(ERROR, "unrecognized object type: %d", (int) objtype);
 
        /*
         * If we could not find the supplied object, return without locking.
         */
        if (!OidIsValid(address.objectId))
        {
            Assert(missing_ok);
            return address;
        }
 
        /*
         * If we're retrying, see if we got the same answer as last time.  If
         * so, we're done; if not, we locked the wrong thing, so give up our
         * lock.
         */
        if (OidIsValid(old_address.classId))
        {
            if (old_address.classId == address.classId
                && old_address.objectId == address.objectId
                && old_address.objectSubId == address.objectSubId)
                break;
            if (old_address.classId != RelationRelationId)
            {
                if (IsSharedRelation(old_address.classId))
                    UnlockSharedObject(old_address.classId,
                                       old_address.objectId,
                                       0, lockmode);
                else
                    UnlockDatabaseObject(old_address.classId,
                                         old_address.objectId,
                                         0, lockmode);
            }
        }
 
        /*
         * If we're dealing with a relation or attribute, then the relation is
         * already locked.  Otherwise, we lock it now.
         */
        if (address.classId != RelationRelationId)
        {
            if (IsSharedRelation(address.classId))
                LockSharedObject(address.classId, address.objectId, 0,
                                 lockmode);
            else
                LockDatabaseObject(address.classId, address.objectId, 0,
                                   lockmode);
        }
 
        /*
         * At this point, we've resolved the name to an OID and locked the
         * corresponding database object.  However, it's possible that by the
         * time we acquire the lock on the object, concurrent DDL has modified
         * the database in such a way that the name we originally looked up no
         * longer resolves to that OID.
         *
         * We can be certain that this isn't an issue if (a) no shared
         * invalidation messages have been processed or (b) we've locked a
         * relation somewhere along the line.  All the relation name lookups
         * in this module ultimately use RangeVarGetRelid() to acquire a
         * relation lock, and that function protects against the same kinds of
         * races we're worried about here.  Even when operating on a
         * constraint, rule, or trigger, we still acquire AccessShareLock on
         * the relation, which is enough to freeze out any concurrent DDL.
         *
         * In all other cases, however, it's possible that the name we looked
         * up no longer refers to the object we locked, so we retry the lookup
         * and see whether we get the same answer.
         */
        if (inval_count == SharedInvalidMessageCounter || relation != NULL)
            break;
        old_address = address;
    }
 
    /* relp must be given if it's a relation */
    Assert(!relation || relp);
 
    /* Return the object address and the relation. */
    if (relp)
        *relp = relation;
    return address;
}

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

◆ get_object_address_attrdef()

static ObjectAddress get_object_address_attrdef	(	ObjectType	objtype,
		List *	object,
		Relation *	relp,
		LOCKMODE	lockmode,
		bool	missing_ok
	)

static

Definition at line 1645 of file objectaddress.c.

{
    ObjectAddress address;
    List       *relname;
    Oid         reloid;
    Relation    relation;
    const char *attname;
    AttrNumber  attnum;
    TupleDesc   tupdesc;
    Oid         defoid;
 
    /* Extract relation name and open relation. */
    if (list_length(object) < 2)
        ereport(ERROR,
                (errcode(ERRCODE_SYNTAX_ERROR),
                 errmsg("column name must be qualified")));
    attname = strVal(llast(object));
    relname = list_copy_head(object, list_length(object) - 1);
    /* XXX no missing_ok support here */
    relation = relation_openrv(makeRangeVarFromNameList(relname), lockmode);
    reloid = RelationGetRelid(relation);
 
    tupdesc = RelationGetDescr(relation);
 
    /* Look up attribute number and fetch the pg_attrdef OID */
    attnum = get_attnum(reloid, attname);
    defoid = InvalidOid;
    if (attnum != InvalidAttrNumber && tupdesc->constr != NULL)
        defoid = GetAttrDefaultOid(reloid, attnum);
    if (!OidIsValid(defoid))
    {
        if (!missing_ok)
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_COLUMN),
                     errmsg("default value for column \"%s\" of relation \"%s\" does not exist",
                            attname, NameListToString(relname))));
 
        address.classId = AttrDefaultRelationId;
        address.objectId = InvalidOid;
        address.objectSubId = InvalidAttrNumber;
        relation_close(relation, lockmode);
        return address;
    }
 
    address.classId = AttrDefaultRelationId;
    address.objectId = defoid;
    address.objectSubId = 0;
 
    *relp = relation;
    return address;
}

References attname, attnum, ObjectAddress::classId, TupleDescData::constr, ereport, errcode(), errmsg, ERROR, fb(), get_attnum(), GetAttrDefaultOid(), InvalidAttrNumber, InvalidOid, list_copy_head(), list_length(), llast, makeRangeVarFromNameList(), NameListToString(), ObjectAddress::objectId, ObjectAddress::objectSubId, OidIsValid, relation_close(), relation_openrv(), RelationGetDescr, RelationGetRelid, relname, and strVal.

Referenced by get_object_address().

◆ get_object_address_attribute()

static ObjectAddress get_object_address_attribute	(	ObjectType	objtype,
		List *	object,
		Relation *	relp,
		LOCKMODE	lockmode,
		bool	missing_ok
	)

static

Definition at line 1594 of file objectaddress.c.

{
    ObjectAddress address;
    List       *relname;
    Oid         reloid;
    Relation    relation;
    const char *attname;
    AttrNumber  attnum;
 
    /* Extract relation name and open relation. */
    if (list_length(object) < 2)
        ereport(ERROR,
                (errcode(ERRCODE_SYNTAX_ERROR),
                 errmsg("column name must be qualified")));
    attname = strVal(llast(object));
    relname = list_copy_head(object, list_length(object) - 1);
    /* XXX no missing_ok support here */
    relation = relation_openrv(makeRangeVarFromNameList(relname), lockmode);
    reloid = RelationGetRelid(relation);
 
    /* Look up attribute and construct return value. */
    attnum = get_attnum(reloid, attname);
    if (attnum == InvalidAttrNumber)
    {
        if (!missing_ok)
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_COLUMN),
                     errmsg("column \"%s\" of relation \"%s\" does not exist",
                            attname, NameListToString(relname))));
 
        address.classId = RelationRelationId;
        address.objectId = InvalidOid;
        address.objectSubId = InvalidAttrNumber;
        relation_close(relation, lockmode);
        return address;
    }
 
    address.classId = RelationRelationId;
    address.objectId = reloid;
    address.objectSubId = attnum;
 
    *relp = relation;
    return address;
}

References attname, attnum, ObjectAddress::classId, ereport, errcode(), errmsg, ERROR, fb(), get_attnum(), InvalidAttrNumber, InvalidOid, list_copy_head(), list_length(), llast, makeRangeVarFromNameList(), NameListToString(), ObjectAddress::objectId, ObjectAddress::objectSubId, relation_close(), relation_openrv(), RelationGetRelid, relname, and strVal.

Referenced by get_object_address().

◆ get_object_address_defacl()

static ObjectAddress get_object_address_defacl	(	List *	object,
		bool	missing_ok
	)

static

Definition at line 2058 of file objectaddress.c.

{
    HeapTuple   tp;
    Oid         userid;
    Oid         schemaid;
    char       *username;
    char       *schema;
    char        objtype;
    char       *objtype_str;
    ObjectAddress address;
 
    ObjectAddressSet(address, DefaultAclRelationId, InvalidOid);
 
    /*
     * First figure out the textual attributes so that they can be used for
     * error reporting.
     */
    username = strVal(lsecond(object));
    if (list_length(object) >= 3)
        schema = (char *) strVal(lthird(object));
    else
        schema = NULL;
 
    /*
     * Decode defaclobjtype.  Only first char is considered; the rest of the
     * string, if any, is blissfully ignored.
     */
    objtype = ((char *) strVal(linitial(object)))[0];
    switch (objtype)
    {
        case DEFACLOBJ_RELATION:
            objtype_str = "tables";
            break;
        case DEFACLOBJ_SEQUENCE:
            objtype_str = "sequences";
            break;
        case DEFACLOBJ_FUNCTION:
            objtype_str = "functions";
            break;
        case DEFACLOBJ_TYPE:
            objtype_str = "types";
            break;
        case DEFACLOBJ_NAMESPACE:
            objtype_str = "schemas";
            break;
        case DEFACLOBJ_LARGEOBJECT:
            objtype_str = "large objects";
            break;
        default:
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("unrecognized default ACL object type \"%c\"", objtype),
                     errhint("Valid object types are \"%c\", \"%c\", \"%c\", \"%c\", \"%c\", \"%c\".",
                             DEFACLOBJ_RELATION,
                             DEFACLOBJ_SEQUENCE,
                             DEFACLOBJ_FUNCTION,
                             DEFACLOBJ_TYPE,
                             DEFACLOBJ_NAMESPACE,
                             DEFACLOBJ_LARGEOBJECT)));
    }
 
    /*
     * Look up user ID.  Behave as "default ACL not found" if the user doesn't
     * exist.
     */
    tp = SearchSysCache1(AUTHNAME,
                         CStringGetDatum(username));
    if (!HeapTupleIsValid(tp))
        goto not_found;
    userid = ((Form_pg_authid) GETSTRUCT(tp))->oid;
    ReleaseSysCache(tp);
 
    /*
     * If a schema name was given, look up its OID.  If it doesn't exist,
     * behave as "default ACL not found".
     */
    if (schema)
    {
        schemaid = get_namespace_oid(schema, true);
        if (schemaid == InvalidOid)
            goto not_found;
    }
    else
        schemaid = InvalidOid;
 
    /* Finally, look up the pg_default_acl object */
    tp = SearchSysCache3(DEFACLROLENSPOBJ,
                         ObjectIdGetDatum(userid),
                         ObjectIdGetDatum(schemaid),
                         CharGetDatum(objtype));
    if (!HeapTupleIsValid(tp))
        goto not_found;
 
    address.objectId = ((Form_pg_default_acl) GETSTRUCT(tp))->oid;
    ReleaseSysCache(tp);
 
    return address;
 
not_found:
    if (!missing_ok)
    {
        if (schema)
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_OBJECT),
                     errmsg("default ACL for user \"%s\" in schema \"%s\" on %s does not exist",
                            username, schema, objtype_str)));
        else
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_OBJECT),
                     errmsg("default ACL for user \"%s\" on %s does not exist",
                            username, objtype_str)));
    }
    return address;
}

References CharGetDatum(), CStringGetDatum(), ereport, errcode(), errhint(), errmsg, ERROR, fb(), Form_pg_authid, Form_pg_default_acl, get_namespace_oid(), GETSTRUCT(), HeapTupleIsValid, InvalidOid, linitial, list_length(), lsecond, lthird, ObjectAddressSet, ObjectAddress::objectId, ObjectIdGetDatum(), ReleaseSysCache(), SearchSysCache1(), SearchSysCache3(), strVal, and username.

Referenced by get_object_address().

◆ get_object_address_opcf()

static ObjectAddress get_object_address_opcf	(	ObjectType	objtype,
		List *	object,
		bool	missing_ok
	)

static

Definition at line 1742 of file objectaddress.c.

{
    Oid         amoid;
    ObjectAddress address;
 
    /* XXX no missing_ok support here */
    amoid = get_index_am_oid(strVal(linitial(object)), false);
    object = list_copy_tail(object, 1);
 
    switch (objtype)
    {
        case OBJECT_OPCLASS:
            address.classId = OperatorClassRelationId;
            address.objectId = get_opclass_oid(amoid, object, missing_ok);
            address.objectSubId = 0;
            break;
        case OBJECT_OPFAMILY:
            address.classId = OperatorFamilyRelationId;
            address.objectId = get_opfamily_oid(amoid, object, missing_ok);
            address.objectSubId = 0;
            break;
        default:
            elog(ERROR, "unrecognized object type: %d", (int) objtype);
            /* placate compiler, which doesn't know elog won't return */
            address.classId = InvalidOid;
            address.objectId = InvalidOid;
            address.objectSubId = 0;
    }
 
    return address;
}

References ObjectAddress::classId, elog, ERROR, fb(), get_index_am_oid(), get_opclass_oid(), get_opfamily_oid(), InvalidOid, linitial, list_copy_tail(), OBJECT_OPCLASS, OBJECT_OPFAMILY, ObjectAddress::objectId, ObjectAddress::objectSubId, and strVal.

Referenced by get_object_address(), and get_object_address_opf_member().

◆ get_object_address_opf_member()

static ObjectAddress get_object_address_opf_member	(	ObjectType	objtype,
		List *	object,
		bool	missing_ok
	)

static

Definition at line 1780 of file objectaddress.c.

{
    ObjectAddress famaddr;
    ObjectAddress address;
    ListCell   *cell;
    List       *copy;
    TypeName   *typenames[2];
    Oid         typeoids[2];
    int         membernum;
    int         i;
 
    /*
     * The last element of the object list contains the strategy or procedure
     * number.  We need to strip that out before getting the opclass/family
     * address.  The rest can be used directly by get_object_address_opcf().
     */
    membernum = atoi(strVal(llast(linitial(object))));
    copy = list_copy_head(linitial(object), list_length(linitial(object)) - 1);
 
    /* no missing_ok support here */
    famaddr = get_object_address_opcf(OBJECT_OPFAMILY, copy, false);
 
    /* find out left/right type names and OIDs */
    typenames[0] = typenames[1] = NULL;
    typeoids[0] = typeoids[1] = InvalidOid;
    i = 0;
    foreach(cell, lsecond(object))
    {
        ObjectAddress typaddr;
 
        typenames[i] = lfirst_node(TypeName, cell);
        typaddr = get_object_address_type(OBJECT_TYPE, typenames[i], missing_ok);
        typeoids[i] = typaddr.objectId;
        if (++i >= 2)
            break;
    }
 
    switch (objtype)
    {
        case OBJECT_AMOP:
            {
                HeapTuple   tp;
 
                ObjectAddressSet(address, AccessMethodOperatorRelationId,
                                 InvalidOid);
 
                tp = SearchSysCache4(AMOPSTRATEGY,
                                     ObjectIdGetDatum(famaddr.objectId),
                                     ObjectIdGetDatum(typeoids[0]),
                                     ObjectIdGetDatum(typeoids[1]),
                                     Int16GetDatum(membernum));
                if (!HeapTupleIsValid(tp))
                {
                    if (!missing_ok)
                        ereport(ERROR,
                                (errcode(ERRCODE_UNDEFINED_OBJECT),
                                 errmsg("operator %d (%s, %s) of %s does not exist",
                                        membernum,
                                        TypeNameToString(typenames[0]),
                                        TypeNameToString(typenames[1]),
                                        getObjectDescription(&famaddr, false))));
                }
                else
                {
                    address.objectId = ((Form_pg_amop) GETSTRUCT(tp))->oid;
                    ReleaseSysCache(tp);
                }
            }
            break;
 
        case OBJECT_AMPROC:
            {
                HeapTuple   tp;
 
                ObjectAddressSet(address, AccessMethodProcedureRelationId,
                                 InvalidOid);
 
                tp = SearchSysCache4(AMPROCNUM,
                                     ObjectIdGetDatum(famaddr.objectId),
                                     ObjectIdGetDatum(typeoids[0]),
                                     ObjectIdGetDatum(typeoids[1]),
                                     Int16GetDatum(membernum));
                if (!HeapTupleIsValid(tp))
                {
                    if (!missing_ok)
                        ereport(ERROR,
                                (errcode(ERRCODE_UNDEFINED_OBJECT),
                                 errmsg("function %d (%s, %s) of %s does not exist",
                                        membernum,
                                        TypeNameToString(typenames[0]),
                                        TypeNameToString(typenames[1]),
                                        getObjectDescription(&famaddr, false))));
                }
                else
                {
                    address.objectId = ((Form_pg_amproc) GETSTRUCT(tp))->oid;
                    ReleaseSysCache(tp);
                }
            }
            break;
        default:
            elog(ERROR, "unrecognized object type: %d", (int) objtype);
    }
 
    return address;
}

References elog, ereport, errcode(), errmsg, ERROR, fb(), Form_pg_amop, Form_pg_amproc, get_object_address_opcf(), get_object_address_type(), getObjectDescription(), GETSTRUCT(), HeapTupleIsValid, i, Int16GetDatum(), InvalidOid, lfirst_node, linitial, list_copy_head(), list_length(), llast, lsecond, OBJECT_AMOP, OBJECT_AMPROC, OBJECT_OPFAMILY, OBJECT_TYPE, ObjectAddressSet, ObjectAddress::objectId, ObjectIdGetDatum(), ReleaseSysCache(), SearchSysCache4(), strVal, typenames, and TypeNameToString().

Referenced by get_object_address().

◆ get_object_address_publication_rel()

static ObjectAddress get_object_address_publication_rel	(	List *	object,
		Relation *	relp,
		bool	missing_ok
	)

static

Definition at line 1963 of file objectaddress.c.

{
    ObjectAddress address;
    Relation    relation;
    List       *relname;
    char       *pubname;
    Publication *pub;
 
    ObjectAddressSet(address, PublicationRelRelationId, InvalidOid);
 
    relname = linitial(object);
    relation = relation_openrv_extended(makeRangeVarFromNameList(relname),
                                        AccessShareLock, missing_ok);
    if (!relation)
        return address;
 
    /* fetch publication name from input list */
    pubname = strVal(lsecond(object));
 
    /* Now look up the pg_publication tuple */
    pub = GetPublicationByName(pubname, missing_ok);
    if (!pub)
    {
        relation_close(relation, AccessShareLock);
        return address;
    }
 
    /* Find the publication relation mapping in syscache. */
    address.objectId =
        GetSysCacheOid2(PUBLICATIONRELMAP, Anum_pg_publication_rel_oid,
                        ObjectIdGetDatum(RelationGetRelid(relation)),
                        ObjectIdGetDatum(pub->oid));
    if (!OidIsValid(address.objectId))
    {
        if (!missing_ok)
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_OBJECT),
                     errmsg("publication relation \"%s\" in publication \"%s\" does not exist",
                            RelationGetRelationName(relation), pubname)));
        relation_close(relation, AccessShareLock);
        return address;
    }
 
    *relp = relation;
    return address;
}

References AccessShareLock, ereport, errcode(), errmsg, ERROR, fb(), GetPublicationByName(), GetSysCacheOid2, InvalidOid, linitial, lsecond, makeRangeVarFromNameList(), ObjectAddressSet, ObjectAddress::objectId, ObjectIdGetDatum(), Publication::oid, OidIsValid, relation_close(), relation_openrv_extended(), RelationGetRelationName, RelationGetRelid, relname, and strVal.

Referenced by get_object_address().

◆ get_object_address_publication_schema()

static ObjectAddress get_object_address_publication_schema	(	List *	object,
		bool	missing_ok
	)

static

Definition at line 2016 of file objectaddress.c.

{
    ObjectAddress address;
    Publication *pub;
    char       *pubname;
    char       *schemaname;
    Oid         schemaid;
 
    ObjectAddressSet(address, PublicationNamespaceRelationId, InvalidOid);
 
    /* Fetch schema name and publication name from input list */
    schemaname = strVal(linitial(object));
    pubname = strVal(lsecond(object));
 
    schemaid = get_namespace_oid(schemaname, missing_ok);
    if (!OidIsValid(schemaid))
        return address;
 
    /* Now look up the pg_publication tuple */
    pub = GetPublicationByName(pubname, missing_ok);
    if (!pub)
        return address;
 
    /* Find the publication schema mapping in syscache */
    address.objectId =
        GetSysCacheOid2(PUBLICATIONNAMESPACEMAP,
                        Anum_pg_publication_namespace_oid,
                        ObjectIdGetDatum(schemaid),
                        ObjectIdGetDatum(pub->oid));
    if (!OidIsValid(address.objectId) && !missing_ok)
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("publication schema \"%s\" in publication \"%s\" does not exist",
                        schemaname, pubname)));
 
    return address;
}

References ereport, errcode(), errmsg, ERROR, fb(), get_namespace_oid(), GetPublicationByName(), GetSysCacheOid2, InvalidOid, linitial, lsecond, ObjectAddressSet, ObjectAddress::objectId, ObjectIdGetDatum(), Publication::oid, OidIsValid, and strVal.

Referenced by get_object_address().

◆ get_object_address_relobject()

static ObjectAddress get_object_address_relobject	(	ObjectType	objtype,
		List *	object,
		Relation *	relp,
		bool	missing_ok
	)

static

Definition at line 1515 of file objectaddress.c.

{
    ObjectAddress address;
    Relation    relation = NULL;
    int         nnames;
    const char *depname;
    List       *relname;
    Oid         reloid;
 
    /* Extract name of dependent object. */
    depname = strVal(llast(object));
 
    /* Separate relation name from dependent object name. */
    nnames = list_length(object);
    if (nnames < 2)
        ereport(ERROR,
                (errcode(ERRCODE_SYNTAX_ERROR),
                 errmsg("must specify relation and object name")));
 
    /* Extract relation name and open relation. */
    relname = list_copy_head(object, nnames - 1);
    relation = table_openrv_extended(makeRangeVarFromNameList(relname),
                                     AccessShareLock,
                                     missing_ok);
 
    reloid = relation ? RelationGetRelid(relation) : InvalidOid;
 
    switch (objtype)
    {
        case OBJECT_RULE:
            address.classId = RewriteRelationId;
            address.objectId = relation ?
                get_rewrite_oid(reloid, depname, missing_ok) : InvalidOid;
            address.objectSubId = 0;
            break;
        case OBJECT_TRIGGER:
            address.classId = TriggerRelationId;
            address.objectId = relation ?
                get_trigger_oid(reloid, depname, missing_ok) : InvalidOid;
            address.objectSubId = 0;
            break;
        case OBJECT_TABCONSTRAINT:
            address.classId = ConstraintRelationId;
            address.objectId = relation ?
                get_relation_constraint_oid(reloid, depname, missing_ok) :
                InvalidOid;
            address.objectSubId = 0;
            break;
        case OBJECT_POLICY:
            address.classId = PolicyRelationId;
            address.objectId = relation ?
                get_relation_policy_oid(reloid, depname, missing_ok) :
                InvalidOid;
            address.objectSubId = 0;
            break;
        default:
            elog(ERROR, "unrecognized object type: %d", (int) objtype);
    }
 
    /* Avoid relcache leak when object not found. */
    if (!OidIsValid(address.objectId))
    {
        if (relation != NULL)
            table_close(relation, AccessShareLock);
 
        relation = NULL;        /* department of accident prevention */
        return address;
    }
 
    /* Done. */
    *relp = relation;
    return address;
}

References AccessShareLock, ObjectAddress::classId, elog, ereport, errcode(), errmsg, ERROR, fb(), get_relation_constraint_oid(), get_relation_policy_oid(), get_rewrite_oid(), get_trigger_oid(), InvalidOid, list_copy_head(), list_length(), llast, makeRangeVarFromNameList(), OBJECT_POLICY, OBJECT_RULE, OBJECT_TABCONSTRAINT, OBJECT_TRIGGER, ObjectAddress::objectId, ObjectAddress::objectSubId, OidIsValid, RelationGetRelid, relname, strVal, table_close(), and table_openrv_extended().

Referenced by get_object_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 1313 of file objectaddress.c.

{
    if (rel)
    {
        object = lcons(makeString(rel->relname), object);
        if (rel->schemaname)
            object = lcons(makeString(rel->schemaname), object);
        if (rel->catalogname)
            object = lcons(makeString(rel->catalogname), object);
    }
 
    return get_object_address(objtype, (Node *) object,
                              relp, lockmode, missing_ok);
}

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

Referenced by ExecAlterObjectDependsStmt(), and ExecAlterOwnerStmt().

◆ get_object_address_type()

static ObjectAddress get_object_address_type	(	ObjectType	objtype,
		TypeName *	typename,
		bool	missing_ok
	)

static

Definition at line 1703 of file objectaddress.c.

{
    ObjectAddress address;
    Type        tup;
 
    address.classId = TypeRelationId;
    address.objectId = InvalidOid;
    address.objectSubId = 0;
 
    tup = LookupTypeName(NULL, typename, NULL, missing_ok);
    if (!HeapTupleIsValid(tup))
    {
        if (!missing_ok)
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_OBJECT),
                     errmsg("type \"%s\" does not exist",
                            TypeNameToString(typename))));
        return address;
    }
    address.objectId = typeTypeId(tup);
 
    if (objtype == OBJECT_DOMAIN)
    {
        if (((Form_pg_type) GETSTRUCT(tup))->typtype != TYPTYPE_DOMAIN)
            ereport(ERROR,
                    (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                     errmsg("\"%s\" is not a domain",
                            TypeNameToString(typename))));
    }
 
    ReleaseSysCache(tup);
 
    return address;
}

References ObjectAddress::classId, ereport, errcode(), errmsg, ERROR, fb(), Form_pg_type, GETSTRUCT(), HeapTupleIsValid, InvalidOid, LookupTypeName(), OBJECT_DOMAIN, ObjectAddress::objectId, ObjectAddress::objectSubId, ReleaseSysCache(), TypeNameToString(), and typeTypeId().

Referenced by get_object_address(), and get_object_address_opf_member().

◆ get_object_address_unqualified()

static ObjectAddress get_object_address_unqualified	(	ObjectType	objtype,
		String *	strval,
		bool	missing_ok
	)

static

Definition at line 1335 of file objectaddress.c.

{
    const char *name;
    ObjectAddress address;
 
    name = strVal(strval);
 
    /* Translate name to OID. */
    switch (objtype)
    {
        case OBJECT_ACCESS_METHOD:
            address.classId = AccessMethodRelationId;
            address.objectId = get_am_oid(name, missing_ok);
            address.objectSubId = 0;
            break;
        case OBJECT_DATABASE:
            address.classId = DatabaseRelationId;
            address.objectId = get_database_oid(name, missing_ok);
            address.objectSubId = 0;
            break;
        case OBJECT_EXTENSION:
            address.classId = ExtensionRelationId;
            address.objectId = get_extension_oid(name, missing_ok);
            address.objectSubId = 0;
            break;
        case OBJECT_TABLESPACE:
            address.classId = TableSpaceRelationId;
            address.objectId = get_tablespace_oid(name, missing_ok);
            address.objectSubId = 0;
            break;
        case OBJECT_ROLE:
            address.classId = AuthIdRelationId;
            address.objectId = get_role_oid(name, missing_ok);
            address.objectSubId = 0;
            break;
        case OBJECT_SCHEMA:
            address.classId = NamespaceRelationId;
            address.objectId = get_namespace_oid(name, missing_ok);
            address.objectSubId = 0;
            break;
        case OBJECT_LANGUAGE:
            address.classId = LanguageRelationId;
            address.objectId = get_language_oid(name, missing_ok);
            address.objectSubId = 0;
            break;
        case OBJECT_FDW:
            address.classId = ForeignDataWrapperRelationId;
            address.objectId = get_foreign_data_wrapper_oid(name, missing_ok);
            address.objectSubId = 0;
            break;
        case OBJECT_FOREIGN_SERVER:
            address.classId = ForeignServerRelationId;
            address.objectId = get_foreign_server_oid(name, missing_ok);
            address.objectSubId = 0;
            break;
        case OBJECT_EVENT_TRIGGER:
            address.classId = EventTriggerRelationId;
            address.objectId = get_event_trigger_oid(name, missing_ok);
            address.objectSubId = 0;
            break;
        case OBJECT_PARAMETER_ACL:
            address.classId = ParameterAclRelationId;
            address.objectId = ParameterAclLookup(name, missing_ok);
            address.objectSubId = 0;
            break;
        case OBJECT_PUBLICATION:
            address.classId = PublicationRelationId;
            address.objectId = get_publication_oid(name, missing_ok);
            address.objectSubId = 0;
            break;
        case OBJECT_SUBSCRIPTION:
            address.classId = SubscriptionRelationId;
            address.objectId = get_subscription_oid(name, missing_ok);
            address.objectSubId = 0;
            break;
        default:
            elog(ERROR, "unrecognized object type: %d", (int) objtype);
            /* placate compiler, which doesn't know elog won't return */
            address.classId = InvalidOid;
            address.objectId = InvalidOid;
            address.objectSubId = 0;
    }
 
    return address;
}

References ObjectAddress::classId, elog, ERROR, fb(), get_am_oid(), get_database_oid(), get_event_trigger_oid(), get_extension_oid(), get_foreign_data_wrapper_oid(), get_foreign_server_oid(), get_language_oid(), get_namespace_oid(), get_publication_oid(), get_role_oid(), get_subscription_oid(), get_tablespace_oid(), InvalidOid, name, OBJECT_ACCESS_METHOD, OBJECT_DATABASE, OBJECT_EVENT_TRIGGER, OBJECT_EXTENSION, OBJECT_FDW, OBJECT_FOREIGN_SERVER, OBJECT_LANGUAGE, OBJECT_PARAMETER_ACL, OBJECT_PUBLICATION, OBJECT_ROLE, OBJECT_SCHEMA, OBJECT_SUBSCRIPTION, OBJECT_TABLESPACE, ObjectAddress::objectId, ObjectAddress::objectSubId, ParameterAclLookup(), and strVal.

Referenced by get_object_address().

◆ get_object_address_usermapping()

static ObjectAddress get_object_address_usermapping	(	List *	object,
		bool	missing_ok
	)

static

Definition at line 1892 of file objectaddress.c.

{
    ObjectAddress address;
    Oid         userid;
    char       *username;
    char       *servername;
    ForeignServer *server;
    HeapTuple   tp;
 
    ObjectAddressSet(address, UserMappingRelationId, InvalidOid);
 
    /* fetch string names from input lists, for error messages */
    username = strVal(linitial(object));
    servername = strVal(lsecond(object));
 
    /* look up pg_authid OID of mapped user; InvalidOid if PUBLIC */
    if (strcmp(username, "public") == 0)
        userid = InvalidOid;
    else
    {
        tp = SearchSysCache1(AUTHNAME,
                             CStringGetDatum(username));
        if (!HeapTupleIsValid(tp))
        {
            if (!missing_ok)
                ereport(ERROR,
                        (errcode(ERRCODE_UNDEFINED_OBJECT),
                         errmsg("user mapping for user \"%s\" on server \"%s\" does not exist",
                                username, servername)));
            return address;
        }
        userid = ((Form_pg_authid) GETSTRUCT(tp))->oid;
        ReleaseSysCache(tp);
    }
 
    /* Now look up the pg_user_mapping tuple */
    server = GetForeignServerByName(servername, true);
    if (!server)
    {
        if (!missing_ok)
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_OBJECT),
                     errmsg("server \"%s\" does not exist", servername)));
        return address;
    }
    tp = SearchSysCache2(USERMAPPINGUSERSERVER,
                         ObjectIdGetDatum(userid),
                         ObjectIdGetDatum(server->serverid));
    if (!HeapTupleIsValid(tp))
    {
        if (!missing_ok)
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_OBJECT),
                     errmsg("user mapping for user \"%s\" on server \"%s\" does not exist",
                            username, servername)));
        return address;
    }
 
    address.objectId = ((Form_pg_user_mapping) GETSTRUCT(tp))->oid;
 
    ReleaseSysCache(tp);
 
    return address;
}

References CStringGetDatum(), ereport, errcode(), errmsg, ERROR, fb(), Form_pg_authid, Form_pg_user_mapping, GetForeignServerByName(), GETSTRUCT(), HeapTupleIsValid, InvalidOid, linitial, lsecond, ObjectAddressSet, ObjectAddress::objectId, ObjectIdGetDatum(), ReleaseSysCache(), SearchSysCache1(), SearchSysCache2(), ForeignServer::serverid, strVal, and username.

Referenced by get_object_address().

◆ get_object_attnum_acl()

AttrNumber get_object_attnum_acl ( Oid class_id )

Definition at line 2790 of file objectaddress.c.

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

References ObjectPropertyType::attnum_acl, fb(), and get_object_property_data().

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

◆ get_object_attnum_name()

AttrNumber get_object_attnum_name ( Oid class_id )

Definition at line 2766 of file objectaddress.c.

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

References ObjectPropertyType::attnum_name, fb(), and get_object_property_data().

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

◆ get_object_attnum_namespace()

AttrNumber get_object_attnum_namespace ( Oid class_id )

Definition at line 2774 of file objectaddress.c.

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

References ObjectPropertyType::attnum_namespace, fb(), and get_object_property_data().

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

◆ get_object_attnum_oid()

AttrNumber get_object_attnum_oid ( Oid class_id )

Definition at line 2758 of file objectaddress.c.

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

References ObjectPropertyType::attnum_oid, fb(), and get_object_property_data().

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

◆ get_object_attnum_owner()

AttrNumber get_object_attnum_owner ( Oid class_id )

Definition at line 2782 of file objectaddress.c.

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

References ObjectPropertyType::attnum_owner, fb(), and get_object_property_data().

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

◆ get_object_catcache_name()

SysCacheIdentifier get_object_catcache_name ( Oid class_id )

Definition at line 2750 of file objectaddress.c.

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

References fb(), get_object_property_data(), and ObjectPropertyType::name_catcache_id.

Referenced by AlterObjectNamespace_internal(), and AlterObjectRename_internal().

◆ get_object_catcache_oid()

SysCacheIdentifier get_object_catcache_oid ( Oid class_id )

Definition at line 2742 of file objectaddress.c.

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

References fb(), get_object_property_data(), and ObjectPropertyType::oid_catcache_id.

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

◆ get_object_class_descr()

const char * get_object_class_descr ( Oid class_id )

Definition at line 2726 of file objectaddress.c.

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

References ObjectPropertyType::class_descr, fb(), and get_object_property_data().

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

◆ get_object_namensp_unique()

bool get_object_namensp_unique ( Oid class_id )

Definition at line 2823 of file objectaddress.c.

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

References fb(), get_object_property_data(), and ObjectPropertyType::is_nsp_name_unique.

Referenced by obtain_object_name_namespace(), and pg_identify_object().

◆ get_object_namespace()

Oid get_object_namespace ( const ObjectAddress * address )

Definition at line 2670 of file objectaddress.c.

{
    SysCacheIdentifier cache;
    HeapTuple   tuple;
    Oid         oid;
    const ObjectPropertyType *property;
 
    /* If not owned by a namespace, just return InvalidOid. */
    property = get_object_property_data(address->classId);
    if (property->attnum_namespace == InvalidAttrNumber)
        return InvalidOid;
 
    /* Currently, we can only handle object types with system caches. */
    cache = property->oid_catcache_id;
    Assert(cache != SYSCACHEID_INVALID);
 
    /* Fetch tuple from syscache and extract namespace attribute. */
    tuple = SearchSysCache1(cache, ObjectIdGetDatum(address->objectId));
    if (!HeapTupleIsValid(tuple))
        elog(ERROR, "cache lookup failed for cache %d oid %u",
             cache, address->objectId);
    oid = DatumGetObjectId(SysCacheGetAttrNotNull(cache,
                                                  tuple,
                                                  property->attnum_namespace));
    ReleaseSysCache(tuple);
 
    return oid;
}

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

Referenced by find_temp_object(), and RemoveObjects().

◆ get_object_oid_index()

Oid get_object_oid_index ( Oid class_id )

Definition at line 2734 of file objectaddress.c.

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

References fb(), get_object_property_data(), and ObjectPropertyType::oid_index_oid.

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

◆ get_object_property_data()

static const ObjectPropertyType * get_object_property_data ( Oid class_id )

static

Definition at line 2852 of file objectaddress.c.

{
    static const ObjectPropertyType *prop_last = NULL;
    int         index;
 
    /*
     * A shortcut to speed up multiple consecutive lookups of a particular
     * object class.
     */
    if (prop_last && prop_last->class_oid == class_id)
        return prop_last;
 
    for (index = 0; index < lengthof(ObjectProperty); index++)
    {
        if (ObjectProperty[index].class_oid == class_id)
        {
            prop_last = &ObjectProperty[index];
            return &ObjectProperty[index];
        }
    }
 
    ereport(ERROR,
            (errmsg_internal("unrecognized class ID: %u", class_id)));
 
    return NULL;                /* keep MSC compiler happy */
}

References ereport, errmsg_internal(), ERROR, fb(), lengthof, and ObjectProperty.

Referenced by get_object_attnum_acl(), get_object_attnum_name(), get_object_attnum_namespace(), get_object_attnum_oid(), get_object_attnum_owner(), get_object_catcache_name(), get_object_catcache_oid(), get_object_class_descr(), get_object_namensp_unique(), get_object_namespace(), get_object_oid_index(), and get_object_type().

◆ get_object_type()

ObjectType get_object_type	(	Oid	class_id,
		Oid	object_id
	)

Definition at line 2805 of file objectaddress.c.

{
    const ObjectPropertyType *prop = get_object_property_data(class_id);
 
    if (prop->objtype == OBJECT_TABLE)
    {
        /*
         * If the property data says it's a table, dig a little deeper to get
         * the real relation kind, so that callers can produce more precise
         * error messages.
         */
        return get_relkind_objtype(get_rel_relkind(object_id));
    }
    else
        return prop->objtype;
}

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

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

◆ get_relation_by_qualified_name()

static ObjectAddress get_relation_by_qualified_name	(	ObjectType	objtype,
		List *	object,
		Relation *	relp,
		LOCKMODE	lockmode,
		bool	missing_ok
	)

static

Definition at line 1426 of file objectaddress.c.

{
    Relation    relation;
    ObjectAddress address;
 
    address.classId = RelationRelationId;
    address.objectId = InvalidOid;
    address.objectSubId = 0;
 
    relation = relation_openrv_extended(makeRangeVarFromNameList(object),
                                        lockmode, missing_ok);
    if (!relation)
        return address;
 
    switch (objtype)
    {
        case OBJECT_INDEX:
            if (relation->rd_rel->relkind != RELKIND_INDEX &&
                relation->rd_rel->relkind != RELKIND_PARTITIONED_INDEX)
                ereport(ERROR,
                        (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                         errmsg("\"%s\" is not an index",
                                RelationGetRelationName(relation))));
            break;
        case OBJECT_PROPGRAPH:
            if (relation->rd_rel->relkind != RELKIND_PROPGRAPH)
                ereport(ERROR,
                        (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                         errmsg("\"%s\" is not a property graph",
                                RelationGetRelationName(relation))));
            break;
        case OBJECT_SEQUENCE:
            if (relation->rd_rel->relkind != RELKIND_SEQUENCE)
                ereport(ERROR,
                        (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                         errmsg("\"%s\" is not a sequence",
                                RelationGetRelationName(relation))));
            break;
        case OBJECT_TABLE:
            if (relation->rd_rel->relkind != RELKIND_RELATION &&
                relation->rd_rel->relkind != RELKIND_PARTITIONED_TABLE)
                ereport(ERROR,
                        (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                         errmsg("\"%s\" is not a table",
                                RelationGetRelationName(relation))));
            break;
        case OBJECT_VIEW:
            if (relation->rd_rel->relkind != RELKIND_VIEW)
                ereport(ERROR,
                        (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                         errmsg("\"%s\" is not a view",
                                RelationGetRelationName(relation))));
            break;
        case OBJECT_MATVIEW:
            if (relation->rd_rel->relkind != RELKIND_MATVIEW)
                ereport(ERROR,
                        (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                         errmsg("\"%s\" is not a materialized view",
                                RelationGetRelationName(relation))));
            break;
        case OBJECT_FOREIGN_TABLE:
            if (relation->rd_rel->relkind != RELKIND_FOREIGN_TABLE)
                ereport(ERROR,
                        (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                         errmsg("\"%s\" is not a foreign table",
                                RelationGetRelationName(relation))));
            break;
        default:
            elog(ERROR, "unrecognized object type: %d", (int) objtype);
            break;
    }
 
    /* Done. */
    address.objectId = RelationGetRelid(relation);
    *relp = relation;
 
    return address;
}

References ObjectAddress::classId, elog, ereport, errcode(), errmsg, ERROR, fb(), InvalidOid, makeRangeVarFromNameList(), OBJECT_FOREIGN_TABLE, OBJECT_INDEX, OBJECT_MATVIEW, OBJECT_PROPGRAPH, OBJECT_SEQUENCE, OBJECT_TABLE, OBJECT_VIEW, ObjectAddress::objectId, ObjectAddress::objectSubId, RelationData::rd_rel, relation_openrv_extended(), RelationGetRelationName, and RelationGetRelid.

Referenced by get_object_address().

◆ get_relkind_objtype()

ObjectType get_relkind_objtype ( char relkind )

Definition at line 6519 of file objectaddress.c.

{
    switch (relkind)
    {
        case RELKIND_RELATION:
        case RELKIND_PARTITIONED_TABLE:
            return OBJECT_TABLE;
        case RELKIND_INDEX:
        case RELKIND_PARTITIONED_INDEX:
            return OBJECT_INDEX;
        case RELKIND_SEQUENCE:
            return OBJECT_SEQUENCE;
        case RELKIND_VIEW:
            return OBJECT_VIEW;
        case RELKIND_MATVIEW:
            return OBJECT_MATVIEW;
        case RELKIND_FOREIGN_TABLE:
            return OBJECT_FOREIGN_TABLE;
        case RELKIND_PROPGRAPH:
            return OBJECT_PROPGRAPH;
        case RELKIND_TOASTVALUE:
            return OBJECT_TABLE;
        default:
            /* Per above, don't raise an error */
            return OBJECT_TABLE;
    }
}

References fb(), OBJECT_FOREIGN_TABLE, OBJECT_INDEX, OBJECT_MATVIEW, OBJECT_PROPGRAPH, OBJECT_SEQUENCE, OBJECT_TABLE, and OBJECT_VIEW.

◆ getConstraintTypeDescription()

static void getConstraintTypeDescription	(	StringInfo	buffer,
		Oid	constroid,
		bool	missing_ok
	)

static

Definition at line 5016 of file objectaddress.c.

{
    Relation    constrRel;
    HeapTuple   constrTup;
    Form_pg_constraint constrForm;
 
    constrRel = table_open(ConstraintRelationId, AccessShareLock);
    constrTup = get_catalog_object_by_oid(constrRel, Anum_pg_constraint_oid,
                                          constroid);
    if (!HeapTupleIsValid(constrTup))
    {
        if (!missing_ok)
            elog(ERROR, "cache lookup failed for constraint %u", constroid);
 
        table_close(constrRel, AccessShareLock);
 
        /* fallback to "constraint" for an undefined object */
        appendStringInfoString(buffer, "constraint");
        return;
    }
 
    constrForm = (Form_pg_constraint) GETSTRUCT(constrTup);
 
    if (OidIsValid(constrForm->conrelid))
        appendStringInfoString(buffer, "table constraint");
    else if (OidIsValid(constrForm->contypid))
        appendStringInfoString(buffer, "domain constraint");
    else
        elog(ERROR, "invalid constraint %u", constrForm->oid);
 
    table_close(constrRel, AccessShareLock);
}

References AccessShareLock, appendStringInfoString(), elog, ERROR, fb(), Form_pg_constraint, get_catalog_object_by_oid(), GETSTRUCT(), HeapTupleIsValid, OidIsValid, table_close(), and table_open().

Referenced by getObjectTypeDescription().

◆ getObjectDescription()

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

Definition at line 3009 of file objectaddress.c.

{
    StringInfoData buffer;
 
    initStringInfo(&buffer);
 
    switch (object->classId)
    {
        case RelationRelationId:
            if (object->objectSubId == 0)
                getRelationDescription(&buffer, object->objectId, missing_ok);
            else
            {
                /* column, not whole relation */
                StringInfoData rel;
                char       *attname = get_attname(object->objectId,
                                                  object->objectSubId,
                                                  missing_ok);
 
                if (!attname)
                    break;
 
                initStringInfo(&rel);
                getRelationDescription(&rel, object->objectId, missing_ok);
                /* translator: second %s is, e.g., "table %s" */
                appendStringInfo(&buffer, _("column %s of %s"),
                                 attname, rel.data);
                pfree(rel.data);
            }
            break;
 
        case ProcedureRelationId:
            {
                bits16      flags = FORMAT_PROC_INVALID_AS_NULL;
                char       *proname = format_procedure_extended(object->objectId,
                                                                flags);
 
                if (proname == NULL)
                    break;
 
                appendStringInfo(&buffer, _("function %s"), proname);
                break;
            }
 
        case TypeRelationId:
            {
                bits16      flags = FORMAT_TYPE_INVALID_AS_NULL;
                char       *typname = format_type_extended(object->objectId, -1,
                                                           flags);
 
                if (typname == NULL)
                    break;
 
                appendStringInfo(&buffer, _("type %s"), typname);
                break;
            }
 
        case CastRelationId:
            {
                Relation    castDesc;
                ScanKeyData skey[1];
                SysScanDesc rcscan;
                HeapTuple   tup;
                Form_pg_cast castForm;
 
                castDesc = table_open(CastRelationId, AccessShareLock);
 
                ScanKeyInit(&skey[0],
                            Anum_pg_cast_oid,
                            BTEqualStrategyNumber, F_OIDEQ,
                            ObjectIdGetDatum(object->objectId));
 
                rcscan = systable_beginscan(castDesc, CastOidIndexId, true,
                                            NULL, 1, skey);
 
                tup = systable_getnext(rcscan);
 
                if (!HeapTupleIsValid(tup))
                {
                    if (!missing_ok)
                        elog(ERROR, "could not find tuple for cast %u",
                             object->objectId);
 
                    systable_endscan(rcscan);
                    table_close(castDesc, AccessShareLock);
                    break;
                }
 
                castForm = (Form_pg_cast) GETSTRUCT(tup);
 
                appendStringInfo(&buffer, _("cast from %s to %s"),
                                 format_type_be(castForm->castsource),
                                 format_type_be(castForm->casttarget));
 
                systable_endscan(rcscan);
                table_close(castDesc, AccessShareLock);
                break;
            }
 
        case CollationRelationId:
            {
                HeapTuple   collTup;
                Form_pg_collation coll;
                char       *nspname;
 
                collTup = SearchSysCache1(COLLOID,
                                          ObjectIdGetDatum(object->objectId));
                if (!HeapTupleIsValid(collTup))
                {
                    if (!missing_ok)
                        elog(ERROR, "cache lookup failed for collation %u",
                             object->objectId);
                    break;
                }
 
                coll = (Form_pg_collation) GETSTRUCT(collTup);
 
                /* Qualify the name if not visible in search path */
                if (CollationIsVisible(object->objectId))
                    nspname = NULL;
                else
                    nspname = get_namespace_name(coll->collnamespace);
 
                appendStringInfo(&buffer, _("collation %s"),
                                 quote_qualified_identifier(nspname,
                                                            NameStr(coll->collname)));
                ReleaseSysCache(collTup);
                break;
            }
 
        case ConstraintRelationId:
            {
                HeapTuple   conTup;
                Form_pg_constraint con;
 
                conTup = SearchSysCache1(CONSTROID,
                                         ObjectIdGetDatum(object->objectId));
                if (!HeapTupleIsValid(conTup))
                {
                    if (!missing_ok)
                        elog(ERROR, "cache lookup failed for constraint %u",
                             object->objectId);
                    break;
                }
 
                con = (Form_pg_constraint) GETSTRUCT(conTup);
 
                if (OidIsValid(con->conrelid))
                {
                    StringInfoData rel;
 
                    initStringInfo(&rel);
                    getRelationDescription(&rel, con->conrelid, false);
                    /* translator: second %s is, e.g., "table %s" */
                    appendStringInfo(&buffer, _("constraint %s on %s"),
                                     NameStr(con->conname), rel.data);
                    pfree(rel.data);
                }
                else
                {
                    appendStringInfo(&buffer, _("constraint %s"),
                                     NameStr(con->conname));
                }
 
                ReleaseSysCache(conTup);
                break;
            }
 
        case ConversionRelationId:
            {
                HeapTuple   conTup;
                Form_pg_conversion conv;
                char       *nspname;
 
                conTup = SearchSysCache1(CONVOID,
                                         ObjectIdGetDatum(object->objectId));
                if (!HeapTupleIsValid(conTup))
                {
                    if (!missing_ok)
                        elog(ERROR, "cache lookup failed for conversion %u",
                             object->objectId);
                    break;
                }
 
                conv = (Form_pg_conversion) GETSTRUCT(conTup);
 
                /* Qualify the name if not visible in search path */
                if (ConversionIsVisible(object->objectId))
                    nspname = NULL;
                else
                    nspname = get_namespace_name(conv->connamespace);
 
                appendStringInfo(&buffer, _("conversion %s"),
                                 quote_qualified_identifier(nspname,
                                                            NameStr(conv->conname)));
                ReleaseSysCache(conTup);
                break;
            }
 
        case AttrDefaultRelationId:
            {
                ObjectAddress colobject;
 
                colobject = GetAttrDefaultColumnAddress(object->objectId);
 
                if (!OidIsValid(colobject.objectId))
                {
                    if (!missing_ok)
                        elog(ERROR, "could not find tuple for attrdef %u",
                             object->objectId);
                    break;
                }
 
                /* translator: %s is typically "column %s of table %s" */
                appendStringInfo(&buffer, _("default value for %s"),
                                 getObjectDescription(&colobject, false));
                break;
            }
 
        case LanguageRelationId:
            {
                char       *langname = get_language_name(object->objectId,
                                                         missing_ok);
 
                if (langname)
                    appendStringInfo(&buffer, _("language %s"),
                                     get_language_name(object->objectId, false));
                break;
            }
 
        case LargeObjectRelationId:
            if (!LargeObjectExists(object->objectId))
                break;
            appendStringInfo(&buffer, _("large object %u"),
                             object->objectId);
            break;
 
        case OperatorRelationId:
            {
                bits16      flags = FORMAT_OPERATOR_INVALID_AS_NULL;
                char       *oprname = format_operator_extended(object->objectId,
                                                               flags);
 
                if (oprname == NULL)
                    break;
 
                appendStringInfo(&buffer, _("operator %s"), oprname);
                break;
            }
 
        case OperatorClassRelationId:
            {
                HeapTuple   opcTup;
                Form_pg_opclass opcForm;
                HeapTuple   amTup;
                Form_pg_am  amForm;
                char       *nspname;
 
                opcTup = SearchSysCache1(CLAOID,
                                         ObjectIdGetDatum(object->objectId));
                if (!HeapTupleIsValid(opcTup))
                {
                    if (!missing_ok)
                        elog(ERROR, "cache lookup failed for opclass %u",
                             object->objectId);
                    break;
                }
 
                opcForm = (Form_pg_opclass) GETSTRUCT(opcTup);
 
                amTup = SearchSysCache1(AMOID,
                                        ObjectIdGetDatum(opcForm->opcmethod));
                if (!HeapTupleIsValid(amTup))
                    elog(ERROR, "cache lookup failed for access method %u",
                         opcForm->opcmethod);
                amForm = (Form_pg_am) GETSTRUCT(amTup);
 
                /* Qualify the name if not visible in search path */
                if (OpclassIsVisible(object->objectId))
                    nspname = NULL;
                else
                    nspname = get_namespace_name(opcForm->opcnamespace);
 
                appendStringInfo(&buffer, _("operator class %s for access method %s"),
                                 quote_qualified_identifier(nspname,
                                                            NameStr(opcForm->opcname)),
                                 NameStr(amForm->amname));
 
                ReleaseSysCache(amTup);
                ReleaseSysCache(opcTup);
                break;
            }
 
        case OperatorFamilyRelationId:
            getOpFamilyDescription(&buffer, object->objectId, missing_ok);
            break;
 
        case AccessMethodRelationId:
            {
                HeapTuple   tup;
 
                tup = SearchSysCache1(AMOID,
                                      ObjectIdGetDatum(object->objectId));
                if (!HeapTupleIsValid(tup))
                {
                    if (!missing_ok)
                        elog(ERROR, "cache lookup failed for access method %u",
                             object->objectId);
                    break;
                }
 
                appendStringInfo(&buffer, _("access method %s"),
                                 NameStr(((Form_pg_am) GETSTRUCT(tup))->amname));
                ReleaseSysCache(tup);
                break;
            }
 
        case AccessMethodOperatorRelationId:
            {
                Relation    amopDesc;
                HeapTuple   tup;
                ScanKeyData skey[1];
                SysScanDesc amscan;
                Form_pg_amop amopForm;
                StringInfoData opfam;
 
                amopDesc = table_open(AccessMethodOperatorRelationId,
                                      AccessShareLock);
 
                ScanKeyInit(&skey[0],
                            Anum_pg_amop_oid,
                            BTEqualStrategyNumber, F_OIDEQ,
                            ObjectIdGetDatum(object->objectId));
 
                amscan = systable_beginscan(amopDesc, AccessMethodOperatorOidIndexId, true,
                                            NULL, 1, skey);
 
                tup = systable_getnext(amscan);
 
                if (!HeapTupleIsValid(tup))
                {
                    if (!missing_ok)
                        elog(ERROR, "could not find tuple for amop entry %u",
                             object->objectId);
 
                    systable_endscan(amscan);
                    table_close(amopDesc, AccessShareLock);
                    break;
                }
 
                amopForm = (Form_pg_amop) GETSTRUCT(tup);
 
                initStringInfo(&opfam);
                getOpFamilyDescription(&opfam, amopForm->amopfamily, false);
 
                /*
                 * We use FORMAT_TYPE_ALLOW_INVALID here so as not to fail
                 * completely if the type links are dangling, which is a form
                 * of catalog corruption that could occur due to old bugs.
                 */
 
                /*------
                   translator: %d is the operator strategy (a number), the
                   first two %s's are data type names, the third %s is the
                   description of the operator family, and the last %s is the
                   textual form of the operator with arguments.  */
                appendStringInfo(&buffer, _("operator %d (%s, %s) of %s: %s"),
                                 amopForm->amopstrategy,
                                 format_type_extended(amopForm->amoplefttype,
                                                      -1, FORMAT_TYPE_ALLOW_INVALID),
                                 format_type_extended(amopForm->amoprighttype,
                                                      -1, FORMAT_TYPE_ALLOW_INVALID),
                                 opfam.data,
                                 format_operator(amopForm->amopopr));
 
                pfree(opfam.data);
 
                systable_endscan(amscan);
                table_close(amopDesc, AccessShareLock);
                break;
            }
 
        case AccessMethodProcedureRelationId:
            {
                Relation    amprocDesc;
                ScanKeyData skey[1];
                SysScanDesc amscan;
                HeapTuple   tup;
                Form_pg_amproc amprocForm;
                StringInfoData opfam;
 
                amprocDesc = table_open(AccessMethodProcedureRelationId,
                                        AccessShareLock);
 
                ScanKeyInit(&skey[0],
                            Anum_pg_amproc_oid,
                            BTEqualStrategyNumber, F_OIDEQ,
                            ObjectIdGetDatum(object->objectId));
 
                amscan = systable_beginscan(amprocDesc, AccessMethodProcedureOidIndexId, true,
                                            NULL, 1, skey);
 
                tup = systable_getnext(amscan);
 
                if (!HeapTupleIsValid(tup))
                {
                    if (!missing_ok)
                        elog(ERROR, "could not find tuple for amproc entry %u",
                             object->objectId);
 
                    systable_endscan(amscan);
                    table_close(amprocDesc, AccessShareLock);
                    break;
                }
 
                amprocForm = (Form_pg_amproc) GETSTRUCT(tup);
 
                initStringInfo(&opfam);
                getOpFamilyDescription(&opfam, amprocForm->amprocfamily, false);
 
                /*
                 * We use FORMAT_TYPE_ALLOW_INVALID here so as not to fail
                 * completely if the type links are dangling, which is a form
                 * of catalog corruption that could occur due to old bugs.
                 */
 
                /*------
                   translator: %d is the function number, the first two %s's
                   are data type names, the third %s is the description of the
                   operator family, and the last %s is the textual form of the
                   function with arguments.  */
                appendStringInfo(&buffer, _("function %d (%s, %s) of %s: %s"),
                                 amprocForm->amprocnum,
                                 format_type_extended(amprocForm->amproclefttype,
                                                      -1, FORMAT_TYPE_ALLOW_INVALID),
                                 format_type_extended(amprocForm->amprocrighttype,
                                                      -1, FORMAT_TYPE_ALLOW_INVALID),
                                 opfam.data,
                                 format_procedure(amprocForm->amproc));
 
                pfree(opfam.data);
 
                systable_endscan(amscan);
                table_close(amprocDesc, AccessShareLock);
                break;
            }
 
        case RewriteRelationId:
            {
                Relation    ruleDesc;
                ScanKeyData skey[1];
                SysScanDesc rcscan;
                HeapTuple   tup;
                Form_pg_rewrite rule;
                StringInfoData rel;
 
                ruleDesc = table_open(RewriteRelationId, AccessShareLock);
 
                ScanKeyInit(&skey[0],
                            Anum_pg_rewrite_oid,
                            BTEqualStrategyNumber, F_OIDEQ,
                            ObjectIdGetDatum(object->objectId));
 
                rcscan = systable_beginscan(ruleDesc, RewriteOidIndexId, true,
                                            NULL, 1, skey);
 
                tup = systable_getnext(rcscan);
 
                if (!HeapTupleIsValid(tup))
                {
                    if (!missing_ok)
                        elog(ERROR, "could not find tuple for rule %u",
                             object->objectId);
 
                    systable_endscan(rcscan);
                    table_close(ruleDesc, AccessShareLock);
                    break;
                }
 
                rule = (Form_pg_rewrite) GETSTRUCT(tup);
 
                initStringInfo(&rel);
                getRelationDescription(&rel, rule->ev_class, false);
 
                /* translator: second %s is, e.g., "table %s" */
                appendStringInfo(&buffer, _("rule %s on %s"),
                                 NameStr(rule->rulename), rel.data);
                pfree(rel.data);
                systable_endscan(rcscan);
                table_close(ruleDesc, AccessShareLock);
                break;
            }
 
        case TriggerRelationId:
            {
                Relation    trigDesc;
                ScanKeyData skey[1];
                SysScanDesc tgscan;
                HeapTuple   tup;
                Form_pg_trigger trig;
                StringInfoData rel;
 
                trigDesc = table_open(TriggerRelationId, AccessShareLock);
 
                ScanKeyInit(&skey[0],
                            Anum_pg_trigger_oid,
                            BTEqualStrategyNumber, F_OIDEQ,
                            ObjectIdGetDatum(object->objectId));
 
                tgscan = systable_beginscan(trigDesc, TriggerOidIndexId, true,
                                            NULL, 1, skey);
 
                tup = systable_getnext(tgscan);
 
                if (!HeapTupleIsValid(tup))
                {
                    if (!missing_ok)
                        elog(ERROR, "could not find tuple for trigger %u",
                             object->objectId);
 
                    systable_endscan(tgscan);
                    table_close(trigDesc, AccessShareLock);
                    break;
                }
 
                trig = (Form_pg_trigger) GETSTRUCT(tup);
 
                initStringInfo(&rel);
                getRelationDescription(&rel, trig->tgrelid, false);
 
                /* translator: second %s is, e.g., "table %s" */
                appendStringInfo(&buffer, _("trigger %s on %s"),
                                 NameStr(trig->tgname), rel.data);
                pfree(rel.data);
                systable_endscan(tgscan);
                table_close(trigDesc, AccessShareLock);
                break;
            }
 
        case NamespaceRelationId:
            {
                char       *nspname;
 
                nspname = get_namespace_name(object->objectId);
                if (!nspname)
                {
                    if (!missing_ok)
                        elog(ERROR, "cache lookup failed for namespace %u",
                             object->objectId);
                    break;
                }
                appendStringInfo(&buffer, _("schema %s"), nspname);
                break;
            }
 
        case StatisticExtRelationId:
            {
                HeapTuple   stxTup;
                Form_pg_statistic_ext stxForm;
                char       *nspname;
 
                stxTup = SearchSysCache1(STATEXTOID,
                                         ObjectIdGetDatum(object->objectId));
                if (!HeapTupleIsValid(stxTup))
                {
                    if (!missing_ok)
                        elog(ERROR, "could not find tuple for statistics object %u",
                             object->objectId);
                    break;
                }
 
                stxForm = (Form_pg_statistic_ext) GETSTRUCT(stxTup);
 
                /* Qualify the name if not visible in search path */
                if (StatisticsObjIsVisible(object->objectId))
                    nspname = NULL;
                else
                    nspname = get_namespace_name(stxForm->stxnamespace);
 
                appendStringInfo(&buffer, _("statistics object %s"),
                                 quote_qualified_identifier(nspname,
                                                            NameStr(stxForm->stxname)));
 
                ReleaseSysCache(stxTup);
                break;
            }
 
        case TSParserRelationId:
            {
                HeapTuple   tup;
                Form_pg_ts_parser prsForm;
                char       *nspname;
 
                tup = SearchSysCache1(TSPARSEROID,
                                      ObjectIdGetDatum(object->objectId));
                if (!HeapTupleIsValid(tup))
                {
                    if (!missing_ok)
                        elog(ERROR, "cache lookup failed for text search parser %u",
                             object->objectId);
                    break;
                }
                prsForm = (Form_pg_ts_parser) GETSTRUCT(tup);
 
                /* Qualify the name if not visible in search path */
                if (TSParserIsVisible(object->objectId))
                    nspname = NULL;
                else
                    nspname = get_namespace_name(prsForm->prsnamespace);
 
                appendStringInfo(&buffer, _("text search parser %s"),
                                 quote_qualified_identifier(nspname,
                                                            NameStr(prsForm->prsname)));
                ReleaseSysCache(tup);
                break;
            }
 
        case TSDictionaryRelationId:
            {
                HeapTuple   tup;
                Form_pg_ts_dict dictForm;
                char       *nspname;
 
                tup = SearchSysCache1(TSDICTOID,
                                      ObjectIdGetDatum(object->objectId));
                if (!HeapTupleIsValid(tup))
                {
                    if (!missing_ok)
                        elog(ERROR, "cache lookup failed for text search dictionary %u",
                             object->objectId);
                    break;
                }
 
                dictForm = (Form_pg_ts_dict) GETSTRUCT(tup);
 
                /* Qualify the name if not visible in search path */
                if (TSDictionaryIsVisible(object->objectId))
                    nspname = NULL;
                else
                    nspname = get_namespace_name(dictForm->dictnamespace);
 
                appendStringInfo(&buffer, _("text search dictionary %s"),
                                 quote_qualified_identifier(nspname,
                                                            NameStr(dictForm->dictname)));
                ReleaseSysCache(tup);
                break;
            }
 
        case TSTemplateRelationId:
            {
                HeapTuple   tup;
                Form_pg_ts_template tmplForm;
                char       *nspname;
 
                tup = SearchSysCache1(TSTEMPLATEOID,
                                      ObjectIdGetDatum(object->objectId));
                if (!HeapTupleIsValid(tup))
                {
                    if (!missing_ok)
                        elog(ERROR, "cache lookup failed for text search template %u",
                             object->objectId);
                    break;
                }
 
                tmplForm = (Form_pg_ts_template) GETSTRUCT(tup);
 
                /* Qualify the name if not visible in search path */
                if (TSTemplateIsVisible(object->objectId))
                    nspname = NULL;
                else
                    nspname = get_namespace_name(tmplForm->tmplnamespace);
 
                appendStringInfo(&buffer, _("text search template %s"),
                                 quote_qualified_identifier(nspname,
                                                            NameStr(tmplForm->tmplname)));
                ReleaseSysCache(tup);
                break;
            }
 
        case TSConfigRelationId:
            {
                HeapTuple   tup;
                Form_pg_ts_config cfgForm;
                char       *nspname;
 
                tup = SearchSysCache1(TSCONFIGOID,
                                      ObjectIdGetDatum(object->objectId));
                if (!HeapTupleIsValid(tup))
                {
                    if (!missing_ok)
                        elog(ERROR, "cache lookup failed for text search configuration %u",
                             object->objectId);
                    break;
                }
 
                cfgForm = (Form_pg_ts_config) GETSTRUCT(tup);
 
                /* Qualify the name if not visible in search path */
                if (TSConfigIsVisible(object->objectId))
                    nspname = NULL;
                else
                    nspname = get_namespace_name(cfgForm->cfgnamespace);
 
                appendStringInfo(&buffer, _("text search configuration %s"),
                                 quote_qualified_identifier(nspname,
                                                            NameStr(cfgForm->cfgname)));
                ReleaseSysCache(tup);
                break;
            }
 
        case AuthIdRelationId:
            {
                char       *username = GetUserNameFromId(object->objectId,
                                                         missing_ok);
 
                if (username)
                    appendStringInfo(&buffer, _("role %s"), username);
                break;
            }
 
        case AuthMemRelationId:
            {
                Relation    amDesc;
                ScanKeyData skey[1];
                SysScanDesc rcscan;
                HeapTuple   tup;
                Form_pg_auth_members amForm;
 
                amDesc = table_open(AuthMemRelationId, AccessShareLock);
 
                ScanKeyInit(&skey[0],
                            Anum_pg_auth_members_oid,
                            BTEqualStrategyNumber, F_OIDEQ,
                            ObjectIdGetDatum(object->objectId));
 
                rcscan = systable_beginscan(amDesc, AuthMemOidIndexId, true,
                                            NULL, 1, skey);
 
                tup = systable_getnext(rcscan);
 
                if (!HeapTupleIsValid(tup))
                {
                    if (!missing_ok)
                        elog(ERROR, "could not find tuple for role membership %u",
                             object->objectId);
 
                    systable_endscan(rcscan);
                    table_close(amDesc, AccessShareLock);
                    break;
                }
 
                amForm = (Form_pg_auth_members) GETSTRUCT(tup);
 
                appendStringInfo(&buffer, _("membership of role %s in role %s"),
                                 GetUserNameFromId(amForm->member, false),
                                 GetUserNameFromId(amForm->roleid, false));
 
                systable_endscan(rcscan);
                table_close(amDesc, AccessShareLock);
                break;
            }
 
        case DatabaseRelationId:
            {
                char       *datname;
 
                datname = get_database_name(object->objectId);
                if (!datname)
                {
                    if (!missing_ok)
                        elog(ERROR, "cache lookup failed for database %u",
                             object->objectId);
                    break;
                }
                appendStringInfo(&buffer, _("database %s"), datname);
                break;
            }
 
        case TableSpaceRelationId:
            {
                char       *tblspace;
 
                tblspace = get_tablespace_name(object->objectId);
                if (!tblspace)
                {
                    if (!missing_ok)
                        elog(ERROR, "cache lookup failed for tablespace %u",
                             object->objectId);
                    break;
                }
                appendStringInfo(&buffer, _("tablespace %s"), tblspace);
                break;
            }
 
        case ForeignDataWrapperRelationId:
            {
                ForeignDataWrapper *fdw;
 
                fdw = GetForeignDataWrapperExtended(object->objectId,
                                                    missing_ok);
                if (fdw)
                    appendStringInfo(&buffer, _("foreign-data wrapper %s"), fdw->fdwname);
                break;
            }
 
        case ForeignServerRelationId:
            {
                ForeignServer *srv;
 
                srv = GetForeignServerExtended(object->objectId, missing_ok);
                if (srv)
                    appendStringInfo(&buffer, _("server %s"), srv->servername);
                break;
            }
 
        case UserMappingRelationId:
            {
                HeapTuple   tup;
                Oid         useid;
                char       *usename;
                Form_pg_user_mapping umform;
                ForeignServer *srv;
 
                tup = SearchSysCache1(USERMAPPINGOID,
                                      ObjectIdGetDatum(object->objectId));
                if (!HeapTupleIsValid(tup))
                {
                    if (!missing_ok)
                        elog(ERROR, "cache lookup failed for user mapping %u",
                             object->objectId);
                    break;
                }
 
                umform = (Form_pg_user_mapping) GETSTRUCT(tup);
                useid = umform->umuser;
                srv = GetForeignServer(umform->umserver);
 
                ReleaseSysCache(tup);
 
                if (OidIsValid(useid))
                    usename = GetUserNameFromId(useid, false);
                else
                    usename = "public";
 
                appendStringInfo(&buffer, _("user mapping for %s on server %s"), usename,
                                 srv->servername);
                break;
            }
 
        case DefaultAclRelationId:
            {
                Relation    defaclrel;
                ScanKeyData skey[1];
                SysScanDesc rcscan;
                HeapTuple   tup;
                Form_pg_default_acl defacl;
                char       *rolename;
                char       *nspname;
 
                defaclrel = table_open(DefaultAclRelationId, AccessShareLock);
 
                ScanKeyInit(&skey[0],
                            Anum_pg_default_acl_oid,
                            BTEqualStrategyNumber, F_OIDEQ,
                            ObjectIdGetDatum(object->objectId));
 
                rcscan = systable_beginscan(defaclrel, DefaultAclOidIndexId,
                                            true, NULL, 1, skey);
 
                tup = systable_getnext(rcscan);
 
                if (!HeapTupleIsValid(tup))
                {
                    if (!missing_ok)
                        elog(ERROR, "could not find tuple for default ACL %u",
                             object->objectId);
 
                    systable_endscan(rcscan);
                    table_close(defaclrel, AccessShareLock);
                    break;
                }
 
                defacl = (Form_pg_default_acl) GETSTRUCT(tup);
 
                rolename = GetUserNameFromId(defacl->defaclrole, false);
 
                if (OidIsValid(defacl->defaclnamespace))
                    nspname = get_namespace_name(defacl->defaclnamespace);
                else
                    nspname = NULL;
 
                switch (defacl->defaclobjtype)
                {
                    case DEFACLOBJ_RELATION:
                        if (nspname)
                            appendStringInfo(&buffer,
                                             _("default privileges on new relations belonging to role %s in schema %s"),
                                             rolename, nspname);
                        else
                            appendStringInfo(&buffer,
                                             _("default privileges on new relations belonging to role %s"),
                                             rolename);
                        break;
                    case DEFACLOBJ_SEQUENCE:
                        if (nspname)
                            appendStringInfo(&buffer,
                                             _("default privileges on new sequences belonging to role %s in schema %s"),
                                             rolename, nspname);
                        else
                            appendStringInfo(&buffer,
                                             _("default privileges on new sequences belonging to role %s"),
                                             rolename);
                        break;
                    case DEFACLOBJ_FUNCTION:
                        if (nspname)
                            appendStringInfo(&buffer,
                                             _("default privileges on new functions belonging to role %s in schema %s"),
                                             rolename, nspname);
                        else
                            appendStringInfo(&buffer,
                                             _("default privileges on new functions belonging to role %s"),
                                             rolename);
                        break;
                    case DEFACLOBJ_TYPE:
                        if (nspname)
                            appendStringInfo(&buffer,
                                             _("default privileges on new types belonging to role %s in schema %s"),
                                             rolename, nspname);
                        else
                            appendStringInfo(&buffer,
                                             _("default privileges on new types belonging to role %s"),
                                             rolename);
                        break;
                    case DEFACLOBJ_NAMESPACE:
                        Assert(!nspname);
                        appendStringInfo(&buffer,
                                         _("default privileges on new schemas belonging to role %s"),
                                         rolename);
                        break;
                    case DEFACLOBJ_LARGEOBJECT:
                        Assert(!nspname);
                        appendStringInfo(&buffer,
                                         _("default privileges on new large objects belonging to role %s"),
                                         rolename);
                        break;
                    default:
                        /* shouldn't get here */
                        if (nspname)
                            appendStringInfo(&buffer,
                                             _("default privileges belonging to role %s in schema %s"),
                                             rolename, nspname);
                        else
                            appendStringInfo(&buffer,
                                             _("default privileges belonging to role %s"),
                                             rolename);
                        break;
                }
 
                systable_endscan(rcscan);
                table_close(defaclrel, AccessShareLock);
                break;
            }
 
        case ExtensionRelationId:
            {
                char       *extname;
 
                extname = get_extension_name(object->objectId);
                if (!extname)
                {
                    if (!missing_ok)
                        elog(ERROR, "cache lookup failed for extension %u",
                             object->objectId);
                    break;
                }
                appendStringInfo(&buffer, _("extension %s"), extname);
                break;
            }
 
        case EventTriggerRelationId:
            {
                HeapTuple   tup;
 
                tup = SearchSysCache1(EVENTTRIGGEROID,
                                      ObjectIdGetDatum(object->objectId));
                if (!HeapTupleIsValid(tup))
                {
                    if (!missing_ok)
                        elog(ERROR, "cache lookup failed for event trigger %u",
                             object->objectId);
                    break;
                }
                appendStringInfo(&buffer, _("event trigger %s"),
                                 NameStr(((Form_pg_event_trigger) GETSTRUCT(tup))->evtname));
                ReleaseSysCache(tup);
                break;
            }
 
        case ParameterAclRelationId:
            {
                HeapTuple   tup;
                Datum       nameDatum;
                char       *parname;
 
                tup = SearchSysCache1(PARAMETERACLOID,
                                      ObjectIdGetDatum(object->objectId));
                if (!HeapTupleIsValid(tup))
                {
                    if (!missing_ok)
                        elog(ERROR, "cache lookup failed for parameter ACL %u",
                             object->objectId);
                    break;
                }
                nameDatum = SysCacheGetAttrNotNull(PARAMETERACLOID, tup,
                                                   Anum_pg_parameter_acl_parname);
                parname = TextDatumGetCString(nameDatum);
                appendStringInfo(&buffer, _("parameter %s"), parname);
                ReleaseSysCache(tup);
                break;
            }
 
        case PolicyRelationId:
            {
                Relation    policy_rel;
                ScanKeyData skey[1];
                SysScanDesc sscan;
                HeapTuple   tuple;
                Form_pg_policy form_policy;
                StringInfoData rel;
 
                policy_rel = table_open(PolicyRelationId, AccessShareLock);
 
                ScanKeyInit(&skey[0],
                            Anum_pg_policy_oid,
                            BTEqualStrategyNumber, F_OIDEQ,
                            ObjectIdGetDatum(object->objectId));
 
                sscan = systable_beginscan(policy_rel, PolicyOidIndexId,
                                           true, NULL, 1, skey);
 
                tuple = systable_getnext(sscan);
 
                if (!HeapTupleIsValid(tuple))
                {
                    if (!missing_ok)
                        elog(ERROR, "could not find tuple for policy %u",
                             object->objectId);
 
                    systable_endscan(sscan);
                    table_close(policy_rel, AccessShareLock);
                    break;
                }
 
                form_policy = (Form_pg_policy) GETSTRUCT(tuple);
 
                initStringInfo(&rel);
                getRelationDescription(&rel, form_policy->polrelid, false);
 
                /* translator: second %s is, e.g., "table %s" */
                appendStringInfo(&buffer, _("policy %s on %s"),
                                 NameStr(form_policy->polname), rel.data);
                pfree(rel.data);
                systable_endscan(sscan);
                table_close(policy_rel, AccessShareLock);
                break;
            }
 
        case PropgraphElementRelationId:
            {
                HeapTuple   tup;
                Form_pg_propgraph_element pgeform;
 
                tup = SearchSysCache1(PROPGRAPHELOID, ObjectIdGetDatum(object->objectId));
                if (!HeapTupleIsValid(tup))
                {
                    if (!missing_ok)
                        elog(ERROR, "cache lookup failed for property graph element %u",
                             object->objectId);
                    break;
                }
 
                pgeform = (Form_pg_propgraph_element) GETSTRUCT(tup);
 
                if (pgeform->pgekind == PGEKIND_VERTEX)
                    /* translator: followed by, e.g., "property graph %s" */
                    appendStringInfo(&buffer, _("vertex %s of "), NameStr(pgeform->pgealias));
                else if (pgeform->pgekind == PGEKIND_EDGE)
                    /* translator: followed by, e.g., "property graph %s" */
                    appendStringInfo(&buffer, _("edge %s of "), NameStr(pgeform->pgealias));
                else
                    appendStringInfo(&buffer, "??? element %s of ", NameStr(pgeform->pgealias));
                getRelationDescription(&buffer, pgeform->pgepgid, false);
 
                ReleaseSysCache(tup);
                break;
            }
 
        case PropgraphElementLabelRelationId:
            {
                Relation    rel;
                SysScanDesc scan;
                ScanKeyData key[1];
                HeapTuple   tuple;
                Form_pg_propgraph_element_label pgelform;
                ObjectAddress oa;
 
                rel = table_open(PropgraphElementLabelRelationId, AccessShareLock);
                ScanKeyInit(&key[0],
                            Anum_pg_propgraph_element_label_oid,
                            BTEqualStrategyNumber, F_OIDEQ,
                            ObjectIdGetDatum(object->objectId));
 
                scan = systable_beginscan(rel, PropgraphElementLabelObjectIndexId, true, NULL, 1, key);
                tuple = systable_getnext(scan);
                if (!HeapTupleIsValid(tuple))
                {
                    if (!missing_ok)
                        elog(ERROR, "could not find tuple for element label %u", object->objectId);
 
                    systable_endscan(scan);
                    table_close(rel, AccessShareLock);
                    break;
                }
 
                pgelform = (Form_pg_propgraph_element_label) GETSTRUCT(tuple);
 
                appendStringInfo(&buffer, _("label %s of "), get_propgraph_label_name(pgelform->pgellabelid));
                ObjectAddressSet(oa, PropgraphElementRelationId, pgelform->pgelelid);
                appendStringInfoString(&buffer, getObjectDescription(&oa, false));
 
                systable_endscan(scan);
                table_close(rel, AccessShareLock);
                break;
            }
 
        case PropgraphLabelRelationId:
            {
                HeapTuple   tuple;
                Form_pg_propgraph_label pglform;
 
                tuple = SearchSysCache1(PROPGRAPHLABELOID, object->objectId);
                if (!HeapTupleIsValid(tuple))
                {
                    if (!missing_ok)
                        elog(ERROR, "could not find tuple for label %u", object->objectId);
                    break;
                }
 
                pglform = (Form_pg_propgraph_label) GETSTRUCT(tuple);
 
                /* translator: followed by, e.g., "property graph %s" */
                appendStringInfo(&buffer, _("label %s of "), NameStr(pglform->pgllabel));
                getRelationDescription(&buffer, pglform->pglpgid, false);
                ReleaseSysCache(tuple);
                break;
            }
 
        case PropgraphLabelPropertyRelationId:
            {
                Relation    rel;
                SysScanDesc scan;
                ScanKeyData key[1];
                HeapTuple   tuple;
                Form_pg_propgraph_label_property plpform;
                ObjectAddress oa;
 
                rel = table_open(PropgraphLabelPropertyRelationId, AccessShareLock);
                ScanKeyInit(&key[0],
                            Anum_pg_propgraph_label_property_oid,
                            BTEqualStrategyNumber, F_OIDEQ,
                            ObjectIdGetDatum(object->objectId));
 
                scan = systable_beginscan(rel, PropgraphLabelPropertyObjectIndexId, true, NULL, 1, key);
                tuple = systable_getnext(scan);
                if (!HeapTupleIsValid(tuple))
                {
                    if (!missing_ok)
                        elog(ERROR, "could not find tuple for label property %u", object->objectId);
 
                    systable_endscan(scan);
                    table_close(rel, AccessShareLock);
                    break;
                }
 
                plpform = (Form_pg_propgraph_label_property) GETSTRUCT(tuple);
 
                appendStringInfo(&buffer, _("property %s of "), get_propgraph_property_name(plpform->plppropid));
                ObjectAddressSet(oa, PropgraphElementLabelRelationId, plpform->plpellabelid);
                appendStringInfoString(&buffer, getObjectDescription(&oa, false));
 
                systable_endscan(scan);
                table_close(rel, AccessShareLock);
                break;
            }
 
        case PropgraphPropertyRelationId:
            {
                HeapTuple   tuple;
                Form_pg_propgraph_property pgpform;
 
                tuple = SearchSysCache1(PROPGRAPHPROPOID, object->objectId);
                if (!HeapTupleIsValid(tuple))
                {
                    if (!missing_ok)
                        elog(ERROR, "could not find tuple for property %u", object->objectId);
                    break;
                }
 
                pgpform = (Form_pg_propgraph_property) GETSTRUCT(tuple);
 
                /* translator: followed by, e.g., "property graph %s" */
                appendStringInfo(&buffer, _("property %s of "), NameStr(pgpform->pgpname));
                getRelationDescription(&buffer, pgpform->pgppgid, false);
                ReleaseSysCache(tuple);
                break;
            }
 
        case PublicationRelationId:
            {
                char       *pubname = get_publication_name(object->objectId,
                                                           missing_ok);
 
                if (pubname)
                    appendStringInfo(&buffer, _("publication %s"), pubname);
                break;
            }
 
        case PublicationNamespaceRelationId:
            {
                char       *pubname;
                char       *nspname;
 
                if (!getPublicationSchemaInfo(object, missing_ok,
                                              &pubname, &nspname))
                    break;
 
                appendStringInfo(&buffer, _("publication of schema %s in publication %s"),
                                 nspname, pubname);
                pfree(pubname);
                pfree(nspname);
                break;
            }
 
        case PublicationRelRelationId:
            {
                HeapTuple   tup;
                char       *pubname;
                Form_pg_publication_rel prform;
                StringInfoData rel;
 
                tup = SearchSysCache1(PUBLICATIONREL,
                                      ObjectIdGetDatum(object->objectId));
                if (!HeapTupleIsValid(tup))
                {
                    if (!missing_ok)
                        elog(ERROR, "cache lookup failed for publication table %u",
                             object->objectId);
                    break;
                }
 
                prform = (Form_pg_publication_rel) GETSTRUCT(tup);
                pubname = get_publication_name(prform->prpubid, false);
 
                initStringInfo(&rel);
                getRelationDescription(&rel, prform->prrelid, false);
 
                /* translator: first %s is, e.g., "table %s" */
                appendStringInfo(&buffer, _("publication of %s in publication %s"),
                                 rel.data, pubname);
                pfree(rel.data);
                ReleaseSysCache(tup);
                break;
            }
 
        case SubscriptionRelationId:
            {
                char       *subname = get_subscription_name(object->objectId,
                                                            missing_ok);
 
                if (subname)
                    appendStringInfo(&buffer, _("subscription %s"), subname);
                break;
            }
 
        case TransformRelationId:
            {
                HeapTuple   trfTup;
                Form_pg_transform trfForm;
 
                trfTup = SearchSysCache1(TRFOID,
                                         ObjectIdGetDatum(object->objectId));
                if (!HeapTupleIsValid(trfTup))
                {
                    if (!missing_ok)
                        elog(ERROR, "could not find tuple for transform %u",
                             object->objectId);
                    break;
                }
 
                trfForm = (Form_pg_transform) GETSTRUCT(trfTup);
 
                appendStringInfo(&buffer, _("transform for %s language %s"),
                                 format_type_be(trfForm->trftype),
                                 get_language_name(trfForm->trflang, false));
 
                ReleaseSysCache(trfTup);
                break;
            }
 
        default:
            elog(ERROR, "unsupported object class: %u", object->classId);
    }
 
    /* an empty buffer is equivalent to no object found */
    if (buffer.len == 0)
        return NULL;
 
    return buffer.data;
}

References _, AccessShareLock, appendStringInfo(), appendStringInfoString(), Assert, attname, BTEqualStrategyNumber, ObjectAddress::classId, CollationIsVisible(), ConversionIsVisible(), StringInfoData::data, datname, elog, ERROR, fb(), Form_pg_am, Form_pg_amop, Form_pg_amproc, Form_pg_auth_members, Form_pg_cast, Form_pg_collation, Form_pg_constraint, Form_pg_conversion, Form_pg_default_acl, Form_pg_event_trigger, Form_pg_opclass, Form_pg_policy, Form_pg_propgraph_element, Form_pg_propgraph_element_label, Form_pg_propgraph_label, Form_pg_propgraph_label_property, Form_pg_propgraph_property, Form_pg_publication_rel, Form_pg_rewrite, Form_pg_statistic_ext, Form_pg_transform, Form_pg_trigger, Form_pg_ts_config, Form_pg_ts_dict, Form_pg_ts_parser, Form_pg_ts_template, Form_pg_user_mapping, format_operator(), format_operator_extended(), FORMAT_OPERATOR_INVALID_AS_NULL, FORMAT_PROC_INVALID_AS_NULL, format_procedure(), format_procedure_extended(), FORMAT_TYPE_ALLOW_INVALID, format_type_be(), format_type_extended(), FORMAT_TYPE_INVALID_AS_NULL, get_attname(), get_database_name(), get_extension_name(), get_language_name(), get_namespace_name(), get_propgraph_label_name(), get_propgraph_property_name(), get_publication_name(), get_subscription_name(), get_tablespace_name(), GetAttrDefaultColumnAddress(), GetForeignDataWrapperExtended(), GetForeignServer(), GetForeignServerExtended(), getObjectDescription(), getOpFamilyDescription(), getPublicationSchemaInfo(), getRelationDescription(), GETSTRUCT(), GetUserNameFromId(), HeapTupleIsValid, initStringInfo(), LargeObjectExists(), StringInfoData::len, NameStr, ObjectAddressSet, ObjectAddress::objectId, ObjectIdGetDatum(), ObjectAddress::objectSubId, OidIsValid, OpclassIsVisible(), pfree(), proname, quote_qualified_identifier(), ReleaseSysCache(), ScanKeyInit(), SearchSysCache1(), StatisticsObjIsVisible(), subname, SysCacheGetAttrNotNull(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), table_open(), TextDatumGetCString, TSConfigIsVisible(), TSDictionaryIsVisible(), TSParserIsVisible(), TSTemplateIsVisible(), typname, and username.

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

◆ getObjectDescriptionOids()

char * getObjectDescriptionOids	(	Oid	classid,
		Oid	objid
	)

Definition at line 4333 of file objectaddress.c.

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

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

Referenced by AlterObjectNamespace_internal(), and AlterObjectRename_internal().

◆ getObjectIdentity()

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

Definition at line 5090 of file objectaddress.c.

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

References fb(), and getObjectIdentityParts().

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

◆ getObjectIdentityParts()

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

Definition at line 5105 of file objectaddress.c.

{
    StringInfoData buffer;
 
    initStringInfo(&buffer);
 
    /*
     * Make sure that both objname and objargs were passed, or none was; and
     * initialize them to empty lists.  For objname this is useless because it
     * will be initialized in all cases inside the switch; but we do it anyway
     * so that we can test below that no branch leaves it unset.
     */
    Assert((objname != NULL) == (objargs != NULL));
    if (objname)
    {
        *objname = NIL;
        *objargs = NIL;
    }
 
    switch (object->classId)
    {
        case RelationRelationId:
            {
                char       *attr = NULL;
 
                /*
                 * Check for the attribute first, so as if it is missing we
                 * can skip the entire relation description.
                 */
                if (object->objectSubId != 0)
                {
                    attr = get_attname(object->objectId,
                                       object->objectSubId,
                                       missing_ok);
 
                    if (missing_ok && attr == NULL)
                        break;
                }
 
                getRelationIdentity(&buffer, object->objectId, objname,
                                    missing_ok);
                if (objname && *objname == NIL)
                    break;
 
                if (attr)
                {
                    appendStringInfo(&buffer, ".%s",
                                     quote_identifier(attr));
                    if (objname)
                        *objname = lappend(*objname, attr);
                }
            }
            break;
 
        case ProcedureRelationId:
            {
                bits16      flags = FORMAT_PROC_FORCE_QUALIFY | FORMAT_PROC_INVALID_AS_NULL;
                char       *proname = format_procedure_extended(object->objectId,
                                                                flags);
 
                if (proname == NULL)
                    break;
 
                appendStringInfoString(&buffer, proname);
                if (objname)
                    format_procedure_parts(object->objectId, objname, objargs,
                                           missing_ok);
                break;
            }
 
        case TypeRelationId:
            {
                bits16      flags = FORMAT_TYPE_INVALID_AS_NULL | FORMAT_TYPE_FORCE_QUALIFY;
                char       *typeout;
 
                typeout = format_type_extended(object->objectId, -1, flags);
 
                if (typeout == NULL)
                    break;
 
                appendStringInfoString(&buffer, typeout);
                if (objname)
                    *objname = list_make1(typeout);
            }
            break;
 
        case CastRelationId:
            {
                Relation    castRel;
                HeapTuple   tup;
                Form_pg_cast castForm;
 
                castRel = table_open(CastRelationId, AccessShareLock);
 
                tup = get_catalog_object_by_oid(castRel, Anum_pg_cast_oid,
                                                object->objectId);
 
                if (!HeapTupleIsValid(tup))
                {
                    if (!missing_ok)
                        elog(ERROR, "could not find tuple for cast %u",
                             object->objectId);
 
                    table_close(castRel, AccessShareLock);
                    break;
                }
 
                castForm = (Form_pg_cast) GETSTRUCT(tup);
 
                appendStringInfo(&buffer, "(%s AS %s)",
                                 format_type_be_qualified(castForm->castsource),
                                 format_type_be_qualified(castForm->casttarget));
 
                if (objname)
                {
                    *objname = list_make1(format_type_be_qualified(castForm->castsource));
                    *objargs = list_make1(format_type_be_qualified(castForm->casttarget));
                }
 
                table_close(castRel, AccessShareLock);
                break;
            }
 
        case CollationRelationId:
            {
                HeapTuple   collTup;
                Form_pg_collation coll;
                char       *schema;
 
                collTup = SearchSysCache1(COLLOID,
                                          ObjectIdGetDatum(object->objectId));
                if (!HeapTupleIsValid(collTup))
                {
                    if (!missing_ok)
                        elog(ERROR, "cache lookup failed for collation %u",
                             object->objectId);
                    break;
                }
                coll = (Form_pg_collation) GETSTRUCT(collTup);
                schema = get_namespace_name_or_temp(coll->collnamespace);
                appendStringInfoString(&buffer,
                                       quote_qualified_identifier(schema,
                                                                  NameStr(coll->collname)));
                if (objname)
                    *objname = list_make2(schema,
                                          pstrdup(NameStr(coll->collname)));
                ReleaseSysCache(collTup);
                break;
            }
 
        case ConstraintRelationId:
            {
                HeapTuple   conTup;
                Form_pg_constraint con;
 
                conTup = SearchSysCache1(CONSTROID,
                                         ObjectIdGetDatum(object->objectId));
                if (!HeapTupleIsValid(conTup))
                {
                    if (!missing_ok)
                        elog(ERROR, "cache lookup failed for constraint %u",
                             object->objectId);
                    break;
                }
                con = (Form_pg_constraint) GETSTRUCT(conTup);
 
                if (OidIsValid(con->conrelid))
                {
                    appendStringInfo(&buffer, "%s on ",
                                     quote_identifier(NameStr(con->conname)));
                    getRelationIdentity(&buffer, con->conrelid, objname,
                                        false);
                    if (objname)
                        *objname = lappend(*objname, pstrdup(NameStr(con->conname)));
                }
                else
                {
                    ObjectAddress domain;
 
                    Assert(OidIsValid(con->contypid));
                    domain.classId = TypeRelationId;
                    domain.objectId = con->contypid;
                    domain.objectSubId = 0;
 
                    appendStringInfo(&buffer, "%s on %s",
                                     quote_identifier(NameStr(con->conname)),
                                     getObjectIdentityParts(&domain, objname,
                                                            objargs, false));
 
                    if (objname)
                        *objargs = lappend(*objargs, pstrdup(NameStr(con->conname)));
                }
 
                ReleaseSysCache(conTup);
                break;
            }
 
        case ConversionRelationId:
            {
                HeapTuple   conTup;
                Form_pg_conversion conForm;
                char       *schema;
 
                conTup = SearchSysCache1(CONVOID,
                                         ObjectIdGetDatum(object->objectId));
                if (!HeapTupleIsValid(conTup))
                {
                    if (!missing_ok)
                        elog(ERROR, "cache lookup failed for conversion %u",
                             object->objectId);
                    break;
                }
                conForm = (Form_pg_conversion) GETSTRUCT(conTup);
                schema = get_namespace_name_or_temp(conForm->connamespace);
                appendStringInfoString(&buffer,
                                       quote_qualified_identifier(schema,
                                                                  NameStr(conForm->conname)));
                if (objname)
                    *objname = list_make2(schema,
                                          pstrdup(NameStr(conForm->conname)));
                ReleaseSysCache(conTup);
                break;
            }
 
        case AttrDefaultRelationId:
            {
                ObjectAddress colobject;
 
                colobject = GetAttrDefaultColumnAddress(object->objectId);
 
                if (!OidIsValid(colobject.objectId))
                {
                    if (!missing_ok)
                        elog(ERROR, "could not find tuple for attrdef %u",
                             object->objectId);
                    break;
                }
 
                appendStringInfo(&buffer, "for %s",
                                 getObjectIdentityParts(&colobject,
                                                        objname, objargs,
                                                        false));
                break;
            }
 
        case LanguageRelationId:
            {
                HeapTuple   langTup;
                Form_pg_language langForm;
 
                langTup = SearchSysCache1(LANGOID,
                                          ObjectIdGetDatum(object->objectId));
                if (!HeapTupleIsValid(langTup))
                {
                    if (!missing_ok)
                        elog(ERROR, "cache lookup failed for language %u",
                             object->objectId);
                    break;
                }
                langForm = (Form_pg_language) GETSTRUCT(langTup);
                appendStringInfoString(&buffer,
                                       quote_identifier(NameStr(langForm->lanname)));
                if (objname)
                    *objname = list_make1(pstrdup(NameStr(langForm->lanname)));
                ReleaseSysCache(langTup);
                break;
            }
 
        case LargeObjectRelationId:
            if (!LargeObjectExists(object->objectId))
                break;
            appendStringInfo(&buffer, "%u",
                             object->objectId);
            if (objname)
                *objname = list_make1(psprintf("%u", object->objectId));
            break;
 
        case OperatorRelationId:
            {
                bits16      flags = FORMAT_OPERATOR_FORCE_QUALIFY | FORMAT_OPERATOR_INVALID_AS_NULL;
                char       *oprname = format_operator_extended(object->objectId,
                                                               flags);
 
                if (oprname == NULL)
                    break;
 
                appendStringInfoString(&buffer, oprname);
                if (objname)
                    format_operator_parts(object->objectId, objname, objargs, missing_ok);
                break;
            }
 
        case OperatorClassRelationId:
            {
                HeapTuple   opcTup;
                Form_pg_opclass opcForm;
                HeapTuple   amTup;
                Form_pg_am  amForm;
                char       *schema;
 
                opcTup = SearchSysCache1(CLAOID,
                                         ObjectIdGetDatum(object->objectId));
                if (!HeapTupleIsValid(opcTup))
                {
                    if (!missing_ok)
                        elog(ERROR, "cache lookup failed for opclass %u",
                             object->objectId);
                    break;
                }
                opcForm = (Form_pg_opclass) GETSTRUCT(opcTup);
                schema = get_namespace_name_or_temp(opcForm->opcnamespace);
 
                amTup = SearchSysCache1(AMOID,
                                        ObjectIdGetDatum(opcForm->opcmethod));
                if (!HeapTupleIsValid(amTup))
                    elog(ERROR, "cache lookup failed for access method %u",
                         opcForm->opcmethod);
                amForm = (Form_pg_am) GETSTRUCT(amTup);
 
                appendStringInfo(&buffer, "%s USING %s",
                                 quote_qualified_identifier(schema,
                                                            NameStr(opcForm->opcname)),
                                 quote_identifier(NameStr(amForm->amname)));
                if (objname)
                    *objname = list_make3(pstrdup(NameStr(amForm->amname)),
                                          schema,
                                          pstrdup(NameStr(opcForm->opcname)));
 
                ReleaseSysCache(amTup);
                ReleaseSysCache(opcTup);
                break;
            }
 
        case OperatorFamilyRelationId:
            getOpFamilyIdentity(&buffer, object->objectId, objname,
                                missing_ok);
            break;
 
        case AccessMethodRelationId:
            {
                char       *amname;
 
                amname = get_am_name(object->objectId);
                if (!amname)
                {
                    if (!missing_ok)
                        elog(ERROR, "cache lookup failed for access method %u",
                             object->objectId);
                    break;
                }
                appendStringInfoString(&buffer, quote_identifier(amname));
                if (objname)
                    *objname = list_make1(amname);
            }
            break;
 
        case AccessMethodOperatorRelationId:
            {
                Relation    amopDesc;
                HeapTuple   tup;
                ScanKeyData skey[1];
                SysScanDesc amscan;
                Form_pg_amop amopForm;
                StringInfoData opfam;
                char       *ltype;
                char       *rtype;
 
                amopDesc = table_open(AccessMethodOperatorRelationId,
                                      AccessShareLock);
 
                ScanKeyInit(&skey[0],
                            Anum_pg_amop_oid,
                            BTEqualStrategyNumber, F_OIDEQ,
                            ObjectIdGetDatum(object->objectId));
 
                amscan = systable_beginscan(amopDesc, AccessMethodOperatorOidIndexId, true,
                                            NULL, 1, skey);
 
                tup = systable_getnext(amscan);
 
                if (!HeapTupleIsValid(tup))
                {
                    if (!missing_ok)
                        elog(ERROR, "could not find tuple for amop entry %u",
                             object->objectId);
 
                    systable_endscan(amscan);
                    table_close(amopDesc, AccessShareLock);
                    break;
                }
 
                amopForm = (Form_pg_amop) GETSTRUCT(tup);
 
                initStringInfo(&opfam);
                getOpFamilyIdentity(&opfam, amopForm->amopfamily, objname,
                                    false);
 
                ltype = format_type_be_qualified(amopForm->amoplefttype);
                rtype = format_type_be_qualified(amopForm->amoprighttype);
 
                if (objname)
                {
                    *objname = lappend(*objname,
                                       psprintf("%d", amopForm->amopstrategy));
                    *objargs = list_make2(ltype, rtype);
                }
 
                appendStringInfo(&buffer, "operator %d (%s, %s) of %s",
                                 amopForm->amopstrategy,
                                 ltype, rtype, opfam.data);
 
                pfree(opfam.data);
 
                systable_endscan(amscan);
                table_close(amopDesc, AccessShareLock);
                break;
            }
 
        case AccessMethodProcedureRelationId:
            {
                Relation    amprocDesc;
                ScanKeyData skey[1];
                SysScanDesc amscan;
                HeapTuple   tup;
                Form_pg_amproc amprocForm;
                StringInfoData opfam;
                char       *ltype;
                char       *rtype;
 
                amprocDesc = table_open(AccessMethodProcedureRelationId,
                                        AccessShareLock);
 
                ScanKeyInit(&skey[0],
                            Anum_pg_amproc_oid,
                            BTEqualStrategyNumber, F_OIDEQ,
                            ObjectIdGetDatum(object->objectId));
 
                amscan = systable_beginscan(amprocDesc, AccessMethodProcedureOidIndexId, true,
                                            NULL, 1, skey);
 
                tup = systable_getnext(amscan);
 
                if (!HeapTupleIsValid(tup))
                {
                    if (!missing_ok)
                        elog(ERROR, "could not find tuple for amproc entry %u",
                             object->objectId);
 
                    systable_endscan(amscan);
                    table_close(amprocDesc, AccessShareLock);
                    break;
                }
 
                amprocForm = (Form_pg_amproc) GETSTRUCT(tup);
 
                initStringInfo(&opfam);
                getOpFamilyIdentity(&opfam, amprocForm->amprocfamily, objname,
                                    false);
 
                ltype = format_type_be_qualified(amprocForm->amproclefttype);
                rtype = format_type_be_qualified(amprocForm->amprocrighttype);
 
                if (objname)
                {
                    *objname = lappend(*objname,
                                       psprintf("%d", amprocForm->amprocnum));
                    *objargs = list_make2(ltype, rtype);
                }
 
                appendStringInfo(&buffer, "function %d (%s, %s) of %s",
                                 amprocForm->amprocnum,
                                 ltype, rtype, opfam.data);
 
                pfree(opfam.data);
 
                systable_endscan(amscan);
                table_close(amprocDesc, AccessShareLock);
                break;
            }
 
        case RewriteRelationId:
            {
                Relation    ruleDesc;
                HeapTuple   tup;
                Form_pg_rewrite rule;
 
                ruleDesc = table_open(RewriteRelationId, AccessShareLock);
 
                tup = get_catalog_object_by_oid(ruleDesc, Anum_pg_rewrite_oid,
                                                object->objectId);
 
                if (!HeapTupleIsValid(tup))
                {
                    if (!missing_ok)
                        elog(ERROR, "could not find tuple for rule %u",
                             object->objectId);
 
                    table_close(ruleDesc, AccessShareLock);
                    break;
                }
 
                rule = (Form_pg_rewrite) GETSTRUCT(tup);
 
                appendStringInfo(&buffer, "%s on ",
                                 quote_identifier(NameStr(rule->rulename)));
                getRelationIdentity(&buffer, rule->ev_class, objname, false);
                if (objname)
                    *objname = lappend(*objname, pstrdup(NameStr(rule->rulename)));
 
                table_close(ruleDesc, AccessShareLock);
                break;
            }
 
        case TriggerRelationId:
            {
                Relation    trigDesc;
                HeapTuple   tup;
                Form_pg_trigger trig;
 
                trigDesc = table_open(TriggerRelationId, AccessShareLock);
 
                tup = get_catalog_object_by_oid(trigDesc, Anum_pg_trigger_oid,
                                                object->objectId);
 
                if (!HeapTupleIsValid(tup))
                {
                    if (!missing_ok)
                        elog(ERROR, "could not find tuple for trigger %u",
                             object->objectId);
 
                    table_close(trigDesc, AccessShareLock);
                    break;
                }
 
                trig = (Form_pg_trigger) GETSTRUCT(tup);
 
                appendStringInfo(&buffer, "%s on ",
                                 quote_identifier(NameStr(trig->tgname)));
                getRelationIdentity(&buffer, trig->tgrelid, objname, false);
                if (objname)
                    *objname = lappend(*objname, pstrdup(NameStr(trig->tgname)));
 
                table_close(trigDesc, AccessShareLock);
                break;
            }
 
        case NamespaceRelationId:
            {
                char       *nspname;
 
                nspname = get_namespace_name_or_temp(object->objectId);
                if (!nspname)
                {
                    if (!missing_ok)
                        elog(ERROR, "cache lookup failed for namespace %u",
                             object->objectId);
                    break;
                }
                appendStringInfoString(&buffer,
                                       quote_identifier(nspname));
                if (objname)
                    *objname = list_make1(nspname);
                break;
            }
 
        case StatisticExtRelationId:
            {
                HeapTuple   tup;
                Form_pg_statistic_ext formStatistic;
                char       *schema;
 
                tup = SearchSysCache1(STATEXTOID,
                                      ObjectIdGetDatum(object->objectId));
                if (!HeapTupleIsValid(tup))
                {
                    if (!missing_ok)
                        elog(ERROR, "cache lookup failed for statistics object %u",
                             object->objectId);
                    break;
                }
                formStatistic = (Form_pg_statistic_ext) GETSTRUCT(tup);
                schema = get_namespace_name_or_temp(formStatistic->stxnamespace);
                appendStringInfoString(&buffer,
                                       quote_qualified_identifier(schema,
                                                                  NameStr(formStatistic->stxname)));
                if (objname)
                    *objname = list_make2(schema,
                                          pstrdup(NameStr(formStatistic->stxname)));
                ReleaseSysCache(tup);
            }
            break;
 
        case TSParserRelationId:
            {
                HeapTuple   tup;
                Form_pg_ts_parser formParser;
                char       *schema;
 
                tup = SearchSysCache1(TSPARSEROID,
                                      ObjectIdGetDatum(object->objectId));
                if (!HeapTupleIsValid(tup))
                {
                    if (!missing_ok)
                        elog(ERROR, "cache lookup failed for text search parser %u",
                             object->objectId);
                    break;
                }
                formParser = (Form_pg_ts_parser) GETSTRUCT(tup);
                schema = get_namespace_name_or_temp(formParser->prsnamespace);
                appendStringInfoString(&buffer,
                                       quote_qualified_identifier(schema,
                                                                  NameStr(formParser->prsname)));
                if (objname)
                    *objname = list_make2(schema,
                                          pstrdup(NameStr(formParser->prsname)));
                ReleaseSysCache(tup);
                break;
            }
 
        case TSDictionaryRelationId:
            {
                HeapTuple   tup;
                Form_pg_ts_dict formDict;
                char       *schema;
 
                tup = SearchSysCache1(TSDICTOID,
                                      ObjectIdGetDatum(object->objectId));
                if (!HeapTupleIsValid(tup))
                {
                    if (!missing_ok)
                        elog(ERROR, "cache lookup failed for text search dictionary %u",
                             object->objectId);
                    break;
                }
                formDict = (Form_pg_ts_dict) GETSTRUCT(tup);
                schema = get_namespace_name_or_temp(formDict->dictnamespace);
                appendStringInfoString(&buffer,
                                       quote_qualified_identifier(schema,
                                                                  NameStr(formDict->dictname)));
                if (objname)
                    *objname = list_make2(schema,
                                          pstrdup(NameStr(formDict->dictname)));
                ReleaseSysCache(tup);
                break;
            }
 
        case TSTemplateRelationId:
            {
                HeapTuple   tup;
                Form_pg_ts_template formTmpl;
                char       *schema;
 
                tup = SearchSysCache1(TSTEMPLATEOID,
                                      ObjectIdGetDatum(object->objectId));
                if (!HeapTupleIsValid(tup))
                {
                    if (!missing_ok)
                        elog(ERROR, "cache lookup failed for text search template %u",
                             object->objectId);
                    break;
                }
                formTmpl = (Form_pg_ts_template) GETSTRUCT(tup);
                schema = get_namespace_name_or_temp(formTmpl->tmplnamespace);
                appendStringInfoString(&buffer,
                                       quote_qualified_identifier(schema,
                                                                  NameStr(formTmpl->tmplname)));
                if (objname)
                    *objname = list_make2(schema,
                                          pstrdup(NameStr(formTmpl->tmplname)));
                ReleaseSysCache(tup);
                break;
            }
 
        case TSConfigRelationId:
            {
                HeapTuple   tup;
                Form_pg_ts_config formCfg;
                char       *schema;
 
                tup = SearchSysCache1(TSCONFIGOID,
                                      ObjectIdGetDatum(object->objectId));
                if (!HeapTupleIsValid(tup))
                {
                    if (!missing_ok)
                        elog(ERROR, "cache lookup failed for text search configuration %u",
                             object->objectId);
                    break;
                }
                formCfg = (Form_pg_ts_config) GETSTRUCT(tup);
                schema = get_namespace_name_or_temp(formCfg->cfgnamespace);
                appendStringInfoString(&buffer,
                                       quote_qualified_identifier(schema,
                                                                  NameStr(formCfg->cfgname)));
                if (objname)
                    *objname = list_make2(schema,
                                          pstrdup(NameStr(formCfg->cfgname)));
                ReleaseSysCache(tup);
                break;
            }
 
        case AuthIdRelationId:
            {
                char       *username;
 
                username = GetUserNameFromId(object->objectId, missing_ok);
                if (!username)
                    break;
                if (objname)
                    *objname = list_make1(username);
                appendStringInfoString(&buffer,
                                       quote_identifier(username));
                break;
            }
 
        case AuthMemRelationId:
            {
                Relation    authMemDesc;
                ScanKeyData skey[1];
                SysScanDesc amscan;
                HeapTuple   tup;
                Form_pg_auth_members amForm;
 
                authMemDesc = table_open(AuthMemRelationId,
                                         AccessShareLock);
 
                ScanKeyInit(&skey[0],
                            Anum_pg_auth_members_oid,
                            BTEqualStrategyNumber, F_OIDEQ,
                            ObjectIdGetDatum(object->objectId));
 
                amscan = systable_beginscan(authMemDesc, AuthMemOidIndexId, true,
                                            NULL, 1, skey);
 
                tup = systable_getnext(amscan);
 
                if (!HeapTupleIsValid(tup))
                {
                    if (!missing_ok)
                        elog(ERROR, "could not find tuple for pg_auth_members entry %u",
                             object->objectId);
 
                    systable_endscan(amscan);
                    table_close(authMemDesc, AccessShareLock);
                    break;
                }
 
                amForm = (Form_pg_auth_members) GETSTRUCT(tup);
 
                appendStringInfo(&buffer, _("membership of role %s in role %s"),
                                 GetUserNameFromId(amForm->member, false),
                                 GetUserNameFromId(amForm->roleid, false));
 
                systable_endscan(amscan);
                table_close(authMemDesc, AccessShareLock);
                break;
            }
 
        case DatabaseRelationId:
            {
                char       *datname;
 
                datname = get_database_name(object->objectId);
                if (!datname)
                {
                    if (!missing_ok)
                        elog(ERROR, "cache lookup failed for database %u",
                             object->objectId);
                    break;
                }
                if (objname)
                    *objname = list_make1(datname);
                appendStringInfoString(&buffer,
                                       quote_identifier(datname));
                break;
            }
 
        case TableSpaceRelationId:
            {
                char       *tblspace;
 
                tblspace = get_tablespace_name(object->objectId);
                if (!tblspace)
                {
                    if (!missing_ok)
                        elog(ERROR, "cache lookup failed for tablespace %u",
                             object->objectId);
                    break;
                }
                if (objname)
                    *objname = list_make1(tblspace);
                appendStringInfoString(&buffer,
                                       quote_identifier(tblspace));
                break;
            }
 
        case ForeignDataWrapperRelationId:
            {
                ForeignDataWrapper *fdw;
 
                fdw = GetForeignDataWrapperExtended(object->objectId,
                                                    missing_ok);
                if (fdw)
                {
                    appendStringInfoString(&buffer, quote_identifier(fdw->fdwname));
                    if (objname)
                        *objname = list_make1(pstrdup(fdw->fdwname));
                }
                break;
            }
 
        case ForeignServerRelationId:
            {
                ForeignServer *srv;
 
                srv = GetForeignServerExtended(object->objectId,
                                               missing_ok);
                if (srv)
                {
                    appendStringInfoString(&buffer,
                                           quote_identifier(srv->servername));
                    if (objname)
                        *objname = list_make1(pstrdup(srv->servername));
                }
                break;
            }
 
        case UserMappingRelationId:
            {
                HeapTuple   tup;
                Oid         useid;
                Form_pg_user_mapping umform;
                ForeignServer *srv;
                const char *usename;
 
                tup = SearchSysCache1(USERMAPPINGOID,
                                      ObjectIdGetDatum(object->objectId));
                if (!HeapTupleIsValid(tup))
                {
                    if (!missing_ok)
                        elog(ERROR, "cache lookup failed for user mapping %u",
                             object->objectId);
                    break;
                }
                umform = (Form_pg_user_mapping) GETSTRUCT(tup);
                useid = umform->umuser;
                srv = GetForeignServer(umform->umserver);
 
                ReleaseSysCache(tup);
 
                if (OidIsValid(useid))
                    usename = GetUserNameFromId(useid, false);
                else
                    usename = "public";
 
                if (objname)
                {
                    *objname = list_make1(pstrdup(usename));
                    *objargs = list_make1(pstrdup(srv->servername));
                }
 
                appendStringInfo(&buffer, "%s on server %s",
                                 quote_identifier(usename),
                                 srv->servername);
                break;
            }
 
        case DefaultAclRelationId:
            {
                Relation    defaclrel;
                ScanKeyData skey[1];
                SysScanDesc rcscan;
                HeapTuple   tup;
                Form_pg_default_acl defacl;
                char       *schema;
                char       *username;
 
                defaclrel = table_open(DefaultAclRelationId, AccessShareLock);
 
                ScanKeyInit(&skey[0],
                            Anum_pg_default_acl_oid,
                            BTEqualStrategyNumber, F_OIDEQ,
                            ObjectIdGetDatum(object->objectId));
 
                rcscan = systable_beginscan(defaclrel, DefaultAclOidIndexId,
                                            true, NULL, 1, skey);
 
                tup = systable_getnext(rcscan);
 
                if (!HeapTupleIsValid(tup))
                {
                    if (!missing_ok)
                        elog(ERROR, "could not find tuple for default ACL %u",
                             object->objectId);
 
                    systable_endscan(rcscan);
                    table_close(defaclrel, AccessShareLock);
                    break;
                }
 
                defacl = (Form_pg_default_acl) GETSTRUCT(tup);
 
                username = GetUserNameFromId(defacl->defaclrole, false);
                appendStringInfo(&buffer,
                                 "for role %s",
                                 quote_identifier(username));
 
                if (OidIsValid(defacl->defaclnamespace))
                {
                    schema = get_namespace_name_or_temp(defacl->defaclnamespace);
                    appendStringInfo(&buffer,
                                     " in schema %s",
                                     quote_identifier(schema));
                }
                else
                    schema = NULL;
 
                switch (defacl->defaclobjtype)
                {
                    case DEFACLOBJ_RELATION:
                        appendStringInfoString(&buffer,
                                               " on tables");
                        break;
                    case DEFACLOBJ_SEQUENCE:
                        appendStringInfoString(&buffer,
                                               " on sequences");
                        break;
                    case DEFACLOBJ_FUNCTION:
                        appendStringInfoString(&buffer,
                                               " on functions");
                        break;
                    case DEFACLOBJ_TYPE:
                        appendStringInfoString(&buffer,
                                               " on types");
                        break;
                    case DEFACLOBJ_NAMESPACE:
                        appendStringInfoString(&buffer,
                                               " on schemas");
                        break;
                    case DEFACLOBJ_LARGEOBJECT:
                        appendStringInfoString(&buffer,
                                               " on large objects");
                        break;
                }
 
                if (objname)
                {
                    *objname = list_make1(username);
                    if (schema)
                        *objname = lappend(*objname, schema);
                    *objargs = list_make1(psprintf("%c", defacl->defaclobjtype));
                }
 
                systable_endscan(rcscan);
                table_close(defaclrel, AccessShareLock);
                break;
            }
 
        case ExtensionRelationId:
            {
                char       *extname;
 
                extname = get_extension_name(object->objectId);
                if (!extname)
                {
                    if (!missing_ok)
                        elog(ERROR, "cache lookup failed for extension %u",
                             object->objectId);
                    break;
                }
                appendStringInfoString(&buffer, quote_identifier(extname));
                if (objname)
                    *objname = list_make1(extname);
                break;
            }
 
        case EventTriggerRelationId:
            {
                HeapTuple   tup;
                Form_pg_event_trigger trigForm;
                char       *evtname;
 
                tup = SearchSysCache1(EVENTTRIGGEROID,
                                      ObjectIdGetDatum(object->objectId));
                if (!HeapTupleIsValid(tup))
                {
                    if (!missing_ok)
                        elog(ERROR, "cache lookup failed for event trigger %u",
                             object->objectId);
                    break;
                }
                trigForm = (Form_pg_event_trigger) GETSTRUCT(tup);
                evtname = pstrdup(NameStr(trigForm->evtname));
                appendStringInfoString(&buffer, quote_identifier(evtname));
                if (objname)
                    *objname = list_make1(evtname);
                ReleaseSysCache(tup);
                break;
            }
 
        case ParameterAclRelationId:
            {
                HeapTuple   tup;
                Datum       nameDatum;
                char       *parname;
 
                tup = SearchSysCache1(PARAMETERACLOID,
                                      ObjectIdGetDatum(object->objectId));
                if (!HeapTupleIsValid(tup))
                {
                    if (!missing_ok)
                        elog(ERROR, "cache lookup failed for parameter ACL %u",
                             object->objectId);
                    break;
                }
                nameDatum = SysCacheGetAttrNotNull(PARAMETERACLOID, tup,
                                                   Anum_pg_parameter_acl_parname);
                parname = TextDatumGetCString(nameDatum);
                appendStringInfoString(&buffer, parname);
                if (objname)
                    *objname = list_make1(parname);
                ReleaseSysCache(tup);
                break;
            }
 
        case PolicyRelationId:
            {
                Relation    polDesc;
                HeapTuple   tup;
                Form_pg_policy policy;
 
                polDesc = table_open(PolicyRelationId, AccessShareLock);
 
                tup = get_catalog_object_by_oid(polDesc, Anum_pg_policy_oid,
                                                object->objectId);
 
                if (!HeapTupleIsValid(tup))
                {
                    if (!missing_ok)
                        elog(ERROR, "could not find tuple for policy %u",
                             object->objectId);
 
                    table_close(polDesc, AccessShareLock);
                    break;
                }
 
                policy = (Form_pg_policy) GETSTRUCT(tup);
 
                appendStringInfo(&buffer, "%s on ",
                                 quote_identifier(NameStr(policy->polname)));
                getRelationIdentity(&buffer, policy->polrelid, objname, false);
                if (objname)
                    *objname = lappend(*objname, pstrdup(NameStr(policy->polname)));
 
                table_close(polDesc, AccessShareLock);
                break;
            }
 
        case PropgraphElementRelationId:
            {
                HeapTuple   tup;
                Form_pg_propgraph_element pge;
 
                tup = SearchSysCache1(PROPGRAPHELOID, object->objectId);
                if (!HeapTupleIsValid(tup))
                {
                    if (!missing_ok)
                        elog(ERROR, "cache lookup failed for property graph element %u", object->objectId);
                    break;
                }
                pge = (Form_pg_propgraph_element) GETSTRUCT(tup);
                appendStringInfo(&buffer, "%s of ", quote_identifier(NameStr(pge->pgealias)));
 
                getRelationIdentity(&buffer, pge->pgepgid, objname, false);
                if (objname)
                    *objname = lappend(*objname, pstrdup(NameStr(pge->pgealias)));
 
                ReleaseSysCache(tup);
                break;
            }
 
        case PropgraphLabelRelationId:
            {
                HeapTuple   tup;
                Form_pg_propgraph_label pgl;
 
                tup = SearchSysCache1(PROPGRAPHLABELOID, object->objectId);
                if (!HeapTupleIsValid(tup))
                {
                    if (!missing_ok)
                        elog(ERROR, "cache lookup failed for property graph label %u", object->objectId);
                    break;
                }
 
                pgl = (Form_pg_propgraph_label) GETSTRUCT(tup);
                appendStringInfo(&buffer, "%s of ", quote_identifier(NameStr(pgl->pgllabel)));
                getRelationIdentity(&buffer, pgl->pglpgid, objname, false);
                if (objname)
                    *objname = lappend(*objname, pstrdup(NameStr(pgl->pgllabel)));
                ReleaseSysCache(tup);
                break;
            }
 
        case PropgraphPropertyRelationId:
            {
                HeapTuple   tup;
                Form_pg_propgraph_property pgp;
 
                tup = SearchSysCache1(PROPGRAPHPROPOID, object->objectId);
                if (!HeapTupleIsValid(tup))
                {
                    if (!missing_ok)
                        elog(ERROR, "cache lookup failed for property graph property %u", object->objectId);
                    break;
                }
 
                pgp = (Form_pg_propgraph_property) GETSTRUCT(tup);
                appendStringInfo(&buffer, "%s of ", quote_identifier(NameStr(pgp->pgpname)));
                getRelationIdentity(&buffer, pgp->pgppgid, objname, false);
                if (objname)
                    *objname = lappend(*objname, pstrdup(NameStr(pgp->pgpname)));
                ReleaseSysCache(tup);
                break;
            }
 
        case PublicationRelationId:
            {
                char       *pubname;
 
                pubname = get_publication_name(object->objectId, missing_ok);
                if (pubname)
                {
                    appendStringInfoString(&buffer,
                                           quote_identifier(pubname));
                    if (objname)
                        *objname = list_make1(pubname);
                }
                break;
            }
 
        case PublicationNamespaceRelationId:
            {
                char       *pubname;
                char       *nspname;
 
                if (!getPublicationSchemaInfo(object, missing_ok, &pubname,
                                              &nspname))
                    break;
                appendStringInfo(&buffer, "%s in publication %s",
                                 nspname, pubname);
 
                if (objargs)
                    *objargs = list_make1(pubname);
                else
                    pfree(pubname);
 
                if (objname)
                    *objname = list_make1(nspname);
                else
                    pfree(nspname);
 
                break;
            }
 
        case PublicationRelRelationId:
            {
                HeapTuple   tup;
                char       *pubname;
                Form_pg_publication_rel prform;
 
                tup = SearchSysCache1(PUBLICATIONREL,
                                      ObjectIdGetDatum(object->objectId));
                if (!HeapTupleIsValid(tup))
                {
                    if (!missing_ok)
                        elog(ERROR, "cache lookup failed for publication table %u",
                             object->objectId);
                    break;
                }
 
                prform = (Form_pg_publication_rel) GETSTRUCT(tup);
                pubname = get_publication_name(prform->prpubid, false);
 
                getRelationIdentity(&buffer, prform->prrelid, objname, false);
                appendStringInfo(&buffer, " in publication %s", pubname);
 
                if (objargs)
                    *objargs = list_make1(pubname);
 
                ReleaseSysCache(tup);
                break;
            }
 
        case SubscriptionRelationId:
            {
                char       *subname;
 
                subname = get_subscription_name(object->objectId, missing_ok);
                if (subname)
                {
                    appendStringInfoString(&buffer,
                                           quote_identifier(subname));
                    if (objname)
                        *objname = list_make1(subname);
                }
                break;
            }
 
        case TransformRelationId:
            {
                Relation    transformDesc;
                HeapTuple   tup;
                Form_pg_transform transform;
                char       *transformLang;
                char       *transformType;
 
                transformDesc = table_open(TransformRelationId, AccessShareLock);
 
                tup = get_catalog_object_by_oid(transformDesc,
                                                Anum_pg_transform_oid,
                                                object->objectId);
 
                if (!HeapTupleIsValid(tup))
                {
                    if (!missing_ok)
                        elog(ERROR, "could not find tuple for transform %u",
                             object->objectId);
 
                    table_close(transformDesc, AccessShareLock);
                    break;
                }
 
                transform = (Form_pg_transform) GETSTRUCT(tup);
 
                transformType = format_type_be_qualified(transform->trftype);
                transformLang = get_language_name(transform->trflang, false);
 
                appendStringInfo(&buffer, "for %s language %s",
                                 transformType,
                                 transformLang);
                if (objname)
                {
                    *objname = list_make1(transformType);
                    *objargs = list_make1(pstrdup(transformLang));
                }
 
                table_close(transformDesc, AccessShareLock);
            }
            break;
 
        default:
            elog(ERROR, "unsupported object class: %u", object->classId);
    }
 
    if (!missing_ok)
    {
        /*
         * If a get_object_address() representation was requested, make sure
         * we are providing one.  We don't check objargs, because many of the
         * cases above leave it as NIL.
         */
        if (objname && *objname == NIL)
            elog(ERROR, "requested object address for unsupported object class %u: text result \"%s\"",
                 object->classId, buffer.data);
    }
    else
    {
        /* an empty buffer is equivalent to no object found */
        if (buffer.len == 0)
        {
            Assert((objname == NULL || *objname == NIL) &&
                   (objargs == NULL || *objargs == NIL));
            return NULL;
        }
    }
 
    return buffer.data;
}

References _, AccessShareLock, appendStringInfo(), appendStringInfoString(), Assert, BTEqualStrategyNumber, ObjectAddress::classId, StringInfoData::data, datname, elog, ERROR, fb(), Form_pg_am, Form_pg_amop, Form_pg_amproc, Form_pg_auth_members, Form_pg_cast, Form_pg_collation, Form_pg_constraint, Form_pg_conversion, Form_pg_default_acl, Form_pg_event_trigger, Form_pg_language, Form_pg_opclass, Form_pg_policy, Form_pg_propgraph_element, Form_pg_propgraph_label, Form_pg_propgraph_property, Form_pg_publication_rel, Form_pg_rewrite, Form_pg_statistic_ext, Form_pg_transform, Form_pg_trigger, Form_pg_ts_config, Form_pg_ts_dict, Form_pg_ts_parser, Form_pg_ts_template, Form_pg_user_mapping, format_operator_extended(), FORMAT_OPERATOR_FORCE_QUALIFY, FORMAT_OPERATOR_INVALID_AS_NULL, format_operator_parts(), FORMAT_PROC_FORCE_QUALIFY, FORMAT_PROC_INVALID_AS_NULL, format_procedure_extended(), format_procedure_parts(), format_type_be_qualified(), format_type_extended(), FORMAT_TYPE_FORCE_QUALIFY, FORMAT_TYPE_INVALID_AS_NULL, get_am_name(), get_attname(), get_catalog_object_by_oid(), get_database_name(), get_extension_name(), get_language_name(), get_namespace_name_or_temp(), get_publication_name(), get_subscription_name(), get_tablespace_name(), GetAttrDefaultColumnAddress(), GetForeignDataWrapperExtended(), GetForeignServer(), GetForeignServerExtended(), getObjectIdentityParts(), getOpFamilyIdentity(), getPublicationSchemaInfo(), getRelationIdentity(), GETSTRUCT(), GetUserNameFromId(), HeapTupleIsValid, initStringInfo(), lappend(), LargeObjectExists(), StringInfoData::len, list_make1, list_make2, list_make3, NameStr, NIL, ObjectAddress::objectId, ObjectIdGetDatum(), ObjectAddress::objectSubId, OidIsValid, pfree(), proname, psprintf(), pstrdup(), quote_identifier(), quote_qualified_identifier(), ReleaseSysCache(), ScanKeyInit(), SearchSysCache1(), subname, SysCacheGetAttrNotNull(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), table_open(), TextDatumGetCString, and username.

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

◆ getObjectTypeDescription()

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

Definition at line 4748 of file objectaddress.c.

{
    StringInfoData buffer;
 
    initStringInfo(&buffer);
 
    switch (object->classId)
    {
        case RelationRelationId:
            getRelationTypeDescription(&buffer, object->objectId,
                                       object->objectSubId,
                                       missing_ok);
            break;
 
        case ProcedureRelationId:
            getProcedureTypeDescription(&buffer, object->objectId,
                                        missing_ok);
            break;
 
        case TypeRelationId:
            appendStringInfoString(&buffer, "type");
            break;
 
        case CastRelationId:
            appendStringInfoString(&buffer, "cast");
            break;
 
        case CollationRelationId:
            appendStringInfoString(&buffer, "collation");
            break;
 
        case ConstraintRelationId:
            getConstraintTypeDescription(&buffer, object->objectId,
                                         missing_ok);
            break;
 
        case ConversionRelationId:
            appendStringInfoString(&buffer, "conversion");
            break;
 
        case AttrDefaultRelationId:
            appendStringInfoString(&buffer, "default value");
            break;
 
        case LanguageRelationId:
            appendStringInfoString(&buffer, "language");
            break;
 
        case LargeObjectRelationId:
            appendStringInfoString(&buffer, "large object");
            break;
 
        case OperatorRelationId:
            appendStringInfoString(&buffer, "operator");
            break;
 
        case OperatorClassRelationId:
            appendStringInfoString(&buffer, "operator class");
            break;
 
        case OperatorFamilyRelationId:
            appendStringInfoString(&buffer, "operator family");
            break;
 
        case AccessMethodRelationId:
            appendStringInfoString(&buffer, "access method");
            break;
 
        case AccessMethodOperatorRelationId:
            appendStringInfoString(&buffer, "operator of access method");
            break;
 
        case AccessMethodProcedureRelationId:
            appendStringInfoString(&buffer, "function of access method");
            break;
 
        case RewriteRelationId:
            appendStringInfoString(&buffer, "rule");
            break;
 
        case TriggerRelationId:
            appendStringInfoString(&buffer, "trigger");
            break;
 
        case NamespaceRelationId:
            appendStringInfoString(&buffer, "schema");
            break;
 
        case StatisticExtRelationId:
            appendStringInfoString(&buffer, "statistics object");
            break;
 
        case TSParserRelationId:
            appendStringInfoString(&buffer, "text search parser");
            break;
 
        case TSDictionaryRelationId:
            appendStringInfoString(&buffer, "text search dictionary");
            break;
 
        case TSTemplateRelationId:
            appendStringInfoString(&buffer, "text search template");
            break;
 
        case TSConfigRelationId:
            appendStringInfoString(&buffer, "text search configuration");
            break;
 
        case AuthIdRelationId:
            appendStringInfoString(&buffer, "role");
            break;
 
        case AuthMemRelationId:
            appendStringInfoString(&buffer, "role membership");
            break;
 
        case DatabaseRelationId:
            appendStringInfoString(&buffer, "database");
            break;
 
        case TableSpaceRelationId:
            appendStringInfoString(&buffer, "tablespace");
            break;
 
        case ForeignDataWrapperRelationId:
            appendStringInfoString(&buffer, "foreign-data wrapper");
            break;
 
        case ForeignServerRelationId:
            appendStringInfoString(&buffer, "server");
            break;
 
        case UserMappingRelationId:
            appendStringInfoString(&buffer, "user mapping");
            break;
 
        case DefaultAclRelationId:
            appendStringInfoString(&buffer, "default acl");
            break;
 
        case ExtensionRelationId:
            appendStringInfoString(&buffer, "extension");
            break;
 
        case EventTriggerRelationId:
            appendStringInfoString(&buffer, "event trigger");
            break;
 
        case ParameterAclRelationId:
            appendStringInfoString(&buffer, "parameter ACL");
            break;
 
        case PolicyRelationId:
            appendStringInfoString(&buffer, "policy");
            break;
 
        case PropgraphElementRelationId:
            appendStringInfoString(&buffer, "property graph element");
            break;
 
        case PropgraphLabelRelationId:
            appendStringInfoString(&buffer, "property graph label");
            break;
 
        case PropgraphPropertyRelationId:
            appendStringInfoString(&buffer, "property graph property");
            break;
 
        case PublicationRelationId:
            appendStringInfoString(&buffer, "publication");
            break;
 
        case PublicationNamespaceRelationId:
            appendStringInfoString(&buffer, "publication namespace");
            break;
 
        case PublicationRelRelationId:
            appendStringInfoString(&buffer, "publication relation");
            break;
 
        case SubscriptionRelationId:
            appendStringInfoString(&buffer, "subscription");
            break;
 
        case TransformRelationId:
            appendStringInfoString(&buffer, "transform");
            break;
 
        default:
            elog(ERROR, "unsupported object class: %u", object->classId);
    }
 
    /* the result can never be empty */
    Assert(buffer.len > 0);
 
    return buffer.data;
}

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

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

◆ getOpFamilyDescription()

static void getOpFamilyDescription	(	StringInfo	buffer,
		Oid	opfid,
		bool	missing_ok
	)

static

Definition at line 4429 of file objectaddress.c.

{
    HeapTuple   opfTup;
    Form_pg_opfamily opfForm;
    HeapTuple   amTup;
    Form_pg_am  amForm;
    char       *nspname;
 
    opfTup = SearchSysCache1(OPFAMILYOID, ObjectIdGetDatum(opfid));
    if (!HeapTupleIsValid(opfTup))
    {
        if (!missing_ok)
            elog(ERROR, "cache lookup failed for opfamily %u", opfid);
        return;
    }
    opfForm = (Form_pg_opfamily) GETSTRUCT(opfTup);
 
    amTup = SearchSysCache1(AMOID, ObjectIdGetDatum(opfForm->opfmethod));
    if (!HeapTupleIsValid(amTup))
        elog(ERROR, "cache lookup failed for access method %u",
             opfForm->opfmethod);
    amForm = (Form_pg_am) GETSTRUCT(amTup);
 
    /* Qualify the name if not visible in search path */
    if (OpfamilyIsVisible(opfid))
        nspname = NULL;
    else
        nspname = get_namespace_name(opfForm->opfnamespace);
 
    appendStringInfo(buffer, _("operator family %s for access method %s"),
                     quote_qualified_identifier(nspname,
                                                NameStr(opfForm->opfname)),
                     NameStr(amForm->amname));
 
    ReleaseSysCache(amTup);
    ReleaseSysCache(opfTup);
}

References _, appendStringInfo(), elog, ERROR, fb(), Form_pg_am, Form_pg_opfamily, get_namespace_name(), GETSTRUCT(), HeapTupleIsValid, NameStr, ObjectIdGetDatum(), OpfamilyIsVisible(), quote_qualified_identifier(), ReleaseSysCache(), and SearchSysCache1().

Referenced by getObjectDescription().

◆ getOpFamilyIdentity()

static void getOpFamilyIdentity	(	StringInfo	buffer,
		Oid	opfid,
		List **	object,
		bool	missing_ok
	)

static

Definition at line 6386 of file objectaddress.c.

{
    HeapTuple   opfTup;
    Form_pg_opfamily opfForm;
    HeapTuple   amTup;
    Form_pg_am  amForm;
    char       *schema;
 
    opfTup = SearchSysCache1(OPFAMILYOID, ObjectIdGetDatum(opfid));
    if (!HeapTupleIsValid(opfTup))
    {
        if (!missing_ok)
            elog(ERROR, "cache lookup failed for opfamily %u", opfid);
        return;
    }
    opfForm = (Form_pg_opfamily) GETSTRUCT(opfTup);
 
    amTup = SearchSysCache1(AMOID, ObjectIdGetDatum(opfForm->opfmethod));
    if (!HeapTupleIsValid(amTup))
        elog(ERROR, "cache lookup failed for access method %u",
             opfForm->opfmethod);
    amForm = (Form_pg_am) GETSTRUCT(amTup);
 
    schema = get_namespace_name_or_temp(opfForm->opfnamespace);
    appendStringInfo(buffer, "%s USING %s",
                     quote_qualified_identifier(schema,
                                                NameStr(opfForm->opfname)),
                     NameStr(amForm->amname));
 
    if (object)
        *object = list_make3(pstrdup(NameStr(amForm->amname)),
                             pstrdup(schema),
                             pstrdup(NameStr(opfForm->opfname)));
 
    ReleaseSysCache(amTup);
    ReleaseSysCache(opfTup);
}

References appendStringInfo(), elog, ERROR, fb(), Form_pg_am, Form_pg_opfamily, get_namespace_name_or_temp(), GETSTRUCT(), HeapTupleIsValid, list_make3, NameStr, ObjectIdGetDatum(), pstrdup(), quote_qualified_identifier(), ReleaseSysCache(), and SearchSysCache1().

Referenced by getObjectIdentityParts().

◆ getProcedureTypeDescription()

static void getProcedureTypeDescription	(	StringInfo	buffer,
		Oid	procid,
		bool	missing_ok
	)

static

Definition at line 5053 of file objectaddress.c.

{
    HeapTuple   procTup;
    Form_pg_proc procForm;
 
    procTup = SearchSysCache1(PROCOID,
                              ObjectIdGetDatum(procid));
    if (!HeapTupleIsValid(procTup))
    {
        if (!missing_ok)
            elog(ERROR, "cache lookup failed for procedure %u", procid);
 
        /* fallback to "procedure" for an undefined object */
        appendStringInfoString(buffer, "routine");
        return;
    }
    procForm = (Form_pg_proc) GETSTRUCT(procTup);
 
    if (procForm->prokind == PROKIND_AGGREGATE)
        appendStringInfoString(buffer, "aggregate");
    else if (procForm->prokind == PROKIND_PROCEDURE)
        appendStringInfoString(buffer, "procedure");
    else                        /* function or window function */
        appendStringInfoString(buffer, "function");
 
    ReleaseSysCache(procTup);
}

References appendStringInfoString(), elog, ERROR, fb(), Form_pg_proc, GETSTRUCT(), HeapTupleIsValid, ObjectIdGetDatum(), ReleaseSysCache(), and SearchSysCache1().

Referenced by getObjectTypeDescription().

◆ getPublicationSchemaInfo()

static bool getPublicationSchemaInfo	(	const ObjectAddress *	object,
		bool	missing_ok,
		char **	pubname,
		char **	nspname
	)

static

Definition at line 2961 of file objectaddress.c.

{
    HeapTuple   tup;
    Form_pg_publication_namespace pnform;
 
    tup = SearchSysCache1(PUBLICATIONNAMESPACE,
                          ObjectIdGetDatum(object->objectId));
    if (!HeapTupleIsValid(tup))
    {
        if (!missing_ok)
            elog(ERROR, "cache lookup failed for publication schema %u",
                 object->objectId);
        return false;
    }
 
    pnform = (Form_pg_publication_namespace) GETSTRUCT(tup);
    *pubname = get_publication_name(pnform->pnpubid, missing_ok);
    if (!(*pubname))
    {
        ReleaseSysCache(tup);
        return false;
    }
 
    *nspname = get_namespace_name(pnform->pnnspid);
    if (!(*nspname))
    {
        Oid         schemaid = pnform->pnnspid;
 
        pfree(*pubname);
        ReleaseSysCache(tup);
        if (!missing_ok)
            elog(ERROR, "cache lookup failed for schema %u",
                 schemaid);
        return false;
    }
 
    ReleaseSysCache(tup);
    return true;
}

References elog, ERROR, fb(), Form_pg_publication_namespace, get_namespace_name(), get_publication_name(), GETSTRUCT(), HeapTupleIsValid, ObjectAddress::objectId, ObjectIdGetDatum(), pfree(), ReleaseSysCache(), and SearchSysCache1().

Referenced by getObjectDescription(), and getObjectIdentityParts().

◆ getRelationDescription()

static void getRelationDescription	(	StringInfo	buffer,
		Oid	relid,
		bool	missing_ok
	)

static

Definition at line 4350 of file objectaddress.c.

{
    HeapTuple   relTup;
    Form_pg_class relForm;
    char       *nspname;
    char       *relname;
 
    relTup = SearchSysCache1(RELOID,
                             ObjectIdGetDatum(relid));
    if (!HeapTupleIsValid(relTup))
    {
        if (!missing_ok)
            elog(ERROR, "cache lookup failed for relation %u", relid);
        return;
    }
    relForm = (Form_pg_class) GETSTRUCT(relTup);
 
    /* Qualify the name if not visible in search path */
    if (RelationIsVisible(relid))
        nspname = NULL;
    else
        nspname = get_namespace_name(relForm->relnamespace);
 
    relname = quote_qualified_identifier(nspname, NameStr(relForm->relname));
 
    switch (relForm->relkind)
    {
        case RELKIND_RELATION:
        case RELKIND_PARTITIONED_TABLE:
            appendStringInfo(buffer, _("table %s"),
                             relname);
            break;
        case RELKIND_INDEX:
        case RELKIND_PARTITIONED_INDEX:
            appendStringInfo(buffer, _("index %s"),
                             relname);
            break;
        case RELKIND_SEQUENCE:
            appendStringInfo(buffer, _("sequence %s"),
                             relname);
            break;
        case RELKIND_TOASTVALUE:
            appendStringInfo(buffer, _("toast table %s"),
                             relname);
            break;
        case RELKIND_VIEW:
            appendStringInfo(buffer, _("view %s"),
                             relname);
            break;
        case RELKIND_MATVIEW:
            appendStringInfo(buffer, _("materialized view %s"),
                             relname);
            break;
        case RELKIND_COMPOSITE_TYPE:
            appendStringInfo(buffer, _("composite type %s"),
                             relname);
            break;
        case RELKIND_FOREIGN_TABLE:
            appendStringInfo(buffer, _("foreign table %s"),
                             relname);
            break;
        case RELKIND_PROPGRAPH:
            appendStringInfo(buffer, _("property graph %s"),
                             relname);
            break;
        default:
            /* shouldn't get here */
            appendStringInfo(buffer, _("relation %s"),
                             relname);
            break;
    }
 
    ReleaseSysCache(relTup);
}

References _, appendStringInfo(), elog, ERROR, fb(), get_namespace_name(), GETSTRUCT(), HeapTupleIsValid, NameStr, ObjectIdGetDatum(), quote_qualified_identifier(), RelationIsVisible(), ReleaseSysCache(), relname, and SearchSysCache1().

Referenced by getObjectDescription().

◆ getRelationIdentity()

static void getRelationIdentity	(	StringInfo	buffer,
		Oid	relid,
		List **	object,
		bool	missing_ok
	)

static

Definition at line 6430 of file objectaddress.c.

{
    HeapTuple   relTup;
    Form_pg_class relForm;
    char       *schema;
 
    relTup = SearchSysCache1(RELOID,
                             ObjectIdGetDatum(relid));
    if (!HeapTupleIsValid(relTup))
    {
        if (!missing_ok)
            elog(ERROR, "cache lookup failed for relation %u", relid);
 
        if (object)
            *object = NIL;
        return;
    }
    relForm = (Form_pg_class) GETSTRUCT(relTup);
 
    schema = get_namespace_name_or_temp(relForm->relnamespace);
    appendStringInfoString(buffer,
                           quote_qualified_identifier(schema,
                                                      NameStr(relForm->relname)));
    if (object)
        *object = list_make2(schema, pstrdup(NameStr(relForm->relname)));
 
    ReleaseSysCache(relTup);
}

References appendStringInfoString(), elog, ERROR, fb(), get_namespace_name_or_temp(), GETSTRUCT(), HeapTupleIsValid, list_make2, NameStr, NIL, ObjectIdGetDatum(), pstrdup(), quote_qualified_identifier(), ReleaseSysCache(), and SearchSysCache1().

Referenced by getObjectIdentityParts().

◆ getRelationTypeDescription()

static void getRelationTypeDescription	(	StringInfo	buffer,
		Oid	relid,
		int32	objectSubId,
		bool	missing_ok
	)

static

Definition at line 4950 of file objectaddress.c.

{
    HeapTuple   relTup;
    Form_pg_class relForm;
 
    relTup = SearchSysCache1(RELOID,
                             ObjectIdGetDatum(relid));
    if (!HeapTupleIsValid(relTup))
    {
        if (!missing_ok)
            elog(ERROR, "cache lookup failed for relation %u", relid);
 
        /* fallback to "relation" for an undefined object */
        appendStringInfoString(buffer, "relation");
        return;
    }
    relForm = (Form_pg_class) GETSTRUCT(relTup);
 
    switch (relForm->relkind)
    {
        case RELKIND_RELATION:
        case RELKIND_PARTITIONED_TABLE:
            appendStringInfoString(buffer, "table");
            break;
        case RELKIND_INDEX:
        case RELKIND_PARTITIONED_INDEX:
            appendStringInfoString(buffer, "index");
            break;
        case RELKIND_SEQUENCE:
            appendStringInfoString(buffer, "sequence");
            break;
        case RELKIND_TOASTVALUE:
            appendStringInfoString(buffer, "toast table");
            break;
        case RELKIND_VIEW:
            appendStringInfoString(buffer, "view");
            break;
        case RELKIND_MATVIEW:
            appendStringInfoString(buffer, "materialized view");
            break;
        case RELKIND_COMPOSITE_TYPE:
            appendStringInfoString(buffer, "composite type");
            break;
        case RELKIND_FOREIGN_TABLE:
            appendStringInfoString(buffer, "foreign table");
            break;
        case RELKIND_PROPGRAPH:
            appendStringInfoString(buffer, "property graph");
            break;
        default:
            /* shouldn't get here */
            appendStringInfoString(buffer, "relation");
            break;
    }
 
    if (objectSubId != 0)
        appendStringInfoString(buffer, " column");
 
    ReleaseSysCache(relTup);
}

References appendStringInfoString(), elog, ERROR, fb(), GETSTRUCT(), HeapTupleIsValid, ObjectIdGetDatum(), ReleaseSysCache(), and SearchSysCache1().

Referenced by getObjectTypeDescription().

◆ is_objectclass_supported()

bool is_objectclass_supported ( Oid class_id )

Definition at line 2835 of file objectaddress.c.

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

References fb(), lengthof, and ObjectProperty.

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

◆ pg_describe_object()

Datum pg_describe_object ( PG_FUNCTION_ARGS )

Definition at line 4471 of file objectaddress.c.

{
    Oid         classid = PG_GETARG_OID(0);
    Oid         objid = PG_GETARG_OID(1);
    int32       objsubid = PG_GETARG_INT32(2);
    char       *description;
    ObjectAddress address;
 
    /* for "pinned" items in pg_depend, return null */
    if (!OidIsValid(classid) && !OidIsValid(objid))
        PG_RETURN_NULL();
 
    address.classId = classid;
    address.objectId = objid;
    address.objectSubId = objsubid;
 
    description = getObjectDescription(&address, true);
 
    if (description == NULL)
        PG_RETURN_NULL();
 
    PG_RETURN_TEXT_P(cstring_to_text(description));
}

References ObjectAddress::classId, cstring_to_text(), description, fb(), getObjectDescription(), ObjectAddress::objectId, ObjectAddress::objectSubId, OidIsValid, PG_GETARG_INT32, PG_GETARG_OID, PG_RETURN_NULL, and PG_RETURN_TEXT_P.

◆ pg_get_acl()

Datum pg_get_acl ( PG_FUNCTION_ARGS )

Definition at line 4677 of file objectaddress.c.

{
    Oid         classId = PG_GETARG_OID(0);
    Oid         objectId = PG_GETARG_OID(1);
    int32       objsubid = PG_GETARG_INT32(2);
    Oid         catalogId;
    AttrNumber  Anum_acl;
    Datum       datum;
    bool        isnull;
    HeapTuple   tup;
 
    /* for "pinned" items in pg_depend, return null */
    if (!OidIsValid(classId) && !OidIsValid(objectId))
        PG_RETURN_NULL();
 
    /* for large objects, the catalog to look at is pg_largeobject_metadata */
    catalogId = (classId == LargeObjectRelationId) ?
        LargeObjectMetadataRelationId : classId;
    Anum_acl = get_object_attnum_acl(catalogId);
 
    /* return NULL if no ACL field for this catalog */
    if (Anum_acl == InvalidAttrNumber)
        PG_RETURN_NULL();
 
    /*
     * If dealing with a relation's attribute (objsubid is set), the ACL is
     * retrieved from pg_attribute.
     */
    if (classId == RelationRelationId && objsubid != 0)
    {
        AttrNumber  attnum = (AttrNumber) objsubid;
 
        tup = SearchSysCacheCopyAttNum(objectId, attnum);
 
        if (!HeapTupleIsValid(tup))
            PG_RETURN_NULL();
 
        datum = SysCacheGetAttr(ATTNUM, tup, Anum_pg_attribute_attacl,
                                &isnull);
    }
    else
    {
        Relation    rel;
 
        rel = table_open(catalogId, AccessShareLock);
 
        tup = get_catalog_object_by_oid(rel, get_object_attnum_oid(catalogId),
                                        objectId);
        if (!HeapTupleIsValid(tup))
        {
            table_close(rel, AccessShareLock);
            PG_RETURN_NULL();
        }
 
        datum = heap_getattr(tup, Anum_acl, RelationGetDescr(rel), &isnull);
        table_close(rel, AccessShareLock);
    }
 
    if (isnull)
        PG_RETURN_NULL();
 
    PG_RETURN_DATUM(datum);
}

References AccessShareLock, attnum, fb(), get_catalog_object_by_oid(), get_object_attnum_acl(), get_object_attnum_oid(), heap_getattr(), HeapTupleIsValid, InvalidAttrNumber, OidIsValid, PG_GETARG_INT32, PG_GETARG_OID, PG_RETURN_DATUM, PG_RETURN_NULL, RelationGetDescr, SearchSysCacheCopyAttNum(), SysCacheGetAttr(), table_close(), and table_open().

◆ pg_get_object_address()

Datum pg_get_object_address ( PG_FUNCTION_ARGS )

Definition at line 2204 of file objectaddress.c.

{
    char       *ttype = TextDatumGetCString(PG_GETARG_DATUM(0));
    ArrayType  *namearr = PG_GETARG_ARRAYTYPE_P(1);
    ArrayType  *argsarr = PG_GETARG_ARRAYTYPE_P(2);
    int         itype;
    ObjectType  type;
    List       *name = NIL;
    TypeName   *typename = NULL;
    List       *args = NIL;
    Node       *objnode = NULL;
    ObjectAddress addr;
    TupleDesc   tupdesc;
    Datum       values[3];
    bool        nulls[3];
    HeapTuple   htup;
    Relation    relation;
 
    /* Decode object type, raise error if unknown */
    itype = read_objtype_from_string(ttype);
    if (itype < 0)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("unsupported object type \"%s\"", ttype)));
    type = (ObjectType) itype;
 
    /*
     * Convert the text array to the representation appropriate for the given
     * object type.  Most use a simple string Values list, but there are some
     * exceptions.
     */
    if (type == OBJECT_TYPE || type == OBJECT_DOMAIN || type == OBJECT_CAST ||
        type == OBJECT_TRANSFORM || type == OBJECT_DOMCONSTRAINT)
    {
        Datum      *elems;
        bool       *nulls;
        int         nelems;
 
        deconstruct_array_builtin(namearr, TEXTOID, &elems, &nulls, &nelems);
        if (nelems != 1)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("name list length must be exactly %d", 1)));
        if (nulls[0])
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("name or argument lists may not contain nulls")));
        typename = typeStringToTypeName(TextDatumGetCString(elems[0]), NULL);
    }
    else if (type == OBJECT_LARGEOBJECT)
    {
        Datum      *elems;
        bool       *nulls;
        int         nelems;
 
        deconstruct_array_builtin(namearr, TEXTOID, &elems, &nulls, &nelems);
        if (nelems != 1)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("name list length must be exactly %d", 1)));
        if (nulls[0])
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("large object OID may not be null")));
        objnode = (Node *) makeFloat(TextDatumGetCString(elems[0]));
    }
    else
    {
        name = textarray_to_strvaluelist(namearr);
        if (name == NIL)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("name list length must be at least %d", 1)));
    }
 
    /*
     * If args are given, decode them according to the object type.
     */
    if (type == OBJECT_AGGREGATE ||
        type == OBJECT_FUNCTION ||
        type == OBJECT_PROCEDURE ||
        type == OBJECT_ROUTINE ||
        type == OBJECT_OPERATOR ||
        type == OBJECT_CAST ||
        type == OBJECT_AMOP ||
        type == OBJECT_AMPROC)
    {
        /* in these cases, the args list must be of TypeName */
        Datum      *elems;
        bool       *nulls;
        int         nelems;
        int         i;
 
        deconstruct_array_builtin(argsarr, TEXTOID, &elems, &nulls, &nelems);
 
        args = NIL;
        for (i = 0; i < nelems; i++)
        {
            if (nulls[i])
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                         errmsg("name or argument lists may not contain nulls")));
            args = lappend(args,
                           typeStringToTypeName(TextDatumGetCString(elems[i]),
                                                NULL));
        }
    }
    else
    {
        /* For all other object types, use string Values */
        args = textarray_to_strvaluelist(argsarr);
    }
 
    /*
     * get_object_address is pretty sensitive to the length of its input
     * lists; check that they're what it wants.
     */
    switch (type)
    {
        case OBJECT_PUBLICATION_NAMESPACE:
        case OBJECT_USER_MAPPING:
            if (list_length(name) != 1)
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                         errmsg("name list length must be exactly %d", 1)));
            /* fall through to check args length */
            pg_fallthrough;
        case OBJECT_DOMCONSTRAINT:
        case OBJECT_CAST:
        case OBJECT_PUBLICATION_REL:
        case OBJECT_DEFACL:
        case OBJECT_TRANSFORM:
            if (list_length(args) != 1)
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                         errmsg("argument list length must be exactly %d", 1)));
            break;
        case OBJECT_OPFAMILY:
        case OBJECT_OPCLASS:
            if (list_length(name) < 2)
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                         errmsg("name list length must be at least %d", 2)));
            break;
        case OBJECT_AMOP:
        case OBJECT_AMPROC:
            if (list_length(name) < 3)
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                         errmsg("name list length must be at least %d", 3)));
            /* fall through to check args length */
            pg_fallthrough;
        case OBJECT_OPERATOR:
            if (list_length(args) != 2)
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                         errmsg("argument list length must be exactly %d", 2)));
            break;
        default:
            break;
    }
 
    /*
     * Now build the Node type that get_object_address() expects for the given
     * type.
     */
    switch (type)
    {
        case OBJECT_TABLE:
        case OBJECT_SEQUENCE:
        case OBJECT_VIEW:
        case OBJECT_MATVIEW:
        case OBJECT_INDEX:
        case OBJECT_FOREIGN_TABLE:
        case OBJECT_PROPGRAPH:
        case OBJECT_COLUMN:
        case OBJECT_ATTRIBUTE:
        case OBJECT_COLLATION:
        case OBJECT_CONVERSION:
        case OBJECT_STATISTIC_EXT:
        case OBJECT_TSPARSER:
        case OBJECT_TSDICTIONARY:
        case OBJECT_TSTEMPLATE:
        case OBJECT_TSCONFIGURATION:
        case OBJECT_DEFAULT:
        case OBJECT_POLICY:
        case OBJECT_RULE:
        case OBJECT_TRIGGER:
        case OBJECT_TABCONSTRAINT:
        case OBJECT_OPCLASS:
        case OBJECT_OPFAMILY:
            objnode = (Node *) name;
            break;
        case OBJECT_ACCESS_METHOD:
        case OBJECT_DATABASE:
        case OBJECT_EVENT_TRIGGER:
        case OBJECT_EXTENSION:
        case OBJECT_FDW:
        case OBJECT_FOREIGN_SERVER:
        case OBJECT_LANGUAGE:
        case OBJECT_PARAMETER_ACL:
        case OBJECT_PUBLICATION:
        case OBJECT_ROLE:
        case OBJECT_SCHEMA:
        case OBJECT_SUBSCRIPTION:
        case OBJECT_TABLESPACE:
            if (list_length(name) != 1)
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                         errmsg("name list length must be exactly %d", 1)));
            objnode = linitial(name);
            break;
        case OBJECT_TYPE:
        case OBJECT_DOMAIN:
            objnode = (Node *) typename;
            break;
        case OBJECT_CAST:
        case OBJECT_DOMCONSTRAINT:
        case OBJECT_TRANSFORM:
            objnode = (Node *) list_make2(typename, linitial(args));
            break;
        case OBJECT_PUBLICATION_REL:
            objnode = (Node *) list_make2(name, linitial(args));
            break;
        case OBJECT_PUBLICATION_NAMESPACE:
        case OBJECT_USER_MAPPING:
            objnode = (Node *) list_make2(linitial(name), linitial(args));
            break;
        case OBJECT_DEFACL:
            objnode = (Node *) lcons(linitial(args), name);
            break;
        case OBJECT_AMOP:
        case OBJECT_AMPROC:
            objnode = (Node *) list_make2(name, args);
            break;
        case OBJECT_FUNCTION:
        case OBJECT_PROCEDURE:
        case OBJECT_ROUTINE:
        case OBJECT_AGGREGATE:
        case OBJECT_OPERATOR:
            {
                ObjectWithArgs *owa = makeNode(ObjectWithArgs);
 
                owa->objname = name;
                owa->objargs = args;
                objnode = (Node *) owa;
                break;
            }
        case OBJECT_LARGEOBJECT:
            /* already handled above */
            break;
            /* no default, to let compiler warn about missing case */
    }
 
    if (objnode == NULL)
        elog(ERROR, "unrecognized object type: %d", type);
 
    addr = get_object_address(type, objnode,
                              &relation, AccessShareLock, false);
 
    /* We don't need the relcache entry, thank you very much */
    if (relation)
        relation_close(relation, AccessShareLock);
 
    if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
        elog(ERROR, "return type must be a row type");
 
    values[0] = ObjectIdGetDatum(addr.classId);
    values[1] = ObjectIdGetDatum(addr.objectId);
    values[2] = Int32GetDatum(addr.objectSubId);
    nulls[0] = false;
    nulls[1] = false;
    nulls[2] = false;
 
    htup = heap_form_tuple(tupdesc, values, nulls);
 
    PG_RETURN_DATUM(HeapTupleGetDatum(htup));
}

References AccessShareLock, ObjectAddress::classId, deconstruct_array_builtin(), elog, ereport, errcode(), errmsg, ERROR, fb(), get_call_result_type(), get_object_address(), heap_form_tuple(), HeapTupleGetDatum(), i, Int32GetDatum(), lappend(), lcons(), linitial, list_length(), list_make2, makeFloat(), makeNode, name, NIL, OBJECT_ACCESS_METHOD, OBJECT_AGGREGATE, OBJECT_AMOP, OBJECT_AMPROC, OBJECT_ATTRIBUTE, OBJECT_CAST, OBJECT_COLLATION, OBJECT_COLUMN, OBJECT_CONVERSION, OBJECT_DATABASE, OBJECT_DEFACL, OBJECT_DEFAULT, OBJECT_DOMAIN, OBJECT_DOMCONSTRAINT, OBJECT_EVENT_TRIGGER, OBJECT_EXTENSION, OBJECT_FDW, OBJECT_FOREIGN_SERVER, OBJECT_FOREIGN_TABLE, OBJECT_FUNCTION, OBJECT_INDEX, OBJECT_LANGUAGE, OBJECT_LARGEOBJECT, OBJECT_MATVIEW, OBJECT_OPCLASS, OBJECT_OPERATOR, OBJECT_OPFAMILY, OBJECT_PARAMETER_ACL, OBJECT_POLICY, OBJECT_PROCEDURE, OBJECT_PROPGRAPH, OBJECT_PUBLICATION, OBJECT_PUBLICATION_NAMESPACE, OBJECT_PUBLICATION_REL, OBJECT_ROLE, OBJECT_ROUTINE, OBJECT_RULE, OBJECT_SCHEMA, OBJECT_SEQUENCE, OBJECT_STATISTIC_EXT, OBJECT_SUBSCRIPTION, OBJECT_TABCONSTRAINT, OBJECT_TABLE, OBJECT_TABLESPACE, OBJECT_TRANSFORM, OBJECT_TRIGGER, OBJECT_TSCONFIGURATION, OBJECT_TSDICTIONARY, OBJECT_TSPARSER, OBJECT_TSTEMPLATE, OBJECT_TYPE, OBJECT_USER_MAPPING, OBJECT_VIEW, ObjectAddress::objectId, ObjectIdGetDatum(), ObjectAddress::objectSubId, pg_fallthrough, PG_GETARG_ARRAYTYPE_P, PG_GETARG_DATUM, PG_RETURN_DATUM, read_objtype_from_string(), relation_close(), textarray_to_strvaluelist(), TextDatumGetCString, type, TYPEFUNC_COMPOSITE, typeStringToTypeName(), and values.

◆ pg_identify_object()

Datum pg_identify_object ( PG_FUNCTION_ARGS )

Definition at line 4499 of file objectaddress.c.

{
    Oid         classid = PG_GETARG_OID(0);
    Oid         objid = PG_GETARG_OID(1);
    int32       objsubid = PG_GETARG_INT32(2);
    Oid         schema_oid = InvalidOid;
    const char *objname = NULL;
    char       *objidentity;
    ObjectAddress address;
    Datum       values[4];
    bool        nulls[4];
    TupleDesc   tupdesc;
    HeapTuple   htup;
 
    address.classId = classid;
    address.objectId = objid;
    address.objectSubId = objsubid;
 
    if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
        elog(ERROR, "return type must be a row type");
 
    if (is_objectclass_supported(address.classId))
    {
        HeapTuple   objtup;
        Relation    catalog = table_open(address.classId, AccessShareLock);
 
        objtup = get_catalog_object_by_oid(catalog,
                                           get_object_attnum_oid(address.classId),
                                           address.objectId);
        if (objtup != NULL)
        {
            bool        isnull;
            AttrNumber  nspAttnum;
            AttrNumber  nameAttnum;
 
            nspAttnum = get_object_attnum_namespace(address.classId);
            if (nspAttnum != InvalidAttrNumber)
            {
                schema_oid = DatumGetObjectId(heap_getattr(objtup, nspAttnum,
                                                           RelationGetDescr(catalog), &isnull));
                if (isnull)
                    elog(ERROR, "invalid null namespace in object %u/%u/%d",
                         address.classId, address.objectId, address.objectSubId);
            }
 
            /*
             * We only return the object name if it can be used (together with
             * the schema name, if any) as a unique identifier.
             */
            if (get_object_namensp_unique(address.classId))
            {
                nameAttnum = get_object_attnum_name(address.classId);
                if (nameAttnum != InvalidAttrNumber)
                {
                    Datum       nameDatum;
 
                    nameDatum = heap_getattr(objtup, nameAttnum,
                                             RelationGetDescr(catalog), &isnull);
                    if (isnull)
                        elog(ERROR, "invalid null name in object %u/%u/%d",
                             address.classId, address.objectId, address.objectSubId);
                    objname = quote_identifier(NameStr(*(DatumGetName(nameDatum))));
                }
            }
        }
 
        table_close(catalog, AccessShareLock);
    }
 
    /* object type, which can never be NULL */
    values[0] = CStringGetTextDatum(getObjectTypeDescription(&address, true));
    nulls[0] = false;
 
    /*
     * Before doing anything, extract the object identity.  If the identity
     * could not be found, set all the fields except the object type to NULL.
     */
    objidentity = getObjectIdentity(&address, true);
 
    /* schema name */
    if (OidIsValid(schema_oid) && objidentity)
    {
        const char *schema = quote_identifier(get_namespace_name(schema_oid));
 
        values[1] = CStringGetTextDatum(schema);
        nulls[1] = false;
    }
    else
        nulls[1] = true;
 
    /* object name */
    if (objname && objidentity)
    {
        values[2] = CStringGetTextDatum(objname);
        nulls[2] = false;
    }
    else
        nulls[2] = true;
 
    /* object identity */
    if (objidentity)
    {
        values[3] = CStringGetTextDatum(objidentity);
        nulls[3] = false;
    }
    else
        nulls[3] = true;
 
    htup = heap_form_tuple(tupdesc, values, nulls);
 
    PG_RETURN_DATUM(HeapTupleGetDatum(htup));
}

References AccessShareLock, ObjectAddress::classId, CStringGetTextDatum, DatumGetName(), DatumGetObjectId(), elog, ERROR, fb(), get_call_result_type(), get_catalog_object_by_oid(), get_namespace_name(), get_object_attnum_name(), get_object_attnum_namespace(), get_object_attnum_oid(), get_object_namensp_unique(), getObjectIdentity(), getObjectTypeDescription(), heap_form_tuple(), heap_getattr(), HeapTupleGetDatum(), InvalidAttrNumber, InvalidOid, is_objectclass_supported(), NameStr, ObjectAddress::objectId, ObjectAddress::objectSubId, OidIsValid, PG_GETARG_INT32, PG_GETARG_OID, PG_RETURN_DATUM, quote_identifier(), RelationGetDescr, table_close(), table_open(), TYPEFUNC_COMPOSITE, and values.

◆ pg_identify_object_as_address()

Datum pg_identify_object_as_address ( PG_FUNCTION_ARGS )

Definition at line 4616 of file objectaddress.c.

{
    Oid         classid = PG_GETARG_OID(0);
    Oid         objid = PG_GETARG_OID(1);
    int32       objsubid = PG_GETARG_INT32(2);
    ObjectAddress address;
    char       *identity;
    List       *names;
    List       *args;
    Datum       values[3];
    bool        nulls[3];
    TupleDesc   tupdesc;
    HeapTuple   htup;
 
    address.classId = classid;
    address.objectId = objid;
    address.objectSubId = objsubid;
 
    if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
        elog(ERROR, "return type must be a row type");
 
    /* object type, which can never be NULL */
    values[0] = CStringGetTextDatum(getObjectTypeDescription(&address, true));
    nulls[0] = false;
 
    /* object identity */
    identity = getObjectIdentityParts(&address, &names, &args, true);
    if (identity == NULL)
    {
        nulls[1] = true;
        nulls[2] = true;
    }
    else
    {
        pfree(identity);
 
        /* object_names */
        if (names != NIL)
            values[1] = PointerGetDatum(strlist_to_textarray(names));
        else
            values[1] = PointerGetDatum(construct_empty_array(TEXTOID));
        nulls[1] = false;
 
        /* object_args */
        if (args)
            values[2] = PointerGetDatum(strlist_to_textarray(args));
        else
            values[2] = PointerGetDatum(construct_empty_array(TEXTOID));
        nulls[2] = false;
    }
 
    htup = heap_form_tuple(tupdesc, values, nulls);
 
    PG_RETURN_DATUM(HeapTupleGetDatum(htup));
}

References ObjectAddress::classId, construct_empty_array(), CStringGetTextDatum, elog, ERROR, fb(), get_call_result_type(), getObjectIdentityParts(), getObjectTypeDescription(), heap_form_tuple(), HeapTupleGetDatum(), NIL, ObjectAddress::objectId, ObjectAddress::objectSubId, pfree(), PG_GETARG_INT32, PG_GETARG_OID, PG_RETURN_DATUM, PointerGetDatum(), strlist_to_textarray(), TYPEFUNC_COMPOSITE, and values.

◆ read_objtype_from_string()

int read_objtype_from_string ( const char * objtype )

Definition at line 2706 of file objectaddress.c.

{
    int         i;
 
    for (i = 0; i < lengthof(ObjectTypeMap); i++)
    {
        if (strcmp(ObjectTypeMap[i].tm_name, objtype) == 0)
            return ObjectTypeMap[i].tm_type;
    }
    ereport(ERROR,
            (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
             errmsg("unrecognized object type \"%s\"", objtype)));
 
    return -1;                  /* keep compiler quiet */
}

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

Referenced by pg_get_object_address().

◆ strlist_to_textarray()

ArrayType * strlist_to_textarray ( List * list )

Definition at line 6464 of file objectaddress.c.

{
    ArrayType  *arr;
    Datum      *datums;
    bool       *nulls;
    int         j = 0;
    ListCell   *cell;
    MemoryContext memcxt;
    MemoryContext oldcxt;
    int         lb[1];
 
    /* Work in a temp context; easier than individually pfree'ing the Datums */
    memcxt = AllocSetContextCreate(CurrentMemoryContext,
                                   "strlist to array",
                                   ALLOCSET_DEFAULT_SIZES);
    oldcxt = MemoryContextSwitchTo(memcxt);
 
    datums = palloc_array(Datum, list_length(list));
    nulls = palloc_array(bool, list_length(list));
 
    foreach(cell, list)
    {
        char       *name = lfirst(cell);
 
        if (name)
        {
            nulls[j] = false;
            datums[j++] = CStringGetTextDatum(name);
        }
        else
            nulls[j] = true;
    }
 
    MemoryContextSwitchTo(oldcxt);
 
    lb[0] = 1;
    arr = construct_md_array(datums, nulls, 1, &j,
                             lb, TEXTOID, -1, false, TYPALIGN_INT);
 
    MemoryContextDelete(memcxt);
 
    return arr;
}

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

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

◆ textarray_to_strvaluelist()

static List * textarray_to_strvaluelist ( ArrayType * arr )

static

Definition at line 2178 of file objectaddress.c.

{
    Datum      *elems;
    bool       *nulls;
    int         nelems;
    List       *list = NIL;
    int         i;
 
    deconstruct_array_builtin(arr, TEXTOID, &elems, &nulls, &nelems);
 
    for (i = 0; i < nelems; i++)
    {
        if (nulls[i])
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("name or argument lists may not contain nulls")));
        list = lappend(list, makeString(TextDatumGetCString(elems[i])));
    }
 
    return list;
}

References deconstruct_array_builtin(), ereport, errcode(), errmsg, ERROR, fb(), i, lappend(), makeString(), NIL, and TextDatumGetCString.

Referenced by pg_get_object_address().

Variable Documentation

◆ InvalidObjectAddress

const ObjectAddress InvalidObjectAddress

Initial value:

=
{
    InvalidOid,
    InvalidOid,
    0
}

Definition at line 924 of file objectaddress.c.

{
    InvalidOid,
    InvalidOid,
    0
};

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

◆ ObjectProperty

const ObjectPropertyType ObjectProperty[]

static

Definition at line 124 of file objectaddress.c.

{
    {
        "access method",
        AccessMethodRelationId,
        AmOidIndexId,
        AMOID,
        AMNAME,
        Anum_pg_am_oid,
        Anum_pg_am_amname,
        InvalidAttrNumber,
        InvalidAttrNumber,
        InvalidAttrNumber,
        OBJECT_ACCESS_METHOD,
        true
    },
    {
        "access method operator",
        AccessMethodOperatorRelationId,
        AccessMethodOperatorOidIndexId,
        SYSCACHEID_INVALID,
        SYSCACHEID_INVALID,
        Anum_pg_amop_oid,
        InvalidAttrNumber,
        InvalidAttrNumber,
        InvalidAttrNumber,
        InvalidAttrNumber,
        OBJECT_AMOP,
        false
    },
    {
        "access method procedure",
        AccessMethodProcedureRelationId,
        AccessMethodProcedureOidIndexId,
        SYSCACHEID_INVALID,
        SYSCACHEID_INVALID,
        Anum_pg_amproc_oid,
        InvalidAttrNumber,
        InvalidAttrNumber,
        InvalidAttrNumber,
        InvalidAttrNumber,
        OBJECT_AMPROC,
        false
    },
    {
        "cast",
        CastRelationId,
        CastOidIndexId,
        SYSCACHEID_INVALID,
        SYSCACHEID_INVALID,
        Anum_pg_cast_oid,
        InvalidAttrNumber,
        InvalidAttrNumber,
        InvalidAttrNumber,
        InvalidAttrNumber,
        OBJECT_CAST,
        false
    },
    {
        "collation",
        CollationRelationId,
        CollationOidIndexId,
        COLLOID,
        SYSCACHEID_INVALID,     /* COLLNAMEENCNSP also takes encoding */
        Anum_pg_collation_oid,
        Anum_pg_collation_collname,
        Anum_pg_collation_collnamespace,
        Anum_pg_collation_collowner,
        InvalidAttrNumber,
        OBJECT_COLLATION,
        true
    },
    {
        "constraint",
        ConstraintRelationId,
        ConstraintOidIndexId,
        CONSTROID,
        SYSCACHEID_INVALID,
        Anum_pg_constraint_oid,
        Anum_pg_constraint_conname,
        Anum_pg_constraint_connamespace,
        InvalidAttrNumber,
        InvalidAttrNumber,
        -1,
        false
    },
    {
        "conversion",
        ConversionRelationId,
        ConversionOidIndexId,
        CONVOID,
        CONNAMENSP,
        Anum_pg_conversion_oid,
        Anum_pg_conversion_conname,
        Anum_pg_conversion_connamespace,
        Anum_pg_conversion_conowner,
        InvalidAttrNumber,
        OBJECT_CONVERSION,
        true
    },
    {
        "database",
        DatabaseRelationId,
        DatabaseOidIndexId,
        DATABASEOID,
        SYSCACHEID_INVALID,
        Anum_pg_database_oid,
        Anum_pg_database_datname,
        InvalidAttrNumber,
        Anum_pg_database_datdba,
        Anum_pg_database_datacl,
        OBJECT_DATABASE,
        true
    },
    {
        "default ACL",
        DefaultAclRelationId,
        DefaultAclOidIndexId,
        SYSCACHEID_INVALID,
        SYSCACHEID_INVALID,
        Anum_pg_default_acl_oid,
        InvalidAttrNumber,
        InvalidAttrNumber,
        InvalidAttrNumber,
        InvalidAttrNumber,
        OBJECT_DEFACL,
        false
    },
    {
        "extension",
        ExtensionRelationId,
        ExtensionOidIndexId,
        SYSCACHEID_INVALID,
        SYSCACHEID_INVALID,
        Anum_pg_extension_oid,
        Anum_pg_extension_extname,
        InvalidAttrNumber,      /* extension doesn't belong to extnamespace */
        Anum_pg_extension_extowner,
        InvalidAttrNumber,
        OBJECT_EXTENSION,
        true
    },
    {
        "foreign-data wrapper",
        ForeignDataWrapperRelationId,
        ForeignDataWrapperOidIndexId,
        FOREIGNDATAWRAPPEROID,
        FOREIGNDATAWRAPPERNAME,
        Anum_pg_foreign_data_wrapper_oid,
        Anum_pg_foreign_data_wrapper_fdwname,
        InvalidAttrNumber,
        Anum_pg_foreign_data_wrapper_fdwowner,
        Anum_pg_foreign_data_wrapper_fdwacl,
        OBJECT_FDW,
        true
    },
    {
        "foreign server",
        ForeignServerRelationId,
        ForeignServerOidIndexId,
        FOREIGNSERVEROID,
        FOREIGNSERVERNAME,
        Anum_pg_foreign_server_oid,
        Anum_pg_foreign_server_srvname,
        InvalidAttrNumber,
        Anum_pg_foreign_server_srvowner,
        Anum_pg_foreign_server_srvacl,
        OBJECT_FOREIGN_SERVER,
        true
    },
    {
        "function",
        ProcedureRelationId,
        ProcedureOidIndexId,
        PROCOID,
        SYSCACHEID_INVALID,     /* PROCNAMEARGSNSP also takes argument types */
        Anum_pg_proc_oid,
        Anum_pg_proc_proname,
        Anum_pg_proc_pronamespace,
        Anum_pg_proc_proowner,
        Anum_pg_proc_proacl,
        OBJECT_FUNCTION,
        false
    },
    {
        "language",
        LanguageRelationId,
        LanguageOidIndexId,
        LANGOID,
        LANGNAME,
        Anum_pg_language_oid,
        Anum_pg_language_lanname,
        InvalidAttrNumber,
        Anum_pg_language_lanowner,
        Anum_pg_language_lanacl,
        OBJECT_LANGUAGE,
        true
    },
    {
        "large object metadata",
        LargeObjectMetadataRelationId,
        LargeObjectMetadataOidIndexId,
        SYSCACHEID_INVALID,
        SYSCACHEID_INVALID,
        Anum_pg_largeobject_metadata_oid,
        InvalidAttrNumber,
        InvalidAttrNumber,
        Anum_pg_largeobject_metadata_lomowner,
        Anum_pg_largeobject_metadata_lomacl,
        OBJECT_LARGEOBJECT,
        false
    },
    {
        "operator class",
        OperatorClassRelationId,
        OpclassOidIndexId,
        CLAOID,
        SYSCACHEID_INVALID,     /* CLAAMNAMENSP also takes opcmethod */
        Anum_pg_opclass_oid,
        Anum_pg_opclass_opcname,
        Anum_pg_opclass_opcnamespace,
        Anum_pg_opclass_opcowner,
        InvalidAttrNumber,
        OBJECT_OPCLASS,
        true
    },
    {
        "operator",
        OperatorRelationId,
        OperatorOidIndexId,
        OPEROID,
        SYSCACHEID_INVALID,     /* OPERNAMENSP also takes left and right type */
        Anum_pg_operator_oid,
        Anum_pg_operator_oprname,
        Anum_pg_operator_oprnamespace,
        Anum_pg_operator_oprowner,
        InvalidAttrNumber,
        OBJECT_OPERATOR,
        false
    },
    {
        "operator family",
        OperatorFamilyRelationId,
        OpfamilyOidIndexId,
        OPFAMILYOID,
        SYSCACHEID_INVALID,     /* OPFAMILYAMNAMENSP also takes opfmethod */
        Anum_pg_opfamily_oid,
        Anum_pg_opfamily_opfname,
        Anum_pg_opfamily_opfnamespace,
        Anum_pg_opfamily_opfowner,
        InvalidAttrNumber,
        OBJECT_OPFAMILY,
        true
    },
    {
        "property graph element",
        PropgraphElementRelationId,
        PropgraphElementObjectIndexId,
        PROPGRAPHELOID,
        PROPGRAPHELALIAS,
        Anum_pg_propgraph_element_oid,
        Anum_pg_propgraph_element_pgealias,
        InvalidAttrNumber,
        InvalidAttrNumber,
        InvalidAttrNumber,
        -1,
        false
    },
    {
        "property graph element label",
        PropgraphElementLabelRelationId,
        PropgraphElementLabelObjectIndexId,
        -1,
        -1,
        Anum_pg_propgraph_element_label_oid,
        InvalidAttrNumber,
        InvalidAttrNumber,
        InvalidAttrNumber,
        InvalidAttrNumber,
        -1,
        false
    },
    {
        "property graph label",
        PropgraphLabelRelationId,
        PropgraphLabelObjectIndexId,
        PROPGRAPHLABELOID,
        PROPGRAPHLABELNAME,
        Anum_pg_propgraph_label_oid,
        Anum_pg_propgraph_label_pgllabel,
        InvalidAttrNumber,
        InvalidAttrNumber,
        InvalidAttrNumber,
        -1,
        false
    },
    {
        "property graph label property",
        PropgraphLabelPropertyRelationId,
        PropgraphLabelPropertyObjectIndexId,
        -1,
        -1,
        Anum_pg_propgraph_label_property_oid,
        InvalidAttrNumber,
        InvalidAttrNumber,
        InvalidAttrNumber,
        InvalidAttrNumber,
        -1,
        false
    },
    {
        "property graph property",
        PropgraphPropertyRelationId,
        PropgraphPropertyObjectIndexId,
        -1,
        PROPGRAPHPROPNAME,
        Anum_pg_propgraph_property_oid,
        Anum_pg_propgraph_property_pgpname,
        InvalidAttrNumber,
        InvalidAttrNumber,
        InvalidAttrNumber,
        -1,
        false
    },
    {
        "role",
        AuthIdRelationId,
        AuthIdOidIndexId,
        AUTHOID,
        AUTHNAME,
        Anum_pg_authid_oid,
        Anum_pg_authid_rolname,
        InvalidAttrNumber,
        InvalidAttrNumber,
        InvalidAttrNumber,
        OBJECT_ROLE,
        true
    },
    {
        "role membership",
        AuthMemRelationId,
        AuthMemOidIndexId,
        SYSCACHEID_INVALID,
        SYSCACHEID_INVALID,
        Anum_pg_auth_members_oid,
        InvalidAttrNumber,
        InvalidAttrNumber,
        Anum_pg_auth_members_grantor,
        InvalidAttrNumber,
        -1,
        true
    },
    {
        "rule",
        RewriteRelationId,
        RewriteOidIndexId,
        SYSCACHEID_INVALID,
        SYSCACHEID_INVALID,
        Anum_pg_rewrite_oid,
        Anum_pg_rewrite_rulename,
        InvalidAttrNumber,
        InvalidAttrNumber,
        InvalidAttrNumber,
        OBJECT_RULE,
        false
    },
    {
        "schema",
        NamespaceRelationId,
        NamespaceOidIndexId,
        NAMESPACEOID,
        NAMESPACENAME,
        Anum_pg_namespace_oid,
        Anum_pg_namespace_nspname,
        InvalidAttrNumber,
        Anum_pg_namespace_nspowner,
        Anum_pg_namespace_nspacl,
        OBJECT_SCHEMA,
        true
    },
    {
        "relation",
        RelationRelationId,
        ClassOidIndexId,
        RELOID,
        RELNAMENSP,
        Anum_pg_class_oid,
        Anum_pg_class_relname,
        Anum_pg_class_relnamespace,
        Anum_pg_class_relowner,
        Anum_pg_class_relacl,
        OBJECT_TABLE,
        true
    },
    {
        "tablespace",
        TableSpaceRelationId,
        TablespaceOidIndexId,
        TABLESPACEOID,
        SYSCACHEID_INVALID,
        Anum_pg_tablespace_oid,
        Anum_pg_tablespace_spcname,
        InvalidAttrNumber,
        Anum_pg_tablespace_spcowner,
        Anum_pg_tablespace_spcacl,
        OBJECT_TABLESPACE,
        true
    },
    {
        "transform",
        TransformRelationId,
        TransformOidIndexId,
        TRFOID,
        SYSCACHEID_INVALID,
        Anum_pg_transform_oid,
        InvalidAttrNumber,
        InvalidAttrNumber,
        InvalidAttrNumber,
        InvalidAttrNumber,
        OBJECT_TRANSFORM,
        false
    },
    {
        "trigger",
        TriggerRelationId,
        TriggerOidIndexId,
        SYSCACHEID_INVALID,
        SYSCACHEID_INVALID,
        Anum_pg_trigger_oid,
        Anum_pg_trigger_tgname,
        InvalidAttrNumber,
        InvalidAttrNumber,
        InvalidAttrNumber,
        OBJECT_TRIGGER,
        false
    },
    {
        "policy",
        PolicyRelationId,
        PolicyOidIndexId,
        SYSCACHEID_INVALID,
        SYSCACHEID_INVALID,
        Anum_pg_policy_oid,
        Anum_pg_policy_polname,
        InvalidAttrNumber,
        InvalidAttrNumber,
        InvalidAttrNumber,
        OBJECT_POLICY,
        false
    },
    {
        "event trigger",
        EventTriggerRelationId,
        EventTriggerOidIndexId,
        EVENTTRIGGEROID,
        EVENTTRIGGERNAME,
        Anum_pg_event_trigger_oid,
        Anum_pg_event_trigger_evtname,
        InvalidAttrNumber,
        Anum_pg_event_trigger_evtowner,
        InvalidAttrNumber,
        OBJECT_EVENT_TRIGGER,
        true
    },
    {
        "text search configuration",
        TSConfigRelationId,
        TSConfigOidIndexId,
        TSCONFIGOID,
        TSCONFIGNAMENSP,
        Anum_pg_ts_config_oid,
        Anum_pg_ts_config_cfgname,
        Anum_pg_ts_config_cfgnamespace,
        Anum_pg_ts_config_cfgowner,
        InvalidAttrNumber,
        OBJECT_TSCONFIGURATION,
        true
    },
    {
        "text search dictionary",
        TSDictionaryRelationId,
        TSDictionaryOidIndexId,
        TSDICTOID,
        TSDICTNAMENSP,
        Anum_pg_ts_dict_oid,
        Anum_pg_ts_dict_dictname,
        Anum_pg_ts_dict_dictnamespace,
        Anum_pg_ts_dict_dictowner,
        InvalidAttrNumber,
        OBJECT_TSDICTIONARY,
        true
    },
    {
        "text search parser",
        TSParserRelationId,
        TSParserOidIndexId,
        TSPARSEROID,
        TSPARSERNAMENSP,
        Anum_pg_ts_parser_oid,
        Anum_pg_ts_parser_prsname,
        Anum_pg_ts_parser_prsnamespace,
        InvalidAttrNumber,
        InvalidAttrNumber,
        OBJECT_TSPARSER,
        true
    },
    {
        "text search template",
        TSTemplateRelationId,
        TSTemplateOidIndexId,
        TSTEMPLATEOID,
        TSTEMPLATENAMENSP,
        Anum_pg_ts_template_oid,
        Anum_pg_ts_template_tmplname,
        Anum_pg_ts_template_tmplnamespace,
        InvalidAttrNumber,
        InvalidAttrNumber,
        OBJECT_TSTEMPLATE,
        true,
    },
    {
        "type",
        TypeRelationId,
        TypeOidIndexId,
        TYPEOID,
        TYPENAMENSP,
        Anum_pg_type_oid,
        Anum_pg_type_typname,
        Anum_pg_type_typnamespace,
        Anum_pg_type_typowner,
        Anum_pg_type_typacl,
        OBJECT_TYPE,
        true
    },
    {
        "publication",
        PublicationRelationId,
        PublicationObjectIndexId,
        PUBLICATIONOID,
        PUBLICATIONNAME,
        Anum_pg_publication_oid,
        Anum_pg_publication_pubname,
        InvalidAttrNumber,
        Anum_pg_publication_pubowner,
        InvalidAttrNumber,
        OBJECT_PUBLICATION,
        true
    },
    {
        "subscription",
        SubscriptionRelationId,
        SubscriptionObjectIndexId,
        SUBSCRIPTIONOID,
        SUBSCRIPTIONNAME,
        Anum_pg_subscription_oid,
        Anum_pg_subscription_subname,
        InvalidAttrNumber,
        Anum_pg_subscription_subowner,
        InvalidAttrNumber,
        OBJECT_SUBSCRIPTION,
        true
    },
    {
        "extended statistics",
        StatisticExtRelationId,
        StatisticExtOidIndexId,
        STATEXTOID,
        STATEXTNAMENSP,
        Anum_pg_statistic_ext_oid,
        Anum_pg_statistic_ext_stxname,
        Anum_pg_statistic_ext_stxnamespace,
        Anum_pg_statistic_ext_stxowner,
        InvalidAttrNumber,      /* no ACL (same as relation) */
        OBJECT_STATISTIC_EXT,
        true
    },
    {
        "user mapping",
        UserMappingRelationId,
        UserMappingOidIndexId,
        USERMAPPINGOID,
        SYSCACHEID_INVALID,
        Anum_pg_user_mapping_oid,
        InvalidAttrNumber,
        InvalidAttrNumber,
        InvalidAttrNumber,
        InvalidAttrNumber,
        OBJECT_USER_MAPPING,
        false
    },
};

Referenced by get_object_property_data(), and is_objectclass_supported().

◆ ObjectTypeMap

const struct object_type_map ObjectTypeMap[]

static

Referenced by read_objtype_from_string().

Data Structures

Functions

Variables

Function Documentation

◆ check_object_ownership()

◆ get_catalog_object_by_oid()

◆ get_catalog_object_by_oid_extended()

◆ get_object_address()

◆ 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_publication_schema()

◆ get_object_address_relobject()

◆ get_object_address_rv()

◆ get_object_address_type()

◆ get_object_address_unqualified()

◆ get_object_address_usermapping()

◆ get_object_attnum_acl()

◆ get_object_attnum_name()

◆ get_object_attnum_namespace()

◆ get_object_attnum_oid()

◆ get_object_attnum_owner()

◆ get_object_catcache_name()

◆ get_object_catcache_oid()

◆ get_object_class_descr()

◆ get_object_namensp_unique()

◆ get_object_namespace()

◆ get_object_oid_index()

◆ get_object_property_data()

◆ get_object_type()

◆ get_relation_by_qualified_name()

◆ get_relkind_objtype()

◆ getConstraintTypeDescription()

◆ getObjectDescription()

◆ getObjectDescriptionOids()

◆ getObjectIdentity()

◆ getObjectIdentityParts()

◆ getObjectTypeDescription()

◆ getOpFamilyDescription()

◆ getOpFamilyIdentity()

◆ getProcedureTypeDescription()

◆ getPublicationSchemaInfo()

◆ getRelationDescription()

◆ getRelationIdentity()

◆ getRelationTypeDescription()

◆ is_objectclass_supported()

◆ pg_describe_object()

◆ pg_get_acl()

◆ pg_get_object_address()

◆ pg_identify_object()

◆ pg_identify_object_as_address()

◆ read_objtype_from_string()

◆ strlist_to_textarray()

◆ textarray_to_strvaluelist()

Variable Documentation

◆ InvalidObjectAddress

◆ ObjectProperty

◆ ObjectTypeMap