dependency.h File Reference

#include "catalog/objectaddress.h"

Include dependency graph for dependency.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	PERFORM_DELETION_INTERNAL   0x0001 /* internal action */
#define	PERFORM_DELETION_CONCURRENTLY   0x0002 /* concurrent drop */
#define	PERFORM_DELETION_QUIETLY   0x0004 /* suppress notices */
#define	PERFORM_DELETION_SKIP_ORIGINAL   0x0008 /* keep original obj */
#define	PERFORM_DELETION_SKIP_EXTENSIONS   0x0010 /* keep extensions */
#define	PERFORM_DELETION_CONCURRENT_LOCK

Typedefs
typedef enum DependencyType	DependencyType
typedef enum SharedDependencyType	SharedDependencyType
typedef struct ObjectAddresses	ObjectAddresses

Enumerations
enum	DependencyType {   DEPENDENCY_NORMAL = 'n' , DEPENDENCY_AUTO = 'a' , DEPENDENCY_INTERNAL = 'i' , DEPENDENCY_PARTITION_PRI = 'P' ,   DEPENDENCY_PARTITION_SEC = 'S' , DEPENDENCY_EXTENSION = 'e' , DEPENDENCY_AUTO_EXTENSION = 'x' }
enum	SharedDependencyType {   SHARED_DEPENDENCY_OWNER = 'o' , SHARED_DEPENDENCY_ACL = 'a' , SHARED_DEPENDENCY_INITACL = 'i' , SHARED_DEPENDENCY_POLICY = 'r' ,   SHARED_DEPENDENCY_TABLESPACE = 't' , SHARED_DEPENDENCY_INVALID = 0 }

Functions
void	AcquireDeletionLock (const ObjectAddress *object, int flags)
void	ReleaseDeletionLock (const ObjectAddress *object)
void	performDeletion (const ObjectAddress *object, DropBehavior behavior, int flags)
void	performDeletionCheck (const ObjectAddress *object, DropBehavior behavior, int flags)
void	performMultipleDeletions (const ObjectAddresses *objects, DropBehavior behavior, int flags)
void	recordDependencyOnExpr (const ObjectAddress *depender, Node *expr, List *rtable, DependencyType behavior)
void	collectDependenciesOfExpr (ObjectAddresses *addrs, Node *expr, List *rtable)
void	recordDependencyOnSingleRelExpr (const ObjectAddress *depender, Node *expr, Oid relId, DependencyType behavior, DependencyType self_behavior, bool reverse_self)
bool	find_temp_object (const ObjectAddresses *addrs, bool local_temp_okay, ObjectAddress *foundobj)
bool	query_uses_temp_object (Query *query, ObjectAddress *temp_object)
ObjectAddresses *	new_object_addresses (void)
void	add_exact_object_address (const ObjectAddress *object, ObjectAddresses *addrs)
bool	object_address_present (const ObjectAddress *object, const ObjectAddresses *addrs)
void	record_object_address_dependencies (const ObjectAddress *depender, ObjectAddresses *referenced, DependencyType behavior)
void	sort_object_addresses (ObjectAddresses *addrs)
void	free_object_addresses (ObjectAddresses *addrs)
void	recordDependencyOn (const ObjectAddress *depender, const ObjectAddress *referenced, DependencyType behavior)
void	recordMultipleDependencies (const ObjectAddress *depender, const ObjectAddress *referenced, int nreferenced, DependencyType behavior)
void	recordDependencyOnCurrentExtension (const ObjectAddress *object, bool isReplace)
void	checkMembershipInCurrentExtension (const ObjectAddress *object)
long	deleteDependencyRecordsFor (Oid classId, Oid objectId, bool skipExtensionDeps)
long	deleteDependencyRecordsForClass (Oid classId, Oid objectId, Oid refclassId, char deptype)
long	deleteDependencyRecordsForSpecific (Oid classId, Oid objectId, char deptype, Oid refclassId, Oid refobjectId)
long	changeDependencyFor (Oid classId, Oid objectId, Oid refClassId, Oid oldRefObjectId, Oid newRefObjectId)
long	changeDependenciesOf (Oid classId, Oid oldObjectId, Oid newObjectId)
long	changeDependenciesOn (Oid refClassId, Oid oldRefObjectId, Oid newRefObjectId)
Oid	getExtensionOfObject (Oid classId, Oid objectId)
List *	getAutoExtensionsOfObject (Oid classId, Oid objectId)
Oid	getExtensionType (Oid extensionOid, const char *typname)
bool	sequenceIsOwned (Oid seqId, char deptype, Oid *tableId, int32 *colId)
List *	getOwnedSequences (Oid relid)
Oid	getIdentitySequence (Relation rel, AttrNumber attnum, bool missing_ok)
Oid	get_index_constraint (Oid indexId)
List *	get_index_ref_constraints (Oid indexId)
void	recordSharedDependencyOn (ObjectAddress *depender, ObjectAddress *referenced, SharedDependencyType deptype)
void	deleteSharedDependencyRecordsFor (Oid classId, Oid objectId, int32 objectSubId)
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)
bool	checkSharedDependencies (Oid classId, Oid objectId, char **detail_msg, char **detail_log_msg)
void	shdepLockAndCheckObject (Oid classId, Oid objectId)
void	copyTemplateDependencies (Oid templateDbId, Oid newDbId)
void	dropDatabaseDependencies (Oid databaseId)
void	shdepDropOwned (List *roleids, DropBehavior behavior)
void	shdepReassignOwned (List *roleids, Oid newrole)

Macro Definition Documentation

PERFORM_DELETION_CONCURRENT_LOCK

#define PERFORM_DELETION_CONCURRENT_LOCK

Value:

                                                     0x0020 /* normal drop with
                                                     * concurrent lock mode */

Definition at line 97 of file dependency.h.

PERFORM_DELETION_CONCURRENTLY

#define PERFORM_DELETION_CONCURRENTLY   0x0002 /* concurrent drop */

Definition at line 93 of file dependency.h.

PERFORM_DELETION_INTERNAL

#define PERFORM_DELETION_INTERNAL   0x0001 /* internal action */

Definition at line 92 of file dependency.h.

PERFORM_DELETION_QUIETLY

#define PERFORM_DELETION_QUIETLY   0x0004 /* suppress notices */

Definition at line 94 of file dependency.h.

PERFORM_DELETION_SKIP_EXTENSIONS

#define PERFORM_DELETION_SKIP_EXTENSIONS   0x0010 /* keep extensions */

Definition at line 96 of file dependency.h.

PERFORM_DELETION_SKIP_ORIGINAL

#define PERFORM_DELETION_SKIP_ORIGINAL   0x0008 /* keep original obj */

Definition at line 95 of file dependency.h.

Typedef Documentation

DependencyType

typedef enum DependencyType DependencyType

ObjectAddresses

typedef struct ObjectAddresses ObjectAddresses

Definition at line 89 of file dependency.h.

SharedDependencyType

typedef enum SharedDependencyType SharedDependencyType

Enumeration Type Documentation

DependencyType

enum DependencyType

Enumerator
DEPENDENCY_NORMAL
DEPENDENCY_AUTO
DEPENDENCY_INTERNAL
DEPENDENCY_PARTITION_PRI
DEPENDENCY_PARTITION_SEC
DEPENDENCY_EXTENSION
DEPENDENCY_AUTO_EXTENSION

Definition at line 31 of file dependency.h.

{
    DEPENDENCY_NORMAL = 'n',
    DEPENDENCY_AUTO = 'a',
    DEPENDENCY_INTERNAL = 'i',
    DEPENDENCY_PARTITION_PRI = 'P',
    DEPENDENCY_PARTITION_SEC = 'S',
    DEPENDENCY_EXTENSION = 'e',
    DEPENDENCY_AUTO_EXTENSION = 'x',
} DependencyType;

SharedDependencyType

enum SharedDependencyType

Enumerator
SHARED_DEPENDENCY_OWNER
SHARED_DEPENDENCY_ACL
SHARED_DEPENDENCY_INITACL
SHARED_DEPENDENCY_POLICY
SHARED_DEPENDENCY_TABLESPACE
SHARED_DEPENDENCY_INVALID

Definition at line 78 of file dependency.h.

{
    SHARED_DEPENDENCY_OWNER = 'o',
    SHARED_DEPENDENCY_ACL = 'a',
    SHARED_DEPENDENCY_INITACL = 'i',
    SHARED_DEPENDENCY_POLICY = 'r',
    SHARED_DEPENDENCY_TABLESPACE = 't',
    SHARED_DEPENDENCY_INVALID = 0,
} SharedDependencyType;

Function Documentation

AcquireDeletionLock()

void AcquireDeletionLock ( const ObjectAddress *  object, int  flags  )

extern

Definition at line 1567 of file dependency.c.

{
    if (object->classId == RelationRelationId)
    {
        /*
         * In DROP INDEX CONCURRENTLY, take only ShareUpdateExclusiveLock on
         * the index for the moment.  index_drop() will promote the lock once
         * it's safe to do so.  In all other cases we need full exclusive
         * lock.
         */
        if (flags & PERFORM_DELETION_CONCURRENTLY)
            LockRelationOid(object->objectId, ShareUpdateExclusiveLock);
        else
            LockRelationOid(object->objectId, AccessExclusiveLock);
    }
    else if (object->classId == AuthMemRelationId)
        LockSharedObject(object->classId, object->objectId, 0,
                         AccessExclusiveLock);
    else
    {
        /* assume we should lock the whole object not a sub-object */
        LockDatabaseObject(object->classId, object->objectId, 0,
                           AccessExclusiveLock);
    }
}

References AccessExclusiveLock, ObjectAddress::classId, fb(), ObjectAddressStack::flags, LockDatabaseObject(), LockRelationOid(), LockSharedObject(), ObjectAddressStack::object, ObjectAddress::objectId, PERFORM_DELETION_CONCURRENTLY, and ShareUpdateExclusiveLock.

Referenced by findDependentObjects(), performDeletion(), performDeletionCheck(), performMultipleDeletions(), and shdepDropOwned().

add_exact_object_address()

void add_exact_object_address ( const ObjectAddress *  object, ObjectAddresses *  addrs  )

extern

Definition at line 2750 of file dependency.c.

{
    ObjectAddress *item;
 
    /* enlarge array if needed */
    if (addrs->numrefs >= addrs->maxrefs)
    {
        addrs->maxrefs *= 2;
        addrs->refs = (ObjectAddress *)
            repalloc(addrs->refs, addrs->maxrefs * sizeof(ObjectAddress));
        Assert(!addrs->extras);
    }
    /* record this item */
    item = addrs->refs + addrs->numrefs;
    *item = *object;
    addrs->numrefs++;
}

References Assert, ObjectAddresses::extras, ObjectAddresses::maxrefs, ObjectAddresses::numrefs, ObjectAddressStack::object, ObjectAddresses::refs, and repalloc().

Referenced by AggregateCreate(), AlterConstraintNamespaces(), AlterIndexNamespaces(), AlterRelationNamespaceInternal(), AlterTypeNamespaceInternal(), array_of_attnums_to_objectaddrs(), array_of_opers_to_objectaddrs(), ATExecDropColumn(), ATPostAlterTypeCleanup(), CastCreate(), CreateConstraintEntry(), CreateProceduralLanguage(), CreateTransform(), DropClonedTriggersFromPartition(), GenerateTypeDependencies(), heap_create_with_catalog(), index_create(), insert_element_record(), InsertExtensionTuple(), makeConfigurationDependencies(), makeDictionaryDependencies(), makeOperatorDependencies(), makeParserDependencies(), makeTSTemplateDependencies(), PreCommit_on_commit_actions(), ProcedureCreate(), RangeCreate(), recordDependencyOnSingleRelExpr(), ReindexRelationConcurrently(), RemoveInheritedConstraint(), RemoveObjects(), RemoveRelations(), shdepDropOwned(), and StorePartitionKey().

changeDependenciesOf()

long changeDependenciesOf ( Oid  classId, Oid  oldObjectId, Oid  newObjectId  )

extern

Definition at line 585 of file pg_depend.c.

{
    long        count = 0;
    Relation    depRel;
    ScanKeyData key[2];
    SysScanDesc scan;
    HeapTuple   tup;
 
    depRel = table_open(DependRelationId, RowExclusiveLock);
 
    ScanKeyInit(&key[0],
                Anum_pg_depend_classid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(classId));
    ScanKeyInit(&key[1],
                Anum_pg_depend_objid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(oldObjectId));
 
    scan = systable_beginscan(depRel, DependDependerIndexId, true,
                              NULL, 2, key);
 
    while (HeapTupleIsValid((tup = systable_getnext(scan))))
    {
        Form_pg_depend depform;
 
        /* make a modifiable copy */
        tup = heap_copytuple(tup);
        depform = (Form_pg_depend) GETSTRUCT(tup);
 
        depform->objid = newObjectId;
 
        CatalogTupleUpdate(depRel, &tup->t_self, tup);
 
        heap_freetuple(tup);
 
        count++;
    }
 
    systable_endscan(scan);
 
    table_close(depRel, RowExclusiveLock);
 
    return count;
}

References BTEqualStrategyNumber, CatalogTupleUpdate(), fb(), Form_pg_depend, GETSTRUCT(), heap_copytuple(), heap_freetuple(), HeapTupleIsValid, ObjectIdGetDatum(), RowExclusiveLock, ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), and table_open().

Referenced by index_concurrently_swap().

changeDependenciesOn()

long changeDependenciesOn ( Oid  refClassId, Oid  oldRefObjectId, Oid  newRefObjectId  )

extern

Definition at line 641 of file pg_depend.c.

{
    long        count = 0;
    Relation    depRel;
    ScanKeyData key[2];
    SysScanDesc scan;
    HeapTuple   tup;
    ObjectAddress objAddr;
    bool        newIsPinned;
 
    depRel = table_open(DependRelationId, RowExclusiveLock);
 
    /*
     * If oldRefObjectId is pinned, there won't be any dependency entries on
     * it --- we can't cope in that case.  (This isn't really worth expending
     * code to fix, in current usage; it just means you can't rename stuff out
     * of pg_catalog, which would likely be a bad move anyway.)
     */
    objAddr.classId = refClassId;
    objAddr.objectId = oldRefObjectId;
    objAddr.objectSubId = 0;
 
    if (isObjectPinned(&objAddr))
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("cannot remove dependency on %s because it is a system object",
                        getObjectDescription(&objAddr, false))));
 
    /*
     * We can handle adding a dependency on something pinned, though, since
     * that just means deleting the dependency entry.
     */
    objAddr.objectId = newRefObjectId;
 
    newIsPinned = isObjectPinned(&objAddr);
 
    /* Now search for dependency records */
    ScanKeyInit(&key[0],
                Anum_pg_depend_refclassid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(refClassId));
    ScanKeyInit(&key[1],
                Anum_pg_depend_refobjid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(oldRefObjectId));
 
    scan = systable_beginscan(depRel, DependReferenceIndexId, true,
                              NULL, 2, key);
 
    while (HeapTupleIsValid((tup = systable_getnext(scan))))
    {
        if (newIsPinned)
            CatalogTupleDelete(depRel, &tup->t_self);
        else
        {
            Form_pg_depend depform;
 
            /* make a modifiable copy */
            tup = heap_copytuple(tup);
            depform = (Form_pg_depend) GETSTRUCT(tup);
 
            depform->refobjid = newRefObjectId;
 
            CatalogTupleUpdate(depRel, &tup->t_self, tup);
 
            heap_freetuple(tup);
        }
 
        count++;
    }
 
    systable_endscan(scan);
 
    table_close(depRel, RowExclusiveLock);
 
    return count;
}

References BTEqualStrategyNumber, CatalogTupleDelete(), CatalogTupleUpdate(), ereport, errcode(), errmsg, ERROR, fb(), Form_pg_depend, getObjectDescription(), GETSTRUCT(), heap_copytuple(), heap_freetuple(), HeapTupleIsValid, isObjectPinned(), ObjectIdGetDatum(), RowExclusiveLock, ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), and table_open().

Referenced by index_concurrently_swap().

changeDependencyFor()

long changeDependencyFor ( Oid  classId, Oid  objectId, Oid  refClassId, Oid  oldRefObjectId, Oid  newRefObjectId  )

extern

Definition at line 470 of file pg_depend.c.

{
    long        count = 0;
    Relation    depRel;
    ScanKeyData key[2];
    SysScanDesc scan;
    HeapTuple   tup;
    ObjectAddress objAddr;
    ObjectAddress depAddr;
    bool        oldIsPinned;
    bool        newIsPinned;
 
    /*
     * Check to see if either oldRefObjectId or newRefObjectId is pinned.
     * Pinned objects should not have any dependency entries pointing to them,
     * so in these cases we should add or remove a pg_depend entry, or do
     * nothing at all, rather than update an entry as in the normal case.
     */
    objAddr.classId = refClassId;
    objAddr.objectId = oldRefObjectId;
    objAddr.objectSubId = 0;
 
    oldIsPinned = isObjectPinned(&objAddr);
 
    objAddr.objectId = newRefObjectId;
 
    newIsPinned = isObjectPinned(&objAddr);
 
    if (oldIsPinned)
    {
        /*
         * If both are pinned, we need do nothing.  However, return 1 not 0,
         * else callers will think this is an error case.
         */
        if (newIsPinned)
            return 1;
 
        /*
         * There is no old dependency record, but we should insert a new one.
         * Assume a normal dependency is wanted.
         */
        depAddr.classId = classId;
        depAddr.objectId = objectId;
        depAddr.objectSubId = 0;
        recordDependencyOn(&depAddr, &objAddr, DEPENDENCY_NORMAL);
 
        return 1;
    }
 
    /*
     * Make sure the new referenced object doesn't go away while we record the
     * dependency.
     */
    if (!newIsPinned)
        dependencyLockAndCheckObject(refClassId, newRefObjectId);
 
    depRel = table_open(DependRelationId, RowExclusiveLock);
 
    /* There should be existing dependency record(s), so search. */
    ScanKeyInit(&key[0],
                Anum_pg_depend_classid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(classId));
    ScanKeyInit(&key[1],
                Anum_pg_depend_objid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(objectId));
 
    scan = systable_beginscan(depRel, DependDependerIndexId, true,
                              NULL, 2, key);
 
    while (HeapTupleIsValid((tup = systable_getnext(scan))))
    {
        Form_pg_depend depform = (Form_pg_depend) GETSTRUCT(tup);
 
        if (depform->refclassid == refClassId &&
            depform->refobjid == oldRefObjectId)
        {
            if (newIsPinned)
                CatalogTupleDelete(depRel, &tup->t_self);
            else
            {
                /* make a modifiable copy */
                tup = heap_copytuple(tup);
                depform = (Form_pg_depend) GETSTRUCT(tup);
 
                depform->refobjid = newRefObjectId;
 
                CatalogTupleUpdate(depRel, &tup->t_self, tup);
 
                heap_freetuple(tup);
            }
 
            count++;
        }
    }
 
    systable_endscan(scan);
 
    table_close(depRel, RowExclusiveLock);
 
    return count;
}

References BTEqualStrategyNumber, CatalogTupleDelete(), CatalogTupleUpdate(), ObjectAddress::classId, DEPENDENCY_NORMAL, dependencyLockAndCheckObject(), fb(), Form_pg_depend, GETSTRUCT(), heap_copytuple(), heap_freetuple(), HeapTupleIsValid, isObjectPinned(), ObjectIdGetDatum(), recordDependencyOn(), RowExclusiveLock, ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), and table_open().

Referenced by AlterExtensionNamespace(), AlterFunction(), AlterObjectNamespace_internal(), AlterRelationNamespaceInternal(), AlterTypeNamespaceInternal(), ATExecSetAccessMethodNoStorage(), and swap_relation_files().

changeDependencyOnOwner()

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

extern

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  )

extern

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().

checkMembershipInCurrentExtension()

void checkMembershipInCurrentExtension ( const ObjectAddress *  object )

extern

Definition at line 271 of file pg_depend.c.

{
    /*
     * This is actually the same condition tested in
     * recordDependencyOnCurrentExtension; but we want to issue a
     * differently-worded error, and anyway it would be pretty confusing to
     * call recordDependencyOnCurrentExtension in these circumstances.
     */
 
    /* Only whole objects can be extension members */
    Assert(object->objectSubId == 0);
 
    if (creating_extension)
    {
        Oid         oldext;
 
        oldext = getExtensionOfObject(object->classId, object->objectId);
        /* If already a member of this extension, OK */
        if (oldext == CurrentExtensionObject)
            return;
        /* Else complain */
        ereport(ERROR,
                (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                 errmsg("%s is not a member of extension \"%s\"",
                        getObjectDescription(object, false),
                        get_extension_name(CurrentExtensionObject)),
                 errdetail("An extension may only use CREATE ... IF NOT EXISTS to skip object creation if the conflicting object is one that it already owns.")));
    }
}

References Assert, ObjectAddress::classId, creating_extension, CurrentExtensionObject, ereport, errcode(), errdetail(), errmsg, ERROR, fb(), get_extension_name(), getExtensionOfObject(), getObjectDescription(), ObjectAddress::objectId, and ObjectAddress::objectSubId.

Referenced by CollationCreate(), CreateForeignServer(), CreateSchemaCommand(), CreateTableAsRelExists(), DefineSequence(), and transformCreateStmt().

checkSharedDependencies()

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

extern

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(), Form_pg_shdepend, 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().

collectDependenciesOfExpr()

void collectDependenciesOfExpr ( ObjectAddresses *  addrs, Node *  expr, List *  rtable  )

extern

Definition at line 1667 of file dependency.c.

{
    find_expr_references_context context;
 
    context.addrs = addrs;
 
    /* Set up interpretation for Vars at varlevelsup = 0 */
    context.rtables = list_make1(rtable);
 
    /* Scan the expression tree for referenceable objects */
    find_expr_references_walker(expr, &context);
}

References find_expr_references_context::addrs, find_expr_references_walker(), list_make1, and find_expr_references_context::rtables.

Referenced by ProcedureCreate(), query_uses_temp_object(), and recordDependencyOnExpr().

copyTemplateDependencies()

void copyTemplateDependencies ( Oid  templateDbId, Oid  newDbId  )

extern

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(), Form_pg_shdepend, 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().

deleteDependencyRecordsFor()

long deleteDependencyRecordsFor ( Oid  classId, Oid  objectId, bool  skipExtensionDeps  )

extern

Definition at line 314 of file pg_depend.c.

{
    long        count = 0;
    Relation    depRel;
    ScanKeyData key[2];
    SysScanDesc scan;
    HeapTuple   tup;
 
    depRel = table_open(DependRelationId, RowExclusiveLock);
 
    ScanKeyInit(&key[0],
                Anum_pg_depend_classid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(classId));
    ScanKeyInit(&key[1],
                Anum_pg_depend_objid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(objectId));
 
    scan = systable_beginscan(depRel, DependDependerIndexId, true,
                              NULL, 2, key);
 
    while (HeapTupleIsValid(tup = systable_getnext(scan)))
    {
        if (skipExtensionDeps &&
            ((Form_pg_depend) GETSTRUCT(tup))->deptype == DEPENDENCY_EXTENSION)
            continue;
 
        CatalogTupleDelete(depRel, &tup->t_self);
        count++;
    }
 
    systable_endscan(scan);
 
    table_close(depRel, RowExclusiveLock);
 
    return count;
}

References BTEqualStrategyNumber, CatalogTupleDelete(), DEPENDENCY_EXTENSION, fb(), Form_pg_depend, GETSTRUCT(), HeapTupleIsValid, ObjectIdGetDatum(), RowExclusiveLock, ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), and table_open().

Referenced by AlterPolicy(), ATExecAlterColumnType(), ATExecDropExpression(), ATExecSetExpression(), CreateProceduralLanguage(), CreateTransform(), CreateTriggerFiringOn(), DropForeignKeyConstraintTriggers(), DropSubscription(), GenerateTypeDependencies(), InsertRule(), makeConfigurationDependencies(), makeOperatorDependencies(), ProcedureCreate(), and swap_relation_files().

deleteDependencyRecordsForClass()

long deleteDependencyRecordsForClass ( Oid  classId, Oid  objectId, Oid  refclassId, char  deptype  )

extern

Definition at line 364 of file pg_depend.c.

{
    long        count = 0;
    Relation    depRel;
    ScanKeyData key[2];
    SysScanDesc scan;
    HeapTuple   tup;
 
    depRel = table_open(DependRelationId, RowExclusiveLock);
 
    ScanKeyInit(&key[0],
                Anum_pg_depend_classid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(classId));
    ScanKeyInit(&key[1],
                Anum_pg_depend_objid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(objectId));
 
    scan = systable_beginscan(depRel, DependDependerIndexId, true,
                              NULL, 2, key);
 
    while (HeapTupleIsValid(tup = systable_getnext(scan)))
    {
        Form_pg_depend depform = (Form_pg_depend) GETSTRUCT(tup);
 
        if (depform->refclassid == refclassId && depform->deptype == deptype)
        {
            CatalogTupleDelete(depRel, &tup->t_self);
            count++;
        }
    }
 
    systable_endscan(scan);
 
    table_close(depRel, RowExclusiveLock);
 
    return count;
}

References BTEqualStrategyNumber, CatalogTupleDelete(), fb(), Form_pg_depend, GETSTRUCT(), HeapTupleIsValid, ObjectIdGetDatum(), RowExclusiveLock, ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), and table_open().

Referenced by AlterForeignDataWrapper(), ApplyExtensionUpdates(), ATExecDropIdentity(), ATExecSetAccessMethodNoStorage(), ConstraintSetParentConstraint(), DetachPartitionFinalize(), DropClonedTriggersFromPartition(), ExecAlterExtensionContentsRecurse(), index_constraint_create(), IndexSetParentIndex(), process_owned_by(), and TriggerSetParentTrigger().

deleteDependencyRecordsForSpecific()

long deleteDependencyRecordsForSpecific ( Oid  classId, Oid  objectId, char  deptype, Oid  refclassId, Oid  refobjectId  )

extern

Definition at line 411 of file pg_depend.c.

{
    long        count = 0;
    Relation    depRel;
    ScanKeyData key[2];
    SysScanDesc scan;
    HeapTuple   tup;
 
    depRel = table_open(DependRelationId, RowExclusiveLock);
 
    ScanKeyInit(&key[0],
                Anum_pg_depend_classid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(classId));
    ScanKeyInit(&key[1],
                Anum_pg_depend_objid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(objectId));
 
    scan = systable_beginscan(depRel, DependDependerIndexId, true,
                              NULL, 2, key);
 
    while (HeapTupleIsValid(tup = systable_getnext(scan)))
    {
        Form_pg_depend depform = (Form_pg_depend) GETSTRUCT(tup);
 
        if (depform->refclassid == refclassId &&
            depform->refobjid == refobjectId &&
            depform->deptype == deptype)
        {
            CatalogTupleDelete(depRel, &tup->t_self);
            count++;
        }
    }
 
    systable_endscan(scan);
 
    table_close(depRel, RowExclusiveLock);
 
    return count;
}

References BTEqualStrategyNumber, CatalogTupleDelete(), fb(), Form_pg_depend, GETSTRUCT(), HeapTupleIsValid, ObjectIdGetDatum(), RowExclusiveLock, ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), and table_open().

Referenced by AlterSubscription(), ExecAlterObjectDependsStmt(), and RemoveInheritedConstraint().

deleteSharedDependencyRecordsFor()

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

extern

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 )

extern

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().

find_temp_object()

bool find_temp_object ( const ObjectAddresses *  addrs, bool  local_temp_okay, ObjectAddress *  foundobj  )

extern

Definition at line 2544 of file dependency.c.

{
    for (int i = 0; i < addrs->numrefs; i++)
    {
        const ObjectAddress *thisobj = addrs->refs + i;
        Oid         objnamespace;
 
        /*
         * Use get_object_namespace() to see if this object belongs to a
         * schema.  If not, we can skip it.
         */
        objnamespace = get_object_namespace(thisobj);
 
        /*
         * If the object is in a temporary namespace, complain, except if
         * local_temp_okay and it's our own temp namespace.
         */
        if (OidIsValid(objnamespace) && isAnyTempNamespace(objnamespace) &&
            !(local_temp_okay && isTempNamespace(objnamespace)))
        {
            *foundobj = *thisobj;
            return true;
        }
    }
    return false;
}

References fb(), get_object_namespace(), i, isAnyTempNamespace(), isTempNamespace(), ObjectAddresses::numrefs, OidIsValid, and ObjectAddresses::refs.

Referenced by ProcedureCreate(), and query_uses_temp_object().

free_object_addresses()

void free_object_addresses ( ObjectAddresses *  addrs )

extern

Definition at line 2990 of file dependency.c.

{
    pfree(addrs->refs);
    if (addrs->extras)
        pfree(addrs->extras);
    pfree(addrs);
}

References ObjectAddresses::extras, pfree(), and ObjectAddresses::refs.

Referenced by AggregateCreate(), AlterTableNamespace(), AlterTypeNamespace(), ATExecDropColumn(), ATPostAlterTypeCleanup(), CastCreate(), CreateConstraintEntry(), CreateProceduralLanguage(), CreateTransform(), DropClonedTriggersFromPartition(), GenerateTypeDependencies(), heap_create_with_catalog(), index_create(), InsertExtensionTuple(), makeConfigurationDependencies(), makeDictionaryDependencies(), makeOperatorDependencies(), makeParserDependencies(), makeTSTemplateDependencies(), performDeletion(), performDeletionCheck(), performMultipleDeletions(), ProcedureCreate(), query_uses_temp_object(), RangeCreate(), recordDependencyOnExpr(), recordDependencyOnSingleRelExpr(), RemoveObjects(), RemoveRelations(), shdepDropOwned(), and StorePartitionKey().

get_index_constraint()

Oid get_index_constraint ( Oid  indexId )

extern

Definition at line 1192 of file pg_depend.c.

{
    Oid         constraintId = InvalidOid;
    Relation    depRel;
    ScanKeyData key[3];
    SysScanDesc scan;
    HeapTuple   tup;
 
    /* Search the dependency table for the index */
    depRel = table_open(DependRelationId, AccessShareLock);
 
    ScanKeyInit(&key[0],
                Anum_pg_depend_classid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(RelationRelationId));
    ScanKeyInit(&key[1],
                Anum_pg_depend_objid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(indexId));
    ScanKeyInit(&key[2],
                Anum_pg_depend_objsubid,
                BTEqualStrategyNumber, F_INT4EQ,
                Int32GetDatum(0));
 
    scan = systable_beginscan(depRel, DependDependerIndexId, true,
                              NULL, 3, key);
 
    while (HeapTupleIsValid(tup = systable_getnext(scan)))
    {
        Form_pg_depend deprec = (Form_pg_depend) GETSTRUCT(tup);
 
        /*
         * We assume any internal dependency on a constraint must be what we
         * are looking for.
         */
        if (deprec->refclassid == ConstraintRelationId &&
            deprec->refobjsubid == 0 &&
            deprec->deptype == DEPENDENCY_INTERNAL)
        {
            constraintId = deprec->refobjid;
            break;
        }
    }
 
    systable_endscan(scan);
    table_close(depRel, AccessShareLock);
 
    return constraintId;
}

References AccessShareLock, BTEqualStrategyNumber, DEPENDENCY_INTERNAL, fb(), Form_pg_depend, GETSTRUCT(), HeapTupleIsValid, Int32GetDatum(), InvalidOid, ObjectIdGetDatum(), ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), and table_open().

Referenced by generateClonedIndexStmt(), index_concurrently_swap(), RememberIndexForRebuilding(), RenameRelationInternal(), and transformIndexConstraint().

get_index_ref_constraints()

List * get_index_ref_constraints ( Oid  indexId )

extern

Definition at line 1248 of file pg_depend.c.

{
    List       *result = NIL;
    Relation    depRel;
    ScanKeyData key[3];
    SysScanDesc scan;
    HeapTuple   tup;
 
    /* Search the dependency table for the index */
    depRel = table_open(DependRelationId, AccessShareLock);
 
    ScanKeyInit(&key[0],
                Anum_pg_depend_refclassid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(RelationRelationId));
    ScanKeyInit(&key[1],
                Anum_pg_depend_refobjid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(indexId));
    ScanKeyInit(&key[2],
                Anum_pg_depend_refobjsubid,
                BTEqualStrategyNumber, F_INT4EQ,
                Int32GetDatum(0));
 
    scan = systable_beginscan(depRel, DependReferenceIndexId, true,
                              NULL, 3, key);
 
    while (HeapTupleIsValid(tup = systable_getnext(scan)))
    {
        Form_pg_depend deprec = (Form_pg_depend) GETSTRUCT(tup);
 
        /*
         * We assume any normal dependency from a constraint must be what we
         * are looking for.
         */
        if (deprec->classid == ConstraintRelationId &&
            deprec->objsubid == 0 &&
            deprec->deptype == DEPENDENCY_NORMAL)
        {
            result = lappend_oid(result, deprec->objid);
        }
    }
 
    systable_endscan(scan);
    table_close(depRel, AccessShareLock);
 
    return result;
}

References AccessShareLock, BTEqualStrategyNumber, DEPENDENCY_NORMAL, fb(), Form_pg_depend, GETSTRUCT(), HeapTupleIsValid, Int32GetDatum(), lappend_oid(), NIL, ObjectIdGetDatum(), result, ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), and table_open().

Referenced by index_concurrently_swap().

getAutoExtensionsOfObject()

List * getAutoExtensionsOfObject ( Oid  classId, Oid  objectId  )

extern

Definition at line 911 of file pg_depend.c.

{
    List       *result = NIL;
    Relation    depRel;
    ScanKeyData key[2];
    SysScanDesc scan;
    HeapTuple   tup;
 
    depRel = table_open(DependRelationId, AccessShareLock);
 
    ScanKeyInit(&key[0],
                Anum_pg_depend_classid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(classId));
    ScanKeyInit(&key[1],
                Anum_pg_depend_objid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(objectId));
 
    scan = systable_beginscan(depRel, DependDependerIndexId, true,
                              NULL, 2, key);
 
    while (HeapTupleIsValid((tup = systable_getnext(scan))))
    {
        Form_pg_depend depform = (Form_pg_depend) GETSTRUCT(tup);
 
        if (depform->refclassid == ExtensionRelationId &&
            depform->deptype == DEPENDENCY_AUTO_EXTENSION)
            result = lappend_oid(result, depform->refobjid);
    }
 
    systable_endscan(scan);
 
    table_close(depRel, AccessShareLock);
 
    return result;
}

References AccessShareLock, BTEqualStrategyNumber, DEPENDENCY_AUTO_EXTENSION, fb(), Form_pg_depend, GETSTRUCT(), HeapTupleIsValid, lappend_oid(), NIL, ObjectIdGetDatum(), result, ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), and table_open().

Referenced by collectPartitionIndexExtDeps(), and ExecAlterObjectDependsStmt().

getExtensionOfObject()

Oid getExtensionOfObject ( Oid  classId, Oid  objectId  )

extern

Definition at line 865 of file pg_depend.c.

{
    Oid         result = InvalidOid;
    Relation    depRel;
    ScanKeyData key[2];
    SysScanDesc scan;
    HeapTuple   tup;
 
    depRel = table_open(DependRelationId, AccessShareLock);
 
    ScanKeyInit(&key[0],
                Anum_pg_depend_classid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(classId));
    ScanKeyInit(&key[1],
                Anum_pg_depend_objid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(objectId));
 
    scan = systable_beginscan(depRel, DependDependerIndexId, true,
                              NULL, 2, key);
 
    while (HeapTupleIsValid((tup = systable_getnext(scan))))
    {
        Form_pg_depend depform = (Form_pg_depend) GETSTRUCT(tup);
 
        if (depform->refclassid == ExtensionRelationId &&
            depform->deptype == DEPENDENCY_EXTENSION)
        {
            result = depform->refobjid;
            break;              /* no need to keep scanning */
        }
    }
 
    systable_endscan(scan);
 
    table_close(depRel, AccessShareLock);
 
    return result;
}

References AccessShareLock, BTEqualStrategyNumber, DEPENDENCY_EXTENSION, fb(), Form_pg_depend, GETSTRUCT(), HeapTupleIsValid, InvalidOid, ObjectIdGetDatum(), result, ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), and table_open().

Referenced by AlterExtensionNamespace(), checkMembershipInCurrentExtension(), ExecAlterExtensionContentsRecurse(), get_function_sibling_type(), lookup_shippable(), pg_extension_config_dump(), and recordDependencyOnCurrentExtension().

getExtensionType()

Oid getExtensionType ( Oid  extensionOid, const char *  typname  )

extern

Definition at line 963 of file pg_depend.c.

{
    Oid         result = InvalidOid;
    Relation    depRel;
    ScanKeyData key[3];
    SysScanDesc scan;
    HeapTuple   tup;
 
    depRel = table_open(DependRelationId, AccessShareLock);
 
    ScanKeyInit(&key[0],
                Anum_pg_depend_refclassid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(ExtensionRelationId));
    ScanKeyInit(&key[1],
                Anum_pg_depend_refobjid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(extensionOid));
    ScanKeyInit(&key[2],
                Anum_pg_depend_refobjsubid,
                BTEqualStrategyNumber, F_INT4EQ,
                Int32GetDatum(0));
 
    scan = systable_beginscan(depRel, DependReferenceIndexId, true,
                              NULL, 3, key);
 
    while (HeapTupleIsValid(tup = systable_getnext(scan)))
    {
        Form_pg_depend depform = (Form_pg_depend) GETSTRUCT(tup);
 
        if (depform->classid == TypeRelationId &&
            depform->deptype == DEPENDENCY_EXTENSION)
        {
            Oid         typoid = depform->objid;
            HeapTuple   typtup;
 
            typtup = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typoid));
            if (!HeapTupleIsValid(typtup))
                continue;       /* should we throw an error? */
            if (strcmp(NameStr(((Form_pg_type) GETSTRUCT(typtup))->typname),
                       typname) == 0)
            {
                result = typoid;
                ReleaseSysCache(typtup);
                break;          /* no need to keep searching */
            }
            ReleaseSysCache(typtup);
        }
    }
 
    systable_endscan(scan);
 
    table_close(depRel, AccessShareLock);
 
    return result;
}

References AccessShareLock, BTEqualStrategyNumber, DEPENDENCY_EXTENSION, fb(), Form_pg_depend, Form_pg_type, GETSTRUCT(), HeapTupleIsValid, Int32GetDatum(), InvalidOid, NameStr, ObjectIdGetDatum(), ReleaseSysCache(), result, ScanKeyInit(), SearchSysCache1(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), table_open(), and typname.

Referenced by get_function_sibling_type().

getIdentitySequence()

Oid getIdentitySequence ( Relation  rel, AttrNumber  attnum, bool  missing_ok  )

extern

Definition at line 1149 of file pg_depend.c.

{
    Oid         relid = RelationGetRelid(rel);
    List       *seqlist;
 
    /*
     * The identity sequence is associated with the topmost partitioned table,
     * which might have column order different than the given partition.
     */
    if (RelationGetForm(rel)->relispartition)
    {
        List       *ancestors = get_partition_ancestors(relid);
        const char *attname = get_attname(relid, attnum, false);
 
        relid = llast_oid(ancestors);
        attnum = get_attnum(relid, attname);
        if (attnum == InvalidAttrNumber)
            elog(ERROR, "cache lookup failed for attribute \"%s\" of relation %u",
                 attname, relid);
        list_free(ancestors);
    }
 
    seqlist = getOwnedSequences_internal(relid, attnum, DEPENDENCY_INTERNAL);
    if (list_length(seqlist) > 1)
        elog(ERROR, "more than one owned sequence found");
    else if (seqlist == NIL)
    {
        if (missing_ok)
            return InvalidOid;
        else
            elog(ERROR, "no owned sequence found");
    }
 
    return linitial_oid(seqlist);
}

References attname, attnum, DEPENDENCY_INTERNAL, elog, ERROR, fb(), get_attname(), get_attnum(), get_partition_ancestors(), getOwnedSequences_internal(), InvalidAttrNumber, InvalidOid, linitial_oid, list_free(), list_length(), llast_oid, NIL, RelationGetForm, and RelationGetRelid.

Referenced by ATExecDropIdentity(), build_column_default(), transformAlterTableStmt(), and transformTableLikeClause().

getOwnedSequences()

List * getOwnedSequences ( Oid  relid )

extern

Definition at line 1140 of file pg_depend.c.

{
    return getOwnedSequences_internal(relid, 0, 0);
}

References getOwnedSequences_internal().

Referenced by ATRewriteTables(), and ExecuteTruncateGuts().

new_object_addresses()

ObjectAddresses * new_object_addresses ( void  )

extern

Definition at line 2705 of file dependency.c.

{
    ObjectAddresses *addrs;
 
    addrs = palloc_object(ObjectAddresses);
 
    addrs->numrefs = 0;
    addrs->maxrefs = 32;
    addrs->refs = palloc_array(ObjectAddress, addrs->maxrefs);
    addrs->extras = NULL;       /* until/unless needed */
 
    return addrs;
}

References ObjectAddresses::extras, fb(), ObjectAddresses::maxrefs, ObjectAddresses::numrefs, palloc_array, palloc_object, and ObjectAddresses::refs.

Referenced by AggregateCreate(), AlterExtensionNamespace(), AlterTableNamespace(), AlterTypeNamespace(), ATExecDropColumn(), ATPostAlterTypeCleanup(), CastCreate(), CreateConstraintEntry(), CreateProceduralLanguage(), CreateTransform(), DropClonedTriggersFromPartition(), GenerateTypeDependencies(), heap_create_with_catalog(), index_create(), insert_element_record(), InsertExtensionTuple(), makeConfigurationDependencies(), makeDictionaryDependencies(), makeOperatorDependencies(), makeParserDependencies(), makeTSTemplateDependencies(), performDeletion(), performDeletionCheck(), performMultipleDeletions(), PreCommit_on_commit_actions(), ProcedureCreate(), query_uses_temp_object(), RangeCreate(), recordDependencyOnExpr(), recordDependencyOnSingleRelExpr(), ReindexRelationConcurrently(), RemoveInheritedConstraint(), RemoveObjects(), RemoveRelations(), shdepDropOwned(), and StorePartitionKey().

object_address_present()

bool object_address_present ( const ObjectAddress *  object, const ObjectAddresses *  addrs  )

extern

Definition at line 2810 of file dependency.c.

{
    int         i;
 
    for (i = addrs->numrefs - 1; i >= 0; i--)
    {
        const ObjectAddress *thisobj = addrs->refs + i;
 
        if (object->classId == thisobj->classId &&
            object->objectId == thisobj->objectId)
        {
            if (object->objectSubId == thisobj->objectSubId ||
                thisobj->objectSubId == 0)
                return true;
        }
    }
 
    return false;
}

References ObjectAddress::classId, fb(), i, ObjectAddresses::numrefs, ObjectAddressStack::object, ObjectAddress::objectId, ObjectAddress::objectSubId, and ObjectAddresses::refs.

Referenced by AlterConstraintNamespaces(), AlterIndexNamespaces(), AlterRelationNamespaceInternal(), AlterTypeNamespaceInternal(), findDependentObjects(), and PreCommit_on_commit_actions().

performDeletion()

void performDeletion ( const ObjectAddress *  object, DropBehavior  behavior, int  flags  )

extern

Definition at line 279 of file dependency.c.

{
    Relation    depRel;
    ObjectAddresses *targetObjects;
 
    /*
     * We save some cycles by opening pg_depend just once and passing the
     * Relation pointer down to all the recursive deletion steps.
     */
    depRel = table_open(DependRelationId, RowExclusiveLock);
 
    /*
     * Acquire deletion lock on the target object.  (Ideally the caller has
     * done this already, but many places are sloppy about it.)
     */
    AcquireDeletionLock(object, 0);
 
    /*
     * Construct a list of objects to delete (ie, the given object plus
     * everything directly or indirectly dependent on it).
     */
    targetObjects = new_object_addresses();
 
    findDependentObjects(object,
                         DEPFLAG_ORIGINAL,
                         flags,
                         NULL,  /* empty stack */
                         targetObjects,
                         NULL,  /* no pendingObjects */
                         &depRel);
 
    /*
     * Check if deletion is allowed, and report about cascaded deletes.
     */
    reportDependentObjects(targetObjects,
                           behavior,
                           flags,
                           object);
 
    /* do the deed */
    deleteObjectsInList(targetObjects, &depRel, flags);
 
    /* And clean up */
    free_object_addresses(targetObjects);
 
    table_close(depRel, RowExclusiveLock);
}

References AcquireDeletionLock(), deleteObjectsInList(), DEPFLAG_ORIGINAL, fb(), findDependentObjects(), ObjectAddressStack::flags, free_object_addresses(), new_object_addresses(), reportDependentObjects(), RowExclusiveLock, table_close(), and table_open().

Referenced by AlterDomainDropConstraint(), AlterDomainNotNull(), AlterPropGraph(), ATExecDropIdentity(), ATExecMergePartitions(), ATExecSplitPartition(), DetachPartitionFinalize(), do_autovacuum(), dropconstraint_internal(), DropForeignKeyConstraintTriggers(), dropOperators(), dropProcedures(), finish_heap_swap(), inv_drop(), PublicationDropSchemas(), PublicationDropTables(), RemoveAttrDefault(), RemoveTempRelations(), RemoveUserMapping(), and SetDefaultACL().

performDeletionCheck()

void performDeletionCheck ( const ObjectAddress *  object, DropBehavior  behavior, int  flags  )

extern

Definition at line 338 of file dependency.c.

{
    Relation    depRel;
    ObjectAddresses *targetObjects;
 
    Assert(behavior == DROP_RESTRICT);
 
    depRel = table_open(DependRelationId, RowExclusiveLock);
 
    AcquireDeletionLock(object, 0);
 
    /*
     * Construct a list of objects we want to delete later (ie, the given
     * object plus everything directly or indirectly dependent on it).
     */
    targetObjects = new_object_addresses();
 
    findDependentObjects(object,
                         DEPFLAG_ORIGINAL,
                         flags,
                         NULL,  /* empty stack */
                         targetObjects,
                         NULL,  /* no pendingObjects */
                         &depRel);
 
    /*
     * Check if deletion is allowed.
     */
    reportDependentObjects(targetObjects,
                           behavior,
                           flags,
                           object);
 
    /* And clean up */
    free_object_addresses(targetObjects);
 
    table_close(depRel, RowExclusiveLock);
}

References AcquireDeletionLock(), Assert, DEPFLAG_ORIGINAL, DROP_RESTRICT, fb(), findDependentObjects(), ObjectAddressStack::flags, free_object_addresses(), new_object_addresses(), reportDependentObjects(), RowExclusiveLock, table_close(), and table_open().

Referenced by ATExecMergePartitions(), and ATExecSplitPartition().

performMultipleDeletions()

void performMultipleDeletions ( const ObjectAddresses *  objects, DropBehavior  behavior, int  flags  )

extern

Definition at line 388 of file dependency.c.

{
    Relation    depRel;
    ObjectAddresses *targetObjects;
    int         i;
 
    /* No work if no objects... */
    if (objects->numrefs <= 0)
        return;
 
    /*
     * We save some cycles by opening pg_depend just once and passing the
     * Relation pointer down to all the recursive deletion steps.
     */
    depRel = table_open(DependRelationId, RowExclusiveLock);
 
    /*
     * Construct a list of objects to delete (ie, the given objects plus
     * everything directly or indirectly dependent on them).  Note that
     * because we pass the whole objects list as pendingObjects context, we
     * won't get a failure from trying to delete an object that is internally
     * dependent on another one in the list; we'll just skip that object and
     * delete it when we reach its owner.
     */
    targetObjects = new_object_addresses();
 
    for (i = 0; i < objects->numrefs; i++)
    {
        const ObjectAddress *thisobj = objects->refs + i;
 
        /*
         * Acquire deletion lock on each target object.  (Ideally the caller
         * has done this already, but many places are sloppy about it.)
         */
        AcquireDeletionLock(thisobj, flags);
 
        findDependentObjects(thisobj,
                             DEPFLAG_ORIGINAL,
                             flags,
                             NULL,  /* empty stack */
                             targetObjects,
                             objects,
                             &depRel);
    }
 
    /*
     * Check if deletion is allowed, and report about cascaded deletes.
     *
     * If there's exactly one object being deleted, report it the same way as
     * in performDeletion(), else we have to be vaguer.
     */
    reportDependentObjects(targetObjects,
                           behavior,
                           flags,
                           (objects->numrefs == 1 ? objects->refs : NULL));
 
    /* do the deed */
    deleteObjectsInList(targetObjects, &depRel, flags);
 
    /* And clean up */
    free_object_addresses(targetObjects);
 
    table_close(depRel, RowExclusiveLock);
}

References AcquireDeletionLock(), deleteObjectsInList(), DEPFLAG_ORIGINAL, fb(), findDependentObjects(), ObjectAddressStack::flags, free_object_addresses(), i, new_object_addresses(), ObjectAddresses::numrefs, ObjectAddresses::refs, reportDependentObjects(), RowExclusiveLock, table_close(), and table_open().

Referenced by ATExecDropColumn(), ATPostAlterTypeCleanup(), DropClonedTriggersFromPartition(), PreCommit_on_commit_actions(), ReindexRelationConcurrently(), RemoveInheritedConstraint(), RemoveObjects(), RemoveRelations(), and shdepDropOwned().

query_uses_temp_object()

bool query_uses_temp_object ( Query *  query, ObjectAddress *  temp_object  )

extern

Definition at line 2579 of file dependency.c.

{
    bool        result;
    ObjectAddresses *addrs;
 
    addrs = new_object_addresses();
 
    /* Collect all dependencies from the Query */
    collectDependenciesOfExpr(addrs, (Node *) query, NIL);
 
    /* Look for one that is temp */
    result = find_temp_object(addrs, false, temp_object);
 
    free_object_addresses(addrs);
 
    return result;
}

References collectDependenciesOfExpr(), fb(), find_temp_object(), free_object_addresses(), new_object_addresses(), NIL, and result.

Referenced by DefineView(), and transformCreateTableAsStmt().

record_object_address_dependencies()

void record_object_address_dependencies ( const ObjectAddress *  depender, ObjectAddresses *  referenced, DependencyType  behavior  )

extern

Definition at line 2959 of file dependency.c.

{
    eliminate_duplicate_dependencies(referenced);
    recordMultipleDependencies(depender,
                               referenced->refs, referenced->numrefs,
                               behavior);
}

References eliminate_duplicate_dependencies(), fb(), and recordMultipleDependencies().

Referenced by AggregateCreate(), CastCreate(), CreateConstraintEntry(), CreateProceduralLanguage(), CreateTransform(), GenerateTypeDependencies(), heap_create_with_catalog(), index_create(), insert_element_record(), InsertExtensionTuple(), makeConfigurationDependencies(), makeDictionaryDependencies(), makeOperatorDependencies(), makeParserDependencies(), makeTSTemplateDependencies(), ProcedureCreate(), RangeCreate(), and StorePartitionKey().

recordDependencyOn()

void recordDependencyOn ( const ObjectAddress *  depender, const ObjectAddress *  referenced, DependencyType  behavior  )

extern

Definition at line 51 of file pg_depend.c.

{
    recordMultipleDependencies(depender, referenced, 1, behavior);
}

References fb(), and recordMultipleDependencies().

Referenced by add_column_collation_dependency(), add_column_datatype_dependency(), addFkConstraint(), AddNewAttributeTuples(), AlterForeignDataWrapper(), AlterFunction(), AlterPolicy(), AlterSubscription(), ApplyExtensionUpdates(), applyPartitionIndexExtDeps(), ATExecAddOf(), ATExecSetAccessMethodNoStorage(), changeDependencyFor(), CollationCreate(), ConstraintSetParentConstraint(), ConversionCreate(), copy_index_constraints(), create_toast_table(), CreateAccessMethod(), CreateForeignDataWrapper(), CreateForeignServer(), CreateForeignTable(), CreateOpFamily(), CreatePolicy(), CreateStatistics(), CreateSubscription(), CreateTriggerFiringOn(), CreateUserMapping(), DefineOpClass(), ExecAlterExtensionContentsRecurse(), ExecAlterObjectDependsStmt(), GenerateTypeDependencies(), index_constraint_create(), index_create(), IndexSetParentIndex(), insert_element_record(), insert_event_trigger_tuple(), insert_label_record(), insert_property_record(), InsertRule(), makeMultirangeConstructors(), makeRangeConstructors(), process_owned_by(), publication_add_relation(), publication_add_schema(), RangeCreate(), recordDependencyOnCurrentExtension(), recordDependencyOnSingleRelExpr(), SetDefaultACL(), StoreAttrDefault(), StoreCatalogInheritance1(), storeOperators(), StorePartitionKey(), storeProcedures(), swap_relation_files(), and TriggerSetParentTrigger().

recordDependencyOnCurrentExtension()

void recordDependencyOnCurrentExtension ( const ObjectAddress *  object, bool  isReplace  )

extern

Definition at line 206 of file pg_depend.c.

{
    /* Only whole objects can be extension members */
    Assert(object->objectSubId == 0);
 
    if (creating_extension)
    {
        ObjectAddress extension;
 
        /* Only need to check for existing membership if isReplace */
        if (isReplace)
        {
            Oid         oldext;
 
            /*
             * Side note: these catalog lookups are safe only because the
             * object is a pre-existing one.  In the not-isReplace case, the
             * caller has most likely not yet done a CommandCounterIncrement
             * that would make the new object visible.
             */
            oldext = getExtensionOfObject(object->classId, object->objectId);
            if (OidIsValid(oldext))
            {
                /* If already a member of this extension, nothing to do */
                if (oldext == CurrentExtensionObject)
                    return;
                /* Already a member of some other extension, so reject */
                ereport(ERROR,
                        (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                         errmsg("%s is already a member of extension \"%s\"",
                                getObjectDescription(object, false),
                                get_extension_name(oldext))));
            }
            /* It's a free-standing object, so reject */
            ereport(ERROR,
                    (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                     errmsg("%s is not a member of extension \"%s\"",
                            getObjectDescription(object, false),
                            get_extension_name(CurrentExtensionObject)),
                     errdetail("An extension is not allowed to replace an object that it does not own.")));
        }
 
        /* OK, record it as a member of CurrentExtensionObject */
        extension.classId = ExtensionRelationId;
        extension.objectId = CurrentExtensionObject;
        extension.objectSubId = 0;
 
        recordDependencyOn(object, &extension, DEPENDENCY_EXTENSION);
    }
}

References Assert, ObjectAddress::classId, creating_extension, CurrentExtensionObject, DEPENDENCY_EXTENSION, ereport, errcode(), errdetail(), errmsg, ERROR, fb(), get_extension_name(), getExtensionOfObject(), getObjectDescription(), ObjectAddress::objectId, ObjectAddress::objectSubId, OidIsValid, and recordDependencyOn().

Referenced by CastCreate(), CollationCreate(), ConversionCreate(), CreateAccessMethod(), CreateForeignDataWrapper(), CreateForeignServer(), CreateOpFamily(), CreateProceduralLanguage(), CreateTransform(), DefineOpClass(), DefineVirtualRelation(), GenerateTypeDependencies(), heap_create_with_catalog(), insert_event_trigger_tuple(), makeConfigurationDependencies(), makeDictionaryDependencies(), makeOperatorDependencies(), makeParserDependencies(), makeTSTemplateDependencies(), NamespaceCreate(), and ProcedureCreate().

recordDependencyOnExpr()

void recordDependencyOnExpr ( const ObjectAddress *  depender, Node *  expr, List *  rtable, DependencyType  behavior  )

extern

Definition at line 1624 of file dependency.c.

{
    ObjectAddresses *addrs;
 
    addrs = new_object_addresses();
 
    /* Collect all dependencies from the expression */
    collectDependenciesOfExpr(addrs, expr, rtable);
 
    /* Remove duplicates */
    eliminate_duplicate_dependencies(addrs);
 
    /* And record 'em */
    recordMultipleDependencies(depender,
                               addrs->refs, addrs->numrefs,
                               behavior);
 
    free_object_addresses(addrs);
}

References collectDependenciesOfExpr(), eliminate_duplicate_dependencies(), fb(), free_object_addresses(), new_object_addresses(), ObjectAddresses::numrefs, recordMultipleDependencies(), and ObjectAddresses::refs.

Referenced by AlterPolicy(), CreatePolicy(), CreateTriggerFiringOn(), GenerateTypeDependencies(), and InsertRule().

recordDependencyOnOwner()

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

extern

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().

recordDependencyOnSingleRelExpr()

void recordDependencyOnSingleRelExpr ( const ObjectAddress *  depender, Node *  expr, Oid  relId, DependencyType  behavior, DependencyType  self_behavior, bool  reverse_self  )

extern

Definition at line 1699 of file dependency.c.

{
    find_expr_references_context context;
    RangeTblEntry rte = {0};
 
    context.addrs = new_object_addresses();
 
    /* We gin up a rather bogus rangetable list to handle Vars */
    rte.type = T_RangeTblEntry;
    rte.rtekind = RTE_RELATION;
    rte.relid = relId;
    rte.relkind = RELKIND_RELATION; /* no need for exactness here */
    rte.rellockmode = AccessShareLock;
 
    context.rtables = list_make1(list_make1(&rte));
 
    /* Scan the expression tree for referenceable objects */
    find_expr_references_walker(expr, &context);
 
    /* Remove any duplicates */
    eliminate_duplicate_dependencies(context.addrs);
 
    /* Separate self-dependencies if necessary */
    if ((behavior != self_behavior || reverse_self) &&
        context.addrs->numrefs > 0)
    {
        ObjectAddresses *self_addrs;
        ObjectAddress *outobj;
        int         oldref,
                    outrefs;
 
        self_addrs = new_object_addresses();
 
        outobj = context.addrs->refs;
        outrefs = 0;
        for (oldref = 0; oldref < context.addrs->numrefs; oldref++)
        {
            ObjectAddress *thisobj = context.addrs->refs + oldref;
 
            if (thisobj->classId == RelationRelationId &&
                thisobj->objectId == relId)
            {
                /* Move this ref into self_addrs */
                add_exact_object_address(thisobj, self_addrs);
            }
            else
            {
                /* Keep it in context.addrs */
                *outobj = *thisobj;
                outobj++;
                outrefs++;
            }
        }
        context.addrs->numrefs = outrefs;
 
        /* Record the self-dependencies with the appropriate direction */
        if (!reverse_self)
            recordMultipleDependencies(depender,
                                       self_addrs->refs, self_addrs->numrefs,
                                       self_behavior);
        else
        {
            /* Can't use recordMultipleDependencies, so do it the hard way */
            int         selfref;
 
            for (selfref = 0; selfref < self_addrs->numrefs; selfref++)
            {
                ObjectAddress *thisobj = self_addrs->refs + selfref;
 
                recordDependencyOn(thisobj, depender, self_behavior);
            }
        }
 
        free_object_addresses(self_addrs);
    }
 
    /* Record the external dependencies */
    recordMultipleDependencies(depender,
                               context.addrs->refs, context.addrs->numrefs,
                               behavior);
 
    free_object_addresses(context.addrs);
}

References AccessShareLock, add_exact_object_address(), find_expr_references_context::addrs, eliminate_duplicate_dependencies(), fb(), find_expr_references_walker(), free_object_addresses(), list_make1, new_object_addresses(), ObjectAddresses::numrefs, recordDependencyOn(), recordMultipleDependencies(), ObjectAddresses::refs, find_expr_references_context::rtables, and RTE_RELATION.

Referenced by CreateConstraintEntry(), CreateStatistics(), index_create(), insert_property_record(), publication_add_relation(), StoreAttrDefault(), and StorePartitionKey().

recordDependencyOnTablespace()

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

extern

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().

recordMultipleDependencies()

void recordMultipleDependencies ( const ObjectAddress *  depender, const ObjectAddress *  referenced, int  nreferenced, DependencyType  behavior  )

extern

Definition at line 63 of file pg_depend.c.

{
    Relation    dependDesc;
    CatalogIndexState indstate;
    TupleTableSlot **slot;
    int         i,
                max_slots,
                slot_init_count,
                slot_stored_count;
 
    if (nreferenced <= 0)
        return;                 /* nothing to do */
 
    /*
     * During bootstrap, do nothing since pg_depend may not exist yet.
     *
     * Objects created during bootstrap are most likely pinned, and the few
     * that are not do not have dependencies on each other, so that there
     * would be no need to make a pg_depend entry anyway.
     */
    if (IsBootstrapProcessingMode())
        return;
 
    dependDesc = table_open(DependRelationId, RowExclusiveLock);
 
    /*
     * Allocate the slots to use, but delay costly initialization until we
     * know that they will be used.
     */
    max_slots = Min(nreferenced,
                    MAX_CATALOG_MULTI_INSERT_BYTES / sizeof(FormData_pg_depend));
    slot = palloc_array(TupleTableSlot *, max_slots);
 
    /* Don't open indexes unless we need to make an update */
    indstate = NULL;
 
    /* number of slots currently storing tuples */
    slot_stored_count = 0;
    /* number of slots currently initialized */
    slot_init_count = 0;
    for (i = 0; i < nreferenced; i++, referenced++)
    {
        /*
         * If the referenced object is pinned by the system, there's no real
         * need to record dependencies on it.  This saves lots of space in
         * pg_depend, so it's worth the time taken to check.
         */
        if (isObjectPinned(referenced))
            continue;
 
        /*
         * Make sure the new referenced object doesn't go away while we record
         * the dependency.  DROP routines should lock the object exclusively
         * before they check dependencies.
         */
        dependencyLockAndCheckObject(referenced->classId, referenced->objectId);
 
        if (slot_init_count < max_slots)
        {
            slot[slot_stored_count] = MakeSingleTupleTableSlot(RelationGetDescr(dependDesc),
                                                               &TTSOpsHeapTuple);
            slot_init_count++;
        }
 
        ExecClearTuple(slot[slot_stored_count]);
 
        /*
         * Record the dependency.  Note we don't bother to check for duplicate
         * dependencies; there's no harm in them.
         */
        slot[slot_stored_count]->tts_values[Anum_pg_depend_refclassid - 1] = ObjectIdGetDatum(referenced->classId);
        slot[slot_stored_count]->tts_values[Anum_pg_depend_refobjid - 1] = ObjectIdGetDatum(referenced->objectId);
        slot[slot_stored_count]->tts_values[Anum_pg_depend_refobjsubid - 1] = Int32GetDatum(referenced->objectSubId);
        slot[slot_stored_count]->tts_values[Anum_pg_depend_deptype - 1] = CharGetDatum((char) behavior);
        slot[slot_stored_count]->tts_values[Anum_pg_depend_classid - 1] = ObjectIdGetDatum(depender->classId);
        slot[slot_stored_count]->tts_values[Anum_pg_depend_objid - 1] = ObjectIdGetDatum(depender->objectId);
        slot[slot_stored_count]->tts_values[Anum_pg_depend_objsubid - 1] = Int32GetDatum(depender->objectSubId);
 
        memset(slot[slot_stored_count]->tts_isnull, false,
               slot[slot_stored_count]->tts_tupleDescriptor->natts * sizeof(bool));
 
        ExecStoreVirtualTuple(slot[slot_stored_count]);
        slot_stored_count++;
 
        /* If slots are full, insert a batch of tuples */
        if (slot_stored_count == max_slots)
        {
            /* fetch index info only when we know we need it */
            if (indstate == NULL)
                indstate = CatalogOpenIndexes(dependDesc);
 
            CatalogTuplesMultiInsertWithInfo(dependDesc, slot, slot_stored_count,
                                             indstate);
            slot_stored_count = 0;
        }
    }
 
    /* Insert any tuples left in the buffer */
    if (slot_stored_count > 0)
    {
        /* fetch index info only when we know we need it */
        if (indstate == NULL)
            indstate = CatalogOpenIndexes(dependDesc);
 
        CatalogTuplesMultiInsertWithInfo(dependDesc, slot, slot_stored_count,
                                         indstate);
    }
 
    if (indstate != NULL)
        CatalogCloseIndexes(indstate);
 
    table_close(dependDesc, RowExclusiveLock);
 
    /* Drop only the number of slots used */
    for (i = 0; i < slot_init_count; i++)
        ExecDropSingleTupleTableSlot(slot[i]);
    pfree(slot);
}

References CatalogCloseIndexes(), CatalogOpenIndexes(), CatalogTuplesMultiInsertWithInfo(), CharGetDatum(), dependencyLockAndCheckObject(), ExecClearTuple(), ExecDropSingleTupleTableSlot(), ExecStoreVirtualTuple(), fb(), FormData_pg_depend, i, Int32GetDatum(), IsBootstrapProcessingMode, isObjectPinned(), MakeSingleTupleTableSlot(), MAX_CATALOG_MULTI_INSERT_BYTES, Min, ObjectIdGetDatum(), palloc_array, pfree(), RelationGetDescr, RowExclusiveLock, table_close(), table_open(), TupleTableSlot::tts_values, and TTSOpsHeapTuple.

Referenced by record_object_address_dependencies(), recordDependencyOn(), recordDependencyOnExpr(), and recordDependencyOnSingleRelExpr().

recordSharedDependencyOn()

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

extern

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().

ReleaseDeletionLock()

void ReleaseDeletionLock ( const ObjectAddress *  object )

extern

Definition at line 1599 of file dependency.c.

{
    if (object->classId == RelationRelationId)
        UnlockRelationOid(object->objectId, AccessExclusiveLock);
    else
        /* assume we should lock the whole object not a sub-object */
        UnlockDatabaseObject(object->classId, object->objectId, 0,
                             AccessExclusiveLock);
}

References AccessExclusiveLock, ObjectAddress::classId, fb(), ObjectAddressStack::object, ObjectAddress::objectId, UnlockDatabaseObject(), and UnlockRelationOid().

Referenced by findDependentObjects(), and shdepDropOwned().

sequenceIsOwned()

bool sequenceIsOwned ( Oid  seqId, char  deptype, Oid *  tableId, int32 *  colId  )

extern

Definition at line 1032 of file pg_depend.c.

{
    bool        ret = false;
    Relation    depRel;
    ScanKeyData key[2];
    SysScanDesc scan;
    HeapTuple   tup;
 
    depRel = table_open(DependRelationId, AccessShareLock);
 
    ScanKeyInit(&key[0],
                Anum_pg_depend_classid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(RelationRelationId));
    ScanKeyInit(&key[1],
                Anum_pg_depend_objid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(seqId));
 
    scan = systable_beginscan(depRel, DependDependerIndexId, true,
                              NULL, 2, key);
 
    while (HeapTupleIsValid((tup = systable_getnext(scan))))
    {
        Form_pg_depend depform = (Form_pg_depend) GETSTRUCT(tup);
 
        if (depform->refclassid == RelationRelationId &&
            depform->deptype == deptype)
        {
            *tableId = depform->refobjid;
            *colId = depform->refobjsubid;
            ret = true;
            break;              /* no need to keep scanning */
        }
    }
 
    systable_endscan(scan);
 
    table_close(depRel, AccessShareLock);
 
    return ret;
}

References AccessShareLock, BTEqualStrategyNumber, fb(), Form_pg_depend, GETSTRUCT(), HeapTupleIsValid, ObjectIdGetDatum(), ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), and table_open().

Referenced by AlterTableNamespace(), ATExecChangeOwner(), and process_owned_by().

shdepDropOwned()

void shdepDropOwned ( List *  roleids, DropBehavior  behavior  )

extern

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;
                    }
                    pg_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(), Form_pg_shdepend, free_object_addresses(), getObjectDescription(), GETSTRUCT(), InvalidOid, IsPinnedObject(), lfirst_oid, MyDatabaseId, new_object_addresses(), ObjectAddress::objectId, ObjectIdGetDatum(), ObjectAddress::objectSubId, performMultipleDeletions(), pg_fallthrough, 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  )

extern

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  )

extern

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(), Form_pg_shdepend, 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().

sort_object_addresses()

void sort_object_addresses ( ObjectAddresses *  addrs )

extern

Definition at line 2978 of file dependency.c.

{
    if (addrs->numrefs > 1)
        qsort(addrs->refs, addrs->numrefs,
              sizeof(ObjectAddress),
              object_address_comparator);
}

References ObjectAddresses::numrefs, object_address_comparator(), qsort, and ObjectAddresses::refs.

Referenced by shdepDropOwned().

updateAclDependencies()

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

extern

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().

updateInitAclDependencies()

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

extern

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().