Oid nspid; /* namespace, or InvalidOid if none */
/* remaining fields are same as in InternalGrant: */
bool is_grant;
- GrantObjectType objtype;
+ ObjectType objtype;
bool all_privs;
AclMode privileges;
List *grantees;
static void SetDefaultACLsInSchemas(InternalDefaultACL *iacls, List *nspnames);
static void SetDefaultACL(InternalDefaultACL *iacls);
-static List *objectNamesToOids(GrantObjectType objtype, List *objnames);
-static List *objectsInSchemaToOids(GrantObjectType objtype, List *nspnames);
+static List *objectNamesToOids(ObjectType objtype, List *objnames);
+static List *objectsInSchemaToOids(ObjectType objtype, List *nspnames);
static List *getRelationsInNamespace(Oid namespaceId, char relkind);
static void expand_col_privileges(List *colnames, Oid table_oid,
AclMode this_privileges,
whole_mask = ACL_ALL_RIGHTS_LARGEOBJECT;
break;
case ACL_KIND_NAMESPACE:
- whole_mask = ACL_ALL_RIGHTS_NAMESPACE;
+ whole_mask = ACL_ALL_RIGHTS_SCHEMA;
break;
case ACL_KIND_TABLESPACE:
whole_mask = ACL_ALL_RIGHTS_TABLESPACE;
/*
* Convert stmt->privileges, a list of AccessPriv nodes, into an AclMode
- * bitmask. Note: objtype can't be ACL_OBJECT_COLUMN.
+ * bitmask. Note: objtype can't be OBJECT_COLUMN.
*/
switch (stmt->objtype)
{
+ case OBJECT_TABLE:
/*
* Because this might be a sequence, we test both relation and
* sequence bits, and later do a more limited test when we know
* the object type.
*/
- case ACL_OBJECT_RELATION:
all_privileges = ACL_ALL_RIGHTS_RELATION | ACL_ALL_RIGHTS_SEQUENCE;
errormsg = gettext_noop("invalid privilege type %s for relation");
break;
- case ACL_OBJECT_SEQUENCE:
+ case OBJECT_SEQUENCE:
all_privileges = ACL_ALL_RIGHTS_SEQUENCE;
errormsg = gettext_noop("invalid privilege type %s for sequence");
break;
- case ACL_OBJECT_DATABASE:
+ case OBJECT_DATABASE:
all_privileges = ACL_ALL_RIGHTS_DATABASE;
errormsg = gettext_noop("invalid privilege type %s for database");
break;
- case ACL_OBJECT_DOMAIN:
+ case OBJECT_DOMAIN:
all_privileges = ACL_ALL_RIGHTS_TYPE;
errormsg = gettext_noop("invalid privilege type %s for domain");
break;
- case ACL_OBJECT_FUNCTION:
+ case OBJECT_FUNCTION:
all_privileges = ACL_ALL_RIGHTS_FUNCTION;
errormsg = gettext_noop("invalid privilege type %s for function");
break;
- case ACL_OBJECT_LANGUAGE:
+ case OBJECT_LANGUAGE:
all_privileges = ACL_ALL_RIGHTS_LANGUAGE;
errormsg = gettext_noop("invalid privilege type %s for language");
break;
- case ACL_OBJECT_LARGEOBJECT:
+ case OBJECT_LARGEOBJECT:
all_privileges = ACL_ALL_RIGHTS_LARGEOBJECT;
errormsg = gettext_noop("invalid privilege type %s for large object");
break;
- case ACL_OBJECT_NAMESPACE:
- all_privileges = ACL_ALL_RIGHTS_NAMESPACE;
+ case OBJECT_SCHEMA:
+ all_privileges = ACL_ALL_RIGHTS_SCHEMA;
errormsg = gettext_noop("invalid privilege type %s for schema");
break;
- case ACL_OBJECT_PROCEDURE:
+ case OBJECT_PROCEDURE:
all_privileges = ACL_ALL_RIGHTS_FUNCTION;
errormsg = gettext_noop("invalid privilege type %s for procedure");
break;
- case ACL_OBJECT_ROUTINE:
+ case OBJECT_ROUTINE:
all_privileges = ACL_ALL_RIGHTS_FUNCTION;
errormsg = gettext_noop("invalid privilege type %s for routine");
break;
- case ACL_OBJECT_TABLESPACE:
+ case OBJECT_TABLESPACE:
all_privileges = ACL_ALL_RIGHTS_TABLESPACE;
errormsg = gettext_noop("invalid privilege type %s for tablespace");
break;
- case ACL_OBJECT_TYPE:
+ case OBJECT_TYPE:
all_privileges = ACL_ALL_RIGHTS_TYPE;
errormsg = gettext_noop("invalid privilege type %s for type");
break;
- case ACL_OBJECT_FDW:
+ case OBJECT_FDW:
all_privileges = ACL_ALL_RIGHTS_FDW;
errormsg = gettext_noop("invalid privilege type %s for foreign-data wrapper");
break;
- case ACL_OBJECT_FOREIGN_SERVER:
+ case OBJECT_FOREIGN_SERVER:
all_privileges = ACL_ALL_RIGHTS_FOREIGN_SERVER;
errormsg = gettext_noop("invalid privilege type %s for foreign server");
break;
*/
if (privnode->cols)
{
- if (stmt->objtype != ACL_OBJECT_RELATION)
+ if (stmt->objtype != OBJECT_TABLE)
ereport(ERROR,
(errcode(ERRCODE_INVALID_GRANT_OPERATION),
errmsg("column privileges are only valid for relations")));
{
switch (istmt->objtype)
{
- case ACL_OBJECT_RELATION:
- case ACL_OBJECT_SEQUENCE:
+ case OBJECT_TABLE:
+ case OBJECT_SEQUENCE:
ExecGrant_Relation(istmt);
break;
- case ACL_OBJECT_DATABASE:
+ case OBJECT_DATABASE:
ExecGrant_Database(istmt);
break;
- case ACL_OBJECT_DOMAIN:
- case ACL_OBJECT_TYPE:
+ case OBJECT_DOMAIN:
+ case OBJECT_TYPE:
ExecGrant_Type(istmt);
break;
- case ACL_OBJECT_FDW:
+ case OBJECT_FDW:
ExecGrant_Fdw(istmt);
break;
- case ACL_OBJECT_FOREIGN_SERVER:
+ case OBJECT_FOREIGN_SERVER:
ExecGrant_ForeignServer(istmt);
break;
- case ACL_OBJECT_FUNCTION:
- case ACL_OBJECT_PROCEDURE:
- case ACL_OBJECT_ROUTINE:
+ case OBJECT_FUNCTION:
+ case OBJECT_PROCEDURE:
+ case OBJECT_ROUTINE:
ExecGrant_Function(istmt);
break;
- case ACL_OBJECT_LANGUAGE:
+ case OBJECT_LANGUAGE:
ExecGrant_Language(istmt);
break;
- case ACL_OBJECT_LARGEOBJECT:
+ case OBJECT_LARGEOBJECT:
ExecGrant_Largeobject(istmt);
break;
- case ACL_OBJECT_NAMESPACE:
+ case OBJECT_SCHEMA:
ExecGrant_Namespace(istmt);
break;
- case ACL_OBJECT_TABLESPACE:
+ case OBJECT_TABLESPACE:
ExecGrant_Tablespace(istmt);
break;
default:
* the functions a chance to adjust the istmt with privileges actually
* granted.
*/
- if (EventTriggerSupportsGrantObjectType(istmt->objtype))
+ if (EventTriggerSupportsObjectType(istmt->objtype))
EventTriggerCollectGrant(istmt);
}
* to fail.
*/
static List *
-objectNamesToOids(GrantObjectType objtype, List *objnames)
+objectNamesToOids(ObjectType objtype, List *objnames)
{
List *objects = NIL;
ListCell *cell;
switch (objtype)
{
- case ACL_OBJECT_RELATION:
- case ACL_OBJECT_SEQUENCE:
+ case OBJECT_TABLE:
+ case OBJECT_SEQUENCE:
foreach(cell, objnames)
{
RangeVar *relvar = (RangeVar *) lfirst(cell);
objects = lappend_oid(objects, relOid);
}
break;
- case ACL_OBJECT_DATABASE:
+ case OBJECT_DATABASE:
foreach(cell, objnames)
{
char *dbname = strVal(lfirst(cell));
objects = lappend_oid(objects, dbid);
}
break;
- case ACL_OBJECT_DOMAIN:
- case ACL_OBJECT_TYPE:
+ case OBJECT_DOMAIN:
+ case OBJECT_TYPE:
foreach(cell, objnames)
{
List *typname = (List *) lfirst(cell);
objects = lappend_oid(objects, oid);
}
break;
- case ACL_OBJECT_FUNCTION:
+ case OBJECT_FUNCTION:
foreach(cell, objnames)
{
ObjectWithArgs *func = (ObjectWithArgs *) lfirst(cell);
objects = lappend_oid(objects, funcid);
}
break;
- case ACL_OBJECT_LANGUAGE:
+ case OBJECT_LANGUAGE:
foreach(cell, objnames)
{
char *langname = strVal(lfirst(cell));
objects = lappend_oid(objects, oid);
}
break;
- case ACL_OBJECT_LARGEOBJECT:
+ case OBJECT_LARGEOBJECT:
foreach(cell, objnames)
{
Oid lobjOid = oidparse(lfirst(cell));
objects = lappend_oid(objects, lobjOid);
}
break;
- case ACL_OBJECT_NAMESPACE:
+ case OBJECT_SCHEMA:
foreach(cell, objnames)
{
char *nspname = strVal(lfirst(cell));
objects = lappend_oid(objects, oid);
}
break;
- case ACL_OBJECT_PROCEDURE:
+ case OBJECT_PROCEDURE:
foreach(cell, objnames)
{
ObjectWithArgs *func = (ObjectWithArgs *) lfirst(cell);
objects = lappend_oid(objects, procid);
}
break;
- case ACL_OBJECT_ROUTINE:
+ case OBJECT_ROUTINE:
foreach(cell, objnames)
{
ObjectWithArgs *func = (ObjectWithArgs *) lfirst(cell);
objects = lappend_oid(objects, routid);
}
break;
- case ACL_OBJECT_TABLESPACE:
+ case OBJECT_TABLESPACE:
foreach(cell, objnames)
{
char *spcname = strVal(lfirst(cell));
objects = lappend_oid(objects, spcoid);
}
break;
- case ACL_OBJECT_FDW:
+ case OBJECT_FDW:
foreach(cell, objnames)
{
char *fdwname = strVal(lfirst(cell));
objects = lappend_oid(objects, fdwid);
}
break;
- case ACL_OBJECT_FOREIGN_SERVER:
+ case OBJECT_FOREIGN_SERVER:
foreach(cell, objnames)
{
char *srvname = strVal(lfirst(cell));
* no privilege checking on the individual objects here.
*/
static List *
-objectsInSchemaToOids(GrantObjectType objtype, List *nspnames)
+objectsInSchemaToOids(ObjectType objtype, List *nspnames)
{
List *objects = NIL;
ListCell *cell;
switch (objtype)
{
- case ACL_OBJECT_RELATION:
+ case OBJECT_TABLE:
objs = getRelationsInNamespace(namespaceId, RELKIND_RELATION);
objects = list_concat(objects, objs);
objs = getRelationsInNamespace(namespaceId, RELKIND_VIEW);
objs = getRelationsInNamespace(namespaceId, RELKIND_PARTITIONED_TABLE);
objects = list_concat(objects, objs);
break;
- case ACL_OBJECT_SEQUENCE:
+ case OBJECT_SEQUENCE:
objs = getRelationsInNamespace(namespaceId, RELKIND_SEQUENCE);
objects = list_concat(objects, objs);
break;
- case ACL_OBJECT_FUNCTION:
- case ACL_OBJECT_PROCEDURE:
- case ACL_OBJECT_ROUTINE:
+ case OBJECT_FUNCTION:
+ case OBJECT_PROCEDURE:
+ case OBJECT_ROUTINE:
{
ScanKeyData key[2];
int keycount;
* When looking for procedures, check for return type ==0.
* When looking for routines, don't check the return type.
*/
- if (objtype == ACL_OBJECT_FUNCTION)
+ if (objtype == OBJECT_FUNCTION)
ScanKeyInit(&key[keycount++],
Anum_pg_proc_prorettype,
BTEqualStrategyNumber, F_OIDNE,
InvalidOid);
- else if (objtype == ACL_OBJECT_PROCEDURE)
+ else if (objtype == OBJECT_PROCEDURE)
ScanKeyInit(&key[keycount++],
Anum_pg_proc_prorettype,
BTEqualStrategyNumber, F_OIDEQ,
*/
switch (action->objtype)
{
- case ACL_OBJECT_RELATION:
+ case OBJECT_TABLE:
all_privileges = ACL_ALL_RIGHTS_RELATION;
errormsg = gettext_noop("invalid privilege type %s for relation");
break;
- case ACL_OBJECT_SEQUENCE:
+ case OBJECT_SEQUENCE:
all_privileges = ACL_ALL_RIGHTS_SEQUENCE;
errormsg = gettext_noop("invalid privilege type %s for sequence");
break;
- case ACL_OBJECT_FUNCTION:
+ case OBJECT_FUNCTION:
all_privileges = ACL_ALL_RIGHTS_FUNCTION;
errormsg = gettext_noop("invalid privilege type %s for function");
break;
- case ACL_OBJECT_PROCEDURE:
+ case OBJECT_PROCEDURE:
all_privileges = ACL_ALL_RIGHTS_FUNCTION;
errormsg = gettext_noop("invalid privilege type %s for procedure");
break;
- case ACL_OBJECT_ROUTINE:
+ case OBJECT_ROUTINE:
all_privileges = ACL_ALL_RIGHTS_FUNCTION;
errormsg = gettext_noop("invalid privilege type %s for routine");
break;
- case ACL_OBJECT_TYPE:
+ case OBJECT_TYPE:
all_privileges = ACL_ALL_RIGHTS_TYPE;
errormsg = gettext_noop("invalid privilege type %s for type");
break;
- case ACL_OBJECT_NAMESPACE:
- all_privileges = ACL_ALL_RIGHTS_NAMESPACE;
+ case OBJECT_SCHEMA:
+ all_privileges = ACL_ALL_RIGHTS_SCHEMA;
errormsg = gettext_noop("invalid privilege type %s for schema");
break;
default:
*/
switch (iacls->objtype)
{
- case ACL_OBJECT_RELATION:
+ case OBJECT_TABLE:
objtype = DEFACLOBJ_RELATION;
if (iacls->all_privs && this_privileges == ACL_NO_RIGHTS)
this_privileges = ACL_ALL_RIGHTS_RELATION;
break;
- case ACL_OBJECT_SEQUENCE:
+ case OBJECT_SEQUENCE:
objtype = DEFACLOBJ_SEQUENCE;
if (iacls->all_privs && this_privileges == ACL_NO_RIGHTS)
this_privileges = ACL_ALL_RIGHTS_SEQUENCE;
break;
- case ACL_OBJECT_FUNCTION:
+ case OBJECT_FUNCTION:
objtype = DEFACLOBJ_FUNCTION;
if (iacls->all_privs && this_privileges == ACL_NO_RIGHTS)
this_privileges = ACL_ALL_RIGHTS_FUNCTION;
break;
- case ACL_OBJECT_TYPE:
+ case OBJECT_TYPE:
objtype = DEFACLOBJ_TYPE;
if (iacls->all_privs && this_privileges == ACL_NO_RIGHTS)
this_privileges = ACL_ALL_RIGHTS_TYPE;
break;
- case ACL_OBJECT_NAMESPACE:
+ case OBJECT_SCHEMA:
if (OidIsValid(iacls->nspid))
ereport(ERROR,
(errcode(ERRCODE_INVALID_GRANT_OPERATION),
errmsg("cannot use IN SCHEMA clause when using GRANT/REVOKE ON SCHEMAS")));
objtype = DEFACLOBJ_NAMESPACE;
if (iacls->all_privs && this_privileges == ACL_NO_RIGHTS)
- this_privileges = ACL_ALL_RIGHTS_NAMESPACE;
+ this_privileges = ACL_ALL_RIGHTS_SCHEMA;
break;
default:
switch (pg_default_acl_tuple->defaclobjtype)
{
case DEFACLOBJ_RELATION:
- iacls.objtype = ACL_OBJECT_RELATION;
+ iacls.objtype = OBJECT_TABLE;
break;
case DEFACLOBJ_SEQUENCE:
- iacls.objtype = ACL_OBJECT_SEQUENCE;
+ iacls.objtype = OBJECT_SEQUENCE;
break;
case DEFACLOBJ_FUNCTION:
- iacls.objtype = ACL_OBJECT_FUNCTION;
+ iacls.objtype = OBJECT_FUNCTION;
break;
case DEFACLOBJ_TYPE:
- iacls.objtype = ACL_OBJECT_TYPE;
+ iacls.objtype = OBJECT_TYPE;
break;
case DEFACLOBJ_NAMESPACE:
- iacls.objtype = ACL_OBJECT_NAMESPACE;
+ iacls.objtype = OBJECT_SCHEMA;
break;
default:
/* Shouldn't get here */
switch (classid)
{
case RelationRelationId:
- /* it's OK to use RELATION for a sequence */
- istmt.objtype = ACL_OBJECT_RELATION;
+ /* it's OK to use TABLE for a sequence */
+ istmt.objtype = OBJECT_TABLE;
break;
case DatabaseRelationId:
- istmt.objtype = ACL_OBJECT_DATABASE;
+ istmt.objtype = OBJECT_DATABASE;
break;
case TypeRelationId:
- istmt.objtype = ACL_OBJECT_TYPE;
+ istmt.objtype = OBJECT_TYPE;
break;
case ProcedureRelationId:
- istmt.objtype = ACL_OBJECT_ROUTINE;
+ istmt.objtype = OBJECT_ROUTINE;
break;
case LanguageRelationId:
- istmt.objtype = ACL_OBJECT_LANGUAGE;
+ istmt.objtype = OBJECT_LANGUAGE;
break;
case LargeObjectRelationId:
- istmt.objtype = ACL_OBJECT_LARGEOBJECT;
+ istmt.objtype = OBJECT_LARGEOBJECT;
break;
case NamespaceRelationId:
- istmt.objtype = ACL_OBJECT_NAMESPACE;
+ istmt.objtype = OBJECT_SCHEMA;
break;
case TableSpaceRelationId:
- istmt.objtype = ACL_OBJECT_TABLESPACE;
+ istmt.objtype = OBJECT_TABLESPACE;
break;
case ForeignServerRelationId:
- istmt.objtype = ACL_OBJECT_FOREIGN_SERVER;
+ istmt.objtype = OBJECT_FOREIGN_SERVER;
break;
case ForeignDataWrapperRelationId:
- istmt.objtype = ACL_OBJECT_FDW;
+ istmt.objtype = OBJECT_FDW;
break;
default:
elog(ERROR, "unexpected object class %u", classid);
&isNull);
if (isNull)
{
- old_acl = acldefault(ACL_OBJECT_COLUMN, ownerId);
+ old_acl = acldefault(OBJECT_COLUMN, ownerId);
/* There are no old member roles according to the catalogs */
noldmembers = 0;
oldmembers = NULL;
NameStr(pg_class_tuple->relname))));
/* Used GRANT SEQUENCE on a non-sequence? */
- if (istmt->objtype == ACL_OBJECT_SEQUENCE &&
+ if (istmt->objtype == OBJECT_SEQUENCE &&
pg_class_tuple->relkind != RELKIND_SEQUENCE)
ereport(ERROR,
(errcode(ERRCODE_WRONG_OBJECT_TYPE),
* permissions. The OR of table and sequence permissions were already
* checked.
*/
- if (istmt->objtype == ACL_OBJECT_RELATION)
+ if (istmt->objtype == OBJECT_TABLE)
{
if (pg_class_tuple->relkind == RELKIND_SEQUENCE)
{
switch (pg_class_tuple->relkind)
{
case RELKIND_SEQUENCE:
- old_acl = acldefault(ACL_OBJECT_SEQUENCE, ownerId);
+ old_acl = acldefault(OBJECT_SEQUENCE, ownerId);
break;
default:
- old_acl = acldefault(ACL_OBJECT_RELATION, ownerId);
+ old_acl = acldefault(OBJECT_TABLE, ownerId);
break;
}
/* There are no old member roles according to the catalogs */
RelationGetDescr(relation), &isNull);
if (isNull)
{
- old_acl = acldefault(ACL_OBJECT_DATABASE, ownerId);
+ old_acl = acldefault(OBJECT_DATABASE, ownerId);
/* There are no old member roles according to the catalogs */
noldmembers = 0;
oldmembers = NULL;
&isNull);
if (isNull)
{
- old_acl = acldefault(ACL_OBJECT_FDW, ownerId);
+ old_acl = acldefault(OBJECT_FDW, ownerId);
/* There are no old member roles according to the catalogs */
noldmembers = 0;
oldmembers = NULL;
&isNull);
if (isNull)
{
- old_acl = acldefault(ACL_OBJECT_FOREIGN_SERVER, ownerId);
+ old_acl = acldefault(OBJECT_FOREIGN_SERVER, ownerId);
/* There are no old member roles according to the catalogs */
noldmembers = 0;
oldmembers = NULL;
&isNull);
if (isNull)
{
- old_acl = acldefault(ACL_OBJECT_FUNCTION, ownerId);
+ old_acl = acldefault(OBJECT_FUNCTION, ownerId);
/* There are no old member roles according to the catalogs */
noldmembers = 0;
oldmembers = NULL;
&isNull);
if (isNull)
{
- old_acl = acldefault(ACL_OBJECT_LANGUAGE, ownerId);
+ old_acl = acldefault(OBJECT_LANGUAGE, ownerId);
/* There are no old member roles according to the catalogs */
noldmembers = 0;
oldmembers = NULL;
RelationGetDescr(relation), &isNull);
if (isNull)
{
- old_acl = acldefault(ACL_OBJECT_LARGEOBJECT, ownerId);
+ old_acl = acldefault(OBJECT_LARGEOBJECT, ownerId);
/* There are no old member roles according to the catalogs */
noldmembers = 0;
oldmembers = NULL;
ListCell *cell;
if (istmt->all_privs && istmt->privileges == ACL_NO_RIGHTS)
- istmt->privileges = ACL_ALL_RIGHTS_NAMESPACE;
+ istmt->privileges = ACL_ALL_RIGHTS_SCHEMA;
relation = heap_open(NamespaceRelationId, RowExclusiveLock);
&isNull);
if (isNull)
{
- old_acl = acldefault(ACL_OBJECT_NAMESPACE, ownerId);
+ old_acl = acldefault(OBJECT_SCHEMA, ownerId);
/* There are no old member roles according to the catalogs */
noldmembers = 0;
oldmembers = NULL;
RelationGetDescr(relation), &isNull);
if (isNull)
{
- old_acl = acldefault(ACL_OBJECT_TABLESPACE, ownerId);
+ old_acl = acldefault(OBJECT_TABLESPACE, ownerId);
/* There are no old member roles according to the catalogs */
noldmembers = 0;
oldmembers = NULL;
errhint("Set the privileges of the element type instead.")));
/* Used GRANT DOMAIN on a non-domain? */
- if (istmt->objtype == ACL_OBJECT_DOMAIN &&
+ if (istmt->objtype == OBJECT_DOMAIN &&
pg_type_tuple->typtype != TYPTYPE_DOMAIN)
ereport(ERROR,
(errcode(ERRCODE_WRONG_OBJECT_TYPE),
switch (classForm->relkind)
{
case RELKIND_SEQUENCE:
- acl = acldefault(ACL_OBJECT_SEQUENCE, ownerId);
+ acl = acldefault(OBJECT_SEQUENCE, ownerId);
break;
default:
- acl = acldefault(ACL_OBJECT_RELATION, ownerId);
+ acl = acldefault(OBJECT_TABLE, ownerId);
break;
}
aclDatum = (Datum) 0;
if (isNull)
{
/* No ACL, so build default ACL */
- acl = acldefault(ACL_OBJECT_DATABASE, ownerId);
+ acl = acldefault(OBJECT_DATABASE, ownerId);
aclDatum = (Datum) 0;
}
else
if (isNull)
{
/* No ACL, so build default ACL */
- acl = acldefault(ACL_OBJECT_FUNCTION, ownerId);
+ acl = acldefault(OBJECT_FUNCTION, ownerId);
aclDatum = (Datum) 0;
}
else
if (isNull)
{
/* No ACL, so build default ACL */
- acl = acldefault(ACL_OBJECT_LANGUAGE, ownerId);
+ acl = acldefault(OBJECT_LANGUAGE, ownerId);
aclDatum = (Datum) 0;
}
else
if (isNull)
{
/* No ACL, so build default ACL */
- acl = acldefault(ACL_OBJECT_LARGEOBJECT, ownerId);
+ acl = acldefault(OBJECT_LARGEOBJECT, ownerId);
aclDatum = (Datum) 0;
}
else
{
if (pg_database_aclcheck(MyDatabaseId, roleid,
ACL_CREATE_TEMP) == ACLCHECK_OK)
- return mask & ACL_ALL_RIGHTS_NAMESPACE;
+ return mask & ACL_ALL_RIGHTS_SCHEMA;
else
return mask & ACL_USAGE;
}
if (isNull)
{
/* No ACL, so build default ACL */
- acl = acldefault(ACL_OBJECT_NAMESPACE, ownerId);
+ acl = acldefault(OBJECT_SCHEMA, ownerId);
aclDatum = (Datum) 0;
}
else
if (isNull)
{
/* No ACL, so build default ACL */
- acl = acldefault(ACL_OBJECT_TABLESPACE, ownerId);
+ acl = acldefault(OBJECT_TABLESPACE, ownerId);
aclDatum = (Datum) 0;
}
else
if (isNull)
{
/* No ACL, so build default ACL */
- acl = acldefault(ACL_OBJECT_FDW, ownerId);
+ acl = acldefault(OBJECT_FDW, ownerId);
aclDatum = (Datum) 0;
}
else
if (isNull)
{
/* No ACL, so build default ACL */
- acl = acldefault(ACL_OBJECT_FOREIGN_SERVER, ownerId);
+ acl = acldefault(OBJECT_FOREIGN_SERVER, ownerId);
aclDatum = (Datum) 0;
}
else
if (isNull)
{
/* No ACL, so build default ACL */
- acl = acldefault(ACL_OBJECT_TYPE, ownerId);
+ acl = acldefault(OBJECT_TYPE, ownerId);
aclDatum = (Datum) 0;
}
else
* Returns NULL if built-in system defaults should be used
*/
Acl *
-get_user_default_acl(GrantObjectType objtype, Oid ownerId, Oid nsp_oid)
+get_user_default_acl(ObjectType objtype, Oid ownerId, Oid nsp_oid)
{
Acl *result;
Acl *glob_acl;
/* Check if object type is supported in pg_default_acl */
switch (objtype)
{
- case ACL_OBJECT_RELATION:
+ case OBJECT_TABLE:
defaclobjtype = DEFACLOBJ_RELATION;
break;
- case ACL_OBJECT_SEQUENCE:
+ case OBJECT_SEQUENCE:
defaclobjtype = DEFACLOBJ_SEQUENCE;
break;
- case ACL_OBJECT_FUNCTION:
+ case OBJECT_FUNCTION:
defaclobjtype = DEFACLOBJ_FUNCTION;
break;
- case ACL_OBJECT_TYPE:
+ case OBJECT_TYPE:
defaclobjtype = DEFACLOBJ_TYPE;
break;
- case ACL_OBJECT_NAMESPACE:
+ case OBJECT_SCHEMA:
defaclobjtype = DEFACLOBJ_NAMESPACE;
break;
static void validate_ddl_tags(const char *filtervar, List *taglist);
static void validate_table_rewrite_tags(const char *filtervar, List *taglist);
static void EventTriggerInvoke(List *fn_oid_list, EventTriggerData *trigdata);
-static const char *stringify_grantobjtype(GrantObjectType objtype);
-static const char *stringify_adefprivs_objtype(GrantObjectType objtype);
+static const char *stringify_grant_objtype(ObjectType objtype);
+static const char *stringify_adefprivs_objtype(ObjectType objtype);
/*
* Create an event trigger.
return false;
}
-bool
-EventTriggerSupportsGrantObjectType(GrantObjectType objtype)
-{
- switch (objtype)
- {
- case ACL_OBJECT_DATABASE:
- case ACL_OBJECT_TABLESPACE:
- /* no support for global objects */
- return false;
-
- case ACL_OBJECT_COLUMN:
- case ACL_OBJECT_RELATION:
- case ACL_OBJECT_SEQUENCE:
- case ACL_OBJECT_DOMAIN:
- case ACL_OBJECT_FDW:
- case ACL_OBJECT_FOREIGN_SERVER:
- case ACL_OBJECT_FUNCTION:
- case ACL_OBJECT_LANGUAGE:
- case ACL_OBJECT_LARGEOBJECT:
- case ACL_OBJECT_NAMESPACE:
- case ACL_OBJECT_PROCEDURE:
- case ACL_OBJECT_ROUTINE:
- case ACL_OBJECT_TYPE:
- return true;
-
- /*
- * There's intentionally no default: case here; we want the
- * compiler to warn if a new ACL class hasn't been handled above.
- */
- }
-
- /* Shouldn't get here, but if we do, say "no support" */
- return false;
-}
-
/*
* Prepare event trigger state for a new complete query to run, if necessary;
* returns whether this was done. If it was, EventTriggerEndCompleteQuery must
values[i++] = CStringGetTextDatum(cmd->d.grant.istmt->is_grant ?
"GRANT" : "REVOKE");
/* object_type */
- values[i++] = CStringGetTextDatum(stringify_grantobjtype(
+ values[i++] = CStringGetTextDatum(stringify_grant_objtype(
cmd->d.grant.istmt->objtype));
/* schema */
nulls[i++] = true;
}
/*
- * Return the GrantObjectType as a string, as it would appear in GRANT and
+ * Return the ObjectType as a string, as it would appear in GRANT and
* REVOKE commands.
*/
static const char *
-stringify_grantobjtype(GrantObjectType objtype)
+stringify_grant_objtype(ObjectType objtype)
{
switch (objtype)
{
- case ACL_OBJECT_COLUMN:
+ case OBJECT_COLUMN:
return "COLUMN";
- case ACL_OBJECT_RELATION:
+ case OBJECT_TABLE:
return "TABLE";
- case ACL_OBJECT_SEQUENCE:
+ case OBJECT_SEQUENCE:
return "SEQUENCE";
- case ACL_OBJECT_DATABASE:
+ case OBJECT_DATABASE:
return "DATABASE";
- case ACL_OBJECT_DOMAIN:
+ case OBJECT_DOMAIN:
return "DOMAIN";
- case ACL_OBJECT_FDW:
+ case OBJECT_FDW:
return "FOREIGN DATA WRAPPER";
- case ACL_OBJECT_FOREIGN_SERVER:
+ case OBJECT_FOREIGN_SERVER:
return "FOREIGN SERVER";
- case ACL_OBJECT_FUNCTION:
+ case OBJECT_FUNCTION:
return "FUNCTION";
- case ACL_OBJECT_LANGUAGE:
+ case OBJECT_LANGUAGE:
return "LANGUAGE";
- case ACL_OBJECT_LARGEOBJECT:
+ case OBJECT_LARGEOBJECT:
return "LARGE OBJECT";
- case ACL_OBJECT_NAMESPACE:
+ case OBJECT_SCHEMA:
return "SCHEMA";
- case ACL_OBJECT_PROCEDURE:
+ case OBJECT_PROCEDURE:
return "PROCEDURE";
- case ACL_OBJECT_ROUTINE:
+ case OBJECT_ROUTINE:
return "ROUTINE";
- case ACL_OBJECT_TABLESPACE:
+ case OBJECT_TABLESPACE:
return "TABLESPACE";
- case ACL_OBJECT_TYPE:
+ case OBJECT_TYPE:
return "TYPE";
+ /* these currently aren't used */
+ case OBJECT_ACCESS_METHOD:
+ case OBJECT_AGGREGATE:
+ case OBJECT_AMOP:
+ case OBJECT_AMPROC:
+ case OBJECT_ATTRIBUTE:
+ case OBJECT_CAST:
+ case OBJECT_COLLATION:
+ case OBJECT_CONVERSION:
+ case OBJECT_DEFAULT:
+ case OBJECT_DEFACL:
+ case OBJECT_DOMCONSTRAINT:
+ case OBJECT_EVENT_TRIGGER:
+ case OBJECT_EXTENSION:
+ case OBJECT_FOREIGN_TABLE:
+ case OBJECT_INDEX:
+ case OBJECT_MATVIEW:
+ case OBJECT_OPCLASS:
+ case OBJECT_OPERATOR:
+ case OBJECT_OPFAMILY:
+ case OBJECT_POLICY:
+ case OBJECT_PUBLICATION:
+ case OBJECT_PUBLICATION_REL:
+ case OBJECT_ROLE:
+ case OBJECT_RULE:
+ case OBJECT_STATISTIC_EXT:
+ case OBJECT_SUBSCRIPTION:
+ case OBJECT_TABCONSTRAINT:
+ case OBJECT_TRANSFORM:
+ case OBJECT_TRIGGER:
+ case OBJECT_TSCONFIGURATION:
+ case OBJECT_TSDICTIONARY:
+ case OBJECT_TSPARSER:
+ case OBJECT_TSTEMPLATE:
+ case OBJECT_USER_MAPPING:
+ case OBJECT_VIEW:
+ elog(ERROR, "unsupported object type: %d", (int) objtype);
}
- elog(ERROR, "unrecognized grant object type: %d", (int) objtype);
return "???"; /* keep compiler quiet */
}
/*
- * Return the GrantObjectType as a string; as above, but use the spelling
+ * Return the ObjectType as a string; as above, but use the spelling
* in ALTER DEFAULT PRIVILEGES commands instead. Generally this is just
* the plural.
*/
static const char *
-stringify_adefprivs_objtype(GrantObjectType objtype)
+stringify_adefprivs_objtype(ObjectType objtype)
{
switch (objtype)
{
- case ACL_OBJECT_COLUMN:
+ case OBJECT_COLUMN:
return "COLUMNS";
- case ACL_OBJECT_RELATION:
+ case OBJECT_TABLE:
return "TABLES";
- case ACL_OBJECT_SEQUENCE:
+ case OBJECT_SEQUENCE:
return "SEQUENCES";
- case ACL_OBJECT_DATABASE:
+ case OBJECT_DATABASE:
return "DATABASES";
- case ACL_OBJECT_DOMAIN:
+ case OBJECT_DOMAIN:
return "DOMAINS";
- case ACL_OBJECT_FDW:
+ case OBJECT_FDW:
return "FOREIGN DATA WRAPPERS";
- case ACL_OBJECT_FOREIGN_SERVER:
+ case OBJECT_FOREIGN_SERVER:
return "FOREIGN SERVERS";
- case ACL_OBJECT_FUNCTION:
+ case OBJECT_FUNCTION:
return "FUNCTIONS";
- case ACL_OBJECT_LANGUAGE:
+ case OBJECT_LANGUAGE:
return "LANGUAGES";
- case ACL_OBJECT_LARGEOBJECT:
+ case OBJECT_LARGEOBJECT:
return "LARGE OBJECTS";
- case ACL_OBJECT_NAMESPACE:
+ case OBJECT_SCHEMA:
return "SCHEMAS";
- case ACL_OBJECT_PROCEDURE:
+ case OBJECT_PROCEDURE:
return "PROCEDURES";
- case ACL_OBJECT_ROUTINE:
+ case OBJECT_ROUTINE:
return "ROUTINES";
- case ACL_OBJECT_TABLESPACE:
+ case OBJECT_TABLESPACE:
return "TABLESPACES";
- case ACL_OBJECT_TYPE:
+ case OBJECT_TYPE:
return "TYPES";
+ /* these currently aren't used */
+ case OBJECT_ACCESS_METHOD:
+ case OBJECT_AGGREGATE:
+ case OBJECT_AMOP:
+ case OBJECT_AMPROC:
+ case OBJECT_ATTRIBUTE:
+ case OBJECT_CAST:
+ case OBJECT_COLLATION:
+ case OBJECT_CONVERSION:
+ case OBJECT_DEFAULT:
+ case OBJECT_DEFACL:
+ case OBJECT_DOMCONSTRAINT:
+ case OBJECT_EVENT_TRIGGER:
+ case OBJECT_EXTENSION:
+ case OBJECT_FOREIGN_TABLE:
+ case OBJECT_INDEX:
+ case OBJECT_MATVIEW:
+ case OBJECT_OPCLASS:
+ case OBJECT_OPERATOR:
+ case OBJECT_OPFAMILY:
+ case OBJECT_POLICY:
+ case OBJECT_PUBLICATION:
+ case OBJECT_PUBLICATION_REL:
+ case OBJECT_ROLE:
+ case OBJECT_RULE:
+ case OBJECT_STATISTIC_EXT:
+ case OBJECT_SUBSCRIPTION:
+ case OBJECT_TABCONSTRAINT:
+ case OBJECT_TRANSFORM:
+ case OBJECT_TRIGGER:
+ case OBJECT_TSCONFIGURATION:
+ case OBJECT_TSDICTIONARY:
+ case OBJECT_TSPARSER:
+ case OBJECT_TSTEMPLATE:
+ case OBJECT_USER_MAPPING:
+ case OBJECT_VIEW:
+ elog(ERROR, "unsupported object type: %d", (int) objtype);
}
- elog(ERROR, "unrecognized grant object type: %d", (int) objtype);
return "???"; /* keep compiler quiet */
}
typedef struct PrivTarget
{
GrantTargetType targtype;
- GrantObjectType objtype;
+ ObjectType objtype;
List *objs;
} PrivTarget;
{
PrivTarget *n = (PrivTarget *) palloc(sizeof(PrivTarget));
n->targtype = ACL_TARGET_OBJECT;
- n->objtype = ACL_OBJECT_RELATION;
+ n->objtype = OBJECT_TABLE;
n->objs = $1;
$$ = n;
}
{
PrivTarget *n = (PrivTarget *) palloc(sizeof(PrivTarget));
n->targtype = ACL_TARGET_OBJECT;
- n->objtype = ACL_OBJECT_RELATION;
+ n->objtype = OBJECT_TABLE;
n->objs = $2;
$$ = n;
}
{
PrivTarget *n = (PrivTarget *) palloc(sizeof(PrivTarget));
n->targtype = ACL_TARGET_OBJECT;
- n->objtype = ACL_OBJECT_SEQUENCE;
+ n->objtype = OBJECT_SEQUENCE;
n->objs = $2;
$$ = n;
}
{
PrivTarget *n = (PrivTarget *) palloc(sizeof(PrivTarget));
n->targtype = ACL_TARGET_OBJECT;
- n->objtype = ACL_OBJECT_FDW;
+ n->objtype = OBJECT_FDW;
n->objs = $4;
$$ = n;
}
{
PrivTarget *n = (PrivTarget *) palloc(sizeof(PrivTarget));
n->targtype = ACL_TARGET_OBJECT;
- n->objtype = ACL_OBJECT_FOREIGN_SERVER;
+ n->objtype = OBJECT_FOREIGN_SERVER;
n->objs = $3;
$$ = n;
}
{
PrivTarget *n = (PrivTarget *) palloc(sizeof(PrivTarget));
n->targtype = ACL_TARGET_OBJECT;
- n->objtype = ACL_OBJECT_FUNCTION;
+ n->objtype = OBJECT_FUNCTION;
n->objs = $2;
$$ = n;
}
{
PrivTarget *n = (PrivTarget *) palloc(sizeof(PrivTarget));
n->targtype = ACL_TARGET_OBJECT;
- n->objtype = ACL_OBJECT_PROCEDURE;
+ n->objtype = OBJECT_PROCEDURE;
n->objs = $2;
$$ = n;
}
{
PrivTarget *n = (PrivTarget *) palloc(sizeof(PrivTarget));
n->targtype = ACL_TARGET_OBJECT;
- n->objtype = ACL_OBJECT_ROUTINE;
+ n->objtype = OBJECT_ROUTINE;
n->objs = $2;
$$ = n;
}
{
PrivTarget *n = (PrivTarget *) palloc(sizeof(PrivTarget));
n->targtype = ACL_TARGET_OBJECT;
- n->objtype = ACL_OBJECT_DATABASE;
+ n->objtype = OBJECT_DATABASE;
n->objs = $2;
$$ = n;
}
{
PrivTarget *n = (PrivTarget *) palloc(sizeof(PrivTarget));
n->targtype = ACL_TARGET_OBJECT;
- n->objtype = ACL_OBJECT_DOMAIN;
+ n->objtype = OBJECT_DOMAIN;
n->objs = $2;
$$ = n;
}
{
PrivTarget *n = (PrivTarget *) palloc(sizeof(PrivTarget));
n->targtype = ACL_TARGET_OBJECT;
- n->objtype = ACL_OBJECT_LANGUAGE;
+ n->objtype = OBJECT_LANGUAGE;
n->objs = $2;
$$ = n;
}
{
PrivTarget *n = (PrivTarget *) palloc(sizeof(PrivTarget));
n->targtype = ACL_TARGET_OBJECT;
- n->objtype = ACL_OBJECT_LARGEOBJECT;
+ n->objtype = OBJECT_LARGEOBJECT;
n->objs = $3;
$$ = n;
}
{
PrivTarget *n = (PrivTarget *) palloc(sizeof(PrivTarget));
n->targtype = ACL_TARGET_OBJECT;
- n->objtype = ACL_OBJECT_NAMESPACE;
+ n->objtype = OBJECT_SCHEMA;
n->objs = $2;
$$ = n;
}
{
PrivTarget *n = (PrivTarget *) palloc(sizeof(PrivTarget));
n->targtype = ACL_TARGET_OBJECT;
- n->objtype = ACL_OBJECT_TABLESPACE;
+ n->objtype = OBJECT_TABLESPACE;
n->objs = $2;
$$ = n;
}
{
PrivTarget *n = (PrivTarget *) palloc(sizeof(PrivTarget));
n->targtype = ACL_TARGET_OBJECT;
- n->objtype = ACL_OBJECT_TYPE;
+ n->objtype = OBJECT_TYPE;
n->objs = $2;
$$ = n;
}
{
PrivTarget *n = (PrivTarget *) palloc(sizeof(PrivTarget));
n->targtype = ACL_TARGET_ALL_IN_SCHEMA;
- n->objtype = ACL_OBJECT_RELATION;
+ n->objtype = OBJECT_TABLE;
n->objs = $5;
$$ = n;
}
{
PrivTarget *n = (PrivTarget *) palloc(sizeof(PrivTarget));
n->targtype = ACL_TARGET_ALL_IN_SCHEMA;
- n->objtype = ACL_OBJECT_SEQUENCE;
+ n->objtype = OBJECT_SEQUENCE;
n->objs = $5;
$$ = n;
}
{
PrivTarget *n = (PrivTarget *) palloc(sizeof(PrivTarget));
n->targtype = ACL_TARGET_ALL_IN_SCHEMA;
- n->objtype = ACL_OBJECT_FUNCTION;
+ n->objtype = OBJECT_FUNCTION;
n->objs = $5;
$$ = n;
}
{
PrivTarget *n = (PrivTarget *) palloc(sizeof(PrivTarget));
n->targtype = ACL_TARGET_ALL_IN_SCHEMA;
- n->objtype = ACL_OBJECT_PROCEDURE;
+ n->objtype = OBJECT_PROCEDURE;
n->objs = $5;
$$ = n;
}
{
PrivTarget *n = (PrivTarget *) palloc(sizeof(PrivTarget));
n->targtype = ACL_TARGET_ALL_IN_SCHEMA;
- n->objtype = ACL_OBJECT_ROUTINE;
+ n->objtype = OBJECT_ROUTINE;
n->objs = $5;
$$ = n;
}
;
defacl_privilege_target:
- TABLES { $$ = ACL_OBJECT_RELATION; }
- | FUNCTIONS { $$ = ACL_OBJECT_FUNCTION; }
- | ROUTINES { $$ = ACL_OBJECT_FUNCTION; }
- | SEQUENCES { $$ = ACL_OBJECT_SEQUENCE; }
- | TYPES_P { $$ = ACL_OBJECT_TYPE; }
- | SCHEMAS { $$ = ACL_OBJECT_NAMESPACE; }
+ TABLES { $$ = OBJECT_TABLE; }
+ | FUNCTIONS { $$ = OBJECT_FUNCTION; }
+ | ROUTINES { $$ = OBJECT_FUNCTION; }
+ | SEQUENCES { $$ = OBJECT_SEQUENCE; }
+ | TYPES_P { $$ = OBJECT_TYPE; }
+ | SCHEMAS { $$ = OBJECT_SCHEMA; }
;
* absence of any pg_default_acl entry.
*/
Acl *
-acldefault(GrantObjectType objtype, Oid ownerId)
+acldefault(ObjectType objtype, Oid ownerId)
{
AclMode world_default;
AclMode owner_default;
switch (objtype)
{
- case ACL_OBJECT_COLUMN:
+ case OBJECT_COLUMN:
/* by default, columns have no extra privileges */
world_default = ACL_NO_RIGHTS;
owner_default = ACL_NO_RIGHTS;
break;
- case ACL_OBJECT_RELATION:
+ case OBJECT_TABLE:
world_default = ACL_NO_RIGHTS;
owner_default = ACL_ALL_RIGHTS_RELATION;
break;
- case ACL_OBJECT_SEQUENCE:
+ case OBJECT_SEQUENCE:
world_default = ACL_NO_RIGHTS;
owner_default = ACL_ALL_RIGHTS_SEQUENCE;
break;
- case ACL_OBJECT_DATABASE:
+ case OBJECT_DATABASE:
/* for backwards compatibility, grant some rights by default */
world_default = ACL_CREATE_TEMP | ACL_CONNECT;
owner_default = ACL_ALL_RIGHTS_DATABASE;
break;
- case ACL_OBJECT_FUNCTION:
+ case OBJECT_FUNCTION:
/* Grant EXECUTE by default, for now */
world_default = ACL_EXECUTE;
owner_default = ACL_ALL_RIGHTS_FUNCTION;
break;
- case ACL_OBJECT_LANGUAGE:
+ case OBJECT_LANGUAGE:
/* Grant USAGE by default, for now */
world_default = ACL_USAGE;
owner_default = ACL_ALL_RIGHTS_LANGUAGE;
break;
- case ACL_OBJECT_LARGEOBJECT:
+ case OBJECT_LARGEOBJECT:
world_default = ACL_NO_RIGHTS;
owner_default = ACL_ALL_RIGHTS_LARGEOBJECT;
break;
- case ACL_OBJECT_NAMESPACE:
+ case OBJECT_SCHEMA:
world_default = ACL_NO_RIGHTS;
- owner_default = ACL_ALL_RIGHTS_NAMESPACE;
+ owner_default = ACL_ALL_RIGHTS_SCHEMA;
break;
- case ACL_OBJECT_TABLESPACE:
+ case OBJECT_TABLESPACE:
world_default = ACL_NO_RIGHTS;
owner_default = ACL_ALL_RIGHTS_TABLESPACE;
break;
- case ACL_OBJECT_FDW:
+ case OBJECT_FDW:
world_default = ACL_NO_RIGHTS;
owner_default = ACL_ALL_RIGHTS_FDW;
break;
- case ACL_OBJECT_FOREIGN_SERVER:
+ case OBJECT_FOREIGN_SERVER:
world_default = ACL_NO_RIGHTS;
owner_default = ACL_ALL_RIGHTS_FOREIGN_SERVER;
break;
- case ACL_OBJECT_DOMAIN:
- case ACL_OBJECT_TYPE:
+ case OBJECT_DOMAIN:
+ case OBJECT_TYPE:
world_default = ACL_USAGE;
owner_default = ACL_ALL_RIGHTS_TYPE;
break;
/*
* SQL-accessible version of acldefault(). Hackish mapping from "char" type to
- * ACL_OBJECT_* values, but it's only used in the information schema, not
+ * OBJECT_* values, but it's only used in the information schema, not
* documented for general use.
*/
Datum
{
char objtypec = PG_GETARG_CHAR(0);
Oid owner = PG_GETARG_OID(1);
- GrantObjectType objtype = 0;
+ ObjectType objtype = 0;
switch (objtypec)
{
case 'c':
- objtype = ACL_OBJECT_COLUMN;
+ objtype = OBJECT_COLUMN;
break;
case 'r':
- objtype = ACL_OBJECT_RELATION;
+ objtype = OBJECT_TABLE;
break;
case 's':
- objtype = ACL_OBJECT_SEQUENCE;
+ objtype = OBJECT_SEQUENCE;
break;
case 'd':
- objtype = ACL_OBJECT_DATABASE;
+ objtype = OBJECT_DATABASE;
break;
case 'f':
- objtype = ACL_OBJECT_FUNCTION;
+ objtype = OBJECT_FUNCTION;
break;
case 'l':
- objtype = ACL_OBJECT_LANGUAGE;
+ objtype = OBJECT_LANGUAGE;
break;
case 'L':
- objtype = ACL_OBJECT_LARGEOBJECT;
+ objtype = OBJECT_LARGEOBJECT;
break;
case 'n':
- objtype = ACL_OBJECT_NAMESPACE;
+ objtype = OBJECT_SCHEMA;
break;
case 't':
- objtype = ACL_OBJECT_TABLESPACE;
+ objtype = OBJECT_TABLESPACE;
break;
case 'F':
- objtype = ACL_OBJECT_FDW;
+ objtype = OBJECT_FDW;
break;
case 'S':
- objtype = ACL_OBJECT_FOREIGN_SERVER;
+ objtype = OBJECT_FOREIGN_SERVER;
break;
case 'T':
- objtype = ACL_OBJECT_TYPE;
+ objtype = OBJECT_TYPE;
break;
default:
elog(ERROR, "unrecognized objtype abbreviation: %c", objtypec);
projects / postgresql.git / commitdiff