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/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/lsyscache.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	updateAclDependenciesWorker (Oid classId, Oid objectId, int32 objsubId, Oid ownerId, SharedDependencyType deptype, int noldmembers, Oid *oldmembers, int nnewmembers, Oid *newmembers)
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)
static void	shdepReassignOwned_Owner (Form_pg_shdepend sdepForm, Oid newrole)
static void	shdepReassignOwned_InitAcl (Form_pg_shdepend sdepForm, Oid oldrole, Oid newrole)
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)
void	updateInitAclDependencies (Oid classId, Oid objectId, int32 objsubId, 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 316 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);
 
    /*
     * However, nothing need be done about SHARED_DEPENDENCY_INITACL entries,
     * since those exist whether or not the role is the object's owner, and
     * ALTER OWNER does not modify the underlying pg_init_privs entry.
     */
 
    table_close(sdepRel, RowExclusiveLock);
}

References fb(), 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 391 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 fb(), 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 676 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 = palloc_object(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, ShDependObjectInfo::deptype, ereport, errcode(), errmsg(), ERROR, fb(), getObjectDescription(), GETSTRUCT(), HeapTupleIsValid, i, initStringInfo(), InvalidOid, IsPinnedObject(), lappend(), lfirst, list_free_deep(), LOCAL_OBJECT, MAX_REPORTED_DEPS, MyDatabaseId, ngettext, NIL, ShDependObjectInfo::object, ObjectIdGetDatum(), ShDependObjectInfo::objtype, palloc(), palloc_object, 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 1190 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 895 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_array(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] = ObjectIdGetDatum(shdep->classid);
        slot[slot_stored_count]->tts_values[Anum_pg_shdepend_objid - 1] = ObjectIdGetDatum(shdep->objid);
        slot[slot_stored_count]->tts_values[Anum_pg_shdepend_objsubid - 1] = Int32GetDatum(shdep->objsubid);
        slot[slot_stored_count]->tts_values[Anum_pg_shdepend_refclassid - 1] = ObjectIdGetDatum(shdep->refclassid);
        slot[slot_stored_count]->tts_values[Anum_pg_shdepend_refobjid - 1] = ObjectIdGetDatum(shdep->refobjid);
        slot[slot_stored_count]->tts_values[Anum_pg_shdepend_deptype - 1] = CharGetDatum(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(), CharGetDatum(), ExecClearTuple(), ExecDropSingleTupleTableSlot(), ExecStoreVirtualTuple(), fb(), FormData_pg_shdepend, GETSTRUCT(), HeapTupleIsValid, i, Int32GetDatum(), MakeSingleTupleTableSlot(), MAX_CATALOG_MULTI_INSERT_BYTES, ObjectIdGetDatum(), palloc_array, 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 1047 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 fb(), 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 999 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(), fb(), HeapTupleIsValid, InvalidOid, ObjectIdGetDatum(), RowExclusiveLock, ScanKeyInit(), SHARED_DEPENDENCY_INVALID, shdepDropDependency(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), and table_open().

Referenced by dropdb().

getOidListDiff()

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

static

Definition at line 421 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;
}

References fb().

Referenced by updateAclDependenciesWorker().

recordDependencyOnOwner()

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

Definition at line 168 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, fb(), 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 370 of file pg_shdepend.c.

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

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

Referenced by heap_create().

recordSharedDependencyOn()

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

Definition at line 125 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, fb(), IsBootstrapProcessingMode, IsPinnedObject(), 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 610 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, and fb().

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 1069 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(), fb(), heap_form_tuple(), heap_freetuple(), Int32GetDatum(), ObjectIdGetDatum(), shdepLockAndCheckObject(), and values.

Referenced by recordSharedDependencyOn(), and updateAclDependenciesWorker().

shdepChangeDep()

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

static

Definition at line 206 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, fb(), GETSTRUCT(), heap_copytuple(), heap_form_tuple(), heap_freetuple(), Int32GetDatum(), IsPinnedObject(), ObjectIdGetDatum(), RelationGetDescr, ScanKeyInit(), shdepLockAndCheckObject(), systable_beginscan(), systable_endscan(), systable_getnext(), 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 1124 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(), fb(), GETSTRUCT(), HeapTupleIsValid, Int32GetDatum(), ObjectIdGetDatum(), OidIsValid, ScanKeyInit(), SHARED_DEPENDENCY_INVALID, systable_beginscan(), systable_endscan(), and systable_getnext().

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

shdepDropOwned()

void shdepDropOwned	(	List *	roleids,
		DropBehavior	behavior
	)

Definition at line 1342 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;
                case SHARED_DEPENDENCY_INITACL:
 
                    /*
                     * Any mentions of the role that remain in pg_init_privs
                     * entries are just dropped.  This is the same policy as
                     * we apply to regular ACLs.
                     */
 
                    /* Shouldn't see a role grant here */
                    Assert(sdepForm->classid != AuthMemRelationId);
                    RemoveRoleFromInitPriv(roleid,
                                           sdepForm->classid,
                                           sdepForm->objid,
                                           sdepForm->objsubid);
                    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(), Assert, BTEqualStrategyNumber, ObjectAddress::classId, elog, ereport, errcode(), errmsg(), ERROR, fb(), free_object_addresses(), getObjectDescription(), GETSTRUCT(), InvalidOid, IsPinnedObject(), lfirst_oid, MyDatabaseId, new_object_addresses(), ObjectAddress::objectId, ObjectIdGetDatum(), ObjectAddress::objectSubId, performMultipleDeletions(), ReleaseDeletionLock(), RemoveRoleFromInitPriv(), RemoveRoleFromObjectACL(), RemoveRoleFromObjectPolicy(), RowExclusiveLock, ScanKeyInit(), SHARED_DEPENDENCY_ACL, SHARED_DEPENDENCY_INITACL, 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 1211 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, fb(), 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 1530 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;
 
            /*
             * The various DDL routines called here 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);
 
            /* Perform the appropriate processing */
            switch (sdepForm->deptype)
            {
                case SHARED_DEPENDENCY_OWNER:
                    shdepReassignOwned_Owner(sdepForm, newrole);
                    break;
                case SHARED_DEPENDENCY_INITACL:
                    shdepReassignOwned_InitAcl(sdepForm, roleid, newrole);
                    break;
                case SHARED_DEPENDENCY_ACL:
                case SHARED_DEPENDENCY_POLICY:
                case SHARED_DEPENDENCY_TABLESPACE:
                    /* Nothing to do for these entry types */
                    break;
                default:
                    elog(ERROR, "unrecognized dependency type: %d",
                         (int) sdepForm->deptype);
                    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 ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, BTEqualStrategyNumber, ObjectAddress::classId, CommandCounterIncrement(), CurrentMemoryContext, elog, ereport, errcode(), errmsg(), ERROR, fb(), getObjectDescription(), GETSTRUCT(), InvalidOid, IsPinnedObject(), lfirst_oid, MemoryContextDelete(), MemoryContextSwitchTo(), MyDatabaseId, ObjectAddress::objectId, ObjectIdGetDatum(), ObjectAddress::objectSubId, RowExclusiveLock, ScanKeyInit(), SHARED_DEPENDENCY_ACL, SHARED_DEPENDENCY_INITACL, SHARED_DEPENDENCY_OWNER, SHARED_DEPENDENCY_POLICY, SHARED_DEPENDENCY_TABLESPACE, shdepReassignOwned_InitAcl(), shdepReassignOwned_Owner(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), and table_open().

Referenced by ReassignOwnedObjects().

shdepReassignOwned_InitAcl()

static void shdepReassignOwned_InitAcl ( Form_pg_shdepend  sdepForm, Oid  oldrole, Oid  newrole  )

static

Definition at line 1734 of file pg_shdepend.c.

{
    /*
     * Currently, REASSIGN OWNED replaces mentions of oldrole with newrole in
     * pg_init_privs entries, just as it does in the object's regular ACL.
     * This is less than ideal, since pg_init_privs ought to retain a
     * historical record of the situation at the end of CREATE EXTENSION.
     * However, there are two big stumbling blocks to doing something
     * different:
     *
     * 1. If we don't replace the references, what is to happen if the old
     * role gets dropped?  (DROP OWNED's current answer is to just delete the
     * pg_init_privs entry, which is surely ahistorical.)
     *
     * 2. It's unlikely that pg_dump will cope nicely with pg_init_privs
     * entries that are based on a different owner than the object now has ---
     * the more so given that pg_init_privs doesn't record the original owner
     * explicitly.  (This problem actually exists anyway given that a bare
     * ALTER OWNER won't update pg_init_privs, but we don't need REASSIGN
     * OWNED making it worse.)
     */
    ReplaceRoleInInitPriv(oldrole, newrole,
                          sdepForm->classid,
                          sdepForm->objid,
                          sdepForm->objsubid);
}

References fb(), and ReplaceRoleInInitPriv().

Referenced by shdepReassignOwned().

shdepReassignOwned_Owner()

static void shdepReassignOwned_Owner ( Form_pg_shdepend  sdepForm, Oid  newrole  )

static

Definition at line 1647 of file pg_shdepend.c.

{
    /* 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;
    }
}

References AccessExclusiveLock, AlterEventTriggerOwner_oid(), AlterForeignDataWrapperOwner_oid(), AlterForeignServerOwner_oid(), AlterObjectOwner_internal(), AlterPublicationOwner_oid(), AlterSchemaOwner_oid(), AlterSubscriptionOwner_oid(), AlterTypeOwner_oid(), ATExecChangeOwner(), elog, ERROR, and fb().

Referenced by shdepReassignOwned().

storeObjectDescription()

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

static

Definition at line 1276 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_INITACL)
                appendStringInfo(descs, _("initial 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, fb(), getObjectDescription(), LOCAL_OBJECT, ngettext, pfree(), REMOTE_OBJECT, SHARED_DEPENDENCY_ACL, SHARED_DEPENDENCY_INITACL, 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 491 of file pg_shdepend.c.

{
    updateAclDependenciesWorker(classId, objectId, objsubId,
                                ownerId, SHARED_DEPENDENCY_ACL,
                                noldmembers, oldmembers,
                                nnewmembers, newmembers);
}

References fb(), SHARED_DEPENDENCY_ACL, and updateAclDependenciesWorker().

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

updateAclDependenciesWorker()

static void updateAclDependenciesWorker ( Oid  classId, Oid  objectId, int32  objsubId, Oid  ownerId, SharedDependencyType  deptype, int  noldmembers, Oid *  oldmembers, int  nnewmembers, Oid *  newmembers  )

static

Definition at line 525 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];
 
            /*
             * For SHARED_DEPENDENCY_ACL entries, skip the owner: she has an
             * OWNER shdep entry instead.  (This is not just a space
             * optimization; it makes ALTER OWNER easier.  See notes in
             * changeDependencyOnOwner.)  But for INITACL entries, we record
             * the owner too.
             */
            if (deptype == SHARED_DEPENDENCY_ACL && roleid == ownerId)
                continue;
 
            /* Skip pinned roles; they don't need dependency entries */
            if (IsPinnedObject(AuthIdRelationId, roleid))
                continue;
 
            shdepAddDependency(sdepRel, classId, objectId, objsubId,
                               AuthIdRelationId, roleid,
                               deptype);
        }
 
        /* Drop no-longer-used old dependencies */
        for (i = 0; i < noldmembers; i++)
        {
            Oid         roleid = oldmembers[i];
 
            /* Skip the owner for ACL entries, same as above */
            if (deptype == SHARED_DEPENDENCY_ACL && roleid == ownerId)
                continue;
 
            /* Skip pinned roles */
            if (IsPinnedObject(AuthIdRelationId, roleid))
                continue;
 
            shdepDropDependency(sdepRel, classId, objectId, objsubId,
                                false,  /* exact match on objsubId */
                                AuthIdRelationId, roleid,
                                deptype);
        }
 
        table_close(sdepRel, RowExclusiveLock);
    }
 
    if (oldmembers)
        pfree(oldmembers);
    if (newmembers)
        pfree(newmembers);
}

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

Referenced by updateAclDependencies(), and updateInitAclDependencies().

updateInitAclDependencies()

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

Definition at line 512 of file pg_shdepend.c.

{
    updateAclDependenciesWorker(classId, objectId, objsubId,
                                InvalidOid, /* ownerId will not be consulted */
                                SHARED_DEPENDENCY_INITACL,
                                noldmembers, oldmembers,
                                nnewmembers, newmembers);
}

References fb(), InvalidOid, SHARED_DEPENDENCY_INITACL, and updateAclDependenciesWorker().

Referenced by recordExtensionInitPrivWorker(), RemoveRoleFromInitPriv(), and ReplaceRoleInInitPriv().