objectaddress.c

Go to the documentation of this file.

/*-------------------------------------------------------------------------
 *
 * objectaddress.c
 *    functions for working with ObjectAddresses
 *
 * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 *
 * IDENTIFICATION
 *    src/backend/catalog/objectaddress.c
 *
 *-------------------------------------------------------------------------
 */
 
#include "postgres.h"
 
#include "access/genam.h"
#include "access/htup_details.h"
#include "access/relation.h"
#include "access/table.h"
#include "catalog/catalog.h"
#include "catalog/objectaddress.h"
#include "catalog/pg_am.h"
#include "catalog/pg_amop.h"
#include "catalog/pg_amproc.h"
#include "catalog/pg_attrdef.h"
#include "catalog/pg_authid.h"
#include "catalog/pg_auth_members.h"
#include "catalog/pg_cast.h"
#include "catalog/pg_collation.h"
#include "catalog/pg_constraint.h"
#include "catalog/pg_conversion.h"
#include "catalog/pg_database.h"
#include "catalog/pg_default_acl.h"
#include "catalog/pg_event_trigger.h"
#include "catalog/pg_extension.h"
#include "catalog/pg_foreign_data_wrapper.h"
#include "catalog/pg_foreign_server.h"
#include "catalog/pg_language.h"
#include "catalog/pg_largeobject.h"
#include "catalog/pg_largeobject_metadata.h"
#include "catalog/pg_namespace.h"
#include "catalog/pg_opclass.h"
#include "catalog/pg_operator.h"
#include "catalog/pg_opfamily.h"
#include "catalog/pg_parameter_acl.h"
#include "catalog/pg_policy.h"
#include "catalog/pg_proc.h"
#include "catalog/pg_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"
 
/*
 * ObjectProperty
 *
 * This array provides a common part of system object structure; to help
 * consolidate routines to handle various kind of object classes.
 */
typedef struct
{
    const char *class_descr;    /* string describing the catalog, for internal
                                 * error messages */
    Oid         class_oid;      /* oid of catalog */
    Oid         oid_index_oid;  /* oid of index on system oid column */
    SysCacheIdentifier oid_catcache_id; /* id of catcache on system oid column  */
    SysCacheIdentifier name_catcache_id;    /* id of catcache on
                                             * (name,namespace), or (name) if
                                             * the object does not live in a
                                             * namespace */
    AttrNumber  attnum_oid;     /* attribute number of oid column */
    AttrNumber  attnum_name;    /* attnum of name field */
    AttrNumber  attnum_namespace;   /* attnum of namespace field */
    AttrNumber  attnum_owner;   /* attnum of owner field */
    AttrNumber  attnum_acl;     /* attnum of acl field */
    ObjectType  objtype;        /* OBJECT_* of this object type */
    bool        is_nsp_name_unique; /* can the nsp/name combination (or name
                                     * alone, if there's no namespace) be
                                     * considered a unique identifier for an
                                     * object of this class? */
} ObjectPropertyType;
 
static const ObjectPropertyType ObjectProperty[] =
{
    {
        "access method",
        AccessMethodRelationId,
        AmOidIndexId,
        AMOID,
        AMNAME,
        Anum_pg_am_oid,
        Anum_pg_am_amname,
        InvalidAttrNumber,
        InvalidAttrNumber,
        InvalidAttrNumber,
        OBJECT_ACCESS_METHOD,
        true
    },
    {
        "access method operator",
        AccessMethodOperatorRelationId,
        AccessMethodOperatorOidIndexId,
        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
    },
};
 
/*
 * This struct maps the string object types as returned by
 * getObjectTypeDescription into ObjectType enum values.  Note that some enum
 * values can be obtained by different names, and that some string object types
 * do not have corresponding values in the output enum.  The user of this map
 * must be careful to test for invalid values being returned.
 *
 * To ease maintenance, this follows the order of getObjectTypeDescription.
 */
static const struct object_type_map
{
    const char *tm_name;
    ObjectType  tm_type;
}
 
            ObjectTypeMap[] =
{
    {
        "table", OBJECT_TABLE
    },
    {
        "index", OBJECT_INDEX
    },
    {
        "sequence", OBJECT_SEQUENCE
    },
    {
        "toast table", -1
    },                          /* unmapped */
    {
        "view", OBJECT_VIEW
    },
    {
        "materialized view", OBJECT_MATVIEW
    },
    {
        "composite type", -1
    },                          /* unmapped */
    {
        "foreign table", OBJECT_FOREIGN_TABLE
    },
    {
        "property graph", OBJECT_PROPGRAPH
    },
    {
        "table column", OBJECT_COLUMN
    },
    {
        "index column", -1
    },                          /* unmapped */
    {
        "sequence column", -1
    },                          /* unmapped */
    {
        "toast table column", -1
    },                          /* unmapped */
    {
        "view column", -1
    },                          /* unmapped */
    {
        "materialized view column", -1
    },                          /* unmapped */
    {
        "composite type column", -1
    },                          /* unmapped */
    {
        "foreign table column", OBJECT_COLUMN
    },
    {
        "aggregate", OBJECT_AGGREGATE
    },
    {
        "function", OBJECT_FUNCTION
    },
    {
        "procedure", OBJECT_PROCEDURE
    },
    {
        "type", OBJECT_TYPE
    },
    {
        "cast", OBJECT_CAST
    },
    {
        "collation", OBJECT_COLLATION
    },
    {
        "table constraint", OBJECT_TABCONSTRAINT
    },
    {
        "domain constraint", OBJECT_DOMCONSTRAINT
    },
    {
        "conversion", OBJECT_CONVERSION
    },
    {
        "default value", OBJECT_DEFAULT
    },
    {
        "language", OBJECT_LANGUAGE
    },
    {
        "large object", OBJECT_LARGEOBJECT
    },
    {
        "operator", OBJECT_OPERATOR
    },
    {
        "operator class", OBJECT_OPCLASS
    },
    {
        "operator family", OBJECT_OPFAMILY
    },
    {
        "access method", OBJECT_ACCESS_METHOD
    },
    {
        "operator of access method", OBJECT_AMOP
    },
    {
        "function of access method", OBJECT_AMPROC
    },
    {
        "rule", OBJECT_RULE
    },
    {
        "trigger", OBJECT_TRIGGER
    },
    {
        "schema", OBJECT_SCHEMA
    },
    {
        "text search parser", OBJECT_TSPARSER
    },
    {
        "text search dictionary", OBJECT_TSDICTIONARY
    },
    {
        "text search template", OBJECT_TSTEMPLATE
    },
    {
        "text search configuration", OBJECT_TSCONFIGURATION
    },
    {
        "role", OBJECT_ROLE
    },
    {
        "role membership", -1   /* unmapped */
    },
    {
        "database", OBJECT_DATABASE
    },
    {
        "tablespace", OBJECT_TABLESPACE
    },
    {
        "foreign-data wrapper", OBJECT_FDW
    },
    {
        "server", OBJECT_FOREIGN_SERVER
    },
    {
        "user mapping", OBJECT_USER_MAPPING
    },
    {
        "default acl", OBJECT_DEFACL
    },
    {
        "extension", OBJECT_EXTENSION
    },
    {
        "event trigger", OBJECT_EVENT_TRIGGER
    },
    {
        "parameter ACL", OBJECT_PARAMETER_ACL
    },
    {
        "policy", OBJECT_POLICY
    },
    {
        "property graph element", -1
    },
    {
        "property graph element label", -1
    },
    {
        "property graph label", -1
    },
    {
        "property graph label property", -1
    },
    {
        "property graph property", -1
    },
    {
        "publication", OBJECT_PUBLICATION
    },
    {
        "publication namespace", OBJECT_PUBLICATION_NAMESPACE
    },
    {
        "publication relation", OBJECT_PUBLICATION_REL
    },
    {
        "subscription", OBJECT_SUBSCRIPTION
    },
    {
        "transform", OBJECT_TRANSFORM
    },
    {
        "statistics object", OBJECT_STATISTIC_EXT
    }
};
 
const ObjectAddress InvalidObjectAddress =
{
    InvalidOid,
    InvalidOid,
    0
};
 
static ObjectAddress get_object_address_unqualified(ObjectType objtype,
                                                    String *strval, bool missing_ok);
static ObjectAddress get_relation_by_qualified_name(ObjectType objtype,
                                                    List *object, Relation *relp,
                                                    LOCKMODE lockmode, bool missing_ok);
static ObjectAddress get_object_address_relobject(ObjectType objtype,
                                                  List *object, Relation *relp, bool missing_ok);
static ObjectAddress get_object_address_attribute(ObjectType objtype,
                                                  List *object, Relation *relp,
                                                  LOCKMODE lockmode, bool missing_ok);
static ObjectAddress get_object_address_attrdef(ObjectType objtype,
                                                List *object, Relation *relp, LOCKMODE lockmode,
                                                bool missing_ok);
static ObjectAddress get_object_address_type(ObjectType objtype,
                                             TypeName *typename, bool missing_ok);
static ObjectAddress get_object_address_opcf(ObjectType objtype, List *object,
                                             bool missing_ok);
static ObjectAddress get_object_address_opf_member(ObjectType objtype,
                                                   List *object, bool missing_ok);
 
static ObjectAddress get_object_address_usermapping(List *object,
                                                    bool missing_ok);
static ObjectAddress get_object_address_publication_rel(List *object,
                                                        Relation *relp,
                                                        bool missing_ok);
static ObjectAddress get_object_address_publication_schema(List *object,
                                                           bool missing_ok);
static ObjectAddress get_object_address_defacl(List *object,
                                               bool missing_ok);
static const ObjectPropertyType *get_object_property_data(Oid class_id);
 
static void getRelationDescription(StringInfo buffer, Oid relid,
                                   bool missing_ok);
static void getOpFamilyDescription(StringInfo buffer, Oid opfid,
                                   bool missing_ok);
static void getRelationTypeDescription(StringInfo buffer, Oid relid,
                                       int32 objectSubId, bool missing_ok);
static void getProcedureTypeDescription(StringInfo buffer, Oid procid,
                                        bool missing_ok);
static void getConstraintTypeDescription(StringInfo buffer, Oid constroid,
                                         bool missing_ok);
static void getOpFamilyIdentity(StringInfo buffer, Oid opfid, List **object,
                                bool missing_ok);
static void getRelationIdentity(StringInfo buffer, Oid relid, List **object,
                                bool missing_ok);
 
/*
 * Translate an object name and arguments (as passed by the parser) to an
 * ObjectAddress.
 *
 * The returned object will be locked using the specified lockmode.  If a
 * sub-object is looked up, the parent object will be locked instead.
 *
 * If the object is a relation or a child object of a relation (e.g. an
 * attribute or constraint), the relation is also opened and *relp receives
 * the open relcache entry pointer; otherwise, *relp is set to NULL.
 * (relp can be NULL if the caller never passes a relation-related object.)  This
 * is a bit grotty but it makes life simpler, since the caller will
 * typically need the relcache entry too.  Caller must close the relcache
 * entry when done with it.  The relation is locked with the specified lockmode
 * if the target object is the relation itself or an attribute, but for other
 * child objects, only AccessShareLock is acquired on the relation.
 *
 * If the object is not found, an error is thrown, unless missing_ok is
 * true.  In this case, no lock is acquired, relp is set to NULL, and the
 * returned address has objectId set to InvalidOid.
 *
 * We don't currently provide a function to release the locks acquired here;
 * typically, the lock must be held until commit to guard against a concurrent
 * drop operation.
 *
 * Note: If the object is not found, we don't give any indication of the
 * reason.  (It might have been a missing schema if the name was qualified, or
 * a nonexistent type name in case of a cast, function or operator; etc).
 * Currently there is only one caller that might be interested in such info, so
 * we don't spend much effort here.  If more callers start to care, it might be
 * better to add some support for that in this function.
 */
ObjectAddress
get_object_address(ObjectType objtype, Node *object,
                   Relation *relp, LOCKMODE lockmode, bool missing_ok)
{
    ObjectAddress address = {InvalidOid, InvalidOid, 0};
    ObjectAddress old_address = {InvalidOid, InvalidOid, 0};
    Relation    relation = NULL;
    uint64      inval_count;
 
    /* Some kind of lock must be taken. */
    Assert(lockmode != NoLock);
 
    for (;;)
    {
        /*
         * Remember this value, so that, after looking up the object name and
         * locking it, we can check whether any invalidation messages have
         * been processed that might require a do-over.
         */
        inval_count = SharedInvalidMessageCounter;
 
        /* Look up object address. */
        switch (objtype)
        {
            case OBJECT_INDEX:
            case OBJECT_SEQUENCE:
            case OBJECT_TABLE:
            case OBJECT_VIEW:
            case OBJECT_MATVIEW:
            case OBJECT_FOREIGN_TABLE:
            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;
}
 
/*
 * Return an ObjectAddress based on a RangeVar and an object name. The
 * name of the relation identified by the RangeVar is prepended to the
 * (possibly empty) list passed in as object. This is useful to find
 * the ObjectAddress of objects that depend on a relation. All other
 * considerations are exactly as for get_object_address above.
 */
ObjectAddress
get_object_address_rv(ObjectType objtype, RangeVar *rel, List *object,
                      Relation *relp, LOCKMODE lockmode,
                      bool missing_ok)
{
    if (rel)
    {
        object = lcons(makeString(rel->relname), object);
        if (rel->schemaname)
            object = lcons(makeString(rel->schemaname), object);
        if (rel->catalogname)
            object = lcons(makeString(rel->catalogname), object);
    }
 
    return get_object_address(objtype, (Node *) object,
                              relp, lockmode, missing_ok);
}
 
/*
 * Find an ObjectAddress for a type of object that is identified by an
 * unqualified name.
 */
static ObjectAddress
get_object_address_unqualified(ObjectType objtype,
                               String *strval, bool missing_ok)
{
    const char *name;
    ObjectAddress address;
 
    name = strVal(strval);
 
    /* Translate name to OID. */
    switch (objtype)
    {
        case OBJECT_ACCESS_METHOD:
            address.classId = AccessMethodRelationId;
            address.objectId = get_am_oid(name, missing_ok);
            address.objectSubId = 0;
            break;
        case OBJECT_DATABASE:
            address.classId = DatabaseRelationId;
            address.objectId = get_database_oid(name, missing_ok);
            address.objectSubId = 0;
            break;
        case OBJECT_EXTENSION:
            address.classId = ExtensionRelationId;
            address.objectId = get_extension_oid(name, missing_ok);
            address.objectSubId = 0;
            break;
        case OBJECT_TABLESPACE:
            address.classId = TableSpaceRelationId;
            address.objectId = get_tablespace_oid(name, missing_ok);
            address.objectSubId = 0;
            break;
        case OBJECT_ROLE:
            address.classId = AuthIdRelationId;
            address.objectId = get_role_oid(name, missing_ok);
            address.objectSubId = 0;
            break;
        case OBJECT_SCHEMA:
            address.classId = NamespaceRelationId;
            address.objectId = get_namespace_oid(name, missing_ok);
            address.objectSubId = 0;
            break;
        case OBJECT_LANGUAGE:
            address.classId = LanguageRelationId;
            address.objectId = get_language_oid(name, missing_ok);
            address.objectSubId = 0;
            break;
        case OBJECT_FDW:
            address.classId = ForeignDataWrapperRelationId;
            address.objectId = get_foreign_data_wrapper_oid(name, missing_ok);
            address.objectSubId = 0;
            break;
        case OBJECT_FOREIGN_SERVER:
            address.classId = ForeignServerRelationId;
            address.objectId = get_foreign_server_oid(name, missing_ok);
            address.objectSubId = 0;
            break;
        case OBJECT_EVENT_TRIGGER:
            address.classId = EventTriggerRelationId;
            address.objectId = get_event_trigger_oid(name, missing_ok);
            address.objectSubId = 0;
            break;
        case OBJECT_PARAMETER_ACL:
            address.classId = ParameterAclRelationId;
            address.objectId = ParameterAclLookup(name, missing_ok);
            address.objectSubId = 0;
            break;
        case OBJECT_PUBLICATION:
            address.classId = PublicationRelationId;
            address.objectId = get_publication_oid(name, missing_ok);
            address.objectSubId = 0;
            break;
        case OBJECT_SUBSCRIPTION:
            address.classId = SubscriptionRelationId;
            address.objectId = get_subscription_oid(name, missing_ok);
            address.objectSubId = 0;
            break;
        default:
            elog(ERROR, "unrecognized object type: %d", (int) objtype);
            /* placate compiler, which doesn't know elog won't return */
            address.classId = InvalidOid;
            address.objectId = InvalidOid;
            address.objectSubId = 0;
    }
 
    return address;
}
 
/*
 * Locate a relation by qualified name.
 */
static ObjectAddress
get_relation_by_qualified_name(ObjectType objtype, List *object,
                               Relation *relp, LOCKMODE lockmode,
                               bool missing_ok)
{
    Relation    relation;
    ObjectAddress address;
 
    address.classId = RelationRelationId;
    address.objectId = InvalidOid;
    address.objectSubId = 0;
 
    relation = relation_openrv_extended(makeRangeVarFromNameList(object),
                                        lockmode, missing_ok);
    if (!relation)
        return address;
 
    switch (objtype)
    {
        case OBJECT_INDEX:
            if (relation->rd_rel->relkind != RELKIND_INDEX &&
                relation->rd_rel->relkind != RELKIND_PARTITIONED_INDEX)
                ereport(ERROR,
                        (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                         errmsg("\"%s\" is not an index",
                                RelationGetRelationName(relation))));
            break;
        case OBJECT_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;
}
 
/*
 * Find object address for an object that is attached to a relation.
 *
 * Note that we take only an AccessShareLock on the relation.  We need not
 * pass down the LOCKMODE from get_object_address(), because that is the lock
 * mode for the object itself, not the relation to which it is attached.
 */
static ObjectAddress
get_object_address_relobject(ObjectType objtype, List *object,
                             Relation *relp, bool missing_ok)
{
    ObjectAddress address;
    Relation    relation = NULL;
    int         nnames;
    const char *depname;
    List       *relname;
    Oid         reloid;
 
    /* Extract name of dependent object. */
    depname = strVal(llast(object));
 
    /* Separate relation name from dependent object name. */
    nnames = list_length(object);
    if (nnames < 2)
        ereport(ERROR,
                (errcode(ERRCODE_SYNTAX_ERROR),
                 errmsg("must specify relation and object name")));
 
    /* Extract relation name and open relation. */
    relname = list_copy_head(object, nnames - 1);
    relation = table_openrv_extended(makeRangeVarFromNameList(relname),
                                     AccessShareLock,
                                     missing_ok);
 
    reloid = relation ? RelationGetRelid(relation) : InvalidOid;
 
    switch (objtype)
    {
        case OBJECT_RULE:
            address.classId = RewriteRelationId;
            address.objectId = relation ?
                get_rewrite_oid(reloid, depname, missing_ok) : InvalidOid;
            address.objectSubId = 0;
            break;
        case OBJECT_TRIGGER:
            address.classId = TriggerRelationId;
            address.objectId = relation ?
                get_trigger_oid(reloid, depname, missing_ok) : InvalidOid;
            address.objectSubId = 0;
            break;
        case OBJECT_TABCONSTRAINT:
            address.classId = ConstraintRelationId;
            address.objectId = relation ?
                get_relation_constraint_oid(reloid, depname, missing_ok) :
                InvalidOid;
            address.objectSubId = 0;
            break;
        case OBJECT_POLICY:
            address.classId = PolicyRelationId;
            address.objectId = relation ?
                get_relation_policy_oid(reloid, depname, missing_ok) :
                InvalidOid;
            address.objectSubId = 0;
            break;
        default:
            elog(ERROR, "unrecognized object type: %d", (int) objtype);
    }
 
    /* Avoid relcache leak when object not found. */
    if (!OidIsValid(address.objectId))
    {
        if (relation != NULL)
            table_close(relation, AccessShareLock);
 
        relation = NULL;        /* department of accident prevention */
        return address;
    }
 
    /* Done. */
    *relp = relation;
    return address;
}
 
/*
 * Find the ObjectAddress for an attribute.
 */
static ObjectAddress
get_object_address_attribute(ObjectType objtype, List *object,
                             Relation *relp, LOCKMODE lockmode,
                             bool missing_ok)
{
    ObjectAddress address;
    List       *relname;
    Oid         reloid;
    Relation    relation;
    const char *attname;
    AttrNumber  attnum;
 
    /* Extract relation name and open relation. */
    if (list_length(object) < 2)
        ereport(ERROR,
                (errcode(ERRCODE_SYNTAX_ERROR),
                 errmsg("column name must be qualified")));
    attname = strVal(llast(object));
    relname = list_copy_head(object, list_length(object) - 1);
    /* XXX no missing_ok support here */
    relation = relation_openrv(makeRangeVarFromNameList(relname), lockmode);
    reloid = RelationGetRelid(relation);
 
    /* Look up attribute and construct return value. */
    attnum = get_attnum(reloid, attname);
    if (attnum == InvalidAttrNumber)
    {
        if (!missing_ok)
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_COLUMN),
                     errmsg("column \"%s\" of relation \"%s\" does not exist",
                            attname, NameListToString(relname))));
 
        address.classId = RelationRelationId;
        address.objectId = InvalidOid;
        address.objectSubId = InvalidAttrNumber;
        relation_close(relation, lockmode);
        return address;
    }
 
    address.classId = RelationRelationId;
    address.objectId = reloid;
    address.objectSubId = attnum;
 
    *relp = relation;
    return address;
}
 
/*
 * Find the ObjectAddress for an attribute's default value.
 */
static ObjectAddress
get_object_address_attrdef(ObjectType objtype, List *object,
                           Relation *relp, LOCKMODE lockmode,
                           bool missing_ok)
{
    ObjectAddress address;
    List       *relname;
    Oid         reloid;
    Relation    relation;
    const char *attname;
    AttrNumber  attnum;
    TupleDesc   tupdesc;
    Oid         defoid;
 
    /* Extract relation name and open relation. */
    if (list_length(object) < 2)
        ereport(ERROR,
                (errcode(ERRCODE_SYNTAX_ERROR),
                 errmsg("column name must be qualified")));
    attname = strVal(llast(object));
    relname = list_copy_head(object, list_length(object) - 1);
    /* XXX no missing_ok support here */
    relation = relation_openrv(makeRangeVarFromNameList(relname), lockmode);
    reloid = RelationGetRelid(relation);
 
    tupdesc = RelationGetDescr(relation);
 
    /* Look up attribute number and fetch the pg_attrdef OID */
    attnum = get_attnum(reloid, attname);
    defoid = InvalidOid;
    if (attnum != InvalidAttrNumber && tupdesc->constr != NULL)
        defoid = GetAttrDefaultOid(reloid, attnum);
    if (!OidIsValid(defoid))
    {
        if (!missing_ok)
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_COLUMN),
                     errmsg("default value for column \"%s\" of relation \"%s\" does not exist",
                            attname, NameListToString(relname))));
 
        address.classId = AttrDefaultRelationId;
        address.objectId = InvalidOid;
        address.objectSubId = InvalidAttrNumber;
        relation_close(relation, lockmode);
        return address;
    }
 
    address.classId = AttrDefaultRelationId;
    address.objectId = defoid;
    address.objectSubId = 0;
 
    *relp = relation;
    return address;
}
 
/*
 * Find the ObjectAddress for a type or domain
 */
static ObjectAddress
get_object_address_type(ObjectType objtype, TypeName *typename, bool missing_ok)
{
    ObjectAddress address;
    Type        tup;
 
    address.classId = TypeRelationId;
    address.objectId = InvalidOid;
    address.objectSubId = 0;
 
    tup = LookupTypeName(NULL, typename, NULL, missing_ok);
    if (!HeapTupleIsValid(tup))
    {
        if (!missing_ok)
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_OBJECT),
                     errmsg("type \"%s\" does not exist",
                            TypeNameToString(typename))));
        return address;
    }
    address.objectId = typeTypeId(tup);
 
    if (objtype == OBJECT_DOMAIN)
    {
        if (((Form_pg_type) GETSTRUCT(tup))->typtype != TYPTYPE_DOMAIN)
            ereport(ERROR,
                    (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                     errmsg("\"%s\" is not a domain",
                            TypeNameToString(typename))));
    }
 
    ReleaseSysCache(tup);
 
    return address;
}
 
/*
 * Find the ObjectAddress for an opclass or opfamily.
 */
static ObjectAddress
get_object_address_opcf(ObjectType objtype, List *object, bool missing_ok)
{
    Oid         amoid;
    ObjectAddress address;
 
    /* XXX no missing_ok support here */
    amoid = get_index_am_oid(strVal(linitial(object)), false);
    object = list_copy_tail(object, 1);
 
    switch (objtype)
    {
        case OBJECT_OPCLASS:
            address.classId = OperatorClassRelationId;
            address.objectId = get_opclass_oid(amoid, object, missing_ok);
            address.objectSubId = 0;
            break;
        case OBJECT_OPFAMILY:
            address.classId = OperatorFamilyRelationId;
            address.objectId = get_opfamily_oid(amoid, object, missing_ok);
            address.objectSubId = 0;
            break;
        default:
            elog(ERROR, "unrecognized object type: %d", (int) objtype);
            /* placate compiler, which doesn't know elog won't return */
            address.classId = InvalidOid;
            address.objectId = InvalidOid;
            address.objectSubId = 0;
    }
 
    return address;
}
 
/*
 * Find the ObjectAddress for an opclass/opfamily member.
 *
 * (The returned address corresponds to a pg_amop/pg_amproc object).
 */
static ObjectAddress
get_object_address_opf_member(ObjectType objtype,
                              List *object, bool missing_ok)
{
    ObjectAddress famaddr;
    ObjectAddress address;
    ListCell   *cell;
    List       *copy;
    TypeName   *typenames[2];
    Oid         typeoids[2];
    int         membernum;
    int         i;
 
    /*
     * The last element of the object list contains the strategy or procedure
     * number.  We need to strip that out before getting the opclass/family
     * address.  The rest can be used directly by get_object_address_opcf().
     */
    membernum = atoi(strVal(llast(linitial(object))));
    copy = list_copy_head(linitial(object), list_length(linitial(object)) - 1);
 
    /* no missing_ok support here */
    famaddr = get_object_address_opcf(OBJECT_OPFAMILY, copy, false);
 
    /* find out left/right type names and OIDs */
    typenames[0] = typenames[1] = NULL;
    typeoids[0] = typeoids[1] = InvalidOid;
    i = 0;
    foreach(cell, lsecond(object))
    {
        ObjectAddress typaddr;
 
        typenames[i] = lfirst_node(TypeName, cell);
        typaddr = get_object_address_type(OBJECT_TYPE, typenames[i], missing_ok);
        typeoids[i] = typaddr.objectId;
        if (++i >= 2)
            break;
    }
 
    switch (objtype)
    {
        case OBJECT_AMOP:
            {
                HeapTuple   tp;
 
                ObjectAddressSet(address, AccessMethodOperatorRelationId,
                                 InvalidOid);
 
                tp = SearchSysCache4(AMOPSTRATEGY,
                                     ObjectIdGetDatum(famaddr.objectId),
                                     ObjectIdGetDatum(typeoids[0]),
                                     ObjectIdGetDatum(typeoids[1]),
                                     Int16GetDatum(membernum));
                if (!HeapTupleIsValid(tp))
                {
                    if (!missing_ok)
                        ereport(ERROR,
                                (errcode(ERRCODE_UNDEFINED_OBJECT),
                                 errmsg("operator %d (%s, %s) of %s does not exist",
                                        membernum,
                                        TypeNameToString(typenames[0]),
                                        TypeNameToString(typenames[1]),
                                        getObjectDescription(&famaddr, false))));
                }
                else
                {
                    address.objectId = ((Form_pg_amop) GETSTRUCT(tp))->oid;
                    ReleaseSysCache(tp);
                }
            }
            break;
 
        case OBJECT_AMPROC:
            {
                HeapTuple   tp;
 
                ObjectAddressSet(address, AccessMethodProcedureRelationId,
                                 InvalidOid);
 
                tp = SearchSysCache4(AMPROCNUM,
                                     ObjectIdGetDatum(famaddr.objectId),
                                     ObjectIdGetDatum(typeoids[0]),
                                     ObjectIdGetDatum(typeoids[1]),
                                     Int16GetDatum(membernum));
                if (!HeapTupleIsValid(tp))
                {
                    if (!missing_ok)
                        ereport(ERROR,
                                (errcode(ERRCODE_UNDEFINED_OBJECT),
                                 errmsg("function %d (%s, %s) of %s does not exist",
                                        membernum,
                                        TypeNameToString(typenames[0]),
                                        TypeNameToString(typenames[1]),
                                        getObjectDescription(&famaddr, false))));
                }
                else
                {
                    address.objectId = ((Form_pg_amproc) GETSTRUCT(tp))->oid;
                    ReleaseSysCache(tp);
                }
            }
            break;
        default:
            elog(ERROR, "unrecognized object type: %d", (int) objtype);
    }
 
    return address;
}
 
/*
 * Find the ObjectAddress for a user mapping.
 */
static ObjectAddress
get_object_address_usermapping(List *object, bool missing_ok)
{
    ObjectAddress address;
    Oid         userid;
    char       *username;
    char       *servername;
    ForeignServer *server;
    HeapTuple   tp;
 
    ObjectAddressSet(address, UserMappingRelationId, InvalidOid);
 
    /* fetch string names from input lists, for error messages */
    username = strVal(linitial(object));
    servername = strVal(lsecond(object));
 
    /* look up pg_authid OID of mapped user; InvalidOid if PUBLIC */
    if (strcmp(username, "public") == 0)
        userid = InvalidOid;
    else
    {
        tp = SearchSysCache1(AUTHNAME,
                             CStringGetDatum(username));
        if (!HeapTupleIsValid(tp))
        {
            if (!missing_ok)
                ereport(ERROR,
                        (errcode(ERRCODE_UNDEFINED_OBJECT),
                         errmsg("user mapping for user \"%s\" on server \"%s\" does not exist",
                                username, servername)));
            return address;
        }
        userid = ((Form_pg_authid) GETSTRUCT(tp))->oid;
        ReleaseSysCache(tp);
    }
 
    /* Now look up the pg_user_mapping tuple */
    server = GetForeignServerByName(servername, true);
    if (!server)
    {
        if (!missing_ok)
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_OBJECT),
                     errmsg("server \"%s\" does not exist", servername)));
        return address;
    }
    tp = SearchSysCache2(USERMAPPINGUSERSERVER,
                         ObjectIdGetDatum(userid),
                         ObjectIdGetDatum(server->serverid));
    if (!HeapTupleIsValid(tp))
    {
        if (!missing_ok)
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_OBJECT),
                     errmsg("user mapping for user \"%s\" on server \"%s\" does not exist",
                            username, servername)));
        return address;
    }
 
    address.objectId = ((Form_pg_user_mapping) GETSTRUCT(tp))->oid;
 
    ReleaseSysCache(tp);
 
    return address;
}
 
/*
 * Find the ObjectAddress for a publication relation.  The first element of
 * the object parameter is the relation name, the second is the
 * publication name.
 */
static ObjectAddress
get_object_address_publication_rel(List *object,
                                   Relation *relp, bool missing_ok)
{
    ObjectAddress address;
    Relation    relation;
    List       *relname;
    char       *pubname;
    Publication *pub;
 
    ObjectAddressSet(address, PublicationRelRelationId, InvalidOid);
 
    relname = linitial(object);
    relation = relation_openrv_extended(makeRangeVarFromNameList(relname),
                                        AccessShareLock, missing_ok);
    if (!relation)
        return address;
 
    /* fetch publication name from input list */
    pubname = strVal(lsecond(object));
 
    /* Now look up the pg_publication tuple */
    pub = GetPublicationByName(pubname, missing_ok);
    if (!pub)
    {
        relation_close(relation, AccessShareLock);
        return address;
    }
 
    /* Find the publication relation mapping in syscache. */
    address.objectId =
        GetSysCacheOid2(PUBLICATIONRELMAP, Anum_pg_publication_rel_oid,
                        ObjectIdGetDatum(RelationGetRelid(relation)),
                        ObjectIdGetDatum(pub->oid));
    if (!OidIsValid(address.objectId))
    {
        if (!missing_ok)
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_OBJECT),
                     errmsg("publication relation \"%s\" in publication \"%s\" does not exist",
                            RelationGetRelationName(relation), pubname)));
        relation_close(relation, AccessShareLock);
        return address;
    }
 
    *relp = relation;
    return address;
}
 
/*
 * Find the ObjectAddress for a publication schema. The first element of the
 * object parameter is the schema name, the second is the publication name.
 */
static ObjectAddress
get_object_address_publication_schema(List *object, bool missing_ok)
{
    ObjectAddress address;
    Publication *pub;
    char       *pubname;
    char       *schemaname;
    Oid         schemaid;
 
    ObjectAddressSet(address, PublicationNamespaceRelationId, InvalidOid);
 
    /* Fetch schema name and publication name from input list */
    schemaname = strVal(linitial(object));
    pubname = strVal(lsecond(object));
 
    schemaid = get_namespace_oid(schemaname, missing_ok);
    if (!OidIsValid(schemaid))
        return address;
 
    /* Now look up the pg_publication tuple */
    pub = GetPublicationByName(pubname, missing_ok);
    if (!pub)
        return address;
 
    /* Find the publication schema mapping in syscache */
    address.objectId =
        GetSysCacheOid2(PUBLICATIONNAMESPACEMAP,
                        Anum_pg_publication_namespace_oid,
                        ObjectIdGetDatum(schemaid),
                        ObjectIdGetDatum(pub->oid));
    if (!OidIsValid(address.objectId) && !missing_ok)
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("publication schema \"%s\" in publication \"%s\" does not exist",
                        schemaname, pubname)));
 
    return address;
}
 
/*
 * Find the ObjectAddress for a default ACL.
 */
static ObjectAddress
get_object_address_defacl(List *object, bool missing_ok)
{
    HeapTuple   tp;
    Oid         userid;
    Oid         schemaid;
    char       *username;
    char       *schema;
    char        objtype;
    char       *objtype_str;
    ObjectAddress address;
 
    ObjectAddressSet(address, DefaultAclRelationId, InvalidOid);
 
    /*
     * First figure out the textual attributes so that they can be used for
     * error reporting.
     */
    username = strVal(lsecond(object));
    if (list_length(object) >= 3)
        schema = (char *) strVal(lthird(object));
    else
        schema = NULL;
 
    /*
     * Decode defaclobjtype.  Only first char is considered; the rest of the
     * string, if any, is blissfully ignored.
     */
    objtype = ((char *) strVal(linitial(object)))[0];
    switch (objtype)
    {
        case DEFACLOBJ_RELATION:
            objtype_str = "tables";
            break;
        case DEFACLOBJ_SEQUENCE:
            objtype_str = "sequences";
            break;
        case DEFACLOBJ_FUNCTION:
            objtype_str = "functions";
            break;
        case DEFACLOBJ_TYPE:
            objtype_str = "types";
            break;
        case DEFACLOBJ_NAMESPACE:
            objtype_str = "schemas";
            break;
        case DEFACLOBJ_LARGEOBJECT:
            objtype_str = "large objects";
            break;
        default:
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("unrecognized default ACL object type \"%c\"", objtype),
                     errhint("Valid object types are \"%c\", \"%c\", \"%c\", \"%c\", \"%c\", \"%c\".",
                             DEFACLOBJ_RELATION,
                             DEFACLOBJ_SEQUENCE,
                             DEFACLOBJ_FUNCTION,
                             DEFACLOBJ_TYPE,
                             DEFACLOBJ_NAMESPACE,
                             DEFACLOBJ_LARGEOBJECT)));
    }
 
    /*
     * Look up user ID.  Behave as "default ACL not found" if the user doesn't
     * exist.
     */
    tp = SearchSysCache1(AUTHNAME,
                         CStringGetDatum(username));
    if (!HeapTupleIsValid(tp))
        goto not_found;
    userid = ((Form_pg_authid) GETSTRUCT(tp))->oid;
    ReleaseSysCache(tp);
 
    /*
     * If a schema name was given, look up its OID.  If it doesn't exist,
     * behave as "default ACL not found".
     */
    if (schema)
    {
        schemaid = get_namespace_oid(schema, true);
        if (schemaid == InvalidOid)
            goto not_found;
    }
    else
        schemaid = InvalidOid;
 
    /* Finally, look up the pg_default_acl object */
    tp = SearchSysCache3(DEFACLROLENSPOBJ,
                         ObjectIdGetDatum(userid),
                         ObjectIdGetDatum(schemaid),
                         CharGetDatum(objtype));
    if (!HeapTupleIsValid(tp))
        goto not_found;
 
    address.objectId = ((Form_pg_default_acl) GETSTRUCT(tp))->oid;
    ReleaseSysCache(tp);
 
    return address;
 
not_found:
    if (!missing_ok)
    {
        if (schema)
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_OBJECT),
                     errmsg("default ACL for user \"%s\" in schema \"%s\" on %s does not exist",
                            username, schema, objtype_str)));
        else
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_OBJECT),
                     errmsg("default ACL for user \"%s\" on %s does not exist",
                            username, objtype_str)));
    }
    return address;
}
 
/*
 * Convert an array of TEXT into a List of string Values, as emitted by the
 * parser, which is what get_object_address uses as input.
 */
static List *
textarray_to_strvaluelist(ArrayType *arr)
{
    Datum      *elems;
    bool       *nulls;
    int         nelems;
    List       *list = NIL;
    int         i;
 
    deconstruct_array_builtin(arr, TEXTOID, &elems, &nulls, &nelems);
 
    for (i = 0; i < nelems; i++)
    {
        if (nulls[i])
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("name or argument lists may not contain nulls")));
        list = lappend(list, makeString(TextDatumGetCString(elems[i])));
    }
 
    return list;
}
 
/*
 * SQL-callable version of get_object_address
 */
Datum
pg_get_object_address(PG_FUNCTION_ARGS)
{
    char       *ttype = TextDatumGetCString(PG_GETARG_DATUM(0));
    ArrayType  *namearr = PG_GETARG_ARRAYTYPE_P(1);
    ArrayType  *argsarr = PG_GETARG_ARRAYTYPE_P(2);
    int         itype;
    ObjectType  type;
    List       *name = NIL;
    TypeName   *typename = NULL;
    List       *args = NIL;
    Node       *objnode = NULL;
    ObjectAddress addr;
    TupleDesc   tupdesc;
    Datum       values[3];
    bool        nulls[3];
    HeapTuple   htup;
    Relation    relation;
 
    /* Decode object type, raise error if unknown */
    itype = read_objtype_from_string(ttype);
    if (itype < 0)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("unsupported object type \"%s\"", ttype)));
    type = (ObjectType) itype;
 
    /*
     * Convert the text array to the representation appropriate for the given
     * object type.  Most use a simple string Values list, but there are some
     * exceptions.
     */
    if (type == OBJECT_TYPE || type == OBJECT_DOMAIN || type == OBJECT_CAST ||
        type == OBJECT_TRANSFORM || type == OBJECT_DOMCONSTRAINT)
    {
        Datum      *elems;
        bool       *nulls;
        int         nelems;
 
        deconstruct_array_builtin(namearr, TEXTOID, &elems, &nulls, &nelems);
        if (nelems != 1)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("name list length must be exactly %d", 1)));
        if (nulls[0])
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("name or argument lists may not contain nulls")));
        typename = typeStringToTypeName(TextDatumGetCString(elems[0]), NULL);
    }
    else if (type == OBJECT_LARGEOBJECT)
    {
        Datum      *elems;
        bool       *nulls;
        int         nelems;
 
        deconstruct_array_builtin(namearr, TEXTOID, &elems, &nulls, &nelems);
        if (nelems != 1)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("name list length must be exactly %d", 1)));
        if (nulls[0])
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("large object OID may not be null")));
        objnode = (Node *) makeFloat(TextDatumGetCString(elems[0]));
    }
    else
    {
        name = textarray_to_strvaluelist(namearr);
        if (name == NIL)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("name list length must be at least %d", 1)));
    }
 
    /*
     * If args are given, decode them according to the object type.
     */
    if (type == OBJECT_AGGREGATE ||
        type == OBJECT_FUNCTION ||
        type == OBJECT_PROCEDURE ||
        type == OBJECT_ROUTINE ||
        type == OBJECT_OPERATOR ||
        type == OBJECT_CAST ||
        type == OBJECT_AMOP ||
        type == OBJECT_AMPROC)
    {
        /* in these cases, the args list must be of TypeName */
        Datum      *elems;
        bool       *nulls;
        int         nelems;
        int         i;
 
        deconstruct_array_builtin(argsarr, TEXTOID, &elems, &nulls, &nelems);
 
        args = NIL;
        for (i = 0; i < nelems; i++)
        {
            if (nulls[i])
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                         errmsg("name or argument lists may not contain nulls")));
            args = lappend(args,
                           typeStringToTypeName(TextDatumGetCString(elems[i]),
                                                NULL));
        }
    }
    else
    {
        /* For all other object types, use string Values */
        args = textarray_to_strvaluelist(argsarr);
    }
 
    /*
     * get_object_address is pretty sensitive to the length of its input
     * lists; check that they're what it wants.
     */
    switch (type)
    {
        case OBJECT_PUBLICATION_NAMESPACE:
        case OBJECT_USER_MAPPING:
            if (list_length(name) != 1)
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                         errmsg("name list length must be exactly %d", 1)));
            /* fall through to check args length */
            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));
}
 
/*
 * Check ownership of an object previously identified by get_object_address.
 */
void
check_object_ownership(Oid roleid, ObjectType objtype, ObjectAddress address,
                       Node *object, Relation relation)
{
    switch (objtype)
    {
        case OBJECT_INDEX:
        case OBJECT_SEQUENCE:
        case OBJECT_TABLE:
        case OBJECT_VIEW:
        case OBJECT_MATVIEW:
        case OBJECT_FOREIGN_TABLE:
        case OBJECT_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;
    }
}
 
/*
 * get_object_namespace
 *
 * Find the schema containing the specified object.  For non-schema objects,
 * this function returns InvalidOid.
 */
Oid
get_object_namespace(const ObjectAddress *address)
{
    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;
}
 
/*
 * Return ObjectType for the given object type as given by
 * getObjectTypeDescription; if no valid ObjectType code exists, but it's a
 * possible output type from getObjectTypeDescription, return -1.
 * Otherwise, an error is thrown.
 */
int
read_objtype_from_string(const char *objtype)
{
    int         i;
 
    for (i = 0; i < lengthof(ObjectTypeMap); i++)
    {
        if (strcmp(ObjectTypeMap[i].tm_name, objtype) == 0)
            return ObjectTypeMap[i].tm_type;
    }
    ereport(ERROR,
            (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
             errmsg("unrecognized object type \"%s\"", objtype)));
 
    return -1;                  /* keep compiler quiet */
}
 
/*
 * Interfaces to reference fields of ObjectPropertyType
 */
const char *
get_object_class_descr(Oid class_id)
{
    const ObjectPropertyType *prop = get_object_property_data(class_id);
 
    return prop->class_descr;
}
 
Oid
get_object_oid_index(Oid class_id)
{
    const ObjectPropertyType *prop = get_object_property_data(class_id);
 
    return prop->oid_index_oid;
}
 
SysCacheIdentifier
get_object_catcache_oid(Oid class_id)
{
    const ObjectPropertyType *prop = get_object_property_data(class_id);
 
    return prop->oid_catcache_id;
}
 
SysCacheIdentifier
get_object_catcache_name(Oid class_id)
{
    const ObjectPropertyType *prop = get_object_property_data(class_id);
 
    return prop->name_catcache_id;
}
 
AttrNumber
get_object_attnum_oid(Oid class_id)
{
    const ObjectPropertyType *prop = get_object_property_data(class_id);
 
    return prop->attnum_oid;
}
 
AttrNumber
get_object_attnum_name(Oid class_id)
{
    const ObjectPropertyType *prop = get_object_property_data(class_id);
 
    return prop->attnum_name;
}
 
AttrNumber
get_object_attnum_namespace(Oid class_id)
{
    const ObjectPropertyType *prop = get_object_property_data(class_id);
 
    return prop->attnum_namespace;
}
 
AttrNumber
get_object_attnum_owner(Oid class_id)
{
    const ObjectPropertyType *prop = get_object_property_data(class_id);
 
    return prop->attnum_owner;
}
 
AttrNumber
get_object_attnum_acl(Oid class_id)
{
    const ObjectPropertyType *prop = get_object_property_data(class_id);
 
    return prop->attnum_acl;
}
 
/*
 * get_object_type
 *
 * Return the object type associated with a given object.  This routine
 * is primarily used to determine the object type to mention in ACL check
 * error messages, so it's desirable for it to avoid failing.
 */
ObjectType
get_object_type(Oid class_id, Oid object_id)
{
    const ObjectPropertyType *prop = get_object_property_data(class_id);
 
    if (prop->objtype == OBJECT_TABLE)
    {
        /*
         * If the property data says it's a table, dig a little deeper to get
         * the real relation kind, so that callers can produce more precise
         * error messages.
         */
        return get_relkind_objtype(get_rel_relkind(object_id));
    }
    else
        return prop->objtype;
}
 
bool
get_object_namensp_unique(Oid class_id)
{
    const ObjectPropertyType *prop = get_object_property_data(class_id);
 
    return prop->is_nsp_name_unique;
}
 
/*
 * Return whether we have useful data for the given object class in the
 * ObjectProperty table.
 */
bool
is_objectclass_supported(Oid class_id)
{
    int         index;
 
    for (index = 0; index < lengthof(ObjectProperty); index++)
    {
        if (ObjectProperty[index].class_oid == class_id)
            return true;
    }
 
    return false;
}
 
/*
 * Find ObjectProperty structure by class_id.
 */
static const ObjectPropertyType *
get_object_property_data(Oid class_id)
{
    static const ObjectPropertyType *prop_last = NULL;
    int         index;
 
    /*
     * A shortcut to speed up multiple consecutive lookups of a particular
     * object class.
     */
    if (prop_last && prop_last->class_oid == class_id)
        return prop_last;
 
    for (index = 0; index < lengthof(ObjectProperty); index++)
    {
        if (ObjectProperty[index].class_oid == class_id)
        {
            prop_last = &ObjectProperty[index];
            return &ObjectProperty[index];
        }
    }
 
    ereport(ERROR,
            (errmsg_internal("unrecognized class ID: %u", class_id)));
 
    return NULL;                /* keep MSC compiler happy */
}
 
/*
 * Return a copy of the tuple for the object with the given object OID, from
 * the given catalog (which must have been opened by the caller and suitably
 * locked).  NULL is returned if the OID is not found.
 *
 * We try a syscache first, if available.
 */
HeapTuple
get_catalog_object_by_oid(Relation catalog, AttrNumber oidcol, Oid objectId)
{
    return
        get_catalog_object_by_oid_extended(catalog, oidcol, objectId, false);
}
 
/*
 * Same as get_catalog_object_by_oid(), but with an additional "locktup"
 * argument controlling whether to acquire a LOCKTAG_TUPLE at mode
 * InplaceUpdateTupleLock.  See README.tuplock section "Locking to write
 * inplace-updated tables".
 */
HeapTuple
get_catalog_object_by_oid_extended(Relation catalog,
                                   AttrNumber oidcol,
                                   Oid objectId,
                                   bool locktup)
{
    HeapTuple   tuple;
    Oid         classId = RelationGetRelid(catalog);
    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;
}
 
/*
 * getPublicationSchemaInfo
 *
 * Get publication name and schema name from the object address into pubname and
 * nspname. Both pubname and nspname are palloc'd strings which will be freed by
 * the caller.
 */
static bool
getPublicationSchemaInfo(const ObjectAddress *object, bool missing_ok,
                         char **pubname, char **nspname)
{
    HeapTuple   tup;
    Form_pg_publication_namespace pnform;
 
    tup = SearchSysCache1(PUBLICATIONNAMESPACE,
                          ObjectIdGetDatum(object->objectId));
    if (!HeapTupleIsValid(tup))
    {
        if (!missing_ok)
            elog(ERROR, "cache lookup failed for publication schema %u",
                 object->objectId);
        return false;
    }
 
    pnform = (Form_pg_publication_namespace) GETSTRUCT(tup);
    *pubname = get_publication_name(pnform->pnpubid, missing_ok);
    if (!(*pubname))
    {
        ReleaseSysCache(tup);
        return false;
    }
 
    *nspname = get_namespace_name(pnform->pnnspid);
    if (!(*nspname))
    {
        Oid         schemaid = pnform->pnnspid;
 
        pfree(*pubname);
        ReleaseSysCache(tup);
        if (!missing_ok)
            elog(ERROR, "cache lookup failed for schema %u",
                 schemaid);
        return false;
    }
 
    ReleaseSysCache(tup);
    return true;
}
 
/*
 * getObjectDescription: build an object description for messages
 *
 * The result is a palloc'd string.  NULL is returned for an undefined
 * object if missing_ok is true, else an error is generated.
 */
char *
getObjectDescription(const ObjectAddress *object, bool missing_ok)
{
    StringInfoData buffer;
 
    initStringInfo(&buffer);
 
    switch (object->classId)
    {
        case RelationRelationId:
            if (object->objectSubId == 0)
                getRelationDescription(&buffer, object->objectId, missing_ok);
            else
            {
                /* column, not whole relation */
                StringInfoData rel;
                char       *attname = get_attname(object->objectId,
                                                  object->objectSubId,
                                                  missing_ok);
 
                if (!attname)
                    break;
 
                initStringInfo(&rel);
                getRelationDescription(&rel, object->objectId, missing_ok);
                /* translator: second %s is, e.g., "table %s" */
                appendStringInfo(&buffer, _("column %s of %s"),
                                 attname, rel.data);
                pfree(rel.data);
            }
            break;
 
        case ProcedureRelationId:
            {
                uint16      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:
            {
                uint16      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:
            {
                uint16      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;
                HeapTuple   tuple;
                Form_pg_propgraph_element_label pgelform;
                ObjectAddress oa;
 
                rel = table_open(PropgraphElementLabelRelationId, AccessShareLock);
                tuple = get_catalog_object_by_oid(rel,
                                                  Anum_pg_propgraph_element_label_oid,
                                                  object->objectId);
                if (!HeapTupleIsValid(tuple))
                {
                    if (!missing_ok)
                        elog(ERROR, "could not find tuple for element label %u", object->objectId);
 
                    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));
 
                table_close(rel, AccessShareLock);
                break;
            }
 
        case PropgraphLabelRelationId:
            {
                HeapTuple   tuple;
                Form_pg_propgraph_label pglform;
 
                tuple = SearchSysCache1(PROPGRAPHLABELOID, ObjectIdGetDatum(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;
                HeapTuple   tuple;
                Form_pg_propgraph_label_property plpform;
                ObjectAddress oa;
 
                rel = table_open(PropgraphLabelPropertyRelationId, AccessShareLock);
                tuple = get_catalog_object_by_oid(rel,
                                                  Anum_pg_propgraph_label_property_oid,
                                                  object->objectId);
                if (!HeapTupleIsValid(tuple))
                {
                    if (!missing_ok)
                        elog(ERROR, "could not find tuple for label property %u", object->objectId);
 
                    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));
 
                table_close(rel, AccessShareLock);
                break;
            }
 
        case PropgraphPropertyRelationId:
            {
                HeapTuple   tuple;
                Form_pg_propgraph_property pgpform;
 
                tuple = SearchSysCache1(PROPGRAPHPROPOID, ObjectIdGetDatum(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;
}
 
/*
 * getObjectDescriptionOids: as above, except the object is specified by Oids
 */
char *
getObjectDescriptionOids(Oid classid, Oid objid)
{
    ObjectAddress address;
 
    address.classId = classid;
    address.objectId = objid;
    address.objectSubId = 0;
 
    return getObjectDescription(&address, false);
}
 
/*
 * subroutine for getObjectDescription: describe a relation
 *
 * The result is appended to "buffer".
 */
static void
getRelationDescription(StringInfo buffer, Oid relid, bool missing_ok)
{
    HeapTuple   relTup;
    Form_pg_class relForm;
    char       *nspname;
    char       *relname;
 
    relTup = SearchSysCache1(RELOID,
                             ObjectIdGetDatum(relid));
    if (!HeapTupleIsValid(relTup))
    {
        if (!missing_ok)
            elog(ERROR, "cache lookup failed for relation %u", relid);
        return;
    }
    relForm = (Form_pg_class) GETSTRUCT(relTup);
 
    /* Qualify the name if not visible in search path */
    if (RelationIsVisible(relid))
        nspname = NULL;
    else
        nspname = get_namespace_name(relForm->relnamespace);
 
    relname = quote_qualified_identifier(nspname, NameStr(relForm->relname));
 
    switch (relForm->relkind)
    {
        case RELKIND_RELATION:
        case RELKIND_PARTITIONED_TABLE:
            appendStringInfo(buffer, _("table %s"),
                             relname);
            break;
        case RELKIND_INDEX:
        case RELKIND_PARTITIONED_INDEX:
            appendStringInfo(buffer, _("index %s"),
                             relname);
            break;
        case RELKIND_SEQUENCE:
            appendStringInfo(buffer, _("sequence %s"),
                             relname);
            break;
        case RELKIND_TOASTVALUE:
            appendStringInfo(buffer, _("toast table %s"),
                             relname);
            break;
        case RELKIND_VIEW:
            appendStringInfo(buffer, _("view %s"),
                             relname);
            break;
        case RELKIND_MATVIEW:
            appendStringInfo(buffer, _("materialized view %s"),
                             relname);
            break;
        case RELKIND_COMPOSITE_TYPE:
            appendStringInfo(buffer, _("composite type %s"),
                             relname);
            break;
        case RELKIND_FOREIGN_TABLE:
            appendStringInfo(buffer, _("foreign table %s"),
                             relname);
            break;
        case RELKIND_PROPGRAPH:
            appendStringInfo(buffer, _("property graph %s"),
                             relname);
            break;
        default:
            /* shouldn't get here */
            appendStringInfo(buffer, _("relation %s"),
                             relname);
            break;
    }
 
    ReleaseSysCache(relTup);
}
 
/*
 * subroutine for getObjectDescription: describe an operator family
 */
static void
getOpFamilyDescription(StringInfo buffer, Oid opfid, bool missing_ok)
{
    HeapTuple   opfTup;
    Form_pg_opfamily opfForm;
    HeapTuple   amTup;
    Form_pg_am  amForm;
    char       *nspname;
 
    opfTup = SearchSysCache1(OPFAMILYOID, ObjectIdGetDatum(opfid));
    if (!HeapTupleIsValid(opfTup))
    {
        if (!missing_ok)
            elog(ERROR, "cache lookup failed for opfamily %u", opfid);
        return;
    }
    opfForm = (Form_pg_opfamily) GETSTRUCT(opfTup);
 
    amTup = SearchSysCache1(AMOID, ObjectIdGetDatum(opfForm->opfmethod));
    if (!HeapTupleIsValid(amTup))
        elog(ERROR, "cache lookup failed for access method %u",
             opfForm->opfmethod);
    amForm = (Form_pg_am) GETSTRUCT(amTup);
 
    /* Qualify the name if not visible in search path */
    if (OpfamilyIsVisible(opfid))
        nspname = NULL;
    else
        nspname = get_namespace_name(opfForm->opfnamespace);
 
    appendStringInfo(buffer, _("operator family %s for access method %s"),
                     quote_qualified_identifier(nspname,
                                                NameStr(opfForm->opfname)),
                     NameStr(amForm->amname));
 
    ReleaseSysCache(amTup);
    ReleaseSysCache(opfTup);
}
 
/*
 * SQL-level callable version of getObjectDescription
 */
Datum
pg_describe_object(PG_FUNCTION_ARGS)
{
    Oid         classid = PG_GETARG_OID(0);
    Oid         objid = PG_GETARG_OID(1);
    int32       objsubid = PG_GETARG_INT32(2);
    char       *description;
    ObjectAddress address;
 
    /* for "pinned" items in pg_depend, return null */
    if (!OidIsValid(classid) && !OidIsValid(objid))
        PG_RETURN_NULL();
 
    address.classId = classid;
    address.objectId = objid;
    address.objectSubId = objsubid;
 
    description = getObjectDescription(&address, true);
 
    if (description == NULL)
        PG_RETURN_NULL();
 
    PG_RETURN_TEXT_P(cstring_to_text(description));
}
 
/*
 * SQL-level callable function to obtain object type + identity
 */
Datum
pg_identify_object(PG_FUNCTION_ARGS)
{
    Oid         classid = PG_GETARG_OID(0);
    Oid         objid = PG_GETARG_OID(1);
    int32       objsubid = PG_GETARG_INT32(2);
    Oid         schema_oid = InvalidOid;
    const char *objname = NULL;
    char       *objidentity;
    ObjectAddress address;
    Datum       values[4];
    bool        nulls[4];
    TupleDesc   tupdesc;
    HeapTuple   htup;
 
    address.classId = classid;
    address.objectId = objid;
    address.objectSubId = objsubid;
 
    if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
        elog(ERROR, "return type must be a row type");
 
    if (is_objectclass_supported(address.classId))
    {
        HeapTuple   objtup;
        Relation    catalog = table_open(address.classId, AccessShareLock);
 
        objtup = get_catalog_object_by_oid(catalog,
                                           get_object_attnum_oid(address.classId),
                                           address.objectId);
        if (objtup != NULL)
        {
            bool        isnull;
            AttrNumber  nspAttnum;
            AttrNumber  nameAttnum;
 
            nspAttnum = get_object_attnum_namespace(address.classId);
            if (nspAttnum != InvalidAttrNumber)
            {
                schema_oid = 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));
}
 
/*
 * SQL-level callable function to obtain object type + identity
 */
Datum
pg_identify_object_as_address(PG_FUNCTION_ARGS)
{
    Oid         classid = PG_GETARG_OID(0);
    Oid         objid = PG_GETARG_OID(1);
    int32       objsubid = PG_GETARG_INT32(2);
    ObjectAddress address;
    char       *identity;
    List       *names;
    List       *args;
    Datum       values[3];
    bool        nulls[3];
    TupleDesc   tupdesc;
    HeapTuple   htup;
 
    address.classId = classid;
    address.objectId = objid;
    address.objectSubId = objsubid;
 
    if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
        elog(ERROR, "return type must be a row type");
 
    /* object type, which can never be NULL */
    values[0] = CStringGetTextDatum(getObjectTypeDescription(&address, true));
    nulls[0] = false;
 
    /* object identity */
    identity = getObjectIdentityParts(&address, &names, &args, true);
    if (identity == NULL)
    {
        nulls[1] = true;
        nulls[2] = true;
    }
    else
    {
        pfree(identity);
 
        /* object_names */
        if (names != NIL)
            values[1] = PointerGetDatum(strlist_to_textarray(names));
        else
            values[1] = PointerGetDatum(construct_empty_array(TEXTOID));
        nulls[1] = false;
 
        /* object_args */
        if (args)
            values[2] = PointerGetDatum(strlist_to_textarray(args));
        else
            values[2] = PointerGetDatum(construct_empty_array(TEXTOID));
        nulls[2] = false;
    }
 
    htup = heap_form_tuple(tupdesc, values, nulls);
 
    PG_RETURN_DATUM(HeapTupleGetDatum(htup));
}
 
/*
 * SQL-level callable function to obtain the ACL of a specified object, given
 * its catalog OID, object OID and sub-object ID.
 */
Datum
pg_get_acl(PG_FUNCTION_ARGS)
{
    Oid         classId = PG_GETARG_OID(0);
    Oid         objectId = PG_GETARG_OID(1);
    int32       objsubid = PG_GETARG_INT32(2);
    Oid         catalogId;
    AttrNumber  Anum_acl;
    Datum       datum;
    bool        isnull;
    HeapTuple   tup;
 
    /* for "pinned" items in pg_depend, return null */
    if (!OidIsValid(classId) && !OidIsValid(objectId))
        PG_RETURN_NULL();
 
    /* for large objects, the catalog to look at is pg_largeobject_metadata */
    catalogId = (classId == LargeObjectRelationId) ?
        LargeObjectMetadataRelationId : classId;
    Anum_acl = get_object_attnum_acl(catalogId);
 
    /* return NULL if no ACL field for this catalog */
    if (Anum_acl == InvalidAttrNumber)
        PG_RETURN_NULL();
 
    /*
     * If dealing with a relation's attribute (objsubid is set), the ACL is
     * retrieved from pg_attribute.
     */
    if (classId == RelationRelationId && objsubid != 0)
    {
        AttrNumber  attnum = (AttrNumber) objsubid;
 
        tup = SearchSysCacheCopyAttNum(objectId, attnum);
 
        if (!HeapTupleIsValid(tup))
            PG_RETURN_NULL();
 
        datum = SysCacheGetAttr(ATTNUM, tup, Anum_pg_attribute_attacl,
                                &isnull);
    }
    else
    {
        Relation    rel;
 
        rel = table_open(catalogId, AccessShareLock);
 
        tup = get_catalog_object_by_oid(rel, get_object_attnum_oid(catalogId),
                                        objectId);
        if (!HeapTupleIsValid(tup))
        {
            table_close(rel, AccessShareLock);
            PG_RETURN_NULL();
        }
 
        datum = heap_getattr(tup, Anum_acl, RelationGetDescr(rel), &isnull);
        table_close(rel, AccessShareLock);
    }
 
    if (isnull)
        PG_RETURN_NULL();
 
    PG_RETURN_DATUM(datum);
}
 
/*
 * Return a palloc'ed string that describes the type of object that the
 * passed address is for.
 *
 * Keep ObjectTypeMap in sync with this.
 */
char *
getObjectTypeDescription(const ObjectAddress *object, bool missing_ok)
{
    StringInfoData buffer;
 
    initStringInfo(&buffer);
 
    switch (object->classId)
    {
        case RelationRelationId:
            getRelationTypeDescription(&buffer, object->objectId,
                                       object->objectSubId,
                                       missing_ok);
            break;
 
        case ProcedureRelationId:
            getProcedureTypeDescription(&buffer, object->objectId,
                                        missing_ok);
            break;
 
        case TypeRelationId:
            appendStringInfoString(&buffer, "type");
            break;
 
        case CastRelationId:
            appendStringInfoString(&buffer, "cast");
            break;
 
        case CollationRelationId:
            appendStringInfoString(&buffer, "collation");
            break;
 
        case ConstraintRelationId:
            getConstraintTypeDescription(&buffer, object->objectId,
                                         missing_ok);
            break;
 
        case ConversionRelationId:
            appendStringInfoString(&buffer, "conversion");
            break;
 
        case AttrDefaultRelationId:
            appendStringInfoString(&buffer, "default value");
            break;
 
        case LanguageRelationId:
            appendStringInfoString(&buffer, "language");
            break;
 
        case LargeObjectRelationId:
            appendStringInfoString(&buffer, "large object");
            break;
 
        case OperatorRelationId:
            appendStringInfoString(&buffer, "operator");
            break;
 
        case OperatorClassRelationId:
            appendStringInfoString(&buffer, "operator class");
            break;
 
        case OperatorFamilyRelationId:
            appendStringInfoString(&buffer, "operator family");
            break;
 
        case AccessMethodRelationId:
            appendStringInfoString(&buffer, "access method");
            break;
 
        case AccessMethodOperatorRelationId:
            appendStringInfoString(&buffer, "operator of access method");
            break;
 
        case AccessMethodProcedureRelationId:
            appendStringInfoString(&buffer, "function of access method");
            break;
 
        case RewriteRelationId:
            appendStringInfoString(&buffer, "rule");
            break;
 
        case TriggerRelationId:
            appendStringInfoString(&buffer, "trigger");
            break;
 
        case NamespaceRelationId:
            appendStringInfoString(&buffer, "schema");
            break;
 
        case StatisticExtRelationId:
            appendStringInfoString(&buffer, "statistics object");
            break;
 
        case TSParserRelationId:
            appendStringInfoString(&buffer, "text search parser");
            break;
 
        case TSDictionaryRelationId:
            appendStringInfoString(&buffer, "text search dictionary");
            break;
 
        case TSTemplateRelationId:
            appendStringInfoString(&buffer, "text search template");
            break;
 
        case TSConfigRelationId:
            appendStringInfoString(&buffer, "text search configuration");
            break;
 
        case AuthIdRelationId:
            appendStringInfoString(&buffer, "role");
            break;
 
        case AuthMemRelationId:
            appendStringInfoString(&buffer, "role membership");
            break;
 
        case DatabaseRelationId:
            appendStringInfoString(&buffer, "database");
            break;
 
        case TableSpaceRelationId:
            appendStringInfoString(&buffer, "tablespace");
            break;
 
        case ForeignDataWrapperRelationId:
            appendStringInfoString(&buffer, "foreign-data wrapper");
            break;
 
        case ForeignServerRelationId:
            appendStringInfoString(&buffer, "server");
            break;
 
        case UserMappingRelationId:
            appendStringInfoString(&buffer, "user mapping");
            break;
 
        case DefaultAclRelationId:
            appendStringInfoString(&buffer, "default acl");
            break;
 
        case ExtensionRelationId:
            appendStringInfoString(&buffer, "extension");
            break;
 
        case EventTriggerRelationId:
            appendStringInfoString(&buffer, "event trigger");
            break;
 
        case ParameterAclRelationId:
            appendStringInfoString(&buffer, "parameter ACL");
            break;
 
        case PolicyRelationId:
            appendStringInfoString(&buffer, "policy");
            break;
 
        case PropgraphElementRelationId:
            appendStringInfoString(&buffer, "property graph element");
            break;
 
        case PropgraphLabelRelationId:
            appendStringInfoString(&buffer, "property graph label");
            break;
 
        case PropgraphPropertyRelationId:
            appendStringInfoString(&buffer, "property graph property");
            break;
 
        case PropgraphElementLabelRelationId:
            appendStringInfoString(&buffer, "property graph element label");
            break;
 
        case PropgraphLabelPropertyRelationId:
            appendStringInfoString(&buffer, "property graph label 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;
}
 
/*
 * subroutine for getObjectTypeDescription: describe a relation type
 */
static void
getRelationTypeDescription(StringInfo buffer, Oid relid, int32 objectSubId,
                           bool missing_ok)
{
    HeapTuple   relTup;
    Form_pg_class relForm;
 
    relTup = SearchSysCache1(RELOID,
                             ObjectIdGetDatum(relid));
    if (!HeapTupleIsValid(relTup))
    {
        if (!missing_ok)
            elog(ERROR, "cache lookup failed for relation %u", relid);
 
        /* fallback to "relation" for an undefined object */
        appendStringInfoString(buffer, "relation");
        return;
    }
    relForm = (Form_pg_class) GETSTRUCT(relTup);
 
    switch (relForm->relkind)
    {
        case RELKIND_RELATION:
        case RELKIND_PARTITIONED_TABLE:
            appendStringInfoString(buffer, "table");
            break;
        case RELKIND_INDEX:
        case RELKIND_PARTITIONED_INDEX:
            appendStringInfoString(buffer, "index");
            break;
        case RELKIND_SEQUENCE:
            appendStringInfoString(buffer, "sequence");
            break;
        case RELKIND_TOASTVALUE:
            appendStringInfoString(buffer, "toast table");
            break;
        case RELKIND_VIEW:
            appendStringInfoString(buffer, "view");
            break;
        case RELKIND_MATVIEW:
            appendStringInfoString(buffer, "materialized view");
            break;
        case RELKIND_COMPOSITE_TYPE:
            appendStringInfoString(buffer, "composite type");
            break;
        case RELKIND_FOREIGN_TABLE:
            appendStringInfoString(buffer, "foreign table");
            break;
        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);
}
 
/*
 * subroutine for getObjectTypeDescription: describe a constraint type
 */
static void
getConstraintTypeDescription(StringInfo buffer, Oid constroid, bool missing_ok)
{
    Relation    constrRel;
    HeapTuple   constrTup;
    Form_pg_constraint constrForm;
 
    constrRel = table_open(ConstraintRelationId, AccessShareLock);
    constrTup = get_catalog_object_by_oid(constrRel, Anum_pg_constraint_oid,
                                          constroid);
    if (!HeapTupleIsValid(constrTup))
    {
        if (!missing_ok)
            elog(ERROR, "cache lookup failed for constraint %u", constroid);
 
        table_close(constrRel, AccessShareLock);
 
        /* fallback to "constraint" for an undefined object */
        appendStringInfoString(buffer, "constraint");
        return;
    }
 
    constrForm = (Form_pg_constraint) GETSTRUCT(constrTup);
 
    if (OidIsValid(constrForm->conrelid))
        appendStringInfoString(buffer, "table constraint");
    else if (OidIsValid(constrForm->contypid))
        appendStringInfoString(buffer, "domain constraint");
    else
        elog(ERROR, "invalid constraint %u", constrForm->oid);
 
    table_close(constrRel, AccessShareLock);
}
 
/*
 * subroutine for getObjectTypeDescription: describe a procedure type
 */
static void
getProcedureTypeDescription(StringInfo buffer, Oid procid,
                            bool missing_ok)
{
    HeapTuple   procTup;
    Form_pg_proc procForm;
 
    procTup = SearchSysCache1(PROCOID,
                              ObjectIdGetDatum(procid));
    if (!HeapTupleIsValid(procTup))
    {
        if (!missing_ok)
            elog(ERROR, "cache lookup failed for procedure %u", procid);
 
        /* fallback to "procedure" for an undefined object */
        appendStringInfoString(buffer, "routine");
        return;
    }
    procForm = (Form_pg_proc) GETSTRUCT(procTup);
 
    if (procForm->prokind == PROKIND_AGGREGATE)
        appendStringInfoString(buffer, "aggregate");
    else if (procForm->prokind == PROKIND_PROCEDURE)
        appendStringInfoString(buffer, "procedure");
    else                        /* function or window function */
        appendStringInfoString(buffer, "function");
 
    ReleaseSysCache(procTup);
}
 
/*
 * Obtain a given object's identity, as a palloc'ed string.
 *
 * This is for machine consumption, so it's not translated.  All elements are
 * schema-qualified when appropriate.  Returns NULL if the object could not
 * be found.
 */
char *
getObjectIdentity(const ObjectAddress *object, bool missing_ok)
{
    return getObjectIdentityParts(object, NULL, NULL, missing_ok);
}
 
/*
 * As above, but more detailed.
 *
 * There are two sets of return values: the identity itself as a palloc'd
 * string is returned.  objname and objargs, if not NULL, are output parameters
 * that receive lists of C-strings that are useful to give back to
 * get_object_address() to reconstruct the ObjectAddress.  Returns NULL if
 * the object could not be found.
 */
char *
getObjectIdentityParts(const ObjectAddress *object,
                       List **objname, List **objargs,
                       bool missing_ok)
{
    StringInfoData buffer;
 
    initStringInfo(&buffer);
 
    /*
     * Make sure that both objname and objargs were passed, or none was; and
     * initialize them to empty lists.  For objname this is useless because it
     * will be initialized in all cases inside the switch; but we do it anyway
     * so that we can test below that no branch leaves it unset.
     */
    Assert((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:
            {
                uint16      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:
            {
                uint16      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:
            {
                uint16      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, ObjectIdGetDatum(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, ObjectIdGetDatum(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, ObjectIdGetDatum(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 PropgraphElementLabelRelationId:
            {
                Relation    ellabelDesc;
                HeapTuple   tup;
                Form_pg_propgraph_element_label pgelform;
                ObjectAddress oa;
                char       *labelname;
 
                ellabelDesc = table_open(PropgraphElementLabelRelationId, AccessShareLock);
                tup = get_catalog_object_by_oid(ellabelDesc,
                                                Anum_pg_propgraph_element_label_oid,
                                                object->objectId);
                if (!HeapTupleIsValid(tup))
                {
                    if (!missing_ok)
                        elog(ERROR, "could not find tuple for element label %u",
                             object->objectId);
 
                    table_close(ellabelDesc, AccessShareLock);
                    break;
                }
 
                pgelform = (Form_pg_propgraph_element_label) GETSTRUCT(tup);
 
                labelname = get_propgraph_label_name(pgelform->pgellabelid);
                appendStringInfo(&buffer, "%s of ", quote_identifier(labelname));
                ObjectAddressSet(oa, PropgraphElementRelationId, pgelform->pgelelid);
                appendStringInfoString(&buffer, getObjectIdentityParts(&oa, objname,
                                                                       objargs, false));
                /* labelname is already pstrdup'ed. */
                if (objname)
                    *objname = lappend(*objname, labelname);
 
                table_close(ellabelDesc, AccessShareLock);
                break;
            }
 
        case PropgraphLabelPropertyRelationId:
            {
                Relation    lblpropDesc;
                HeapTuple   tup;
                Form_pg_propgraph_label_property plpform;
                ObjectAddress oa;
                char       *propname;
 
                lblpropDesc = table_open(PropgraphLabelPropertyRelationId,
                                         AccessShareLock);
                tup = get_catalog_object_by_oid(lblpropDesc,
                                                Anum_pg_propgraph_label_property_oid,
                                                object->objectId);
                if (!HeapTupleIsValid(tup))
                {
                    if (!missing_ok)
                        elog(ERROR, "could not find tuple for label property %u",
                             object->objectId);
 
                    table_close(lblpropDesc, AccessShareLock);
                    break;
                }
 
                plpform = (Form_pg_propgraph_label_property) GETSTRUCT(tup);
 
                propname = get_propgraph_property_name(plpform->plppropid);
                appendStringInfo(&buffer, "%s of ", quote_identifier(propname));
                ObjectAddressSet(oa, PropgraphElementLabelRelationId, plpform->plpellabelid);
                appendStringInfoString(&buffer, getObjectIdentityParts(&oa, objname,
                                                                       objargs, false));
                /* propname is already pstrdup'ed. */
                if (objname)
                    *objname = lappend(*objname, propname);
 
                table_close(lblpropDesc, AccessShareLock);
                break;
            }
 
        case PublicationRelationId:
            {
                char       *pubname;
 
                pubname = get_publication_name(object->objectId, missing_ok);
                if (pubname)
                {
                    appendStringInfoString(&buffer,
                                           quote_identifier(pubname));
                    if (objname)
                        *objname = list_make1(pubname);
                }
                break;
            }
 
        case PublicationNamespaceRelationId:
            {
                char       *pubname;
                char       *nspname;
 
                if (!getPublicationSchemaInfo(object, missing_ok, &pubname,
                                              &nspname))
                    break;
                appendStringInfo(&buffer, "%s in publication %s",
                                 nspname, pubname);
 
                if (objargs)
                    *objargs = list_make1(pubname);
                else
                    pfree(pubname);
 
                if (objname)
                    *objname = list_make1(nspname);
                else
                    pfree(nspname);
 
                break;
            }
 
        case PublicationRelRelationId:
            {
                HeapTuple   tup;
                char       *pubname;
                Form_pg_publication_rel prform;
 
                tup = SearchSysCache1(PUBLICATIONREL,
                                      ObjectIdGetDatum(object->objectId));
                if (!HeapTupleIsValid(tup))
                {
                    if (!missing_ok)
                        elog(ERROR, "cache lookup failed for publication table %u",
                             object->objectId);
                    break;
                }
 
                prform = (Form_pg_publication_rel) GETSTRUCT(tup);
                pubname = get_publication_name(prform->prpubid, false);
 
                getRelationIdentity(&buffer, prform->prrelid, objname, false);
                appendStringInfo(&buffer, " in publication %s", pubname);
 
                if (objargs)
                    *objargs = list_make1(pubname);
 
                ReleaseSysCache(tup);
                break;
            }
 
        case SubscriptionRelationId:
            {
                char       *subname;
 
                subname = get_subscription_name(object->objectId, missing_ok);
                if (subname)
                {
                    appendStringInfoString(&buffer,
                                           quote_identifier(subname));
                    if (objname)
                        *objname = list_make1(subname);
                }
                break;
            }
 
        case TransformRelationId:
            {
                Relation    transformDesc;
                HeapTuple   tup;
                Form_pg_transform transform;
                char       *transformLang;
                char       *transformType;
 
                transformDesc = table_open(TransformRelationId, AccessShareLock);
 
                tup = get_catalog_object_by_oid(transformDesc,
                                                Anum_pg_transform_oid,
                                                object->objectId);
 
                if (!HeapTupleIsValid(tup))
                {
                    if (!missing_ok)
                        elog(ERROR, "could not find tuple for transform %u",
                             object->objectId);
 
                    table_close(transformDesc, AccessShareLock);
                    break;
                }
 
                transform = (Form_pg_transform) GETSTRUCT(tup);
 
                transformType = format_type_be_qualified(transform->trftype);
                transformLang = get_language_name(transform->trflang, false);
 
                appendStringInfo(&buffer, "for %s language %s",
                                 transformType,
                                 transformLang);
                if (objname)
                {
                    *objname = list_make1(transformType);
                    *objargs = list_make1(pstrdup(transformLang));
                }
 
                table_close(transformDesc, AccessShareLock);
            }
            break;
 
        default:
            elog(ERROR, "unsupported object class: %u", object->classId);
    }
 
    if (!missing_ok)
    {
        /*
         * If a get_object_address() representation was requested, make sure
         * we are providing one.  We don't check objargs, because many of the
         * cases above leave it as NIL.
         */
        if (objname && *objname == NIL)
            elog(ERROR, "requested object address for unsupported object class %u: text result \"%s\"",
                 object->classId, buffer.data);
    }
    else
    {
        /* an empty buffer is equivalent to no object found */
        if (buffer.len == 0)
        {
            Assert((objname == NULL || *objname == NIL) &&
                   (objargs == NULL || *objargs == NIL));
            return NULL;
        }
    }
 
    return buffer.data;
}
 
static void
getOpFamilyIdentity(StringInfo buffer, Oid opfid, List **object,
                    bool missing_ok)
{
    HeapTuple   opfTup;
    Form_pg_opfamily opfForm;
    HeapTuple   amTup;
    Form_pg_am  amForm;
    char       *schema;
 
    opfTup = SearchSysCache1(OPFAMILYOID, ObjectIdGetDatum(opfid));
    if (!HeapTupleIsValid(opfTup))
    {
        if (!missing_ok)
            elog(ERROR, "cache lookup failed for opfamily %u", opfid);
        return;
    }
    opfForm = (Form_pg_opfamily) GETSTRUCT(opfTup);
 
    amTup = SearchSysCache1(AMOID, ObjectIdGetDatum(opfForm->opfmethod));
    if (!HeapTupleIsValid(amTup))
        elog(ERROR, "cache lookup failed for access method %u",
             opfForm->opfmethod);
    amForm = (Form_pg_am) GETSTRUCT(amTup);
 
    schema = get_namespace_name_or_temp(opfForm->opfnamespace);
    appendStringInfo(buffer, "%s USING %s",
                     quote_qualified_identifier(schema,
                                                NameStr(opfForm->opfname)),
                     NameStr(amForm->amname));
 
    if (object)
        *object = list_make3(pstrdup(NameStr(amForm->amname)),
                             pstrdup(schema),
                             pstrdup(NameStr(opfForm->opfname)));
 
    ReleaseSysCache(amTup);
    ReleaseSysCache(opfTup);
}
 
/*
 * Append the relation identity (quoted qualified name) to the given
 * StringInfo.
 */
static void
getRelationIdentity(StringInfo buffer, Oid relid, List **object,
                    bool missing_ok)
{
    HeapTuple   relTup;
    Form_pg_class relForm;
    char       *schema;
 
    relTup = SearchSysCache1(RELOID,
                             ObjectIdGetDatum(relid));
    if (!HeapTupleIsValid(relTup))
    {
        if (!missing_ok)
            elog(ERROR, "cache lookup failed for relation %u", relid);
 
        if (object)
            *object = NIL;
        return;
    }
    relForm = (Form_pg_class) GETSTRUCT(relTup);
 
    schema = get_namespace_name_or_temp(relForm->relnamespace);
    appendStringInfoString(buffer,
                           quote_qualified_identifier(schema,
                                                      NameStr(relForm->relname)));
    if (object)
        *object = list_make2(schema, pstrdup(NameStr(relForm->relname)));
 
    ReleaseSysCache(relTup);
}
 
/*
 * Auxiliary function to build a TEXT array out of a list of C-strings.
 */
ArrayType *
strlist_to_textarray(List *list)
{
    ArrayType  *arr;
    Datum      *datums;
    bool       *nulls;
    int         j = 0;
    ListCell   *cell;
    MemoryContext memcxt;
    MemoryContext oldcxt;
    int         lb[1];
 
    /* Work in a temp context; easier than individually pfree'ing the Datums */
    memcxt = AllocSetContextCreate(CurrentMemoryContext,
                                   "strlist to array",
                                   ALLOCSET_DEFAULT_SIZES);
    oldcxt = MemoryContextSwitchTo(memcxt);
 
    datums = 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;
}
 
/*
 * get_relkind_objtype
 *
 * Return the object type for the relkind given by the caller.
 *
 * If an unexpected relkind is passed, we say OBJECT_TABLE rather than
 * failing.  That's because this is mostly used for generating error messages
 * for failed ACL checks on relations, and we'd rather produce a generic
 * message saying "table" than fail entirely.
 */
ObjectType
get_relkind_objtype(char relkind)
{
    switch (relkind)
    {
        case RELKIND_RELATION:
        case RELKIND_PARTITIONED_TABLE:
            return OBJECT_TABLE;
        case RELKIND_INDEX:
        case RELKIND_PARTITIONED_INDEX:
            return OBJECT_INDEX;
        case RELKIND_SEQUENCE:
            return OBJECT_SEQUENCE;
        case RELKIND_VIEW:
            return OBJECT_VIEW;
        case RELKIND_MATVIEW:
            return OBJECT_MATVIEW;
        case RELKIND_FOREIGN_TABLE:
            return OBJECT_FOREIGN_TABLE;
        case RELKIND_PROPGRAPH:
            return OBJECT_PROPGRAPH;
        case RELKIND_TOASTVALUE:
            return OBJECT_TABLE;
        default:
            /* Per above, don't raise an error */
            return OBJECT_TABLE;
    }
}