/*-------------------------------------------------------------------------

 *

 * dependency.c

 *    Routines to support inter-object dependencies.

 *

 *

 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group

 * Portions Copyright (c) 1994, Regents of the University of California

 *

 * IDENTIFICATION

 *    src/backend/catalog/dependency.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/heap.h"

#include "catalog/index.h"

#include "catalog/objectaccess.h"

#include "catalog/pg_am.h"

#include "catalog/pg_amop.h"

#include "catalog/pg_amproc.h"

#include "catalog/pg_attrdef.h"

#include "catalog/pg_authid.h"

#include "catalog/pg_auth_members.h"

#include "catalog/pg_cast.h"

#include "catalog/pg_collation.h"

#include "catalog/pg_constraint.h"

#include "catalog/pg_conversion.h"

#include "catalog/pg_database.h"

#include "catalog/pg_default_acl.h"

#include "catalog/pg_depend.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_init_privs.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_parameter_acl.h"

#include "catalog/pg_policy.h"

#include "catalog/pg_proc.h"

#include "catalog/pg_publication.h"

#include "catalog/pg_publication_namespace.h"

#include "catalog/pg_publication_rel.h"

#include "catalog/pg_rewrite.h"

#include "catalog/pg_statistic_ext.h"

#include "catalog/pg_subscription.h"

#include "catalog/pg_tablespace.h"

#include "catalog/pg_transform.h"

#include "catalog/pg_trigger.h"

#include "catalog/pg_ts_config.h"

#include "catalog/pg_ts_dict.h"

#include "catalog/pg_ts_parser.h"

#include "catalog/pg_ts_template.h"

#include "catalog/pg_type.h"

#include "catalog/pg_user_mapping.h"

#include "commands/comment.h"

#include "commands/defrem.h"

#include "commands/event_trigger.h"

#include "commands/extension.h"

#include "commands/policy.h"

#include "commands/publicationcmds.h"

#include "commands/seclabel.h"

#include "commands/sequence.h"

#include "commands/trigger.h"

#include "commands/typecmds.h"

#include "funcapi.h"

#include "miscadmin.h"

#include "nodes/nodeFuncs.h"

#include "parser/parsetree.h"

#include "rewrite/rewriteRemove.h"

#include "storage/lmgr.h"

#include "utils/fmgroids.h"

#include "utils/lsyscache.h"

#include "utils/syscache.h"

/*

 * Deletion processing requires additional state for each ObjectAddress that

 * it's planning to delete.  For simplicity and code-sharing we make the

 * ObjectAddresses code support arrays with or without this extra state.

 */

typedef struct

{

  int     flags;      /* bitmask, see bit definitions below */

  ObjectAddress dependee;   /* object whose deletion forced this one */

} ObjectAddressExtra;

/* ObjectAddressExtra flag bits */

#define DEPFLAG_ORIGINAL  0x0001  /* an original deletion target */

#define DEPFLAG_NORMAL    0x0002  /* reached via normal dependency */

#define DEPFLAG_AUTO    0x0004  /* reached via auto dependency */

#define DEPFLAG_INTERNAL  0x0008  /* reached via internal dependency */

#define DEPFLAG_PARTITION 0x0010  /* reached via partition dependency */

#define DEPFLAG_EXTENSION 0x0020  /* reached via extension dependency */

#define DEPFLAG_REVERSE   0x0040  /* reverse internal/extension link */

#define DEPFLAG_IS_PART   0x0080  /* has a partition dependency */

#define DEPFLAG_SUBOBJECT 0x0100  /* subobject of another deletable object */

/* expansible list of ObjectAddresses */

struct ObjectAddresses

{

  ObjectAddress *refs;    /* => palloc'd array */

  ObjectAddressExtra *extras; /* => palloc'd array, or NULL if not used */

  int     numrefs;    /* current number of references */

  int     maxrefs;    /* current size of palloc'd array(s) */

};

/* typedef ObjectAddresses appears in dependency.h */

/* threaded list of ObjectAddresses, for recursion detection */

typedef struct ObjectAddressStack

{

  const ObjectAddress *object;  /* object being visited */

  int     flags;      /* its current flag bits */

  struct ObjectAddressStack *next;  /* next outer stack level */

} ObjectAddressStack;

/* temporary storage in findDependentObjects */

typedef struct

{

  ObjectAddress obj;      /* object to be deleted --- MUST BE FIRST */

  int     subflags;   /* flags to pass down when recursing to obj */

} ObjectAddressAndFlags;

/* for find_expr_references_walker */

typedef struct

{

  ObjectAddresses *addrs;   /* addresses being accumulated */

  List     *rtables;    /* list of rangetables to resolve Vars */

} find_expr_references_context;

static void findDependentObjects(const ObjectAddress *object,

                 int objflags,

                 int flags,

                 ObjectAddressStack *stack,

                 ObjectAddresses *targetObjects,

                 const ObjectAddresses *pendingObjects,

                 Relation *depRel);

static void reportDependentObjects(const ObjectAddresses *targetObjects,

                   DropBehavior behavior,

                   int flags,

                   const ObjectAddress *origObject);

static void deleteOneObject(const ObjectAddress *object,

              Relation *depRel, int32 flags);

static void doDeletion(const ObjectAddress *object, int flags);

static bool find_expr_references_walker(Node *node,

                    find_expr_references_context *context);

static void process_function_rte_ref(RangeTblEntry *rte, AttrNumber attnum,

                   find_expr_references_context *context);

static void eliminate_duplicate_dependencies(ObjectAddresses *addrs);

static int  object_address_comparator(const void *a, const void *b);

static void add_object_address(Oid classId, Oid objectId, int32 subId,

                 ObjectAddresses *addrs);

static void add_exact_object_address_extra(const ObjectAddress *object,

                       const ObjectAddressExtra *extra,

                       ObjectAddresses *addrs);

static bool object_address_present_add_flags(const ObjectAddress *object,

                       int flags,

                       ObjectAddresses *addrs);

static bool stack_address_present_add_flags(const ObjectAddress *object,

                      int flags,

                      ObjectAddressStack *stack);

static void DeleteInitPrivs(const ObjectAddress *object);

/*

 * Go through the objects given running the final actions on them, and execute

 * the actual deletion.

 */

static void

deleteObjectsInList(ObjectAddresses *targetObjects, Relation *depRel,

          int flags)

{

  int     i;

  /*

   * Keep track of objects for event triggers, if necessary.

   */

  if (trackDroppedObjectsNeeded() && !(flags & PERFORM_DELETION_INTERNAL))

  {

    for (i = 0; i < targetObjects->numrefs; i++)

    {

      const ObjectAddress *thisobj = &targetObjects->refs[i];

      const ObjectAddressExtra *extra = &targetObjects->extras[i];

      bool    original = false;

      bool    normal = false;

      if (extra->flags & DEPFLAG_ORIGINAL)

        original = true;

      if (extra->flags & DEPFLAG_NORMAL)

        normal = true;

      if (extra->flags & DEPFLAG_REVERSE)

        normal = true;

      if (EventTriggerSupportsObject(thisobj))

      {

        EventTriggerSQLDropAddObject(thisobj, original, normal);

      }

    }

  }

  /*

   * Delete all the objects in the proper order, except that if told to, we

   * should skip the original object(s).

   */

  for (i = 0; i < targetObjects->numrefs; i++)

  {

    ObjectAddress *thisobj = targetObjects->refs + i;

    ObjectAddressExtra *thisextra = targetObjects->extras + i;

    if ((flags & PERFORM_DELETION_SKIP_ORIGINAL) &&

      (thisextra->flags & DEPFLAG_ORIGINAL))

      continue;

    deleteOneObject(thisobj, depRel, flags);

  }

}

/*

 * performDeletion: attempt to drop the specified object.  If CASCADE

 * behavior is specified, also drop any dependent objects (recursively).

 * If RESTRICT behavior is specified, error out if there are any dependent

 * objects, except for those that should be implicitly dropped anyway

 * according to the dependency type.

 *

 * This is the outer control routine for all forms of DROP that drop objects

 * that can participate in dependencies.  Note that performMultipleDeletions

 * is a variant on the same theme; if you change anything here you'll likely

 * need to fix that too.

 *

 * Bits in the flags argument can include:

 *

 * PERFORM_DELETION_INTERNAL: indicates that the drop operation is not the

 * direct result of a user-initiated action.  For example, when a temporary

 * schema is cleaned out so that a new backend can use it, or when a column

 * default is dropped as an intermediate step while adding a new one, that's

 * an internal operation.  On the other hand, when we drop something because

 * the user issued a DROP statement against it, that's not internal. Currently

 * this suppresses calling event triggers and making some permissions checks.

 *

 * PERFORM_DELETION_CONCURRENTLY: perform the drop concurrently.  This does

 * not currently work for anything except dropping indexes; don't set it for

 * other object types or you may get strange results.

 *

 * PERFORM_DELETION_QUIETLY: reduce message level from NOTICE to DEBUG2.

 *

 * PERFORM_DELETION_SKIP_ORIGINAL: do not delete the specified object(s),

 * but only what depends on it/them.

 *

 * PERFORM_DELETION_SKIP_EXTENSIONS: do not delete extensions, even when

 * deleting objects that are part of an extension.  This should generally

 * be used only when dropping temporary objects.

 *

 * PERFORM_DELETION_CONCURRENT_LOCK: perform the drop normally but with a lock

 * as if it were concurrent.  This is used by REINDEX CONCURRENTLY.

 *

 */

void

performDeletion(const ObjectAddress *object,

        DropBehavior behavior, int flags)

{

  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);

}

/*

 * performMultipleDeletions: Similar to performDeletion, but act on multiple

 * objects at once.

 *

 * The main difference from issuing multiple performDeletion calls is that the

 * list of objects that would be implicitly dropped, for each object to be

 * dropped, is the union of the implicit-object list for all objects.  This

 * makes each check be more relaxed.

 */

void

performMultipleDeletions(const ObjectAddresses *objects,

             DropBehavior behavior, int flags)

{

  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);

}

/*

 * findDependentObjects - find all objects that depend on 'object'

 *

 * For every object that depends on the starting object, acquire a deletion

 * lock on the object, add it to targetObjects (if not already there),

 * and recursively find objects that depend on it.  An object's dependencies

 * will be placed into targetObjects before the object itself; this means

 * that the finished list's order represents a safe deletion order.

 *

 * The caller must already have a deletion lock on 'object' itself,

 * but must not have added it to targetObjects.  (Note: there are corner

 * cases where we won't add the object either, and will also release the

 * caller-taken lock.  This is a bit ugly, but the API is set up this way

 * to allow easy rechecking of an object's liveness after we lock it.  See

 * notes within the function.)

 *

 * When dropping a whole object (subId = 0), we find dependencies for

 * its sub-objects too.

 *

 *  object: the object to add to targetObjects and find dependencies on

 *  objflags: flags to be ORed into the object's targetObjects entry

 *  flags: PERFORM_DELETION_xxx flags for the deletion operation as a whole

 *  stack: list of objects being visited in current recursion; topmost item

 *      is the object that we recursed from (NULL for external callers)

 *  targetObjects: list of objects that are scheduled to be deleted

 *  pendingObjects: list of other objects slated for destruction, but

 *      not necessarily in targetObjects yet (can be NULL if none)

 *  *depRel: already opened pg_depend relation

 *

 * Note: objflags describes the reason for visiting this particular object

 * at this time, and is not passed down when recursing.  The flags argument

 * is passed down, since it describes what we're doing overall.

 */

static void

findDependentObjects(const ObjectAddress *object,

           int objflags,

           int flags,

           ObjectAddressStack *stack,

           ObjectAddresses *targetObjects,

           const ObjectAddresses *pendingObjects,

           Relation *depRel)

{

  ScanKeyData key[3];

  int     nkeys;

  SysScanDesc scan;

  HeapTuple tup;

  ObjectAddress otherObject;

  ObjectAddress owningObject;

  ObjectAddress partitionObject;

  ObjectAddressAndFlags *dependentObjects;

  int     numDependentObjects;

  int     maxDependentObjects;

  ObjectAddressStack mystack;

  ObjectAddressExtra extra;

  /*

   * If the target object is already being visited in an outer recursion

   * level, just report the current objflags back to that level and exit.

   * This is needed to avoid infinite recursion in the face of circular

   * dependencies.

   *

   * The stack check alone would result in dependency loops being broken at

   * an arbitrary point, ie, the first member object of the loop to be

   * visited is the last one to be deleted.  This is obviously unworkable.

   * However, the check for internal dependency below guarantees that we

   * will not break a loop at an internal dependency: if we enter the loop

   * at an "owned" object we will switch and start at the "owning" object

   * instead.  We could probably hack something up to avoid breaking at an

   * auto dependency, too, if we had to.  However there are no known cases

   * where that would be necessary.

   */

  if (stack_address_present_add_flags(object, objflags, stack))

    return;

  /*

   * since this function recurses, it could be driven to stack overflow,

   * because of the deep dependency tree, not only due to dependency loops.

   */

  check_stack_depth();

  /*

   * It's also possible that the target object has already been completely

   * processed and put into targetObjects.  If so, again we just add the

   * specified objflags to its entry and return.

   *

   * (Note: in these early-exit cases we could release the caller-taken

   * lock, since the object is presumably now locked multiple times; but it

   * seems not worth the cycles.)

   */

  if (object_address_present_add_flags(object, objflags, targetObjects))

    return;

  /*

   * If the target object is pinned, we can just error out immediately; it

   * won't have any objects recorded as depending on it.

   */

  if (IsPinnedObject(object->classId, object->objectId))

    ereport(ERROR,

        (errcode(ERRCODE_DEPENDENT_OBJECTS_STILL_EXIST),

         errmsg("cannot drop %s because it is required by the database system",

            getObjectDescription(object, false))));

  /*

   * The target object might be internally dependent on some other object

   * (its "owner"), and/or be a member of an extension (also considered its

   * owner).  If so, and if we aren't recursing from the owning object, we

   * have to transform this deletion request into a deletion request of the

   * owning object.  (We'll eventually recurse back to this object, but the

   * owning object has to be visited first so it will be deleted after.) The

   * way to find out about this is to scan the pg_depend entries that show

   * what this object depends on.

   */

  ScanKeyInit(&key[0],

        Anum_pg_depend_classid,

        BTEqualStrategyNumber, F_OIDEQ,

        ObjectIdGetDatum(object->classId));

  ScanKeyInit(&key[1],

        Anum_pg_depend_objid,

        BTEqualStrategyNumber, F_OIDEQ,

        ObjectIdGetDatum(object->objectId));

  if (object->objectSubId != 0)

  {

    /* Consider only dependencies of this sub-object */

    ScanKeyInit(&key[2],

          Anum_pg_depend_objsubid,

          BTEqualStrategyNumber, F_INT4EQ,

          Int32GetDatum(object->objectSubId));

    nkeys = 3;

  }

  else

  {

    /* Consider dependencies of this object and any sub-objects it has */

    nkeys = 2;

  }

  scan = systable_beginscan(*depRel, DependDependerIndexId, true,

                NULL, nkeys, key);

  /* initialize variables that loop may fill */

  memset(&owningObject, 0, sizeof(owningObject));

  memset(&partitionObject, 0, sizeof(partitionObject));

  while (HeapTupleIsValid(tup = systable_getnext(scan)))

  {

    Form_pg_depend foundDep = (Form_pg_depend) GETSTRUCT(tup);

    otherObject.classId = foundDep->refclassid;

    otherObject.objectId = foundDep->refobjid;

    otherObject.objectSubId = foundDep->refobjsubid;

    /*

     * When scanning dependencies of a whole object, we may find rows

     * linking sub-objects of the object to the object itself.  (Normally,

     * such a dependency is implicit, but we must make explicit ones in

     * some cases involving partitioning.)  We must ignore such rows to

     * avoid infinite recursion.

     */

    if (otherObject.classId == object->classId &&

      otherObject.objectId == object->objectId &&

      object->objectSubId == 0)

      continue;

    switch (foundDep->deptype)

    {

      case DEPENDENCY_NORMAL:

      case DEPENDENCY_AUTO:

      case DEPENDENCY_AUTO_EXTENSION:

        /* no problem */

        break;

      case DEPENDENCY_EXTENSION:

        /*

         * If told to, ignore EXTENSION dependencies altogether.  This

         * flag is normally used to prevent dropping extensions during

         * temporary-object cleanup, even if a temp object was created

         * during an extension script.

         */

        if (flags & PERFORM_DELETION_SKIP_EXTENSIONS)

          break;

        /*

         * If the other object is the extension currently being

         * created/altered, ignore this dependency and continue with

         * the deletion.  This allows dropping of an extension's

         * objects within the extension's scripts, as well as corner

         * cases such as dropping a transient object created within

         * such a script.

         */

        if (creating_extension &&

          otherObject.classId == ExtensionRelationId &&

          otherObject.objectId == CurrentExtensionObject)

          break;

        /* Otherwise, treat this like an internal dependency */

        /* FALL THRU */

      case DEPENDENCY_INTERNAL:

        /*

         * This object is part of the internal implementation of

         * another object, or is part of the extension that is the

         * other object.  We have three cases:

         *

         * 1. At the outermost recursion level, we must disallow the

         * DROP.  However, if the owning object is listed in

         * pendingObjects, just release the caller's lock and return;

         * we'll eventually complete the DROP when we reach that entry

         * in the pending list.

         *

         * Note: the above statement is true only if this pg_depend

         * entry still exists by then; in principle, therefore, we

         * could miss deleting an item the user told us to delete.

         * However, no inconsistency can result: since we're at outer

         * level, there is no object depending on this one.

         */

        if (stack == NULL)

        {

          if (pendingObjects &&

            object_address_present(&otherObject, pendingObjects))

          {

            systable_endscan(scan);

            /* need to release caller's lock; see notes below */

            ReleaseDeletionLock(object);

            return;

          }

          /*

           * We postpone actually issuing the error message until

           * after this loop, so that we can make the behavior

           * independent of the ordering of pg_depend entries, at

           * least if there's not more than one INTERNAL and one

           * EXTENSION dependency.  (If there's more, we'll complain

           * about a random one of them.)  Prefer to complain about

           * EXTENSION, since that's generally a more important

           * dependency.

           */

          if (!OidIsValid(owningObject.classId) ||

            foundDep->deptype == DEPENDENCY_EXTENSION)

            owningObject = otherObject;

          break;

        }

        /*

         * 2. When recursing from the other end of this dependency,

         * it's okay to continue with the deletion.  This holds when

         * recursing from a whole object that includes the nominal

         * other end as a component, too.  Since there can be more

         * than one "owning" object, we have to allow matches that are

         * more than one level down in the stack.

         */

        if (stack_address_present_add_flags(&otherObject, 0, stack))

          break;

        /*

         * 3. Not all the owning objects have been visited, so

         * transform this deletion request into a delete of this

         * owning object.

         *

         * First, release caller's lock on this object and get

         * deletion lock on the owning object.  (We must release

         * caller's lock to avoid deadlock against a concurrent

         * deletion of the owning object.)

         */

        ReleaseDeletionLock(object);

        AcquireDeletionLock(&otherObject, 0);

        /*

         * The owning object might have been deleted while we waited

         * to lock it; if so, neither it nor the current object are

         * interesting anymore.  We test this by checking the

         * pg_depend entry (see notes below).

         */

        if (!systable_recheck_tuple(scan, tup))

        {

          systable_endscan(scan);

          ReleaseDeletionLock(&otherObject);

          return;

        }

        /*

         * One way or the other, we're done with the scan; might as

         * well close it down before recursing, to reduce peak

         * resource consumption.

         */

        systable_endscan(scan);

        /*

         * Okay, recurse to the owning object instead of proceeding.

         *

         * We do not need to stack the current object; we want the

         * traversal order to be as if the original reference had

         * linked to the owning object instead of this one.

         *

         * The dependency type is a "reverse" dependency: we need to

         * delete the owning object if this one is to be deleted, but

         * this linkage is never a reason for an automatic deletion.

         */

        findDependentObjects(&otherObject,

                   DEPFLAG_REVERSE,

                   flags,

                   stack,

                   targetObjects,

                   pendingObjects,

                   depRel);

        /*

         * The current target object should have been added to

         * targetObjects while processing the owning object; but it

         * probably got only the flag bits associated with the

         * dependency we're looking at.  We need to add the objflags

         * that were passed to this recursion level, too, else we may

         * get a bogus failure in reportDependentObjects (if, for

         * example, we were called due to a partition dependency).

         *

         * If somehow the current object didn't get scheduled for

         * deletion, bleat.  (That would imply that somebody deleted

         * this dependency record before the recursion got to it.)

         * Another idea would be to reacquire lock on the current

         * object and resume trying to delete it, but it seems not

         * worth dealing with the race conditions inherent in that.

         */

        if (!object_address_present_add_flags(object, objflags,

                            targetObjects))

          elog(ERROR, "deletion of owning object %s failed to delete %s",

             getObjectDescription(&otherObject, false),

             getObjectDescription(object, false));

        /* And we're done here. */

        return;

      case DEPENDENCY_PARTITION_PRI:

        /*

         * Remember that this object has a partition-type dependency.

         * After the dependency scan, we'll complain if we didn't find

         * a reason to delete one of its partition dependencies.

         */

        objflags |= DEPFLAG_IS_PART;

        /*

         * Also remember the primary partition owner, for error

         * messages.  If there are multiple primary owners (which

         * there should not be), we'll report a random one of them.

         */

        partitionObject = otherObject;

        break;

      case DEPENDENCY_PARTITION_SEC:

        /*

         * Only use secondary partition owners in error messages if we

         * find no primary owner (which probably shouldn't happen).

         */

        if (!(objflags & DEPFLAG_IS_PART))

          partitionObject = otherObject;

        /*

         * Remember that this object has a partition-type dependency.

         * After the dependency scan, we'll complain if we didn't find

         * a reason to delete one of its partition dependencies.

         */

        objflags |= DEPFLAG_IS_PART;

        break;

      default:

        elog(ERROR, "unrecognized dependency type '%c' for %s",

           foundDep->deptype, getObjectDescription(object, false));

        break;

    }

  }

  systable_endscan(scan);

  /*

   * If we found an INTERNAL or EXTENSION dependency when we're at outer

   * level, complain about it now.  If we also found a PARTITION dependency,

   * we prefer to report the PARTITION dependency.  This is arbitrary but

   * seems to be more useful in practice.

   */

  if (OidIsValid(owningObject.classId))

  {

    char     *otherObjDesc;

    if (OidIsValid(partitionObject.classId))

      otherObjDesc = getObjectDescription(&partitionObject, false);

    else

      otherObjDesc = getObjectDescription(&owningObject, false);

    ereport(ERROR,

        (errcode(ERRCODE_DEPENDENT_OBJECTS_STILL_EXIST),

         errmsg("cannot drop %s because %s requires it",

            getObjectDescription(object, false), otherObjDesc),

         errhint("You can drop %s instead.", otherObjDesc)));

  }

  /*

   * Next, identify all objects that directly depend on the current object.

   * To ensure predictable deletion order, we collect them up in

   * dependentObjects and sort the list before actually recursing.  (The

   * deletion order would be valid in any case, but doing this ensures

   * consistent output from DROP CASCADE commands, which is helpful for

   * regression testing.)

   */

  maxDependentObjects = 128;  /* arbitrary initial allocation */

  dependentObjects = (ObjectAddressAndFlags *)

    palloc(maxDependentObjects * sizeof(ObjectAddressAndFlags));

  numDependentObjects = 0;

  ScanKeyInit(&key[0],

        Anum_pg_depend_refclassid,

        BTEqualStrategyNumber, F_OIDEQ,

        ObjectIdGetDatum(object->classId));

  ScanKeyInit(&key[1],

        Anum_pg_depend_refobjid,

        BTEqualStrategyNumber, F_OIDEQ,

        ObjectIdGetDatum(object->objectId));

  if (object->objectSubId != 0)

  {

    ScanKeyInit(&key[2],

          Anum_pg_depend_refobjsubid,

          BTEqualStrategyNumber, F_INT4EQ,

          Int32GetDatum(object->objectSubId));

    nkeys = 3;

  }

  else

    nkeys = 2;

  scan = systable_beginscan(*depRel, DependReferenceIndexId, true,

                NULL, nkeys, key);

  while (HeapTupleIsValid(tup = systable_getnext(scan)))

  {

    Form_pg_depend foundDep = (Form_pg_depend) GETSTRUCT(tup);

    int     subflags;

    otherObject.classId = foundDep->classid;

    otherObject.objectId = foundDep->objid;

    otherObject.objectSubId = foundDep->objsubid;

    /*

     * If what we found is a sub-object of the current object, just ignore

     * it.  (Normally, such a dependency is implicit, but we must make

     * explicit ones in some cases involving partitioning.)

     */

    if (otherObject.classId == object->classId &&

      otherObject.objectId == object->objectId &&

      object->objectSubId == 0)

      continue;

    /*

     * Must lock the dependent object before recursing to it.

     */

    AcquireDeletionLock(&otherObject, 0);

    /*

     * The dependent object might have been deleted while we waited to

     * lock it; if so, we don't need to do anything more with it. We can

     * test this cheaply and independently of the object's type by seeing

     * if the pg_depend tuple we are looking at is still live. (If the

     * object got deleted, the tuple would have been deleted too.)

     */

    if (!systable_recheck_tuple(scan, tup))

    {

      /* release the now-useless lock */

      ReleaseDeletionLock(&otherObject);

      /* and continue scanning for dependencies */

      continue;

    }

    /*

     * We do need to delete it, so identify objflags to be passed down,

     * which depend on the dependency type.

     */

    switch (foundDep->deptype)

    {

      case DEPENDENCY_NORMAL:

        subflags = DEPFLAG_NORMAL;

        break;

      case DEPENDENCY_AUTO:

      case DEPENDENCY_AUTO_EXTENSION:

        subflags = DEPFLAG_AUTO;

        break;

      case DEPENDENCY_INTERNAL:

        subflags = DEPFLAG_INTERNAL;

        break;

      case DEPENDENCY_PARTITION_PRI:

      case DEPENDENCY_PARTITION_SEC:

        subflags = DEPFLAG_PARTITION;

        break;

      case DEPENDENCY_EXTENSION:

        subflags = DEPFLAG_EXTENSION;

        break;

      default:

        elog(ERROR, "unrecognized dependency type '%c' for %s",

           foundDep->deptype, getObjectDescription(object, false));

        subflags = 0; /* keep compiler quiet */

        break;

    }

    /* And add it to the pending-objects list */

    if (numDependentObjects >= maxDependentObjects)

    {

      /* enlarge array if needed */

      maxDependentObjects *= 2;

      dependentObjects = (ObjectAddressAndFlags *)

        repalloc(dependentObjects,

             maxDependentObjects * sizeof(ObjectAddressAndFlags));

    }

    dependentObjects[numDependentObjects].obj = otherObject;

    dependentObjects[numDependentObjects].subflags = subflags;

    numDependentObjects++;

  }

  systable_endscan(scan);

  /*

   * Now we can sort the dependent objects into a stable visitation order.

   * It's safe to use object_address_comparator here since the obj field is

   * first within ObjectAddressAndFlags.

   */

  if (numDependentObjects > 1)

    qsort(dependentObjects, numDependentObjects,

        sizeof(ObjectAddressAndFlags),

        object_address_comparator);

  /*

   * Now recurse to the dependent objects.  We must visit them first since

   * they have to be deleted before the current object.

   */

  mystack.object = object;  /* set up a new stack level */

  mystack.flags = objflags;

  mystack.next = stack;

  for (int i = 0; i < numDependentObjects; i++)

  {

    ObjectAddressAndFlags *depObj = dependentObjects + i;

    findDependentObjects(&depObj->obj,

               depObj->subflags,

               flags,

               &mystack,

               targetObjects,

               pendingObjects,

               depRel);

  }

  pfree(dependentObjects);

  /*

   * Finally, we can add the target object to targetObjects.  Be careful to

   * include any flags that were passed back down to us from inner recursion

   * levels.  Record the "dependee" as being either the most important

   * partition owner if there is one, else the object we recursed from, if

   * any.  (The logic in reportDependentObjects() is such that it can only

   * need one of those objects.)

   */

  extra.flags = mystack.flags;

  if (extra.flags & DEPFLAG_IS_PART)

    extra.dependee = partitionObject;

  else if (stack)

    extra.dependee = *stack->object;

  else

    memset(&extra.dependee, 0, sizeof(extra.dependee));

  add_exact_object_address_extra(object, &extra, targetObjects);

}

/*

 * reportDependentObjects - report about dependencies, and fail if RESTRICT

 *

 * Tell the user about dependent objects that we are going to delete

 * (or would need to delete, but are prevented by RESTRICT mode);

 * then error out if there are any and it's not CASCADE mode.

 *

 *  targetObjects: list of objects that are scheduled to be deleted

 *  behavior: RESTRICT or CASCADE

 *  flags: other flags for the deletion operation

 *  origObject: base object of deletion, or NULL if not available

 *    (the latter case occurs in DROP OWNED)

 */

static void

reportDependentObjects(const ObjectAddresses *targetObjects,

             DropBehavior behavior,

             int flags,

             const ObjectAddress *origObject)

{

  int     msglevel = (flags & PERFORM_DELETION_QUIETLY) ? DEBUG2 : NOTICE;

  bool    ok = true;

  StringInfoData clientdetail;

  StringInfoData logdetail;

  int     numReportedClient = 0;

  int     numNotReportedClient = 0;

  int     i;

  /*

   * If we need to delete any partition-dependent objects, make sure that