src/include/catalog/dependency.h

   1 /*-------------------------------------------------------------------------
   2  *
   3  * dependency.h
   4  *        Routines to support inter-object dependencies.
   5  *
   6  *
   7  * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
   8  * Portions Copyright (c) 1994, Regents of the University of California
   9  *
  10  * src/include/catalog/dependency.h
  11  *
  12  *-------------------------------------------------------------------------
  13  */
  14 #ifndef DEPENDENCY_H
  15 #define DEPENDENCY_H
  16
  17 #include "catalog/objectaddress.h"
  18
  19
  20 /*
  21  * Precise semantics of a dependency relationship are specified by the
  22  * DependencyType code (which is stored in a "char" field in pg_depend,
  23  * so we assign ASCII-code values to the enumeration members).
  24  *
  25  * In all cases, a dependency relationship indicates that the referenced
  26  * object may not be dropped without also dropping the dependent object.
  27  * However, there are several subflavors; see the description of pg_depend
  28  * in catalogs.sgml for details.
  29  */
  30
  31 typedef enum DependencyType
  32 {
  33         DEPENDENCY_NORMAL = 'n',
  34         DEPENDENCY_AUTO = 'a',
  35         DEPENDENCY_INTERNAL = 'i',
  36         DEPENDENCY_PARTITION_PRI = 'P',
  37         DEPENDENCY_PARTITION_SEC = 'S',
  38         DEPENDENCY_EXTENSION = 'e',
  39         DEPENDENCY_AUTO_EXTENSION = 'x',
  40 } DependencyType;
  41
  42 /*
  43  * There is also a SharedDependencyType enum type that determines the exact
  44  * semantics of an entry in pg_shdepend.  Just like regular dependency entries,
  45  * any pg_shdepend entry means that the referenced object cannot be dropped
  46  * unless the dependent object is dropped at the same time.  There are some
  47  * additional rules however:
  48  *
  49  * (a) a SHARED_DEPENDENCY_OWNER entry means that the referenced object is
  50  * the role owning the dependent object.  The referenced object must be
  51  * a pg_authid entry.
  52  *
  53  * (b) a SHARED_DEPENDENCY_ACL entry means that the referenced object is
  54  * a role mentioned in the ACL field of the dependent object.  The referenced
  55  * object must be a pg_authid entry.  (SHARED_DEPENDENCY_ACL entries are not
  56  * created for the owner of an object; hence two objects may be linked by
  57  * one or the other, but not both, of these dependency types.)
  58  *
  59  * (c) a SHARED_DEPENDENCY_INITACL entry means that the referenced object is
  60  * a role mentioned in a pg_init_privs entry for the dependent object.
  61  * The referenced object must be a pg_authid entry.  (Unlike the case for
  62  * SHARED_DEPENDENCY_ACL, we make an entry for such a role whether or not
  63  * it is the object's owner.)
  64  *
  65  * (d) a SHARED_DEPENDENCY_POLICY entry means that the referenced object is
  66  * a role mentioned in a policy object.  The referenced object must be a
  67  * pg_authid entry.
  68  *
  69  * (e) a SHARED_DEPENDENCY_TABLESPACE entry means that the referenced
  70  * object is a tablespace mentioned in a relation without storage.  The
  71  * referenced object must be a pg_tablespace entry.  (Relations that have
  72  * storage don't need this: they are protected by the existence of a physical
  73  * file in the tablespace.)
  74  *
  75  * SHARED_DEPENDENCY_INVALID is a value used as a parameter in internal
  76  * routines, and is not valid in the catalog itself.
  77  */
  78 typedef enum SharedDependencyType
  79 {
  80         SHARED_DEPENDENCY_OWNER = 'o',
  81         SHARED_DEPENDENCY_ACL = 'a',
  82         SHARED_DEPENDENCY_INITACL = 'i',
  83         SHARED_DEPENDENCY_POLICY = 'r',
  84         SHARED_DEPENDENCY_TABLESPACE = 't',
  85         SHARED_DEPENDENCY_INVALID = 0,
  86 } SharedDependencyType;
  87
  88 /* expansible list of ObjectAddresses (private in dependency.c) */
  89 typedef struct ObjectAddresses ObjectAddresses;
  90
  91 /* flag bits for performDeletion/performMultipleDeletions: */
  92 #define PERFORM_DELETION_INTERNAL                       0x0001  /* internal action */
  93 #define PERFORM_DELETION_CONCURRENTLY           0x0002  /* concurrent drop */
  94 #define PERFORM_DELETION_QUIETLY                        0x0004  /* suppress notices */
  95 #define PERFORM_DELETION_SKIP_ORIGINAL          0x0008  /* keep original obj */
  96 #define PERFORM_DELETION_SKIP_EXTENSIONS        0x0010  /* keep extensions */
  97 #define PERFORM_DELETION_CONCURRENT_LOCK        0x0020  /* normal drop with
  98                                                                                                          * concurrent lock mode */
  99
 100
 101 /* in dependency.c */
 102
 103 extern void AcquireDeletionLock(const ObjectAddress *object, int flags);
 104
 105 extern void ReleaseDeletionLock(const ObjectAddress *object);
 106
 107 extern void performDeletion(const ObjectAddress *object,
 108                                                         DropBehavior behavior, int flags);
 109
 110 extern void performMultipleDeletions(const ObjectAddresses *objects,
 111                                                                          DropBehavior behavior, int flags);
 112
 113 extern void recordDependencyOnExpr(const ObjectAddress *depender,
 114                                                                    Node *expr, List *rtable,
 115                                                                    DependencyType behavior);
 116
 117 extern void recordDependencyOnSingleRelExpr(const ObjectAddress *depender,
 118                                                                                         Node *expr, Oid relId,
 119                                                                                         DependencyType behavior,
 120                                                                                         DependencyType self_behavior,
 121                                                                                         bool reverse_self);
 122
 123 extern ObjectAddresses *new_object_addresses(void);
 124
 125 extern void add_exact_object_address(const ObjectAddress *object,
 126                                                                          ObjectAddresses *addrs);
 127
 128 extern bool object_address_present(const ObjectAddress *object,
 129                                                                    const ObjectAddresses *addrs);
 130
 131 extern void record_object_address_dependencies(const ObjectAddress *depender,
 132                                                                                            ObjectAddresses *referenced,
 133                                                                                            DependencyType behavior);
 134
 135 extern void sort_object_addresses(ObjectAddresses *addrs);
 136
 137 extern void free_object_addresses(ObjectAddresses *addrs);
 138
 139 /* in pg_depend.c */
 140
 141 extern void recordDependencyOn(const ObjectAddress *depender,
 142                                                            const ObjectAddress *referenced,
 143                                                            DependencyType behavior);
 144
 145 extern void recordMultipleDependencies(const ObjectAddress *depender,
 146                                                                            const ObjectAddress *referenced,
 147                                                                            int nreferenced,
 148                                                                            DependencyType behavior);
 149
 150 extern void recordDependencyOnCurrentExtension(const ObjectAddress *object,
 151                                                                                            bool isReplace);
 152
 153 extern void checkMembershipInCurrentExtension(const ObjectAddress *object);
 154
 155 extern long deleteDependencyRecordsFor(Oid classId, Oid objectId,
 156                                                                            bool skipExtensionDeps);
 157
 158 extern long deleteDependencyRecordsForClass(Oid classId, Oid objectId,
 159                                                                                         Oid refclassId, char deptype);
 160
 161 extern long deleteDependencyRecordsForSpecific(Oid classId, Oid objectId,
 162                                                                                            char deptype,
 163                                                                                            Oid refclassId, Oid refobjectId);
 164
 165 extern long changeDependencyFor(Oid classId, Oid objectId,
 166                                                                 Oid refClassId, Oid oldRefObjectId,
 167                                                                 Oid newRefObjectId);
 168
 169 extern long changeDependenciesOf(Oid classId, Oid oldObjectId,
 170                                                                  Oid newObjectId);
 171
 172 extern long changeDependenciesOn(Oid refClassId, Oid oldRefObjectId,
 173                                                                  Oid newRefObjectId);
 174
 175 extern Oid      getExtensionOfObject(Oid classId, Oid objectId);
 176 extern List *getAutoExtensionsOfObject(Oid classId, Oid objectId);
 177
 178 extern bool sequenceIsOwned(Oid seqId, char deptype, Oid *tableId, int32 *colId);
 179 extern List *getOwnedSequences(Oid relid);
 180 extern Oid      getIdentitySequence(Relation rel, AttrNumber attnum, bool missing_ok);
 181
 182 extern Oid      get_index_constraint(Oid indexId);
 183
 184 extern List *get_index_ref_constraints(Oid indexId);
 185
 186 /* in pg_shdepend.c */
 187
 188 extern void recordSharedDependencyOn(ObjectAddress *depender,
 189                                                                          ObjectAddress *referenced,
 190                                                                          SharedDependencyType deptype);
 191
 192 extern void deleteSharedDependencyRecordsFor(Oid classId, Oid objectId,
 193                                                                                          int32 objectSubId);
 194
 195 extern void recordDependencyOnOwner(Oid classId, Oid objectId, Oid owner);
 196
 197 extern void changeDependencyOnOwner(Oid classId, Oid objectId,
 198                                                                         Oid newOwnerId);
 199
 200 extern void recordDependencyOnTablespace(Oid classId, Oid objectId,
 201                                                                                  Oid tablespace);
 202
 203 extern void changeDependencyOnTablespace(Oid classId, Oid objectId,
 204                                                                                  Oid newTablespaceId);
 205
 206 extern void updateAclDependencies(Oid classId, Oid objectId, int32 objsubId,
 207                                                                   Oid ownerId,
 208                                                                   int noldmembers, Oid *oldmembers,
 209                                                                   int nnewmembers, Oid *newmembers);
 210
 211 extern void updateInitAclDependencies(Oid classId, Oid objectId, int32 objsubId,
 212                                                                           int noldmembers, Oid *oldmembers,
 213                                                                           int nnewmembers, Oid *newmembers);
 214
 215 extern bool checkSharedDependencies(Oid classId, Oid objectId,
 216                                                                         char **detail_msg, char **detail_log_msg);
 217
 218 extern void shdepLockAndCheckObject(Oid classId, Oid objectId);
 219
 220 extern void copyTemplateDependencies(Oid templateDbId, Oid newDbId);
 221
 222 extern void dropDatabaseDependencies(Oid databaseId);
 223
 224 extern void shdepDropOwned(List *roleids, DropBehavior behavior);
 225
 226 extern void shdepReassignOwned(List *roleids, Oid newrole);
 227
 228 #endif                                                  /* DEPENDENCY_H */