/*-------------------------------------------------------------------------
 *
 * pg_shdepend.c
 *   routines to support manipulation of the pg_shdepend relation
 *
 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 *
 * IDENTIFICATION
 *   src/backend/catalog/pg_shdepend.c
 *
 *-------------------------------------------------------------------------
 */
#include "postgres.h"

#include "access/genam.h"
#include "access/htup_details.h"
#include "access/table.h"
#include "access/xact.h"
#include "catalog/catalog.h"
#include "catalog/dependency.h"
#include "catalog/indexing.h"
#include "catalog/pg_authid.h"
#include "catalog/pg_auth_members.h"
#include "catalog/pg_collation.h"
#include "catalog/pg_conversion.h"
#include "catalog/pg_database.h"
#include "catalog/pg_default_acl.h"
#include "catalog/pg_event_trigger.h"
#include "catalog/pg_extension.h"
#include "catalog/pg_foreign_data_wrapper.h"
#include "catalog/pg_foreign_server.h"
#include "catalog/pg_language.h"
#include "catalog/pg_largeobject.h"
#include "catalog/pg_namespace.h"
#include "catalog/pg_opclass.h"
#include "catalog/pg_operator.h"
#include "catalog/pg_opfamily.h"
#include "catalog/pg_proc.h"
#include "catalog/pg_shdepend.h"
#include "catalog/pg_statistic_ext.h"
#include "catalog/pg_subscription.h"
#include "catalog/pg_tablespace.h"
#include "catalog/pg_ts_config.h"
#include "catalog/pg_ts_dict.h"
#include "catalog/pg_type.h"
#include "catalog/pg_user_mapping.h"
#include "commands/alter.h"
#include "commands/dbcommands.h"
#include "commands/defrem.h"
#include "commands/event_trigger.h"
#include "commands/policy.h"
#include "commands/publicationcmds.h"
#include "commands/schemacmds.h"
#include "commands/subscriptioncmds.h"
#include "commands/tablecmds.h"
#include "commands/tablespace.h"
#include "commands/typecmds.h"
#include "miscadmin.h"
#include "storage/lmgr.h"
#include "utils/acl.h"
#include "utils/fmgroids.h"
#include "utils/memutils.h"
#include "utils/syscache.h"

typedef enum
{
 LOCAL_OBJECT,
 SHARED_OBJECT,
 REMOTE_OBJECT,
} SharedDependencyObjectType;

typedef struct
{
 ObjectAddress object;
 char  deptype;
 SharedDependencyObjectType objtype;
} ShDependObjectInfo;

static void getOidListDiff(Oid *list1, int *nlist1, Oid *list2, int *nlist2);
static Oid classIdGetDbId(Oid classId);
static void shdepChangeDep(Relation sdepRel,
         Oid classid, Oid objid, int32 objsubid,
         Oid refclassid, Oid refobjid,
         SharedDependencyType deptype);
static void updateAclDependenciesWorker(Oid classId, Oid objectId,
          int32 objsubId, Oid ownerId,
          SharedDependencyType deptype,
          int noldmembers, Oid *oldmembers,
          int nnewmembers, Oid *newmembers);
static void shdepAddDependency(Relation sdepRel,
          Oid classId, Oid objectId, int32 objsubId,
          Oid refclassId, Oid refobjId,
          SharedDependencyType deptype);
static void shdepDropDependency(Relation sdepRel,
        Oid classId, Oid objectId, int32 objsubId,
        bool drop_subobjects,
        Oid refclassId, Oid refobjId,
        SharedDependencyType deptype);
static void storeObjectDescription(StringInfo descs,
           SharedDependencyObjectType type,
           ObjectAddress *object,
           SharedDependencyType deptype,
           int count);
static void shdepReassignOwned_Owner(Form_pg_shdepend sdepForm, Oid newrole);
static void shdepReassignOwned_InitAcl(Form_pg_shdepend sdepForm,
            Oid oldrole, Oid newrole);


/*
 * recordSharedDependencyOn
 *
 * Record a dependency between 2 objects via their respective ObjectAddresses.
 * The first argument is the dependent object, the second the one it
 * references (which must be a shared object).
 *
 * This locks the referenced object and makes sure it still exists.
 * Then it creates an entry in pg_shdepend.  The lock is kept until
 * the end of the transaction.
 *
 * Dependencies on pinned objects are not recorded.
 */
void
recordSharedDependencyOn(ObjectAddress *depender,
       ObjectAddress *referenced,
       SharedDependencyType deptype)
{
 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);
}

/*
 * recordDependencyOnOwner
 *
 * A convenient wrapper of recordSharedDependencyOn -- register the specified
 * user as owner of the given object.
 *
 * Note: it's the caller's responsibility to ensure that there isn't an owner
 * entry for the object already.
 */
void
recordDependencyOnOwner(Oid classId, Oid objectId, Oid owner)
{
 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);
}

/*
 * shdepChangeDep
 *
 * Update shared dependency records to account for an updated referenced
 * object.  This is an internal workhorse for operations such as changing
 * an object's owner.
 *
 * There must be no more than one existing entry for the given dependent
 * object and dependency type! So in practice this can only be used for
 * updating SHARED_DEPENDENCY_OWNER and SHARED_DEPENDENCY_TABLESPACE
 * entries, which should have that property.
 *
 * If there is no previous entry, we assume it was referencing a PINned
 * object, so we create a new entry.  If the new referenced object is
 * PINned, we don't create an entry (and drop the old one, if any).
 * (For tablespaces, we don't record dependencies in certain cases, so
 * there are other possible reasons for entries to be missing.)
 *
 * sdepRel must be the pg_shdepend relation, already opened and suitably
 * locked.
 */
static void
shdepChangeDep(Relation sdepRel,
      Oid classid, Oid objid, int32 objsubid,
      Oid refclassid, Oid refobjid,
      SharedDependencyType deptype)
{
 Oid   dbid = classIdGetDbId(classid);
 HeapTuple oldtup = NULL;
 HeapTuple scantup;
 ScanKeyData key[4];
 SysScanDesc scan;

 /*
  * Make sure the new referenced object doesn't go away while we record the
  * dependency.
 */
 shdepLockAndCheckObject(refclassid, refobjid);

 /*
  * Look for a previous entry
 */
 ScanKeyInit(&key[0],
    Anum_pg_shdepend_dbid,
    BTEqualStrategyNumber, F_OIDEQ,
    ObjectIdGetDatum(dbid));
 ScanKeyInit(&key[1],
    Anum_pg_shdepend_classid,
    BTEqualStrategyNumber, F_OIDEQ,
    ObjectIdGetDatum(classid));
 ScanKeyInit(&key[2],
    Anum_pg_shdepend_objid,
    BTEqualStrategyNumber, F_OIDEQ,
    ObjectIdGetDatum(objid));
 ScanKeyInit(&key[3],
    Anum_pg_shdepend_objsubid,
    BTEqualStrategyNumber, F_INT4EQ,
    Int32GetDatum(objsubid));

 scan = systable_beginscan(sdepRel, SharedDependDependerIndexId, true,
         NULL, 4, key);

 while ((scantup = systable_getnext(scan)) != NULL)
 {
  /* Ignore if not of the target dependency type */
  if (((Form_pg_shdepend) GETSTRUCT(scantup))->deptype != deptype)
   continue;
  /* Caller screwed up if multiple matches */
  if (oldtup)
   elog(ERROR,
     "multiple pg_shdepend entries for object %u/%u/%d deptype %c",
     classid, objid, objsubid, deptype);
  oldtup = heap_copytuple(scantup);
 }

 systable_endscan(scan);

 if (IsPinnedObject(refclassid, refobjid))
 {
  /* No new entry needed, so just delete existing entry if any */
  if (oldtup)
   CatalogTupleDelete(sdepRel, &oldtup->t_self);
 }
 else if (oldtup)
 {
  /* Need to update existing entry */
  Form_pg_shdepend shForm = (Form_pg_shdepend) GETSTRUCT(oldtup);

  /* Since oldtup is a copy, we can just modify it in-memory */
  shForm->refclassid = refclassid;
  shForm->refobjid = refobjid;

  CatalogTupleUpdate(sdepRel, &oldtup->t_self, oldtup);
 }
 else
 {
  /* Need to insert new entry */
  Datum  values[Natts_pg_shdepend];
  bool  nulls[Natts_pg_shdepend];

  memset(nulls, false, sizeof(nulls));

  values[Anum_pg_shdepend_dbid - 1] = ObjectIdGetDatum(dbid);
  values[Anum_pg_shdepend_classid - 1] = ObjectIdGetDatum(classid);
  values[Anum_pg_shdepend_objid - 1] = ObjectIdGetDatum(objid);
  values[Anum_pg_shdepend_objsubid - 1] = Int32GetDatum(objsubid);

  values[Anum_pg_shdepend_refclassid - 1] = ObjectIdGetDatum(refclassid);
  values[Anum_pg_shdepend_refobjid - 1] = ObjectIdGetDatum(refobjid);
  values[Anum_pg_shdepend_deptype - 1] = CharGetDatum(deptype);

  /*
   * we are reusing oldtup just to avoid declaring a new variable, but
   * it's certainly a new tuple
 */
  oldtup = heap_form_tuple(RelationGetDescr(sdepRel), values, nulls);
  CatalogTupleInsert(sdepRel, oldtup);
 }

 if (oldtup)
  heap_freetuple(oldtup);
}

/*
 * changeDependencyOnOwner
 *
 * Update the shared dependencies to account for the new owner.
 *
 * Note: we don't need an objsubid argument because only whole objects
 * have owners.
 */
void
changeDependencyOnOwner(Oid classId, Oid objectId, Oid newOwnerId)
{
 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);
}

/*
 * recordDependencyOnTablespace
 *
 * A convenient wrapper of recordSharedDependencyOn -- register the specified
 * tablespace as default for the given object.
 *
 * Note: it's the caller's responsibility to ensure that there isn't a
 * tablespace entry for the object already.
 */
void
recordDependencyOnTablespace(Oid classId, Oid objectId, Oid tablespace)
{
 ObjectAddress myself,
    referenced;

 ObjectAddressSet(myself, classId, objectId);
 ObjectAddressSet(referenced, TableSpaceRelationId, tablespace);

 recordSharedDependencyOn(&myself, &referenced,
        SHARED_DEPENDENCY_TABLESPACE);
}

/*
 * changeDependencyOnTablespace
 *
 * Update the shared dependencies to account for the new tablespace.
 *
 * Note: we don't need an objsubid argument because only whole objects
 * have tablespaces.
 */
void
changeDependencyOnTablespace(Oid classId, Oid objectId, Oid newTablespaceId)
{
 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);
}

/*
 * getOidListDiff
 *  Helper for updateAclDependencies.
 *
 * Takes two Oid arrays and removes elements that are common to both arrays,
 * leaving just those that are in one input but not the other.
 * We assume both arrays have been sorted and de-duped.
 */
static void
getOidListDiff(Oid *list1, int *nlist1, Oid *list2, int *nlist2)
{
 int   in1,
    in2,
    out1,
    out2;

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

 /* any remaining list1 entries are not in list2 */
 while (in1 < *nlist1)
 {
  list1[out1++] = list1[in1++];
 }

 /* any remaining list2 entries are not in list1 */
 while (in2 < *nlist2)
 {
  list2[out2++] = list2[in2++];
 }

 *nlist1 = out1;
 *nlist2 = out2;
}

/*
 * updateAclDependencies
 *  Update the pg_shdepend info for an object's ACL during GRANT/REVOKE.
 *
 * classId, objectId, objsubId: identify the object whose ACL this is
 * ownerId: role owning the object
 * noldmembers, oldmembers: array of roleids appearing in old ACL
 * nnewmembers, newmembers: array of roleids appearing in new ACL
 *
 * We calculate the differences between the new and old lists of roles,
 * and then insert or delete from pg_shdepend as appropriate.
 *
 * Note that we can't just insert all referenced roles blindly during GRANT,
 * because we would end up with duplicate registered dependencies.  We could
 * check for existence of the tuples before inserting, but that seems to be
 * more expensive than what we are doing here.  Likewise we can't just delete
 * blindly during REVOKE, because the user may still have other privileges.
 * It is also possible that REVOKE actually adds dependencies, due to
 * instantiation of a formerly implicit default ACL (although at present,
 * all such dependencies should be for the owning role, which we ignore here).
 *
 * NOTE: Both input arrays must be sorted and de-duped.  (Typically they
 * are extracted from an ACL array by aclmembers(), which takes care of
 * both requirements.) The arrays are pfreed before return.
 */
void
updateAclDependencies(Oid classId, Oid objectId, int32 objsubId,
       Oid ownerId,
       int noldmembers, Oid *oldmembers,
       int nnewmembers, Oid *newmembers)
{
 updateAclDependenciesWorker(classId, objectId, objsubId,
        ownerId, SHARED_DEPENDENCY_ACL,
        noldmembers, oldmembers,
        nnewmembers, newmembers);
}

/*
 * updateInitAclDependencies
 *  Update the pg_shdepend info for a pg_init_privs entry.
 *
 * Exactly like updateAclDependencies, except we are considering a
 * pg_init_privs ACL for the specified object.  Since recording of
 * pg_init_privs role dependencies is the same for owners and non-owners,
 * we do not need an ownerId argument.
 */
void
updateInitAclDependencies(Oid classId, Oid objectId, int32 objsubId,
        int noldmembers, Oid *oldmembers,
        int nnewmembers, Oid *newmembers)
{
 updateAclDependenciesWorker(classId, objectId, objsubId,
        InvalidOid, /* ownerId will not be consulted */
        SHARED_DEPENDENCY_INITACL,
        noldmembers, oldmembers,
        nnewmembers, newmembers);
}

/* Common code for the above two functions */
static void
updateAclDependenciesWorker(Oid classId, Oid objectId, int32 objsubId,
       Oid ownerId, SharedDependencyType deptype,
       int noldmembers, Oid *oldmembers,
       int nnewmembers, Oid *newmembers)
{
 Relation sdepRel;
 int   i;

 /*
  * Remove entries that are common to both lists; those represent existing
  * dependencies we don't need to change.
  *
  * OK to overwrite the inputs since we'll pfree them anyway.
 */
 getOidListDiff(oldmembers, &noldmembers, newmembers, &nnewmembers);

 if (noldmembers > 0 || nnewmembers > 0)
 {
  sdepRel = table_open(SharedDependRelationId, RowExclusiveLock);

  /* Add new dependencies that weren't already present */
  for (i = 0; i < nnewmembers; i++)
  {
   Oid   roleid = newmembers[i];

   /*
    * For SHARED_DEPENDENCY_ACL entries, skip the owner: she has an
    * OWNER shdep entry instead.  (This is not just a space
    * optimization; it makes ALTER OWNER easier.  See notes in
    * changeDependencyOnOwner.)  But for INITACL entries, we record
    * the owner too.
 */
   if (deptype == SHARED_DEPENDENCY_ACL && roleid == ownerId)
    continue;

   /* Skip pinned roles; they don't need dependency entries */
   if (IsPinnedObject(AuthIdRelationId, roleid))
    continue;

   shdepAddDependency(sdepRel, classId, objectId, objsubId,
          AuthIdRelationId, roleid,
          deptype);
  }

  /* Drop no-longer-used old dependencies */
  for (i = 0; i < noldmembers; i++)
  {
   Oid   roleid = oldmembers[i];

   /* Skip the owner for ACL entries, same as above */
   if (deptype == SHARED_DEPENDENCY_ACL && roleid == ownerId)
    continue;

   /* Skip pinned roles */
   if (IsPinnedObject(AuthIdRelationId, roleid))
    continue;

   shdepDropDependency(sdepRel, classId, objectId, objsubId,
        false, /* exact match on objsubId */
        AuthIdRelationId, roleid,
        deptype);
  }

  table_close(sdepRel, RowExclusiveLock);
 }

 if (oldmembers)
  pfree(oldmembers);
 if (newmembers)
  pfree(newmembers);
}

/*
 * A struct to keep track of dependencies found in other databases.
 */
typedef struct
{
 Oid   dbOid;
 int   count;
} remoteDep;

/*
 * qsort comparator for ShDependObjectInfo items
 */
static int
shared_dependency_comparator(const void *a, const void *b)
{
 const ShDependObjectInfo *obja = (const ShDependObjectInfo *) a;
 const ShDependObjectInfo *objb = (const ShDependObjectInfo *) b;

 /*
  * Primary sort key is OID ascending.
 */
 if (obja->object.objectId < objb->object.objectId)
  return -1;
 if (obja->object.objectId > objb->object.objectId)
  return 1;

 /*
  * Next sort on catalog ID, in case identical OIDs appear in different
  * catalogs.  Sort direction is pretty arbitrary here.
 */
 if (obja->object.classId < objb->object.classId)
  return -1;
 if (obja->object.classId > objb->object.classId)
  return 1;

 /*
  * Sort on object subId.
  *
  * We sort the subId as an unsigned int so that 0 (the whole object) will
  * come first.
 */
 if ((unsigned int) obja->object.objectSubId < (unsigned int) objb->object.objectSubId)
  return -1;
 if ((unsigned int) obja->object.objectSubId > (unsigned int) objb->object.objectSubId)
  return 1;

 /*
  * Last, sort on deptype, in case the same object has multiple dependency
  * types.  (Note that there's no need to consider objtype, as that's
  * determined by the catalog OID.)
 */
 if (obja->deptype < objb->deptype)
  return -1;
 if (obja->deptype > objb->deptype)
  return 1;

 return 0;
}

/*
 * checkSharedDependencies
 *
 * Check whether there are shared dependency entries for a given shared
 * object; return true if so.
 *
 * In addition, return a string containing a newline-separated list of object
 * descriptions that depend on the shared object, or NULL if none is found.
 * We actually return two such strings; the "detail" result is suitable for
 * returning to the client as an errdetail() string, and is limited in size.
 * The "detail_log" string is potentially much longer, and should be emitted
 * to the server log only.
 *
 * We can find three different kinds of dependencies: dependencies on objects
 * of the current database; dependencies on shared objects; and dependencies
 * on objects local to other databases.  We can (and do) provide descriptions
 * of the two former kinds of objects, but we can't do that for "remote"
 * objects, so we just provide a count of them.
 */
bool
checkSharedDependencies(Oid classId, Oid objectId,
      char **detail_msg, char **detail_log_msg)
{
 Relation sdepRel;
 ScanKeyData key[2];
 SysScanDesc scan;
 HeapTuple tup;
 int   numReportedDeps = 0;
 int   numNotReportedDeps = 0;
 int   numNotReportedDbs = 0;
 List    *remDeps = NIL;
 ListCell   *cell;
 ObjectAddress object;
 ShDependObjectInfo *objects;
 int   numobjects;
 int   allocedobjects;
 StringInfoData descs;
 StringInfoData alldescs;

 /* This case can be dispatched quickly */
 if (IsPinnedObject(classId, objectId))
 {
  object.classId = classId;
  object.objectId = objectId;
  object.objectSubId = 0;
  ereport(ERROR,
    (errcode(ERRCODE_DEPENDENT_OBJECTS_STILL_EXIST),
     errmsg("cannot drop %s because it is required by the database system",
      getObjectDescription(&object, false))));
 }

 /*
  * We limit the number of dependencies reported to the client to
  * MAX_REPORTED_DEPS, since client software may not deal well with
  * enormous error strings.  The server log always gets a full report.
  *
  * For stability of regression test results, we sort local and shared
  * objects by OID before reporting them.  We don't worry about the order
  * in which other databases are reported, though.
 */
#define MAX_REPORTED_DEPS 100

 allocedobjects = 128;  /* arbitrary initial array size */
 objects = (ShDependObjectInfo *)
  palloc(allocedobjects * sizeof(ShDependObjectInfo));
 numobjects = 0;
 initStringInfo(&descs);
 initStringInfo(&alldescs);

 sdepRel = table_open(SharedDependRelationId, AccessShareLock);

 ScanKeyInit(&key[0],
    Anum_pg_shdepend_refclassid,
    BTEqualStrategyNumber, F_OIDEQ,
    ObjectIdGetDatum(classId));
 ScanKeyInit(&key[1],
    Anum_pg_shdepend_refobjid,
    BTEqualStrategyNumber, F_OIDEQ,
    ObjectIdGetDatum(objectId));

 scan = systable_beginscan(sdepRel, SharedDependReferenceIndexId, true,
         NULL, 2, key);

 while (HeapTupleIsValid(tup = systable_getnext(scan)))
 {
  Form_pg_shdepend sdepForm = (Form_pg_shdepend) GETSTRUCT(tup);

  object.classId = sdepForm->classid;
  object.objectId = sdepForm->objid;
  object.objectSubId = sdepForm->objsubid;

  /*
   * If it's a dependency local to this database or it's a shared
   * object, add it to the objects array.
   *
   * If it's a remote dependency, keep track of it so we can report the
   * number of them later.
 */
  if (sdepForm->dbid == MyDatabaseId ||
   sdepForm->dbid == InvalidOid)
  {
   if (numobjects >= allocedobjects)
   {
    allocedobjects *= 2;
    objects = (ShDependObjectInfo *)
     repalloc(objects,
        allocedobjects * sizeof(ShDependObjectInfo));
   }
   objects[numobjects].object = object;
   objects[numobjects].deptype = sdepForm->deptype;
   objects[numobjects].objtype = (sdepForm->dbid == MyDatabaseId) ?
    LOCAL_OBJECT : SHARED_OBJECT;
   numobjects++;
  }
  else
  {
   /* It's not local nor shared, so it must be remote. */
   remoteDep  *dep;
   bool  stored = false;

   /*
    * XXX this info is kept on a simple List.  Maybe it's not good
    * for performance, but using a hash table seems needlessly
    * complex.  The expected number of databases is not high anyway,
    * I suppose.
 */
   foreach(cell, remDeps)
   {
    dep = lfirst(cell);
    if (dep->dbOid == sdepForm->dbid)
    {
     dep->count++;
     stored = true;
     break;
    }
   }
   if (!stored)
   {
    dep = (remoteDep *) palloc(sizeof(remoteDep));
    dep->dbOid = sdepForm->dbid;
    dep->count = 1;
    remDeps = lappend(remDeps, dep);
   }
  }
 }

 systable_endscan(scan);

 table_close(sdepRel, AccessShareLock);

 /*
  * Sort and report local and shared objects.
 */
 if (numobjects > 1)
  qsort(objects, numobjects,
     sizeof(ShDependObjectInfo), shared_dependency_comparator);

 for (int i = 0; i < numobjects; i++)
 {
  if (numReportedDeps < MAX_REPORTED_DEPS)
  {
   numReportedDeps++;
   storeObjectDescription(&descs,
           objects[i].objtype,
           &objects[i].object,
           objects[i].deptype,
           0);
  }
  else
   numNotReportedDeps++;
  storeObjectDescription(&alldescs,
          objects[i].objtype,
          &objects[i].object,
          objects[i].deptype,
          0);
 }

 /*
  * Summarize dependencies in remote databases.
 */
 foreach(cell, remDeps)
 {
  remoteDep  *dep = lfirst(cell);

  object.classId = DatabaseRelationId;
  object.objectId = dep->dbOid;
  object.objectSubId = 0;

  if (numReportedDeps < MAX_REPORTED_DEPS)
  {
   numReportedDeps++;
   storeObjectDescription(&descs, REMOTE_OBJECT, &object,
           SHARED_DEPENDENCY_INVALID, dep->count);
  }
  else
   numNotReportedDbs++;
  storeObjectDescription(&alldescs, REMOTE_OBJECT, &object,
          SHARED_DEPENDENCY_INVALID, dep->count);
 }

 pfree(objects);
 list_free_deep(remDeps);

 if (descs.len == 0)
 {
  pfree(descs.data);
  pfree(alldescs.data);
  *detail_msg = *detail_log_msg = NULL;
  return false;
 }

 if (numNotReportedDeps > 0)
  appendStringInfo(&descs, ngettext("\nand %d other object "
            "(see server log for list)",
            "\nand %d other objects "
            "(see server log for list)",
            numNotReportedDeps),
       numNotReportedDeps);
 if (numNotReportedDbs > 0)
  appendStringInfo(&descs, ngettext("\nand objects in %d other database "
            "(see server log for list)",
            "\nand objects in %d other databases "
            "(see server log for list)",
            numNotReportedDbs),
       numNotReportedDbs);

 *detail_msg = descs.data;
 *detail_log_msg = alldescs.data;
 return true;
}


/*
 * copyTemplateDependencies
 *
 * Routine to create the initial shared dependencies of a new database.
 * We simply copy the dependencies from the template database.
 */
void
copyTemplateDependencies(Oid templateDbId, Oid newDbId)
{
 Relation sdepRel;
 TupleDesc sdepDesc;
 ScanKeyData key[1];
 SysScanDesc scan;
 HeapTuple tup;
 CatalogIndexState indstate;
 TupleTableSlot **slot;
 int   max_slots,
    slot_init_count,
    slot_stored_count;

 sdepRel = table_open(SharedDependRelationId, RowExclusiveLock);
 sdepDesc = RelationGetDescr(sdepRel);

 /*
  * Allocate the slots to use, but delay costly initialization until we
  * know that they will be used.
 */
 max_slots = MAX_CATALOG_MULTI_INSERT_BYTES / sizeof(FormData_pg_shdepend);
 slot = palloc(sizeof(TupleTableSlot *) * max_slots);

 indstate = CatalogOpenIndexes(sdepRel);

 /* Scan all entries with dbid = templateDbId */
 ScanKeyInit(&key[0],
    Anum_pg_shdepend_dbid,
    BTEqualStrategyNumber, F_OIDEQ,
    ObjectIdGetDatum(templateDbId));

 scan = systable_beginscan(sdepRel, SharedDependDependerIndexId, true,
         NULL, 1, key);

 /* number of slots currently storing tuples */
 slot_stored_count = 0;
 /* number of slots currently initialized */
 slot_init_count = 0;

 /*
  * Copy the entries of the original database, changing the database Id to
  * that of the new database.  Note that because we are not copying rows
  * with dbId == 0 (ie, rows describing dependent shared objects) we won't
  * copy the ownership dependency of the template database itself; this is
  * what we want.
 */
 while (HeapTupleIsValid(tup = systable_getnext(scan)))
 {
  Form_pg_shdepend shdep;

  if (slot_init_count < max_slots)
  {
   slot[slot_stored_count] = MakeSingleTupleTableSlot(sdepDesc, &TTSOpsHeapTuple);
   slot_init_count++;
  }

  ExecClearTuple(slot[slot_stored_count]);

  memset(slot[slot_stored_count]->tts_isnull, false,
      slot[slot_stored_count]->tts_tupleDescriptor->natts * sizeof(bool));

  shdep = (Form_pg_shdepend) GETSTRUCT(tup);

  slot[slot_stored_count]->tts_values[Anum_pg_shdepend_dbid - 1] = ObjectIdGetDatum(newDbId);
  slot[slot_stored_count]->tts_values[Anum_pg_shdepend_classid - 1] = shdep->classid;
  slot[slot_stored_count]->tts_values[Anum_pg_shdepend_objid - 1] = shdep->objid;
  slot[slot_stored_count]->tts_values[Anum_pg_shdepend_objsubid - 1] = shdep->objsubid;
  slot[slot_stored_count]->tts_values[Anum_pg_shdepend_refclassid - 1] = shdep->refclassid;
  slot[slot_stored_count]->tts_values[Anum_pg_shdepend_refobjid - 1] = shdep->refobjid;
  slot[slot_stored_count]->tts_values[Anum_pg_shdepend_deptype - 1] = shdep->deptype;

  ExecStoreVirtualTuple(slot[slot_stored_count]);
  slot_stored_count++;

  /* If slots are full, insert a batch of tuples */
  if (slot_stored_count == max_slots)
  {
   CatalogTuplesMultiInsertWithInfo(sdepRel, slot, slot_stored_count, indstate);
   slot_stored_count = 0;
  }
 }

 /* Insert any tuples left in the buffer */
 if (slot_stored_count > 0)
  CatalogTuplesMultiInsertWithInfo(sdepRel, slot, slot_stored_count, indstate);

 systable_endscan(scan);

 CatalogCloseIndexes(indstate);
 table_close(sdepRel, RowExclusiveLock);

 /* Drop only the number of slots used */
 for (int i = 0; i < slot_init_count; i++)
  ExecDropSingleTupleTableSlot(slot[i]);
 pfree(slot);
}

/*
 * dropDatabaseDependencies
 *
 * Delete pg_shdepend entries corresponding to a database that's being
 * dropped.
 */
void
dropDatabaseDependencies(Oid databaseId)
{
 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);
}

/*
 * deleteSharedDependencyRecordsFor
 *
 * Delete all pg_shdepend entries corresponding to an object that's being
 * dropped or modified.  The object is assumed to be either a shared object
 * or local to the current database (the classId tells us which).
 *
 * If objectSubId is zero, we are deleting a whole object, so get rid of
 * pg_shdepend entries for subobjects as well.
 */
void
deleteSharedDependencyRecordsFor(Oid classId, Oid objectId, int32 objectSubId)
{
 Relation sdepRel;

 sdepRel = table_open(SharedDependRelationId, RowExclusiveLock);

 shdepDropDependency(sdepRel, classId, objectId, objectSubId,
      (objectSubId == 0),
      InvalidOid, InvalidOid,
      SHARED_DEPENDENCY_INVALID);

 table_close(sdepRel, RowExclusiveLock);
}

/*
 * shdepAddDependency
 *  Internal workhorse for inserting into pg_shdepend
 *
 * sdepRel must be the pg_shdepend relation, already opened and suitably
 * locked.
 */
static void
shdepAddDependency(Relation sdepRel,
       Oid classId, Oid objectId, int32 objsubId,
       Oid refclassId, Oid refobjId,
       SharedDependencyType deptype)
{
 HeapTuple tup;
 Datum  values[Natts_pg_shdepend];
 bool  nulls[Natts_pg_shdepend];

 /*
  * Make sure the object doesn't go away while we record the dependency on
  * it.  DROP routines should lock the object exclusively before they check
  * shared dependencies.
 */
 shdepLockAndCheckObject(refclassId, refobjId);

 memset(nulls, false, sizeof(nulls));

 /*
  * Form the new tuple and record the dependency.
 */
 values[Anum_pg_shdepend_dbid - 1] = ObjectIdGetDatum(classIdGetDbId(classId));
 values[Anum_pg_shdepend_classid - 1] = ObjectIdGetDatum(classId);
 values[Anum_pg_shdepend_objid - 1] = ObjectIdGetDatum(objectId);
 values[Anum_pg_shdepend_objsubid - 1] = Int32GetDatum(objsubId);

 values[Anum_pg_shdepend_refclassid - 1] = ObjectIdGetDatum(refclassId);
 values[Anum_pg_shdepend_refobjid - 1] = ObjectIdGetDatum(refobjId);
 values[Anum_pg_shdepend_deptype - 1] = CharGetDatum(deptype);

 tup = heap_form_tuple(sdepRel->rd_att, values, nulls);

 CatalogTupleInsert(sdepRel, tup);

 /* clean up */
 heap_freetuple(tup);
}

/*
 * shdepDropDependency
 *  Internal workhorse for deleting entries from pg_shdepend.
 *
 * We drop entries having the following properties:
 * dependent object is the one identified by classId/objectId/objsubId
 * if refclassId isn't InvalidOid, it must match the entry's refclassid
 * if refobjId isn't InvalidOid, it must match the entry's refobjid
 * if deptype isn't SHARED_DEPENDENCY_INVALID, it must match entry's deptype
 *
 * If drop_subobjects is true, we ignore objsubId and consider all entries
 * matching classId/objectId.
 *
 * sdepRel must be the pg_shdepend relation, already opened and suitably
 * locked.
 */
static void
shdepDropDependency(Relation sdepRel,
     Oid classId, Oid objectId, int32 objsubId,
     bool drop_subobjects,
     Oid refclassId, Oid refobjId,
     SharedDependencyType deptype)
{
 ScanKeyData key[4];
 int   nkeys;
 SysScanDesc scan;
 HeapTuple tup;

 /* Scan for entries matching the dependent object */
 ScanKeyInit(&key[0],
    Anum_pg_shdepend_dbid,
    BTEqualStrategyNumber, F_OIDEQ,
    ObjectIdGetDatum(classIdGetDbId(classId)));
 ScanKeyInit(&key[1],
    Anum_pg_shdepend_classid,
    BTEqualStrategyNumber, F_OIDEQ,
    ObjectIdGetDatum(classId));
 ScanKeyInit(&key[2],
    Anum_pg_shdepend_objid,
    BTEqualStrategyNumber, F_OIDEQ,
    ObjectIdGetDatum(objectId));
 if (drop_subobjects)
  nkeys = 3;
 else
 {
  ScanKeyInit(&key[3],
     Anum_pg_shdepend_objsubid,
     BTEqualStrategyNumber, F_INT4EQ,
     Int32GetDatum(objsubId));
  nkeys = 4;
 }

 scan = systable_beginscan(sdepRel, SharedDependDependerIndexId, true,
         NULL, nkeys, key);

 while (HeapTupleIsValid(tup = systable_getnext(scan)))
 {
  Form_pg_shdepend shdepForm = (Form_pg_shdepend) GETSTRUCT(tup);

  /* Filter entries according to additional parameters */
  if (OidIsValid(refclassId) && shdepForm->refclassid != refclassId)
   continue;
  if (OidIsValid(refobjId) && shdepForm->refobjid != refobjId)
   continue;
  if (deptype != SHARED_DEPENDENCY_INVALID &&
   shdepForm->deptype != deptype)
   continue;

  /* OK, delete it */
  CatalogTupleDelete(sdepRel, &tup->t_self);
 }

 systable_endscan(scan);
}

/*
 * classIdGetDbId
 *
 * Get the database Id that should be used in pg_shdepend, given the OID
 * of the catalog containing the object.  For shared objects, it's 0
 * (InvalidOid); for all other objects, it's the current database Id.
 */
static Oid
classIdGetDbId(Oid classId)
{
 Oid   dbId;

 if (IsSharedRelation(classId))
  dbId = InvalidOid;
 else
  dbId = MyDatabaseId;

 return dbId;
}

/*
 * shdepLockAndCheckObject
 *
 * Lock the object that we are about to record a dependency on.
 * After it's locked, verify that it hasn't been dropped while we
 * weren't looking.  If the object has been dropped, this function
 * does not return!
 */
void
shdepLockAndCheckObject(Oid classId, Oid objectId)
{
 /* 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);
 }
}


/*
 * storeObjectDescription
 *  Append the description of a dependent object to "descs"
 *
 * While searching for dependencies of a shared object, we stash the
 * descriptions of dependent objects we find in a single string, which we
 * later pass to ereport() in the DETAIL field when somebody attempts to
 * drop a referenced shared object.
 *
 * When type is LOCAL_OBJECT or SHARED_OBJECT, we expect object to be the
 * dependent object, deptype is the dependency type, and count is not used.
 * When type is REMOTE_OBJECT, we expect object to be the database object,
 * and count to be nonzero; deptype is not used in this case.
 */
static void
storeObjectDescription(StringInfo descs,
        SharedDependencyObjectType type,
        ObjectAddress *object,
        SharedDependencyType deptype,
        int count)
{
 char    *objdesc = getObjectDescription(object, false);

 /*
  * An object being dropped concurrently doesn't need to be reported.
 */
 if (objdesc == NULL)
  return;

 /* separate entries with a newline */
 if (descs->len != 0)
  appendStringInfoChar(descs, '\n');

 switch (type)
 {
  case LOCAL_OBJECT:
  case SHARED_OBJECT:
   if (deptype == SHARED_DEPENDENCY_OWNER)
    appendStringInfo(descs, _("owner of %s"), objdesc);
   else if (deptype == SHARED_DEPENDENCY_ACL)
    appendStringInfo(descs, _("privileges for %s"), objdesc);
   else if (deptype == SHARED_DEPENDENCY_INITACL)
    appendStringInfo(descs, _("initial privileges for %s"), objdesc);
   else if (deptype == SHARED_DEPENDENCY_POLICY)
    appendStringInfo(descs, _("target of %s"), objdesc);
   else if (deptype == SHARED_DEPENDENCY_TABLESPACE)
    appendStringInfo(descs, _("tablespace for %s"), objdesc);
   else
    elog(ERROR, "unrecognized dependency type: %d",
      (int) deptype);
   break;

  case REMOTE_OBJECT:
   /* translator: %s will always be "database %s" */
   appendStringInfo(descs, ngettext("%d object in %s",
            "%d objects in %s",
            count),
        count, objdesc);
   break;

  default:
   elog(ERROR, "unrecognized object type: %d", type);
 }

 pfree(objdesc);
}


/*
 * shdepDropOwned
 *
 * Drop the objects owned by any one of the given RoleIds.  If a role has
 * access to an object, the grant will be removed as well (but the object
 * will not, of course).
 *
 * We can revoke grants immediately while doing the scan, but drops are
 * saved up and done all at once with performMultipleDeletions.  This
 * is necessary so that we don't get failures from trying to delete
 * interdependent objects in the wrong order.
 */
void
shdepDropOwned(List *roleids, DropBehavior behavior)
{
 Relation sdepRel;
 ListCell   *cell;
 ObjectAddresses *deleteobjs;

 deleteobjs = new_object_addresses();

 /*
  * We don't need this strong a lock here, but we'll call routines that
  * acquire RowExclusiveLock.  Better get that right now to avoid potential
  * deadlock failures.
 */
 sdepRel = table_open(SharedDependRelationId, RowExclusiveLock);

 /*
  * For each role, find the dependent objects and drop them using the
  * regular (non-shared) dependency management.
 */
 foreach(cell, roleids)
 {
  Oid   roleid = lfirst_oid(cell);
  ScanKeyData key[2];
  SysScanDesc scan;
  HeapTuple tuple;

  /* Doesn't work for pinned objects */
  if (IsPinnedObject(AuthIdRelationId, roleid))
  {
   ObjectAddress obj;

   obj.classId = AuthIdRelationId;
   obj.objectId = roleid;
   obj.objectSubId = 0;

   ereport(ERROR,
     (errcode(ERRCODE_DEPENDENT_OBJECTS_STILL_EXIST),
      errmsg("cannot drop objects owned by %s because they are "
       "required by the database system",
       getObjectDescription(&obj, false))));
  }

  ScanKeyInit(&key[0],
     Anum_pg_shdepend_refclassid,
     BTEqualStrategyNumber, F_OIDEQ,
     ObjectIdGetDatum(AuthIdRelationId));
  ScanKeyInit(&key[1],
     Anum_pg_shdepend_refobjid,
     BTEqualStrategyNumber, F_OIDEQ,
     ObjectIdGetDatum(roleid));

  scan = systable_beginscan(sdepRel, SharedDependReferenceIndexId, true,
          NULL, 2, key);

  while ((tuple = systable_getnext(scan)) != NULL)
  {
   Form_pg_shdepend sdepForm = (Form_pg_shdepend) GETSTRUCT(tuple);
   ObjectAddress obj;

   /*
    * We only operate on shared objects and objects in the current
    * database
 */
   if (sdepForm->dbid != MyDatabaseId &&
    sdepForm->dbid != InvalidOid)
    continue;

   switch (sdepForm->deptype)
   {
     /* Shouldn't happen */
    case SHARED_DEPENDENCY_INVALID:
     elog(ERROR, "unexpected dependency type");
     break;
    case SHARED_DEPENDENCY_POLICY:

     /*
      * Try to remove role from policy; if unable to, remove
      * policy.
 */
     if (!RemoveRoleFromObjectPolicy(roleid,
             sdepForm->classid,
             sdepForm->objid))
     {
      obj.classId = sdepForm->classid;
      obj.objectId = sdepForm->objid;
      obj.objectSubId = sdepForm->objsubid;

      /*
       * Acquire lock on object, then verify this dependency
       * is still relevant.  If not, the object might have
       * been dropped or the policy modified.  Ignore the
       * object in that case.
 */
      AcquireDeletionLock(&obj, 0);
      if (!systable_recheck_tuple(scan, tuple))
      {
       ReleaseDeletionLock(&obj);
       break;
      }
      add_exact_object_address(&obj, deleteobjs);
     }
     break;
    case SHARED_DEPENDENCY_ACL:

     /*
      * Dependencies on role grants are recorded using
      * SHARED_DEPENDENCY_ACL, but unlike a regular ACL list
      * which stores all permissions for a particular object in
      * a single ACL array, there's a separate catalog row for
      * each grant - so removing the grant just means removing
      * the entire row.
 */
     if (sdepForm->classid != AuthMemRelationId)
     {
      RemoveRoleFromObjectACL(roleid,
            sdepForm->classid,
            sdepForm->objid);
      break;
     }
     /* FALLTHROUGH */

    case SHARED_DEPENDENCY_OWNER:

     /*
      * Save it for deletion below, if it's a local object or a
      * role grant. Other shared objects, such as databases,
      * should not be removed here.
 */
     if (sdepForm->dbid == MyDatabaseId ||
      sdepForm->classid == AuthMemRelationId)
     {
      obj.classId = sdepForm->classid;
      obj.objectId = sdepForm->objid;
      obj.objectSubId = sdepForm->objsubid;
      /* as above */
      AcquireDeletionLock(&obj, 0);
      if (!systable_recheck_tuple(scan, tuple))
      {
       ReleaseDeletionLock(&obj);
       break;
      }
      add_exact_object_address(&obj, deleteobjs);
     }
     break;
    case SHARED_DEPENDENCY_INITACL:

     /*
      * Any mentions of the role that remain in pg_init_privs
      * entries are just dropped.  This is the same policy as
      * we apply to regular ACLs.
 */

     /* Shouldn't see a role grant here */
     Assert(sdepForm->classid != AuthMemRelationId);
     RemoveRoleFromInitPriv(roleid,
             sdepForm->classid,
             sdepForm->objid,
             sdepForm->objsubid);
     break;
   }
  }

  systable_endscan(scan);
 }

 /*
  * For stability of deletion-report ordering, sort the objects into
  * approximate reverse creation order before deletion.  (This might also
  * make the deletion go a bit faster, since there's less chance of having
  * to rearrange the objects due to dependencies.)
 */
 sort_object_addresses(deleteobjs);

 /* the dependency mechanism does the actual work */
 performMultipleDeletions(deleteobjs, behavior, 0);

 table_close(sdepRel, RowExclusiveLock);

 free_object_addresses(deleteobjs);
}

/*
 * shdepReassignOwned
 *
 * Change the owner of objects owned by any of the roles in roleids to
 * newrole.  Grants are not touched.
 */
void
shdepReassignOwned(List *roleids, Oid newrole)
{
 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);
}

/*
 * shdepReassignOwned_Owner
 *
 * shdepReassignOwned's processing of SHARED_DEPENDENCY_OWNER entries
 */
static void
shdepReassignOwned_Owner(Form_pg_shdepend sdepForm, Oid newrole)
{
 /* Issue the appropriate ALTER OWNER call */
 switch (sdepForm->classid)
 {
  case TypeRelationId:
   AlterTypeOwner_oid(sdepForm->objid, newrole, true);
   break;

  case NamespaceRelationId:
   AlterSchemaOwner_oid(sdepForm->objid, newrole);
   break;

  case RelationRelationId:

   /*
    * Pass recursing = true so that we don't fail on indexes, owned
    * sequences, etc when we happen to visit them before their parent
    * table.
 */
   ATExecChangeOwner(sdepForm->objid, newrole, true, AccessExclusiveLock);
   break;

  case DefaultAclRelationId:

   /*
    * Ignore default ACLs; they should be handled by DROP OWNED, not
    * REASSIGN OWNED.
 */
   break;

  case UserMappingRelationId:
   /* ditto */
   break;

  case ForeignServerRelationId:
   AlterForeignServerOwner_oid(sdepForm->objid, newrole);
   break;

  case ForeignDataWrapperRelationId:
   AlterForeignDataWrapperOwner_oid(sdepForm->objid, newrole);
   break;

  case EventTriggerRelationId:
   AlterEventTriggerOwner_oid(sdepForm->objid, newrole);
   break;

  case PublicationRelationId:
   AlterPublicationOwner_oid(sdepForm->objid, newrole);
   break;

  case SubscriptionRelationId:
   AlterSubscriptionOwner_oid(sdepForm->objid, newrole);
   break;

   /* Generic alter owner cases */
  case CollationRelationId:
  case ConversionRelationId:
  case OperatorRelationId:
  case ProcedureRelationId:
  case LanguageRelationId:
  case LargeObjectRelationId:
  case OperatorFamilyRelationId:
  case OperatorClassRelationId:
  case ExtensionRelationId:
  case StatisticExtRelationId:
  case TableSpaceRelationId:
  case DatabaseRelationId:
  case TSConfigRelationId:
  case TSDictionaryRelationId:
   AlterObjectOwner_internal(sdepForm->classid,
           sdepForm->objid,
           newrole);
   break;

  default:
   elog(ERROR, "unexpected classid %u", sdepForm->classid);
   break;
 }
}

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