if (extra->flags & DEPFLAG_REVERSE)
normal = true;
- if (EventTriggerSupportsObjectClass(getObjectClass(thisobj)))
+ if (EventTriggerSupportsObject(thisobj))
{
EventTriggerSQLDropAddObject(thisobj, original, normal);
}
static void
doDeletion(const ObjectAddress *object, int flags)
{
- switch (getObjectClass(object))
+ switch (object->classId)
{
- case OCLASS_CLASS:
+ case RelationRelationId:
{
char relKind = get_rel_relkind(object->objectId);
break;
}
- case OCLASS_PROC:
+ case ProcedureRelationId:
RemoveFunctionById(object->objectId);
break;
- case OCLASS_TYPE:
+ case TypeRelationId:
RemoveTypeById(object->objectId);
break;
- case OCLASS_CONSTRAINT:
+ case ConstraintRelationId:
RemoveConstraintById(object->objectId);
break;
- case OCLASS_DEFAULT:
+ case AttrDefaultRelationId:
RemoveAttrDefaultById(object->objectId);
break;
- case OCLASS_LARGEOBJECT:
+ case LargeObjectRelationId:
LargeObjectDrop(object->objectId);
break;
- case OCLASS_OPERATOR:
+ case OperatorRelationId:
RemoveOperatorById(object->objectId);
break;
- case OCLASS_REWRITE:
+ case RewriteRelationId:
RemoveRewriteRuleById(object->objectId);
break;
- case OCLASS_TRIGGER:
+ case TriggerRelationId:
RemoveTriggerById(object->objectId);
break;
- case OCLASS_STATISTIC_EXT:
+ case StatisticExtRelationId:
RemoveStatisticsById(object->objectId);
break;
- case OCLASS_TSCONFIG:
+ case TSConfigRelationId:
RemoveTSConfigurationById(object->objectId);
break;
- case OCLASS_EXTENSION:
+ case ExtensionRelationId:
RemoveExtensionById(object->objectId);
break;
- case OCLASS_POLICY:
+ case PolicyRelationId:
RemovePolicyById(object->objectId);
break;
- case OCLASS_PUBLICATION_NAMESPACE:
+ case PublicationNamespaceRelationId:
RemovePublicationSchemaById(object->objectId);
break;
- case OCLASS_PUBLICATION_REL:
+ case PublicationRelRelationId:
RemovePublicationRelById(object->objectId);
break;
- case OCLASS_PUBLICATION:
+ case PublicationRelationId:
RemovePublicationById(object->objectId);
break;
- case OCLASS_CAST:
- case OCLASS_COLLATION:
- case OCLASS_CONVERSION:
- case OCLASS_LANGUAGE:
- case OCLASS_OPCLASS:
- case OCLASS_OPFAMILY:
- case OCLASS_AM:
- case OCLASS_AMOP:
- case OCLASS_AMPROC:
- case OCLASS_SCHEMA:
- case OCLASS_TSPARSER:
- case OCLASS_TSDICT:
- case OCLASS_TSTEMPLATE:
- case OCLASS_FDW:
- case OCLASS_FOREIGN_SERVER:
- case OCLASS_USER_MAPPING:
- case OCLASS_DEFACL:
- case OCLASS_EVENT_TRIGGER:
- case OCLASS_TRANSFORM:
- case OCLASS_ROLE_MEMBERSHIP:
+ case CastRelationId:
+ case CollationRelationId:
+ case ConversionRelationId:
+ case LanguageRelationId:
+ case OperatorClassRelationId:
+ case OperatorFamilyRelationId:
+ case AccessMethodRelationId:
+ case AccessMethodOperatorRelationId:
+ case AccessMethodProcedureRelationId:
+ case NamespaceRelationId:
+ case TSParserRelationId:
+ case TSDictionaryRelationId:
+ case TSTemplateRelationId:
+ case ForeignDataWrapperRelationId:
+ case ForeignServerRelationId:
+ case UserMappingRelationId:
+ case DefaultAclRelationId:
+ case EventTriggerRelationId:
+ case TransformRelationId:
+ case AuthMemRelationId:
DropObjectById(object);
break;
/*
* These global object types are not supported here.
*/
- case OCLASS_ROLE:
- case OCLASS_DATABASE:
- case OCLASS_TBLSPACE:
- case OCLASS_SUBSCRIPTION:
- case OCLASS_PARAMETER_ACL:
+ case AuthIdRelationId:
+ case DatabaseRelationId:
+ case TableSpaceRelationId:
+ case SubscriptionRelationId:
+ case ParameterAclRelationId:
elog(ERROR, "global objects cannot be deleted by doDeletion");
break;
- /*
- * There's intentionally no default: case here; we want the
- * compiler to warn if a new OCLASS hasn't been handled above.
- */
+ default:
+ elog(ERROR, "unsupported object class: %u", object->classId);
}
}
pfree(addrs);
}
-/*
- * Determine the class of a given object identified by objectAddress.
- *
- * We implement it as a function instead of an array because the OIDs aren't
- * consecutive.
- */
-ObjectClass
-getObjectClass(const ObjectAddress *object)
-{
- /* only pg_class entries can have nonzero objectSubId */
- if (object->classId != RelationRelationId &&
- object->objectSubId != 0)
- elog(ERROR, "invalid non-zero objectSubId for object class %u",
- object->classId);
-
- switch (object->classId)
- {
- case RelationRelationId:
- /* caller must check objectSubId */
- return OCLASS_CLASS;
-
- case ProcedureRelationId:
- return OCLASS_PROC;
-
- case TypeRelationId:
- return OCLASS_TYPE;
-
- case CastRelationId:
- return OCLASS_CAST;
-
- case CollationRelationId:
- return OCLASS_COLLATION;
-
- case ConstraintRelationId:
- return OCLASS_CONSTRAINT;
-
- case ConversionRelationId:
- return OCLASS_CONVERSION;
-
- case AttrDefaultRelationId:
- return OCLASS_DEFAULT;
-
- case LanguageRelationId:
- return OCLASS_LANGUAGE;
-
- case LargeObjectRelationId:
- return OCLASS_LARGEOBJECT;
-
- case OperatorRelationId:
- return OCLASS_OPERATOR;
-
- case OperatorClassRelationId:
- return OCLASS_OPCLASS;
-
- case OperatorFamilyRelationId:
- return OCLASS_OPFAMILY;
-
- case AccessMethodRelationId:
- return OCLASS_AM;
-
- case AccessMethodOperatorRelationId:
- return OCLASS_AMOP;
-
- case AccessMethodProcedureRelationId:
- return OCLASS_AMPROC;
-
- case RewriteRelationId:
- return OCLASS_REWRITE;
-
- case TriggerRelationId:
- return OCLASS_TRIGGER;
-
- case NamespaceRelationId:
- return OCLASS_SCHEMA;
-
- case StatisticExtRelationId:
- return OCLASS_STATISTIC_EXT;
-
- case TSParserRelationId:
- return OCLASS_TSPARSER;
-
- case TSDictionaryRelationId:
- return OCLASS_TSDICT;
-
- case TSTemplateRelationId:
- return OCLASS_TSTEMPLATE;
-
- case TSConfigRelationId:
- return OCLASS_TSCONFIG;
-
- case AuthIdRelationId:
- return OCLASS_ROLE;
-
- case AuthMemRelationId:
- return OCLASS_ROLE_MEMBERSHIP;
-
- case DatabaseRelationId:
- return OCLASS_DATABASE;
-
- case TableSpaceRelationId:
- return OCLASS_TBLSPACE;
-
- case ForeignDataWrapperRelationId:
- return OCLASS_FDW;
-
- case ForeignServerRelationId:
- return OCLASS_FOREIGN_SERVER;
-
- case UserMappingRelationId:
- return OCLASS_USER_MAPPING;
-
- case DefaultAclRelationId:
- return OCLASS_DEFACL;
-
- case ExtensionRelationId:
- return OCLASS_EXTENSION;
-
- case EventTriggerRelationId:
- return OCLASS_EVENT_TRIGGER;
-
- case ParameterAclRelationId:
- return OCLASS_PARAMETER_ACL;
-
- case PolicyRelationId:
- return OCLASS_POLICY;
-
- case PublicationNamespaceRelationId:
- return OCLASS_PUBLICATION_NAMESPACE;
-
- case PublicationRelationId:
- return OCLASS_PUBLICATION;
-
- case PublicationRelRelationId:
- return OCLASS_PUBLICATION_REL;
-
- case SubscriptionRelationId:
- return OCLASS_SUBSCRIPTION;
-
- case TransformRelationId:
- return OCLASS_TRANSFORM;
- }
-
- /* shouldn't get here */
- elog(ERROR, "unrecognized object class: %u", object->classId);
- return OCLASS_CLASS; /* keep compiler quiet */
-}
-
/*
* delete initial ACL for extension objects
*/
ObjectTypeMap[] =
{
- /* OCLASS_CLASS, all kinds of relations */
{
"table", OBJECT_TABLE
},
{
"foreign table column", OBJECT_COLUMN
},
- /* OCLASS_PROC */
{
"aggregate", OBJECT_AGGREGATE
},
{
"procedure", OBJECT_PROCEDURE
},
- /* OCLASS_TYPE */
{
"type", OBJECT_TYPE
},
- /* OCLASS_CAST */
{
"cast", OBJECT_CAST
},
- /* OCLASS_COLLATION */
{
"collation", OBJECT_COLLATION
},
- /* OCLASS_CONSTRAINT */
{
"table constraint", OBJECT_TABCONSTRAINT
},
{
"domain constraint", OBJECT_DOMCONSTRAINT
},
- /* OCLASS_CONVERSION */
{
"conversion", OBJECT_CONVERSION
},
- /* OCLASS_DEFAULT */
{
"default value", OBJECT_DEFAULT
},
- /* OCLASS_LANGUAGE */
{
"language", OBJECT_LANGUAGE
},
- /* OCLASS_LARGEOBJECT */
{
"large object", OBJECT_LARGEOBJECT
},
- /* OCLASS_OPERATOR */
{
"operator", OBJECT_OPERATOR
},
- /* OCLASS_OPCLASS */
{
"operator class", OBJECT_OPCLASS
},
- /* OCLASS_OPFAMILY */
{
"operator family", OBJECT_OPFAMILY
},
- /* OCLASS_AM */
{
"access method", OBJECT_ACCESS_METHOD
},
- /* OCLASS_AMOP */
{
"operator of access method", OBJECT_AMOP
},
- /* OCLASS_AMPROC */
{
"function of access method", OBJECT_AMPROC
},
- /* OCLASS_REWRITE */
{
"rule", OBJECT_RULE
},
- /* OCLASS_TRIGGER */
{
"trigger", OBJECT_TRIGGER
},
- /* OCLASS_SCHEMA */
{
"schema", OBJECT_SCHEMA
},
- /* OCLASS_TSPARSER */
{
"text search parser", OBJECT_TSPARSER
},
- /* OCLASS_TSDICT */
{
"text search dictionary", OBJECT_TSDICTIONARY
},
- /* OCLASS_TSTEMPLATE */
{
"text search template", OBJECT_TSTEMPLATE
},
- /* OCLASS_TSCONFIG */
{
"text search configuration", OBJECT_TSCONFIGURATION
},
- /* OCLASS_ROLE */
{
"role", OBJECT_ROLE
},
- /* OCLASS_ROLE_MEMBERSHIP */
{
"role membership", -1 /* unmapped */
},
- /* OCLASS_DATABASE */
{
"database", OBJECT_DATABASE
},
- /* OCLASS_TBLSPACE */
{
"tablespace", OBJECT_TABLESPACE
},
- /* OCLASS_FDW */
{
"foreign-data wrapper", OBJECT_FDW
},
- /* OCLASS_FOREIGN_SERVER */
{
"server", OBJECT_FOREIGN_SERVER
},
- /* OCLASS_USER_MAPPING */
{
"user mapping", OBJECT_USER_MAPPING
},
- /* OCLASS_DEFACL */
{
"default acl", OBJECT_DEFACL
},
- /* OCLASS_EXTENSION */
{
"extension", OBJECT_EXTENSION
},
- /* OCLASS_EVENT_TRIGGER */
{
"event trigger", OBJECT_EVENT_TRIGGER
},
- /* OCLASS_PARAMETER_ACL */
{
"parameter ACL", OBJECT_PARAMETER_ACL
},
- /* OCLASS_POLICY */
{
"policy", OBJECT_POLICY
},
- /* OCLASS_PUBLICATION */
{
"publication", OBJECT_PUBLICATION
},
- /* OCLASS_PUBLICATION_NAMESPACE */
{
"publication namespace", OBJECT_PUBLICATION_NAMESPACE
},
- /* OCLASS_PUBLICATION_REL */
{
"publication relation", OBJECT_PUBLICATION_REL
},
- /* OCLASS_SUBSCRIPTION */
{
"subscription", OBJECT_SUBSCRIPTION
},
- /* OCLASS_TRANSFORM */
{
"transform", OBJECT_TRANSFORM
},
- /* OCLASS_STATISTIC_EXT */
{
"statistics object", OBJECT_STATISTIC_EXT
}
initStringInfo(&buffer);
- switch (getObjectClass(object))
+ switch (object->classId)
{
- case OCLASS_CLASS:
+ case RelationRelationId:
if (object->objectSubId == 0)
getRelationDescription(&buffer, object->objectId, missing_ok);
else
}
break;
- case OCLASS_PROC:
+ case ProcedureRelationId:
{
bits16 flags = FORMAT_PROC_INVALID_AS_NULL;
char *proname = format_procedure_extended(object->objectId,
break;
}
- case OCLASS_TYPE:
+ case TypeRelationId:
{
bits16 flags = FORMAT_TYPE_INVALID_AS_NULL;
char *typname = format_type_extended(object->objectId, -1,
break;
}
- case OCLASS_CAST:
+ case CastRelationId:
{
Relation castDesc;
ScanKeyData skey[1];
break;
}
- case OCLASS_COLLATION:
+ case CollationRelationId:
{
HeapTuple collTup;
Form_pg_collation coll;
break;
}
- case OCLASS_CONSTRAINT:
+ case ConstraintRelationId:
{
HeapTuple conTup;
Form_pg_constraint con;
break;
}
- case OCLASS_CONVERSION:
+ case ConversionRelationId:
{
HeapTuple conTup;
Form_pg_conversion conv;
break;
}
- case OCLASS_DEFAULT:
+ case AttrDefaultRelationId:
{
ObjectAddress colobject;
break;
}
- case OCLASS_LANGUAGE:
+ case LanguageRelationId:
{
char *langname = get_language_name(object->objectId,
missing_ok);
break;
}
- case OCLASS_LARGEOBJECT:
+ case LargeObjectRelationId:
if (!LargeObjectExists(object->objectId))
break;
appendStringInfo(&buffer, _("large object %u"),
object->objectId);
break;
- case OCLASS_OPERATOR:
+ case OperatorRelationId:
{
bits16 flags = FORMAT_OPERATOR_INVALID_AS_NULL;
char *oprname = format_operator_extended(object->objectId,
break;
}
- case OCLASS_OPCLASS:
+ case OperatorClassRelationId:
{
HeapTuple opcTup;
Form_pg_opclass opcForm;
break;
}
- case OCLASS_OPFAMILY:
+ case OperatorFamilyRelationId:
getOpFamilyDescription(&buffer, object->objectId, missing_ok);
break;
- case OCLASS_AM:
+ case AccessMethodRelationId:
{
HeapTuple tup;
break;
}
- case OCLASS_AMOP:
+ case AccessMethodOperatorRelationId:
{
Relation amopDesc;
HeapTuple tup;
break;
}
- case OCLASS_AMPROC:
+ case AccessMethodProcedureRelationId:
{
Relation amprocDesc;
ScanKeyData skey[1];
break;
}
- case OCLASS_REWRITE:
+ case RewriteRelationId:
{
Relation ruleDesc;
ScanKeyData skey[1];
break;
}
- case OCLASS_TRIGGER:
+ case TriggerRelationId:
{
Relation trigDesc;
ScanKeyData skey[1];
break;
}
- case OCLASS_SCHEMA:
+ case NamespaceRelationId:
{
char *nspname;
break;
}
- case OCLASS_STATISTIC_EXT:
+ case StatisticExtRelationId:
{
HeapTuple stxTup;
Form_pg_statistic_ext stxForm;
break;
}
- case OCLASS_TSPARSER:
+ case TSParserRelationId:
{
HeapTuple tup;
Form_pg_ts_parser prsForm;
break;
}
- case OCLASS_TSDICT:
+ case TSDictionaryRelationId:
{
HeapTuple tup;
Form_pg_ts_dict dictForm;
break;
}
- case OCLASS_TSTEMPLATE:
+ case TSTemplateRelationId:
{
HeapTuple tup;
Form_pg_ts_template tmplForm;
break;
}
- case OCLASS_TSCONFIG:
+ case TSConfigRelationId:
{
HeapTuple tup;
Form_pg_ts_config cfgForm;
break;
}
- case OCLASS_ROLE:
+ case AuthIdRelationId:
{
char *username = GetUserNameFromId(object->objectId,
missing_ok);
break;
}
- case OCLASS_ROLE_MEMBERSHIP:
+ case AuthMemRelationId:
{
Relation amDesc;
ScanKeyData skey[1];
break;
}
- case OCLASS_DATABASE:
+ case DatabaseRelationId:
{
char *datname;
break;
}
- case OCLASS_TBLSPACE:
+ case TableSpaceRelationId:
{
char *tblspace;
break;
}
- case OCLASS_FDW:
+ case ForeignDataWrapperRelationId:
{
ForeignDataWrapper *fdw;
break;
}
- case OCLASS_FOREIGN_SERVER:
+ case ForeignServerRelationId:
{
ForeignServer *srv;
break;
}
- case OCLASS_USER_MAPPING:
+ case UserMappingRelationId:
{
HeapTuple tup;
Oid useid;
break;
}
- case OCLASS_DEFACL:
+ case DefaultAclRelationId:
{
Relation defaclrel;
ScanKeyData skey[1];
break;
}
- case OCLASS_EXTENSION:
+ case ExtensionRelationId:
{
char *extname;
break;
}
- case OCLASS_EVENT_TRIGGER:
+ case EventTriggerRelationId:
{
HeapTuple tup;
break;
}
- case OCLASS_PARAMETER_ACL:
+ case ParameterAclRelationId:
{
HeapTuple tup;
Datum nameDatum;
break;
}
- case OCLASS_POLICY:
+ case PolicyRelationId:
{
Relation policy_rel;
ScanKeyData skey[1];
break;
}
- case OCLASS_PUBLICATION:
+ case PublicationRelationId:
{
char *pubname = get_publication_name(object->objectId,
missing_ok);
break;
}
- case OCLASS_PUBLICATION_NAMESPACE:
+ case PublicationNamespaceRelationId:
{
char *pubname;
char *nspname;
break;
}
- case OCLASS_PUBLICATION_REL:
+ case PublicationRelRelationId:
{
HeapTuple tup;
char *pubname;
break;
}
- case OCLASS_SUBSCRIPTION:
+ case SubscriptionRelationId:
{
char *subname = get_subscription_name(object->objectId,
missing_ok);
break;
}
- case OCLASS_TRANSFORM:
+ case TransformRelationId:
{
HeapTuple trfTup;
Form_pg_transform trfForm;
break;
}
- /*
- * There's intentionally no default: case here; we want the
- * compiler to warn if a new OCLASS hasn't been handled above.
- */
+ default:
+ elog(ERROR, "unsupported object class: %u", object->classId);
}
/* an empty buffer is equivalent to no object found */
initStringInfo(&buffer);
- switch (getObjectClass(object))
+ switch (object->classId)
{
- case OCLASS_CLASS:
+ case RelationRelationId:
getRelationTypeDescription(&buffer, object->objectId,
object->objectSubId,
missing_ok);
break;
- case OCLASS_PROC:
+ case ProcedureRelationId:
getProcedureTypeDescription(&buffer, object->objectId,
missing_ok);
break;
- case OCLASS_TYPE:
+ case TypeRelationId:
appendStringInfoString(&buffer, "type");
break;
- case OCLASS_CAST:
+ case CastRelationId:
appendStringInfoString(&buffer, "cast");
break;
- case OCLASS_COLLATION:
+ case CollationRelationId:
appendStringInfoString(&buffer, "collation");
break;
- case OCLASS_CONSTRAINT:
+ case ConstraintRelationId:
getConstraintTypeDescription(&buffer, object->objectId,
missing_ok);
break;
- case OCLASS_CONVERSION:
+ case ConversionRelationId:
appendStringInfoString(&buffer, "conversion");
break;
- case OCLASS_DEFAULT:
+ case AttrDefaultRelationId:
appendStringInfoString(&buffer, "default value");
break;
- case OCLASS_LANGUAGE:
+ case LanguageRelationId:
appendStringInfoString(&buffer, "language");
break;
- case OCLASS_LARGEOBJECT:
+ case LargeObjectRelationId:
appendStringInfoString(&buffer, "large object");
break;
- case OCLASS_OPERATOR:
+ case OperatorRelationId:
appendStringInfoString(&buffer, "operator");
break;
- case OCLASS_OPCLASS:
+ case OperatorClassRelationId:
appendStringInfoString(&buffer, "operator class");
break;
- case OCLASS_OPFAMILY:
+ case OperatorFamilyRelationId:
appendStringInfoString(&buffer, "operator family");
break;
- case OCLASS_AM:
+ case AccessMethodRelationId:
appendStringInfoString(&buffer, "access method");
break;
- case OCLASS_AMOP:
+ case AccessMethodOperatorRelationId:
appendStringInfoString(&buffer, "operator of access method");
break;
- case OCLASS_AMPROC:
+ case AccessMethodProcedureRelationId:
appendStringInfoString(&buffer, "function of access method");
break;
- case OCLASS_REWRITE:
+ case RewriteRelationId:
appendStringInfoString(&buffer, "rule");
break;
- case OCLASS_TRIGGER:
+ case TriggerRelationId:
appendStringInfoString(&buffer, "trigger");
break;
- case OCLASS_SCHEMA:
+ case NamespaceRelationId:
appendStringInfoString(&buffer, "schema");
break;
- case OCLASS_STATISTIC_EXT:
+ case StatisticExtRelationId:
appendStringInfoString(&buffer, "statistics object");
break;
- case OCLASS_TSPARSER:
+ case TSParserRelationId:
appendStringInfoString(&buffer, "text search parser");
break;
- case OCLASS_TSDICT:
+ case TSDictionaryRelationId:
appendStringInfoString(&buffer, "text search dictionary");
break;
- case OCLASS_TSTEMPLATE:
+ case TSTemplateRelationId:
appendStringInfoString(&buffer, "text search template");
break;
- case OCLASS_TSCONFIG:
+ case TSConfigRelationId:
appendStringInfoString(&buffer, "text search configuration");
break;
- case OCLASS_ROLE:
+ case AuthIdRelationId:
appendStringInfoString(&buffer, "role");
break;
- case OCLASS_ROLE_MEMBERSHIP:
+ case AuthMemRelationId:
appendStringInfoString(&buffer, "role membership");
break;
- case OCLASS_DATABASE:
+ case DatabaseRelationId:
appendStringInfoString(&buffer, "database");
break;
- case OCLASS_TBLSPACE:
+ case TableSpaceRelationId:
appendStringInfoString(&buffer, "tablespace");
break;
- case OCLASS_FDW:
+ case ForeignDataWrapperRelationId:
appendStringInfoString(&buffer, "foreign-data wrapper");
break;
- case OCLASS_FOREIGN_SERVER:
+ case ForeignServerRelationId:
appendStringInfoString(&buffer, "server");
break;
- case OCLASS_USER_MAPPING:
+ case UserMappingRelationId:
appendStringInfoString(&buffer, "user mapping");
break;
- case OCLASS_DEFACL:
+ case DefaultAclRelationId:
appendStringInfoString(&buffer, "default acl");
break;
- case OCLASS_EXTENSION:
+ case ExtensionRelationId:
appendStringInfoString(&buffer, "extension");
break;
- case OCLASS_EVENT_TRIGGER:
+ case EventTriggerRelationId:
appendStringInfoString(&buffer, "event trigger");
break;
- case OCLASS_PARAMETER_ACL:
+ case ParameterAclRelationId:
appendStringInfoString(&buffer, "parameter ACL");
break;
- case OCLASS_POLICY:
+ case PolicyRelationId:
appendStringInfoString(&buffer, "policy");
break;
- case OCLASS_PUBLICATION:
+ case PublicationRelationId:
appendStringInfoString(&buffer, "publication");
break;
- case OCLASS_PUBLICATION_NAMESPACE:
+ case PublicationNamespaceRelationId:
appendStringInfoString(&buffer, "publication namespace");
break;
- case OCLASS_PUBLICATION_REL:
+ case PublicationRelRelationId:
appendStringInfoString(&buffer, "publication relation");
break;
- case OCLASS_SUBSCRIPTION:
+ case SubscriptionRelationId:
appendStringInfoString(&buffer, "subscription");
break;
- case OCLASS_TRANSFORM:
+ case TransformRelationId:
appendStringInfoString(&buffer, "transform");
break;
- /*
- * There's intentionally no default: case here; we want the
- * compiler to warn if a new OCLASS hasn't been handled above.
- */
+ default:
+ elog(ERROR, "unsupported object class: %u", object->classId);
}
/* the result can never be empty */
*objargs = NIL;
}
- switch (getObjectClass(object))
+ switch (object->classId)
{
- case OCLASS_CLASS:
+ case RelationRelationId:
{
char *attr = NULL;
}
break;
- case OCLASS_PROC:
+ case ProcedureRelationId:
{
bits16 flags = FORMAT_PROC_FORCE_QUALIFY | FORMAT_PROC_INVALID_AS_NULL;
char *proname = format_procedure_extended(object->objectId,
break;
}
- case OCLASS_TYPE:
+ case TypeRelationId:
{
bits16 flags = FORMAT_TYPE_INVALID_AS_NULL | FORMAT_TYPE_FORCE_QUALIFY;
char *typeout;
}
break;
- case OCLASS_CAST:
+ case CastRelationId:
{
Relation castRel;
HeapTuple tup;
break;
}
- case OCLASS_COLLATION:
+ case CollationRelationId:
{
HeapTuple collTup;
Form_pg_collation coll;
break;
}
- case OCLASS_CONSTRAINT:
+ case ConstraintRelationId:
{
HeapTuple conTup;
Form_pg_constraint con;
break;
}
- case OCLASS_CONVERSION:
+ case ConversionRelationId:
{
HeapTuple conTup;
Form_pg_conversion conForm;
break;
}
- case OCLASS_DEFAULT:
+ case AttrDefaultRelationId:
{
ObjectAddress colobject;
break;
}
- case OCLASS_LANGUAGE:
+ case LanguageRelationId:
{
HeapTuple langTup;
Form_pg_language langForm;
ReleaseSysCache(langTup);
break;
}
- case OCLASS_LARGEOBJECT:
+
+ case LargeObjectRelationId:
if (!LargeObjectExists(object->objectId))
break;
appendStringInfo(&buffer, "%u",
*objname = list_make1(psprintf("%u", object->objectId));
break;
- case OCLASS_OPERATOR:
+ case OperatorRelationId:
{
bits16 flags = FORMAT_OPERATOR_FORCE_QUALIFY | FORMAT_OPERATOR_INVALID_AS_NULL;
char *oprname = format_operator_extended(object->objectId,
break;
}
- case OCLASS_OPCLASS:
+ case OperatorClassRelationId:
{
HeapTuple opcTup;
Form_pg_opclass opcForm;
break;
}
- case OCLASS_OPFAMILY:
+ case OperatorFamilyRelationId:
getOpFamilyIdentity(&buffer, object->objectId, objname,
missing_ok);
break;
- case OCLASS_AM:
+ case AccessMethodRelationId:
{
char *amname;
}
break;
- case OCLASS_AMOP:
+ case AccessMethodOperatorRelationId:
{
Relation amopDesc;
HeapTuple tup;
break;
}
- case OCLASS_AMPROC:
+ case AccessMethodProcedureRelationId:
{
Relation amprocDesc;
ScanKeyData skey[1];
break;
}
- case OCLASS_REWRITE:
+ case RewriteRelationId:
{
Relation ruleDesc;
HeapTuple tup;
break;
}
- case OCLASS_TRIGGER:
+ case TriggerRelationId:
{
Relation trigDesc;
HeapTuple tup;
break;
}
- case OCLASS_SCHEMA:
+ case NamespaceRelationId:
{
char *nspname;
break;
}
- case OCLASS_STATISTIC_EXT:
+ case StatisticExtRelationId:
{
HeapTuple tup;
Form_pg_statistic_ext formStatistic;
}
break;
- case OCLASS_TSPARSER:
+ case TSParserRelationId:
{
HeapTuple tup;
Form_pg_ts_parser formParser;
break;
}
- case OCLASS_TSDICT:
+ case TSDictionaryRelationId:
{
HeapTuple tup;
Form_pg_ts_dict formDict;
break;
}
- case OCLASS_TSTEMPLATE:
+ case TSTemplateRelationId:
{
HeapTuple tup;
Form_pg_ts_template formTmpl;
break;
}
- case OCLASS_TSCONFIG:
+ case TSConfigRelationId:
{
HeapTuple tup;
Form_pg_ts_config formCfg;
break;
}
- case OCLASS_ROLE:
+ case AuthIdRelationId:
{
char *username;
break;
}
- case OCLASS_ROLE_MEMBERSHIP:
+ case AuthMemRelationId:
{
Relation authMemDesc;
ScanKeyData skey[1];
break;
}
- case OCLASS_DATABASE:
+ case DatabaseRelationId:
{
char *datname;
break;
}
- case OCLASS_TBLSPACE:
+ case TableSpaceRelationId:
{
char *tblspace;
break;
}
- case OCLASS_FDW:
+ case ForeignDataWrapperRelationId:
{
ForeignDataWrapper *fdw;
break;
}
- case OCLASS_FOREIGN_SERVER:
+ case ForeignServerRelationId:
{
ForeignServer *srv;
break;
}
- case OCLASS_USER_MAPPING:
+ case UserMappingRelationId:
{
HeapTuple tup;
Oid useid;
break;
}
- case OCLASS_DEFACL:
+ case DefaultAclRelationId:
{
Relation defaclrel;
ScanKeyData skey[1];
break;
}
- case OCLASS_EXTENSION:
+ case ExtensionRelationId:
{
char *extname;
break;
}
- case OCLASS_EVENT_TRIGGER:
+ case EventTriggerRelationId:
{
HeapTuple tup;
Form_pg_event_trigger trigForm;
break;
}
- case OCLASS_PARAMETER_ACL:
+ case ParameterAclRelationId:
{
HeapTuple tup;
Datum nameDatum;
break;
}
- case OCLASS_POLICY:
+ case PolicyRelationId:
{
Relation polDesc;
HeapTuple tup;
break;
}
- case OCLASS_PUBLICATION:
+ case PublicationRelationId:
{
char *pubname;
break;
}
- case OCLASS_PUBLICATION_NAMESPACE:
+ case PublicationNamespaceRelationId:
{
char *pubname;
char *nspname;
break;
}
- case OCLASS_PUBLICATION_REL:
+ case PublicationRelRelationId:
{
HeapTuple tup;
char *pubname;
break;
}
- case OCLASS_SUBSCRIPTION:
+ case SubscriptionRelationId:
{
char *subname;
break;
}
- case OCLASS_TRANSFORM:
+ case TransformRelationId:
{
Relation transformDesc;
HeapTuple tup;
}
break;
- /*
- * There's intentionally no default: case here; we want the
- * compiler to warn if a new OCLASS hasn't been handled above.
- */
+ default:
+ elog(ERROR, "unsupported object class: %u", object->classId);
}
if (!missing_ok)
* cases above leave it as NIL.
*/
if (objname && *objname == NIL)
- elog(ERROR, "requested object address for unsupported object class %d: text result \"%s\"",
- (int) getObjectClass(object), buffer.data);
+ elog(ERROR, "requested object address for unsupported object class %u: text result \"%s\"",
+ object->classId, buffer.data);
}
else
{
#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_proc.h"
#include "catalog/pg_statistic_ext.h"
* so it only needs to cover object types that can be members of an
* extension, and it doesn't have to deal with certain special cases
* such as not wanting to process array types --- those should never
- * be direct members of an extension anyway. Nonetheless, we insist
- * on listing all OCLASS types in the switch.
+ * be direct members of an extension anyway.
*
* Returns the OID of the object's previous namespace, or InvalidOid if
* object doesn't have a schema.
ObjectAddresses *objsMoved)
{
Oid oldNspOid = InvalidOid;
- ObjectAddress dep;
- dep.classId = classId;
- dep.objectId = objid;
- dep.objectSubId = 0;
-
- switch (getObjectClass(&dep))
+ switch (classId)
{
- case OCLASS_CLASS:
+ case RelationRelationId:
{
Relation rel;
break;
}
- case OCLASS_TYPE:
+ case TypeRelationId:
oldNspOid = AlterTypeNamespace_oid(objid, nspOid, objsMoved);
break;
- case OCLASS_PROC:
- case OCLASS_COLLATION:
- case OCLASS_CONVERSION:
- case OCLASS_OPERATOR:
- case OCLASS_OPCLASS:
- case OCLASS_OPFAMILY:
- case OCLASS_STATISTIC_EXT:
- case OCLASS_TSPARSER:
- case OCLASS_TSDICT:
- case OCLASS_TSTEMPLATE:
- case OCLASS_TSCONFIG:
+ case ProcedureRelationId:
+ case CollationRelationId:
+ case ConversionRelationId:
+ case OperatorRelationId:
+ case OperatorClassRelationId:
+ case OperatorFamilyRelationId:
+ case StatisticExtRelationId:
+ case TSParserRelationId:
+ case TSDictionaryRelationId:
+ case TSTemplateRelationId:
+ case TSConfigRelationId:
{
Relation catalog;
}
break;
- case OCLASS_CAST:
- case OCLASS_CONSTRAINT:
- case OCLASS_DEFAULT:
- case OCLASS_LANGUAGE:
- case OCLASS_LARGEOBJECT:
- case OCLASS_AM:
- case OCLASS_AMOP:
- case OCLASS_AMPROC:
- case OCLASS_REWRITE:
- case OCLASS_TRIGGER:
- case OCLASS_SCHEMA:
- case OCLASS_ROLE:
- case OCLASS_ROLE_MEMBERSHIP:
- case OCLASS_DATABASE:
- case OCLASS_TBLSPACE:
- case OCLASS_FDW:
- case OCLASS_FOREIGN_SERVER:
- case OCLASS_USER_MAPPING:
- case OCLASS_DEFACL:
- case OCLASS_EXTENSION:
- case OCLASS_EVENT_TRIGGER:
- case OCLASS_PARAMETER_ACL:
- case OCLASS_POLICY:
- case OCLASS_PUBLICATION:
- case OCLASS_PUBLICATION_NAMESPACE:
- case OCLASS_PUBLICATION_REL:
- case OCLASS_SUBSCRIPTION:
- case OCLASS_TRANSFORM:
+ default:
/* ignore object types that don't have schema-qualified names */
- break;
-
- /*
- * There's intentionally no default: case here; we want the
- * compiler to warn if a new OCLASS hasn't been handled above.
- */
+ Assert(get_object_attnum_namespace(classId) == InvalidAttrNumber);
}
return oldNspOid;
#include "catalog/dependency.h"
#include "catalog/indexing.h"
#include "catalog/objectaccess.h"
+#include "catalog/pg_authid.h"
+#include "catalog/pg_auth_members.h"
#include "catalog/pg_database.h"
#include "catalog/pg_event_trigger.h"
#include "catalog/pg_namespace.h"
#include "catalog/pg_opclass.h"
#include "catalog/pg_opfamily.h"
+#include "catalog/pg_parameter_acl.h"
#include "catalog/pg_proc.h"
+#include "catalog/pg_tablespace.h"
#include "catalog/pg_trigger.h"
#include "catalog/pg_ts_config.h"
#include "catalog/pg_type.h"
/*
* Do event triggers support this object type?
+ *
+ * See also event trigger support matrix in event-trigger.sgml.
*/
bool
EventTriggerSupportsObjectType(ObjectType obtype)
case OBJECT_TABLESPACE:
case OBJECT_ROLE:
case OBJECT_PARAMETER_ACL:
- /* no support for global objects */
+ /* no support for global objects (except subscriptions) */
return false;
case OBJECT_EVENT_TRIGGER:
/* no support for event triggers on event triggers */
return false;
- case OBJECT_ACCESS_METHOD:
- case OBJECT_AGGREGATE:
- case OBJECT_AMOP:
- case OBJECT_AMPROC:
- case OBJECT_ATTRIBUTE:
- case OBJECT_CAST:
- case OBJECT_COLUMN:
- case OBJECT_COLLATION:
- case OBJECT_CONVERSION:
- case OBJECT_DEFACL:
- case OBJECT_DEFAULT:
- case OBJECT_DOMAIN:
- case OBJECT_DOMCONSTRAINT:
- case OBJECT_EXTENSION:
- case OBJECT_FDW:
- case OBJECT_FOREIGN_SERVER:
- case OBJECT_FOREIGN_TABLE:
- case OBJECT_FUNCTION:
- case OBJECT_INDEX:
- case OBJECT_LANGUAGE:
- case OBJECT_LARGEOBJECT:
- case OBJECT_MATVIEW:
- case OBJECT_OPCLASS:
- case OBJECT_OPERATOR:
- case OBJECT_OPFAMILY:
- case OBJECT_POLICY:
- case OBJECT_PROCEDURE:
- case OBJECT_PUBLICATION:
- case OBJECT_PUBLICATION_NAMESPACE:
- case OBJECT_PUBLICATION_REL:
- case OBJECT_ROUTINE:
- case OBJECT_RULE:
- case OBJECT_SCHEMA:
- case OBJECT_SEQUENCE:
- case OBJECT_SUBSCRIPTION:
- case OBJECT_STATISTIC_EXT:
- case OBJECT_TABCONSTRAINT:
- case OBJECT_TABLE:
- case OBJECT_TRANSFORM:
- case OBJECT_TRIGGER:
- case OBJECT_TSCONFIGURATION:
- case OBJECT_TSDICTIONARY:
- case OBJECT_TSPARSER:
- case OBJECT_TSTEMPLATE:
- case OBJECT_TYPE:
- case OBJECT_USER_MAPPING:
- case OBJECT_VIEW:
+ default:
return true;
-
- /*
- * There's intentionally no default: case here; we want the
- * compiler to warn if a new ObjectType hasn't been handled above.
- */
}
-
- /* Shouldn't get here, but if we do, say "no support" */
- return false;
}
/*
* Do event triggers support this object class?
+ *
+ * See also event trigger support matrix in event-trigger.sgml.
*/
bool
-EventTriggerSupportsObjectClass(ObjectClass objclass)
+EventTriggerSupportsObject(const ObjectAddress *object)
{
- switch (objclass)
+ switch (object->classId)
{
- case OCLASS_DATABASE:
- case OCLASS_TBLSPACE:
- case OCLASS_ROLE:
- case OCLASS_ROLE_MEMBERSHIP:
- case OCLASS_PARAMETER_ACL:
- /* no support for global objects */
+ case DatabaseRelationId:
+ case TableSpaceRelationId:
+ case AuthIdRelationId:
+ case AuthMemRelationId:
+ case ParameterAclRelationId:
+ /* no support for global objects (except subscriptions) */
return false;
- case OCLASS_EVENT_TRIGGER:
+ case EventTriggerRelationId:
/* no support for event triggers on event triggers */
return false;
- case OCLASS_CLASS:
- case OCLASS_PROC:
- case OCLASS_TYPE:
- case OCLASS_CAST:
- case OCLASS_COLLATION:
- case OCLASS_CONSTRAINT:
- case OCLASS_CONVERSION:
- case OCLASS_DEFAULT:
- case OCLASS_LANGUAGE:
- case OCLASS_LARGEOBJECT:
- case OCLASS_OPERATOR:
- case OCLASS_OPCLASS:
- case OCLASS_OPFAMILY:
- case OCLASS_AM:
- case OCLASS_AMOP:
- case OCLASS_AMPROC:
- case OCLASS_REWRITE:
- case OCLASS_TRIGGER:
- case OCLASS_SCHEMA:
- case OCLASS_STATISTIC_EXT:
- case OCLASS_TSPARSER:
- case OCLASS_TSDICT:
- case OCLASS_TSTEMPLATE:
- case OCLASS_TSCONFIG:
- case OCLASS_FDW:
- case OCLASS_FOREIGN_SERVER:
- case OCLASS_USER_MAPPING:
- case OCLASS_DEFACL:
- case OCLASS_EXTENSION:
- case OCLASS_POLICY:
- case OCLASS_PUBLICATION:
- case OCLASS_PUBLICATION_NAMESPACE:
- case OCLASS_PUBLICATION_REL:
- case OCLASS_SUBSCRIPTION:
- case OCLASS_TRANSFORM:
+ default:
return true;
-
- /*
- * There's intentionally no default: case here; we want the
- * compiler to warn if a new OCLASS hasn't been handled above.
- */
}
-
- /* Shouldn't get here, but if we do, say "no support" */
- return false;
}
/*
if (!currentEventTriggerState)
return;
- Assert(EventTriggerSupportsObjectClass(getObjectClass(object)));
+ Assert(EventTriggerSupportsObject(object));
/* don't report temp schemas except my own */
if (object->classId == NamespaceRelationId &&
#include "catalog/pg_largeobject.h"
#include "catalog/pg_namespace.h"
#include "catalog/pg_opclass.h"
+#include "catalog/pg_policy.h"
+#include "catalog/pg_rewrite.h"
#include "catalog/pg_statistic_ext.h"
#include "catalog/pg_tablespace.h"
#include "catalog/pg_trigger.h"
foundObject.objectId = foundDep->objid;
foundObject.objectSubId = foundDep->objsubid;
- switch (getObjectClass(&foundObject))
+ switch (foundObject.classId)
{
- case OCLASS_CLASS:
+ case RelationRelationId:
{
char relKind = get_rel_relkind(foundObject.objectId);
break;
}
- case OCLASS_CONSTRAINT:
+ case ConstraintRelationId:
Assert(foundObject.objectSubId == 0);
RememberConstraintForRebuilding(foundObject.objectId, tab);
break;
- case OCLASS_REWRITE:
+ case RewriteRelationId:
/* XXX someday see if we can cope with revising views */
if (subtype == AT_AlterColumnType)
ereport(ERROR,
colName)));
break;
- case OCLASS_TRIGGER:
+ case TriggerRelationId:
/*
* A trigger can depend on a column because the column is
colName)));
break;
- case OCLASS_POLICY:
+ case PolicyRelationId:
/*
* A policy can depend on a column because the column is
colName)));
break;
- case OCLASS_DEFAULT:
+ case AttrDefaultRelationId:
{
ObjectAddress col = GetAttrDefaultColumnAddress(foundObject.objectId);
break;
}
- case OCLASS_STATISTIC_EXT:
+ case StatisticExtRelationId:
/*
* Give the extended-stats machinery a chance to fix anything
RememberStatisticsForRebuilding(foundObject.objectId, tab);
break;
- case OCLASS_PROC:
- case OCLASS_TYPE:
- case OCLASS_CAST:
- case OCLASS_COLLATION:
- case OCLASS_CONVERSION:
- case OCLASS_LANGUAGE:
- case OCLASS_LARGEOBJECT:
- case OCLASS_OPERATOR:
- case OCLASS_OPCLASS:
- case OCLASS_OPFAMILY:
- case OCLASS_AM:
- case OCLASS_AMOP:
- case OCLASS_AMPROC:
- case OCLASS_SCHEMA:
- case OCLASS_TSPARSER:
- case OCLASS_TSDICT:
- case OCLASS_TSTEMPLATE:
- case OCLASS_TSCONFIG:
- case OCLASS_ROLE:
- case OCLASS_ROLE_MEMBERSHIP:
- case OCLASS_DATABASE:
- case OCLASS_TBLSPACE:
- case OCLASS_FDW:
- case OCLASS_FOREIGN_SERVER:
- case OCLASS_USER_MAPPING:
- case OCLASS_DEFACL:
- case OCLASS_EXTENSION:
- case OCLASS_EVENT_TRIGGER:
- case OCLASS_PARAMETER_ACL:
- case OCLASS_PUBLICATION:
- case OCLASS_PUBLICATION_NAMESPACE:
- case OCLASS_PUBLICATION_REL:
- case OCLASS_SUBSCRIPTION:
- case OCLASS_TRANSFORM:
+ default:
/*
- * We don't expect any of these sorts of objects to depend on
- * a column.
+ * We don't expect any other sorts of objects to depend on a
+ * column.
*/
elog(ERROR, "unexpected object depending on column: %s",
getObjectDescription(&foundObject, false));
break;
-
- /*
- * There's intentionally no default: case here; we want the
- * compiler to warn if a new OCLASS hasn't been handled above.
- */
}
}
/* expansible list of ObjectAddresses (private in dependency.c) */
typedef struct ObjectAddresses ObjectAddresses;
-/*
- * This enum covers all system catalogs whose OIDs can appear in
- * pg_depend.classId or pg_shdepend.classId.
- */
-typedef enum ObjectClass
-{
- OCLASS_CLASS, /* pg_class */
- OCLASS_PROC, /* pg_proc */
- OCLASS_TYPE, /* pg_type */
- OCLASS_CAST, /* pg_cast */
- OCLASS_COLLATION, /* pg_collation */
- OCLASS_CONSTRAINT, /* pg_constraint */
- OCLASS_CONVERSION, /* pg_conversion */
- OCLASS_DEFAULT, /* pg_attrdef */
- OCLASS_LANGUAGE, /* pg_language */
- OCLASS_LARGEOBJECT, /* pg_largeobject */
- OCLASS_OPERATOR, /* pg_operator */
- OCLASS_OPCLASS, /* pg_opclass */
- OCLASS_OPFAMILY, /* pg_opfamily */
- OCLASS_AM, /* pg_am */
- OCLASS_AMOP, /* pg_amop */
- OCLASS_AMPROC, /* pg_amproc */
- OCLASS_REWRITE, /* pg_rewrite */
- OCLASS_TRIGGER, /* pg_trigger */
- OCLASS_SCHEMA, /* pg_namespace */
- OCLASS_STATISTIC_EXT, /* pg_statistic_ext */
- OCLASS_TSPARSER, /* pg_ts_parser */
- OCLASS_TSDICT, /* pg_ts_dict */
- OCLASS_TSTEMPLATE, /* pg_ts_template */
- OCLASS_TSCONFIG, /* pg_ts_config */
- OCLASS_ROLE, /* pg_authid */
- OCLASS_ROLE_MEMBERSHIP, /* pg_auth_members */
- OCLASS_DATABASE, /* pg_database */
- OCLASS_TBLSPACE, /* pg_tablespace */
- OCLASS_FDW, /* pg_foreign_data_wrapper */
- OCLASS_FOREIGN_SERVER, /* pg_foreign_server */
- OCLASS_USER_MAPPING, /* pg_user_mapping */
- OCLASS_DEFACL, /* pg_default_acl */
- OCLASS_EXTENSION, /* pg_extension */
- OCLASS_EVENT_TRIGGER, /* pg_event_trigger */
- OCLASS_PARAMETER_ACL, /* pg_parameter_acl */
- OCLASS_POLICY, /* pg_policy */
- OCLASS_PUBLICATION, /* pg_publication */
- OCLASS_PUBLICATION_NAMESPACE, /* pg_publication_namespace */
- OCLASS_PUBLICATION_REL, /* pg_publication_rel */
- OCLASS_SUBSCRIPTION, /* pg_subscription */
- OCLASS_TRANSFORM, /* pg_transform */
-} ObjectClass;
-
/* flag bits for performDeletion/performMultipleDeletions: */
#define PERFORM_DELETION_INTERNAL 0x0001 /* internal action */
#define PERFORM_DELETION_CONCURRENTLY 0x0002 /* concurrent drop */
DependencyType self_behavior,
bool reverse_self);
-extern ObjectClass getObjectClass(const ObjectAddress *object);
-
extern ObjectAddresses *new_object_addresses(void);
extern void add_exact_object_address(const ObjectAddress *object,
extern void AlterEventTriggerOwner_oid(Oid, Oid newOwnerId);
extern bool EventTriggerSupportsObjectType(ObjectType obtype);
-extern bool EventTriggerSupportsObjectClass(ObjectClass objclass);
+extern bool EventTriggerSupportsObject(const ObjectAddress *object);
extern void EventTriggerDDLCommandStart(Node *parsetree);
extern void EventTriggerDDLCommandEnd(Node *parsetree);
extern void EventTriggerSQLDrop(Node *parsetree);
ObjectAddressExtra
ObjectAddressStack
ObjectAddresses
-ObjectClass
ObjectPropertyType
ObjectType
ObjectWithArgs
projects / postgresql.git / commitdiff