pg_shdepend.c File Reference

#include "postgres.h"
#include "access/genam.h"
#include "access/htup_details.h"
#include "access/table.h"
#include "access/xact.h"
#include "catalog/catalog.h"
#include "catalog/dependency.h"
#include "catalog/indexing.h"
#include "catalog/pg_authid.h"
#include "catalog/pg_auth_members.h"
#include "catalog/pg_collation.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_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_shdepend.h"
#include "catalog/pg_statistic_ext.h"
#include "catalog/pg_subscription.h"
#include "catalog/pg_tablespace.h"
#include "catalog/pg_ts_config.h"
#include "catalog/pg_ts_dict.h"
#include "catalog/pg_type.h"
#include "catalog/pg_user_mapping.h"
#include "commands/alter.h"
#include "commands/dbcommands.h"
#include "commands/defrem.h"
#include "commands/event_trigger.h"
#include "commands/policy.h"
#include "commands/publicationcmds.h"
#include "commands/schemacmds.h"
#include "commands/subscriptioncmds.h"
#include "commands/tablecmds.h"
#include "commands/tablespace.h"
#include "commands/typecmds.h"
#include "miscadmin.h"
#include "storage/lmgr.h"
#include "utils/acl.h"
#include "utils/fmgroids.h"
#include "utils/memutils.h"
#include "utils/syscache.h"

Include dependency graph for pg_shdepend.c:

Go to the source code of this file.

Data Structures
struct	ShDependObjectInfo
struct	remoteDep

Macros
#define	MAX_REPORTED_DEPS   100

Enumerations
enum	SharedDependencyObjectType { LOCAL_OBJECT , SHARED_OBJECT , REMOTE_OBJECT }

Functions
static void	getOidListDiff (Oid *list1, int *nlist1, Oid *list2, int *nlist2)
static Oid	classIdGetDbId (Oid classId)
static void	shdepChangeDep (Relation sdepRel, Oid classid, Oid objid, int32 objsubid, Oid refclassid, Oid refobjid, SharedDependencyType deptype)
static void	shdepAddDependency (Relation sdepRel, Oid classId, Oid objectId, int32 objsubId, Oid refclassId, Oid refobjId, SharedDependencyType deptype)
static void	shdepDropDependency (Relation sdepRel, Oid classId, Oid objectId, int32 objsubId, bool drop_subobjects, Oid refclassId, Oid refobjId, SharedDependencyType deptype)
static void	storeObjectDescription (StringInfo descs, SharedDependencyObjectType type, ObjectAddress *object, SharedDependencyType deptype, int count)
void	recordSharedDependencyOn (ObjectAddress *depender, ObjectAddress *referenced, SharedDependencyType deptype)
void	recordDependencyOnOwner (Oid classId, Oid objectId, Oid owner)
void	changeDependencyOnOwner (Oid classId, Oid objectId, Oid newOwnerId)
void	recordDependencyOnTablespace (Oid classId, Oid objectId, Oid tablespace)
void	changeDependencyOnTablespace (Oid classId, Oid objectId, Oid newTablespaceId)
void	updateAclDependencies (Oid classId, Oid objectId, int32 objsubId, Oid ownerId, int noldmembers, Oid *oldmembers, int nnewmembers, Oid *newmembers)
static int	shared_dependency_comparator (const void *a, const void *b)
bool	checkSharedDependencies (Oid classId, Oid objectId, char **detail_msg, char **detail_log_msg)
void	copyTemplateDependencies (Oid templateDbId, Oid newDbId)
void	dropDatabaseDependencies (Oid databaseId)
void	deleteSharedDependencyRecordsFor (Oid classId, Oid objectId, int32 objectSubId)
void	shdepLockAndCheckObject (Oid classId, Oid objectId)
void	shdepDropOwned (List *roleids, DropBehavior behavior)
void	shdepReassignOwned (List *roleids, Oid newrole)

Macro Definition Documentation

MAX_REPORTED_DEPS

#define MAX_REPORTED_DEPS   100

Enumeration Type Documentation

SharedDependencyObjectType

enum SharedDependencyObjectType

Enumerator
LOCAL_OBJECT
SHARED_OBJECT
REMOTE_OBJECT

Definition at line 67 of file pg_shdepend.c.

{
    LOCAL_OBJECT,
    SHARED_OBJECT,
    REMOTE_OBJECT,
} SharedDependencyObjectType;

Function Documentation

changeDependencyOnOwner()

void changeDependencyOnOwner	(	Oid	classId,
		Oid	objectId,
		Oid	newOwnerId
	)

Definition at line 308 of file pg_shdepend.c.

{
    Relation    sdepRel;
 
    sdepRel = table_open(SharedDependRelationId, RowExclusiveLock);
 
    /* Adjust the SHARED_DEPENDENCY_OWNER entry */
    shdepChangeDep(sdepRel,
                   classId, objectId, 0,
                   AuthIdRelationId, newOwnerId,
                   SHARED_DEPENDENCY_OWNER);
 
    /*----------
     * There should never be a SHARED_DEPENDENCY_ACL entry for the owner,
     * so get rid of it if there is one.  This can happen if the new owner
     * was previously granted some rights to the object.
     *
     * This step is analogous to aclnewowner's removal of duplicate entries
     * in the ACL.  We have to do it to handle this scenario:
     *      A grants some rights on an object to B
     *      ALTER OWNER changes the object's owner to B
     *      ALTER OWNER changes the object's owner to C
     * The third step would remove all mention of B from the object's ACL,
     * but we'd still have a SHARED_DEPENDENCY_ACL for B if we did not do
     * things this way.
     *
     * The rule against having a SHARED_DEPENDENCY_ACL entry for the owner
     * allows us to fix things up in just this one place, without having
     * to make the various ALTER OWNER routines each know about it.
     *----------
     */
    shdepDropDependency(sdepRel, classId, objectId, 0, true,
                        AuthIdRelationId, newOwnerId,
                        SHARED_DEPENDENCY_ACL);
 
    table_close(sdepRel, RowExclusiveLock);
}

References RowExclusiveLock, SHARED_DEPENDENCY_ACL, SHARED_DEPENDENCY_OWNER, shdepChangeDep(), shdepDropDependency(), table_close(), and table_open().

Referenced by AlterDatabaseOwner(), AlterEventTriggerOwner_internal(), AlterForeignDataWrapperOwner_internal(), AlterForeignServerOwner_internal(), AlterObjectOwner_internal(), AlterPublicationOwner_internal(), AlterSchemaOwner_internal(), AlterSubscriptionOwner_internal(), AlterTypeOwner_oid(), and ATExecChangeOwner().

changeDependencyOnTablespace()

void changeDependencyOnTablespace	(	Oid	classId,
		Oid	objectId,
		Oid	newTablespaceId
	)

Definition at line 377 of file pg_shdepend.c.

{
    Relation    sdepRel;
 
    sdepRel = table_open(SharedDependRelationId, RowExclusiveLock);
 
    if (newTablespaceId != DEFAULTTABLESPACE_OID &&
        newTablespaceId != InvalidOid)
        shdepChangeDep(sdepRel,
                       classId, objectId, 0,
                       TableSpaceRelationId, newTablespaceId,
                       SHARED_DEPENDENCY_TABLESPACE);
    else
        shdepDropDependency(sdepRel,
                            classId, objectId, 0, true,
                            InvalidOid, InvalidOid,
                            SHARED_DEPENDENCY_INVALID);
 
    table_close(sdepRel, RowExclusiveLock);
}

References InvalidOid, RowExclusiveLock, SHARED_DEPENDENCY_INVALID, SHARED_DEPENDENCY_TABLESPACE, shdepChangeDep(), shdepDropDependency(), table_close(), and table_open().

Referenced by SetRelationTableSpace().

checkSharedDependencies()

bool checkSharedDependencies	(	Oid	classId,
		Oid	objectId,
		char **	detail_msg,
		char **	detail_log_msg
	)

Definition at line 626 of file pg_shdepend.c.

{
    Relation    sdepRel;
    ScanKeyData key[2];
    SysScanDesc scan;
    HeapTuple   tup;
    int         numReportedDeps = 0;
    int         numNotReportedDeps = 0;
    int         numNotReportedDbs = 0;
    List       *remDeps = NIL;
    ListCell   *cell;
    ObjectAddress object;
    ShDependObjectInfo *objects;
    int         numobjects;
    int         allocedobjects;
    StringInfoData descs;
    StringInfoData alldescs;
 
    /* This case can be dispatched quickly */
    if (IsPinnedObject(classId, objectId))
    {
        object.classId = classId;
        object.objectId = objectId;
        object.objectSubId = 0;
        ereport(ERROR,
                (errcode(ERRCODE_DEPENDENT_OBJECTS_STILL_EXIST),
                 errmsg("cannot drop %s because it is required by the database system",
                        getObjectDescription(&object, false))));
    }
 
    /*
     * We limit the number of dependencies reported to the client to
     * MAX_REPORTED_DEPS, since client software may not deal well with
     * enormous error strings.  The server log always gets a full report.
     *
     * For stability of regression test results, we sort local and shared
     * objects by OID before reporting them.  We don't worry about the order
     * in which other databases are reported, though.
     */
#define MAX_REPORTED_DEPS 100
 
    allocedobjects = 128;       /* arbitrary initial array size */
    objects = (ShDependObjectInfo *)
        palloc(allocedobjects * sizeof(ShDependObjectInfo));
    numobjects = 0;
    initStringInfo(&descs);
    initStringInfo(&alldescs);
 
    sdepRel = table_open(SharedDependRelationId, AccessShareLock);
 
    ScanKeyInit(&key[0],
                Anum_pg_shdepend_refclassid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(classId));
    ScanKeyInit(&key[1],
                Anum_pg_shdepend_refobjid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(objectId));
 
    scan = systable_beginscan(sdepRel, SharedDependReferenceIndexId, true,
                              NULL, 2, key);
 
    while (HeapTupleIsValid(tup = systable_getnext(scan)))
    {
        Form_pg_shdepend sdepForm = (Form_pg_shdepend) GETSTRUCT(tup);
 
        object.classId = sdepForm->classid;
        object.objectId = sdepForm->objid;
        object.objectSubId = sdepForm->objsubid;
 
        /*
         * If it's a dependency local to this database or it's a shared
         * object, add it to the objects array.
         *
         * If it's a remote dependency, keep track of it so we can report the
         * number of them later.
         */
        if (sdepForm->dbid == MyDatabaseId ||
            sdepForm->dbid == InvalidOid)
        {
            if (numobjects >= allocedobjects)
            {
                allocedobjects *= 2;
                objects = (ShDependObjectInfo *)
                    repalloc(objects,
                             allocedobjects * sizeof(ShDependObjectInfo));
            }
            objects[numobjects].object = object;
            objects[numobjects].deptype = sdepForm->deptype;
            objects[numobjects].objtype = (sdepForm->dbid == MyDatabaseId) ?
                LOCAL_OBJECT : SHARED_OBJECT;
            numobjects++;
        }
        else
        {
            /* It's not local nor shared, so it must be remote. */
            remoteDep  *dep;
            bool        stored = false;
 
            /*
             * XXX this info is kept on a simple List.  Maybe it's not good
             * for performance, but using a hash table seems needlessly
             * complex.  The expected number of databases is not high anyway,
             * I suppose.
             */
            foreach(cell, remDeps)
            {
                dep = lfirst(cell);
                if (dep->dbOid == sdepForm->dbid)
                {
                    dep->count++;
                    stored = true;
                    break;
                }
            }
            if (!stored)
            {
                dep = (remoteDep *) palloc(sizeof(remoteDep));
                dep->dbOid = sdepForm->dbid;
                dep->count = 1;
                remDeps = lappend(remDeps, dep);
            }
        }
    }
 
    systable_endscan(scan);
 
    table_close(sdepRel, AccessShareLock);
 
    /*
     * Sort and report local and shared objects.
     */
    if (numobjects > 1)
        qsort(objects, numobjects,
              sizeof(ShDependObjectInfo), shared_dependency_comparator);
 
    for (int i = 0; i < numobjects; i++)
    {
        if (numReportedDeps < MAX_REPORTED_DEPS)
        {
            numReportedDeps++;
            storeObjectDescription(&descs,
                                   objects[i].objtype,
                                   &objects[i].object,
                                   objects[i].deptype,
                                   0);
        }
        else
            numNotReportedDeps++;
        storeObjectDescription(&alldescs,
                               objects[i].objtype,
                               &objects[i].object,
                               objects[i].deptype,
                               0);
    }
 
    /*
     * Summarize dependencies in remote databases.
     */
    foreach(cell, remDeps)
    {
        remoteDep  *dep = lfirst(cell);
 
        object.classId = DatabaseRelationId;
        object.objectId = dep->dbOid;
        object.objectSubId = 0;
 
        if (numReportedDeps < MAX_REPORTED_DEPS)
        {
            numReportedDeps++;
            storeObjectDescription(&descs, REMOTE_OBJECT, &object,
                                   SHARED_DEPENDENCY_INVALID, dep->count);
        }
        else
            numNotReportedDbs++;
        storeObjectDescription(&alldescs, REMOTE_OBJECT, &object,
                               SHARED_DEPENDENCY_INVALID, dep->count);
    }
 
    pfree(objects);
    list_free_deep(remDeps);
 
    if (descs.len == 0)
    {
        pfree(descs.data);
        pfree(alldescs.data);
        *detail_msg = *detail_log_msg = NULL;
        return false;
    }
 
    if (numNotReportedDeps > 0)
        appendStringInfo(&descs, ngettext("\nand %d other object "
                                          "(see server log for list)",
                                          "\nand %d other objects "
                                          "(see server log for list)",
                                          numNotReportedDeps),
                         numNotReportedDeps);
    if (numNotReportedDbs > 0)
        appendStringInfo(&descs, ngettext("\nand objects in %d other database "
                                          "(see server log for list)",
                                          "\nand objects in %d other databases "
                                          "(see server log for list)",
                                          numNotReportedDbs),
                         numNotReportedDbs);
 
    *detail_msg = descs.data;
    *detail_log_msg = alldescs.data;
    return true;
}

References AccessShareLock, appendStringInfo(), BTEqualStrategyNumber, remoteDep::count, StringInfoData::data, remoteDep::dbOid, ShDependObjectInfo::deptype, ereport, errcode(), errmsg(), ERROR, getObjectDescription(), GETSTRUCT, HeapTupleIsValid, i, initStringInfo(), InvalidOid, IsPinnedObject(), sort-test::key, lappend(), StringInfoData::len, lfirst, list_free_deep(), LOCAL_OBJECT, MAX_REPORTED_DEPS, MyDatabaseId, ngettext, NIL, ShDependObjectInfo::object, ObjectIdGetDatum(), ShDependObjectInfo::objtype, palloc(), pfree(), qsort, REMOTE_OBJECT, repalloc(), ScanKeyInit(), shared_dependency_comparator(), SHARED_DEPENDENCY_INVALID, SHARED_OBJECT, storeObjectDescription(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), and table_open().

Referenced by DropRole(), and DropTableSpace().

classIdGetDbId()

static Oid classIdGetDbId ( Oid  classId )

static

Definition at line 1140 of file pg_shdepend.c.

{
    Oid         dbId;
 
    if (IsSharedRelation(classId))
        dbId = InvalidOid;
    else
        dbId = MyDatabaseId;
 
    return dbId;
}

References InvalidOid, IsSharedRelation(), and MyDatabaseId.

Referenced by shdepAddDependency(), shdepChangeDep(), and shdepDropDependency().

copyTemplateDependencies()

void copyTemplateDependencies	(	Oid	templateDbId,
		Oid	newDbId
	)

Definition at line 845 of file pg_shdepend.c.

{
    Relation    sdepRel;
    TupleDesc   sdepDesc;
    ScanKeyData key[1];
    SysScanDesc scan;
    HeapTuple   tup;
    CatalogIndexState indstate;
    TupleTableSlot **slot;
    int         max_slots,
                slot_init_count,
                slot_stored_count;
 
    sdepRel = table_open(SharedDependRelationId, RowExclusiveLock);
    sdepDesc = RelationGetDescr(sdepRel);
 
    /*
     * Allocate the slots to use, but delay costly initialization until we
     * know that they will be used.
     */
    max_slots = MAX_CATALOG_MULTI_INSERT_BYTES / sizeof(FormData_pg_shdepend);
    slot = palloc(sizeof(TupleTableSlot *) * max_slots);
 
    indstate = CatalogOpenIndexes(sdepRel);
 
    /* Scan all entries with dbid = templateDbId */
    ScanKeyInit(&key[0],
                Anum_pg_shdepend_dbid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(templateDbId));
 
    scan = systable_beginscan(sdepRel, SharedDependDependerIndexId, true,
                              NULL, 1, key);
 
    /* number of slots currently storing tuples */
    slot_stored_count = 0;
    /* number of slots currently initialized */
    slot_init_count = 0;
 
    /*
     * Copy the entries of the original database, changing the database Id to
     * that of the new database.  Note that because we are not copying rows
     * with dbId == 0 (ie, rows describing dependent shared objects) we won't
     * copy the ownership dependency of the template database itself; this is
     * what we want.
     */
    while (HeapTupleIsValid(tup = systable_getnext(scan)))
    {
        Form_pg_shdepend shdep;
 
        if (slot_init_count < max_slots)
        {
            slot[slot_stored_count] = MakeSingleTupleTableSlot(sdepDesc, &TTSOpsHeapTuple);
            slot_init_count++;
        }
 
        ExecClearTuple(slot[slot_stored_count]);
 
        memset(slot[slot_stored_count]->tts_isnull, false,
               slot[slot_stored_count]->tts_tupleDescriptor->natts * sizeof(bool));
 
        shdep = (Form_pg_shdepend) GETSTRUCT(tup);
 
        slot[slot_stored_count]->tts_values[Anum_pg_shdepend_dbid - 1] = ObjectIdGetDatum(newDbId);
        slot[slot_stored_count]->tts_values[Anum_pg_shdepend_classid - 1] = shdep->classid;
        slot[slot_stored_count]->tts_values[Anum_pg_shdepend_objid - 1] = shdep->objid;
        slot[slot_stored_count]->tts_values[Anum_pg_shdepend_objsubid - 1] = shdep->objsubid;
        slot[slot_stored_count]->tts_values[Anum_pg_shdepend_refclassid - 1] = shdep->refclassid;
        slot[slot_stored_count]->tts_values[Anum_pg_shdepend_refobjid - 1] = shdep->refobjid;
        slot[slot_stored_count]->tts_values[Anum_pg_shdepend_deptype - 1] = shdep->deptype;
 
        ExecStoreVirtualTuple(slot[slot_stored_count]);
        slot_stored_count++;
 
        /* If slots are full, insert a batch of tuples */
        if (slot_stored_count == max_slots)
        {
            CatalogTuplesMultiInsertWithInfo(sdepRel, slot, slot_stored_count, indstate);
            slot_stored_count = 0;
        }
    }
 
    /* Insert any tuples left in the buffer */
    if (slot_stored_count > 0)
        CatalogTuplesMultiInsertWithInfo(sdepRel, slot, slot_stored_count, indstate);
 
    systable_endscan(scan);
 
    CatalogCloseIndexes(indstate);
    table_close(sdepRel, RowExclusiveLock);
 
    /* Drop only the number of slots used */
    for (int i = 0; i < slot_init_count; i++)
        ExecDropSingleTupleTableSlot(slot[i]);
    pfree(slot);
}

References BTEqualStrategyNumber, CatalogCloseIndexes(), CatalogOpenIndexes(), CatalogTuplesMultiInsertWithInfo(), ExecClearTuple(), ExecDropSingleTupleTableSlot(), ExecStoreVirtualTuple(), FormData_pg_shdepend, GETSTRUCT, HeapTupleIsValid, i, sort-test::key, MakeSingleTupleTableSlot(), MAX_CATALOG_MULTI_INSERT_BYTES, ObjectIdGetDatum(), palloc(), pfree(), RelationGetDescr, RowExclusiveLock, ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), table_open(), TupleTableSlot::tts_values, and TTSOpsHeapTuple.

Referenced by createdb().

deleteSharedDependencyRecordsFor()

void deleteSharedDependencyRecordsFor	(	Oid	classId,
		Oid	objectId,
		int32	objectSubId
	)

Definition at line 997 of file pg_shdepend.c.

{
    Relation    sdepRel;
 
    sdepRel = table_open(SharedDependRelationId, RowExclusiveLock);
 
    shdepDropDependency(sdepRel, classId, objectId, objectSubId,
                        (objectSubId == 0),
                        InvalidOid, InvalidOid,
                        SHARED_DEPENDENCY_INVALID);
 
    table_close(sdepRel, RowExclusiveLock);
}

References InvalidOid, RowExclusiveLock, SHARED_DEPENDENCY_INVALID, shdepDropDependency(), table_close(), and table_open().

Referenced by AlterPolicy(), deleteOneObject(), DelRoleMems(), DropRole(), DropSubscription(), DropTableSpace(), GenerateTypeDependencies(), makeConfigurationDependencies(), makeOperatorDependencies(), and RemoveRoleFromObjectPolicy().

dropDatabaseDependencies()

void dropDatabaseDependencies

(

Oid

databaseId

)

Definition at line 949 of file pg_shdepend.c.

{
    Relation    sdepRel;
    ScanKeyData key[1];
    SysScanDesc scan;
    HeapTuple   tup;
 
    sdepRel = table_open(SharedDependRelationId, RowExclusiveLock);
 
    /*
     * First, delete all the entries that have the database Oid in the dbid
     * field.
     */
    ScanKeyInit(&key[0],
                Anum_pg_shdepend_dbid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(databaseId));
    /* We leave the other index fields unspecified */
 
    scan = systable_beginscan(sdepRel, SharedDependDependerIndexId, true,
                              NULL, 1, key);
 
    while (HeapTupleIsValid(tup = systable_getnext(scan)))
    {
        CatalogTupleDelete(sdepRel, &tup->t_self);
    }
 
    systable_endscan(scan);
 
    /* Now delete all entries corresponding to the database itself */
    shdepDropDependency(sdepRel, DatabaseRelationId, databaseId, 0, true,
                        InvalidOid, InvalidOid,
                        SHARED_DEPENDENCY_INVALID);
 
    table_close(sdepRel, RowExclusiveLock);
}

References BTEqualStrategyNumber, CatalogTupleDelete(), HeapTupleIsValid, InvalidOid, sort-test::key, ObjectIdGetDatum(), RowExclusiveLock, ScanKeyInit(), SHARED_DEPENDENCY_INVALID, shdepDropDependency(), systable_beginscan(), systable_endscan(), systable_getnext(), HeapTupleData::t_self, table_close(), and table_open().

Referenced by dropdb().

getOidListDiff()

static void getOidListDiff ( Oid *  list1, int *  nlist1, Oid *  list2, int *  nlist2  )

static

Definition at line 407 of file pg_shdepend.c.

{
    int         in1,
                in2,
                out1,
                out2;
 
    in1 = in2 = out1 = out2 = 0;
    while (in1 < *nlist1 && in2 < *nlist2)
    {
        if (list1[in1] == list2[in2])
        {
            /* skip over duplicates */
            in1++;
            in2++;
        }
        else if (list1[in1] < list2[in2])
        {
            /* list1[in1] is not in list2 */
            list1[out1++] = list1[in1++];
        }
        else
        {
            /* list2[in2] is not in list1 */
            list2[out2++] = list2[in2++];
        }
    }
 
    /* any remaining list1 entries are not in list2 */
    while (in1 < *nlist1)
    {
        list1[out1++] = list1[in1++];
    }
 
    /* any remaining list2 entries are not in list1 */
    while (in2 < *nlist2)
    {
        list2[out2++] = list2[in2++];
    }
 
    *nlist1 = out1;
    *nlist2 = out2;
}

Referenced by updateAclDependencies().

recordDependencyOnOwner()

void recordDependencyOnOwner	(	Oid	classId,
		Oid	objectId,
		Oid	owner
	)

Definition at line 160 of file pg_shdepend.c.

{
    ObjectAddress myself,
                referenced;
 
    myself.classId = classId;
    myself.objectId = objectId;
    myself.objectSubId = 0;
 
    referenced.classId = AuthIdRelationId;
    referenced.objectId = owner;
    referenced.objectSubId = 0;
 
    recordSharedDependencyOn(&myself, &referenced, SHARED_DEPENDENCY_OWNER);
}

References ObjectAddress::classId, ObjectAddress::objectId, ObjectAddress::objectSubId, recordSharedDependencyOn(), and SHARED_DEPENDENCY_OWNER.

Referenced by CollationCreate(), ConversionCreate(), createdb(), CreateForeignDataWrapper(), CreateForeignServer(), CreateOpFamily(), CreateProceduralLanguage(), CreatePublication(), CreateStatistics(), CreateSubscription(), CreateTableSpace(), CreateUserMapping(), DefineOpClass(), GenerateTypeDependencies(), heap_create_with_catalog(), insert_event_trigger_tuple(), InsertExtensionTuple(), inv_create(), makeConfigurationDependencies(), makeDictionaryDependencies(), makeOperatorDependencies(), NamespaceCreate(), ProcedureCreate(), and SetDefaultACL().

recordDependencyOnTablespace()

void recordDependencyOnTablespace	(	Oid	classId,
		Oid	objectId,
		Oid	tablespace
	)

Definition at line 356 of file pg_shdepend.c.

{
    ObjectAddress myself,
                referenced;
 
    ObjectAddressSet(myself, classId, objectId);
    ObjectAddressSet(referenced, TableSpaceRelationId, tablespace);
 
    recordSharedDependencyOn(&myself, &referenced,
                             SHARED_DEPENDENCY_TABLESPACE);
}

References ObjectAddressSet, recordSharedDependencyOn(), SHARED_DEPENDENCY_TABLESPACE, and tablespace.

Referenced by heap_create().

recordSharedDependencyOn()

void recordSharedDependencyOn	(	ObjectAddress *	depender,
		ObjectAddress *	referenced,
		SharedDependencyType	deptype
	)

Definition at line 117 of file pg_shdepend.c.

{
    Relation    sdepRel;
 
    /*
     * Objects in pg_shdepend can't have SubIds.
     */
    Assert(depender->objectSubId == 0);
    Assert(referenced->objectSubId == 0);
 
    /*
     * During bootstrap, do nothing since pg_shdepend may not exist yet.
     * initdb will fill in appropriate pg_shdepend entries after bootstrap.
     */
    if (IsBootstrapProcessingMode())
        return;
 
    sdepRel = table_open(SharedDependRelationId, RowExclusiveLock);
 
    /* If the referenced object is pinned, do nothing. */
    if (!IsPinnedObject(referenced->classId, referenced->objectId))
    {
        shdepAddDependency(sdepRel, depender->classId, depender->objectId,
                           depender->objectSubId,
                           referenced->classId, referenced->objectId,
                           deptype);
    }
 
    table_close(sdepRel, RowExclusiveLock);
}

References Assert, ObjectAddress::classId, IsBootstrapProcessingMode, IsPinnedObject(), ObjectAddress::objectId, ObjectAddress::objectSubId, RowExclusiveLock, shdepAddDependency(), table_close(), and table_open().

Referenced by AlterPolicy(), CreatePolicy(), recordDependencyOnOwner(), recordDependencyOnTablespace(), and RemoveRoleFromObjectPolicy().

shared_dependency_comparator()

static int shared_dependency_comparator ( const void *  a, const void *  b  )

static

Definition at line 560 of file pg_shdepend.c.

{
    const ShDependObjectInfo *obja = (const ShDependObjectInfo *) a;
    const ShDependObjectInfo *objb = (const ShDependObjectInfo *) b;
 
    /*
     * Primary sort key is OID ascending.
     */
    if (obja->object.objectId < objb->object.objectId)
        return -1;
    if (obja->object.objectId > objb->object.objectId)
        return 1;
 
    /*
     * Next sort on catalog ID, in case identical OIDs appear in different
     * catalogs.  Sort direction is pretty arbitrary here.
     */
    if (obja->object.classId < objb->object.classId)
        return -1;
    if (obja->object.classId > objb->object.classId)
        return 1;
 
    /*
     * Sort on object subId.
     *
     * We sort the subId as an unsigned int so that 0 (the whole object) will
     * come first.
     */
    if ((unsigned int) obja->object.objectSubId < (unsigned int) objb->object.objectSubId)
        return -1;
    if ((unsigned int) obja->object.objectSubId > (unsigned int) objb->object.objectSubId)
        return 1;
 
    /*
     * Last, sort on deptype, in case the same object has multiple dependency
     * types.  (Note that there's no need to consider objtype, as that's
     * determined by the catalog OID.)
     */
    if (obja->deptype < objb->deptype)
        return -1;
    if (obja->deptype > objb->deptype)
        return 1;
 
    return 0;
}

References a, b, ObjectAddress::classId, ShDependObjectInfo::deptype, ShDependObjectInfo::object, ObjectAddress::objectId, and ObjectAddress::objectSubId.

Referenced by checkSharedDependencies().

shdepAddDependency()

static void shdepAddDependency ( Relation  sdepRel, Oid  classId, Oid  objectId, int32  objsubId, Oid  refclassId, Oid  refobjId, SharedDependencyType  deptype  )

static

Definition at line 1019 of file pg_shdepend.c.

{
    HeapTuple   tup;
    Datum       values[Natts_pg_shdepend];
    bool        nulls[Natts_pg_shdepend];
 
    /*
     * Make sure the object doesn't go away while we record the dependency on
     * it.  DROP routines should lock the object exclusively before they check
     * shared dependencies.
     */
    shdepLockAndCheckObject(refclassId, refobjId);
 
    memset(nulls, false, sizeof(nulls));
 
    /*
     * Form the new tuple and record the dependency.
     */
    values[Anum_pg_shdepend_dbid - 1] = ObjectIdGetDatum(classIdGetDbId(classId));
    values[Anum_pg_shdepend_classid - 1] = ObjectIdGetDatum(classId);
    values[Anum_pg_shdepend_objid - 1] = ObjectIdGetDatum(objectId);
    values[Anum_pg_shdepend_objsubid - 1] = Int32GetDatum(objsubId);
 
    values[Anum_pg_shdepend_refclassid - 1] = ObjectIdGetDatum(refclassId);
    values[Anum_pg_shdepend_refobjid - 1] = ObjectIdGetDatum(refobjId);
    values[Anum_pg_shdepend_deptype - 1] = CharGetDatum(deptype);
 
    tup = heap_form_tuple(sdepRel->rd_att, values, nulls);
 
    CatalogTupleInsert(sdepRel, tup);
 
    /* clean up */
    heap_freetuple(tup);
}

References CatalogTupleInsert(), CharGetDatum(), classIdGetDbId(), heap_form_tuple(), heap_freetuple(), Int32GetDatum(), ObjectIdGetDatum(), RelationData::rd_att, shdepLockAndCheckObject(), and values.

Referenced by recordSharedDependencyOn(), and updateAclDependencies().

shdepChangeDep()

static void shdepChangeDep ( Relation  sdepRel, Oid  classid, Oid  objid, int32  objsubid, Oid  refclassid, Oid  refobjid, SharedDependencyType  deptype  )

static

Definition at line 198 of file pg_shdepend.c.

{
    Oid         dbid = classIdGetDbId(classid);
    HeapTuple   oldtup = NULL;
    HeapTuple   scantup;
    ScanKeyData key[4];
    SysScanDesc scan;
 
    /*
     * Make sure the new referenced object doesn't go away while we record the
     * dependency.
     */
    shdepLockAndCheckObject(refclassid, refobjid);
 
    /*
     * Look for a previous entry
     */
    ScanKeyInit(&key[0],
                Anum_pg_shdepend_dbid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(dbid));
    ScanKeyInit(&key[1],
                Anum_pg_shdepend_classid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(classid));
    ScanKeyInit(&key[2],
                Anum_pg_shdepend_objid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(objid));
    ScanKeyInit(&key[3],
                Anum_pg_shdepend_objsubid,
                BTEqualStrategyNumber, F_INT4EQ,
                Int32GetDatum(objsubid));
 
    scan = systable_beginscan(sdepRel, SharedDependDependerIndexId, true,
                              NULL, 4, key);
 
    while ((scantup = systable_getnext(scan)) != NULL)
    {
        /* Ignore if not of the target dependency type */
        if (((Form_pg_shdepend) GETSTRUCT(scantup))->deptype != deptype)
            continue;
        /* Caller screwed up if multiple matches */
        if (oldtup)
            elog(ERROR,
                 "multiple pg_shdepend entries for object %u/%u/%d deptype %c",
                 classid, objid, objsubid, deptype);
        oldtup = heap_copytuple(scantup);
    }
 
    systable_endscan(scan);
 
    if (IsPinnedObject(refclassid, refobjid))
    {
        /* No new entry needed, so just delete existing entry if any */
        if (oldtup)
            CatalogTupleDelete(sdepRel, &oldtup->t_self);
    }
    else if (oldtup)
    {
        /* Need to update existing entry */
        Form_pg_shdepend shForm = (Form_pg_shdepend) GETSTRUCT(oldtup);
 
        /* Since oldtup is a copy, we can just modify it in-memory */
        shForm->refclassid = refclassid;
        shForm->refobjid = refobjid;
 
        CatalogTupleUpdate(sdepRel, &oldtup->t_self, oldtup);
    }
    else
    {
        /* Need to insert new entry */
        Datum       values[Natts_pg_shdepend];
        bool        nulls[Natts_pg_shdepend];
 
        memset(nulls, false, sizeof(nulls));
 
        values[Anum_pg_shdepend_dbid - 1] = ObjectIdGetDatum(dbid);
        values[Anum_pg_shdepend_classid - 1] = ObjectIdGetDatum(classid);
        values[Anum_pg_shdepend_objid - 1] = ObjectIdGetDatum(objid);
        values[Anum_pg_shdepend_objsubid - 1] = Int32GetDatum(objsubid);
 
        values[Anum_pg_shdepend_refclassid - 1] = ObjectIdGetDatum(refclassid);
        values[Anum_pg_shdepend_refobjid - 1] = ObjectIdGetDatum(refobjid);
        values[Anum_pg_shdepend_deptype - 1] = CharGetDatum(deptype);
 
        /*
         * we are reusing oldtup just to avoid declaring a new variable, but
         * it's certainly a new tuple
         */
        oldtup = heap_form_tuple(RelationGetDescr(sdepRel), values, nulls);
        CatalogTupleInsert(sdepRel, oldtup);
    }
 
    if (oldtup)
        heap_freetuple(oldtup);
}

References BTEqualStrategyNumber, CatalogTupleDelete(), CatalogTupleInsert(), CatalogTupleUpdate(), CharGetDatum(), classIdGetDbId(), elog, ERROR, GETSTRUCT, heap_copytuple(), heap_form_tuple(), heap_freetuple(), Int32GetDatum(), IsPinnedObject(), sort-test::key, ObjectIdGetDatum(), RelationGetDescr, ScanKeyInit(), shdepLockAndCheckObject(), systable_beginscan(), systable_endscan(), systable_getnext(), HeapTupleData::t_self, and values.

Referenced by changeDependencyOnOwner(), and changeDependencyOnTablespace().

shdepDropDependency()

static void shdepDropDependency ( Relation  sdepRel, Oid  classId, Oid  objectId, int32  objsubId, bool  drop_subobjects, Oid  refclassId, Oid  refobjId, SharedDependencyType  deptype  )

static

Definition at line 1074 of file pg_shdepend.c.

{
    ScanKeyData key[4];
    int         nkeys;
    SysScanDesc scan;
    HeapTuple   tup;
 
    /* Scan for entries matching the dependent object */
    ScanKeyInit(&key[0],
                Anum_pg_shdepend_dbid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(classIdGetDbId(classId)));
    ScanKeyInit(&key[1],
                Anum_pg_shdepend_classid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(classId));
    ScanKeyInit(&key[2],
                Anum_pg_shdepend_objid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(objectId));
    if (drop_subobjects)
        nkeys = 3;
    else
    {
        ScanKeyInit(&key[3],
                    Anum_pg_shdepend_objsubid,
                    BTEqualStrategyNumber, F_INT4EQ,
                    Int32GetDatum(objsubId));
        nkeys = 4;
    }
 
    scan = systable_beginscan(sdepRel, SharedDependDependerIndexId, true,
                              NULL, nkeys, key);
 
    while (HeapTupleIsValid(tup = systable_getnext(scan)))
    {
        Form_pg_shdepend shdepForm = (Form_pg_shdepend) GETSTRUCT(tup);
 
        /* Filter entries according to additional parameters */
        if (OidIsValid(refclassId) && shdepForm->refclassid != refclassId)
            continue;
        if (OidIsValid(refobjId) && shdepForm->refobjid != refobjId)
            continue;
        if (deptype != SHARED_DEPENDENCY_INVALID &&
            shdepForm->deptype != deptype)
            continue;
 
        /* OK, delete it */
        CatalogTupleDelete(sdepRel, &tup->t_self);
    }
 
    systable_endscan(scan);
}

References BTEqualStrategyNumber, CatalogTupleDelete(), classIdGetDbId(), GETSTRUCT, HeapTupleIsValid, Int32GetDatum(), sort-test::key, ObjectIdGetDatum(), OidIsValid, ScanKeyInit(), SHARED_DEPENDENCY_INVALID, systable_beginscan(), systable_endscan(), systable_getnext(), and HeapTupleData::t_self.

Referenced by changeDependencyOnOwner(), changeDependencyOnTablespace(), deleteSharedDependencyRecordsFor(), dropDatabaseDependencies(), and updateAclDependencies().

shdepDropOwned()

void shdepDropOwned	(	List *	roleids,
		DropBehavior	behavior
	)

Definition at line 1290 of file pg_shdepend.c.

{
    Relation    sdepRel;
    ListCell   *cell;
    ObjectAddresses *deleteobjs;
 
    deleteobjs = new_object_addresses();
 
    /*
     * We don't need this strong a lock here, but we'll call routines that
     * acquire RowExclusiveLock.  Better get that right now to avoid potential
     * deadlock failures.
     */
    sdepRel = table_open(SharedDependRelationId, RowExclusiveLock);
 
    /*
     * For each role, find the dependent objects and drop them using the
     * regular (non-shared) dependency management.
     */
    foreach(cell, roleids)
    {
        Oid         roleid = lfirst_oid(cell);
        ScanKeyData key[2];
        SysScanDesc scan;
        HeapTuple   tuple;
 
        /* Doesn't work for pinned objects */
        if (IsPinnedObject(AuthIdRelationId, roleid))
        {
            ObjectAddress obj;
 
            obj.classId = AuthIdRelationId;
            obj.objectId = roleid;
            obj.objectSubId = 0;
 
            ereport(ERROR,
                    (errcode(ERRCODE_DEPENDENT_OBJECTS_STILL_EXIST),
                     errmsg("cannot drop objects owned by %s because they are "
                            "required by the database system",
                            getObjectDescription(&obj, false))));
        }
 
        ScanKeyInit(&key[0],
                    Anum_pg_shdepend_refclassid,
                    BTEqualStrategyNumber, F_OIDEQ,
                    ObjectIdGetDatum(AuthIdRelationId));
        ScanKeyInit(&key[1],
                    Anum_pg_shdepend_refobjid,
                    BTEqualStrategyNumber, F_OIDEQ,
                    ObjectIdGetDatum(roleid));
 
        scan = systable_beginscan(sdepRel, SharedDependReferenceIndexId, true,
                                  NULL, 2, key);
 
        while ((tuple = systable_getnext(scan)) != NULL)
        {
            Form_pg_shdepend sdepForm = (Form_pg_shdepend) GETSTRUCT(tuple);
            ObjectAddress obj;
 
            /*
             * We only operate on shared objects and objects in the current
             * database
             */
            if (sdepForm->dbid != MyDatabaseId &&
                sdepForm->dbid != InvalidOid)
                continue;
 
            switch (sdepForm->deptype)
            {
                    /* Shouldn't happen */
                case SHARED_DEPENDENCY_INVALID:
                    elog(ERROR, "unexpected dependency type");
                    break;
                case SHARED_DEPENDENCY_POLICY:
 
                    /*
                     * Try to remove role from policy; if unable to, remove
                     * policy.
                     */
                    if (!RemoveRoleFromObjectPolicy(roleid,
                                                    sdepForm->classid,
                                                    sdepForm->objid))
                    {
                        obj.classId = sdepForm->classid;
                        obj.objectId = sdepForm->objid;
                        obj.objectSubId = sdepForm->objsubid;
 
                        /*
                         * Acquire lock on object, then verify this dependency
                         * is still relevant.  If not, the object might have
                         * been dropped or the policy modified.  Ignore the
                         * object in that case.
                         */
                        AcquireDeletionLock(&obj, 0);
                        if (!systable_recheck_tuple(scan, tuple))
                        {
                            ReleaseDeletionLock(&obj);
                            break;
                        }
                        add_exact_object_address(&obj, deleteobjs);
                    }
                    break;
                case SHARED_DEPENDENCY_ACL:
 
                    /*
                     * Dependencies on role grants are recorded using
                     * SHARED_DEPENDENCY_ACL, but unlike a regular ACL list
                     * which stores all permissions for a particular object in
                     * a single ACL array, there's a separate catalog row for
                     * each grant - so removing the grant just means removing
                     * the entire row.
                     */
                    if (sdepForm->classid != AuthMemRelationId)
                    {
                        RemoveRoleFromObjectACL(roleid,
                                                sdepForm->classid,
                                                sdepForm->objid);
                        break;
                    }
                    /* FALLTHROUGH */
 
                case SHARED_DEPENDENCY_OWNER:
 
                    /*
                     * Save it for deletion below, if it's a local object or a
                     * role grant. Other shared objects, such as databases,
                     * should not be removed here.
                     */
                    if (sdepForm->dbid == MyDatabaseId ||
                        sdepForm->classid == AuthMemRelationId)
                    {
                        obj.classId = sdepForm->classid;
                        obj.objectId = sdepForm->objid;
                        obj.objectSubId = sdepForm->objsubid;
                        /* as above */
                        AcquireDeletionLock(&obj, 0);
                        if (!systable_recheck_tuple(scan, tuple))
                        {
                            ReleaseDeletionLock(&obj);
                            break;
                        }
                        add_exact_object_address(&obj, deleteobjs);
                    }
                    break;
            }
        }
 
        systable_endscan(scan);
    }
 
    /*
     * For stability of deletion-report ordering, sort the objects into
     * approximate reverse creation order before deletion.  (This might also
     * make the deletion go a bit faster, since there's less chance of having
     * to rearrange the objects due to dependencies.)
     */
    sort_object_addresses(deleteobjs);
 
    /* the dependency mechanism does the actual work */
    performMultipleDeletions(deleteobjs, behavior, 0);
 
    table_close(sdepRel, RowExclusiveLock);
 
    free_object_addresses(deleteobjs);
}

References AcquireDeletionLock(), add_exact_object_address(), BTEqualStrategyNumber, ObjectAddress::classId, elog, ereport, errcode(), errmsg(), ERROR, free_object_addresses(), getObjectDescription(), GETSTRUCT, InvalidOid, IsPinnedObject(), sort-test::key, lfirst_oid, MyDatabaseId, new_object_addresses(), ObjectAddress::objectId, ObjectIdGetDatum(), ObjectAddress::objectSubId, performMultipleDeletions(), ReleaseDeletionLock(), RemoveRoleFromObjectACL(), RemoveRoleFromObjectPolicy(), RowExclusiveLock, ScanKeyInit(), SHARED_DEPENDENCY_ACL, SHARED_DEPENDENCY_INVALID, SHARED_DEPENDENCY_OWNER, SHARED_DEPENDENCY_POLICY, sort_object_addresses(), systable_beginscan(), systable_endscan(), systable_getnext(), systable_recheck_tuple(), table_close(), and table_open().

Referenced by DropOwnedObjects().

shdepLockAndCheckObject()

void shdepLockAndCheckObject	(	Oid	classId,
		Oid	objectId
	)

Definition at line 1161 of file pg_shdepend.c.

{
    /* AccessShareLock should be OK, since we are not modifying the object */
    LockSharedObject(classId, objectId, 0, AccessShareLock);
 
    switch (classId)
    {
        case AuthIdRelationId:
            if (!SearchSysCacheExists1(AUTHOID, ObjectIdGetDatum(objectId)))
                ereport(ERROR,
                        (errcode(ERRCODE_UNDEFINED_OBJECT),
                         errmsg("role %u was concurrently dropped",
                                objectId)));
            break;
 
        case TableSpaceRelationId:
            {
                /* For lack of a syscache on pg_tablespace, do this: */
                char       *tablespace = get_tablespace_name(objectId);
 
                if (tablespace == NULL)
                    ereport(ERROR,
                            (errcode(ERRCODE_UNDEFINED_OBJECT),
                             errmsg("tablespace %u was concurrently dropped",
                                    objectId)));
                pfree(tablespace);
                break;
            }
 
        case DatabaseRelationId:
            {
                /* For lack of a syscache on pg_database, do this: */
                char       *database = get_database_name(objectId);
 
                if (database == NULL)
                    ereport(ERROR,
                            (errcode(ERRCODE_UNDEFINED_OBJECT),
                             errmsg("database %u was concurrently dropped",
                                    objectId)));
                pfree(database);
                break;
            }
 
 
        default:
            elog(ERROR, "unrecognized shared classId: %u", classId);
    }
}

References AccessShareLock, elog, ereport, errcode(), errmsg(), ERROR, get_database_name(), get_tablespace_name(), LockSharedObject(), ObjectIdGetDatum(), pfree(), SearchSysCacheExists1, and tablespace.

Referenced by AlterDatabaseSet(), AlterRoleSet(), shdepAddDependency(), and shdepChangeDep().

shdepReassignOwned()

void shdepReassignOwned	(	List *	roleids,
		Oid	newrole
	)

Definition at line 1463 of file pg_shdepend.c.

{
    Relation    sdepRel;
    ListCell   *cell;
 
    /*
     * We don't need this strong a lock here, but we'll call routines that
     * acquire RowExclusiveLock.  Better get that right now to avoid potential
     * deadlock problems.
     */
    sdepRel = table_open(SharedDependRelationId, RowExclusiveLock);
 
    foreach(cell, roleids)
    {
        SysScanDesc scan;
        ScanKeyData key[2];
        HeapTuple   tuple;
        Oid         roleid = lfirst_oid(cell);
 
        /* Refuse to work on pinned roles */
        if (IsPinnedObject(AuthIdRelationId, roleid))
        {
            ObjectAddress obj;
 
            obj.classId = AuthIdRelationId;
            obj.objectId = roleid;
            obj.objectSubId = 0;
 
            ereport(ERROR,
                    (errcode(ERRCODE_DEPENDENT_OBJECTS_STILL_EXIST),
                     errmsg("cannot reassign ownership of objects owned by %s because they are required by the database system",
                            getObjectDescription(&obj, false))));
 
            /*
             * There's no need to tell the whole truth, which is that we
             * didn't track these dependencies at all ...
             */
        }
 
        ScanKeyInit(&key[0],
                    Anum_pg_shdepend_refclassid,
                    BTEqualStrategyNumber, F_OIDEQ,
                    ObjectIdGetDatum(AuthIdRelationId));
        ScanKeyInit(&key[1],
                    Anum_pg_shdepend_refobjid,
                    BTEqualStrategyNumber, F_OIDEQ,
                    ObjectIdGetDatum(roleid));
 
        scan = systable_beginscan(sdepRel, SharedDependReferenceIndexId, true,
                                  NULL, 2, key);
 
        while ((tuple = systable_getnext(scan)) != NULL)
        {
            Form_pg_shdepend sdepForm = (Form_pg_shdepend) GETSTRUCT(tuple);
            MemoryContext cxt,
                        oldcxt;
 
            /*
             * We only operate on shared objects and objects in the current
             * database
             */
            if (sdepForm->dbid != MyDatabaseId &&
                sdepForm->dbid != InvalidOid)
                continue;
 
            /* We leave non-owner dependencies alone */
            if (sdepForm->deptype != SHARED_DEPENDENCY_OWNER)
                continue;
 
            /*
             * The various ALTER OWNER routines tend to leak memory in
             * CurrentMemoryContext.  That's not a problem when they're only
             * called once per command; but in this usage where we might be
             * touching many objects, it can amount to a serious memory leak.
             * Fix that by running each call in a short-lived context.
             */
            cxt = AllocSetContextCreate(CurrentMemoryContext,
                                        "shdepReassignOwned",
                                        ALLOCSET_DEFAULT_SIZES);
            oldcxt = MemoryContextSwitchTo(cxt);
 
            /* Issue the appropriate ALTER OWNER call */
            switch (sdepForm->classid)
            {
                case TypeRelationId:
                    AlterTypeOwner_oid(sdepForm->objid, newrole, true);
                    break;
 
                case NamespaceRelationId:
                    AlterSchemaOwner_oid(sdepForm->objid, newrole);
                    break;
 
                case RelationRelationId:
 
                    /*
                     * Pass recursing = true so that we don't fail on indexes,
                     * owned sequences, etc when we happen to visit them
                     * before their parent table.
                     */
                    ATExecChangeOwner(sdepForm->objid, newrole, true, AccessExclusiveLock);
                    break;
 
                case DefaultAclRelationId:
 
                    /*
                     * Ignore default ACLs; they should be handled by DROP
                     * OWNED, not REASSIGN OWNED.
                     */
                    break;
 
                case UserMappingRelationId:
                    /* ditto */
                    break;
 
                case ForeignServerRelationId:
                    AlterForeignServerOwner_oid(sdepForm->objid, newrole);
                    break;
 
                case ForeignDataWrapperRelationId:
                    AlterForeignDataWrapperOwner_oid(sdepForm->objid, newrole);
                    break;
 
                case EventTriggerRelationId:
                    AlterEventTriggerOwner_oid(sdepForm->objid, newrole);
                    break;
 
                case PublicationRelationId:
                    AlterPublicationOwner_oid(sdepForm->objid, newrole);
                    break;
 
                case SubscriptionRelationId:
                    AlterSubscriptionOwner_oid(sdepForm->objid, newrole);
                    break;
 
                    /* Generic alter owner cases */
                case CollationRelationId:
                case ConversionRelationId:
                case OperatorRelationId:
                case ProcedureRelationId:
                case LanguageRelationId:
                case LargeObjectRelationId:
                case OperatorFamilyRelationId:
                case OperatorClassRelationId:
                case ExtensionRelationId:
                case StatisticExtRelationId:
                case TableSpaceRelationId:
                case DatabaseRelationId:
                case TSConfigRelationId:
                case TSDictionaryRelationId:
                    AlterObjectOwner_internal(sdepForm->classid,
                                              sdepForm->objid,
                                              newrole);
                    break;
 
                default:
                    elog(ERROR, "unexpected classid %u", sdepForm->classid);
                    break;
            }
 
            /* Clean up */
            MemoryContextSwitchTo(oldcxt);
            MemoryContextDelete(cxt);
 
            /* Make sure the next iteration will see my changes */
            CommandCounterIncrement();
        }
 
        systable_endscan(scan);
    }
 
    table_close(sdepRel, RowExclusiveLock);
}

References AccessExclusiveLock, ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, AlterEventTriggerOwner_oid(), AlterForeignDataWrapperOwner_oid(), AlterForeignServerOwner_oid(), AlterObjectOwner_internal(), AlterPublicationOwner_oid(), AlterSchemaOwner_oid(), AlterSubscriptionOwner_oid(), AlterTypeOwner_oid(), ATExecChangeOwner(), BTEqualStrategyNumber, ObjectAddress::classId, CommandCounterIncrement(), CurrentMemoryContext, elog, ereport, errcode(), errmsg(), ERROR, getObjectDescription(), GETSTRUCT, InvalidOid, IsPinnedObject(), sort-test::key, lfirst_oid, MemoryContextDelete(), MemoryContextSwitchTo(), MyDatabaseId, ObjectAddress::objectId, ObjectIdGetDatum(), ObjectAddress::objectSubId, RowExclusiveLock, ScanKeyInit(), SHARED_DEPENDENCY_OWNER, systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), and table_open().

Referenced by ReassignOwnedObjects().

storeObjectDescription()

static void storeObjectDescription ( StringInfo  descs, SharedDependencyObjectType  type, ObjectAddress *  object, SharedDependencyType  deptype, int  count  )

static

Definition at line 1226 of file pg_shdepend.c.

{
    char       *objdesc = getObjectDescription(object, false);
 
    /*
     * An object being dropped concurrently doesn't need to be reported.
     */
    if (objdesc == NULL)
        return;
 
    /* separate entries with a newline */
    if (descs->len != 0)
        appendStringInfoChar(descs, '\n');
 
    switch (type)
    {
        case LOCAL_OBJECT:
        case SHARED_OBJECT:
            if (deptype == SHARED_DEPENDENCY_OWNER)
                appendStringInfo(descs, _("owner of %s"), objdesc);
            else if (deptype == SHARED_DEPENDENCY_ACL)
                appendStringInfo(descs, _("privileges for %s"), objdesc);
            else if (deptype == SHARED_DEPENDENCY_POLICY)
                appendStringInfo(descs, _("target of %s"), objdesc);
            else if (deptype == SHARED_DEPENDENCY_TABLESPACE)
                appendStringInfo(descs, _("tablespace for %s"), objdesc);
            else
                elog(ERROR, "unrecognized dependency type: %d",
                     (int) deptype);
            break;
 
        case REMOTE_OBJECT:
            /* translator: %s will always be "database %s" */
            appendStringInfo(descs, ngettext("%d object in %s",
                                             "%d objects in %s",
                                             count),
                             count, objdesc);
            break;
 
        default:
            elog(ERROR, "unrecognized object type: %d", type);
    }
 
    pfree(objdesc);
}

References _, appendStringInfo(), appendStringInfoChar(), elog, ERROR, getObjectDescription(), StringInfoData::len, LOCAL_OBJECT, ngettext, pfree(), REMOTE_OBJECT, SHARED_DEPENDENCY_ACL, SHARED_DEPENDENCY_OWNER, SHARED_DEPENDENCY_POLICY, SHARED_DEPENDENCY_TABLESPACE, SHARED_OBJECT, and type.

Referenced by checkSharedDependencies().

updateAclDependencies()

void updateAclDependencies	(	Oid	classId,
		Oid	objectId,
		int32	objsubId,
		Oid	ownerId,
		int	noldmembers,
		Oid *	oldmembers,
		int	nnewmembers,
		Oid *	newmembers
	)

Definition at line 477 of file pg_shdepend.c.

{
    Relation    sdepRel;
    int         i;
 
    /*
     * Remove entries that are common to both lists; those represent existing
     * dependencies we don't need to change.
     *
     * OK to overwrite the inputs since we'll pfree them anyway.
     */
    getOidListDiff(oldmembers, &noldmembers, newmembers, &nnewmembers);
 
    if (noldmembers > 0 || nnewmembers > 0)
    {
        sdepRel = table_open(SharedDependRelationId, RowExclusiveLock);
 
        /* Add new dependencies that weren't already present */
        for (i = 0; i < nnewmembers; i++)
        {
            Oid         roleid = newmembers[i];
 
            /*
             * Skip the owner: he has an OWNER shdep entry instead. (This is
             * not just a space optimization; it makes ALTER OWNER easier. See
             * notes in changeDependencyOnOwner.)
             */
            if (roleid == ownerId)
                continue;
 
            /* Skip pinned roles; they don't need dependency entries */
            if (IsPinnedObject(AuthIdRelationId, roleid))
                continue;
 
            shdepAddDependency(sdepRel, classId, objectId, objsubId,
                               AuthIdRelationId, roleid,
                               SHARED_DEPENDENCY_ACL);
        }
 
        /* Drop no-longer-used old dependencies */
        for (i = 0; i < noldmembers; i++)
        {
            Oid         roleid = oldmembers[i];
 
            /* Skip the owner, same as above */
            if (roleid == ownerId)
                continue;
 
            /* Skip pinned roles */
            if (IsPinnedObject(AuthIdRelationId, roleid))
                continue;
 
            shdepDropDependency(sdepRel, classId, objectId, objsubId,
                                false,  /* exact match on objsubId */
                                AuthIdRelationId, roleid,
                                SHARED_DEPENDENCY_ACL);
        }
 
        table_close(sdepRel, RowExclusiveLock);
    }
 
    if (oldmembers)
        pfree(oldmembers);
    if (newmembers)
        pfree(newmembers);
}

References getOidListDiff(), i, IsPinnedObject(), pfree(), RowExclusiveLock, SHARED_DEPENDENCY_ACL, shdepAddDependency(), shdepDropDependency(), table_close(), and table_open().

Referenced by AddRoleMems(), ExecGrant_Attribute(), ExecGrant_common(), ExecGrant_Largeobject(), ExecGrant_Parameter(), ExecGrant_Relation(), recordDependencyOnNewAcl(), and SetDefaultACL().